9){
+ Limit = 9
+ }
+ else if (Limit < 5){
+ Limit = 5
+ }
+ switch (Limit) {
+ case 5:
+ Loads = [1,3,4,5,6];
+ break;
+ case 6:
+ Loads = [1,3,5,6,7];
+ break;
+ case 7:
+ Loads = [1,3,6,7,8];
+ break;
+ case 8:
+ Loads = [1,3,6,8,9];
+ break;
+ case 9:
+ Loads = [1,3,6,8,9];
+ }
+ this.Loads = Loads
+ }
+
+ CreateDMSItemList()
+ {
+ // Make a function that runs at the beginning of the DMS block based version. It takes as inpout just the CognCap.
+ // It then identifies the loads required. Then it extracts the corresponding rows from the list. It therefore
+ // shortens the selected list accordingly.
+
+ // This variable describes how many trials there are in the setup file
+ var NTrialsPerLoadInList = 6
+ var TrialList = []
+ for (var i = 0; i < this.Loads.length; i++)
+ {
+ // What is the current load
+ var temp = this.Loads[i]
+ for (var j = 0; j < 54; j++)
+ {
+ if (temp == this.InputStimulusList[j]['Load'])
+ {
+ console.log(this.InputStimulusList[j]['Load'])
+ TrialList.push(this.InputStimulusList[j])
+ }
+ }
+ }
+ this.TrialList = TrialList
+ }
+}
\ No newline at end of file
diff --git a/LetterDMS/DMS_setup_eng.js b/LetterDMS/DMS_setup_eng.js
new file mode 100644
index 0000000..3a538f8
--- /dev/null
+++ b/LetterDMS/DMS_setup_eng.js
@@ -0,0 +1,297 @@
+// General parameters used by all versions of the DFMS task
+// The following letter list does not include vowels nor w. W is removed because it is the only two syllable
+// letter in the English language. During subvocal rehearsal W therefore takes two syllables to rehearse.
+// The letter ELL is in included as a stimulus letter but NOT a probe letter. This is done so that proactive
+// interference can be minimized between consecutive trials with a load of 9 letters. Without ELL as a stimulus
+// there are simply not enough available letters. ELL is not allowed to be a probe leter because it is difficult
+// to differentiate it from ONE and EYE.
+
+var AllowableLetters = "BCDFGHJKLMNPQRSTVXYZ";
+
+var FullScreenMode = true;
+
+var FontSize = 72;
+
+var KeyboardChoices = ['arrowleft', 'arrowright'];
+// the following is used for scoring and allows the keyboard choices to be whatever you would like
+// This response mapping correspopnds to the order of the above KeyboardChoices
+var ResponseMapping = [true, false];
+
+// Timings of the different trial phases in MILLISECONDS
+var StimOnTime = 2500
+var RetOnTime = 3500
+var ProbeOnTime = 5000
+// This is the intertrial interval.
+var ITITime = 1000
+
+// This is the time between blocks. Note that between each block of trials there
+// is also the 3-2-1 countdown. Therefore, the full interblock interval is this value PLUS
+// the countdown time, which is 3 seconds.
+var InterBlockTime = 3000
+// TO DO ++++++
+// This is a delay component for use after instructions and before the first Block
+var WaitOnTime = 5000
+
+var ProbeColor = 'blue'
+
+// ===================================================
+// BLOCK BASED PARAMETERS
+// How many trials per block
+var NTrialsPerBlock = 6
+// The number of blocks to run
+var NumberOfBlocks = 5
+// ===================================================
+// ADAPTIVE VERSION PARAMETERS
+var MaxTrials = 50
+var MaxReversals = 15
+var StartValue = 1
+var MinValue = 1
+var MaxValue = 9
+var StepSize = 1
+var NUp = 3
+var NDown = 1
+var FastStart = true
+// ===================================================
+
+
+MaxTrials = 5
+StimOnTime = 250
+RetOnTime = 250
+
+var instructions = ['This is the Verbal Delayed Match to Sample Task',
+ 'Press [LEFT] if the letter WAS in the set.
You will NOT receive feedback after each trial.
',
+ 'Remember that the letters to study will be in white and CAPITALIZED. The test letter will be in blue and will be lowercase.',
+ 'Try to respond as quickly and as accurately as possible. Press next to begin.']
+
+
+// The following are stimulus lists that are carefully selected to be counterbalanced for
+// probe type and to have six trials per block and minimal proactive interference from
+// previous trials
+
+var DMSLetterBehaviorList001 = [
+ {"StimulusLetters": "****G****", "ProbeLetter": "g", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****H****", "ProbeLetter": "h", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****X****", "ProbeLetter": "d", "Correct": false, "Load": 1},
+ {"StimulusLetters": "****R****", "ProbeLetter": "r", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****M****", "ProbeLetter": "h", "Correct": false, "Load": 1},
+ {"StimulusLetters": "****Y****", "ProbeLetter": "z", "Correct": false, "Load": 1},
+ {"StimulusLetters": "***M*K***", "ProbeLetter": "v", "Correct": false, "Load": 2},
+ {"StimulusLetters": "***H*R***", "ProbeLetter": "p", "Correct": false, "Load": 2},
+ {"StimulusLetters": "***D*T***", "ProbeLetter": "d", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***L*K***", "ProbeLetter": "k", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***M*X***", "ProbeLetter": "x", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***P*T***", "ProbeLetter": "g", "Correct": false, "Load": 2},
+ {"StimulusLetters": "***VPM***", "ProbeLetter": "p", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***SRY***", "ProbeLetter": "j", "Correct": false, "Load": 3},
+ {"StimulusLetters": "***VDB***", "ProbeLetter": "h", "Correct": false, "Load": 3},
+ {"StimulusLetters": "***YRL***", "ProbeLetter": "y", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***PJN***", "ProbeLetter": "c", "Correct": false, "Load": 3},
+ {"StimulusLetters": "***XST***", "ProbeLetter": "s", "Correct": true, "Load": 3},
+ {"StimulusLetters": "G*C***Q*B", "ProbeLetter": "q", "Correct": true, "Load": 4},
+ {"StimulusLetters": "K*P***H*J", "ProbeLetter": "r", "Correct": false, "Load": 4},
+ {"StimulusLetters": "M*B***X*N", "ProbeLetter": "s", "Correct": false, "Load": 4},
+ {"StimulusLetters": "P*V***H*F", "ProbeLetter": "v", "Correct": true, "Load": 4},
+ {"StimulusLetters": "X*L***B*S", "ProbeLetter": "s", "Correct": true, "Load": 4},
+ {"StimulusLetters": "C*T***Q*M", "ProbeLetter": "k", "Correct": false, "Load": 4},
+ {"StimulusLetters": "Z*N*R*K*Y", "ProbeLetter": "y", "Correct": true, "Load": 5},
+ {"StimulusLetters": "Q*G*V*B*M", "ProbeLetter": "g", "Correct": true, "Load": 5},
+ {"StimulusLetters": "J*H*N*C*T", "ProbeLetter": "s", "Correct": false, "Load": 5},
+ {"StimulusLetters": "K*B*P*G*M", "ProbeLetter": "r", "Correct": false, "Load": 5},
+ {"StimulusLetters": "X*Z*N*L*J", "ProbeLetter": "n", "Correct": true, "Load": 5},
+ {"StimulusLetters": "P*M*G*F*K", "ProbeLetter": "h", "Correct": false, "Load": 5},
+ {"StimulusLetters": "BZM***NSJ", "ProbeLetter": "c", "Correct": false, "Load": 6},
+ {"StimulusLetters": "DFH***RPQ", "ProbeLetter": "h", "Correct": true, "Load": 6},
+ {"StimulusLetters": "KLV***MBT", "ProbeLetter": "g", "Correct": false, "Load": 6},
+ {"StimulusLetters": "DXJ***FPZ", "ProbeLetter": "x", "Correct": true, "Load": 6},
+ {"StimulusLetters": "RGT***CBQ", "ProbeLetter": "c", "Correct": true, "Load": 6},
+ {"StimulusLetters": "KYD***XVH", "ProbeLetter": "n", "Correct": false, "Load": 6},
+ {"StimulusLetters": "LBG*C*QKF", "ProbeLetter": "k", "Correct": true, "Load": 7},
+ {"StimulusLetters": "ZYD*J*TXS", "ProbeLetter": "d", "Correct": true, "Load": 7},
+ {"StimulusLetters": "LFP*R*GVN", "ProbeLetter": "g", "Correct": true, "Load": 7},
+ {"StimulusLetters": "TKS*C*XYB", "ProbeLetter": "z", "Correct": false, "Load": 7},
+ {"StimulusLetters": "PGQ*J*VFH", "ProbeLetter": "d", "Correct": false, "Load": 7},
+ {"StimulusLetters": "BYL*R*ZSM", "ProbeLetter": "c", "Correct": false, "Load": 7},
+ {"StimulusLetters": "ZYXR*JDSN", "ProbeLetter": "c", "Correct": false, "Load": 8},
+ {"StimulusLetters": "LGFV*PCQK", "ProbeLetter": "q", "Correct": true, "Load": 8},
+ {"StimulusLetters": "SJXT*RBHV", "ProbeLetter": "s", "Correct": true, "Load": 8},
+ {"StimulusLetters": "FKTQ*YZNM", "ProbeLetter": "n", "Correct": true, "Load": 8},
+ {"StimulusLetters": "BPJG*KHXD", "ProbeLetter": "v", "Correct": false, "Load": 8},
+ {"StimulusLetters": "ZYCF*SLKM", "ProbeLetter": "n", "Correct": false, "Load": 8},
+ {"StimulusLetters": "PMSYLCXKH", "ProbeLetter": "b", "Correct": false, "Load": 9},
+ {"StimulusLetters": "JCNQVKZGT", "ProbeLetter": "c", "Correct": true, "Load": 9},
+ {"StimulusLetters": "HRMYBVPQL", "ProbeLetter": "m", "Correct": true, "Load": 9},
+ {"StimulusLetters": "DYNBXKFZT", "ProbeLetter": "t", "Correct": true, "Load": 9},
+ {"StimulusLetters": "JRGHMNSYV", "ProbeLetter": "p", "Correct": false, "Load": 9},
+ {"StimulusLetters": "GCJXLTKBD", "ProbeLetter": "q", "Correct": false, "Load": 9}
+]
+var DMSLetterBehaviorList002 = [
+ {"StimulusLetters": "****R****", "ProbeLetter": "d", "Correct": false, "Load": 1},
+ {"StimulusLetters": "****K****", "ProbeLetter": "n", "Correct": false, "Load": 1},
+ {"StimulusLetters": "****J****", "ProbeLetter": "f", "Correct": false, "Load": 1},
+ {"StimulusLetters": "****B****", "ProbeLetter": "b", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****X****", "ProbeLetter": "x", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****C****", "ProbeLetter": "c", "Correct": true, "Load": 1},
+ {"StimulusLetters": "***V*F***", "ProbeLetter": "d", "Correct": false, "Load": 2},
+ {"StimulusLetters": "***G*B***", "ProbeLetter": "k", "Correct": false, "Load": 2},
+ {"StimulusLetters": "***D*P***", "ProbeLetter": "p", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***V*T***", "ProbeLetter": "z", "Correct": false, "Load": 2},
+ {"StimulusLetters": "***S*F***", "ProbeLetter": "f", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***T*P***", "ProbeLetter": "t", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***BGF***", "ProbeLetter": "g", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***KDR***", "ProbeLetter": "x", "Correct": false, "Load": 3},
+ {"StimulusLetters": "***GLY***", "ProbeLetter": "s", "Correct": false, "Load": 3},
+ {"StimulusLetters": "***HKF***", "ProbeLetter": "h", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***NVJ***", "ProbeLetter": "v", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***QFK***", "ProbeLetter": "p", "Correct": false, "Load": 3},
+ {"StimulusLetters": "P*Q***H*T", "ProbeLetter": "q", "Correct": true, "Load": 4},
+ {"StimulusLetters": "L*S***V*N", "ProbeLetter": "n", "Correct": true, "Load": 4},
+ {"StimulusLetters": "Q*J***R*B", "ProbeLetter": "r", "Correct": true, "Load": 4},
+ {"StimulusLetters": "F*M***V*H", "ProbeLetter": "g", "Correct": false, "Load": 4},
+ {"StimulusLetters": "L*T***P*C", "ProbeLetter": "y", "Correct": false, "Load": 4},
+ {"StimulusLetters": "N*B***Q*Z", "ProbeLetter": "k", "Correct": false, "Load": 4},
+ {"StimulusLetters": "B*T*K*P*N", "ProbeLetter": "x", "Correct": false, "Load": 5},
+ {"StimulusLetters": "D*R*C*V*Z", "ProbeLetter": "s", "Correct": false, "Load": 5},
+ {"StimulusLetters": "H*G*T*P*F", "ProbeLetter": "p", "Correct": true, "Load": 5},
+ {"StimulusLetters": "S*J*B*Y*X", "ProbeLetter": "j", "Correct": true, "Load": 5},
+ {"StimulusLetters": "T*N*Q*K*H", "ProbeLetter": "n", "Correct": true, "Load": 5},
+ {"StimulusLetters": "R*M*Y*F*L", "ProbeLetter": "v", "Correct": false, "Load": 5},
+ {"StimulusLetters": "DTF***KRC", "ProbeLetter": "j", "Correct": false, "Load": 6},
+ {"StimulusLetters": "BGQ***YPS", "ProbeLetter": "q", "Correct": true, "Load": 6},
+ {"StimulusLetters": "HRT***ZKL", "ProbeLetter": "z", "Correct": true, "Load": 6},
+ {"StimulusLetters": "BCF***JGV", "ProbeLetter": "j", "Correct": true, "Load": 6},
+ {"StimulusLetters": "ZDP***SQX", "ProbeLetter": "k", "Correct": false, "Load": 6},
+ {"StimulusLetters": "BJC***GYF", "ProbeLetter": "m", "Correct": false, "Load": 6},
+ {"StimulusLetters": "SJQ*D*GVP", "ProbeLetter": "d", "Correct": true, "Load": 7},
+ {"StimulusLetters": "MHX*L*TKY", "ProbeLetter": "h", "Correct": true, "Load": 7},
+ {"StimulusLetters": "GDJ*R*BNP", "ProbeLetter": "p", "Correct": true, "Load": 7},
+ {"StimulusLetters": "FQS*K*YLM", "ProbeLetter": "x", "Correct": false, "Load": 7},
+ {"StimulusLetters": "JCV*D*NPB", "ProbeLetter": "r", "Correct": false, "Load": 7},
+ {"StimulusLetters": "FQS*K*YLM", "ProbeLetter": "x", "Correct": false, "Load": 7},
+ {"StimulusLetters": "MFGX*HBLS", "ProbeLetter": "s", "Correct": true, "Load": 8},
+ {"StimulusLetters": "LVPT*KZRC", "ProbeLetter": "k", "Correct": true, "Load": 8},
+ {"StimulusLetters": "SBFX*GDQY", "ProbeLetter": "f", "Correct": true, "Load": 8},
+ {"StimulusLetters": "HYZL*MKVC", "ProbeLetter": "r", "Correct": false, "Load": 8},
+ {"StimulusLetters": "PRXD*GNQB", "ProbeLetter": "t", "Correct": false, "Load": 8},
+ {"StimulusLetters": "YMFH*KZJB", "ProbeLetter": "l", "Correct": false, "Load": 8},
+ {"StimulusLetters": "HYMJSRCBD", "ProbeLetter": "v", "Correct": false, "Load": 9},
+ {"StimulusLetters": "XTNPLFKSY", "ProbeLetter": "t", "Correct": true, "Load": 9},
+ {"StimulusLetters": "VMDGYXRHC", "ProbeLetter": "z", "Correct": false, "Load": 9},
+ {"StimulusLetters": "SPKQVLNYB", "ProbeLetter": "p", "Correct": true, "Load": 9},
+ {"StimulusLetters": "MZHGRKTFS", "ProbeLetter": "h", "Correct": true, "Load": 9},
+ {"StimulusLetters": "ZNRVXJQDY", "ProbeLetter": "b", "Correct": false, "Load": 9}
+]
+
+var DMSLetterMRIList001 = [
+ {"StimulusLetters": "****D****", "ProbeLetter": "z", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****Q****", "ProbeLetter": "v", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****N****", "ProbeLetter": "c", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****M****", "ProbeLetter": "m", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****Z****", "ProbeLetter": "z", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****J****", "ProbeLetter": "j", "Correct": true, "Load": 1},
+ {"StimulusLetters": "***F*X***", "ProbeLetter": "c", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***S*N***", "ProbeLetter": "s", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***Y*L***", "ProbeLetter": "y", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***C*M***", "ProbeLetter": "c", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***Q*B***", "ProbeLetter": "n", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***F*T***", "ProbeLetter": "c", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***CZH***", "ProbeLetter": "y", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***XBK***", "ProbeLetter": "x", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***RHY***", "ProbeLetter": "r", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***CLT***", "ProbeLetter": "c", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***GXY***", "ProbeLetter": "f", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***MNC***", "ProbeLetter": "b", "Correct": true, "Load": 3},
+ {"StimulusLetters": "Z*B***C*P", "ProbeLetter": "z", "Correct": true, "Load": 4},
+ {"StimulusLetters": "V*G***Y*N", "ProbeLetter": "y", "Correct": true, "Load": 4},
+ {"StimulusLetters": "M*X***J*B", "ProbeLetter": "h", "Correct": true, "Load": 4},
+ {"StimulusLetters": "V*L***F*Y", "ProbeLetter": "y", "Correct": true, "Load": 4},
+ {"StimulusLetters": "P*N***H*X", "ProbeLetter": "g", "Correct": true, "Load": 4},
+ {"StimulusLetters": "R*D***Z*T", "ProbeLetter": "m", "Correct": true, "Load": 4},
+ {"StimulusLetters": "V*Q*L*B*H", "ProbeLetter": "x", "Correct": true, "Load": 5},
+ {"StimulusLetters": "Z*P*C*F*K", "ProbeLetter": "p", "Correct": true, "Load": 5},
+ {"StimulusLetters": "J*G*N*D*Y", "ProbeLetter": "h", "Correct": true, "Load": 5},
+ {"StimulusLetters": "X*R*M*V*L", "ProbeLetter": "v", "Correct": true, "Load": 5},
+ {"StimulusLetters": "Q*G*Y*J*Z", "ProbeLetter": "t", "Correct": true, "Load": 5},
+ {"StimulusLetters": "X*C*S*K*M", "ProbeLetter": "x", "Correct": true, "Load": 5},
+ {"StimulusLetters": "PCZ***GQJ", "ProbeLetter": "f", "Correct": true, "Load": 6},
+ {"StimulusLetters": "KHX***RMV", "ProbeLetter": "r", "Correct": true, "Load": 6},
+ {"StimulusLetters": "JLZ***GCD", "ProbeLetter": "f", "Correct": true, "Load": 6},
+ {"StimulusLetters": "BQT***KPY", "ProbeLetter": "h", "Correct": true, "Load": 6},
+ {"StimulusLetters": "SXR***NLF", "ProbeLetter": "r", "Correct": true, "Load": 6},
+ {"StimulusLetters": "MZJ***VBD", "ProbeLetter": "v", "Correct": true, "Load": 6},
+ {"StimulusLetters": "JDF*K*ZNX", "ProbeLetter": "g", "Correct": true, "Load": 7},
+ {"StimulusLetters": "SCQ*T*LMB", "ProbeLetter": "s", "Correct": true, "Load": 7},
+ {"StimulusLetters": "DYF*R*KGN", "ProbeLetter": "x", "Correct": true, "Load": 7},
+ {"StimulusLetters": "TQJ*L*HSM", "ProbeLetter": "j", "Correct": true, "Load": 7},
+ {"StimulusLetters": "RGN*B*DVC", "ProbeLetter": "c", "Correct": true, "Load": 7},
+ {"StimulusLetters": "FQS*K*YLM", "ProbeLetter": "x", "Correct": true, "Load": 7},
+ {"StimulusLetters": "DNSQ*HZKF", "ProbeLetter": "s", "Correct": true, "Load": 8},
+ {"StimulusLetters": "BQLX*MYVG", "ProbeLetter": "g", "Correct": true, "Load": 8},
+ {"StimulusLetters": "RQJK*TCFD", "ProbeLetter": "d", "Correct": true, "Load": 8},
+ {"StimulusLetters": "MGXZ*HSVL", "ProbeLetter": "p", "Correct": true, "Load": 8},
+ {"StimulusLetters": "KMFN*QTDR", "ProbeLetter": "j", "Correct": true, "Load": 8},
+ {"StimulusLetters": "NYXH*GPCL", "ProbeLetter": "z", "Correct": true, "Load": 8},
+ {"StimulusLetters": "SRCZPJQDF", "ProbeLetter": "s", "Correct": true, "Load": 9},
+ {"StimulusLetters": "ZXMFGVTBL", "ProbeLetter": "k", "Correct": true, "Load": 9},
+ {"StimulusLetters": "VDCBRHQJS", "ProbeLetter": "y", "Correct": true, "Load": 9},
+ {"StimulusLetters": "LKFSGNMPY", "ProbeLetter": "n", "Correct": true, "Load": 9},
+ {"StimulusLetters": "TCJXKRGBV", "ProbeLetter": "t", "Correct": true, "Load": 9},
+ {"StimulusLetters": "QZYSRKDLN", "ProbeLetter": "f", "Correct": true, "Load": 9}
+]
+
+var DMSLetterMRIList002 = [
+ {"StimulusLetters": "****F****", "ProbeLetter": "f", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****X****", "ProbeLetter": "x", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****M****", "ProbeLetter": "s", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****N****", "ProbeLetter": "c", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****D****", "ProbeLetter": "s", "Correct": true, "Load": 1},
+ {"StimulusLetters": "****J****", "ProbeLetter": "j", "Correct": true, "Load": 1},
+ {"StimulusLetters": "***V*D***", "ProbeLetter": "s", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***L*T***", "ProbeLetter": "c", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***B*X***", "ProbeLetter": "r", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***Q*H***", "ProbeLetter": "h", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***Z*K***", "ProbeLetter": "k", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***S*N***", "ProbeLetter": "n", "Correct": true, "Load": 2},
+ {"StimulusLetters": "***JKG***", "ProbeLetter": "g", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***LVC***", "ProbeLetter": "c", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***BDM***", "ProbeLetter": "m", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***FCH***", "ProbeLetter": "s", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***JPM***", "ProbeLetter": "t", "Correct": true, "Load": 3},
+ {"StimulusLetters": "***RHN***", "ProbeLetter": "s", "Correct": true, "Load": 3},
+ {"StimulusLetters": "M*T***P*Y", "ProbeLetter": "x", "Correct": true, "Load": 4},
+ {"StimulusLetters": "Q*R***J*S", "ProbeLetter": "q", "Correct": true, "Load": 4},
+ {"StimulusLetters": "K*F***N*V", "ProbeLetter": "x", "Correct": true, "Load": 4},
+ {"StimulusLetters": "M*H***D*L", "ProbeLetter": "d", "Correct": true, "Load": 4},
+ {"StimulusLetters": "Y*X***R*V", "ProbeLetter": "s", "Correct": true, "Load": 4},
+ {"StimulusLetters": "M*G***Z*B", "ProbeLetter": "g", "Correct": true, "Load": 4},
+ {"StimulusLetters": "M*L*Y*Z*J", "ProbeLetter": "j", "Correct": true, "Load": 5},
+ {"StimulusLetters": "K*Q*C*T*H", "ProbeLetter": "h", "Correct": true, "Load": 5},
+ {"StimulusLetters": "S*R*M*P*N", "ProbeLetter": "z", "Correct": true, "Load": 5},
+ {"StimulusLetters": "L*C*Q*F*H", "ProbeLetter": "j", "Correct": true, "Load": 5},
+ {"StimulusLetters": "P*K*R*N*V", "ProbeLetter": "v", "Correct": true, "Load": 5},
+ {"StimulusLetters": "J*Y*Q*X*L", "ProbeLetter": "b", "Correct": true, "Load": 5},
+ {"StimulusLetters": "VSR***KPY", "ProbeLetter": "f", "Correct": true, "Load": 6},
+ {"StimulusLetters": "QHD***GNM", "ProbeLetter": "q", "Correct": true, "Load": 6},
+ {"StimulusLetters": "CXS***LKP", "ProbeLetter": "x", "Correct": true, "Load": 6},
+ {"StimulusLetters": "DBY***MJN", "ProbeLetter": "g", "Correct": true, "Load": 6},
+ {"StimulusLetters": "HRT***ZKL", "ProbeLetter": "z", "Correct": true, "Load": 6},
+ {"StimulusLetters": "BQC***MGY", "ProbeLetter": "s", "Correct": true, "Load": 6},
+ {"StimulusLetters": "ZVX*C*YMH", "ProbeLetter": "d", "Correct": true, "Load": 7},
+ {"StimulusLetters": "QNB*K*LJF", "ProbeLetter": "k", "Correct": true, "Load": 7},
+ {"StimulusLetters": "SMC*R*HXY", "ProbeLetter": "y", "Correct": true, "Load": 7},
+ {"StimulusLetters": "DLJ*P*NBG", "ProbeLetter": "d", "Correct": true, "Load": 7},
+ {"StimulusLetters": "XSR*Z*KHF", "ProbeLetter": "t", "Correct": true, "Load": 7},
+ {"StimulusLetters": "CGD*P*JQY", "ProbeLetter": "b", "Correct": true, "Load": 7},
+ {"StimulusLetters": "VHJQ*CPYM", "ProbeLetter": "n", "Correct": true, "Load": 8},
+ {"StimulusLetters": "VGRK*NZXB", "ProbeLetter": "r", "Correct": true, "Load": 8},
+ {"StimulusLetters": "CJLQ*MTGF", "ProbeLetter": "y", "Correct": true, "Load": 8},
+ {"StimulusLetters": "XBVD*NZKL", "ProbeLetter": "d", "Correct": true, "Load": 8},
+ {"StimulusLetters": "CHFL*YJMG", "ProbeLetter": "r", "Correct": true, "Load": 8},
+ {"StimulusLetters": "XKDB*TMZN", "ProbeLetter": "k", "Correct": true, "Load": 8},
+ {"StimulusLetters": "CTMSQVLFX", "ProbeLetter": "z", "Correct": true, "Load": 9},
+ {"StimulusLetters": "GBYJRVZPH", "ProbeLetter": "y", "Correct": true, "Load": 9},
+ {"StimulusLetters": "NHTBXFMQS", "ProbeLetter": "s", "Correct": true, "Load": 9},
+ {"StimulusLetters": "DVQLPJRZT", "ProbeLetter": "z", "Correct": true, "Load": 9},
+ {"StimulusLetters": "BCQKFXHRN", "ProbeLetter": "m", "Correct": true, "Load": 9},
+ {"StimulusLetters": "RLSZQYGVP", "ProbeLetter": "t", "Correct": true, "Load": 9}
+]
\ No newline at end of file
diff --git a/LetterDMS/StairClass.js b/LetterDMS/StairClass.js
new file mode 100644
index 0000000..2a2bb2c
--- /dev/null
+++ b/LetterDMS/StairClass.js
@@ -0,0 +1,187 @@
+ class Stair {
+ constructor(Current=1, MinValue=1, MaxValue=9, MaxReversals=5,
+ MaxTrials=40, StepSize=1, NUp=3, NDown=1, FastStart=true, MaxTime=420)
+ {
+ this.Current = Current; // what is the current value
+ this.TrialCount = 0; // How many trials have been completed
+ this.MinValue = MinValue; // what is the minimum value this staircase can reach
+ this.MaxValue = MaxValue; // what is the maximum value this staircase can reach
+ this.MaxReversals = MaxReversals; // What is the maximum number of reversal. This is a break condition
+ this.MaxTrials = MaxTrials; // What is the maximum number of trials. This is a break condition
+ this.StepSize = StepSize; // What is the step size
+ this.NUp = NUp;// How many correct responses in a row are required before the current value is INcreased
+ this.NDown = NDown;// How many INcorrect responses in a two are required before the current value is DEcreased
+ this.FastStart = FastStart; // At the beginning should sequential correct responses result in increasing current?
+ this.CurrentRun = 1; // How many correct in a row
+ this.ValueList = []; // List of all the values across all trials
+ // add the inital value to the list
+ this.ValueList.push(this.Current)
+ this.ReversalList = []; // List of values where a reversal took place
+ this.findDirection()
+ this.CurrentDirection = 1; // What direction are we heading? 1 increasing, -1 decreasing
+ this.Finished = false; // If any of the stopping conditions are met this is set to true
+ this.ReversalCount = 0; // the number of reversals
+ this.MaxTime= MaxTime; // This is the maximal amount of time that the staircase can last (IN SECONDS)
+
+ }
+ findDirection() {
+ if (this.StepSize > 0) {
+ this.CurrentDirection = 1
+ }
+ else {
+ this.CurrentDirection = -1
+ }
+ }
+ // increase difficulty
+ stepUp() {
+ // allow for reverse staircases
+ if (this.StepSize > 0) {
+ // only increase current if the max value has NOT been reached
+ if (this.Current < this.MaxValue) {
+ // Is this a reversal?
+ if (this.CurrentDirection == -1) {
+ // if so add the current value to the list
+ this.ReversalList.push(this.Current)
+ // and update the reversal count list
+ this.updateReversalCount()
+ }
+ this.Current += this.StepSize
+
+ // update the current run list
+ this.CurrentRun = 1
+ }
+ // Make sure the direction is correct
+ this.CurrentDirection = 1
+
+ }
+ else {
+ if (this.Current > this.MinValue) {
+ // Is this a reversal?
+ if (this.CurrentDirection == 1) {
+ // if so add the current value to the list
+ this.ReversalList.push(this.Current)
+ // and update the reversal count list
+ this.updateReversalCount()
+ // update the current run list
+ this.CurrentRun = 1
+ }
+ this.Current += this.StepSize
+ }
+ // Make sure the direction is correct
+ this.CurrentDirection = -1
+ }
+ }
+ // Check to see if any stopping conditions are met
+ checkFinished() {
+ if (this.ReversalCount == this.MaxReversals) {
+ this.Finished = true
+ }
+ if (this.TrialCount == this.MaxTrials) {
+ this.Finished = true
+ }
+ }
+
+ // decrease difficulty
+ stepDown() {
+ // allow for reverse staircases
+ if (this.StepSize > 0) {
+
+ if (this.CurrentDirection == 1) {
+ // if so add the current value to the list
+ this.ReversalList.push(this.Current)
+ // and update the reversal count list
+ this.updateReversalCount()
+ }
+ // Check to make sure the value is not at the limit
+ if (this.Current > this.MinValue)
+ {
+ this.Current -= this.StepSize
+ }
+ // Make sure the direction is correct
+ this.CurrentDirection = -1
+ }
+ else {
+ // Check to see if this is a reversal
+ if (this.CurrentDirection == -1) {
+ // if so add the current value to the list
+ this.ReversalList.push(this.Current)
+ // and update the reversal count list
+ this.updateReversalCount()
+ }
+
+ if (this.Current < this.MaxValue)
+ {
+ this.Current -= this.StepSize
+ }
+ // Make sure the direction is correct
+ this.CurrentDirection = 1
+ }
+ }
+
+ // keep track of reversal count
+ updateReversalCount() {
+ this.ReversalCount += 1
+ }
+
+ // stop the fast start
+ StopFastStart() {
+ this.FastStart = false
+ }
+
+ // Make a decision based on the current response
+ Decide(ResponseCorrect) {
+ // the response is correct
+ if (ResponseCorrect) {
+ // are we still at the rapid increase phase?
+ if (this.FastStart) {
+ this.BeginningDecision()
+ }
+ else {
+ this.LaterDecision()
+ }
+ }
+ else {
+ this.stepDown()
+ // reset the current run counter
+ this.CurrentRun = 1
+ // If we are still in the fast start increase phase, then end it
+ if (this.FastStart) {
+ this.FastStart = false
+ }
+ }
+ // At the end of every decision check the ending conditions
+ this.ValueList.push(this.Current)
+ this.TrialCount += 1
+ this.checkFinished()
+ }
+
+ // We are at the rapid increase phase at the beginning
+ BeginningDecision() {
+ this.stepUp()
+ // Note that the CurrentRun counter is not being used yet
+ }
+
+ // We are past the rapid increase phase at the beginning
+ LaterDecision() {
+ // if this is the completeion of a run of correct responses, then increase
+ if (this.CurrentRun == this.NUp) {
+ this.stepUp()
+ // reset the current run counter since we made a change
+ this.CurrentRun = 1
+ }
+ else {
+ this.CurrentRun += 1
+ }
+ }
+
+ CalculateAverage() {
+ // calculate the average of the reversal values
+ var totalSum = 0;
+ for(var i in this.ReversalList) {
+ totalSum += this.ReversalList[i];
+ }
+ var numsCnt = this.ReversalList.length;
+ var average = totalSum / numsCnt;
+ return average
+ }
+ }
diff --git a/LetterDMS/StyleSheet.css b/LetterDMS/StyleSheet.css
new file mode 100644
index 0000000..70229b2
--- /dev/null
+++ b/LetterDMS/StyleSheet.css
@@ -0,0 +1 @@
+body {background-color: rgb(150, 150, 150)}
\ No newline at end of file
diff --git a/LetterDMS/jspsych/VERSION_6.3.1 b/LetterDMS/jspsych/VERSION_6.3.1
new file mode 100644
index 0000000..c33117e
--- /dev/null
+++ b/LetterDMS/jspsych/VERSION_6.3.1
@@ -0,0 +1 @@
+VERSION_6.3.1
diff --git a/LetterDMS/jspsych/css/jspsych.css b/LetterDMS/jspsych/css/jspsych.css
new file mode 100644
index 0000000..3b6d177
--- /dev/null
+++ b/LetterDMS/jspsych/css/jspsych.css
@@ -0,0 +1,206 @@
+/*
+ * CSS for jsPsych experiments.
+ *
+ * This stylesheet provides minimal styling to make jsPsych
+ * experiments look polished without any additional styles.
+ */
+
+ @import url(https://fonts.googleapis.com/css?family=Open+Sans:400italic,700italic,400,700);
+
+/* Container holding jsPsych content */
+
+ .jspsych-display-element {
+ display: flex;
+ flex-direction: column;
+ overflow-y: auto;
+ }
+
+ .jspsych-display-element:focus {
+ outline: none;
+ }
+
+ .jspsych-content-wrapper {
+ display: flex;
+ margin: auto;
+ flex: 1 1 100%;
+ width: 100%;
+ }
+
+ .jspsych-content {
+ max-width: 95%; /* this is mainly an IE 10-11 fix */
+ text-align: center;
+ margin: auto; /* this is for overflowing content */
+ }
+
+ .jspsych-top {
+ align-items: flex-start;
+ }
+
+ .jspsych-middle {
+ align-items: center;
+ }
+
+/* fonts and type */
+
+.jspsych-display-element {
+ font-family: 'Open Sans', 'Arial', sans-serif;
+ font-size: 18px;
+ line-height: 1.6em;
+}
+
+/* Form elements like input fields and buttons */
+
+.jspsych-display-element input[type="text"] {
+ font-family: 'Open Sans', 'Arial', sans-serif;
+ font-size: 14px;
+}
+
+/* borrowing Bootstrap style for btn elements, but combining styles a bit */
+.jspsych-btn {
+ display: inline-block;
+ padding: 6px 12px;
+ margin: 0px;
+ font-size: 14px;
+ font-weight: 400;
+ font-family: 'Open Sans', 'Arial', sans-serif;
+ cursor: pointer;
+ line-height: 1.4;
+ text-align: center;
+ white-space: nowrap;
+ vertical-align: middle;
+ background-image: none;
+ border: 1px solid transparent;
+ border-radius: 4px;
+ color: #333;
+ background-color: #fff;
+ border-color: #ccc;
+}
+
+/* only apply the hover style on devices with a mouse/pointer that can hover - issue #977 */
+@media (hover: hover) {
+ .jspsych-btn:hover {
+ background-color: #ddd;
+ border-color: #aaa;
+ }
+}
+
+.jspsych-btn:active {
+ background-color: #ddd;
+ border-color:#000000;
+}
+
+.jspsych-btn:disabled {
+ background-color: #eee;
+ color: #aaa;
+ border-color: #ccc;
+ cursor: not-allowed;
+}
+
+/* custom style for input[type="range] (slider) to improve alignment between positions and labels */
+
+.jspsych-slider {
+ appearance: none;
+ -webkit-appearance: none;
+ -moz-appearance: none;
+ width: 100%;
+ background: transparent;
+}
+.jspsych-slider:focus {
+ outline: none;
+}
+/* track */
+.jspsych-slider::-webkit-slider-runnable-track {
+ appearance: none;
+ -webkit-appearance: none;
+ width: 100%;
+ height: 8px;
+ cursor: pointer;
+ background: #eee;
+ box-shadow: 0px 0px 0px #000000, 0px 0px 0px #0d0d0d;
+ border-radius: 2px;
+ border: 1px solid #aaa;
+}
+.jspsych-slider::-moz-range-track {
+ appearance: none;
+ width: 100%;
+ height: 8px;
+ cursor: pointer;
+ background: #eee;
+ box-shadow: 0px 0px 0px #000000, 0px 0px 0px #0d0d0d;
+ border-radius: 2px;
+ border: 1px solid #aaa;
+}
+.jspsych-slider::-ms-track {
+ appearance: none;
+ width: 99%;
+ height: 14px;
+ cursor: pointer;
+ background: #eee;
+ box-shadow: 0px 0px 0px #000000, 0px 0px 0px #0d0d0d;
+ border-radius: 2px;
+ border: 1px solid #aaa;
+}
+/* thumb */
+.jspsych-slider::-webkit-slider-thumb {
+ border: 1px solid #666;
+ height: 24px;
+ width: 15px;
+ border-radius: 5px;
+ background: #ffffff;
+ cursor: pointer;
+ -webkit-appearance: none;
+ margin-top: -9px;
+}
+.jspsych-slider::-moz-range-thumb {
+ border: 1px solid #666;
+ height: 24px;
+ width: 15px;
+ border-radius: 5px;
+ background: #ffffff;
+ cursor: pointer;
+}
+.jspsych-slider::-ms-thumb {
+ border: 1px solid #666;
+ height: 20px;
+ width: 15px;
+ border-radius: 5px;
+ background: #ffffff;
+ cursor: pointer;
+ margin-top: -2px;
+}
+
+/* jsPsych progress bar */
+
+#jspsych-progressbar-container {
+ color: #555;
+ border-bottom: 1px solid #dedede;
+ background-color: #f9f9f9;
+ margin-bottom: 1em;
+ text-align: center;
+ padding: 8px 0px;
+ width: 100%;
+ line-height: 1em;
+}
+#jspsych-progressbar-container span {
+ font-size: 14px;
+ padding-right: 14px;
+}
+#jspsych-progressbar-outer {
+ background-color: #eee;
+ width: 50%;
+ margin: auto;
+ height: 14px;
+ display: inline-block;
+ vertical-align: middle;
+ box-shadow: inset 0 1px 2px rgba(0,0,0,0.1);
+}
+#jspsych-progressbar-inner {
+ background-color: #aaa;
+ width: 0%;
+ height: 100%;
+}
+
+/* Control appearance of jsPsych.data.displayData() */
+#jspsych-data-display {
+ text-align: left;
+}
diff --git a/LetterDMS/jspsych/examples/add-to-end-of-timeline.html b/LetterDMS/jspsych/examples/add-to-end-of-timeline.html
new file mode 100644
index 0000000..05dfa2a
--- /dev/null
+++ b/LetterDMS/jspsych/examples/add-to-end-of-timeline.html
@@ -0,0 +1,38 @@
+
+
+
+
+
+
+
+ The URL variable should be logged to the console
+
+
+
diff --git a/LetterDMS/jspsych/examples/demo-flanker.html b/LetterDMS/jspsych/examples/demo-flanker.html
new file mode 100644
index 0000000..f36f85d
--- /dev/null
+++ b/LetterDMS/jspsych/examples/demo-flanker.html
@@ -0,0 +1,117 @@
+
+
+
+ Flanker Task
+
+
+
+
+ My experiment
+
+
+
+
+
+ Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer nec odio. Praesent libero. Sed cursus ante dapibus diam. Sed nisi. Nulla quis sem at nibh elementum imperdiet. Duis sagittis ipsum. Praesent mauris. Fusce nec tellus sed augue semper porta. Mauris massa. Vestibulum lacinia arcu eget nulla.
+
+Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Curabitur sodales ligula in libero. Sed dignissim lacinia nunc. Curabitur tortor. Pellentesque nibh. Aenean quam. In scelerisque sem at dolor. Maecenas mattis. Sed convallis tristique sem. Proin ut ligula vel nunc egestas porttitor. Morbi lectus risus, iaculis vel, suscipit quis, luctus non, massa.
+
+Fusce ac turpis quis ligula lacinia aliquet. Mauris ipsum. Nulla metus metus, ullamcorper vel, tincidunt sed, euismod in, nibh. Quisque volutpat condimentum velit. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Nam nec ante. Sed lacinia, urna non tincidunt mattis, tortor neque adipiscing diam, a cursus ipsum ante quis turpis. Nulla facilisi. Ut fringilla. Suspendisse potenti. Nunc feugiat mi a tellus consequat imperdiet. Vestibulum sapien. Proin quam. Etiam ultrices.
+
+Suspendisse in justo eu magna luctus suscipit. Sed lectus. Integer euismod lacus luctus magna. Quisque cursus, metus vitae pharetra auctor, sem massa mattis sem, at interdum magna augue eget diam. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Morbi lacinia molestie dui. Praesent blandit dolor. Sed non quam. In vel mi sit amet augue congue elementum. Morbi in ipsum sit amet pede facilisis laoreet. Donec lacus nunc, viverra nec, blandit vel, egestas et, augue. Vestibulum tincidunt malesuada tellus.
+
+Ut ultrices ultrices enim. Curabitur sit amet mauris. Morbi in dui quis est pulvinar ullamcorper. Nulla facilisi. Integer lacinia sollicitudin massa. Cras metus. Sed aliquet risus a tortor. Integer id quam. Morbi mi. Quisque nisl felis, venenatis tristique, dignissim in, ultrices sit amet, augue. Proin sodales libero eget ante. Nulla quam.
+
+
+
+
+
+
diff --git a/LetterDMS/jspsych/examples/end-active-node.html b/LetterDMS/jspsych/examples/end-active-node.html
new file mode 100644
index 0000000..7f335cd
--- /dev/null
+++ b/LetterDMS/jspsych/examples/end-active-node.html
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+ This is a demo consent form. Click the checkbox below to indicate the you
+ would like to participate in the experiment
+
+Start Experiment
diff --git a/LetterDMS/jspsych/examples/img/1.gif b/LetterDMS/jspsych/examples/img/1.gif
new file mode 100644
index 0000000..f4511d9
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/1.gif differ
diff --git a/LetterDMS/jspsych/examples/img/10.gif b/LetterDMS/jspsych/examples/img/10.gif
new file mode 100644
index 0000000..1f25f1a
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/10.gif differ
diff --git a/LetterDMS/jspsych/examples/img/11.gif b/LetterDMS/jspsych/examples/img/11.gif
new file mode 100644
index 0000000..f54b3d6
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/11.gif differ
diff --git a/LetterDMS/jspsych/examples/img/12.gif b/LetterDMS/jspsych/examples/img/12.gif
new file mode 100644
index 0000000..053ecf6
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/12.gif differ
diff --git a/LetterDMS/jspsych/examples/img/2.gif b/LetterDMS/jspsych/examples/img/2.gif
new file mode 100644
index 0000000..8900090
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/2.gif differ
diff --git a/LetterDMS/jspsych/examples/img/3.gif b/LetterDMS/jspsych/examples/img/3.gif
new file mode 100644
index 0000000..b6205d1
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/3.gif differ
diff --git a/LetterDMS/jspsych/examples/img/4.gif b/LetterDMS/jspsych/examples/img/4.gif
new file mode 100644
index 0000000..1d2de35
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/4.gif differ
diff --git a/LetterDMS/jspsych/examples/img/5.gif b/LetterDMS/jspsych/examples/img/5.gif
new file mode 100644
index 0000000..0c8ce98
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/5.gif differ
diff --git a/LetterDMS/jspsych/examples/img/6.gif b/LetterDMS/jspsych/examples/img/6.gif
new file mode 100644
index 0000000..59149da
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/6.gif differ
diff --git a/LetterDMS/jspsych/examples/img/7.gif b/LetterDMS/jspsych/examples/img/7.gif
new file mode 100644
index 0000000..6b3ea1b
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/7.gif differ
diff --git a/LetterDMS/jspsych/examples/img/8.gif b/LetterDMS/jspsych/examples/img/8.gif
new file mode 100644
index 0000000..723ab75
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/8.gif differ
diff --git a/LetterDMS/jspsych/examples/img/9.gif b/LetterDMS/jspsych/examples/img/9.gif
new file mode 100644
index 0000000..dabe68d
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/9.gif differ
diff --git a/LetterDMS/jspsych/examples/img/age/of1.jpg b/LetterDMS/jspsych/examples/img/age/of1.jpg
new file mode 100644
index 0000000..13a406d
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/of1.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/of2.jpg b/LetterDMS/jspsych/examples/img/age/of2.jpg
new file mode 100644
index 0000000..0c10e81
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/of2.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/of3.jpg b/LetterDMS/jspsych/examples/img/age/of3.jpg
new file mode 100644
index 0000000..e20f977
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/of3.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/om1.jpg b/LetterDMS/jspsych/examples/img/age/om1.jpg
new file mode 100644
index 0000000..0b4335b
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/om1.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/om2.jpg b/LetterDMS/jspsych/examples/img/age/om2.jpg
new file mode 100644
index 0000000..3930e06
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/om2.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/om3.jpg b/LetterDMS/jspsych/examples/img/age/om3.jpg
new file mode 100644
index 0000000..f74917e
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/om3.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/yf1.jpg b/LetterDMS/jspsych/examples/img/age/yf1.jpg
new file mode 100644
index 0000000..c13b936
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/yf1.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/yf4.jpg b/LetterDMS/jspsych/examples/img/age/yf4.jpg
new file mode 100644
index 0000000..d4d61da
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/yf4.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/yf5.jpg b/LetterDMS/jspsych/examples/img/age/yf5.jpg
new file mode 100644
index 0000000..9471606
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/yf5.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/ym2.jpg b/LetterDMS/jspsych/examples/img/age/ym2.jpg
new file mode 100644
index 0000000..a56e70e
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/ym2.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/ym3.jpg b/LetterDMS/jspsych/examples/img/age/ym3.jpg
new file mode 100644
index 0000000..33847a4
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/ym3.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/age/ym5.jpg b/LetterDMS/jspsych/examples/img/age/ym5.jpg
new file mode 100644
index 0000000..4e25343
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/age/ym5.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/backwardN.gif b/LetterDMS/jspsych/examples/img/backwardN.gif
new file mode 100644
index 0000000..38a2164
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/backwardN.gif differ
diff --git a/LetterDMS/jspsych/examples/img/blue.png b/LetterDMS/jspsych/examples/img/blue.png
new file mode 100644
index 0000000..820bdce
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/blue.png differ
diff --git a/LetterDMS/jspsych/examples/img/card.png b/LetterDMS/jspsych/examples/img/card.png
new file mode 100644
index 0000000..ca8de4f
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/card.png differ
diff --git a/LetterDMS/jspsych/examples/img/con1.png b/LetterDMS/jspsych/examples/img/con1.png
new file mode 100644
index 0000000..9b311d2
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/con1.png differ
diff --git a/LetterDMS/jspsych/examples/img/con2.png b/LetterDMS/jspsych/examples/img/con2.png
new file mode 100644
index 0000000..884bcbb
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/con2.png differ
diff --git a/LetterDMS/jspsych/examples/img/fixation.gif b/LetterDMS/jspsych/examples/img/fixation.gif
new file mode 100644
index 0000000..ff76c92
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/fixation.gif differ
diff --git a/LetterDMS/jspsych/examples/img/happy_face_1.jpg b/LetterDMS/jspsych/examples/img/happy_face_1.jpg
new file mode 100644
index 0000000..00891ce
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/happy_face_1.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/happy_face_2.jpg b/LetterDMS/jspsych/examples/img/happy_face_2.jpg
new file mode 100644
index 0000000..c895ca2
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/happy_face_2.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/happy_face_3.jpg b/LetterDMS/jspsych/examples/img/happy_face_3.jpg
new file mode 100644
index 0000000..d00fe2f
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/happy_face_3.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/happy_face_4.jpg b/LetterDMS/jspsych/examples/img/happy_face_4.jpg
new file mode 100644
index 0000000..843cb19
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/happy_face_4.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/inc1.png b/LetterDMS/jspsych/examples/img/inc1.png
new file mode 100644
index 0000000..4710286
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/inc1.png differ
diff --git a/LetterDMS/jspsych/examples/img/inc2.png b/LetterDMS/jspsych/examples/img/inc2.png
new file mode 100644
index 0000000..cfb43bb
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/inc2.png differ
diff --git a/LetterDMS/jspsych/examples/img/normalN.gif b/LetterDMS/jspsych/examples/img/normalN.gif
new file mode 100644
index 0000000..dc5593d
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/normalN.gif differ
diff --git a/LetterDMS/jspsych/examples/img/orange.png b/LetterDMS/jspsych/examples/img/orange.png
new file mode 100644
index 0000000..108e6e5
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/orange.png differ
diff --git a/LetterDMS/jspsych/examples/img/redX.png b/LetterDMS/jspsych/examples/img/redX.png
new file mode 100644
index 0000000..55eeb03
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/redX.png differ
diff --git a/LetterDMS/jspsych/examples/img/ribbon.jpg b/LetterDMS/jspsych/examples/img/ribbon.jpg
new file mode 100644
index 0000000..cf20cc6
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/ribbon.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/sad_face_1.jpg b/LetterDMS/jspsych/examples/img/sad_face_1.jpg
new file mode 100644
index 0000000..2a12ac2
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/sad_face_1.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/sad_face_2.jpg b/LetterDMS/jspsych/examples/img/sad_face_2.jpg
new file mode 100644
index 0000000..17ca674
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/sad_face_2.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/sad_face_3.jpg b/LetterDMS/jspsych/examples/img/sad_face_3.jpg
new file mode 100644
index 0000000..3edd256
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/sad_face_3.jpg differ
diff --git a/LetterDMS/jspsych/examples/img/sad_face_4.jpg b/LetterDMS/jspsych/examples/img/sad_face_4.jpg
new file mode 100644
index 0000000..c8b7a75
Binary files /dev/null and b/LetterDMS/jspsych/examples/img/sad_face_4.jpg differ
diff --git a/LetterDMS/jspsych/examples/js/snap.svg-min.js b/LetterDMS/jspsych/examples/js/snap.svg-min.js
new file mode 100644
index 0000000..23a7343
--- /dev/null
+++ b/LetterDMS/jspsych/examples/js/snap.svg-min.js
@@ -0,0 +1,21 @@
+// Snap.svg 0.5.1
+//
+// Copyright (c) 2013 – 2017 Adobe Systems Incorporated. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// build: 2017-02-07
+
+!function(a){var b,c,d="0.5.0",e="hasOwnProperty",f=/[\.\/]/,g=/\s*,\s*/,h="*",i=function(a,b){return a-b},j={n:{}},k=function(){for(var a=0,b=this.length;b>a;a++)if("undefined"!=typeof this[a])return this[a]},l=function(){for(var a=this.length;--a;)if("undefined"!=typeof this[a])return this[a]},m=Object.prototype.toString,n=String,o=Array.isArray||function(a){return a instanceof Array||"[object Array]"==m.call(a)};eve=function(a,d){var e,f=c,g=Array.prototype.slice.call(arguments,2),h=eve.listeners(a),j=0,m=[],n={},o=[],p=b;o.firstDefined=k,o.lastDefined=l,b=a,c=0;for(var q=0,r=h.length;r>q;q++)"zIndex"in h[q]&&(m.push(h[q].zIndex),h[q].zIndex<0&&(n[h[q].zIndex]=h[q]));for(m.sort(i);m[j]<0;)if(e=n[m[j++]],o.push(e.apply(d,g)),c)return c=f,o;for(q=0;r>q;q++)if(e=h[q],"zIndex"in e)if(e.zIndex==m[j]){if(o.push(e.apply(d,g)),c)break;do if(j++,e=n[m[j]],e&&o.push(e.apply(d,g)),c)break;while(e)}else n[e.zIndex]=e;else if(o.push(e.apply(d,g)),c)break;return c=f,b=p,o},eve._events=j,eve.listeners=function(a){var b,c,d,e,g,i,k,l,m=o(a)?a:a.split(f),n=j,p=[n],q=[];for(e=0,g=m.length;g>e;e++){for(l=[],i=0,k=p.length;k>i;i++)for(n=p[i].n,c=[n[m[e]],n[h]],d=2;d--;)b=c[d],b&&(l.push(b),q=q.concat(b.f||[]));p=l}return q},eve.separator=function(a){a?(a=n(a).replace(/(?=[\.\^\]\[\-])/g,"\\"),a="["+a+"]",f=new RegExp(a)):f=/[\.\/]/},eve.on=function(a,b){if("function"!=typeof b)return function(){};for(var c=o(a)?o(a[0])?a:[a]:n(a).split(g),d=0,e=c.length;e>d;d++)!function(a){for(var c,d=o(a)?a:n(a).split(f),e=j,g=0,h=d.length;h>g;g++)e=e.n,e=e.hasOwnProperty(d[g])&&e[d[g]]||(e[d[g]]={n:{}});for(e.f=e.f||[],g=0,h=e.f.length;h>g;g++)if(e.f[g]==b){c=!0;break}!c&&e.f.push(b)}(c[d]);return function(a){+a==+a&&(b.zIndex=+a)}},eve.f=function(a){var b=[].slice.call(arguments,1);return function(){eve.apply(null,[a,null].concat(b).concat([].slice.call(arguments,0)))}},eve.stop=function(){c=1},eve.nt=function(a){var c=o(b)?b.join("."):b;return a?new RegExp("(?:\\.|\\/|^)"+a+"(?:\\.|\\/|$)").test(c):c},eve.nts=function(){return o(b)?b:b.split(f)},eve.off=eve.unbind=function(a,b){if(!a)return void(eve._events=j={n:{}});var c=o(a)?o(a[0])?a:[a]:n(a).split(g);if(c.length>1)for(var d=0,i=c.length;i>d;d++)eve.off(c[d],b);else{c=o(a)?a:n(a).split(f);var k,l,m,d,i,p,q,r=[j],s=[];for(d=0,i=c.length;i>d;d++)for(p=0;pd;d++)for(k=r[d];k.n;){if(b){if(k.f){for(p=0,q=k.f.length;q>p;p++)if(k.f[p]==b){k.f.splice(p,1);break}!k.f.length&&delete k.f}for(l in k.n)if(k.n[e](l)&&k.n[l].f){var t=k.n[l].f;for(p=0,q=t.length;q>p;p++)if(t[p]==b){t.splice(p,1);break}!t.length&&delete k.n[l].f}}else{delete k.f;for(l in k.n)k.n[e](l)&&k.n[l].f&&delete k.n[l].f}k=k.n}a:for(d=0,i=s.length;i>d;d++){k=s[d];for(l in k.n[k.name].f)continue a;for(l in k.n[k.name].n)continue a;delete k.n[k.name]}}},eve.once=function(a,b){var c=function(){return eve.off(a,c),b.apply(this,arguments)};return eve.on(a,c)},eve.version=d,eve.toString=function(){return"You are running Eve "+d},"undefined"!=typeof module&&module.exports?module.exports=eve:"function"==typeof define&&define.amd?define("eve",[],function(){return eve}):a.eve=eve}(this),function(a,b){if("function"==typeof define&&define.amd)define(["eve"],function(c){return b(a,c)});else if("undefined"!=typeof exports){var c=require("eve");module.exports=b(a,c)}else b(a,a.eve)}(window||this,function(a,b){var c=function(b){var c,d={},e=a.requestAnimationFrame||a.webkitRequestAnimationFrame||a.mozRequestAnimationFrame||a.oRequestAnimationFrame||a.msRequestAnimationFrame||function(a){return setTimeout(a,16,(new Date).getTime()),!0},f=Array.isArray||function(a){return a instanceof Array||"[object Array]"==Object.prototype.toString.call(a)},g=0,h="M"+(+new Date).toString(36),i=function(){return h+(g++).toString(36)},j=Date.now||function(){return+new Date},k=function(a){var b=this;if(null==a)return b.s;var c=b.s-a;b.b+=b.dur*c,b.B+=b.dur*c,b.s=a},l=function(a){var b=this;return null==a?b.spd:void(b.spd=a)},m=function(a){var b=this;return null==a?b.dur:(b.s=b.s*a/b.dur,void(b.dur=a))},n=function(){var a=this;delete d[a.id],a.update(),b("mina.stop."+a.id,a)},o=function(){var a=this;a.pdif||(delete d[a.id],a.update(),a.pdif=a.get()-a.b)},p=function(){var a=this;a.pdif&&(a.b=a.get()-a.pdif,delete a.pdif,d[a.id]=a,r())},q=function(){var a,b=this;if(f(b.start)){a=[];for(var c=0,d=b.start.length;d>c;c++)a[c]=+b.start[c]+(b.end[c]-b.start[c])*b.easing(b.s)}else a=+b.start+(b.end-b.start)*b.easing(b.s);b.set(a)},r=function(a){if(!a)return void(c||(c=e(r)));var f=0;for(var g in d)if(d.hasOwnProperty(g)){var h=d[g],i=h.get();f++,h.s=(i-h.b)/(h.dur/h.spd),h.s>=1&&(delete d[g],h.s=1,f--,function(a){setTimeout(function(){b("mina.finish."+a.id,a)})}(h)),h.update()}c=f?e(r):!1},s=function(a,b,c,e,f,g,h){var j={id:i(),start:a,end:b,b:c,s:0,dur:e-c,spd:1,get:f,set:g,easing:h||s.linear,status:k,speed:l,duration:m,stop:n,pause:o,resume:p,update:q};d[j.id]=j;var t,u=0;for(t in d)if(d.hasOwnProperty(t)&&(u++,2==u))break;return 1==u&&r(),j};return s.time=j,s.getById=function(a){return d[a]||null},s.linear=function(a){return a},s.easeout=function(a){return Math.pow(a,1.7)},s.easein=function(a){return Math.pow(a,.48)},s.easeinout=function(a){if(1==a)return 1;if(0==a)return 0;var b=.48-a/1.04,c=Math.sqrt(.1734+b*b),d=c-b,e=Math.pow(Math.abs(d),1/3)*(0>d?-1:1),f=-c-b,g=Math.pow(Math.abs(f),1/3)*(0>f?-1:1),h=e+g+.5;return 3*(1-h)*h*h+h*h*h},s.backin=function(a){if(1==a)return 1;var b=1.70158;return a*a*((b+1)*a-b)},s.backout=function(a){if(0==a)return 0;a-=1;var b=1.70158;return a*a*((b+1)*a+b)+1},s.elastic=function(a){return a==!!a?a:Math.pow(2,-10*a)*Math.sin((a-.075)*(2*Math.PI)/.3)+1},s.bounce=function(a){var b,c=7.5625,d=2.75;return 1/d>a?b=c*a*a:2/d>a?(a-=1.5/d,b=c*a*a+.75):2.5/d>a?(a-=2.25/d,b=c*a*a+.9375):(a-=2.625/d,b=c*a*a+.984375),b},a.mina=s,s}("undefined"==typeof b?function(){}:b),d=function(a){function c(a,b){if(a){if(a.nodeType)return w(a);if(e(a,"array")&&c.set)return c.set.apply(c,a);if(a instanceof s)return a;if(null==b)try{return a=y.doc.querySelector(String(a)),w(a)}catch(d){return null}}return a=null==a?"100%":a,b=null==b?"100%":b,new v(a,b)}function d(a,b){if(b){if("#text"==a&&(a=y.doc.createTextNode(b.text||b["#text"]||"")),"#comment"==a&&(a=y.doc.createComment(b.text||b["#text"]||"")),"string"==typeof a&&(a=d(a)),"string"==typeof b)return 1==a.nodeType?"xlink:"==b.substring(0,6)?a.getAttributeNS(T,b.substring(6)):"xml:"==b.substring(0,4)?a.getAttributeNS(U,b.substring(4)):a.getAttribute(b):"text"==b?a.nodeValue:null;if(1==a.nodeType){for(var c in b)if(b[z](c)){var e=A(b[c]);e?"xlink:"==c.substring(0,6)?a.setAttributeNS(T,c.substring(6),e):"xml:"==c.substring(0,4)?a.setAttributeNS(U,c.substring(4),e):a.setAttribute(c,e):a.removeAttribute(c)}}else"text"in b&&(a.nodeValue=b.text)}else a=y.doc.createElementNS(U,a);return a}function e(a,b){return b=A.prototype.toLowerCase.call(b),"finite"==b?isFinite(a):"array"==b&&(a instanceof Array||Array.isArray&&Array.isArray(a))?!0:"null"==b&&null===a||b==typeof a&&null!==a||"object"==b&&a===Object(a)||J.call(a).slice(8,-1).toLowerCase()==b}function f(a){if("function"==typeof a||Object(a)!==a)return a;var b=new a.constructor;for(var c in a)a[z](c)&&(b[c]=f(a[c]));return b}function h(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return a.push(a.splice(c,1)[0])}function i(a,b,c){function d(){var e=Array.prototype.slice.call(arguments,0),f=e.join("␀"),g=d.cache=d.cache||{},i=d.count=d.count||[];return g[z](f)?(h(i,f),c?c(g[f]):g[f]):(i.length>=1e3&&delete g[i.shift()],i.push(f),g[f]=a.apply(b,e),c?c(g[f]):g[f])}return d}function j(a,b,c,d,e,f){if(null==e){var g=a-c,h=b-d;return g||h?(180+180*D.atan2(-h,-g)/H+360)%360:0}return j(a,b,e,f)-j(c,d,e,f)}function k(a){return a%360*H/180}function l(a){return 180*a/H%360}function m(a){var b=[];return a=a.replace(/(?:^|\s)(\w+)\(([^)]+)\)/g,function(a,c,d){return d=d.split(/\s*,\s*|\s+/),"rotate"==c&&1==d.length&&d.push(0,0),"scale"==c&&(d.length>2?d=d.slice(0,2):2==d.length&&d.push(0,0),1==d.length&&d.push(d[0],0,0)),"skewX"==c?b.push(["m",1,0,D.tan(k(d[0])),1,0,0]):"skewY"==c?b.push(["m",1,D.tan(k(d[0])),0,1,0,0]):b.push([c.charAt(0)].concat(d)),a}),b}function n(a,b){var d=aa(a),e=new c.Matrix;if(d)for(var f=0,g=d.length;g>f;f++){var h,i,j,k,l,m=d[f],n=m.length,o=A(m[0]).toLowerCase(),p=m[0]!=o,q=p?e.invert():0;"t"==o&&2==n?e.translate(m[1],0):"t"==o&&3==n?p?(h=q.x(0,0),i=q.y(0,0),j=q.x(m[1],m[2]),k=q.y(m[1],m[2]),e.translate(j-h,k-i)):e.translate(m[1],m[2]):"r"==o?2==n?(l=l||b,e.rotate(m[1],l.x+l.width/2,l.y+l.height/2)):4==n&&(p?(j=q.x(m[2],m[3]),k=q.y(m[2],m[3]),e.rotate(m[1],j,k)):e.rotate(m[1],m[2],m[3])):"s"==o?2==n||3==n?(l=l||b,e.scale(m[1],m[n-1],l.x+l.width/2,l.y+l.height/2)):4==n?p?(j=q.x(m[2],m[3]),k=q.y(m[2],m[3]),e.scale(m[1],m[1],j,k)):e.scale(m[1],m[1],m[2],m[3]):5==n&&(p?(j=q.x(m[3],m[4]),k=q.y(m[3],m[4]),e.scale(m[1],m[2],j,k)):e.scale(m[1],m[2],m[3],m[4])):"m"==o&&7==n&&e.add(m[1],m[2],m[3],m[4],m[5],m[6])}return e}function o(a){var b=a.node.ownerSVGElement&&w(a.node.ownerSVGElement)||a.node.parentNode&&w(a.node.parentNode)||c.select("svg")||c(0,0),d=b.select("defs"),e=null==d?!1:d.node;return e||(e=u("defs",b.node).node),e}function p(a){return a.node.ownerSVGElement&&w(a.node.ownerSVGElement)||c.select("svg")}function q(a,b,c){function e(a){if(null==a)return I;if(a==+a)return a;d(j,{width:a});try{return j.getBBox().width}catch(b){return 0}}function f(a){if(null==a)return I;if(a==+a)return a;d(j,{height:a});try{return j.getBBox().height}catch(b){return 0}}function g(d,e){null==b?i[d]=e(a.attr(d)||0):d==b&&(i=e(null==c?a.attr(d)||0:c))}var h=p(a).node,i={},j=h.querySelector(".svg---mgr");switch(j||(j=d("rect"),d(j,{x:-9e9,y:-9e9,width:10,height:10,"class":"svg---mgr",fill:"none"}),h.appendChild(j)),a.type){case"rect":g("rx",e),g("ry",f);case"image":g("width",e),g("height",f);case"text":g("x",e),g("y",f);break;case"circle":g("cx",e),g("cy",f),g("r",e);break;case"ellipse":g("cx",e),g("cy",f),g("rx",e),g("ry",f);break;case"line":g("x1",e),g("x2",e),g("y1",f),g("y2",f);break;case"marker":g("refX",e),g("markerWidth",e),g("refY",f),g("markerHeight",f);break;case"radialGradient":g("fx",e),g("fy",f);break;case"tspan":g("dx",e),g("dy",f);break;default:g(b,e)}return h.removeChild(j),i}function r(a){e(a,"array")||(a=Array.prototype.slice.call(arguments,0));for(var b=0,c=0,d=this.node;this[b];)delete this[b++];for(b=0;bc;c++){var e={type:a[c].type,attr:a[c].attr()},f=a[c].children();b.push(e),f.length&&x(f,e.childNodes=[])}}c.version="0.5.1",c.toString=function(){return"Snap v"+this.version},c._={};var y={win:a.window,doc:a.window.document};c._.glob=y;var z="hasOwnProperty",A=String,B=parseFloat,C=parseInt,D=Math,E=D.max,F=D.min,G=D.abs,H=(D.pow,D.PI),I=(D.round,""),J=Object.prototype.toString,K=/^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?%?)\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?%?)\s*\))\s*$/i,L=(c._.separator=/[,\s]+/,/[\s]*,[\s]*/),M={hs:1,rg:1},N=/([a-z])[\s,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\s]*,?[\s]*)+)/gi,O=/([rstm])[\s,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\s]*,?[\s]*)+)/gi,P=/(-?\d*\.?\d*(?:e[\-+]?\d+)?)[\s]*,?[\s]*/gi,Q=0,R="S"+(+new Date).toString(36),S=function(a){return(a&&a.type?a.type:I)+R+(Q++).toString(36)},T="http://www.w3.org/1999/xlink",U="http://www.w3.org/2000/svg",V={};c.url=function(a){return"url('#"+a+"')"};c._.$=d,c._.id=S,c.format=function(){var a=/\{([^\}]+)\}/g,b=/(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g,c=function(a,c,d){var e=d;return c.replace(b,function(a,b,c,d,f){b=b||d,e&&(b in e&&(e=e[b]),"function"==typeof e&&f&&(e=e()))}),e=(null==e||e==d?a:e)+""};return function(b,d){return A(b).replace(a,function(a,b){return c(a,b,d)})}}(),c._.clone=f,c._.cacher=i,c.rad=k,c.deg=l,c.sin=function(a){return D.sin(c.rad(a))},c.tan=function(a){return D.tan(c.rad(a))},c.cos=function(a){return D.cos(c.rad(a))},c.asin=function(a){return c.deg(D.asin(a))},c.acos=function(a){return c.deg(D.acos(a))},c.atan=function(a){return c.deg(D.atan(a))},c.atan2=function(a){return c.deg(D.atan2(a))},c.angle=j,c.len=function(a,b,d,e){return Math.sqrt(c.len2(a,b,d,e))},c.len2=function(a,b,c,d){return(a-c)*(a-c)+(b-d)*(b-d)},c.closestPoint=function(a,b,c){function d(a){var d=a.x-b,e=a.y-c;return d*d+e*e}for(var e,f,g,h,i=a.node,j=i.getTotalLength(),k=j/i.pathSegList.numberOfItems*.125,l=1/0,m=0;j>=m;m+=k)(h=d(g=i.getPointAtLength(m))).5;){var n,o,p,q,r,s;(p=f-k)>=0&&(r=d(n=i.getPointAtLength(p)))f)return b-f;if(f>a-c)return b-f+a}return b},c.getRGB=i(function(a){if(!a||(a=A(a)).indexOf("-")+1)return{r:-1,g:-1,b:-1,hex:"none",error:1,toString:Z};if("none"==a)return{r:-1,g:-1,b:-1,hex:"none",toString:Z};if(!(M[z](a.toLowerCase().substring(0,2))||"#"==a.charAt())&&(a=W(a)),!a)return{r:-1,g:-1,b:-1,hex:"none",error:1,toString:Z};var b,d,f,g,h,i,j=a.match(K);return j?(j[2]&&(f=C(j[2].substring(5),16),d=C(j[2].substring(3,5),16),b=C(j[2].substring(1,3),16)),j[3]&&(f=C((h=j[3].charAt(3))+h,16),d=C((h=j[3].charAt(2))+h,16),b=C((h=j[3].charAt(1))+h,16)),j[4]&&(i=j[4].split(L),b=B(i[0]),"%"==i[0].slice(-1)&&(b*=2.55),d=B(i[1]),"%"==i[1].slice(-1)&&(d*=2.55),f=B(i[2]),"%"==i[2].slice(-1)&&(f*=2.55),"rgba"==j[1].toLowerCase().slice(0,4)&&(g=B(i[3])),i[3]&&"%"==i[3].slice(-1)&&(g/=100)),j[5]?(i=j[5].split(L),b=B(i[0]),"%"==i[0].slice(-1)&&(b/=100),d=B(i[1]),"%"==i[1].slice(-1)&&(d/=100),f=B(i[2]),"%"==i[2].slice(-1)&&(f/=100),("deg"==i[0].slice(-3)||"°"==i[0].slice(-1))&&(b/=360),"hsba"==j[1].toLowerCase().slice(0,4)&&(g=B(i[3])),i[3]&&"%"==i[3].slice(-1)&&(g/=100),c.hsb2rgb(b,d,f,g)):j[6]?(i=j[6].split(L),b=B(i[0]),"%"==i[0].slice(-1)&&(b/=100),d=B(i[1]),"%"==i[1].slice(-1)&&(d/=100),f=B(i[2]),"%"==i[2].slice(-1)&&(f/=100),("deg"==i[0].slice(-3)||"°"==i[0].slice(-1))&&(b/=360),"hsla"==j[1].toLowerCase().slice(0,4)&&(g=B(i[3])),i[3]&&"%"==i[3].slice(-1)&&(g/=100),c.hsl2rgb(b,d,f,g)):(b=F(D.round(b),255),d=F(D.round(d),255),f=F(D.round(f),255),g=F(E(g,0),1),j={r:b,g:d,b:f,toString:Z},j.hex="#"+(16777216|f|d<<8|b<<16).toString(16).slice(1),j.opacity=e(g,"finite")?g:1,j)):{r:-1,g:-1,b:-1,hex:"none",error:1,toString:Z}},c),c.hsb=i(function(a,b,d){return c.hsb2rgb(a,b,d).hex}),c.hsl=i(function(a,b,d){return c.hsl2rgb(a,b,d).hex}),c.rgb=i(function(a,b,c,d){if(e(d,"finite")){var f=D.round;return"rgba("+[f(a),f(b),f(c),+d.toFixed(2)]+")"}return"#"+(16777216|c|b<<8|a<<16).toString(16).slice(1)});var W=function(a){var b=y.doc.getElementsByTagName("head")[0]||y.doc.getElementsByTagName("svg")[0],c="rgb(255, 0, 0)";return(W=i(function(a){if("red"==a.toLowerCase())return c;b.style.color=c,b.style.color=a;var d=y.doc.defaultView.getComputedStyle(b,I).getPropertyValue("color");return d==c?null:d}))(a)},X=function(){return"hsb("+[this.h,this.s,this.b]+")"},Y=function(){return"hsl("+[this.h,this.s,this.l]+")"},Z=function(){return 1==this.opacity||null==this.opacity?this.hex:"rgba("+[this.r,this.g,this.b,this.opacity]+")"},$=function(a,b,d){if(null==b&&e(a,"object")&&"r"in a&&"g"in a&&"b"in a&&(d=a.b,b=a.g,a=a.r),null==b&&e(a,string)){var f=c.getRGB(a);a=f.r,b=f.g,d=f.b}return(a>1||b>1||d>1)&&(a/=255,b/=255,d/=255),[a,b,d]},_=function(a,b,d,f){a=D.round(255*a),b=D.round(255*b),d=D.round(255*d);var g={r:a,g:b,b:d,opacity:e(f,"finite")?f:1,hex:c.rgb(a,b,d),toString:Z};return e(f,"finite")&&(g.opacity=f),g};c.color=function(a){var b;return e(a,"object")&&"h"in a&&"s"in a&&"b"in a?(b=c.hsb2rgb(a),a.r=b.r,a.g=b.g,a.b=b.b,a.opacity=1,a.hex=b.hex):e(a,"object")&&"h"in a&&"s"in a&&"l"in a?(b=c.hsl2rgb(a),a.r=b.r,a.g=b.g,a.b=b.b,a.opacity=1,a.hex=b.hex):(e(a,"string")&&(a=c.getRGB(a)),e(a,"object")&&"r"in a&&"g"in a&&"b"in a&&!("error"in a)?(b=c.rgb2hsl(a),a.h=b.h,a.s=b.s,a.l=b.l,b=c.rgb2hsb(a),a.v=b.b):(a={hex:"none"},a.r=a.g=a.b=a.h=a.s=a.v=a.l=-1,a.error=1)),a.toString=Z,a},c.hsb2rgb=function(a,b,c,d){e(a,"object")&&"h"in a&&"s"in a&&"b"in a&&(c=a.b,b=a.s,d=a.o,a=a.h),a*=360;var f,g,h,i,j;return a=a%360/60,j=c*b,i=j*(1-G(a%2-1)),f=g=h=c-j,a=~~a,f+=[j,i,0,0,i,j][a],g+=[i,j,j,i,0,0][a],h+=[0,0,i,j,j,i][a],_(f,g,h,d)},c.hsl2rgb=function(a,b,c,d){e(a,"object")&&"h"in a&&"s"in a&&"l"in a&&(c=a.l,b=a.s,a=a.h),(a>1||b>1||c>1)&&(a/=360,b/=100,c/=100),a*=360;var f,g,h,i,j;return a=a%360/60,j=2*b*(.5>c?c:1-c),i=j*(1-G(a%2-1)),f=g=h=c-j/2,a=~~a,f+=[j,i,0,0,i,j][a],g+=[i,j,j,i,0,0][a],h+=[0,0,i,j,j,i][a],_(f,g,h,d)},c.rgb2hsb=function(a,b,c){c=$(a,b,c),a=c[0],b=c[1],c=c[2];var d,e,f,g;return f=E(a,b,c),g=f-F(a,b,c),d=0==g?null:f==a?(b-c)/g:f==b?(c-a)/g+2:(a-b)/g+4,d=(d+360)%6*60/360,e=0==g?0:g/f,{h:d,s:e,b:f,toString:X}},c.rgb2hsl=function(a,b,c){c=$(a,b,c),a=c[0],b=c[1],c=c[2];var d,e,f,g,h,i;return g=E(a,b,c),h=F(a,b,c),i=g-h,d=0==i?null:g==a?(b-c)/i:g==b?(c-a)/i+2:(a-b)/i+4,d=(d+360)%6*60/360,f=(g+h)/2,e=0==i?0:.5>f?i/(2*f):i/(2-2*f),{h:d,s:e,l:f,toString:Y}},c.parsePathString=function(a){if(!a)return null;var b=c.path(a);if(b.arr)return c.path.clone(b.arr);var d={a:7,c:6,o:2,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,u:3,z:0},f=[];return e(a,"array")&&e(a[0],"array")&&(f=c.path.clone(a)),f.length||A(a).replace(N,function(a,b,c){var e=[],g=b.toLowerCase();if(c.replace(P,function(a,b){b&&e.push(+b)}),"m"==g&&e.length>2&&(f.push([b].concat(e.splice(0,2))),g="l",b="m"==b?"l":"L"),"o"==g&&1==e.length&&f.push([b,e[0]]),"r"==g)f.push([b].concat(e));else for(;e.length>=d[g]&&(f.push([b].concat(e.splice(0,d[g]))),d[g]););}),f.toString=c.path.toString,b.arr=c.path.clone(f),f};var aa=c.parseTransformString=function(a){if(!a)return null;var b=[];return e(a,"array")&&e(a[0],"array")&&(b=c.path.clone(a)),b.length||A(a).replace(O,function(a,c,d){var e=[];c.toLowerCase();d.replace(P,function(a,b){b&&e.push(+b)}),b.push([c].concat(e))}),b.toString=c.path.toString,b};c._.svgTransform2string=m,c._.rgTransform=/^[a-z][\s]*-?\.?\d/i,c._.transform2matrix=n,c._unit2px=q;y.doc.contains||y.doc.compareDocumentPosition?function(a,b){var c=9==a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a==d||!(!d||1!=d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)for(;b;)if(b=b.parentNode,b==a)return!0;return!1};c._.getSomeDefs=o,c._.getSomeSVG=p,c.select=function(a){return a=A(a).replace(/([^\\]):/g,"$1\\:"),w(y.doc.querySelector(a))},c.selectAll=function(a){for(var b=y.doc.querySelectorAll(a),d=(c.set||Array)(),e=0;ei;i++)h[g[i].nodeName]=g[i].nodeValue;return h}if(e(a,"string")){if(!(arguments.length>1))return b("snap.util.getattr."+a,d).firstDefined();var k={};k[a]=c,a=k}for(var l in a)a[z](l)&&b("snap.util.attr."+l,d,a[l]);return d},c.parse=function(a){var b=y.doc.createDocumentFragment(),c=!0,d=y.doc.createElement("div");if(a=A(a),a.match(/^\s*<\s*svg(?:\s|>)/)||(a=""+a+" ",c=!1),d.innerHTML=a,a=d.getElementsByTagName("svg")[0])if(c)b=a;else for(;a.firstChild;)b.appendChild(a.firstChild);return new t(b)},c.fragment=function(){for(var a=Array.prototype.slice.call(arguments,0),b=y.doc.createDocumentFragment(),d=0,e=a.length;e>d;d++){var f=a[d];f.node&&f.node.nodeType&&b.appendChild(f.node),f.nodeType&&b.appendChild(f),"string"==typeof f&&b.appendChild(c.parse(f).node)}return new t(b)},c._.make=u,c._.wrap=w,v.prototype.el=function(a,b){var c=u(a,this.node);return b&&c.attr(b),c},s.prototype.children=function(){for(var a=[],b=this.node.childNodes,d=0,e=b.length;e>d;d++)a[d]=c(b[d]);return a},s.prototype.toJSON=function(){var a=[];return x([this],a),a[0]},b.on("snap.util.getattr",function(){var a=b.nt();a=a.substring(a.lastIndexOf(".")+1);var c=a.replace(/[A-Z]/g,function(a){return"-"+a.toLowerCase()});return ba[z](c)?this.node.ownerDocument.defaultView.getComputedStyle(this.node,null).getPropertyValue(c):d(this.node,a)});var ba={"alignment-baseline":0,"baseline-shift":0,clip:0,"clip-path":0,"clip-rule":0,color:0,"color-interpolation":0,"color-interpolation-filters":0,"color-profile":0,"color-rendering":0,cursor:0,direction:0,display:0,"dominant-baseline":0,"enable-background":0,fill:0,"fill-opacity":0,"fill-rule":0,filter:0,"flood-color":0,"flood-opacity":0,font:0,"font-family":0,"font-size":0,"font-size-adjust":0,"font-stretch":0,"font-style":0,"font-variant":0,"font-weight":0,"glyph-orientation-horizontal":0,"glyph-orientation-vertical":0,"image-rendering":0,kerning:0,"letter-spacing":0,"lighting-color":0,marker:0,"marker-end":0,"marker-mid":0,"marker-start":0,mask:0,opacity:0,overflow:0,"pointer-events":0,"shape-rendering":0,"stop-color":0,"stop-opacity":0,stroke:0,"stroke-dasharray":0,"stroke-dashoffset":0,"stroke-linecap":0,"stroke-linejoin":0,"stroke-miterlimit":0,"stroke-opacity":0,"stroke-width":0,"text-anchor":0,"text-decoration":0,"text-rendering":0,"unicode-bidi":0,visibility:0,"word-spacing":0,"writing-mode":0};b.on("snap.util.attr",function(a){var c=b.nt(),e={};c=c.substring(c.lastIndexOf(".")+1),e[c]=a;var f=c.replace(/-(\w)/gi,function(a,b){return b.toUpperCase()}),g=c.replace(/[A-Z]/g,function(a){return"-"+a.toLowerCase()});ba[z](g)?this.node.style[f]=null==a?I:a:d(this.node,e)}),function(a){}(v.prototype),c.ajax=function(a,c,d,f){var g=new XMLHttpRequest,h=S();if(g){if(e(c,"function"))f=d,d=c,c=null;else if(e(c,"object")){var i=[];for(var j in c)c.hasOwnProperty(j)&&i.push(encodeURIComponent(j)+"="+encodeURIComponent(c[j]));c=i.join("&")}return g.open(c?"POST":"GET",a,!0),c&&(g.setRequestHeader("X-Requested-With","XMLHttpRequest"),g.setRequestHeader("Content-type","application/x-www-form-urlencoded")),d&&(b.once("snap.ajax."+h+".0",d),b.once("snap.ajax."+h+".200",d),b.once("snap.ajax."+h+".304",d)),g.onreadystatechange=function(){4==g.readyState&&b("snap.ajax."+h+"."+g.status,f,g)},4==g.readyState?g:(g.send(c),g)}},c.load=function(a,b,d){c.ajax(a,function(a){var e=c.parse(a.responseText);d?b.call(d,e):b(e)})};var ca=function(a){var b=a.getBoundingClientRect(),c=a.ownerDocument,d=c.body,e=c.documentElement,f=e.clientTop||d.clientTop||0,h=e.clientLeft||d.clientLeft||0,i=b.top+(g.win.pageYOffset||e.scrollTop||d.scrollTop)-f,j=b.left+(g.win.pageXOffset||e.scrollLeft||d.scrollLeft)-h;return{y:i,x:j}};return c.getElementByPoint=function(a,b){var c=this,d=(c.canvas,y.doc.elementFromPoint(a,b));if(y.win.opera&&"svg"==d.tagName){var e=ca(d),f=d.createSVGRect();f.x=a-e.x,f.y=b-e.y,f.width=f.height=1;var g=d.getIntersectionList(f,null);g.length&&(d=g[g.length-1])}return d?w(d):null},c.plugin=function(a){a(c,s,v,y,t)},y.win.Snap=c,c}(a||this);return d.plugin(function(c,d,e,f,g){function h(a,b){if(null==b){var d=!0;if(b="linearGradient"==a.type||"radialGradient"==a.type?a.node.getAttribute("gradientTransform"):"pattern"==a.type?a.node.getAttribute("patternTransform"):a.node.getAttribute("transform"),!b)return new c.Matrix;b=c._.svgTransform2string(b)}else b=c._.rgTransform.test(b)?m(b).replace(/\.{3}|\u2026/g,a._.transform||""):c._.svgTransform2string(b),l(b,"array")&&(b=c.path?c.path.toString.call(b):m(b)),a._.transform=b;var e=c._.transform2matrix(b,a.getBBox(1));return d?e:void(a.matrix=e)}function i(a){function b(a,b){var d=o(a.node,b);d=d&&d.match(g),d=d&&d[2],d&&"#"==d.charAt()&&(d=d.substring(1),d&&(i[d]=(i[d]||[]).concat(function(d){var e={};e[b]=c.url(d),o(a.node,e)})))}function d(a){var b=o(a.node,"xlink:href");b&&"#"==b.charAt()&&(b=b.substring(1),b&&(i[b]=(i[b]||[]).concat(function(b){a.attr("xlink:href","#"+b)})))}for(var e,f=a.selectAll("*"),g=/^\s*url\(("|'|)(.*)\1\)\s*$/,h=[],i={},j=0,k=f.length;k>j;j++){e=f[j],b(e,"fill"),b(e,"stroke"),b(e,"filter"),b(e,"mask"),b(e,"clip-path"),d(e);var l=o(e.node,"id");l&&(o(e.node,{id:e.id}),h.push({old:l,id:e.id}))}for(j=0,k=h.length;k>j;j++){var m=i[h[j].old];if(m)for(var n=0,p=m.length;p>n;n++)m[n](h[j].id)}}function j(a){return function(){var b=a?"<"+this.type:"",c=this.node.attributes,d=this.node.childNodes;if(a)for(var e=0,f=c.length;f>e;e++)b+=" "+c[e].name+'="'+c[e].value.replace(/"/g,'\\"')+'"';if(d.length){for(a&&(b+=">"),e=0,f=d.length;f>e;e++)3==d[e].nodeType?b+=d[e].nodeValue:1==d[e].nodeType&&(b+=s(d[e]).toString());a&&(b+="")}else a&&(b+="/>");return b}}var k=d.prototype,l=c.is,m=String,n=c._unit2px,o=c._.$,p=c._.make,q=c._.getSomeDefs,r="hasOwnProperty",s=c._.wrap;k.getBBox=function(a){if("tspan"==this.type)return c._.box(this.node.getClientRects().item(0));if(!c.Matrix||!c.path)return this.node.getBBox();var b=this,d=new c.Matrix;if(b.removed)return c._.box();for(;"use"==b.type;)if(a||(d=d.add(b.transform().localMatrix.translate(b.attr("x")||0,b.attr("y")||0))),b.original)b=b.original;else{var e=b.attr("xlink:href");b=b.original=b.node.ownerDocument.getElementById(e.substring(e.indexOf("#")+1))}var f=b._,g=c.path.get[b.type]||c.path.get.deflt;try{return a?(f.bboxwt=g?c.path.getBBox(b.realPath=g(b)):c._.box(b.node.getBBox()),c._.box(f.bboxwt)):(b.realPath=g(b),b.matrix=b.transform().localMatrix,f.bbox=c.path.getBBox(c.path.map(b.realPath,d.add(b.matrix))),c._.box(f.bbox))}catch(h){return c._.box()}};var t=function(){return this.string};k.transform=function(a){var b=this._;if(null==a){for(var d,e=this,f=new c.Matrix(this.node.getCTM()),g=h(this),i=[g],j=new c.Matrix,k=g.toTransformString(),l=m(g)==m(this.matrix)?m(b.transform):k;"svg"!=e.type&&(e=e.parent());)i.push(h(e));for(d=i.length;d--;)j.add(i[d]);return{string:l,globalMatrix:f,totalMatrix:j,localMatrix:g,diffMatrix:f.clone().add(g.invert()),global:f.toTransformString(),total:j.toTransformString(),local:k,toString:t}}return a instanceof c.Matrix?(this.matrix=a,this._.transform=a.toTransformString()):h(this,a),this.node&&("linearGradient"==this.type||"radialGradient"==this.type?o(this.node,{gradientTransform:this.matrix}):"pattern"==this.type?o(this.node,{patternTransform:this.matrix}):o(this.node,{transform:this.matrix})),this},k.parent=function(){return s(this.node.parentNode)},k.append=k.add=function(a){if(a){if("set"==a.type){var b=this;return a.forEach(function(a){b.add(a)}),this}a=s(a),this.node.appendChild(a.node),a.paper=this.paper}return this},k.appendTo=function(a){return a&&(a=s(a),a.append(this)),this},k.prepend=function(a){if(a){if("set"==a.type){var b,c=this;return a.forEach(function(a){b?b.after(a):c.prepend(a),b=a}),this}a=s(a);var d=a.parent();this.node.insertBefore(a.node,this.node.firstChild),this.add&&this.add(),a.paper=this.paper,this.parent()&&this.parent().add(),d&&d.add()}return this},k.prependTo=function(a){return a=s(a),a.prepend(this),this},k.before=function(a){if("set"==a.type){var b=this;return a.forEach(function(a){var c=a.parent();b.node.parentNode.insertBefore(a.node,b.node),c&&c.add()}),this.parent().add(),this}a=s(a);var c=a.parent();return this.node.parentNode.insertBefore(a.node,this.node),this.parent()&&this.parent().add(),c&&c.add(),a.paper=this.paper,this},k.after=function(a){a=s(a);var b=a.parent();return this.node.nextSibling?this.node.parentNode.insertBefore(a.node,this.node.nextSibling):this.node.parentNode.appendChild(a.node),this.parent()&&this.parent().add(),b&&b.add(),a.paper=this.paper,this},k.insertBefore=function(a){a=s(a);var b=this.parent();return a.node.parentNode.insertBefore(this.node,a.node),this.paper=a.paper,b&&b.add(),a.parent()&&a.parent().add(),this},k.insertAfter=function(a){a=s(a);var b=this.parent();return a.node.parentNode.insertBefore(this.node,a.node.nextSibling),this.paper=a.paper,b&&b.add(),a.parent()&&a.parent().add(),this},k.remove=function(){var a=this.parent();return this.node.parentNode&&this.node.parentNode.removeChild(this.node),delete this.paper,this.removed=!0,a&&a.add(),this},k.select=function(a){return s(this.node.querySelector(a))},k.selectAll=function(a){for(var b=this.node.querySelectorAll(a),d=(c.set||Array)(),e=0;e{contents}',{x:+b.x.toFixed(3),y:+b.y.toFixed(3),width:+b.width.toFixed(3),height:+b.height.toFixed(3),
+contents:this.outerSVG()});return"data:image/svg+xml;base64,"+btoa(unescape(encodeURIComponent(d)))}},g.prototype.select=k.select,g.prototype.selectAll=k.selectAll}),d.plugin(function(a,d,e,f,g){function h(a,b,c){return function(d){var e=d.slice(a,b);return 1==e.length&&(e=e[0]),c?c(e):e}}var i=d.prototype,j=a.is,k=String,l="hasOwnProperty",m=function(a,b,d,e){"function"!=typeof d||d.length||(e=d,d=c.linear),this.attr=a,this.dur=b,d&&(this.easing=d),e&&(this.callback=e)};a._.Animation=m,a.animation=function(a,b,c,d){return new m(a,b,c,d)},i.inAnim=function(){var a=this,b=[];for(var c in a.anims)a.anims[l](c)&&!function(a){b.push({anim:new m(a._attrs,a.dur,a.easing,a._callback),mina:a,curStatus:a.status(),status:function(b){return a.status(b)},stop:function(){a.stop()}})}(a.anims[c]);return b},a.animate=function(a,d,e,f,g,h){"function"!=typeof g||g.length||(h=g,g=c.linear);var i=c.time(),j=c(a,d,i,i+f,c.time,e,g);return h&&b.once("mina.finish."+j.id,h),j},i.stop=function(){for(var a=this.inAnim(),b=0,c=a.length;c>b;b++)a[b].stop();return this},i.animate=function(a,d,e,f){"function"!=typeof e||e.length||(f=e,e=c.linear),a instanceof m&&(f=a.callback,e=a.easing,d=a.dur,a=a.attr);var g,i,n,o,p=[],q=[],r={},s=this;for(var t in a)if(a[l](t)){s.equal?(o=s.equal(t,k(a[t])),g=o.from,i=o.to,n=o.f):(g=+s.attr(t),i=+a[t]);var u=j(g,"array")?g.length:1;r[t]=h(p.length,p.length+u,n),p=p.concat(g),q=q.concat(i)}var v=c.time(),w=c(p,q,v,v+d,c.time,function(a){var b={};for(var c in r)r[l](c)&&(b[c]=r[c](a));s.attr(b)},e);return s.anims[w.id]=w,w._attrs=a,w._callback=f,b("snap.animcreated."+s.id,w),b.once("mina.finish."+w.id,function(){b.off("mina.*."+w.id),delete s.anims[w.id],f&&f.call(s)}),b.once("mina.stop."+w.id,function(){b.off("mina.*."+w.id),delete s.anims[w.id]}),s}}),d.plugin(function(a,b,c,d,e){function f(a,b,c,d,e,f){return null==b&&"[object SVGMatrix]"==g.call(a)?(this.a=a.a,this.b=a.b,this.c=a.c,this.d=a.d,this.e=a.e,void(this.f=a.f)):void(null!=a?(this.a=+a,this.b=+b,this.c=+c,this.d=+d,this.e=+e,this.f=+f):(this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0))}var g=Object.prototype.toString,h=String,i=Math,j="";!function(b){function c(a){return a[0]*a[0]+a[1]*a[1]}function d(a){var b=i.sqrt(c(a));a[0]&&(a[0]/=b),a[1]&&(a[1]/=b)}b.add=function(a,b,c,d,e,g){if(a&&a instanceof f)return this.add(a.a,a.b,a.c,a.d,a.e,a.f);var h=a*this.a+b*this.c,i=a*this.b+b*this.d;return this.e+=e*this.a+g*this.c,this.f+=e*this.b+g*this.d,this.c=c*this.a+d*this.c,this.d=c*this.b+d*this.d,this.a=h,this.b=i,this},f.prototype.multLeft=function(a,b,c,d,e,g){if(a&&a instanceof f)return this.multLeft(a.a,a.b,a.c,a.d,a.e,a.f);var h=a*this.a+c*this.b,i=a*this.c+c*this.d,j=a*this.e+c*this.f+e;return this.b=b*this.a+d*this.b,this.d=b*this.c+d*this.d,this.f=b*this.e+d*this.f+g,this.a=h,this.c=i,this.e=j,this},b.invert=function(){var a=this,b=a.a*a.d-a.b*a.c;return new f(a.d/b,-a.b/b,-a.c/b,a.a/b,(a.c*a.f-a.d*a.e)/b,(a.b*a.e-a.a*a.f)/b)},b.clone=function(){return new f(this.a,this.b,this.c,this.d,this.e,this.f)},b.translate=function(a,b){return this.e+=a*this.a+b*this.c,this.f+=a*this.b+b*this.d,this},b.scale=function(a,b,c,d){return null==b&&(b=a),(c||d)&&this.translate(c,d),this.a*=a,this.b*=a,this.c*=b,this.d*=b,(c||d)&&this.translate(-c,-d),this},b.rotate=function(b,c,d){b=a.rad(b),c=c||0,d=d||0;var e=+i.cos(b).toFixed(9),f=+i.sin(b).toFixed(9);return this.add(e,f,-f,e,c,d),this.add(1,0,0,1,-c,-d)},b.skewX=function(a){return this.skew(a,0)},b.skewY=function(a){return this.skew(0,a)},b.skew=function(b,c){b=b||0,c=c||0,b=a.rad(b),c=a.rad(c);var d=i.tan(b).toFixed(9),e=i.tan(c).toFixed(9);return this.add(1,e,d,1,0,0)},b.x=function(a,b){return a*this.a+b*this.c+this.e},b.y=function(a,b){return a*this.b+b*this.d+this.f},b.get=function(a){return+this[h.fromCharCode(97+a)].toFixed(4)},b.toString=function(){return"matrix("+[this.get(0),this.get(1),this.get(2),this.get(3),this.get(4),this.get(5)].join()+")"},b.offset=function(){return[this.e.toFixed(4),this.f.toFixed(4)]},b.determinant=function(){return this.a*this.d-this.b*this.c},b.split=function(){var b={};b.dx=this.e,b.dy=this.f;var e=[[this.a,this.b],[this.c,this.d]];b.scalex=i.sqrt(c(e[0])),d(e[0]),b.shear=e[0][0]*e[1][0]+e[0][1]*e[1][1],e[1]=[e[1][0]-e[0][0]*b.shear,e[1][1]-e[0][1]*b.shear],b.scaley=i.sqrt(c(e[1])),d(e[1]),b.shear/=b.scaley,this.determinant()<0&&(b.scalex=-b.scalex);var f=e[0][1],g=e[1][1];return 0>g?(b.rotate=a.deg(i.acos(g)),0>f&&(b.rotate=360-b.rotate)):b.rotate=a.deg(i.asin(f)),b.isSimple=!(+b.shear.toFixed(9)||b.scalex.toFixed(9)!=b.scaley.toFixed(9)&&b.rotate),b.isSuperSimple=!+b.shear.toFixed(9)&&b.scalex.toFixed(9)==b.scaley.toFixed(9)&&!b.rotate,b.noRotation=!+b.shear.toFixed(9)&&!b.rotate,b},b.toTransformString=function(a){var b=a||this.split();return+b.shear.toFixed(9)?"m"+[this.get(0),this.get(1),this.get(2),this.get(3),this.get(4),this.get(5)]:(b.scalex=+b.scalex.toFixed(4),b.scaley=+b.scaley.toFixed(4),b.rotate=+b.rotate.toFixed(4),(b.dx||b.dy?"t"+[+b.dx.toFixed(4),+b.dy.toFixed(4)]:j)+(b.rotate?"r"+[+b.rotate.toFixed(4),0,0]:j)+(1!=b.scalex||1!=b.scaley?"s"+[b.scalex,b.scaley,0,0]:j))}}(f.prototype),a.Matrix=f,a.matrix=function(a,b,c,d,e,g){return new f(a,b,c,d,e,g)}}),d.plugin(function(a,c,d,e,f){function g(d){return function(e){if(b.stop(),e instanceof f&&1==e.node.childNodes.length&&("radialGradient"==e.node.firstChild.tagName||"linearGradient"==e.node.firstChild.tagName||"pattern"==e.node.firstChild.tagName)&&(e=e.node.firstChild,n(this).appendChild(e),e=l(e)),e instanceof c)if("radialGradient"==e.type||"linearGradient"==e.type||"pattern"==e.type){e.node.id||p(e.node,{id:e.id});var g=q(e.node.id)}else g=e.attr(d);else if(g=a.color(e),g.error){var h=a(n(this).ownerSVGElement).gradient(e);h?(h.node.id||p(h.node,{id:h.id}),g=q(h.node.id)):g=e}else g=r(g);var i={};i[d]=g,p(this.node,i),this.node.style[d]=t}}function h(a){b.stop(),a==+a&&(a+="px"),this.node.style.fontSize=a}function i(a){for(var b=[],c=a.childNodes,d=0,e=c.length;e>d;d++){var f=c[d];3==f.nodeType&&b.push(f.nodeValue),"tspan"==f.tagName&&(1==f.childNodes.length&&3==f.firstChild.nodeType?b.push(f.firstChild.nodeValue):b.push(i(f)))}return b}function j(){return b.stop(),this.node.style.fontSize}var k=a._.make,l=a._.wrap,m=a.is,n=a._.getSomeDefs,o=/^url\((['"]?)([^)]+)\1\)$/,p=a._.$,q=a.url,r=String,s=a._.separator,t="";a.deurl=function(a){var b=String(a).match(o);return b?b[2]:a},b.on("snap.util.attr.mask",function(a){if(a instanceof c||a instanceof f){if(b.stop(),a instanceof f&&1==a.node.childNodes.length&&(a=a.node.firstChild,n(this).appendChild(a),a=l(a)),"mask"==a.type)var d=a;else d=k("mask",n(this)),d.node.appendChild(a.node);!d.node.id&&p(d.node,{id:d.id}),p(this.node,{mask:q(d.id)})}}),function(a){b.on("snap.util.attr.clip",a),b.on("snap.util.attr.clip-path",a),b.on("snap.util.attr.clipPath",a)}(function(a){if(a instanceof c||a instanceof f){b.stop();for(var d,e=a.node;e;){if("clipPath"===e.nodeName){d=new c(e);break}if("svg"===e.nodeName){d=void 0;break}e=e.parentNode}d||(d=k("clipPath",n(this)),d.node.appendChild(a.node),!d.node.id&&p(d.node,{id:d.id})),p(this.node,{"clip-path":q(d.node.id||d.id)})}}),b.on("snap.util.attr.fill",g("fill")),b.on("snap.util.attr.stroke",g("stroke"));var u=/^([lr])(?:\(([^)]*)\))?(.*)$/i;b.on("snap.util.grad.parse",function(a){function b(a,b){for(var c=(b-h)/(a-i),d=i;a>d;d++)f[d].offset=+(+h+c*(d-i)).toFixed(2);i=a,h=b}a=r(a);var c=a.match(u);if(!c)return null;var d=c[1],e=c[2],f=c[3];e=e.split(/\s*,\s*/).map(function(a){return+a==a?+a:a}),1==e.length&&0==e[0]&&(e=[]),f=f.split("-"),f=f.map(function(a){a=a.split(":");var b={color:a[0]};return a[1]&&(b.offset=parseFloat(a[1])),b});var g=f.length,h=0,i=0;g--;for(var j=0;g>j;j++)"offset"in f[j]&&b(j,f[j].offset);return f[g].offset=f[g].offset||100,b(g,f[g].offset),{type:d,params:e,stops:f}}),b.on("snap.util.attr.d",function(c){b.stop(),m(c,"array")&&m(c[0],"array")&&(c=a.path.toString.call(c)),c=r(c),c.match(/[ruo]/i)&&(c=a.path.toAbsolute(c)),p(this.node,{d:c})})(-1),b.on("snap.util.attr.#text",function(a){b.stop(),a=r(a);for(var c=e.doc.createTextNode(a);this.node.firstChild;)this.node.removeChild(this.node.firstChild);this.node.appendChild(c)})(-1),b.on("snap.util.attr.path",function(a){b.stop(),this.attr({d:a})})(-1),b.on("snap.util.attr.class",function(a){b.stop(),this.node.className.baseVal=a})(-1),b.on("snap.util.attr.viewBox",function(a){var c;c=m(a,"object")&&"x"in a?[a.x,a.y,a.width,a.height].join(" "):m(a,"array")?a.join(" "):a,p(this.node,{viewBox:c}),b.stop()})(-1),b.on("snap.util.attr.transform",function(a){this.transform(a),b.stop()})(-1),b.on("snap.util.attr.r",function(a){"rect"==this.type&&(b.stop(),p(this.node,{rx:a,ry:a}))})(-1),b.on("snap.util.attr.textpath",function(a){if(b.stop(),"text"==this.type){var d,e,f;if(!a&&this.textPath){for(e=this.textPath;e.node.firstChild;)this.node.appendChild(e.node.firstChild);return e.remove(),void delete this.textPath}if(m(a,"string")){var g=n(this),h=l(g.parentNode).path(a);g.appendChild(h.node),d=h.id,h.attr({id:d})}else a=l(a),a instanceof c&&(d=a.attr("id"),d||(d=a.id,a.attr({id:d})));if(d)if(e=this.textPath,f=this.node,e)e.attr({"xlink:href":"#"+d});else{for(e=p("textPath",{"xlink:href":"#"+d});f.firstChild;)e.appendChild(f.firstChild);f.appendChild(e),this.textPath=l(e)}}})(-1),b.on("snap.util.attr.text",function(a){if("text"==this.type){for(var c=this.node,d=function(a){var b=p("tspan");if(m(a,"array"))for(var c=0;c1&&(a=Array.prototype.slice.call(arguments,0));var b={};return i(a,"object")&&!i(a,"array")?b=a:null!=a&&(b={points:a}),this.el("polyline",b)},h.polygon=function(a){arguments.length>1&&(a=Array.prototype.slice.call(arguments,0));var b={};return i(a,"object")&&!i(a,"array")?b=a:null!=a&&(b={points:a}),this.el("polygon",b)},function(){function d(){return this.selectAll("stop")}function e(a,b){var d=l("stop"),e={offset:+b+"%"};a=c.color(a),e["stop-color"]=a.hex,a.opacity<1&&(e["stop-opacity"]=a.opacity),l(d,e);for(var f,g=this.stops(),h=0;hb){this.node.insertBefore(d,g[h].node),f=!0;break}}return f||this.node.appendChild(d),this}function f(){if("linearGradient"==this.type){var a=l(this.node,"x1")||0,b=l(this.node,"x2")||1,d=l(this.node,"y1")||0,e=l(this.node,"y2")||0;return c._.box(a,d,math.abs(b-a),math.abs(e-d))}var f=this.node.cx||.5,g=this.node.cy||.5,h=this.node.r||0;return c._.box(f-h,g-h,2*h,2*h)}function g(a){var d=a,e=this.stops();if("string"==typeof a&&(d=b("snap.util.grad.parse",null,"l(0,0,0,1)"+a).firstDefined().stops),c.is(d,"array")){for(var f=0;fh;h++){var i=f[h];d.addStop(i.color,i.offset)}return d}function j(a,b,h,i,j){var k=c._.make("linearGradient",a);return k.stops=d,k.addStop=e,k.getBBox=f,k.setStops=g,null!=b&&l(k.node,{x1:b,y1:h,x2:i,y2:j}),k}function k(a,b,g,h,i,j){var k=c._.make("radialGradient",a);return k.stops=d,k.addStop=e,k.getBBox=f,null!=b&&l(k.node,{cx:b,cy:g,r:h}),null!=i&&null!=j&&l(k.node,{fx:i,fy:j}),k}var l=c._.$;h.gradient=function(a){return i(this.defs,a)},h.gradientLinear=function(a,b,c,d){return j(this.defs,a,b,c,d)},h.gradientRadial=function(a,b,c,d,e){return k(this.defs,a,b,c,d,e)},h.toString=function(){var a,b=this.node.ownerDocument,d=b.createDocumentFragment(),e=b.createElement("div"),f=this.node.cloneNode(!0);return d.appendChild(e),e.appendChild(f),c._.$(f,{xmlns:"http://www.w3.org/2000/svg"}),a=e.innerHTML,d.removeChild(d.firstChild),a},h.toDataURL=function(){return a&&a.btoa?"data:image/svg+xml;base64,"+btoa(unescape(encodeURIComponent(this))):void 0},h.clear=function(){for(var a,b=this.node.firstChild;b;)a=b.nextSibling,"defs"!=b.tagName?b.parentNode.removeChild(b):h.clear.call({node:b}),b=a}}()}),d.plugin(function(a,b,c,d){function e(a){var b=e.ps=e.ps||{};return b[a]?b[a].sleep=100:b[a]={sleep:100},setTimeout(function(){for(var c in b)b[M](c)&&c!=a&&(b[c].sleep--,!b[c].sleep&&delete b[c])}),b[a]}function f(a,b,c,d){return null==a&&(a=b=c=d=0),null==b&&(b=a.y,c=a.width,d=a.height,a=a.x),{x:a,y:b,width:c,w:c,height:d,h:d,x2:a+c,y2:b+d,cx:a+c/2,cy:b+d/2,r1:P.min(c,d)/2,r2:P.max(c,d)/2,r0:P.sqrt(c*c+d*d)/2,path:y(a,b,c,d),vb:[a,b,c,d].join(" ")}}function g(){return this.join(",").replace(N,"$1")}function h(a){var b=L(a);return b.toString=g,b}function i(a,b,c,d,e,f,g,h,i){return null==i?p(a,b,c,d,e,f,g,h):k(a,b,c,d,e,f,g,h,q(a,b,c,d,e,f,g,h,i))}function j(c,d){function e(a){return+(+a).toFixed(3)}return a._.cacher(function(a,f,g){a instanceof b&&(a=a.attr("d")),a=G(a);for(var h,j,l,m,n,o="",p={},q=0,r=0,s=a.length;s>r;r++){if(l=a[r],"M"==l[0])h=+l[1],j=+l[2];else{if(m=i(h,j,l[1],l[2],l[3],l[4],l[5],l[6]),q+m>f){if(d&&!p.start){if(n=i(h,j,l[1],l[2],l[3],l[4],l[5],l[6],f-q),o+=["C"+e(n.start.x),e(n.start.y),e(n.m.x),e(n.m.y),e(n.x),e(n.y)],g)return o;p.start=o,o=["M"+e(n.x),e(n.y)+"C"+e(n.n.x),e(n.n.y),e(n.end.x),e(n.end.y),e(l[5]),e(l[6])].join(),q+=m,h=+l[5],j=+l[6];continue}if(!c&&!d)return n=i(h,j,l[1],l[2],l[3],l[4],l[5],l[6],f-q)}q+=m,h=+l[5],j=+l[6]}o+=l.shift()+l}return p.end=o,n=c?q:d?p:k(h,j,l[0],l[1],l[2],l[3],l[4],l[5],1)},null,a._.clone)}function k(a,b,c,d,e,f,g,h,i){var j=1-i,k=T(j,3),l=T(j,2),m=i*i,n=m*i,o=k*a+3*l*i*c+3*j*i*i*e+n*g,p=k*b+3*l*i*d+3*j*i*i*f+n*h,q=a+2*i*(c-a)+m*(e-2*c+a),r=b+2*i*(d-b)+m*(f-2*d+b),s=c+2*i*(e-c)+m*(g-2*e+c),t=d+2*i*(f-d)+m*(h-2*f+d),u=j*a+i*c,v=j*b+i*d,w=j*e+i*g,x=j*f+i*h,y=90-180*P.atan2(q-s,r-t)/Q;return{x:o,y:p,m:{x:q,y:r},n:{x:s,y:t},start:{x:u,y:v},end:{x:w,y:x},alpha:y}}function l(b,c,d,e,g,h,i,j){a.is(b,"array")||(b=[b,c,d,e,g,h,i,j]);var k=F.apply(null,b);return f(k.min.x,k.min.y,k.max.x-k.min.x,k.max.y-k.min.y)}function m(a,b,c){return b>=a.x&&b<=a.x+a.width&&c>=a.y&&c<=a.y+a.height}function n(a,b){return a=f(a),b=f(b),m(b,a.x,a.y)||m(b,a.x2,a.y)||m(b,a.x,a.y2)||m(b,a.x2,a.y2)||m(a,b.x,b.y)||m(a,b.x2,b.y)||m(a,b.x,b.y2)||m(a,b.x2,b.y2)||(a.xb.x||b.xa.x)&&(a.yb.y||b.ya.y)}function o(a,b,c,d,e){var f=-3*b+9*c-9*d+3*e,g=a*f+6*b-12*c+6*d;return a*g-3*b+3*c}function p(a,b,c,d,e,f,g,h,i){null==i&&(i=1),i=i>1?1:0>i?0:i;for(var j=i/2,k=12,l=[-.1252,.1252,-.3678,.3678,-.5873,.5873,-.7699,.7699,-.9041,.9041,-.9816,.9816],m=[.2491,.2491,.2335,.2335,.2032,.2032,.1601,.1601,.1069,.1069,.0472,.0472],n=0,p=0;k>p;p++){var q=j*l[p]+j,r=o(q,a,c,e,g),s=o(q,b,d,f,h),t=r*r+s*s;n+=m[p]*P.sqrt(t)}return j*n}function q(a,b,c,d,e,f,g,h,i){if(!(0>i||p(a,b,c,d,e,f,g,h)n;)l/=2,m+=(i>j?1:-1)*l,j=p(a,b,c,d,e,f,g,h,m);return m}}function r(a,b,c,d,e,f,g,h){if(!(S(a,c)S(e,g)||S(b,d)S(f,h))){var i=(a*d-b*c)*(e-g)-(a-c)*(e*h-f*g),j=(a*d-b*c)*(f-h)-(b-d)*(e*h-f*g),k=(a-c)*(f-h)-(b-d)*(e-g);if(k){var l=i/k,m=j/k,n=+l.toFixed(2),o=+m.toFixed(2);if(!(n<+R(a,c).toFixed(2)||n>+S(a,c).toFixed(2)||n<+R(e,g).toFixed(2)||n>+S(e,g).toFixed(2)||o<+R(b,d).toFixed(2)||o>+S(b,d).toFixed(2)||o<+R(f,h).toFixed(2)||o>+S(f,h).toFixed(2)))return{x:l,y:m}}}}function s(a,b,c){var d=l(a),e=l(b);if(!n(d,e))return c?0:[];for(var f=p.apply(0,a),g=p.apply(0,b),h=~~(f/8),i=~~(g/8),j=[],m=[],o={},q=c?0:[],s=0;h+1>s;s++){var t=k.apply(0,a.concat(s/h));j.push({x:t.x,y:t.y,t:s/h})}for(s=0;i+1>s;s++)t=k.apply(0,b.concat(s/i)),m.push({x:t.x,y:t.y,t:s/i});for(s=0;h>s;s++)for(var u=0;i>u;u++){var v=j[s],w=j[s+1],x=m[u],y=m[u+1],z=U(w.x-v.x)<.001?"y":"x",A=U(y.x-x.x)<.001?"y":"x",B=r(v.x,v.y,w.x,w.y,x.x,x.y,y.x,y.y);if(B){if(o[B.x.toFixed(4)]==B.y.toFixed(4))continue;o[B.x.toFixed(4)]=B.y.toFixed(4);var C=v.t+U((B[z]-v[z])/(w[z]-v[z]))*(w.t-v.t),D=x.t+U((B[A]-x[A])/(y[A]-x[A]))*(y.t-x.t);C>=0&&1>=C&&D>=0&&1>=D&&(c?q++:q.push({x:B.x,y:B.y,t1:C,t2:D}))}}return q}function t(a,b){return v(a,b)}function u(a,b){return v(a,b,1)}function v(a,b,c){a=G(a),b=G(b);for(var d,e,f,g,h,i,j,k,l,m,n=c?0:[],o=0,p=a.length;p>o;o++){var q=a[o];if("M"==q[0])d=h=q[1],e=i=q[2];else{"C"==q[0]?(l=[d,e].concat(q.slice(1)),d=l[6],e=l[7]):(l=[d,e,d,e,h,i,h,i],d=h,e=i);for(var r=0,t=b.length;t>r;r++){var u=b[r];if("M"==u[0])f=j=u[1],g=k=u[2];else{"C"==u[0]?(m=[f,g].concat(u.slice(1)),f=m[6],g=m[7]):(m=[f,g,f,g,j,k,j,k],f=j,g=k);var v=s(l,m,c);if(c)n+=v;else{for(var w=0,x=v.length;x>w;w++)v[w].segment1=o,v[w].segment2=r,v[w].bez1=l,v[w].bez2=m;n=n.concat(v)}}}}}return n}function w(a,b,c){var d=x(a);return m(d,b,c)&&v(a,[["M",b,c],["H",d.x2+10]],1)%2==1}function x(a){var b=e(a);if(b.bbox)return L(b.bbox);if(!a)return f();a=G(a);for(var c,d=0,g=0,h=[],i=[],j=0,k=a.length;k>j;j++)if(c=a[j],"M"==c[0])d=c[1],g=c[2],h.push(d),i.push(g);else{var l=F(d,g,c[1],c[2],c[3],c[4],c[5],c[6]);h=h.concat(l.min.x,l.max.x),i=i.concat(l.min.y,l.max.y),d=c[5],g=c[6]}var m=R.apply(0,h),n=R.apply(0,i),o=S.apply(0,h),p=S.apply(0,i),q=f(m,n,o-m,p-n);return b.bbox=L(q),q}function y(a,b,c,d,e){if(e)return[["M",+a+ +e,b],["l",c-2*e,0],["a",e,e,0,0,1,e,e],["l",0,d-2*e],["a",e,e,0,0,1,-e,e],["l",2*e-c,0],["a",e,e,0,0,1,-e,-e],["l",0,2*e-d],["a",e,e,0,0,1,e,-e],["z"]];var f=[["M",a,b],["l",c,0],["l",0,d],["l",-c,0],["z"]];return f.toString=g,f}function z(a,b,c,d,e){if(null==e&&null==d&&(d=c),a=+a,b=+b,c=+c,d=+d,null!=e)var f=Math.PI/180,h=a+c*Math.cos(-d*f),i=a+c*Math.cos(-e*f),j=b+c*Math.sin(-d*f),k=b+c*Math.sin(-e*f),l=[["M",h,j],["A",c,c,0,+(e-d>180),0,i,k]];else l=[["M",a,b],["m",0,-d],["a",c,d,0,1,1,0,2*d],["a",c,d,0,1,1,0,-2*d],["z"]];return l.toString=g,l}function A(b){var c=e(b),d=String.prototype.toLowerCase;if(c.rel)return h(c.rel);a.is(b,"array")&&a.is(b&&b[0],"array")||(b=a.parsePathString(b));var f=[],i=0,j=0,k=0,l=0,m=0;"M"==b[0][0]&&(i=b[0][1],j=b[0][2],k=i,l=j,m++,f.push(["M",i,j]));for(var n=m,o=b.length;o>n;n++){var p=f[n]=[],q=b[n];if(q[0]!=d.call(q[0]))switch(p[0]=d.call(q[0]),p[0]){case"a":p[1]=q[1],p[2]=q[2],p[3]=q[3],p[4]=q[4],p[5]=q[5],p[6]=+(q[6]-i).toFixed(3),p[7]=+(q[7]-j).toFixed(3);break;case"v":p[1]=+(q[1]-j).toFixed(3);break;case"m":k=q[1],l=q[2];default:for(var r=1,s=q.length;s>r;r++)p[r]=+(q[r]-(r%2?i:j)).toFixed(3)}else{p=f[n]=[],"m"==q[0]&&(k=q[1]+i,l=q[2]+j);for(var t=0,u=q.length;u>t;t++)f[n][t]=q[t]}var v=f[n].length;switch(f[n][0]){case"z":i=k,j=l;break;case"h":i+=+f[n][v-1];break;case"v":j+=+f[n][v-1];break;default:i+=+f[n][v-2],j+=+f[n][v-1]}}return f.toString=g,c.rel=h(f),f}function B(b){var c=e(b);if(c.abs)return h(c.abs);if(K(b,"array")&&K(b&&b[0],"array")||(b=a.parsePathString(b)),!b||!b.length)return[["M",0,0]];var d,f=[],i=0,j=0,k=0,l=0,m=0;"M"==b[0][0]&&(i=+b[0][1],j=+b[0][2],k=i,l=j,m++,f[0]=["M",i,j]);for(var n,o,p=3==b.length&&"M"==b[0][0]&&"R"==b[1][0].toUpperCase()&&"Z"==b[2][0].toUpperCase(),q=m,r=b.length;r>q;q++){if(f.push(n=[]),o=b[q],d=o[0],d!=d.toUpperCase())switch(n[0]=d.toUpperCase(),n[0]){case"A":n[1]=o[1],n[2]=o[2],n[3]=o[3],n[4]=o[4],n[5]=o[5],n[6]=+o[6]+i,n[7]=+o[7]+j;break;case"V":n[1]=+o[1]+j;break;case"H":n[1]=+o[1]+i;break;case"R":for(var s=[i,j].concat(o.slice(1)),t=2,u=s.length;u>t;t++)s[t]=+s[t]+i,s[++t]=+s[t]+j;f.pop(),f=f.concat(I(s,p));break;case"O":f.pop(),s=z(i,j,o[1],o[2]),s.push(s[0]),f=f.concat(s);break;case"U":f.pop(),f=f.concat(z(i,j,o[1],o[2],o[3])),n=["U"].concat(f[f.length-1].slice(-2));break;case"M":k=+o[1]+i,l=+o[2]+j;default:for(t=1,u=o.length;u>t;t++)n[t]=+o[t]+(t%2?i:j)}else if("R"==d)s=[i,j].concat(o.slice(1)),f.pop(),f=f.concat(I(s,p)),n=["R"].concat(o.slice(-2));else if("O"==d)f.pop(),s=z(i,j,o[1],o[2]),s.push(s[0]),f=f.concat(s);else if("U"==d)f.pop(),f=f.concat(z(i,j,o[1],o[2],o[3])),n=["U"].concat(f[f.length-1].slice(-2));else for(var v=0,w=o.length;w>v;v++)n[v]=o[v];if(d=d.toUpperCase(),"O"!=d)switch(n[0]){case"Z":i=+k,j=+l;break;case"H":i=n[1];break;case"V":j=n[1];break;case"M":k=n[n.length-2],l=n[n.length-1];default:i=n[n.length-2],j=n[n.length-1]}}return f.toString=g,c.abs=h(f),f}function C(a,b,c,d){return[a,b,c,d,c,d]}function D(a,b,c,d,e,f){var g=1/3,h=2/3;return[g*a+h*c,g*b+h*d,g*e+h*c,g*f+h*d,e,f]}function E(b,c,d,e,f,g,h,i,j,k){var l,m=120*Q/180,n=Q/180*(+f||0),o=[],p=a._.cacher(function(a,b,c){var d=a*P.cos(c)-b*P.sin(c),e=a*P.sin(c)+b*P.cos(c);return{x:d,y:e}});if(!d||!e)return[b,c,i,j,i,j];if(k)y=k[0],z=k[1],w=k[2],x=k[3];else{l=p(b,c,-n),b=l.x,c=l.y,l=p(i,j,-n),i=l.x,j=l.y;var q=(P.cos(Q/180*f),P.sin(Q/180*f),(b-i)/2),r=(c-j)/2,s=q*q/(d*d)+r*r/(e*e);s>1&&(s=P.sqrt(s),d=s*d,e=s*e);var t=d*d,u=e*e,v=(g==h?-1:1)*P.sqrt(U((t*u-t*r*r-u*q*q)/(t*r*r+u*q*q))),w=v*d*r/e+(b+i)/2,x=v*-e*q/d+(c+j)/2,y=P.asin(((c-x)/e).toFixed(9)),z=P.asin(((j-x)/e).toFixed(9));y=w>b?Q-y:y,z=w>i?Q-z:z,0>y&&(y=2*Q+y),0>z&&(z=2*Q+z),h&&y>z&&(y-=2*Q),!h&&z>y&&(z-=2*Q)}var A=z-y;if(U(A)>m){var B=z,C=i,D=j;z=y+m*(h&&z>y?1:-1),i=w+d*P.cos(z),j=x+e*P.sin(z),o=E(i,j,d,e,f,0,h,C,D,[z,B,w,x])}A=z-y;var F=P.cos(y),G=P.sin(y),H=P.cos(z),I=P.sin(z),J=P.tan(A/4),K=4/3*d*J,L=4/3*e*J,M=[b,c],N=[b+K*G,c-L*F],O=[i+K*I,j-L*H],R=[i,j];if(N[0]=2*M[0]-N[0],N[1]=2*M[1]-N[1],k)return[N,O,R].concat(o);o=[N,O,R].concat(o).join().split(",");for(var S=[],T=0,V=o.length;V>T;T++)S[T]=T%2?p(o[T-1],o[T],n).y:p(o[T],o[T+1],n).x;return S}function F(a,b,c,d,e,f,g,h){for(var i,j,k,l,m,n,o,p,q=[],r=[[],[]],s=0;2>s;++s)if(0==s?(j=6*a-12*c+6*e,i=-3*a+9*c-9*e+3*g,k=3*c-3*a):(j=6*b-12*d+6*f,i=-3*b+9*d-9*f+3*h,k=3*d-3*b),U(i)<1e-12){if(U(j)<1e-12)continue;l=-k/j,l>0&&1>l&&q.push(l)}else o=j*j-4*k*i,p=P.sqrt(o),0>o||(m=(-j+p)/(2*i),m>0&&1>m&&q.push(m),n=(-j-p)/(2*i),n>0&&1>n&&q.push(n));for(var t,u=q.length,v=u;u--;)l=q[u],t=1-l,r[0][u]=t*t*t*a+3*t*t*l*c+3*t*l*l*e+l*l*l*g,r[1][u]=t*t*t*b+3*t*t*l*d+3*t*l*l*f+l*l*l*h;return r[0][v]=a,r[1][v]=b,r[0][v+1]=g,r[1][v+1]=h,r[0].length=r[1].length=v+2,{min:{x:R.apply(0,r[0]),y:R.apply(0,r[1])},max:{x:S.apply(0,r[0]),y:S.apply(0,r[1])}}}function G(a,b){var c=!b&&e(a);if(!b&&c.curve)return h(c.curve);for(var d=B(a),f=b&&B(b),g={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},i={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},j=(function(a,b,c){var d,e;if(!a)return["C",b.x,b.y,b.x,b.y,b.x,b.y];switch(!(a[0]in{T:1,Q:1})&&(b.qx=b.qy=null),a[0]){case"M":b.X=a[1],b.Y=a[2];break;case"A":a=["C"].concat(E.apply(0,[b.x,b.y].concat(a.slice(1))));break;case"S":"C"==c||"S"==c?(d=2*b.x-b.bx,e=2*b.y-b.by):(d=b.x,e=b.y),a=["C",d,e].concat(a.slice(1));break;case"T":"Q"==c||"T"==c?(b.qx=2*b.x-b.qx,b.qy=2*b.y-b.qy):(b.qx=b.x,b.qy=b.y),a=["C"].concat(D(b.x,b.y,b.qx,b.qy,a[1],a[2]));break;case"Q":b.qx=a[1],b.qy=a[2],a=["C"].concat(D(b.x,b.y,a[1],a[2],a[3],a[4]));break;case"L":a=["C"].concat(C(b.x,b.y,a[1],a[2]));break;case"H":a=["C"].concat(C(b.x,b.y,a[1],b.y));break;case"V":a=["C"].concat(C(b.x,b.y,b.x,a[1]));break;case"Z":a=["C"].concat(C(b.x,b.y,b.X,b.Y))}return a}),k=function(a,b){if(a[b].length>7){a[b].shift();for(var c=a[b];c.length;)m[b]="A",f&&(n[b]="A"),a.splice(b++,0,["C"].concat(c.splice(0,6)));a.splice(b,1),r=S(d.length,f&&f.length||0)}},l=function(a,b,c,e,g){a&&b&&"M"==a[g][0]&&"M"!=b[g][0]&&(b.splice(g,0,["M",e.x,e.y]),c.bx=0,c.by=0,c.x=a[g][1],c.y=a[g][2],r=S(d.length,f&&f.length||0))},m=[],n=[],o="",p="",q=0,r=S(d.length,f&&f.length||0);r>q;q++){d[q]&&(o=d[q][0]),"C"!=o&&(m[q]=o,q&&(p=m[q-1])),d[q]=j(d[q],g,p),"A"!=m[q]&&"C"==o&&(m[q]="C"),k(d,q),f&&(f[q]&&(o=f[q][0]),"C"!=o&&(n[q]=o,q&&(p=n[q-1])),f[q]=j(f[q],i,p),"A"!=n[q]&&"C"==o&&(n[q]="C"),k(f,q)),l(d,f,g,i,q),l(f,d,i,g,q);var s=d[q],t=f&&f[q],u=s.length,v=f&&t.length;g.x=s[u-2],g.y=s[u-1],g.bx=O(s[u-4])||g.x,g.by=O(s[u-3])||g.y,i.bx=f&&(O(t[v-4])||i.x),i.by=f&&(O(t[v-3])||i.y),i.x=f&&t[v-2],i.y=f&&t[v-1]}return f||(c.curve=h(d)),f?[d,f]:d}function H(a,b){if(!b)return a;var c,d,e,f,g,h,i;for(a=G(a),e=0,g=a.length;g>e;e++)for(i=a[e],f=1,h=i.length;h>f;f+=2)c=b.x(i[f],i[f+1]),d=b.y(i[f],i[f+1]),i[f]=c,i[f+1]=d;return a}function I(a,b){for(var c=[],d=0,e=a.length;e-2*!b>d;d+=2){var f=[{x:+a[d-2],y:+a[d-1]},{x:+a[d],y:+a[d+1]},{x:+a[d+2],y:+a[d+3]},{x:+a[d+4],y:+a[d+5]}];b?d?e-4==d?f[3]={x:+a[0],y:+a[1]}:e-2==d&&(f[2]={x:+a[0],y:+a[1]},f[3]={x:+a[2],y:+a[3]}):f[0]={x:+a[e-2],y:+a[e-1]}:e-4==d?f[3]=f[2]:d||(f[0]={x:+a[d],y:+a[d+1]}),c.push(["C",(-f[0].x+6*f[1].x+f[2].x)/6,(-f[0].y+6*f[1].y+f[2].y)/6,(f[1].x+6*f[2].x-f[3].x)/6,(f[1].y+6*f[2].y-f[3].y)/6,f[2].x,f[2].y])}return c}var J=b.prototype,K=a.is,L=a._.clone,M="hasOwnProperty",N=/,?([a-z]),?/gi,O=parseFloat,P=Math,Q=P.PI,R=P.min,S=P.max,T=P.pow,U=P.abs,V=j(1),W=j(),X=j(0,1),Y=a._unit2px,Z={path:function(a){return a.attr("path")},circle:function(a){var b=Y(a);return z(b.cx,b.cy,b.r)},ellipse:function(a){var b=Y(a);
+return z(b.cx||0,b.cy||0,b.rx,b.ry)},rect:function(a){var b=Y(a);return y(b.x||0,b.y||0,b.width,b.height,b.rx,b.ry)},image:function(a){var b=Y(a);return y(b.x||0,b.y||0,b.width,b.height)},line:function(a){return"M"+[a.attr("x1")||0,a.attr("y1")||0,a.attr("x2"),a.attr("y2")]},polyline:function(a){return"M"+a.attr("points")},polygon:function(a){return"M"+a.attr("points")+"z"},deflt:function(a){var b=a.node.getBBox();return y(b.x,b.y,b.width,b.height)}};a.path=e,a.path.getTotalLength=V,a.path.getPointAtLength=W,a.path.getSubpath=function(a,b,c){if(this.getTotalLength(a)-c<1e-6)return X(a,b).end;var d=X(a,c,1);return b?X(d,b).end:d},J.getTotalLength=function(){return this.node.getTotalLength?this.node.getTotalLength():void 0},J.getPointAtLength=function(a){return W(this.attr("d"),a)},J.getSubpath=function(b,c){return a.path.getSubpath(this.attr("d"),b,c)},a._.box=f,a.path.findDotsAtSegment=k,a.path.bezierBBox=l,a.path.isPointInsideBBox=m,a.closest=function(b,c,d,e){for(var g=100,h=f(b-g/2,c-g/2,g,g),i=[],j=d[0].hasOwnProperty("x")?function(a){return{x:d[a].x,y:d[a].y}}:function(a){return{x:d[a],y:e[a]}},k=0;1e6>=g&&!k;){for(var l=0,n=d.length;n>l;l++){var o=j(l);if(m(h,o.x,o.y)){k++,i.push(o);break}}k||(g*=2,h=f(b-g/2,c-g/2,g,g))}if(1e6!=g){var p,q=1/0;for(l=0,n=i.length;n>l;l++){var r=a.len(b,c,i[l].x,i[l].y);q>r&&(q=r,i[l].len=r,p=i[l])}return p}},a.path.isBBoxIntersect=n,a.path.intersection=t,a.path.intersectionNumber=u,a.path.isPointInside=w,a.path.getBBox=x,a.path.get=Z,a.path.toRelative=A,a.path.toAbsolute=B,a.path.toCubic=G,a.path.map=H,a.path.toString=g,a.path.clone=h}),d.plugin(function(a,d,e,f){var g=Math.max,h=Math.min,i=function(a){if(this.items=[],this.bindings={},this.length=0,this.type="set",a)for(var b=0,c=a.length;c>b;b++)a[b]&&(this[this.items.length]=this.items[this.items.length]=a[b],this.length++)},j=i.prototype;j.push=function(){for(var a,b,c=0,d=arguments.length;d>c;c++)a=arguments[c],a&&(b=this.items.length,this[b]=this.items[b]=a,this.length++);return this},j.pop=function(){return this.length&&delete this[this.length--],this.items.pop()},j.forEach=function(a,b){for(var c=0,d=this.items.length;d>c;c++)if(a.call(b,this.items[c],c)===!1)return this;return this},j.animate=function(d,e,f,g){"function"!=typeof f||f.length||(g=f,f=c.linear),d instanceof a._.Animation&&(g=d.callback,f=d.easing,e=f.dur,d=d.attr);var h=arguments;if(a.is(d,"array")&&a.is(h[h.length-1],"array"))var i=!0;var j,k=function(){j?this.b=j:j=this.b},l=0,m=this,n=g&&function(){++l==m.length&&g.call(this)};return this.forEach(function(a,c){b.once("snap.animcreated."+a.id,k),i?h[c]&&a.animate.apply(a,h[c]):a.animate(d,e,f,n)})},j.remove=function(){for(;this.length;)this.pop().remove();return this},j.bind=function(a,b,c){var d={};if("function"==typeof b)this.bindings[a]=b;else{var e=c||a;this.bindings[a]=function(a){d[e]=a,b.attr(d)}}return this},j.attr=function(a){var b={};for(var c in a)this.bindings[c]?this.bindings[c](a[c]):b[c]=a[c];for(var d=0,e=this.items.length;e>d;d++)this.items[d].attr(b);return this},j.clear=function(){for(;this.length;)this.pop()},j.splice=function(a,b,c){a=0>a?g(this.length+a,0):a,b=g(0,h(this.length-a,b));var d,e=[],f=[],j=[];for(d=2;dd;d++)f.push(this[a+d]);for(;dd?j[d]:e[d-k];for(d=this.items.length=this.length-=b-k;this[d];)delete this[d++];return new i(f)},j.exclude=function(a){for(var b=0,c=this.length;c>b;b++)if(this[b]==a)return this.splice(b,1),!0;return!1},j.insertAfter=function(a){for(var b=this.items.length;b--;)this.items[b].insertAfter(a);return this},j.getBBox=function(){for(var a=[],b=[],c=[],d=[],e=this.items.length;e--;)if(!this.items[e].removed){var f=this.items[e].getBBox();a.push(f.x),b.push(f.y),c.push(f.x+f.width),d.push(f.y+f.height)}return a=h.apply(0,a),b=h.apply(0,b),c=g.apply(0,c),d=g.apply(0,d),{x:a,y:b,x2:c,y2:d,width:c-a,height:d-b,cx:a+(c-a)/2,cy:b+(d-b)/2}},j.clone=function(a){a=new i;for(var b=0,c=this.items.length;c>b;b++)a.push(this.items[b].clone());return a},j.toString=function(){return"Snap‘s set"},j.type="set",a.Set=i,a.set=function(){var a=new i;return arguments.length&&a.push.apply(a,Array.prototype.slice.call(arguments,0)),a}}),d.plugin(function(a,c,d,e){function f(a){var b=a[0];switch(b.toLowerCase()){case"t":return[b,0,0];case"m":return[b,1,0,0,1,0,0];case"r":return 4==a.length?[b,0,a[2],a[3]]:[b,0];case"s":return 5==a.length?[b,1,1,a[3],a[4]]:3==a.length?[b,1,1]:[b,1]}}function g(b,c,d){b=b||new a.Matrix,c=c||new a.Matrix,b=a.parseTransformString(b.toTransformString())||[],c=a.parseTransformString(c.toTransformString())||[];for(var e,g,h,i,j=Math.max(b.length,c.length),k=[],n=[],o=0;j>o;o++){if(h=b[o]||f(c[o]),i=c[o]||f(h),h[0]!=i[0]||"r"==h[0].toLowerCase()&&(h[2]!=i[2]||h[3]!=i[3])||"s"==h[0].toLowerCase()&&(h[3]!=i[3]||h[4]!=i[4])){b=a._.transform2matrix(b,d()),c=a._.transform2matrix(c,d()),k=[["m",b.a,b.b,b.c,b.d,b.e,b.f]],n=[["m",c.a,c.b,c.c,c.d,c.e,c.f]];break}for(k[o]=[],n[o]=[],e=0,g=Math.max(h.length,i.length);g>e;e++)e in h&&(k[o][e]=h[e]),e in i&&(n[o][e]=i[e])}return{from:m(k),to:m(n),f:l(k)}}function h(a){return a}function i(a){return function(b){return+b.toFixed(3)+a}}function j(a){return a.join(" ")}function k(b){return a.rgb(b[0],b[1],b[2],b[3])}function l(a){var b,c,d,e,f,g,h=0,i=[];for(b=0,c=a.length;c>b;b++){for(f="[",g=['"'+a[b][0]+'"'],d=1,e=a[b].length;e>d;d++)g[d]="val["+h++ +"]";f+=g+"]",i[b]=f}return Function("val","return Snap.path.toString.call(["+i+"])")}function m(a){for(var b=[],c=0,d=a.length;d>c;c++)for(var e=1,f=a[c].length;f>e;e++)b.push(a[c][e]);return b}function n(a){return isFinite(a)}function o(b,c){return a.is(b,"array")&&a.is(c,"array")?b.toString()==c.toString():!1}var p={},q=/[%a-z]+$/i,r=String;p.stroke=p.fill="colour",c.prototype.equal=function(a,c){return b("snap.util.equal",this,a,c).firstDefined()},b.on("snap.util.equal",function(b,c){var d,e,f=r(this.attr(b)||""),s=this;if("colour"==p[b])return d=a.color(f),e=a.color(c),{from:[d.r,d.g,d.b,d.opacity],to:[e.r,e.g,e.b,e.opacity],f:k};if("viewBox"==b)return d=this.attr(b).vb.split(" ").map(Number),e=c.split(" ").map(Number),{from:d,to:e,f:j};if("transform"==b||"gradientTransform"==b||"patternTransform"==b)return"string"==typeof c&&(c=r(c).replace(/\.{3}|\u2026/g,f)),f=this.matrix,c=a._.rgTransform.test(c)?a._.transform2matrix(c,this.getBBox()):a._.transform2matrix(a._.svgTransform2string(c),this.getBBox()),g(f,c,function(){return s.getBBox(1)});if("d"==b||"path"==b)return d=a.path.toCubic(f,c),{from:m(d[0]),to:m(d[1]),f:l(d[0])};if("points"==b)return d=r(f).split(a._.separator),e=r(c).split(a._.separator),{from:d,to:e,f:function(a){return a}};if(n(f)&&n(c))return{from:parseFloat(f),to:parseFloat(c),f:h};var t=f.match(q),u=r(c).match(q);return t&&o(t,u)?{from:parseFloat(f),to:parseFloat(c),f:i(t)}:{from:this.asPX(b),to:this.asPX(b,c),f:h}})}),d.plugin(function(a,c,d,e){for(var f=c.prototype,g="hasOwnProperty",h=("createTouch"in e.doc),i=["click","dblclick","mousedown","mousemove","mouseout","mouseover","mouseup","touchstart","touchmove","touchend","touchcancel"],j={mousedown:"touchstart",mousemove:"touchmove",mouseup:"touchend"},k=(function(a,b){var c="y"==a?"scrollTop":"scrollLeft",d=b&&b.node?b.node.ownerDocument:e.doc;return d[c in d.documentElement?"documentElement":"body"][c]}),l=function(){return this.originalEvent.preventDefault()},m=function(){return this.originalEvent.stopPropagation()},n=function(a,b,c,d){var e=h&&j[b]?j[b]:b,f=function(e){var f=k("y",d),i=k("x",d);if(h&&j[g](b))for(var n=0,o=e.targetTouches&&e.targetTouches.length;o>n;n++)if(e.targetTouches[n].target==a||a.contains(e.targetTouches[n].target)){var p=e;e=e.targetTouches[n],e.originalEvent=p,e.preventDefault=l,e.stopPropagation=m;break}var q=e.clientX+i,r=e.clientY+f;return c.call(d,e,q,r)};return b!==e&&a.addEventListener(b,f,!1),a.addEventListener(e,f,!1),function(){return b!==e&&a.removeEventListener(b,f,!1),a.removeEventListener(e,f,!1),!0}},o=[],p=function(a){for(var c,d=a.clientX,e=a.clientY,f=k("y"),g=k("x"),i=o.length;i--;){if(c=o[i],h){for(var j,l=a.touches&&a.touches.length;l--;)if(j=a.touches[l],j.identifier==c.el._drag.id||c.el.node.contains(j.target)){d=j.clientX,e=j.clientY,(a.originalEvent?a.originalEvent:a).preventDefault();break}}else a.preventDefault();var m=c.el.node;m.nextSibling,m.parentNode,m.style.display;d+=g,e+=f,b("snap.drag.move."+c.el.id,c.move_scope||c.el,d-c.el._drag.x,e-c.el._drag.y,d,e,a)}},q=function(c){a.unmousemove(p).unmouseup(q);for(var d,e=o.length;e--;)d=o[e],d.el._drag={},b("snap.drag.end."+d.el.id,d.end_scope||d.start_scope||d.move_scope||d.el,c),b.off("snap.drag.*."+d.el.id);o=[]},r=i.length;r--;)!function(b){a[b]=f[b]=function(c,d){if(a.is(c,"function"))this.events=this.events||[],this.events.push({name:b,f:c,unbind:n(this.node||document,b,c,d||this)});else for(var e=0,f=this.events.length;f>e;e++)if(this.events[e].name==b)try{this.events[e].f.call(this)}catch(g){}return this},a["un"+b]=f["un"+b]=function(a){for(var c=this.events||[],d=c.length;d--;)if(c[d].name==b&&(c[d].f==a||!a))return c[d].unbind(),c.splice(d,1),!c.length&&delete this.events,this;return this}}(i[r]);f.hover=function(a,b,c,d){return this.mouseover(a,c).mouseout(b,d||c)},f.unhover=function(a,b){return this.unmouseover(a).unmouseout(b)};var s=[];f.drag=function(c,d,e,f,g,h){function i(i,j,l){(i.originalEvent||i).preventDefault(),k._drag.x=j,k._drag.y=l,k._drag.id=i.identifier,!o.length&&a.mousemove(p).mouseup(q),o.push({el:k,move_scope:f,start_scope:g,end_scope:h}),d&&b.on("snap.drag.start."+k.id,d),c&&b.on("snap.drag.move."+k.id,c),e&&b.on("snap.drag.end."+k.id,e),b("snap.drag.start."+k.id,g||f||k,j,l,i)}function j(a,c,d){b("snap.draginit."+k.id,k,a,c,d)}var k=this;if(!arguments.length){var l;return k.drag(function(a,b){this.attr({transform:l+(l?"T":"t")+[a,b]})},function(){l=this.transform().local})}return b.on("snap.draginit."+k.id,i),k._drag={},s.push({el:k,start:i,init:j}),k.mousedown(j),k},f.undrag=function(){for(var c=s.length;c--;)s[c].el==this&&(this.unmousedown(s[c].init),s.splice(c,1),b.unbind("snap.drag.*."+this.id),b.unbind("snap.draginit."+this.id));return!s.length&&a.unmousemove(p).unmouseup(q),this}}),d.plugin(function(a,c,d,e){var f=(c.prototype,d.prototype),g=/^\s*url\((.+)\)/,h=String,i=a._.$;a.filter={},f.filter=function(b){var d=this;"svg"!=d.type&&(d=d.paper);var e=a.parse(h(b)),f=a._.id(),g=(d.node.offsetWidth,d.node.offsetHeight,i("filter"));return i(g,{id:f,filterUnits:"userSpaceOnUse"}),g.appendChild(e.node),d.defs.appendChild(g),new c(g)},b.on("snap.util.getattr.filter",function(){b.stop();var c=i(this.node,"filter");if(c){var d=h(c).match(g);return d&&a.select(d[1])}}),b.on("snap.util.attr.filter",function(d){if(d instanceof c&&"filter"==d.type){b.stop();var e=d.node.id;e||(i(d.node,{id:d.id}),e=d.id),i(this.node,{filter:a.url(e)})}d&&"none"!=d||(b.stop(),this.node.removeAttribute("filter"))}),a.filter.blur=function(b,c){null==b&&(b=2);var d=null==c?b:[b,c];return a.format('>} X - corresponds to gray pixel features (120 pixels for both eyes) for each of n clicks
+ * @param {Array} k - ridge parameter
+ * @return{Array} regression coefficients
+ */
+function ridge(y, X, k){
+ var nc = X[0].length;
+ var m_Coefficients = new Array(nc);
+ var xt = self.webgazer.mat.transpose(X);
+ var solution = new Array();
+ var success = true;
+ do{
+ var ss = self.webgazer.mat.mult(xt,X);
+ // Set ridge regression adjustment
+ for (var i = 0; i < nc; i++) {
+ ss[i][i] = ss[i][i] + k;
+ }
+
+ // Carry out the regression
+ var bb = self.webgazer.mat.mult(xt,y);
+ for(var i = 0; i < nc; i++) {
+ m_Coefficients[i] = bb[i][0];
+ }
+ try{
+ var n = (m_Coefficients.length !== 0 ? m_Coefficients.length/m_Coefficients.length: 0);
+ if (m_Coefficients.length*n !== m_Coefficients.length){
+ console.log('Array length must be a multiple of m')
+ }
+ solution = (ss.length === ss[0].length ? (self.webgazer.mat.LUDecomposition(ss,bb)) : (self.webgazer.mat.QRDecomposition(ss,bb)));
+
+ for (var i = 0; i < nc; i++){
+ m_Coefficients[i] = solution[i][0];
+ }
+ success = true;
+ }
+ catch (ex){
+ k *= 10;
+ console.log(ex);
+ success = false;
+ }
+ } while (!success);
+ return m_Coefficients;
+}
+
+//TODO: still usefull ???
+/**
+ *
+ * @returns {Number}
+ */
+function getCurrentFixationIndex() {
+ var index = 0;
+ var recentX = this.screenXTrailArray.get(0);
+ var recentY = this.screenYTrailArray.get(0);
+ for (var i = this.screenXTrailArray.length - 1; i >= 0; i--) {
+ var currX = this.screenXTrailArray.get(i);
+ var currY = this.screenYTrailArray.get(i);
+ var euclideanDistance = Math.sqrt(Math.pow((currX-recentX),2)+Math.pow((currY-recentY),2));
+ if (euclideanDistance > 72){
+ return i+1;
+ }
+ }
+ return i;
+}
+
+/**
+ * Event handler, it store screen position to allow training
+ * @param {Event} event - the receive event
+ */
+self.onmessage = function(event) {
+ var data = event.data;
+ var screenPos = data['screenPos'];
+ var eyes = data['eyes'];
+ var type = data['type'];
+ if (type === 'click') {
+ self.screenXClicksArray.push([screenPos[0]]);
+ self.screenYClicksArray.push([screenPos[1]]);
+
+ self.eyeFeaturesClicks.push(eyes);
+ } else if (type === 'move') {
+ self.screenXTrailArray.push([screenPos[0]]);
+ self.screenYTrailArray.push([screenPos[1]]);
+
+ self.eyeFeaturesTrail.push(eyes);
+ self.dataTrail.push({'eyes':eyes, 'screenPos':screenPos, 'type':type});
+ }
+ self.needsTraining = true;
+};
+
+/**
+ * Compute coefficient from training data
+ */
+function retrain() {
+ if (self.screenXClicksArray.length === 0) {
+ return;
+ }
+ if (!self.needsTraining) {
+ return;
+ }
+ var screenXArray = self.screenXClicksArray.data.concat(self.screenXTrailArray.data);
+ var screenYArray = self.screenYClicksArray.data.concat(self.screenYTrailArray.data);
+ var eyeFeatures = self.eyeFeaturesClicks.data.concat(self.eyeFeaturesTrail.data);
+
+ var coefficientsX = ridge(screenXArray, eyeFeatures, ridgeParameter);
+ var coefficientsY = ridge(screenYArray, eyeFeatures, ridgeParameter);
+ self.postMessage({'X':coefficientsX, 'Y': coefficientsY});
+ self.needsTraining = false;
+}
+
+setInterval(retrain, trainInterval);
+
diff --git a/LetterDMS/jspsych/examples/js/webgazer/webgazer.js b/LetterDMS/jspsych/examples/js/webgazer/webgazer.js
new file mode 100644
index 0000000..6368f8a
--- /dev/null
+++ b/LetterDMS/jspsych/examples/js/webgazer/webgazer.js
@@ -0,0 +1,88909 @@
+/*!
+ *
+ * WebGazer.js: Scalable Webcam EyeTracking Using User Interactions
+ * Copyright (c) 2016-2020, Brown HCI Group
+ * Licensed under GPLv3. Companies with a valuation of less than $1M can use WebGazer.js under LGPLv3.
+ *
+ */
+var webgazer =
+/******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ }
+/******/ };
+/******/
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = function(exports) {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/
+/******/ // create a fake namespace object
+/******/ // mode & 1: value is a module id, require it
+/******/ // mode & 2: merge all properties of value into the ns
+/******/ // mode & 4: return value when already ns object
+/******/ // mode & 8|1: behave like require
+/******/ __webpack_require__.t = function(value, mode) {
+/******/ if(mode & 1) value = __webpack_require__(value);
+/******/ if(mode & 8) return value;
+/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ var ns = Object.create(null);
+/******/ __webpack_require__.r(ns);
+/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ return ns;
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 90);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "AdadeltaOptimizer", function() { return /* reexport */ adadelta_optimizer_AdadeltaOptimizer; });
+__webpack_require__.d(__webpack_exports__, "AdagradOptimizer", function() { return /* reexport */ adagrad_optimizer_AdagradOptimizer; });
+__webpack_require__.d(__webpack_exports__, "AdamOptimizer", function() { return /* reexport */ adam_optimizer_AdamOptimizer; });
+__webpack_require__.d(__webpack_exports__, "AdamaxOptimizer", function() { return /* reexport */ adamax_optimizer_AdamaxOptimizer; });
+__webpack_require__.d(__webpack_exports__, "MomentumOptimizer", function() { return /* reexport */ momentum_optimizer_MomentumOptimizer; });
+__webpack_require__.d(__webpack_exports__, "Optimizer", function() { return /* reexport */ optimizer_Optimizer; });
+__webpack_require__.d(__webpack_exports__, "RMSPropOptimizer", function() { return /* reexport */ rmsprop_optimizer_RMSPropOptimizer; });
+__webpack_require__.d(__webpack_exports__, "SGDOptimizer", function() { return /* reexport */ sgd_optimizer_SGDOptimizer; });
+__webpack_require__.d(__webpack_exports__, "Tensor", function() { return /* reexport */ dist_tensor["a" /* Tensor */]; });
+__webpack_require__.d(__webpack_exports__, "TensorBuffer", function() { return /* reexport */ dist_tensor["b" /* TensorBuffer */]; });
+__webpack_require__.d(__webpack_exports__, "Variable", function() { return /* reexport */ dist_tensor["c" /* Variable */]; });
+__webpack_require__.d(__webpack_exports__, "Rank", function() { return /* reexport */ dist_types["a" /* Rank */]; });
+__webpack_require__.d(__webpack_exports__, "sumOutType", function() { return /* reexport */ dist_types["b" /* sumOutType */]; });
+__webpack_require__.d(__webpack_exports__, "upcastType", function() { return /* reexport */ dist_types["c" /* upcastType */]; });
+__webpack_require__.d(__webpack_exports__, "add", function() { return /* reexport */ add; });
+__webpack_require__.d(__webpack_exports__, "addN", function() { return /* reexport */ addN; });
+__webpack_require__.d(__webpack_exports__, "atan2", function() { return /* reexport */ atan2; });
+__webpack_require__.d(__webpack_exports__, "avgPool", function() { return /* reexport */ avgPool; });
+__webpack_require__.d(__webpack_exports__, "avgPool3d", function() { return /* reexport */ avgPool3d; });
+__webpack_require__.d(__webpack_exports__, "batchToSpaceND", function() { return /* reexport */ batchToSpaceND; });
+__webpack_require__.d(__webpack_exports__, "batchNorm", function() { return /* reexport */ batchNorm; });
+__webpack_require__.d(__webpack_exports__, "batchNorm2d", function() { return /* reexport */ batchNorm2d; });
+__webpack_require__.d(__webpack_exports__, "batchNorm3d", function() { return /* reexport */ batchNorm3d; });
+__webpack_require__.d(__webpack_exports__, "batchNorm4d", function() { return /* reexport */ batchNorm4d; });
+__webpack_require__.d(__webpack_exports__, "broadcastTo", function() { return /* reexport */ broadcastTo; });
+__webpack_require__.d(__webpack_exports__, "clone", function() { return /* reexport */ clone; });
+__webpack_require__.d(__webpack_exports__, "complex", function() { return /* reexport */ complex["a" /* complex */]; });
+__webpack_require__.d(__webpack_exports__, "concat", function() { return /* reexport */ concat; });
+__webpack_require__.d(__webpack_exports__, "concat1d", function() { return /* reexport */ concat1d; });
+__webpack_require__.d(__webpack_exports__, "concat2d", function() { return /* reexport */ concat2d; });
+__webpack_require__.d(__webpack_exports__, "concat3d", function() { return /* reexport */ concat3d; });
+__webpack_require__.d(__webpack_exports__, "concat4d", function() { return /* reexport */ concat4d; });
+__webpack_require__.d(__webpack_exports__, "conv1d", function() { return /* reexport */ conv1d; });
+__webpack_require__.d(__webpack_exports__, "conv2d", function() { return /* reexport */ conv2d; });
+__webpack_require__.d(__webpack_exports__, "conv2dTranspose", function() { return /* reexport */ conv2dTranspose; });
+__webpack_require__.d(__webpack_exports__, "conv3d", function() { return /* reexport */ conv3d; });
+__webpack_require__.d(__webpack_exports__, "conv3dTranspose", function() { return /* reexport */ conv3dTranspose; });
+__webpack_require__.d(__webpack_exports__, "cumsum", function() { return /* reexport */ cumsum; });
+__webpack_require__.d(__webpack_exports__, "depthToSpace", function() { return /* reexport */ depthToSpace; });
+__webpack_require__.d(__webpack_exports__, "depthwiseConv2d", function() { return /* reexport */ depthwiseConv2d; });
+__webpack_require__.d(__webpack_exports__, "diag", function() { return /* reexport */ diag; });
+__webpack_require__.d(__webpack_exports__, "div", function() { return /* reexport */ div; });
+__webpack_require__.d(__webpack_exports__, "divNoNan", function() { return /* reexport */ divNoNan; });
+__webpack_require__.d(__webpack_exports__, "dot", function() { return /* reexport */ dot; });
+__webpack_require__.d(__webpack_exports__, "elu", function() { return /* reexport */ elu; });
+__webpack_require__.d(__webpack_exports__, "equal", function() { return /* reexport */ equal; });
+__webpack_require__.d(__webpack_exports__, "eye", function() { return /* reexport */ eye; });
+__webpack_require__.d(__webpack_exports__, "fill", function() { return /* reexport */ fill; });
+__webpack_require__.d(__webpack_exports__, "floorDiv", function() { return /* reexport */ floorDiv; });
+__webpack_require__.d(__webpack_exports__, "greater", function() { return /* reexport */ greater; });
+__webpack_require__.d(__webpack_exports__, "greaterEqual", function() { return /* reexport */ greaterEqual; });
+__webpack_require__.d(__webpack_exports__, "imag", function() { return /* reexport */ imag["a" /* imag */]; });
+__webpack_require__.d(__webpack_exports__, "leakyRelu", function() { return /* reexport */ leakyRelu; });
+__webpack_require__.d(__webpack_exports__, "less", function() { return /* reexport */ less; });
+__webpack_require__.d(__webpack_exports__, "lessEqual", function() { return /* reexport */ lessEqual; });
+__webpack_require__.d(__webpack_exports__, "localResponseNormalization", function() { return /* reexport */ localResponseNormalization; });
+__webpack_require__.d(__webpack_exports__, "matMul", function() { return /* reexport */ matMul; });
+__webpack_require__.d(__webpack_exports__, "max", function() { return /* reexport */ max_max; });
+__webpack_require__.d(__webpack_exports__, "maxPool", function() { return /* reexport */ maxPool; });
+__webpack_require__.d(__webpack_exports__, "maxPool3d", function() { return /* reexport */ maxPool3d; });
+__webpack_require__.d(__webpack_exports__, "maxPoolWithArgmax", function() { return /* reexport */ maxPoolWithArgmax; });
+__webpack_require__.d(__webpack_exports__, "maximum", function() { return /* reexport */ maximum; });
+__webpack_require__.d(__webpack_exports__, "minimum", function() { return /* reexport */ minimum; });
+__webpack_require__.d(__webpack_exports__, "mod", function() { return /* reexport */ mod; });
+__webpack_require__.d(__webpack_exports__, "mul", function() { return /* reexport */ mul; });
+__webpack_require__.d(__webpack_exports__, "multinomial", function() { return /* reexport */ multinomial; });
+__webpack_require__.d(__webpack_exports__, "notEqual", function() { return /* reexport */ notEqual; });
+__webpack_require__.d(__webpack_exports__, "oneHot", function() { return /* reexport */ oneHot; });
+__webpack_require__.d(__webpack_exports__, "outerProduct", function() { return /* reexport */ outerProduct; });
+__webpack_require__.d(__webpack_exports__, "pad", function() { return /* reexport */ pad_pad; });
+__webpack_require__.d(__webpack_exports__, "pad1d", function() { return /* reexport */ pad1d; });
+__webpack_require__.d(__webpack_exports__, "pad2d", function() { return /* reexport */ pad2d; });
+__webpack_require__.d(__webpack_exports__, "pad3d", function() { return /* reexport */ pad3d; });
+__webpack_require__.d(__webpack_exports__, "pad4d", function() { return /* reexport */ pad4d; });
+__webpack_require__.d(__webpack_exports__, "pool", function() { return /* reexport */ pool; });
+__webpack_require__.d(__webpack_exports__, "pow", function() { return /* reexport */ pow; });
+__webpack_require__.d(__webpack_exports__, "prelu", function() { return /* reexport */ prelu; });
+__webpack_require__.d(__webpack_exports__, "rand", function() { return /* reexport */ rand; });
+__webpack_require__.d(__webpack_exports__, "randomGamma", function() { return /* reexport */ randomGamma; });
+__webpack_require__.d(__webpack_exports__, "randomNormal", function() { return /* reexport */ randomNormal; });
+__webpack_require__.d(__webpack_exports__, "randomUniform", function() { return /* reexport */ randomUniform; });
+__webpack_require__.d(__webpack_exports__, "real", function() { return /* reexport */ real["a" /* real */]; });
+__webpack_require__.d(__webpack_exports__, "relu", function() { return /* reexport */ relu; });
+__webpack_require__.d(__webpack_exports__, "relu6", function() { return /* reexport */ relu6; });
+__webpack_require__.d(__webpack_exports__, "selu", function() { return /* reexport */ selu; });
+__webpack_require__.d(__webpack_exports__, "separableConv2d", function() { return /* reexport */ separableConv2d; });
+__webpack_require__.d(__webpack_exports__, "spaceToBatchND", function() { return /* reexport */ spaceToBatchND; });
+__webpack_require__.d(__webpack_exports__, "split", function() { return /* reexport */ split; });
+__webpack_require__.d(__webpack_exports__, "square", function() { return /* reexport */ square; });
+__webpack_require__.d(__webpack_exports__, "squaredDifference", function() { return /* reexport */ squaredDifference; });
+__webpack_require__.d(__webpack_exports__, "sub", function() { return /* reexport */ sub; });
+__webpack_require__.d(__webpack_exports__, "tile", function() { return /* reexport */ tile; });
+__webpack_require__.d(__webpack_exports__, "truncatedNormal", function() { return /* reexport */ truncatedNormal; });
+__webpack_require__.d(__webpack_exports__, "booleanMaskAsync", function() { return /* reexport */ booleanMaskAsync; });
+__webpack_require__.d(__webpack_exports__, "reverse", function() { return /* reexport */ reverse_reverse; });
+__webpack_require__.d(__webpack_exports__, "reverse1d", function() { return /* reexport */ reverse1d; });
+__webpack_require__.d(__webpack_exports__, "reverse2d", function() { return /* reexport */ reverse2d; });
+__webpack_require__.d(__webpack_exports__, "reverse3d", function() { return /* reexport */ reverse3d; });
+__webpack_require__.d(__webpack_exports__, "reverse4d", function() { return /* reexport */ reverse4d; });
+__webpack_require__.d(__webpack_exports__, "slice", function() { return /* reexport */ slice; });
+__webpack_require__.d(__webpack_exports__, "slice1d", function() { return /* reexport */ slice1d; });
+__webpack_require__.d(__webpack_exports__, "slice2d", function() { return /* reexport */ slice2d; });
+__webpack_require__.d(__webpack_exports__, "slice3d", function() { return /* reexport */ slice3d; });
+__webpack_require__.d(__webpack_exports__, "slice4d", function() { return /* reexport */ slice4d; });
+__webpack_require__.d(__webpack_exports__, "abs", function() { return /* reexport */ abs; });
+__webpack_require__.d(__webpack_exports__, "acos", function() { return /* reexport */ acos; });
+__webpack_require__.d(__webpack_exports__, "acosh", function() { return /* reexport */ acosh; });
+__webpack_require__.d(__webpack_exports__, "asin", function() { return /* reexport */ asin; });
+__webpack_require__.d(__webpack_exports__, "asinh", function() { return /* reexport */ asinh; });
+__webpack_require__.d(__webpack_exports__, "atan", function() { return /* reexport */ atan; });
+__webpack_require__.d(__webpack_exports__, "atanh", function() { return /* reexport */ atanh; });
+__webpack_require__.d(__webpack_exports__, "ceil", function() { return /* reexport */ ceil; });
+__webpack_require__.d(__webpack_exports__, "clipByValue", function() { return /* reexport */ clipByValue; });
+__webpack_require__.d(__webpack_exports__, "cos", function() { return /* reexport */ cos; });
+__webpack_require__.d(__webpack_exports__, "cosh", function() { return /* reexport */ cosh; });
+__webpack_require__.d(__webpack_exports__, "erf", function() { return /* reexport */ erf; });
+__webpack_require__.d(__webpack_exports__, "exp", function() { return /* reexport */ unary_ops_exp; });
+__webpack_require__.d(__webpack_exports__, "expm1", function() { return /* reexport */ expm1; });
+__webpack_require__.d(__webpack_exports__, "floor", function() { return /* reexport */ floor; });
+__webpack_require__.d(__webpack_exports__, "log", function() { return /* reexport */ log; });
+__webpack_require__.d(__webpack_exports__, "log1p", function() { return /* reexport */ log1p; });
+__webpack_require__.d(__webpack_exports__, "logSigmoid", function() { return /* reexport */ logSigmoid; });
+__webpack_require__.d(__webpack_exports__, "neg", function() { return /* reexport */ neg; });
+__webpack_require__.d(__webpack_exports__, "reciprocal", function() { return /* reexport */ reciprocal; });
+__webpack_require__.d(__webpack_exports__, "round", function() { return /* reexport */ round; });
+__webpack_require__.d(__webpack_exports__, "rsqrt", function() { return /* reexport */ rsqrt; });
+__webpack_require__.d(__webpack_exports__, "sigmoid", function() { return /* reexport */ sigmoid; });
+__webpack_require__.d(__webpack_exports__, "sign", function() { return /* reexport */ sign; });
+__webpack_require__.d(__webpack_exports__, "isNaN", function() { return /* reexport */ unary_ops_isNaN; });
+__webpack_require__.d(__webpack_exports__, "isInf", function() { return /* reexport */ isInf; });
+__webpack_require__.d(__webpack_exports__, "isFinite", function() { return /* reexport */ unary_ops_isFinite; });
+__webpack_require__.d(__webpack_exports__, "sin", function() { return /* reexport */ sin; });
+__webpack_require__.d(__webpack_exports__, "sinh", function() { return /* reexport */ sinh; });
+__webpack_require__.d(__webpack_exports__, "softplus", function() { return /* reexport */ softplus; });
+__webpack_require__.d(__webpack_exports__, "sqrt", function() { return /* reexport */ sqrt; });
+__webpack_require__.d(__webpack_exports__, "step", function() { return /* reexport */ unary_ops_step; });
+__webpack_require__.d(__webpack_exports__, "tan", function() { return /* reexport */ tan; });
+__webpack_require__.d(__webpack_exports__, "tanh", function() { return /* reexport */ tanh; });
+__webpack_require__.d(__webpack_exports__, "all", function() { return /* reexport */ reduction_ops_all; });
+__webpack_require__.d(__webpack_exports__, "any", function() { return /* reexport */ any; });
+__webpack_require__.d(__webpack_exports__, "argMax", function() { return /* reexport */ argMax; });
+__webpack_require__.d(__webpack_exports__, "argMin", function() { return /* reexport */ argMin; });
+__webpack_require__.d(__webpack_exports__, "logSumExp", function() { return /* reexport */ logSumExp; });
+__webpack_require__.d(__webpack_exports__, "mean", function() { return /* reexport */ reduction_ops_mean; });
+__webpack_require__.d(__webpack_exports__, "min", function() { return /* reexport */ reduction_ops_min; });
+__webpack_require__.d(__webpack_exports__, "moments", function() { return /* reexport */ moments; });
+__webpack_require__.d(__webpack_exports__, "sum", function() { return /* reexport */ sum; });
+__webpack_require__.d(__webpack_exports__, "prod", function() { return /* reexport */ reduction_ops_prod; });
+__webpack_require__.d(__webpack_exports__, "equalStrict", function() { return /* reexport */ equalStrict; });
+__webpack_require__.d(__webpack_exports__, "greaterEqualStrict", function() { return /* reexport */ greaterEqualStrict; });
+__webpack_require__.d(__webpack_exports__, "greaterStrict", function() { return /* reexport */ greaterStrict; });
+__webpack_require__.d(__webpack_exports__, "lessEqualStrict", function() { return /* reexport */ lessEqualStrict; });
+__webpack_require__.d(__webpack_exports__, "lessStrict", function() { return /* reexport */ lessStrict; });
+__webpack_require__.d(__webpack_exports__, "notEqualStrict", function() { return /* reexport */ notEqualStrict; });
+__webpack_require__.d(__webpack_exports__, "addStrict", function() { return /* reexport */ addStrict; });
+__webpack_require__.d(__webpack_exports__, "divStrict", function() { return /* reexport */ divStrict; });
+__webpack_require__.d(__webpack_exports__, "maximumStrict", function() { return /* reexport */ maximumStrict; });
+__webpack_require__.d(__webpack_exports__, "minimumStrict", function() { return /* reexport */ minimumStrict; });
+__webpack_require__.d(__webpack_exports__, "modStrict", function() { return /* reexport */ modStrict; });
+__webpack_require__.d(__webpack_exports__, "mulStrict", function() { return /* reexport */ mulStrict; });
+__webpack_require__.d(__webpack_exports__, "powStrict", function() { return /* reexport */ powStrict; });
+__webpack_require__.d(__webpack_exports__, "squaredDifferenceStrict", function() { return /* reexport */ squaredDifferenceStrict; });
+__webpack_require__.d(__webpack_exports__, "subStrict", function() { return /* reexport */ subStrict; });
+__webpack_require__.d(__webpack_exports__, "logicalAnd", function() { return /* reexport */ logicalAnd; });
+__webpack_require__.d(__webpack_exports__, "logicalNot", function() { return /* reexport */ logicalNot; });
+__webpack_require__.d(__webpack_exports__, "logicalOr", function() { return /* reexport */ logicalOr; });
+__webpack_require__.d(__webpack_exports__, "logicalXor", function() { return /* reexport */ logicalXor; });
+__webpack_require__.d(__webpack_exports__, "where", function() { return /* reexport */ where; });
+__webpack_require__.d(__webpack_exports__, "whereAsync", function() { return /* reexport */ whereAsync; });
+__webpack_require__.d(__webpack_exports__, "buffer", function() { return /* reexport */ array_ops_buffer; });
+__webpack_require__.d(__webpack_exports__, "print", function() { return /* reexport */ print; });
+__webpack_require__.d(__webpack_exports__, "cast", function() { return /* reexport */ cast; });
+__webpack_require__.d(__webpack_exports__, "expandDims", function() { return /* reexport */ expandDims; });
+__webpack_require__.d(__webpack_exports__, "reshape", function() { return /* reexport */ reshape; });
+__webpack_require__.d(__webpack_exports__, "squeeze", function() { return /* reexport */ squeeze; });
+__webpack_require__.d(__webpack_exports__, "stack", function() { return /* reexport */ stack; });
+__webpack_require__.d(__webpack_exports__, "unstack", function() { return /* reexport */ unstack; });
+__webpack_require__.d(__webpack_exports__, "setdiff1dAsync", function() { return /* reexport */ setdiff1dAsync; });
+__webpack_require__.d(__webpack_exports__, "linspace", function() { return /* reexport */ tensor_ops["a" /* linspace */]; });
+__webpack_require__.d(__webpack_exports__, "ones", function() { return /* reexport */ tensor_ops["b" /* ones */]; });
+__webpack_require__.d(__webpack_exports__, "range", function() { return /* reexport */ tensor_ops["d" /* range */]; });
+__webpack_require__.d(__webpack_exports__, "scalar", function() { return /* reexport */ tensor_ops["e" /* scalar */]; });
+__webpack_require__.d(__webpack_exports__, "tensor", function() { return /* reexport */ tensor_ops["f" /* tensor */]; });
+__webpack_require__.d(__webpack_exports__, "tensor1d", function() { return /* reexport */ tensor_ops["g" /* tensor1d */]; });
+__webpack_require__.d(__webpack_exports__, "tensor2d", function() { return /* reexport */ tensor_ops["h" /* tensor2d */]; });
+__webpack_require__.d(__webpack_exports__, "tensor3d", function() { return /* reexport */ tensor_ops["i" /* tensor3d */]; });
+__webpack_require__.d(__webpack_exports__, "tensor4d", function() { return /* reexport */ tensor_ops["j" /* tensor4d */]; });
+__webpack_require__.d(__webpack_exports__, "tensor5d", function() { return /* reexport */ tensor_ops["k" /* tensor5d */]; });
+__webpack_require__.d(__webpack_exports__, "tensor6d", function() { return /* reexport */ tensor_ops["l" /* tensor6d */]; });
+__webpack_require__.d(__webpack_exports__, "variable", function() { return /* reexport */ tensor_ops["m" /* variable */]; });
+__webpack_require__.d(__webpack_exports__, "zeros", function() { return /* reexport */ tensor_ops["n" /* zeros */]; });
+__webpack_require__.d(__webpack_exports__, "onesLike", function() { return /* reexport */ tensor_ops["c" /* onesLike */]; });
+__webpack_require__.d(__webpack_exports__, "zerosLike", function() { return /* reexport */ tensor_ops["o" /* zerosLike */]; });
+__webpack_require__.d(__webpack_exports__, "transpose", function() { return /* reexport */ transpose; });
+__webpack_require__.d(__webpack_exports__, "softmax", function() { return /* reexport */ softmax; });
+__webpack_require__.d(__webpack_exports__, "logSoftmax", function() { return /* reexport */ logSoftmax; });
+__webpack_require__.d(__webpack_exports__, "norm", function() { return /* reexport */ norm_norm; });
+__webpack_require__.d(__webpack_exports__, "gather", function() { return /* reexport */ gather; });
+__webpack_require__.d(__webpack_exports__, "unsortedSegmentSum", function() { return /* reexport */ unsortedSegmentSum; });
+__webpack_require__.d(__webpack_exports__, "basicLSTMCell", function() { return /* reexport */ basicLSTMCell; });
+__webpack_require__.d(__webpack_exports__, "multiRNNCell", function() { return /* reexport */ multiRNNCell; });
+__webpack_require__.d(__webpack_exports__, "movingAverage", function() { return /* reexport */ movingAverage; });
+__webpack_require__.d(__webpack_exports__, "stridedSlice", function() { return /* reexport */ stridedSlice; });
+__webpack_require__.d(__webpack_exports__, "topk", function() { return /* reexport */ topk; });
+__webpack_require__.d(__webpack_exports__, "scatterND", function() { return /* reexport */ scatterND; });
+__webpack_require__.d(__webpack_exports__, "fft", function() { return /* reexport */ fft; });
+__webpack_require__.d(__webpack_exports__, "ifft", function() { return /* reexport */ ifft; });
+__webpack_require__.d(__webpack_exports__, "rfft", function() { return /* reexport */ rfft; });
+__webpack_require__.d(__webpack_exports__, "irfft", function() { return /* reexport */ irfft; });
+__webpack_require__.d(__webpack_exports__, "sparseToDense", function() { return /* reexport */ sparseToDense; });
+__webpack_require__.d(__webpack_exports__, "gatherND", function() { return /* reexport */ gatherND; });
+__webpack_require__.d(__webpack_exports__, "dropout", function() { return /* reexport */ dropout; });
+__webpack_require__.d(__webpack_exports__, "hannWindow", function() { return /* reexport */ hannWindow; });
+__webpack_require__.d(__webpack_exports__, "hammingWindow", function() { return /* reexport */ hammingWindow; });
+__webpack_require__.d(__webpack_exports__, "frame", function() { return /* reexport */ signal_ops_frame; });
+__webpack_require__.d(__webpack_exports__, "stft", function() { return /* reexport */ stft; });
+__webpack_require__.d(__webpack_exports__, "inTopKAsync", function() { return /* reexport */ inTopKAsync; });
+__webpack_require__.d(__webpack_exports__, "op", function() { return /* reexport */ operation["a" /* op */]; });
+__webpack_require__.d(__webpack_exports__, "image", function() { return /* reexport */ image_ops_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "linalg", function() { return /* reexport */ linalg_ops_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "losses", function() { return /* reexport */ loss_ops_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "spectral", function() { return /* reexport */ spectral_ops_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "fused", function() { return /* reexport */ fused_ops_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "signal", function() { return /* reexport */ signal_ops_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "Reduction", function() { return /* reexport */ Reduction; });
+__webpack_require__.d(__webpack_exports__, "train", function() { return /* reexport */ train; });
+__webpack_require__.d(__webpack_exports__, "enableProdMode", function() { return /* reexport */ enableProdMode; });
+__webpack_require__.d(__webpack_exports__, "enableDebugMode", function() { return /* reexport */ enableDebugMode; });
+__webpack_require__.d(__webpack_exports__, "disableDeprecationWarnings", function() { return /* reexport */ disableDeprecationWarnings; });
+__webpack_require__.d(__webpack_exports__, "deprecationWarn", function() { return /* reexport */ deprecationWarn; });
+__webpack_require__.d(__webpack_exports__, "disposeVariables", function() { return /* reexport */ disposeVariables; });
+__webpack_require__.d(__webpack_exports__, "engine", function() { return /* reexport */ globals_engine; });
+__webpack_require__.d(__webpack_exports__, "memory", function() { return /* reexport */ memory; });
+__webpack_require__.d(__webpack_exports__, "profile", function() { return /* reexport */ profile; });
+__webpack_require__.d(__webpack_exports__, "tidy", function() { return /* reexport */ tidy; });
+__webpack_require__.d(__webpack_exports__, "dispose", function() { return /* reexport */ dispose; });
+__webpack_require__.d(__webpack_exports__, "keep", function() { return /* reexport */ keep; });
+__webpack_require__.d(__webpack_exports__, "time", function() { return /* reexport */ time; });
+__webpack_require__.d(__webpack_exports__, "setBackend", function() { return /* reexport */ setBackend; });
+__webpack_require__.d(__webpack_exports__, "ready", function() { return /* reexport */ ready; });
+__webpack_require__.d(__webpack_exports__, "getBackend", function() { return /* reexport */ getBackend; });
+__webpack_require__.d(__webpack_exports__, "removeBackend", function() { return /* reexport */ removeBackend; });
+__webpack_require__.d(__webpack_exports__, "findBackend", function() { return /* reexport */ findBackend; });
+__webpack_require__.d(__webpack_exports__, "findBackendFactory", function() { return /* reexport */ findBackendFactory; });
+__webpack_require__.d(__webpack_exports__, "registerBackend", function() { return /* reexport */ registerBackend; });
+__webpack_require__.d(__webpack_exports__, "backend", function() { return /* reexport */ globals_backend; });
+__webpack_require__.d(__webpack_exports__, "setPlatform", function() { return /* reexport */ setPlatform; });
+__webpack_require__.d(__webpack_exports__, "getKernel", function() { return /* reexport */ kernel_registry["b" /* getKernel */]; });
+__webpack_require__.d(__webpack_exports__, "getGradient", function() { return /* reexport */ kernel_registry["a" /* getGradient */]; });
+__webpack_require__.d(__webpack_exports__, "getKernelsForBackend", function() { return /* reexport */ kernel_registry["c" /* getKernelsForBackend */]; });
+__webpack_require__.d(__webpack_exports__, "registerKernel", function() { return /* reexport */ kernel_registry["e" /* registerKernel */]; });
+__webpack_require__.d(__webpack_exports__, "registerGradient", function() { return /* reexport */ kernel_registry["d" /* registerGradient */]; });
+__webpack_require__.d(__webpack_exports__, "unregisterKernel", function() { return /* reexport */ kernel_registry["g" /* unregisterKernel */]; });
+__webpack_require__.d(__webpack_exports__, "unregisterGradient", function() { return /* reexport */ kernel_registry["f" /* unregisterGradient */]; });
+__webpack_require__.d(__webpack_exports__, "customGrad", function() { return /* reexport */ customGrad; });
+__webpack_require__.d(__webpack_exports__, "grad", function() { return /* reexport */ gradients_grad; });
+__webpack_require__.d(__webpack_exports__, "grads", function() { return /* reexport */ gradients_grads; });
+__webpack_require__.d(__webpack_exports__, "valueAndGrad", function() { return /* reexport */ valueAndGrad; });
+__webpack_require__.d(__webpack_exports__, "valueAndGrads", function() { return /* reexport */ valueAndGrads; });
+__webpack_require__.d(__webpack_exports__, "variableGrads", function() { return /* reexport */ variableGrads; });
+__webpack_require__.d(__webpack_exports__, "Environment", function() { return /* reexport */ environment["b" /* Environment */]; });
+__webpack_require__.d(__webpack_exports__, "env", function() { return /* reexport */ environment["c" /* env */]; });
+__webpack_require__.d(__webpack_exports__, "ENV", function() { return /* reexport */ environment["a" /* ENV */]; });
+__webpack_require__.d(__webpack_exports__, "version_core", function() { return /* reexport */ version; });
+__webpack_require__.d(__webpack_exports__, "nextFrame", function() { return /* reexport */ browser_util["a" /* nextFrame */]; });
+__webpack_require__.d(__webpack_exports__, "browser", function() { return /* reexport */ browser_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "io", function() { return /* reexport */ io_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "math", function() { return /* reexport */ math_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "serialization", function() { return /* reexport */ serialization_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "test_util", function() { return /* reexport */ test_util_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "util", function() { return /* reexport */ util; });
+__webpack_require__.d(__webpack_exports__, "backend_util", function() { return /* reexport */ backend_util_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "tensor_util", function() { return /* reexport */ tensor_util; });
+__webpack_require__.d(__webpack_exports__, "slice_util", function() { return /* reexport */ slice_util_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "gather_util", function() { return /* reexport */ gather_nd_util_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "scatter_util", function() { return /* reexport */ scatter_nd_util_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "device_util", function() { return /* reexport */ device_util; });
+__webpack_require__.d(__webpack_exports__, "kernel_impls", function() { return /* reexport */ kernel_impls_namespaceObject; });
+__webpack_require__.d(__webpack_exports__, "KernelBackend", function() { return /* reexport */ KernelBackend; });
+__webpack_require__.d(__webpack_exports__, "DataStorage", function() { return /* reexport */ DataStorage; });
+__webpack_require__.d(__webpack_exports__, "Add", function() { return /* reexport */ kernel_names["a" /* Add */]; });
+__webpack_require__.d(__webpack_exports__, "AddN", function() { return /* reexport */ kernel_names["b" /* AddN */]; });
+__webpack_require__.d(__webpack_exports__, "Atan2", function() { return /* reexport */ kernel_names["c" /* Atan2 */]; });
+__webpack_require__.d(__webpack_exports__, "AvgPool", function() { return /* reexport */ kernel_names["d" /* AvgPool */]; });
+__webpack_require__.d(__webpack_exports__, "AvgPoolBackprop", function() { return /* reexport */ kernel_names["g" /* AvgPoolBackprop */]; });
+__webpack_require__.d(__webpack_exports__, "AvgPool3D", function() { return /* reexport */ kernel_names["e" /* AvgPool3D */]; });
+__webpack_require__.d(__webpack_exports__, "AvgPool3DBackprop", function() { return /* reexport */ kernel_names["f" /* AvgPool3DBackprop */]; });
+__webpack_require__.d(__webpack_exports__, "BatchMatMul", function() { return /* reexport */ kernel_names["h" /* BatchMatMul */]; });
+__webpack_require__.d(__webpack_exports__, "BatchToSpaceND", function() { return /* reexport */ kernel_names["i" /* BatchToSpaceND */]; });
+__webpack_require__.d(__webpack_exports__, "BroadcastTo", function() { return /* reexport */ kernel_names["j" /* BroadcastTo */]; });
+__webpack_require__.d(__webpack_exports__, "Complex", function() { return /* reexport */ kernel_names["k" /* Complex */]; });
+__webpack_require__.d(__webpack_exports__, "Concat", function() { return /* reexport */ kernel_names["l" /* Concat */]; });
+__webpack_require__.d(__webpack_exports__, "Conv2D", function() { return /* reexport */ kernel_names["m" /* Conv2D */]; });
+__webpack_require__.d(__webpack_exports__, "Conv2DBackpropFilter", function() { return /* reexport */ kernel_names["n" /* Conv2DBackpropFilter */]; });
+__webpack_require__.d(__webpack_exports__, "Conv2DBackpropInput", function() { return /* reexport */ kernel_names["o" /* Conv2DBackpropInput */]; });
+__webpack_require__.d(__webpack_exports__, "Conv3D", function() { return /* reexport */ kernel_names["p" /* Conv3D */]; });
+__webpack_require__.d(__webpack_exports__, "Conv3DBackpropFilterV2", function() { return /* reexport */ kernel_names["q" /* Conv3DBackpropFilterV2 */]; });
+__webpack_require__.d(__webpack_exports__, "Conv3DBackpropInputV2", function() { return /* reexport */ kernel_names["r" /* Conv3DBackpropInputV2 */]; });
+__webpack_require__.d(__webpack_exports__, "Cumsum", function() { return /* reexport */ kernel_names["s" /* Cumsum */]; });
+__webpack_require__.d(__webpack_exports__, "DepthToSpace", function() { return /* reexport */ kernel_names["t" /* DepthToSpace */]; });
+__webpack_require__.d(__webpack_exports__, "DepthwiseConv2dNative", function() { return /* reexport */ kernel_names["u" /* DepthwiseConv2dNative */]; });
+__webpack_require__.d(__webpack_exports__, "DepthwiseConv2dNativeBackpropFilter", function() { return /* reexport */ kernel_names["v" /* DepthwiseConv2dNativeBackpropFilter */]; });
+__webpack_require__.d(__webpack_exports__, "DepthwiseConv2dNativeBackpropInput", function() { return /* reexport */ kernel_names["w" /* DepthwiseConv2dNativeBackpropInput */]; });
+__webpack_require__.d(__webpack_exports__, "Diag", function() { return /* reexport */ kernel_names["x" /* Diag */]; });
+__webpack_require__.d(__webpack_exports__, "Div", function() { return /* reexport */ kernel_names["y" /* Div */]; });
+__webpack_require__.d(__webpack_exports__, "Elu", function() { return /* reexport */ kernel_names["z" /* Elu */]; });
+__webpack_require__.d(__webpack_exports__, "EluGrad", function() { return /* reexport */ kernel_names["A" /* EluGrad */]; });
+__webpack_require__.d(__webpack_exports__, "Equal", function() { return /* reexport */ kernel_names["B" /* Equal */]; });
+__webpack_require__.d(__webpack_exports__, "FloorDiv", function() { return /* reexport */ kernel_names["D" /* FloorDiv */]; });
+__webpack_require__.d(__webpack_exports__, "Fill", function() { return /* reexport */ kernel_names["C" /* Fill */]; });
+__webpack_require__.d(__webpack_exports__, "FusedBatchNorm", function() { return /* reexport */ kernel_names["F" /* FusedBatchNorm */]; });
+__webpack_require__.d(__webpack_exports__, "GatherNd", function() { return /* reexport */ kernel_names["G" /* GatherNd */]; });
+__webpack_require__.d(__webpack_exports__, "Greater", function() { return /* reexport */ kernel_names["H" /* Greater */]; });
+__webpack_require__.d(__webpack_exports__, "GreaterEqual", function() { return /* reexport */ kernel_names["I" /* GreaterEqual */]; });
+__webpack_require__.d(__webpack_exports__, "Identity", function() { return /* reexport */ kernel_names["J" /* Identity */]; });
+__webpack_require__.d(__webpack_exports__, "Imag", function() { return /* reexport */ kernel_names["K" /* Imag */]; });
+__webpack_require__.d(__webpack_exports__, "Less", function() { return /* reexport */ kernel_names["N" /* Less */]; });
+__webpack_require__.d(__webpack_exports__, "LessEqual", function() { return /* reexport */ kernel_names["O" /* LessEqual */]; });
+__webpack_require__.d(__webpack_exports__, "LRN", function() { return /* reexport */ kernel_names["L" /* LRN */]; });
+__webpack_require__.d(__webpack_exports__, "LRNBackprop", function() { return /* reexport */ kernel_names["M" /* LRNBackprop */]; });
+__webpack_require__.d(__webpack_exports__, "Max", function() { return /* reexport */ kernel_names["P" /* Max */]; });
+__webpack_require__.d(__webpack_exports__, "Maximum", function() { return /* reexport */ kernel_names["V" /* Maximum */]; });
+__webpack_require__.d(__webpack_exports__, "MaxPool", function() { return /* reexport */ kernel_names["Q" /* MaxPool */]; });
+__webpack_require__.d(__webpack_exports__, "MaxPoolBackprop", function() { return /* reexport */ kernel_names["T" /* MaxPoolBackprop */]; });
+__webpack_require__.d(__webpack_exports__, "MaxPool3D", function() { return /* reexport */ kernel_names["R" /* MaxPool3D */]; });
+__webpack_require__.d(__webpack_exports__, "MaxPool3DBackprop", function() { return /* reexport */ kernel_names["S" /* MaxPool3DBackprop */]; });
+__webpack_require__.d(__webpack_exports__, "MaxPoolWithArgmax", function() { return /* reexport */ kernel_names["U" /* MaxPoolWithArgmax */]; });
+__webpack_require__.d(__webpack_exports__, "Minimum", function() { return /* reexport */ kernel_names["W" /* Minimum */]; });
+__webpack_require__.d(__webpack_exports__, "Mod", function() { return /* reexport */ kernel_names["X" /* Mod */]; });
+__webpack_require__.d(__webpack_exports__, "Multiply", function() { return /* reexport */ kernel_names["Y" /* Multiply */]; });
+__webpack_require__.d(__webpack_exports__, "NotEqual", function() { return /* reexport */ kernel_names["bb" /* NotEqual */]; });
+__webpack_require__.d(__webpack_exports__, "NonMaxSuppressionV3", function() { return /* reexport */ kernel_names["Z" /* NonMaxSuppressionV3 */]; });
+__webpack_require__.d(__webpack_exports__, "NonMaxSuppressionV5", function() { return /* reexport */ kernel_names["ab" /* NonMaxSuppressionV5 */]; });
+__webpack_require__.d(__webpack_exports__, "OneHot", function() { return /* reexport */ kernel_names["cb" /* OneHot */]; });
+__webpack_require__.d(__webpack_exports__, "PadV2", function() { return /* reexport */ kernel_names["db" /* PadV2 */]; });
+__webpack_require__.d(__webpack_exports__, "Pool", function() { return /* reexport */ kernel_names["eb" /* Pool */]; });
+__webpack_require__.d(__webpack_exports__, "Pow", function() { return /* reexport */ kernel_names["fb" /* Pow */]; });
+__webpack_require__.d(__webpack_exports__, "Prelu", function() { return /* reexport */ kernel_names["gb" /* Prelu */]; });
+__webpack_require__.d(__webpack_exports__, "Real", function() { return /* reexport */ kernel_names["hb" /* Real */]; });
+__webpack_require__.d(__webpack_exports__, "Relu", function() { return /* reexport */ kernel_names["ib" /* Relu */]; });
+__webpack_require__.d(__webpack_exports__, "Relu6", function() { return /* reexport */ kernel_names["jb" /* Relu6 */]; });
+__webpack_require__.d(__webpack_exports__, "SelectV2", function() { return /* reexport */ kernel_names["kb" /* SelectV2 */]; });
+__webpack_require__.d(__webpack_exports__, "Selu", function() { return /* reexport */ kernel_names["lb" /* Selu */]; });
+__webpack_require__.d(__webpack_exports__, "SpaceToBatchND", function() { return /* reexport */ kernel_names["mb" /* SpaceToBatchND */]; });
+__webpack_require__.d(__webpack_exports__, "SplitV", function() { return /* reexport */ kernel_names["nb" /* SplitV */]; });
+__webpack_require__.d(__webpack_exports__, "SquaredDifference", function() { return /* reexport */ kernel_names["pb" /* SquaredDifference */]; });
+__webpack_require__.d(__webpack_exports__, "Square", function() { return /* reexport */ kernel_names["ob" /* Square */]; });
+__webpack_require__.d(__webpack_exports__, "Sub", function() { return /* reexport */ kernel_names["qb" /* Sub */]; });
+__webpack_require__.d(__webpack_exports__, "Tile", function() { return /* reexport */ kernel_names["rb" /* Tile */]; });
+__webpack_require__.d(__webpack_exports__, "Transpose", function() { return /* reexport */ kernel_names["sb" /* Transpose */]; });
+__webpack_require__.d(__webpack_exports__, "FromPixels", function() { return /* reexport */ kernel_names["E" /* FromPixels */]; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/slice_util.js
+var slice_util_namespaceObject = {};
+__webpack_require__.r(slice_util_namespaceObject);
+__webpack_require__.d(slice_util_namespaceObject, "assertParamsValid", function() { return assertParamsValid; });
+__webpack_require__.d(slice_util_namespaceObject, "maskToAxes", function() { return maskToAxes; });
+__webpack_require__.d(slice_util_namespaceObject, "computeOutShape", function() { return slice_util_computeOutShape; });
+__webpack_require__.d(slice_util_namespaceObject, "stridesWithElidedDims", function() { return stridesWithElidedDims; });
+__webpack_require__.d(slice_util_namespaceObject, "startIndicesWithElidedDims", function() { return startIndicesWithElidedDims; });
+__webpack_require__.d(slice_util_namespaceObject, "stopIndicesWithElidedDims", function() { return stopIndicesWithElidedDims; });
+__webpack_require__.d(slice_util_namespaceObject, "stridesForAxis", function() { return stridesForAxis; });
+__webpack_require__.d(slice_util_namespaceObject, "startForAxis", function() { return startForAxis; });
+__webpack_require__.d(slice_util_namespaceObject, "stopForAxis", function() { return stopForAxis; });
+__webpack_require__.d(slice_util_namespaceObject, "isSliceContinous", function() { return isSliceContinous; });
+__webpack_require__.d(slice_util_namespaceObject, "computeFlatOffset", function() { return computeFlatOffset; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/io/io.js
+var io_namespaceObject = {};
+__webpack_require__.r(io_namespaceObject);
+__webpack_require__.d(io_namespaceObject, "copyModel", function() { return copyModel; });
+__webpack_require__.d(io_namespaceObject, "listModels", function() { return listModels; });
+__webpack_require__.d(io_namespaceObject, "moveModel", function() { return moveModel; });
+__webpack_require__.d(io_namespaceObject, "removeModel", function() { return removeModel; });
+__webpack_require__.d(io_namespaceObject, "browserFiles", function() { return browserFiles; });
+__webpack_require__.d(io_namespaceObject, "browserHTTPRequest", function() { return browserHTTPRequest; });
+__webpack_require__.d(io_namespaceObject, "concatenateArrayBuffers", function() { return io_utils["d" /* concatenateArrayBuffers */]; });
+__webpack_require__.d(io_namespaceObject, "decodeWeights", function() { return io_utils["e" /* decodeWeights */]; });
+__webpack_require__.d(io_namespaceObject, "encodeWeights", function() { return io_utils["f" /* encodeWeights */]; });
+__webpack_require__.d(io_namespaceObject, "fromMemory", function() { return fromMemory; });
+__webpack_require__.d(io_namespaceObject, "getLoadHandlers", function() { return getLoadHandlers; });
+__webpack_require__.d(io_namespaceObject, "getModelArtifactsInfoForJSON", function() { return io_utils["g" /* getModelArtifactsInfoForJSON */]; });
+__webpack_require__.d(io_namespaceObject, "getSaveHandlers", function() { return getSaveHandlers; });
+__webpack_require__.d(io_namespaceObject, "http", function() { return http; });
+__webpack_require__.d(io_namespaceObject, "isHTTPScheme", function() { return isHTTPScheme; });
+__webpack_require__.d(io_namespaceObject, "loadWeights", function() { return loadWeights; });
+__webpack_require__.d(io_namespaceObject, "registerLoadRouter", function() { return registerLoadRouter; });
+__webpack_require__.d(io_namespaceObject, "registerSaveRouter", function() { return registerSaveRouter; });
+__webpack_require__.d(io_namespaceObject, "weightsLoaderFactory", function() { return weightsLoaderFactory; });
+__webpack_require__.d(io_namespaceObject, "withSaveHandler", function() { return withSaveHandler; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/math.js
+var math_namespaceObject = {};
+__webpack_require__.r(math_namespaceObject);
+__webpack_require__.d(math_namespaceObject, "confusionMatrix", function() { return confusionMatrix; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/browser.js
+var browser_namespaceObject = {};
+__webpack_require__.r(browser_namespaceObject);
+__webpack_require__.d(browser_namespaceObject, "toPixels", function() { return toPixels; });
+__webpack_require__.d(browser_namespaceObject, "fromPixels", function() { return fromPixels; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/gather_nd_util.js
+var gather_nd_util_namespaceObject = {};
+__webpack_require__.r(gather_nd_util_namespaceObject);
+__webpack_require__.d(gather_nd_util_namespaceObject, "prepareAndValidate", function() { return prepareAndValidate; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/scatter_nd_util.js
+var scatter_nd_util_namespaceObject = {};
+__webpack_require__.r(scatter_nd_util_namespaceObject);
+__webpack_require__.d(scatter_nd_util_namespaceObject, "validateUpdateShape", function() { return validateUpdateShape; });
+__webpack_require__.d(scatter_nd_util_namespaceObject, "validateInput", function() { return validateInput; });
+__webpack_require__.d(scatter_nd_util_namespaceObject, "calculateShapes", function() { return calculateShapes; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/serialization.js
+var serialization_namespaceObject = {};
+__webpack_require__.r(serialization_namespaceObject);
+__webpack_require__.d(serialization_namespaceObject, "Serializable", function() { return Serializable; });
+__webpack_require__.d(serialization_namespaceObject, "SerializationMap", function() { return SerializationMap; });
+__webpack_require__.d(serialization_namespaceObject, "registerClass", function() { return registerClass; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/test_util.js
+var test_util_namespaceObject = {};
+__webpack_require__.r(test_util_namespaceObject);
+__webpack_require__.d(test_util_namespaceObject, "TEST_EPSILON_FLOAT16", function() { return TEST_EPSILON_FLOAT16; });
+__webpack_require__.d(test_util_namespaceObject, "expectArraysClose", function() { return expectArraysClose; });
+__webpack_require__.d(test_util_namespaceObject, "testEpsilon", function() { return testEpsilon; });
+__webpack_require__.d(test_util_namespaceObject, "expectPromiseToFail", function() { return expectPromiseToFail; });
+__webpack_require__.d(test_util_namespaceObject, "expectArraysEqual", function() { return expectArraysEqual; });
+__webpack_require__.d(test_util_namespaceObject, "expectNumbersClose", function() { return expectNumbersClose; });
+__webpack_require__.d(test_util_namespaceObject, "expectValuesInRange", function() { return expectValuesInRange; });
+__webpack_require__.d(test_util_namespaceObject, "expectArrayBuffersEqual", function() { return expectArrayBuffersEqual; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/segment_util.js
+var segment_util_namespaceObject = {};
+__webpack_require__.r(segment_util_namespaceObject);
+__webpack_require__.d(segment_util_namespaceObject, "segOpComputeOptimalWindowSize", function() { return segOpComputeOptimalWindowSize; });
+__webpack_require__.d(segment_util_namespaceObject, "computeOutShape", function() { return segment_util_computeOutShape; });
+__webpack_require__.d(segment_util_namespaceObject, "collectGatherOpShapeInfo", function() { return collectGatherOpShapeInfo; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/spectral_ops.js
+var spectral_ops_namespaceObject = {};
+__webpack_require__.r(spectral_ops_namespaceObject);
+__webpack_require__.d(spectral_ops_namespaceObject, "fft", function() { return fft; });
+__webpack_require__.d(spectral_ops_namespaceObject, "ifft", function() { return ifft; });
+__webpack_require__.d(spectral_ops_namespaceObject, "rfft", function() { return rfft; });
+__webpack_require__.d(spectral_ops_namespaceObject, "irfft", function() { return irfft; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/signal_ops.js
+var signal_ops_namespaceObject = {};
+__webpack_require__.r(signal_ops_namespaceObject);
+__webpack_require__.d(signal_ops_namespaceObject, "hannWindow", function() { return hannWindow; });
+__webpack_require__.d(signal_ops_namespaceObject, "hammingWindow", function() { return hammingWindow; });
+__webpack_require__.d(signal_ops_namespaceObject, "frame", function() { return signal_ops_frame; });
+__webpack_require__.d(signal_ops_namespaceObject, "stft", function() { return stft; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/loss_ops.js
+var loss_ops_namespaceObject = {};
+__webpack_require__.r(loss_ops_namespaceObject);
+__webpack_require__.d(loss_ops_namespaceObject, "Reduction", function() { return Reduction; });
+__webpack_require__.d(loss_ops_namespaceObject, "absoluteDifference", function() { return absoluteDifference; });
+__webpack_require__.d(loss_ops_namespaceObject, "computeWeightedLoss", function() { return computeWeightedLoss; });
+__webpack_require__.d(loss_ops_namespaceObject, "cosineDistance", function() { return cosineDistance; });
+__webpack_require__.d(loss_ops_namespaceObject, "hingeLoss", function() { return hingeLoss; });
+__webpack_require__.d(loss_ops_namespaceObject, "huberLoss", function() { return huberLoss; });
+__webpack_require__.d(loss_ops_namespaceObject, "logLoss", function() { return logLoss; });
+__webpack_require__.d(loss_ops_namespaceObject, "meanSquaredError", function() { return meanSquaredError; });
+__webpack_require__.d(loss_ops_namespaceObject, "sigmoidCrossEntropy", function() { return sigmoidCrossEntropy; });
+__webpack_require__.d(loss_ops_namespaceObject, "softmaxCrossEntropy", function() { return softmaxCrossEntropy; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/linalg_ops.js
+var linalg_ops_namespaceObject = {};
+__webpack_require__.r(linalg_ops_namespaceObject);
+__webpack_require__.d(linalg_ops_namespaceObject, "bandPart", function() { return bandPart; });
+__webpack_require__.d(linalg_ops_namespaceObject, "gramSchmidt", function() { return gramSchmidt; });
+__webpack_require__.d(linalg_ops_namespaceObject, "qr", function() { return qr; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/image_ops.js
+var image_ops_namespaceObject = {};
+__webpack_require__.r(image_ops_namespaceObject);
+__webpack_require__.d(image_ops_namespaceObject, "nonMaxSuppression", function() { return nonMaxSuppression; });
+__webpack_require__.d(image_ops_namespaceObject, "resizeBilinear", function() { return resizeBilinear; });
+__webpack_require__.d(image_ops_namespaceObject, "resizeNearestNeighbor", function() { return resizeNearestNeighbor; });
+__webpack_require__.d(image_ops_namespaceObject, "nonMaxSuppressionAsync", function() { return nonMaxSuppressionAsync; });
+__webpack_require__.d(image_ops_namespaceObject, "nonMaxSuppressionWithScore", function() { return nonMaxSuppressionWithScore; });
+__webpack_require__.d(image_ops_namespaceObject, "nonMaxSuppressionWithScoreAsync", function() { return nonMaxSuppressionWithScoreAsync; });
+__webpack_require__.d(image_ops_namespaceObject, "cropAndResize", function() { return cropAndResize; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/fused_ops.js
+var fused_ops_namespaceObject = {};
+__webpack_require__.r(fused_ops_namespaceObject);
+__webpack_require__.d(fused_ops_namespaceObject, "matMul", function() { return fused_ops_matMul; });
+__webpack_require__.d(fused_ops_namespaceObject, "conv2d", function() { return fused_ops_conv2d; });
+__webpack_require__.d(fused_ops_namespaceObject, "depthwiseConv2d", function() { return fused_ops_depthwiseConv2d; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/ops/ops.js
+var ops_namespaceObject = {};
+__webpack_require__.r(ops_namespaceObject);
+__webpack_require__.d(ops_namespaceObject, "add", function() { return add; });
+__webpack_require__.d(ops_namespaceObject, "addN", function() { return addN; });
+__webpack_require__.d(ops_namespaceObject, "atan2", function() { return atan2; });
+__webpack_require__.d(ops_namespaceObject, "avgPool", function() { return avgPool; });
+__webpack_require__.d(ops_namespaceObject, "avgPool3d", function() { return avgPool3d; });
+__webpack_require__.d(ops_namespaceObject, "batchToSpaceND", function() { return batchToSpaceND; });
+__webpack_require__.d(ops_namespaceObject, "batchNorm", function() { return batchNorm; });
+__webpack_require__.d(ops_namespaceObject, "batchNorm2d", function() { return batchNorm2d; });
+__webpack_require__.d(ops_namespaceObject, "batchNorm3d", function() { return batchNorm3d; });
+__webpack_require__.d(ops_namespaceObject, "batchNorm4d", function() { return batchNorm4d; });
+__webpack_require__.d(ops_namespaceObject, "broadcastTo", function() { return broadcastTo; });
+__webpack_require__.d(ops_namespaceObject, "clone", function() { return clone; });
+__webpack_require__.d(ops_namespaceObject, "complex", function() { return complex["a" /* complex */]; });
+__webpack_require__.d(ops_namespaceObject, "concat", function() { return concat; });
+__webpack_require__.d(ops_namespaceObject, "concat1d", function() { return concat1d; });
+__webpack_require__.d(ops_namespaceObject, "concat2d", function() { return concat2d; });
+__webpack_require__.d(ops_namespaceObject, "concat3d", function() { return concat3d; });
+__webpack_require__.d(ops_namespaceObject, "concat4d", function() { return concat4d; });
+__webpack_require__.d(ops_namespaceObject, "conv1d", function() { return conv1d; });
+__webpack_require__.d(ops_namespaceObject, "conv2d", function() { return conv2d; });
+__webpack_require__.d(ops_namespaceObject, "conv2dTranspose", function() { return conv2dTranspose; });
+__webpack_require__.d(ops_namespaceObject, "conv3d", function() { return conv3d; });
+__webpack_require__.d(ops_namespaceObject, "conv3dTranspose", function() { return conv3dTranspose; });
+__webpack_require__.d(ops_namespaceObject, "cumsum", function() { return cumsum; });
+__webpack_require__.d(ops_namespaceObject, "depthToSpace", function() { return depthToSpace; });
+__webpack_require__.d(ops_namespaceObject, "depthwiseConv2d", function() { return depthwiseConv2d; });
+__webpack_require__.d(ops_namespaceObject, "diag", function() { return diag; });
+__webpack_require__.d(ops_namespaceObject, "div", function() { return div; });
+__webpack_require__.d(ops_namespaceObject, "divNoNan", function() { return divNoNan; });
+__webpack_require__.d(ops_namespaceObject, "dot", function() { return dot; });
+__webpack_require__.d(ops_namespaceObject, "elu", function() { return elu; });
+__webpack_require__.d(ops_namespaceObject, "equal", function() { return equal; });
+__webpack_require__.d(ops_namespaceObject, "eye", function() { return eye; });
+__webpack_require__.d(ops_namespaceObject, "fill", function() { return fill; });
+__webpack_require__.d(ops_namespaceObject, "floorDiv", function() { return floorDiv; });
+__webpack_require__.d(ops_namespaceObject, "greater", function() { return greater; });
+__webpack_require__.d(ops_namespaceObject, "greaterEqual", function() { return greaterEqual; });
+__webpack_require__.d(ops_namespaceObject, "imag", function() { return imag["a" /* imag */]; });
+__webpack_require__.d(ops_namespaceObject, "leakyRelu", function() { return leakyRelu; });
+__webpack_require__.d(ops_namespaceObject, "less", function() { return less; });
+__webpack_require__.d(ops_namespaceObject, "lessEqual", function() { return lessEqual; });
+__webpack_require__.d(ops_namespaceObject, "localResponseNormalization", function() { return localResponseNormalization; });
+__webpack_require__.d(ops_namespaceObject, "matMul", function() { return matMul; });
+__webpack_require__.d(ops_namespaceObject, "max", function() { return max_max; });
+__webpack_require__.d(ops_namespaceObject, "maxPool", function() { return maxPool; });
+__webpack_require__.d(ops_namespaceObject, "maxPool3d", function() { return maxPool3d; });
+__webpack_require__.d(ops_namespaceObject, "maxPoolWithArgmax", function() { return maxPoolWithArgmax; });
+__webpack_require__.d(ops_namespaceObject, "maximum", function() { return maximum; });
+__webpack_require__.d(ops_namespaceObject, "minimum", function() { return minimum; });
+__webpack_require__.d(ops_namespaceObject, "mod", function() { return mod; });
+__webpack_require__.d(ops_namespaceObject, "mul", function() { return mul; });
+__webpack_require__.d(ops_namespaceObject, "multinomial", function() { return multinomial; });
+__webpack_require__.d(ops_namespaceObject, "notEqual", function() { return notEqual; });
+__webpack_require__.d(ops_namespaceObject, "oneHot", function() { return oneHot; });
+__webpack_require__.d(ops_namespaceObject, "outerProduct", function() { return outerProduct; });
+__webpack_require__.d(ops_namespaceObject, "pad", function() { return pad_pad; });
+__webpack_require__.d(ops_namespaceObject, "pad1d", function() { return pad1d; });
+__webpack_require__.d(ops_namespaceObject, "pad2d", function() { return pad2d; });
+__webpack_require__.d(ops_namespaceObject, "pad3d", function() { return pad3d; });
+__webpack_require__.d(ops_namespaceObject, "pad4d", function() { return pad4d; });
+__webpack_require__.d(ops_namespaceObject, "pool", function() { return pool; });
+__webpack_require__.d(ops_namespaceObject, "pow", function() { return pow; });
+__webpack_require__.d(ops_namespaceObject, "prelu", function() { return prelu; });
+__webpack_require__.d(ops_namespaceObject, "rand", function() { return rand; });
+__webpack_require__.d(ops_namespaceObject, "randomGamma", function() { return randomGamma; });
+__webpack_require__.d(ops_namespaceObject, "randomNormal", function() { return randomNormal; });
+__webpack_require__.d(ops_namespaceObject, "randomUniform", function() { return randomUniform; });
+__webpack_require__.d(ops_namespaceObject, "real", function() { return real["a" /* real */]; });
+__webpack_require__.d(ops_namespaceObject, "relu", function() { return relu; });
+__webpack_require__.d(ops_namespaceObject, "relu6", function() { return relu6; });
+__webpack_require__.d(ops_namespaceObject, "selu", function() { return selu; });
+__webpack_require__.d(ops_namespaceObject, "separableConv2d", function() { return separableConv2d; });
+__webpack_require__.d(ops_namespaceObject, "spaceToBatchND", function() { return spaceToBatchND; });
+__webpack_require__.d(ops_namespaceObject, "split", function() { return split; });
+__webpack_require__.d(ops_namespaceObject, "square", function() { return square; });
+__webpack_require__.d(ops_namespaceObject, "squaredDifference", function() { return squaredDifference; });
+__webpack_require__.d(ops_namespaceObject, "sub", function() { return sub; });
+__webpack_require__.d(ops_namespaceObject, "tile", function() { return tile; });
+__webpack_require__.d(ops_namespaceObject, "truncatedNormal", function() { return truncatedNormal; });
+__webpack_require__.d(ops_namespaceObject, "booleanMaskAsync", function() { return booleanMaskAsync; });
+__webpack_require__.d(ops_namespaceObject, "reverse", function() { return reverse_reverse; });
+__webpack_require__.d(ops_namespaceObject, "reverse1d", function() { return reverse1d; });
+__webpack_require__.d(ops_namespaceObject, "reverse2d", function() { return reverse2d; });
+__webpack_require__.d(ops_namespaceObject, "reverse3d", function() { return reverse3d; });
+__webpack_require__.d(ops_namespaceObject, "reverse4d", function() { return reverse4d; });
+__webpack_require__.d(ops_namespaceObject, "slice", function() { return slice; });
+__webpack_require__.d(ops_namespaceObject, "slice1d", function() { return slice1d; });
+__webpack_require__.d(ops_namespaceObject, "slice2d", function() { return slice2d; });
+__webpack_require__.d(ops_namespaceObject, "slice3d", function() { return slice3d; });
+__webpack_require__.d(ops_namespaceObject, "slice4d", function() { return slice4d; });
+__webpack_require__.d(ops_namespaceObject, "abs", function() { return abs; });
+__webpack_require__.d(ops_namespaceObject, "acos", function() { return acos; });
+__webpack_require__.d(ops_namespaceObject, "acosh", function() { return acosh; });
+__webpack_require__.d(ops_namespaceObject, "asin", function() { return asin; });
+__webpack_require__.d(ops_namespaceObject, "asinh", function() { return asinh; });
+__webpack_require__.d(ops_namespaceObject, "atan", function() { return atan; });
+__webpack_require__.d(ops_namespaceObject, "atanh", function() { return atanh; });
+__webpack_require__.d(ops_namespaceObject, "ceil", function() { return ceil; });
+__webpack_require__.d(ops_namespaceObject, "clipByValue", function() { return clipByValue; });
+__webpack_require__.d(ops_namespaceObject, "cos", function() { return cos; });
+__webpack_require__.d(ops_namespaceObject, "cosh", function() { return cosh; });
+__webpack_require__.d(ops_namespaceObject, "erf", function() { return erf; });
+__webpack_require__.d(ops_namespaceObject, "exp", function() { return unary_ops_exp; });
+__webpack_require__.d(ops_namespaceObject, "expm1", function() { return expm1; });
+__webpack_require__.d(ops_namespaceObject, "floor", function() { return floor; });
+__webpack_require__.d(ops_namespaceObject, "log", function() { return log; });
+__webpack_require__.d(ops_namespaceObject, "log1p", function() { return log1p; });
+__webpack_require__.d(ops_namespaceObject, "logSigmoid", function() { return logSigmoid; });
+__webpack_require__.d(ops_namespaceObject, "neg", function() { return neg; });
+__webpack_require__.d(ops_namespaceObject, "reciprocal", function() { return reciprocal; });
+__webpack_require__.d(ops_namespaceObject, "round", function() { return round; });
+__webpack_require__.d(ops_namespaceObject, "rsqrt", function() { return rsqrt; });
+__webpack_require__.d(ops_namespaceObject, "sigmoid", function() { return sigmoid; });
+__webpack_require__.d(ops_namespaceObject, "sign", function() { return sign; });
+__webpack_require__.d(ops_namespaceObject, "isNaN", function() { return unary_ops_isNaN; });
+__webpack_require__.d(ops_namespaceObject, "isInf", function() { return isInf; });
+__webpack_require__.d(ops_namespaceObject, "isFinite", function() { return unary_ops_isFinite; });
+__webpack_require__.d(ops_namespaceObject, "sin", function() { return sin; });
+__webpack_require__.d(ops_namespaceObject, "sinh", function() { return sinh; });
+__webpack_require__.d(ops_namespaceObject, "softplus", function() { return softplus; });
+__webpack_require__.d(ops_namespaceObject, "sqrt", function() { return sqrt; });
+__webpack_require__.d(ops_namespaceObject, "step", function() { return unary_ops_step; });
+__webpack_require__.d(ops_namespaceObject, "tan", function() { return tan; });
+__webpack_require__.d(ops_namespaceObject, "tanh", function() { return tanh; });
+__webpack_require__.d(ops_namespaceObject, "all", function() { return reduction_ops_all; });
+__webpack_require__.d(ops_namespaceObject, "any", function() { return any; });
+__webpack_require__.d(ops_namespaceObject, "argMax", function() { return argMax; });
+__webpack_require__.d(ops_namespaceObject, "argMin", function() { return argMin; });
+__webpack_require__.d(ops_namespaceObject, "logSumExp", function() { return logSumExp; });
+__webpack_require__.d(ops_namespaceObject, "mean", function() { return reduction_ops_mean; });
+__webpack_require__.d(ops_namespaceObject, "min", function() { return reduction_ops_min; });
+__webpack_require__.d(ops_namespaceObject, "moments", function() { return moments; });
+__webpack_require__.d(ops_namespaceObject, "sum", function() { return sum; });
+__webpack_require__.d(ops_namespaceObject, "prod", function() { return reduction_ops_prod; });
+__webpack_require__.d(ops_namespaceObject, "equalStrict", function() { return equalStrict; });
+__webpack_require__.d(ops_namespaceObject, "greaterEqualStrict", function() { return greaterEqualStrict; });
+__webpack_require__.d(ops_namespaceObject, "greaterStrict", function() { return greaterStrict; });
+__webpack_require__.d(ops_namespaceObject, "lessEqualStrict", function() { return lessEqualStrict; });
+__webpack_require__.d(ops_namespaceObject, "lessStrict", function() { return lessStrict; });
+__webpack_require__.d(ops_namespaceObject, "notEqualStrict", function() { return notEqualStrict; });
+__webpack_require__.d(ops_namespaceObject, "addStrict", function() { return addStrict; });
+__webpack_require__.d(ops_namespaceObject, "divStrict", function() { return divStrict; });
+__webpack_require__.d(ops_namespaceObject, "maximumStrict", function() { return maximumStrict; });
+__webpack_require__.d(ops_namespaceObject, "minimumStrict", function() { return minimumStrict; });
+__webpack_require__.d(ops_namespaceObject, "modStrict", function() { return modStrict; });
+__webpack_require__.d(ops_namespaceObject, "mulStrict", function() { return mulStrict; });
+__webpack_require__.d(ops_namespaceObject, "powStrict", function() { return powStrict; });
+__webpack_require__.d(ops_namespaceObject, "squaredDifferenceStrict", function() { return squaredDifferenceStrict; });
+__webpack_require__.d(ops_namespaceObject, "subStrict", function() { return subStrict; });
+__webpack_require__.d(ops_namespaceObject, "logicalAnd", function() { return logicalAnd; });
+__webpack_require__.d(ops_namespaceObject, "logicalNot", function() { return logicalNot; });
+__webpack_require__.d(ops_namespaceObject, "logicalOr", function() { return logicalOr; });
+__webpack_require__.d(ops_namespaceObject, "logicalXor", function() { return logicalXor; });
+__webpack_require__.d(ops_namespaceObject, "where", function() { return where; });
+__webpack_require__.d(ops_namespaceObject, "whereAsync", function() { return whereAsync; });
+__webpack_require__.d(ops_namespaceObject, "buffer", function() { return array_ops_buffer; });
+__webpack_require__.d(ops_namespaceObject, "print", function() { return print; });
+__webpack_require__.d(ops_namespaceObject, "cast", function() { return cast; });
+__webpack_require__.d(ops_namespaceObject, "expandDims", function() { return expandDims; });
+__webpack_require__.d(ops_namespaceObject, "reshape", function() { return reshape; });
+__webpack_require__.d(ops_namespaceObject, "squeeze", function() { return squeeze; });
+__webpack_require__.d(ops_namespaceObject, "stack", function() { return stack; });
+__webpack_require__.d(ops_namespaceObject, "unstack", function() { return unstack; });
+__webpack_require__.d(ops_namespaceObject, "setdiff1dAsync", function() { return setdiff1dAsync; });
+__webpack_require__.d(ops_namespaceObject, "linspace", function() { return tensor_ops["a" /* linspace */]; });
+__webpack_require__.d(ops_namespaceObject, "ones", function() { return tensor_ops["b" /* ones */]; });
+__webpack_require__.d(ops_namespaceObject, "range", function() { return tensor_ops["d" /* range */]; });
+__webpack_require__.d(ops_namespaceObject, "scalar", function() { return tensor_ops["e" /* scalar */]; });
+__webpack_require__.d(ops_namespaceObject, "tensor", function() { return tensor_ops["f" /* tensor */]; });
+__webpack_require__.d(ops_namespaceObject, "tensor1d", function() { return tensor_ops["g" /* tensor1d */]; });
+__webpack_require__.d(ops_namespaceObject, "tensor2d", function() { return tensor_ops["h" /* tensor2d */]; });
+__webpack_require__.d(ops_namespaceObject, "tensor3d", function() { return tensor_ops["i" /* tensor3d */]; });
+__webpack_require__.d(ops_namespaceObject, "tensor4d", function() { return tensor_ops["j" /* tensor4d */]; });
+__webpack_require__.d(ops_namespaceObject, "tensor5d", function() { return tensor_ops["k" /* tensor5d */]; });
+__webpack_require__.d(ops_namespaceObject, "tensor6d", function() { return tensor_ops["l" /* tensor6d */]; });
+__webpack_require__.d(ops_namespaceObject, "variable", function() { return tensor_ops["m" /* variable */]; });
+__webpack_require__.d(ops_namespaceObject, "zeros", function() { return tensor_ops["n" /* zeros */]; });
+__webpack_require__.d(ops_namespaceObject, "onesLike", function() { return tensor_ops["c" /* onesLike */]; });
+__webpack_require__.d(ops_namespaceObject, "zerosLike", function() { return tensor_ops["o" /* zerosLike */]; });
+__webpack_require__.d(ops_namespaceObject, "transpose", function() { return transpose; });
+__webpack_require__.d(ops_namespaceObject, "softmax", function() { return softmax; });
+__webpack_require__.d(ops_namespaceObject, "logSoftmax", function() { return logSoftmax; });
+__webpack_require__.d(ops_namespaceObject, "norm", function() { return norm_norm; });
+__webpack_require__.d(ops_namespaceObject, "gather", function() { return gather; });
+__webpack_require__.d(ops_namespaceObject, "unsortedSegmentSum", function() { return unsortedSegmentSum; });
+__webpack_require__.d(ops_namespaceObject, "basicLSTMCell", function() { return basicLSTMCell; });
+__webpack_require__.d(ops_namespaceObject, "multiRNNCell", function() { return multiRNNCell; });
+__webpack_require__.d(ops_namespaceObject, "movingAverage", function() { return movingAverage; });
+__webpack_require__.d(ops_namespaceObject, "stridedSlice", function() { return stridedSlice; });
+__webpack_require__.d(ops_namespaceObject, "topk", function() { return topk; });
+__webpack_require__.d(ops_namespaceObject, "scatterND", function() { return scatterND; });
+__webpack_require__.d(ops_namespaceObject, "fft", function() { return fft; });
+__webpack_require__.d(ops_namespaceObject, "ifft", function() { return ifft; });
+__webpack_require__.d(ops_namespaceObject, "rfft", function() { return rfft; });
+__webpack_require__.d(ops_namespaceObject, "irfft", function() { return irfft; });
+__webpack_require__.d(ops_namespaceObject, "sparseToDense", function() { return sparseToDense; });
+__webpack_require__.d(ops_namespaceObject, "gatherND", function() { return gatherND; });
+__webpack_require__.d(ops_namespaceObject, "dropout", function() { return dropout; });
+__webpack_require__.d(ops_namespaceObject, "hannWindow", function() { return hannWindow; });
+__webpack_require__.d(ops_namespaceObject, "hammingWindow", function() { return hammingWindow; });
+__webpack_require__.d(ops_namespaceObject, "frame", function() { return signal_ops_frame; });
+__webpack_require__.d(ops_namespaceObject, "stft", function() { return stft; });
+__webpack_require__.d(ops_namespaceObject, "inTopKAsync", function() { return inTopKAsync; });
+__webpack_require__.d(ops_namespaceObject, "op", function() { return operation["a" /* op */]; });
+__webpack_require__.d(ops_namespaceObject, "image", function() { return image_ops_namespaceObject; });
+__webpack_require__.d(ops_namespaceObject, "linalg", function() { return linalg_ops_namespaceObject; });
+__webpack_require__.d(ops_namespaceObject, "losses", function() { return loss_ops_namespaceObject; });
+__webpack_require__.d(ops_namespaceObject, "spectral", function() { return spectral_ops_namespaceObject; });
+__webpack_require__.d(ops_namespaceObject, "fused", function() { return fused_ops_namespaceObject; });
+__webpack_require__.d(ops_namespaceObject, "signal", function() { return signal_ops_namespaceObject; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/backends/backend_util.js
+var backend_util_namespaceObject = {};
+__webpack_require__.r(backend_util_namespaceObject);
+__webpack_require__.d(backend_util_namespaceObject, "axesAreInnerMostDims", function() { return axesAreInnerMostDims; });
+__webpack_require__.d(backend_util_namespaceObject, "combineLocations", function() { return combineLocations; });
+__webpack_require__.d(backend_util_namespaceObject, "computeOutAndReduceShapes", function() { return computeOutAndReduceShapes; });
+__webpack_require__.d(backend_util_namespaceObject, "expandShapeToKeepDim", function() { return expandShapeToKeepDim; });
+__webpack_require__.d(backend_util_namespaceObject, "assertAxesAreInnerMostDims", function() { return assertAxesAreInnerMostDims; });
+__webpack_require__.d(backend_util_namespaceObject, "getAxesPermutation", function() { return getAxesPermutation; });
+__webpack_require__.d(backend_util_namespaceObject, "getUndoAxesPermutation", function() { return getUndoAxesPermutation; });
+__webpack_require__.d(backend_util_namespaceObject, "getInnerMostAxes", function() { return getInnerMostAxes; });
+__webpack_require__.d(backend_util_namespaceObject, "getBroadcastDims", function() { return getBroadcastDims; });
+__webpack_require__.d(backend_util_namespaceObject, "getReductionAxes", function() { return getReductionAxes; });
+__webpack_require__.d(backend_util_namespaceObject, "assertAndGetBroadcastShape", function() { return assertAndGetBroadcastShape; });
+__webpack_require__.d(backend_util_namespaceObject, "assertParamsConsistent", function() { return assertParamsConsistent; });
+__webpack_require__.d(backend_util_namespaceObject, "computeOutShape", function() { return computeOutShape; });
+__webpack_require__.d(backend_util_namespaceObject, "computePool2DInfo", function() { return computePool2DInfo; });
+__webpack_require__.d(backend_util_namespaceObject, "computePool3DInfo", function() { return computePool3DInfo; });
+__webpack_require__.d(backend_util_namespaceObject, "computeConv2DInfo", function() { return computeConv2DInfo; });
+__webpack_require__.d(backend_util_namespaceObject, "computeConv3DInfo", function() { return computeConv3DInfo; });
+__webpack_require__.d(backend_util_namespaceObject, "computeDefaultPad", function() { return computeDefaultPad; });
+__webpack_require__.d(backend_util_namespaceObject, "tupleValuesAreOne", function() { return tupleValuesAreOne; });
+__webpack_require__.d(backend_util_namespaceObject, "eitherStridesOrDilationsAreOne", function() { return eitherStridesOrDilationsAreOne; });
+__webpack_require__.d(backend_util_namespaceObject, "convertConv2DDataFormat", function() { return convertConv2DDataFormat; });
+__webpack_require__.d(backend_util_namespaceObject, "PARALLELIZE_THRESHOLD", function() { return PARALLELIZE_THRESHOLD; });
+__webpack_require__.d(backend_util_namespaceObject, "computeOptimalWindowSize", function() { return computeOptimalWindowSize; });
+__webpack_require__.d(backend_util_namespaceObject, "nonMaxSuppressionV3", function() { return nonMaxSuppressionV3; });
+__webpack_require__.d(backend_util_namespaceObject, "nonMaxSuppressionV5", function() { return nonMaxSuppressionV5; });
+__webpack_require__.d(backend_util_namespaceObject, "upcastType", function() { return dist_types["c" /* upcastType */]; });
+__webpack_require__.d(backend_util_namespaceObject, "getReshaped", function() { return getReshaped; });
+__webpack_require__.d(backend_util_namespaceObject, "getPermuted", function() { return getPermuted; });
+__webpack_require__.d(backend_util_namespaceObject, "getReshapedPermuted", function() { return getReshapedPermuted; });
+__webpack_require__.d(backend_util_namespaceObject, "getSliceBeginCoords", function() { return getSliceBeginCoords; });
+__webpack_require__.d(backend_util_namespaceObject, "getSliceSize", function() { return getSliceSize; });
+__webpack_require__.d(backend_util_namespaceObject, "prepareAndValidate", function() { return prepareAndValidate; });
+__webpack_require__.d(backend_util_namespaceObject, "validateUpdateShape", function() { return validateUpdateShape; });
+__webpack_require__.d(backend_util_namespaceObject, "validateInput", function() { return validateInput; });
+__webpack_require__.d(backend_util_namespaceObject, "calculateShapes", function() { return calculateShapes; });
+__webpack_require__.d(backend_util_namespaceObject, "SELU_SCALEALPHA", function() { return SELU_SCALEALPHA; });
+__webpack_require__.d(backend_util_namespaceObject, "SELU_SCALE", function() { return SELU_SCALE; });
+__webpack_require__.d(backend_util_namespaceObject, "shouldFuse", function() { return shouldFuse; });
+__webpack_require__.d(backend_util_namespaceObject, "ERF_P", function() { return ERF_P; });
+__webpack_require__.d(backend_util_namespaceObject, "ERF_A1", function() { return ERF_A1; });
+__webpack_require__.d(backend_util_namespaceObject, "ERF_A2", function() { return ERF_A2; });
+__webpack_require__.d(backend_util_namespaceObject, "ERF_A3", function() { return ERF_A3; });
+__webpack_require__.d(backend_util_namespaceObject, "ERF_A4", function() { return ERF_A4; });
+__webpack_require__.d(backend_util_namespaceObject, "ERF_A5", function() { return ERF_A5; });
+__webpack_require__.d(backend_util_namespaceObject, "warn", function() { return warn; });
+__webpack_require__.d(backend_util_namespaceObject, "log", function() { return log_log; });
+__webpack_require__.d(backend_util_namespaceObject, "mergeRealAndImagArrays", function() { return mergeRealAndImagArrays; });
+__webpack_require__.d(backend_util_namespaceObject, "splitRealAndImagArrays", function() { return splitRealAndImagArrays; });
+__webpack_require__.d(backend_util_namespaceObject, "complexWithEvenIndex", function() { return complexWithEvenIndex; });
+__webpack_require__.d(backend_util_namespaceObject, "complexWithOddIndex", function() { return complexWithOddIndex; });
+__webpack_require__.d(backend_util_namespaceObject, "getComplexWithIndex", function() { return getComplexWithIndex; });
+__webpack_require__.d(backend_util_namespaceObject, "assignToTypedArray", function() { return assignToTypedArray; });
+__webpack_require__.d(backend_util_namespaceObject, "exponents", function() { return exponents; });
+__webpack_require__.d(backend_util_namespaceObject, "exponent", function() { return exponent; });
+__webpack_require__.d(backend_util_namespaceObject, "segment_util", function() { return segment_util_namespaceObject; });
+__webpack_require__.d(backend_util_namespaceObject, "castTensor", function() { return castTensor; });
+__webpack_require__.d(backend_util_namespaceObject, "reshapeTensor", function() { return reshapeTensor; });
+__webpack_require__.d(backend_util_namespaceObject, "linspaceImpl", function() { return linspaceImpl; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-core/dist/backends/kernel_impls.js
+var kernel_impls_namespaceObject = {};
+__webpack_require__.r(kernel_impls_namespaceObject);
+__webpack_require__.d(kernel_impls_namespaceObject, "nonMaxSuppressionV3", function() { return nonMaxSuppressionV3; });
+__webpack_require__.d(kernel_impls_namespaceObject, "nonMaxSuppressionV5", function() { return nonMaxSuppressionV5; });
+__webpack_require__.d(kernel_impls_namespaceObject, "split", function() { return split_shared_split; });
+__webpack_require__.d(kernel_impls_namespaceObject, "tile", function() { return tile_impl_tile; });
+__webpack_require__.d(kernel_impls_namespaceObject, "topkImpl", function() { return topkImpl; });
+__webpack_require__.d(kernel_impls_namespaceObject, "whereImpl", function() { return whereImpl; });
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/engine.js + 2 modules
+var engine = __webpack_require__(5);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/flags.js
+var flags = __webpack_require__(61);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/kernel_names.js
+var kernel_names = __webpack_require__(6);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/broadcast_util.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Returns the dimensions in the input shape that are broadcasted to
+ * produce the provided output shape.
+ *
+ * The returned dimensions are 0-indexed and sorted. An example:
+ * inShape = [4, 1, 3]
+ * outShape = [5, 4, 3, 3]
+ * result = [1]. Dimension 1 (2nd dimension of input) gets broadcasted 1 => 3.
+ */
+function getBroadcastDims(inShape, outShape) {
+ const inRank = inShape.length;
+ const dims = [];
+ for (let i = 0; i < inRank; i++) {
+ const dim = inRank - 1 - i;
+ const a = inShape[dim] || 1;
+ const b = outShape[outShape.length - 1 - i] || 1;
+ if (b > 1 && a === 1) {
+ dims.unshift(dim);
+ }
+ }
+ return dims;
+}
+/**
+ * Returns the axes in the output space that should be reduced to produce
+ * the input space.
+ */
+function getReductionAxes(inShape, outShape) {
+ const result = [];
+ for (let i = 0; i < outShape.length; i++) {
+ const inDim = inShape[inShape.length - i - 1];
+ const outAxis = outShape.length - i - 1;
+ const outDim = outShape[outAxis];
+ if (inDim == null || (inDim === 1 && outDim > 1)) {
+ result.unshift(outAxis);
+ }
+ }
+ return result;
+}
+function assertAndGetBroadcastShape(shapeA, shapeB) {
+ const result = [];
+ const l = Math.max(shapeA.length, shapeB.length);
+ for (let i = 0; i < l; i++) {
+ let a = shapeA[shapeA.length - i - 1];
+ if (a == null) {
+ a = 1;
+ }
+ let b = shapeB[shapeB.length - i - 1];
+ if (b == null) {
+ b = 1;
+ }
+ if (a === 1) {
+ result.unshift(b);
+ }
+ else if (b === 1) {
+ result.unshift(a);
+ }
+ else if (a !== b) {
+ const errMsg = `Operands could not be broadcast together with shapes ` +
+ `${shapeA} and ${shapeB}.`;
+ throw Error(errMsg);
+ }
+ else {
+ result.unshift(a);
+ }
+ }
+ return result;
+}
+//# sourceMappingURL=broadcast_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Add_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const addGradConfig = {
+ kernelName: kernel_names["a" /* Add */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
+ const derA = () => {
+ let res = dy;
+ const reduceAxes = getReductionAxes(a.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = res.sum(reduceAxes);
+ }
+ return res.reshape(a.shape);
+ };
+ const derB = () => {
+ let res = dy;
+ const reduceAxes = getReductionAxes(b.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = res.sum(reduceAxes);
+ }
+ return res.reshape(b.shape);
+ };
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=Add_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/AddN_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+const addNGradConfig = {
+ kernelName: kernel_names["b" /* AddN */],
+ saveAllInputs: true,
+ gradFunc: (dy, saved) => {
+ const ders = {};
+ saved.forEach((_, i) => {
+ ders[i] = () => dy.clone();
+ });
+ return ders;
+ }
+};
+//# sourceMappingURL=AddN_grad.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/tensor_util.js
+var tensor_util = __webpack_require__(11);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/tensor_util_env.js
+var tensor_util_env = __webpack_require__(3);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/operation.js
+var operation = __webpack_require__(4);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/add.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Adds two `tf.Tensor`s element-wise, A + B. Supports broadcasting.
+ *
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3, 4]);
+ * const b = tf.tensor1d([10, 20, 30, 40]);
+ *
+ * a.add(b).print(); // or tf.add(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast add a with b.
+ * const a = tf.scalar(5);
+ * const b = tf.tensor1d([10, 20, 30, 40]);
+ *
+ * a.add(b).print(); // or tf.add(a, b)
+ * ```
+ * @param a The first `tf.Tensor` to add.
+ * @param b The second `tf.Tensor` to add. Must have the same type as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function add_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'add');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'add');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ const forward = (backend, save) => {
+ const res = backend.add($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["a" /* Add */]);
+}
+const add = Object(operation["a" /* op */])({ add_ });
+//# sourceMappingURL=add.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/tensor.js + 1 modules
+var dist_tensor = __webpack_require__(7);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/util.js
+var util = __webpack_require__(1);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/concat_util.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function assertParamsConsistent(shapes, axis) {
+ const rank = shapes[0].length;
+ shapes.forEach((shape, i) => {
+ util["assert"](shape.length === rank, () => `Error in concat${rank}D: rank of tensors[${i}] must be the same ` +
+ `as the rank of the rest (${rank})`);
+ });
+ util["assert"](axis >= 0 && axis < rank, () => `Error in concat${rank}D: axis must be between 0 and ${rank - 1}.`);
+ const firstShape = shapes[0];
+ shapes.forEach((shape, i) => {
+ for (let r = 0; r < rank; r++) {
+ util["assert"]((r === axis) || (shape[r] === firstShape[r]), () => `Error in concat${rank}D: Shape of tensors[${i}] (${shape}) ` +
+ `does not match the shape of the rest (${firstShape}) ` +
+ `along the non-concatenated axis ${i}.`);
+ }
+ });
+}
+function computeOutShape(shapes, axis) {
+ const outputShape = shapes[0].slice();
+ for (let i = 1; i < shapes.length; i++) {
+ outputShape[axis] += shapes[i][axis];
+ }
+ return outputShape;
+}
+//# sourceMappingURL=concat_util.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/tensor_ops.js
+var tensor_ops = __webpack_require__(8);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/concat.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Concatenates a list of `tf.Tensor`s along a given axis.
+ *
+ * The tensors ranks and types must match, and their sizes must match in all
+ * dimensions except `axis`.
+ *
+ * Also available are stricter rank-specific methods that assert that
+ * `tensors` are of the given rank:
+ * - `tf.concat1d`
+ * - `tf.concat2d`
+ * - `tf.concat3d`
+ * - `tf.concat4d`
+ *
+ * Except `tf.concat1d` (which does not have axis param), all methods have
+ * same signature as this method.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2]);
+ * const b = tf.tensor1d([3, 4]);
+ * a.concat(b).print(); // or a.concat(b)
+ * ```
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2]);
+ * const b = tf.tensor1d([3, 4]);
+ * const c = tf.tensor1d([5, 6]);
+ * tf.concat([a, b, c]).print();
+ * ```
+ *
+ * ```js
+ * const a = tf.tensor2d([[1, 2], [10, 20]]);
+ * const b = tf.tensor2d([[3, 4], [30, 40]]);
+ * const axis = 1;
+ * tf.concat([a, b], axis).print();
+ * ```
+ * @param tensors A list of tensors to concatenate.
+ * @param axis The axis to concate along. Defaults to 0 (the first dim).
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+function concat_(tensors, axis = 0) {
+ Object(util["assert"])(tensors.length >= 1, () => 'Pass at least one tensor to concat');
+ let $tensors = Object(tensor_util_env["b" /* convertToTensorArray */])(tensors, 'tensors', 'concat');
+ if ($tensors[0].dtype === 'complex64') {
+ $tensors.forEach(tensor => {
+ if (tensor.dtype !== 'complex64') {
+ throw new Error(`Cannot concatenate complex64 tensors with a tensor
+ with dtype ${tensor.dtype}. `);
+ }
+ });
+ }
+ const $axis = Object(util["parseAxisParam"])(axis, $tensors[0].shape)[0];
+ const outShape = computeOutShape($tensors.map(t => t.shape), $axis);
+ if (Object(util["sizeFromShape"])(outShape) === 0) {
+ return Object(tensor_ops["f" /* tensor */])([], outShape);
+ }
+ // Keep only non-empty tensors (ignore tensors with 0 in their shape).
+ $tensors = $tensors.filter(t => t.size > 0);
+ if ($tensors.length === 1) {
+ return $tensors[0];
+ }
+ const shapes = $tensors.map(t => t.shape);
+ assertParamsConsistent(shapes, $axis);
+ const forward = (backend, save) => {
+ const res = backend.concat($tensors, $axis);
+ save($tensors);
+ return res;
+ };
+ const inputs = $tensors;
+ const attr = { axis };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["l" /* Concat */], attr);
+}
+const concat = Object(operation["a" /* op */])({ concat_ });
+//# sourceMappingURL=concat.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/array_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Reshapes a `tf.Tensor` to a given shape.
+ *
+ * Given an input tensor, returns a new tensor with the same values as the
+ * input tensor with shape `shape`.
+ *
+ * If one component of shape is the special value -1, the size of that
+ * dimension is computed so that the total size remains constant. In
+ * particular, a shape of [-1] flattens into 1-D. At most one component of
+ * shape can be -1.
+ *
+ * If shape is 1-D or higher, then the operation returns a tensor with shape
+ * shape filled with the values of tensor. In this case, the number of
+ * elements implied by shape must be the same as the number of elements in
+ * tensor.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ * x.reshape([2, 2]).print();
+ * ```
+ *
+ * @param x The input tensor to be reshaped.
+ * @param shape An array of integers defining the output tensor shape.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function reshape_(x, shape) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'reshape', null);
+ shape = util["inferFromImplicitShape"](shape, $x.size);
+ util["assert"]($x.size === util["sizeFromShape"](shape), () => 'new shape and old shape must have the same number of elements.');
+ const grad = (dy) => {
+ return { x: () => dy.reshape($x.shape) };
+ };
+ const attrs = { shape };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.reshape($x, shape), { x: $x }, grad, 'Reshape', attrs);
+}
+/**
+ * Removes dimensions of size 1 from the shape of a `tf.Tensor`.
+ *
+ * ```js
+ * const x = tf.tensor([1, 2, 3, 4], [1, 1, 4]);
+ * x.squeeze().print();
+ * ```
+ *
+ * @param x The input tensor to be squeezed.
+ * @param axis An optional list of numbers. If specified, only
+ * squeezes the dimensions listed. The dimension index starts at 0. It
+ * is an error to squeeze a dimension that is not 1.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function squeeze_(x, axis) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'squeeze');
+ return reshape($x, util["squeezeShape"]($x.shape, axis).newShape);
+}
+/**
+ * Casts a `tf.Tensor` to a new dtype.
+ *
+ * ```js
+ * const x = tf.tensor1d([1.5, 2.5, 3]);
+ * tf.cast(x, 'int32').print();
+ * ```
+ * @param x The input tensor to be casted.
+ * @param dtype The dtype to cast the input tensor to.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function cast_(x, dtype) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'cast');
+ // Sanity checks.
+ if (!util["isValidDtype"](dtype)) {
+ throw new Error(`Failed to cast to unknown dtype ${dtype}`);
+ }
+ if (dtype === 'string' && $x.dtype !== 'string' ||
+ dtype !== 'string' && $x.dtype === 'string') {
+ throw new Error('Only strings can be casted to strings');
+ }
+ const grad = (dy) => {
+ return { x: () => dy.clone() };
+ };
+ const attrs = { dtype };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.cast($x, dtype), { x: $x }, grad, 'Cast', attrs);
+}
+/**
+ * Stacks a list of rank-`R` `tf.Tensor`s into one rank-`(R+1)` `tf.Tensor`.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2]);
+ * const b = tf.tensor1d([3, 4]);
+ * const c = tf.tensor1d([5, 6]);
+ * tf.stack([a, b, c]).print();
+ * ```
+ *
+ * @param tensors A list of tensor objects with the same shape and dtype.
+ * @param axis The axis to stack along. Defaults to 0 (the first dim).
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+function stack_(tensors, axis = 0) {
+ const $tensors = Object(tensor_util_env["b" /* convertToTensorArray */])(tensors, 'tensors', 'stack');
+ util["assert"]($tensors.length >= 1, () => 'Pass at least one tensor to tf.stack');
+ if ($tensors.length === 1) {
+ return $tensors[0].expandDims(axis);
+ }
+ const rank = $tensors[0].rank;
+ const shape = $tensors[0].shape;
+ const dtype = $tensors[0].dtype;
+ util["assert"](axis <= rank, () => 'Axis must be <= rank of the tensor');
+ $tensors.forEach(t => {
+ util["assertShapesMatch"](shape, t.shape, 'All tensors passed to stack must have matching shapes');
+ });
+ $tensors.forEach(t => {
+ util["assert"](dtype === t.dtype, () => 'All tensors passed to stack must have matching dtypes');
+ });
+ const expandedTensors = $tensors.map(t => t.expandDims(axis));
+ return concat(expandedTensors, axis);
+}
+/**
+ * Unstacks a `tf.Tensor` of rank-`R` into a list of rank-`(R-1)` `tf.Tensor`s.
+ *
+ * ```js
+ * const a = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * tf.unstack(a).forEach(tensor => tensor.print());
+ * ```
+ *
+ * @param x A tensor object.
+ * @param axis The axis to unstack along. Defaults to 0 (the first dim).
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+function unstack_(x, axis = 0) {
+ axis = axis || 0;
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'unstack');
+ util["assert"](axis >= -$x.shape.length && axis < $x.shape.length, () => `Axis = ${axis} is not in [-${$x.shape.length}, ${$x.shape.length})`);
+ if (axis < 0) {
+ axis += $x.shape.length;
+ }
+ const grad = (dy) => {
+ return { x: () => stack(dy, axis) };
+ };
+ const attrs = { axis };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.unstack($x, axis), { x: $x }, grad, 'Unpack', attrs);
+}
+/**
+ * Returns a `tf.Tensor` that has expanded rank, by inserting a dimension
+ * into the tensor's shape.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ * const axis = 1;
+ * x.expandDims(axis).print();
+ * ```
+ *
+ * @param x The input tensor whose dimensions to be expanded.
+ * @param axis The dimension index at which to insert shape of `1`. Defaults
+ * to 0 (the first dimension).
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function expandDims_(x, axis = 0) {
+ const parseAs = null;
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'expandDims', parseAs);
+ util["assert"](axis <= $x.rank, () => 'Axis must be <= rank of the tensor');
+ const newShape = $x.shape.slice();
+ if (axis < 0) {
+ // Negative value is counted from the tail of rank.
+ util["assert"](-($x.rank + 1) <= axis, () => `Axis must be in the interval [${-($x.rank + 1)}, ${$x.rank}]`);
+ axis = $x.rank + axis + 1;
+ }
+ newShape.splice(axis, 0, 1);
+ return reshape($x, newShape);
+}
+/**
+ * Computes the difference between two lists of numbers.
+ *
+ * Given a Tensor `x` and a Tensor `y`, this operation returns a Tensor `out`
+ * that represents all values that are in `x` but not in `y`. The returned
+ * Tensor `out` is sorted in the same order that the numbers appear in `x`
+ * (duplicates are preserved). This operation also returns a Tensor indices that
+ * represents the position of each out element in `x`. In other words:
+ *
+ * `out[i] = x[idx[i]] for i in [0, 1, ..., out.length - 1]`
+ *
+ * ```js
+ * const x = [1, 2, 3, 4, 5, 6];
+ * const y = [1, 3, 5];
+ *
+ * const [out, indices] = await tf.setdiff1dAsync(x, y);
+ * out.print(); // [2, 4, 6]
+ * indices.print(); // [1, 3, 5]
+ * ```
+ *
+ * @param x 1-D Tensor. Values to keep.
+ * @param y 1-D Tensor. Must have the same type as x. Values to exclude in the
+ * output.
+ * @returns Promise of Tensor tuple [out, indices].
+ * out: Tensor with the same type as x.
+ * indices: A Tensor of type int32.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+async function setdiff1dAsync_(x, y) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'setdiff1d');
+ const $y = Object(tensor_util_env["a" /* convertToTensor */])(y, 'y', 'setdiff1d');
+ util["assert"]($x.dtype === $y.dtype, () => `x and y should have the same dtype, but got x (${$x.dtype}) and y (${$y.dtype}).`);
+ util["assert"]($x.rank === 1, () => `x should be 1D tensor, but got x (${$x.shape}).`);
+ util["assert"]($y.rank === 1, () => `y should be 1D tensor, but got y (${$y.shape}).`);
+ const xVals = await $x.data();
+ const yVals = await $y.data();
+ const ySet = new Set(yVals);
+ let outputSize = 0;
+ for (let i = 0; i < xVals.length; i++) {
+ if (!ySet.has(xVals[i])) {
+ outputSize++;
+ }
+ }
+ const buffer = new dist_tensor["b" /* TensorBuffer */]([outputSize], $x.dtype);
+ const indices = new dist_tensor["b" /* TensorBuffer */]([outputSize], 'int32');
+ for (let i = 0, p = 0; i < xVals.length; i++) {
+ if (!ySet.has(xVals[i])) {
+ buffer.values[p] = xVals[i];
+ indices.values[p] = i;
+ p++;
+ }
+ }
+ return [buffer.toTensor(), indices.toTensor()];
+}
+/**
+ * Creates an empty `tf.TensorBuffer` with the specified `shape` and `dtype`.
+ *
+ * The values are stored in CPU as `TypedArray`. Fill the buffer using
+ * `buffer.set()`, or by modifying directly `buffer.values`.
+ *
+ * When done, call `buffer.toTensor()` to get an immutable `tf.Tensor` with
+ * those values.
+ *
+ * ```js
+ * // Create a buffer and set values at particular indices.
+ * const buffer = tf.buffer([2, 2]);
+ * buffer.set(3, 0, 0);
+ * buffer.set(5, 1, 0);
+ *
+ * // Convert the buffer back to a tensor.
+ * buffer.toTensor().print();
+ * ```
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param dtype The dtype of the buffer. Defaults to 'float32'.
+ * @param values The values of the buffer as `TypedArray`. Defaults to
+ * zeros.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function array_ops_buffer(shape, dtype = 'float32', values) {
+ dtype = dtype || 'float32';
+ util["assertNonNegativeIntegerDimensions"](shape);
+ return new dist_tensor["b" /* TensorBuffer */](shape, dtype, values);
+}
+/**
+ * Prints information about the `tf.Tensor` including its data.
+ *
+ * ```js
+ * const verbose = true;
+ * tf.tensor2d([1, 2, 3, 4], [2, 2]).print(verbose);
+ * ```
+ * @param x The tensor to be printed.
+ * @param verbose Whether to print verbose information about the ` Tensor`,
+ * including dtype and size.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function print(x, verbose = false) {
+ console.log(x.toString(verbose));
+}
+
+const cast = Object(operation["a" /* op */])({ cast_ });
+const expandDims = Object(operation["a" /* op */])({ expandDims_ });
+const reshape = Object(operation["a" /* op */])({ reshape_ });
+const squeeze = Object(operation["a" /* op */])({ squeeze_ });
+const stack = Object(operation["a" /* op */])({ stack_ });
+const unstack = Object(operation["a" /* op */])({ unstack_ });
+const setdiff1dAsync = setdiff1dAsync_;
+//# sourceMappingURL=array_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/floorDiv.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Divides two `tf.Tensor`s element-wise, A / B. Supports broadcasting.
+ * The result is rounded with floor function.
+ *
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 4, 9, 16]);
+ * const b = tf.tensor1d([1, 2, 3, 4]);
+ *
+ * a.floorDiv(b).print(); // or tf.div(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast div a with b.
+ * const a = tf.tensor1d([2, 4, 6, 8]);
+ * const b = tf.scalar(2);
+ *
+ * a.floorDiv(b).print(); // or tf.floorDiv(a, b)
+ * ```
+ *
+ * @param a The first tensor as the numerator.
+ * @param b The second tensor as the denominator. Must have the same dtype as
+ * `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function floorDiv_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'floorDiv');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'floorDiv');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ const forward = (backend, save) => {
+ const res = backend.floorDiv($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["D" /* FloorDiv */]);
+}
+const floorDiv = Object(operation["a" /* op */])({ floorDiv_ });
+//# sourceMappingURL=floorDiv.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/div.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Divides two `tf.Tensor`s element-wise, A / B. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 4, 9, 16]);
+ * const b = tf.tensor1d([1, 2, 3, 4]);
+ *
+ * a.div(b).print(); // or tf.div(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast div a with b.
+ * const a = tf.tensor1d([2, 4, 6, 8]);
+ * const b = tf.scalar(2);
+ *
+ * a.div(b).print(); // or tf.div(a, b)
+ * ```
+ *
+ * @param a The first tensor as the numerator.
+ * @param b The second tensor as the denominator. Must have the same dtype as
+ * `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function div_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'div');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'div');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ if ($a.dtype === 'int32' && $b.dtype === 'int32') {
+ return floorDiv($a, $b);
+ }
+ const forward = (backend, save) => {
+ const res = backend.realDivide($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ const attrs = {};
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["y" /* Div */], attrs);
+}
+const div = Object(operation["a" /* op */])({ div_ });
+//# sourceMappingURL=div.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/mul.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Multiplies two `tf.Tensor`s element-wise, A * B. Supports broadcasting.
+ *
+ * We also expose `tf.mulStrict` which has the same signature as this op and
+ * asserts that `a` and `b` are the same shape (does not broadcast).
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3, 4]);
+ * const b = tf.tensor1d([2, 3, 4, 5]);
+ *
+ * a.mul(b).print(); // or tf.mul(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast mul a with b.
+ * const a = tf.tensor1d([1, 2, 3, 4]);
+ * const b = tf.scalar(5);
+ *
+ * a.mul(b).print(); // or tf.mul(a, b)
+ * ```
+ * @param a The first tensor to multiply.
+ * @param b The second tensor to multiply. Must have the same dtype as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function mul_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'mul');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'mul');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ const forward = (backend, save) => {
+ const res = backend.multiply($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["Y" /* Multiply */]);
+}
+const mul = Object(operation["a" /* op */])({ mul_ });
+//# sourceMappingURL=mul.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Provided `f(x)`, returns another function `g(x, dy?)`, which gives the
+ * gradient of `f(x)` with respect to `x`.
+ *
+ * If `dy` is provided, the gradient of `f(x).mul(dy).sum()` with respect to
+ * `x` is computed instead. `f(x)` must take a single tensor `x` and return a
+ * single tensor `y`. If `f()` takes multiple inputs, use `tf.grads` instead.
+ *
+ * ```js
+ * // f(x) = x ^ 2
+ * const f = x => x.square();
+ * // f'(x) = 2x
+ * const g = tf.grad(f);
+ *
+ * const x = tf.tensor1d([2, 3]);
+ * g(x).print();
+ * ```
+ *
+ * ```js
+ * // f(x) = x ^ 3
+ * const f = x => x.pow(tf.scalar(3, 'int32'));
+ * // f'(x) = 3x ^ 2
+ * const g = tf.grad(f);
+ * // f''(x) = 6x
+ * const gg = tf.grad(g);
+ *
+ * const x = tf.tensor1d([2, 3]);
+ * gg(x).print();
+ * ```
+ *
+ * @param f The function f(x), to compute gradient for.
+ */
+/** @doc {heading: 'Training', subheading: 'Gradients'} */
+function gradients_grad(f) {
+ util["assert"](util["isFunction"](f), () => 'The f passed in grad(f) must be a function');
+ return (x, dy) => {
+ // x can be of any dtype, thus null as the last argument.
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'tf.grad', null);
+ const $dy = (dy != null) ? Object(tensor_util_env["a" /* convertToTensor */])(dy, 'dy', 'tf.grad') : null;
+ return engine["a" /* ENGINE */].tidy(() => {
+ const { value, grads } = engine["a" /* ENGINE */].gradients(() => f($x), [$x], $dy);
+ if ($dy != null) {
+ util["assertShapesMatch"](value.shape, $dy.shape, 'The shape of dy passed in grad(f)(x, dy) must match the shape ' +
+ 'returned by f(x)');
+ }
+ checkGrads(grads);
+ return grads[0];
+ });
+ };
+}
+/**
+ * Provided `f(x1, x2,...)`, returns another function `g([x1, x2,...], dy?)`,
+ * which gives an array of gradients of `f()` with respect to each input
+ * [`x1`,`x2`,...].
+ *
+ * If `dy` is passed when calling `g()`, the gradient of
+ * `f(x1,...).mul(dy).sum()` with respect to each input is computed instead.
+ * The provided `f` must take one or more tensors and return a single tensor
+ * `y`. If `f()` takes a single input, we recommend using `tf.grad` instead.
+ *
+ * ```js
+ * // f(a, b) = a * b
+ * const f = (a, b) => a.mul(b);
+ * // df / da = b, df / db = a
+ * const g = tf.grads(f);
+ *
+ * const a = tf.tensor1d([2, 3]);
+ * const b = tf.tensor1d([-2, -3]);
+ * const [da, db] = g([a, b]);
+ * console.log('da');
+ * da.print();
+ * console.log('db');
+ * db.print();
+ * ```
+ *
+ * @param f The function `f(x1, x2,...)` to compute gradients for.
+ */
+/** @doc {heading: 'Training', subheading: 'Gradients'} */
+function gradients_grads(f) {
+ util["assert"](util["isFunction"](f), () => 'The f passed in grads(f) must be a function');
+ return (args, dy) => {
+ util["assert"](Array.isArray(args), () => 'The args passed in grads(f)(args) must be an array ' +
+ 'of `Tensor`s or `TensorLike`s');
+ // args can be of any dtype, thus null as the last argument.
+ const $args = Object(tensor_util_env["b" /* convertToTensorArray */])(args, 'args', 'tf.grads', null);
+ const $dy = (dy != null) ? Object(tensor_util_env["a" /* convertToTensor */])(dy, 'dy', 'tf.grads') : null;
+ return engine["a" /* ENGINE */].tidy(() => {
+ const { value, grads } = engine["a" /* ENGINE */].gradients(() => f(...$args), $args, $dy);
+ if ($dy != null) {
+ util["assertShapesMatch"](value.shape, $dy.shape, 'The shape of dy passed in grads(f)([x1,...], dy) must ' +
+ 'match the shape returned by f([x1,...])');
+ }
+ checkGrads(grads);
+ return grads;
+ });
+ };
+}
+/**
+ * Like `tf.grad`, but also returns the value of `f()`. Useful when `f()`
+ * returns a metric you want to show.
+ *
+ * The result is a rich object with the following properties:
+ * - grad: The gradient of `f(x)` w.r.t `x` (result of `tf.grad`).
+ * - value: The value returned by `f(x)`.
+ *
+ * ```js
+ * // f(x) = x ^ 2
+ * const f = x => x.square();
+ * // f'(x) = 2x
+ * const g = tf.valueAndGrad(f);
+ *
+ * const x = tf.tensor1d([2, 3]);
+ * const {value, grad} = g(x);
+ *
+ * console.log('value');
+ * value.print();
+ * console.log('grad');
+ * grad.print();
+ * ```
+ */
+/** @doc {heading: 'Training', subheading: 'Gradients'} */
+function valueAndGrad(f) {
+ util["assert"](util["isFunction"](f), () => 'The f passed in valueAndGrad(f) must be a function');
+ return (x, dy) => {
+ util["assert"](x instanceof dist_tensor["a" /* Tensor */], () => 'The x passed in valueAndGrad(f)(x) must be a tensor');
+ util["assert"](dy == null || dy instanceof dist_tensor["a" /* Tensor */], () => 'The dy passed in valueAndGrad(f)(x, dy) must be a tensor');
+ const { grads, value } = engine["a" /* ENGINE */].gradients(() => f(x), [x], dy);
+ checkGrads(grads);
+ return { grad: grads[0], value };
+ };
+}
+/**
+ * Like `tf.grads`, but returns also the value of `f()`. Useful when `f()`
+ * returns a metric you want to show.
+ *
+ * The result is a rich object with the following properties:
+ * - grads: The gradients of `f()` w.r.t each input (result of `tf.grads`).
+ * - value: The value returned by `f(x)`.
+ *
+ * ```js
+ * // f(a, b) = a * b
+ * const f = (a, b) => a.mul(b);
+ * // df/da = b, df/db = a
+ * const g = tf.valueAndGrads(f);
+ *
+ * const a = tf.tensor1d([2, 3]);
+ * const b = tf.tensor1d([-2, -3]);
+ * const {value, grads} = g([a, b]);
+ *
+ * const [da, db] = grads;
+ *
+ * console.log('value');
+ * value.print();
+ *
+ * console.log('da');
+ * da.print();
+ * console.log('db');
+ * db.print();
+ * ```
+ */
+/** @doc {heading: 'Training', subheading: 'Gradients'} */
+function valueAndGrads(f) {
+ util["assert"](util["isFunction"](f), () => 'The f passed in valueAndGrads(f) must be a function');
+ return (args, dy) => {
+ util["assert"](Array.isArray(args) && args.every(arg => arg instanceof dist_tensor["a" /* Tensor */]), () => 'The args passed in valueAndGrads(f)(args) must be array of ' +
+ 'tensors');
+ util["assert"](dy == null || dy instanceof dist_tensor["a" /* Tensor */], () => 'The dy passed in valueAndGrads(f)(args, dy) must be a tensor');
+ const res = engine["a" /* ENGINE */].gradients(() => f(...args), args, dy);
+ if (dy != null) {
+ util["assertShapesMatch"](res.value.shape, dy.shape, 'The shape of dy passed in valueAndGrads(f)([x1,...], dy) must ' +
+ 'match the shape returned by f([x1,...])');
+ }
+ checkGrads(res.grads);
+ return res;
+ };
+}
+/**
+ * Computes and returns the gradient of f(x) with respect to the list of
+ * trainable variables provided by `varList`. If no list is provided, it
+ * defaults to all trainable variables.
+ *
+ * ```js
+ * const a = tf.variable(tf.tensor1d([3, 4]));
+ * const b = tf.variable(tf.tensor1d([5, 6]));
+ * const x = tf.tensor1d([1, 2]);
+ *
+ * // f(a, b) = a * x ^ 2 + b * x
+ * const f = () => a.mul(x.square()).add(b.mul(x)).sum();
+ * // df/da = x ^ 2, df/db = x
+ * const {value, grads} = tf.variableGrads(f);
+ *
+ * Object.keys(grads).forEach(varName => grads[varName].print());
+ * ```
+ *
+ * @param f The function to execute. f() should return a scalar.
+ * @param varList The list of variables to compute the gradients with respect
+ * to. Defaults to all trainable variables.
+ * @returns An object with the following keys and values:
+ * - `value`: The value of the function `f`.
+ * - `grads`: A map from the names of the variables to the gradients.
+ * If the `varList` argument is provided explicitly and contains a subset of
+ * non-trainable variables, this map in the return value will contain keys
+ * that map the names of the non-trainable variables to `null`.
+ */
+/** @doc {heading: 'Training', subheading: 'Gradients'} */
+function variableGrads(f, varList) {
+ util["assert"](util["isFunction"](f), () => 'The f passed in variableGrads(f) must be a function');
+ util["assert"](varList == null ||
+ Array.isArray(varList) && varList.every(v => v instanceof dist_tensor["c" /* Variable */]), () => 'The varList passed in variableGrads(f, varList) must be an array ' +
+ 'of variables');
+ const specifiedVarList = varList != null;
+ if (!specifiedVarList) {
+ // Get all of the trainable variables.
+ varList = [];
+ for (const varName in engine["a" /* ENGINE */].registeredVariables) {
+ varList.push(engine["a" /* ENGINE */].registeredVariables[varName]);
+ }
+ }
+ const specifiedNonTrainable = specifiedVarList ? varList.filter(variable => !variable.trainable) : null;
+ // Prune non-trainable variables.
+ const originalVarCount = varList.length;
+ varList = varList.filter(variable => variable.trainable);
+ util["assert"](varList.length > 0, () => `variableGrads() expects at least one of the input variables to ` +
+ `be trainable, but none of the ${originalVarCount} variables is ` +
+ `trainable.`);
+ const allowNoGradients = true;
+ const { value, grads } = engine["a" /* ENGINE */].gradients(f, varList, null, allowNoGradients);
+ util["assert"](grads.some(g => g != null), () => 'Cannot find a connection between any variable and the result of ' +
+ 'the loss function y=f(x). Please make sure the operations that ' +
+ 'use variables are inside the function f passed to minimize().');
+ util["assert"](value.rank === 0, () => `The f passed in variableGrads(f) must return a scalar, but it ` +
+ `returned a rank-${value.rank} tensor`);
+ const namedGrads = {};
+ varList.forEach((v, i) => {
+ if (grads[i] != null) {
+ namedGrads[v.name] = grads[i];
+ }
+ });
+ if (specifiedNonTrainable != null) {
+ // If varList is explicitly provided and contains non-trainable values,
+ // add them to the returned gradients with `null` values.
+ specifiedNonTrainable.forEach(v => namedGrads[v.name] = null);
+ }
+ return { value, grads: namedGrads };
+}
+/**
+ * Overrides the gradient computation of a function `f`.
+ *
+ * Takes a function
+ * `f(...inputs, save) => {value: Tensor, gradFunc: (dy, saved) => Tensor[]}`
+ * and returns another function `g(...inputs)` which takes the same inputs as
+ * `f`. When called, `g` returns `f().value`. In backward mode, custom gradients
+ * with respect to each input of `f` are computed using `f().gradFunc`.
+ *
+ * The `save` function passsed to `f` should be used for saving tensors needed
+ * in the gradient. And the `saved` passed to the `gradFunc` is a
+ * `NamedTensorMap`, which contains those saved tensor.
+ *
+ * ```js
+ * const customOp = tf.customGrad((x, save) => {
+ * // Save x to make sure it's available later for the gradient.
+ * save([x]);
+ * // Override gradient of our custom x ^ 2 op to be dy * abs(x);
+ * return {
+ * value: x.square(),
+ * // Note `saved.x` which points to the `x` we saved earlier.
+ * gradFunc: (dy, saved) => [dy.mul(saved[0].abs())]
+ * };
+ * });
+ *
+ * const x = tf.tensor1d([-1, -2, 3]);
+ * const dx = tf.grad(x => customOp(x));
+ *
+ * console.log(`f(x):`);
+ * customOp(x).print();
+ * console.log(`f'(x):`);
+ * dx(x).print();
+ * ```
+ *
+ * @param f The function to evaluate in forward mode, which should return
+ * `{value: Tensor, gradFunc: (dy, saved) => Tensor[]}`, where `gradFunc`
+ * returns the custom gradients of `f` with respect to its inputs.
+ */
+/** @doc {heading: 'Training', subheading: 'Gradients'} */
+function customGrad(f) {
+ return engine["a" /* ENGINE */].customGrad(f);
+}
+function checkGrads(grads) {
+ const numNullGradients = grads.filter(g => g == null).length;
+ if (numNullGradients > 0) {
+ throw new Error(`Cannot compute gradient of y=f(x) with respect to x. Make sure that
+ the f you passed encloses all operations that lead from x to y.`);
+ }
+}
+
+//# sourceMappingURL=gradients.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/axis_util.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+/**
+ * Returns true if the axis specifies the inner most dimensions of the
+ * array.
+ */
+function axesAreInnerMostDims(axes, rank) {
+ for (let i = 0; i < axes.length; ++i) {
+ if (axes[axes.length - i - 1] !== rank - 1 - i) {
+ return false;
+ }
+ }
+ return true;
+}
+function combineLocations(outputLoc, reduceLoc, axes) {
+ const rank = outputLoc.length + reduceLoc.length;
+ const loc = [];
+ let outIdx = 0;
+ let reduceIdx = 0;
+ for (let dim = 0; dim < rank; dim++) {
+ if (axes.indexOf(dim) === -1) {
+ loc.push(outputLoc[outIdx++]);
+ }
+ else {
+ loc.push(reduceLoc[reduceIdx++]);
+ }
+ }
+ return loc;
+}
+function computeOutAndReduceShapes(aShape, axes) {
+ const outShape = [];
+ const rank = aShape.length;
+ for (let dim = 0; dim < rank; dim++) {
+ if (axes.indexOf(dim) === -1) {
+ outShape.push(aShape[dim]);
+ }
+ }
+ const reduceShape = axes.map(dim => aShape[dim]);
+ return [outShape, reduceShape];
+}
+function expandShapeToKeepDim(shape, axes) {
+ const reduceSubShape = axes.map(x => 1);
+ return combineLocations(shape, reduceSubShape, axes);
+}
+function assertAxesAreInnerMostDims(msg, axes, rank) {
+ util["assert"](axesAreInnerMostDims(axes, rank), () => `${msg} supports only inner-most axes for now. ` +
+ `Got axes ${axes} and rank-${rank} input.`);
+}
+/**
+ * Returns the axes permutation to be used with `tf.transpose`, if such
+ * permutation is necessary. Otherwise it returns null. This method is used by
+ * operations that operate only on inner-most axes.
+ */
+function getAxesPermutation(axes, rank) {
+ if (axesAreInnerMostDims(axes, rank)) {
+ return null;
+ }
+ const result = [];
+ for (let i = 0; i < rank; ++i) {
+ if (axes.indexOf(i) === -1) {
+ result.push(i);
+ }
+ }
+ axes.forEach(axis => result.push(axis));
+ return result;
+}
+/** Returns the axes permutation that undoes the original permutation. */
+function getUndoAxesPermutation(axes) {
+ return axes.map((axis, i) => [i, axis])
+ .sort((a, b) => a[1] - b[1])
+ .map(x => x[0]);
+}
+function getInnerMostAxes(numAxes, rank) {
+ const res = [];
+ for (let i = rank - numAxes; i < rank; ++i) {
+ res.push(i);
+ }
+ return res;
+}
+//# sourceMappingURL=axis_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/reduction_ops_util.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+/**
+ * Gradient helper function for the min and max operations.
+ */
+function gradForMinAndMax(dy, y, xOrig, origAxes, permutedAxes) {
+ if (y.rank < xOrig.rank) {
+ y = y.reshape(expandShapeToKeepDim(y.shape, origAxes));
+ }
+ if (dy.rank < xOrig.rank) {
+ dy = dy.reshape(expandShapeToKeepDim(dy.shape, origAxes));
+ }
+ return {
+ x: () => {
+ const dx = dy.mul(xOrig.equal(y).cast(dy.dtype));
+ return permutedAxes == null ? dx : dx.transpose(permutedAxes);
+ }
+ };
+}
+//# sourceMappingURL=reduction_ops_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/reduction_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+/**
+ * Computes the log(sum(exp(elements across the reduction dimensions)).
+ *
+ * Reduces the input along the dimensions given in `axis`. Unless `keepDims`
+ * is true, the rank of the array is reduced by 1 for each entry in `axis`.
+ * If `keepDims` is true, the reduced dimensions are retained with length 1.
+ * If `axis` has no entries, all dimensions are reduced, and an array with a
+ * single element is returned.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3]);
+ *
+ * x.logSumExp().print(); // or tf.logSumExp(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * const axis = 1;
+ * x.logSumExp(axis).print(); // or tf.logSumExp(a, axis)
+ * ```
+ * @param x The input tensor.
+ * @param axis The dimension(s) to reduce. If null (the default),
+ * reduces all dimensions.
+ * @param keepDims If true, retains reduced dimensions with length
+ * of 1. Defaults to false.
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function logSumExp_(x, axis = null, keepDims = false) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'logSumExp');
+ const axes = util["parseAxisParam"](axis, $x.shape);
+ const xMax = $x.max(axes, true /* keepDims */);
+ const a = $x.sub(xMax);
+ const b = a.exp();
+ const c = b.sum(axes);
+ const d = c.log();
+ const res = xMax.reshape(d.shape).add(d);
+ if (keepDims) {
+ const newShape = expandShapeToKeepDim(res.shape, axes);
+ return res.reshape(newShape);
+ }
+ return res;
+}
+/**
+ * Computes the sum of elements across dimensions of a `tf.Tensor`.
+ *
+ * Reduces the input along the dimensions given in `axes`. Unless `keepDims`
+ * is true, the rank of the `tf.Tensor` is reduced by 1 for each entry in
+ * `axes`. If `keepDims` is true, the reduced dimensions are retained with
+ * length 1. If axes has no entries, all dimensions are reduced, and a
+ * `tf.Tensor` with a single element is returned.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3]);
+ *
+ * x.sum().print(); // or tf.sum(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * const axis = 1;
+ * x.sum(axis).print(); // or tf.sum(x, axis)
+ * ```
+ *
+ * @param x The input tensor to compute the sum over. If the dtype is `bool`
+ * it will be converted to `int32` and the output dtype will be `int32`.
+ * @param axis The dimension(s) to reduce. By default it reduces
+ * all dimensions.
+ * @param keepDims If true, retains reduced dimensions with size 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function sum_(x, axis = null, keepDims = false) {
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'sum');
+ if ($x.dtype === 'bool') {
+ $x = $x.toInt();
+ }
+ const axes = util["parseAxisParam"](axis, $x.shape);
+ // Use a custom gradient to bypass 2 gradient backprops since sum is used
+ // extremely often.
+ const customOp = customGrad((x) => {
+ const permutation = getAxesPermutation(axes, x.rank);
+ let reductionAxes = axes;
+ let permutedX = x;
+ if (permutation != null) {
+ permutedX = x.transpose(permutation);
+ reductionAxes = getInnerMostAxes(reductionAxes.length, x.rank);
+ }
+ const gradFunc = (dy) => {
+ const expandedDyShape = x.shape.slice();
+ axes.forEach(axis => {
+ expandedDyShape[axis] = 1;
+ });
+ const expandedDy = dy.reshape(expandedDyShape);
+ const derX = expandedDy.mul(Object(tensor_ops["b" /* ones */])(x.shape, 'float32'));
+ return derX;
+ };
+ const gradInputs = (dy) => {
+ return { x: () => gradFunc(dy) };
+ };
+ const attrs = { axes: reductionAxes };
+ let value = engine["a" /* ENGINE */].runKernelFunc(backend => backend.sum(permutedX, reductionAxes), { x: permutedX }, gradInputs, 'Sum', attrs);
+ if (keepDims) {
+ const newShape = expandShapeToKeepDim(value.shape, axes);
+ value = value.reshape(newShape);
+ }
+ return { value, gradFunc };
+ });
+ return customOp($x);
+}
+/**
+ * Computes the product of elements across dimensions of a `tf.Tensor`.
+ *
+ * Reduces the input along the dimensions given in `axes`. Unless `keepDims`
+ * is true, the rank of the `tf.Tensor` is reduced by 1 for each entry in
+ * `axes`. If `keepDims` is true, the reduced dimensions are retained with
+ * length 1. If `axes` has no entries, all dimensions are reduced, and a
+ * `tf.Tensor` with a single element is returned.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3]);
+ *
+ * x.prod().print(); // or tf.prod(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * const axis = 1;
+ * x.prod(axis).print(); // or tf.prod(x, axis)
+ * ```
+ *
+ * @param x The input tensor to compute the product over. If the dtype is `bool`
+ * it will be converted to `int32` and the output dtype will be `int32`.
+ * @param axis The dimension(s) to reduce. By default it reduces
+ * all dimensions.
+ * @param keepDims If true, retains reduced dimensions with size 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function prod_(x, axis = null, keepDims = false) {
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'prod');
+ if ($x.dtype === 'bool') {
+ $x = $x.toInt();
+ }
+ const axes = util["parseAxisParam"](axis, $x.shape);
+ const permutation = getAxesPermutation(axes, $x.rank);
+ let reductionAxes = axes;
+ let permutedX = $x;
+ if (permutation != null) {
+ permutedX = $x.transpose(permutation);
+ reductionAxes = getInnerMostAxes(reductionAxes.length, $x.rank);
+ }
+ let value = engine["a" /* ENGINE */].runKernelFunc(backend => backend.prod(permutedX, reductionAxes), { permutedX });
+ if (keepDims) {
+ const newShape = expandShapeToKeepDim(value.shape, axes);
+ value = value.reshape(newShape);
+ }
+ return value;
+}
+/**
+ * Computes the mean of elements across dimensions of a `tf.Tensor`.
+ *
+ * Reduces `x` along the dimensions given in `axis`. Unless `keepDims` is
+ * true, the rank of the `tf.Tensor` is reduced by 1 for each entry in `axis`.
+ * If `keepDims` is true, the reduced dimensions are retained with length 1.
+ * If `axis` has no entries, all dimensions are reduced, and a `tf.Tensor` with
+ * a single element is returned.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3]);
+ *
+ * x.mean().print(); // or tf.mean(a)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * const axis = 1;
+ * x.mean(axis).print(); // or tf.mean(x, axis)
+ * ```
+ *
+ * @param x The input tensor.
+ * @param axis The dimension(s) to reduce. By default it reduces
+ * all dimensions.
+ * @param keepDims If true, retains reduced dimensions with size 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function mean_(x, axis = null, keepDims = false) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'mean');
+ const axes = util["parseAxisParam"](axis, $x.shape);
+ const shapes = computeOutAndReduceShapes($x.shape, axes);
+ const reduceShape = shapes[1];
+ const reduceSize = util["sizeFromShape"](reduceShape);
+ // Use a custom gradient to bypass 2 gradient backprops since mean is used
+ // extremely often.
+ const customOp = customGrad((x) => {
+ const reduceSizeScalar = Object(tensor_ops["e" /* scalar */])(reduceSize);
+ // Cast if needed.
+ const xReduce = reduceSizeScalar.dtype === x.dtype ? x : x.cast(reduceSizeScalar.dtype);
+ const res = xReduce.div(reduceSizeScalar);
+ const value = res.sum(axis, keepDims);
+ const gradFunc = (dy) => {
+ const expandedDyShape = x.shape.slice();
+ axes.forEach(axis => {
+ expandedDyShape[axis] = 1;
+ });
+ const expandedDy = dy.reshape(expandedDyShape);
+ const derX = expandedDy.mul(Object(tensor_ops["b" /* ones */])(x.shape, 'float32')).div(reduceSize);
+ return derX;
+ };
+ return { value, gradFunc };
+ });
+ return customOp($x);
+}
+/**
+ * Computes the minimum value from the input.
+ *
+ * Reduces the input along the dimensions given in `axes`. Unless `keepDims`
+ * is true, the rank of the array is reduced by 1 for each entry in `axes`.
+ * If `keepDims` is true, the reduced dimensions are retained with length 1.
+ * If `axes` has no entries, all dimensions are reduced, and an array with a
+ * single element is returned.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3]);
+ *
+ * x.min().print(); // or tf.min(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * const axis = 1;
+ * x.min(axis).print(); // or tf.min(x, axis)
+ * ```
+ *
+ * @param x The input Tensor.
+ * @param axis The dimension(s) to reduce. By default it reduces
+ * all dimensions.
+ * @param keepDims If true, retains reduced dimensions with size 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function min_(x, axis = null, keepDims = false) {
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'min');
+ const xOrig = $x;
+ const origAxes = util["parseAxisParam"](axis, $x.shape);
+ let axes = origAxes;
+ const permutedAxes = getAxesPermutation(axes, $x.rank);
+ if (permutedAxes != null) {
+ $x = $x.transpose(permutedAxes);
+ axes = getInnerMostAxes(axes.length, $x.rank);
+ }
+ const grad = (dy, saved) => gradForMinAndMax(dy, saved[1], saved[0], origAxes, permutedAxes);
+ const inputsToSave = [$x];
+ const outputsToSave = [true];
+ let res = engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const y = backend.min($x, axes);
+ save([xOrig, y]);
+ return y;
+ }, { x: $x }, grad, 'Min', { axes }, inputsToSave, outputsToSave);
+ if (keepDims) {
+ const newShape = expandShapeToKeepDim(res.shape, origAxes);
+ res = res.reshape(newShape);
+ }
+ return res;
+}
+/**
+ * Returns the indices of the minimum values along an `axis`.
+ *
+ * The result has the same shape as `input` with the dimension along `axis`
+ * removed.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3]);
+ *
+ * x.argMin().print(); // or tf.argMin(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 4, 3], [2, 2]);
+ *
+ * const axis = 1;
+ * x.argMin(axis).print(); // or tf.argMin(x, axis)
+ * ```
+ *
+ * @param x The input tensor.
+ * @param axis The dimension to reduce. Defaults to 0 (outer-most dimension).
+ *
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function argMin_(x, axis = 0) {
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'argMin');
+ if (axis == null) {
+ axis = 0;
+ }
+ let axes = util["parseAxisParam"](axis, $x.shape);
+ const permutedAxes = getAxesPermutation(axes, $x.rank);
+ if (permutedAxes != null) {
+ $x = $x.transpose(permutedAxes);
+ axes = getInnerMostAxes(axes.length, $x.rank);
+ }
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])($x) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.argMin($x, axes[0]);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Returns the indices of the maximum values along an `axis`.
+ *
+ * The result has the same shape as `input` with the dimension along `axis`
+ * removed.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3]);
+ *
+ * x.argMax().print(); // or tf.argMax(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 4, 3], [2, 2]);
+ *
+ * const axis = 1;
+ * x.argMax(axis).print(); // or tf.argMax(x, axis)
+ * ```
+ *
+ * @param x The input tensor.
+ * @param axis The dimension to reduce. Defaults to 0 (outer-most dimension).
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function argMax_(x, axis = 0) {
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'argMax');
+ if (axis == null) {
+ axis = 0;
+ }
+ let axes = util["parseAxisParam"](axis, $x.shape);
+ const permutedAxes = getAxesPermutation(axes, $x.rank);
+ if (permutedAxes != null) {
+ $x = $x.transpose(permutedAxes);
+ axes = getInnerMostAxes(axes.length, $x.rank);
+ }
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { x: () => Object(tensor_ops["o" /* zerosLike */])($x) };
+ };
+ const attrs = { axis: axes[0] };
+ const inputsToSave = [$x];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.argMax($x, axes[0]);
+ save([$x]);
+ return res;
+ }, { x: $x }, grad, 'ArgMax', attrs, inputsToSave);
+}
+/**
+ * Computes the logical and of elements across dimensions of a `tf.Tensor`.
+ *
+ * Reduces the input along the dimensions given in `axes`. Unless `keepDims`
+ * is true, the rank of the `tf.Tensor` is reduced by 1 for each entry in
+ * `axes`. If `keepDims` is true, the reduced dimensions are retained with
+ * length 1. If `axes` has no entries, all dimensions are reduced, and an
+ * `tf.Tensor` with a single element is returned.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 1, 1], 'bool');
+ *
+ * x.all().print(); // or tf.all(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 1, 0, 0], [2, 2], 'bool');
+ *
+ * const axis = 1;
+ * x.all(axis).print(); // or tf.all(x, axis)
+ * ```
+ *
+ * @param x The input tensor. Must be of dtype bool.
+ * @param axis The dimension(s) to reduce. By default it reduces
+ * all dimensions.
+ * @param keepDims If true, retains reduced dimensions with size 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function all_(x, axis = null, keepDims = false) {
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'all', 'bool');
+ const origAxes = util["parseAxisParam"](axis, $x.shape);
+ let axes = origAxes;
+ const permutedAxes = getAxesPermutation(axes, $x.rank);
+ if (permutedAxes != null) {
+ $x = $x.transpose(permutedAxes);
+ axes = getInnerMostAxes(axes.length, $x.rank);
+ }
+ const res = engine["a" /* ENGINE */].runKernelFunc(backend => backend.all($x, axes), { $x });
+ if (keepDims) {
+ const newShape = expandShapeToKeepDim(res.shape, origAxes);
+ return res.reshape(newShape);
+ }
+ return res;
+}
+/**
+ * Computes the logical or of elements across dimensions of a `tf.Tensor`.
+ *
+ * Reduces the input along the dimensions given in `axes`. Unless `keepDims`
+ * is true, the rank of the `tf.Tensor` is reduced by 1 for each entry in
+ * `axes`. If `keepDims` is true, the reduced dimensions are retained with
+ * length 1. If `axes` has no entries, all dimensions are reduced, and an
+ * `tf.Tensor` with a single element is returned.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 1, 1], 'bool');
+ *
+ * x.any().print(); // or tf.any(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 1, 0, 0], [2, 2], 'bool');
+ *
+ * const axis = 1;
+ * x.any(axis).print(); // or tf.any(x, axis)
+ * ```
+ *
+ * @param x The input tensor. Must be of dtype bool.
+ * @param axis The dimension(s) to reduce. By default it reduces
+ * all dimensions.
+ * @param keepDims If true, retains reduced dimensions with size 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function any_(x, axis = null, keepDims = false) {
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'any', 'bool');
+ const origAxes = util["parseAxisParam"](axis, $x.shape);
+ let axes = origAxes;
+ const permutedAxes = getAxesPermutation(axes, $x.rank);
+ if (permutedAxes != null) {
+ $x = $x.transpose(permutedAxes);
+ axes = getInnerMostAxes(axes.length, $x.rank);
+ }
+ const res = engine["a" /* ENGINE */].runKernelFunc(backend => backend.any($x, axes), { $x });
+ if (keepDims) {
+ const newShape = expandShapeToKeepDim(res.shape, origAxes);
+ return res.reshape(newShape);
+ }
+ return res;
+}
+/**
+ * Calculates the mean and variance of `x`. The mean and variance are
+ * calculated by aggregating the contents of `x` across `axes`. If `x` is
+ * 1-D and `axes = [0]` this is just the mean and variance of a vector.
+ *
+ * @param x The input tensor.
+ * @param axis The dimension(s) along with to compute mean and
+ * variance. By default it reduces all dimensions.
+ * @param keepDims If true, the moments have the same dimensionality as the
+ * input.
+ * @return An object with two keys: `mean` and `variance`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Normalization'} */
+function moments_(x, axis = null, keepDims = false) {
+ x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'moments');
+ const axes = util["parseAxisParam"](axis, x.shape);
+ const mean = x.mean(axes, keepDims);
+ let keepDimsShape = mean.shape;
+ if (!keepDims) {
+ keepDimsShape = expandShapeToKeepDim(mean.shape, axes);
+ }
+ const devSquared = x.toFloat().sub(mean.reshape(keepDimsShape)).square();
+ const variance = devSquared.mean(axes, keepDims);
+ return { mean, variance };
+}
+const reduction_ops_all = Object(operation["a" /* op */])({ all_ });
+// tslint:disable-next-line:variable-name
+const any = Object(operation["a" /* op */])({ any_ });
+const argMax = Object(operation["a" /* op */])({ argMax_ });
+const argMin = Object(operation["a" /* op */])({ argMin_ });
+const logSumExp = Object(operation["a" /* op */])({ logSumExp_ });
+const reduction_ops_mean = Object(operation["a" /* op */])({ mean_ });
+const reduction_ops_min = Object(operation["a" /* op */])({ min_ });
+const moments = Object(operation["a" /* op */])({ moments_ });
+const sum = Object(operation["a" /* op */])({ sum_ });
+const reduction_ops_prod = Object(operation["a" /* op */])({ prod_ });
+//# sourceMappingURL=reduction_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/square.js
+/**
+ * @license
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Computes square of `x` element-wise: `x ^ 2`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, Math.sqrt(2), -1]);
+ *
+ * x.square().print(); // or tf.square(x)
+ * ```
+ * @param x The input Tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function square_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'square');
+ const attrs = {};
+ const inputsToSave = [$x];
+ const outputsToSave = [];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ save([$x]);
+ return backend.square($x);
+ }, { x: $x }, null /* grad */, 'Square', attrs, inputsToSave, outputsToSave);
+}
+const square = Object(operation["a" /* op */])({ square_ });
+//# sourceMappingURL=square.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/unary_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Computes `-1 * x` element-wise.
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, -2, 0], [2, 2]);
+ *
+ * x.neg().print(); // or tf.neg(x)
+ * ```
+ *
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function neg_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'neg');
+ const grad = (dy) => {
+ return { x: () => dy.neg() };
+ };
+ const attrs = {};
+ const inputsToSave = [$x];
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.neg($x), { x: $x }, grad, 'Neg', attrs, inputsToSave);
+}
+/**
+ * Computes ceiling of input `tf.Tensor` element-wise: `ceil(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([.6, 1.1, -3.3]);
+ *
+ * x.ceil().print(); // or tf.ceil(x)
+ * ```
+ * @param x The input Tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function ceil_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'ceil');
+ // TODO(manrajgrover): Return null for gradients when backprop supports it.
+ const grad = (dy) => {
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.ceil($x), { $x }, grad);
+}
+/**
+ * Computes floor of input `tf.Tensor` element-wise: `floor(x)`.
+ *
+ * ```js
+ * const x = tf.tensor1d([.6, 1.1, -3.3]);
+ *
+ * x.floor().print(); // or tf.floor(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function floor_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'floor');
+ // TODO(nsthorat): Let gradients be null for cases where we want to stop
+ // backpropgation.
+ const grad = (dy) => {
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.floor($x), { $x }, grad);
+}
+/**
+ * Returns an element-wise indication of the sign of a number.
+ *
+ * ```js
+ * const x = tf.tensor1d([.6, 1.1, -3.3, NaN, 0]);
+ *
+ * x.sign().print(); // or tf.sign(x)
+ * ```
+ * @param x The input Tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function sign_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'sign');
+ const grad = (dy) => {
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.sign($x), { $x }, grad);
+}
+/**
+ * RReturns which elements of x are NaN.
+ *
+ * ```js
+ * const x = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
+ *
+ * x.isNaN().print(); // or tf.isNaN(x)
+ * ```
+ * @param x The input Tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function isNaN_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'isNaN');
+ // TODO(nsthorat): Let gradients be null for cases where we want to stop
+ // backpropgation.
+ const grad = (dy) => {
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.isNaN($x), { $x }, grad);
+}
+/**
+ * Returns which elements of x are Infinity or -Infinity.
+ *
+ * ```js
+ * const x = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
+ *
+ * x.isInf().print(); // or tf.isNaN(x)
+ * ```
+ * @param x The input Tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function isInf_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'isInf');
+ // TODO(nsthorat): Let gradients be null for cases where we want to stop
+ // backpropgation.
+ const grad = (dy) => {
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.isInf($x), { $x }, grad);
+}
+/**
+ * Returns which elements of x are finite.
+ *
+ * ```js
+ * const x = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
+ *
+ * x.isFinite().print(); // or tf.isNaN(x)
+ * ```
+ * @param x The input Tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function isFinite_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'isFinite');
+ // TODO(nsthorat): Let gradients be null for cases where we want to stop
+ // backpropgation.
+ const grad = (dy) => {
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.isFinite($x), { $x }, grad);
+}
+/**
+ * Computes round of input `tf.Tensor` element-wise: `round(x)`.
+ * It implements banker's rounding.
+ *
+ * ```js
+ * const x = tf.tensor1d([.6, 1.1, -3.3]);
+ *
+ * x.round().print(); // or tf.round(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function round_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'round');
+ // TODO(nsthorat): Let gradients be null for cases where we want to stop
+ // backpropgation.
+ const grad = (dy) => {
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.round($x), { $x }, grad);
+}
+/**
+ * Computes exponential of the input `tf.Tensor` element-wise. `e ^ x`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, -3]);
+ *
+ * x.exp().print(); // or tf.exp(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function exp_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'exp');
+ const bck = (dy, saved) => {
+ // tslint:disable-next-line: no-unnecessary-type-assertion
+ return { x: () => dy.mul(saved[0]) };
+ };
+ const attrs = {};
+ const inputsToSave = [];
+ const outputsToSave = [true];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const y = backend.exp($x);
+ save([y]);
+ return y;
+ }, { x: $x }, bck, 'Exp', attrs, inputsToSave, outputsToSave);
+}
+/**
+ * Computes exponential of the input `tf.Tensor` minus one element-wise.
+ * `e ^ x - 1`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, -3]);
+ *
+ * x.expm1().print(); // or tf.expm1(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function expm1_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'expm1');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => dy.mul($x.exp()) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.expm1($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes natural logarithm of the input `tf.Tensor` element-wise: `ln(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, Math.E]);
+ *
+ * x.log().print(); // or tf.log(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function log_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'log');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { x: () => dy.div($x.toFloat()) };
+ };
+ const attrs = {};
+ const inputsToSave = [$x];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.log($x);
+ save([$x]);
+ return res;
+ }, { x: $x }, grad, 'Log', attrs, inputsToSave);
+}
+/**
+ * Computes natural logarithm of the input `tf.Tensor` plus one
+ * element-wise: `ln(1 + x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, Math.E - 1]);
+ *
+ * x.log1p().print(); // or tf.log1p(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function log1p_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'log1p');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => dy.div($x.add(1)) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.log1p($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes square root of the input `tf.Tensor` element-wise: `y = sqrt(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 4, -1]);
+ *
+ * x.sqrt().print(); // or tf.sqrt(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function sqrt_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'sqrt');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { x: () => dy.div($x.toFloat().sqrt().mul(2)) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.sqrt($x);
+ save([$x]);
+ return res;
+ }, { x: $x }, grad, 'Sqrt', {});
+}
+/**
+ * Computes reciprocal of square root of the input `tf.Tensor` element-wise:
+ * `y = 1 / sqrt(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 4, -1]);
+ *
+ * x.rsqrt().print(); // or tf.rsqrt(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function rsqrt_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'rsqrt');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { x: () => dy.div($x.pow(1.5).mul(2)).neg() };
+ };
+ const inputsToSave = [$x];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.rsqrt($x);
+ save([$x]);
+ return res;
+ }, { x: $x }, grad, 'Rsqrt', {} /* attrs */, inputsToSave);
+}
+/**
+ * Computes reciprocal of x element-wise: `1 / x`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, 2]);
+ *
+ * x.reciprocal().print(); // or tf.reciprocal(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function reciprocal_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'reciprocal');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => dy.div($x.square().neg()) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.reciprocal($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes absolute value element-wise: `abs(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([-1, 2, -3, 4]);
+ *
+ * x.abs().print(); // or tf.abs(x)
+ * ```
+ * @param x The input `tf.Tensor`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function abs_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'abs');
+ if ($x.dtype === 'complex64') {
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.complexAbs($x), { $x });
+ }
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { x: () => dy.mul($x.toFloat().step(-1)) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.abs($x);
+ save([$x]);
+ return res;
+ }, { x: $x }, grad, 'Abs');
+}
+/**
+ * Clips values element-wise. `max(min(x, clipValueMax), clipValueMin)`
+ *
+ * ```js
+ * const x = tf.tensor1d([-1, 2, -3, 4]);
+ *
+ * x.clipByValue(-2, 3).print(); // or tf.clipByValue(x, -2, 3)
+ * ```
+ * @param x The input tensor.
+ * @param clipValueMin Lower-bound of range to be clipped to.
+ * @param clipValueMax Upper-bound of range to be clipped to.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function clipByValue_(x, clipValueMin, clipValueMax) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'clipByValue');
+ util["assert"]((clipValueMin <= clipValueMax), () => `Error in clip: min (${clipValueMin}) must be ` +
+ `less than or equal to max (${clipValueMax}).`);
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return {
+ x: () => dy.where($x.greaterEqual(clipValueMin)
+ .logicalAnd($x.lessEqual(clipValueMax)), Object(tensor_ops["o" /* zerosLike */])(dy)),
+ };
+ };
+ const inputsToSave = [$x];
+ const attr = { min: clipValueMin, max: clipValueMax };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.clip($x, clipValueMin, clipValueMax);
+ save([$x]);
+ return res;
+ }, { x: $x }, grad, 'ClipByValue', attr, inputsToSave);
+}
+/**
+ * Computes sigmoid element-wise, `1 / (1 + exp(-x))`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, -1, 2, -3]);
+ *
+ * x.sigmoid().print(); // or tf.sigmoid(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function sigmoid_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'sigmoid');
+ const grad = (dy, saved) => {
+ const [y] = saved;
+ return { x: () => dy.mul(y.mul(Object(tensor_ops["e" /* scalar */])(1).sub(y))) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const y = backend.sigmoid($x);
+ save([y]);
+ return y;
+ }, { x: $x }, grad, 'Sigmoid');
+}
+/**
+ * Computes log sigmoid of the input `tf.Tensor` element-wise:
+ * `logSigmoid(x)`. For numerical stability, we use `-tf.softplus(-x)`.
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, .7]);
+ *
+ * x.logSigmoid().print(); // or tf.logSigmoid(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function logSigmoid_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'logSigmoid');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => dy.mul($x.neg().sigmoid()) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.softplus($x.neg()).neg();
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes softplus of the input `tf.Tensor` element-wise: `log(exp(x) + 1)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, .7]);
+ *
+ * x.softplus().print(); // or tf.softplus(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function softplus_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'softplus');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => dy.mul($x.sigmoid()) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.softplus($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes sin of the input Tensor element-wise: `sin(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, Math.PI / 2, Math.PI * 3 / 4]);
+ *
+ * x.sin().print(); // or tf.sin(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function sin_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'sin');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { x: () => $x.toFloat().cos().mul(dy) };
+ };
+ const inputsToSave = [$x];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.sin($x);
+ save([$x]);
+ return res;
+ }, { x: $x }, grad, 'Sin', {} /* attrs */, inputsToSave);
+}
+/**
+ * Computes cos of the input `tf.Tensor` element-wise: `cos(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, Math.PI / 2, Math.PI * 3 / 4]);
+ *
+ * x.cos().print(); // or tf.cos(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function cos_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'cos');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { x: () => $x.toFloat().sin().neg().mul(dy) };
+ };
+ const inputsToSave = [$x];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.cos($x);
+ save([$x]);
+ return res;
+ }, { x: $x }, grad, 'Cos', {} /* attrs */, inputsToSave);
+}
+/**
+ * Computes tan of the input `tf.Tensor` element-wise, `tan(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, Math.PI / 2, Math.PI * 3 / 4]);
+ *
+ * x.tan().print(); // or tf.tan(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function tan_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'tan');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => dy.div($x.cos().square()) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.tan($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes asin of the input `tf.Tensor` element-wise: `asin(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, .7]);
+ *
+ * x.asin().print(); // or tf.asin(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function asin_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'asin');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return {
+ // tslint:disable-next-line: no-unnecessary-type-assertion
+ $x: () => dy.div(Object(tensor_ops["e" /* scalar */])(1).sub($x.toFloat().square()).sqrt())
+ };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.asin($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes acos of the input `tf.Tensor` element-wise: `acos(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, .7]);
+ *
+ * x.acos().print(); // or tf.acos(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function acos_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'acos');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return {
+ $x: () => {
+ const a = $x.toFloat().square();
+ const b = Object(tensor_ops["e" /* scalar */])(1).sub(a).sqrt();
+ // tslint:disable-next-line: no-unnecessary-type-assertion
+ return dy.div(b).neg();
+ }
+ };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.acos($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes atan of the input `tf.Tensor` element-wise: `atan(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, .7]);
+ *
+ * x.atan().print(); // or tf.atan(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function atan_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'atan');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => dy.div($x.toFloat().square().add(1)) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.atan($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes hyperbolic sin of the input `tf.Tensor` element-wise: `sinh(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, .7]);
+ *
+ * x.sinh().print(); // or tf.sinh(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function sinh_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'sinh');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ // tslint:disable-next-line: no-unnecessary-type-assertion
+ return { $x: () => $x.toFloat().cosh().mul(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.sinh($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes hyperbolic cos of the input `tf.Tensor` element-wise: `cosh(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, .7]);
+ *
+ * x.cosh().print(); // or tf.cosh(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function cosh_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'cosh');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ // tslint:disable-next-line: no-unnecessary-type-assertion
+ return { $x: () => $x.toFloat().sinh().mul(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.cosh($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes hyperbolic tangent of the input `tf.Tensor` element-wise: `tanh(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, 70]);
+ *
+ * x.tanh().print(); // or tf.tanh(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function tanh_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'tanh');
+ const grad = (dy, saved) => {
+ const [y] = saved;
+ // tslint:disable-next-line: no-unnecessary-type-assertion
+ return { x: () => Object(tensor_ops["e" /* scalar */])(1).sub(y.square()).mul(dy) };
+ };
+ const outputsToSave = [true];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const y = backend.tanh($x);
+ save([y]);
+ return y;
+ }, { x: $x }, grad, 'Tanh', {} /* attrs */, null /* inputsToSave */, outputsToSave);
+}
+/**
+ * Computes inverse hyperbolic sin of the input `tf.Tensor` element-wise:
+ * `asinh(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 1, -1, .7]);
+ *
+ * x.asinh().print(); // or tf.asinh(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function asinh_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'asinh');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return {
+ $x: () => {
+ const a = Object(tensor_ops["e" /* scalar */])(1).add($x.toFloat().square()).sqrt();
+ // tslint:disable-next-line: no-unnecessary-type-assertion
+ return dy.div(a);
+ }
+ };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.asinh($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes the inverse hyperbolic cos of the input `tf.Tensor` element-wise:
+ * `acosh(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([10, 1, 3, 5.7]);
+ *
+ * x.acosh().print(); // or tf.acosh(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function acosh_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'acosh');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return {
+ $x: () => {
+ const a = $x.toFloat().square().sub(1).sqrt();
+ // tslint:disable-next-line: no-unnecessary-type-assertion
+ return dy.div(a);
+ }
+ };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.acosh($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes inverse hyperbolic tan of the input `tf.Tensor` element-wise:
+ * `atanh(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, .1, -.1, .7]);
+ *
+ * x.atanh().print(); // or tf.atanh(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function atanh_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'atanh');
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return { $x: () => dy.div(Object(tensor_ops["e" /* scalar */])(1).sub($x.toFloat().square())) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.atanh($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes gause error function of the input `tf.Tensor` element-wise:
+ * `erf(x)`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, .1, -.1, .7]);
+ *
+ * x.erf().print(); // or tf.erf(x);
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function erf_(x) {
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'erf');
+ util["assert"]($x.dtype === 'int32' || $x.dtype === 'float32', () => 'Input dtype must be `int32` or `float32`.');
+ if ($x.dtype === 'int32') {
+ $x = $x.toFloat();
+ }
+ const grad = (dy, saved) => {
+ const [$x] = saved;
+ return {
+ $x: () => dy.mul($x.square().neg().exp().mul(2 / Math.sqrt(Math.PI)))
+ };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.erf($x);
+ save([$x]);
+ return res;
+ }, { $x }, grad);
+}
+/**
+ * Computes step of the input `tf.Tensor` element-wise: `x > 0 ? 1 : alpha * x`
+ *
+ * ```js
+ * const x = tf.tensor1d([0, 2, -1, -3]);
+ *
+ * x.step(.5).print(); // or tf.step(x, .5)
+ * ```
+ * @param x The input tensor.
+ * @param alpha The gradient when input is negative.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function step_(x, alpha = 0.0) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'step');
+ // TODO(manrajgrover): Return null for gradients when backprop supports
+ // it.
+ const grad = (dy) => {
+ return { $x: () => Object(tensor_ops["o" /* zerosLike */])(dy) };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.step($x, alpha), { $x }, grad);
+}
+const abs = Object(operation["a" /* op */])({ abs_ });
+const acos = Object(operation["a" /* op */])({ acos_ });
+const acosh = Object(operation["a" /* op */])({ acosh_ });
+const asin = Object(operation["a" /* op */])({ asin_ });
+const asinh = Object(operation["a" /* op */])({ asinh_ });
+const atan = Object(operation["a" /* op */])({ atan_ });
+const atanh = Object(operation["a" /* op */])({ atanh_ });
+const ceil = Object(operation["a" /* op */])({ ceil_ });
+const clipByValue = Object(operation["a" /* op */])({ clipByValue_ });
+const cos = Object(operation["a" /* op */])({ cos_ });
+const cosh = Object(operation["a" /* op */])({ cosh_ });
+const erf = Object(operation["a" /* op */])({ erf_ });
+const unary_ops_exp = Object(operation["a" /* op */])({ exp_ });
+const expm1 = Object(operation["a" /* op */])({ expm1_ });
+const floor = Object(operation["a" /* op */])({ floor_ });
+const log = Object(operation["a" /* op */])({ log_ });
+const log1p = Object(operation["a" /* op */])({ log1p_ });
+const logSigmoid = Object(operation["a" /* op */])({ logSigmoid_ });
+const neg = Object(operation["a" /* op */])({ neg_ });
+const reciprocal = Object(operation["a" /* op */])({ reciprocal_ });
+const round = Object(operation["a" /* op */])({ round_ });
+const rsqrt = Object(operation["a" /* op */])({ rsqrt_ });
+const sigmoid = Object(operation["a" /* op */])({ sigmoid_ });
+const sign = Object(operation["a" /* op */])({ sign_ });
+const unary_ops_isNaN = Object(operation["a" /* op */])({ isNaN_ });
+const isInf = Object(operation["a" /* op */])({ isInf_ });
+const unary_ops_isFinite = Object(operation["a" /* op */])({ isFinite_ });
+const sin = Object(operation["a" /* op */])({ sin_ });
+const sinh = Object(operation["a" /* op */])({ sinh_ });
+const softplus = Object(operation["a" /* op */])({ softplus_ });
+const sqrt = Object(operation["a" /* op */])({ sqrt_ });
+const unary_ops_step = Object(operation["a" /* op */])({ step_ });
+const tan = Object(operation["a" /* op */])({ tan_ });
+const tanh = Object(operation["a" /* op */])({ tanh_ });
+//# sourceMappingURL=unary_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Atan2_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+const atan2GradConfig = {
+ kernelName: kernel_names["c" /* Atan2 */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
+ const derA = () => {
+ const d = add(square(a), square(b));
+ let res = mul(dy, div(b, d));
+ const reduceAxes = getReductionAxes(a.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = sum(res, reduceAxes);
+ }
+ return reshape(res, a.shape);
+ };
+ const derB = () => {
+ const d = add(square(a), square(b));
+ let res = neg(mul(dy, div(a, d)));
+ const reduceAxes = getReductionAxes(b.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = sum(res, reduceAxes);
+ }
+ return reshape(res, b.shape);
+ };
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=Atan2_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv_util.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function computePool2DInfo(inShape, filterSize, strides, dilations, pad, roundingMode, dataFormat = 'channelsLast') {
+ const [filterHeight, filterWidth] = parseTupleParam(filterSize);
+ let filterShape;
+ if (dataFormat === 'channelsLast') {
+ filterShape = [filterHeight, filterWidth, inShape[3], inShape[3]];
+ }
+ else if (dataFormat === 'channelsFirst') {
+ filterShape = [filterHeight, filterWidth, inShape[1], inShape[1]];
+ }
+ else {
+ throw new Error(`Unknown dataFormat ${dataFormat}`);
+ }
+ return computeConv2DInfo(inShape, filterShape, strides, dilations, pad, roundingMode, false, dataFormat);
+}
+/**
+ * Computes the information for a forward pass of a pooling3D operation.
+ */
+function computePool3DInfo(inShape, filterSize, strides, dilations, pad, roundingMode, dataFormat = 'NDHWC') {
+ const [filterDepth, filterHeight, filterWidth] = parse3TupleParam(filterSize);
+ let filterShape;
+ let $dataFormat;
+ if (dataFormat === 'NDHWC') {
+ $dataFormat = 'channelsLast';
+ filterShape =
+ [filterDepth, filterHeight, filterWidth, inShape[4], inShape[4]];
+ }
+ else if (dataFormat === 'NCDHW') {
+ $dataFormat = 'channelsFirst';
+ filterShape =
+ [filterDepth, filterHeight, filterWidth, inShape[1], inShape[1]];
+ }
+ else {
+ throw new Error(`Unknown dataFormat ${dataFormat}`);
+ }
+ return computeConv3DInfo(inShape, filterShape, strides, dilations, pad, false, $dataFormat, roundingMode);
+}
+/**
+ * Computes the information for a forward pass of a convolution/pooling
+ * operation.
+ */
+function computeConv2DInfo(inShape, filterShape, strides, dilations, pad, roundingMode, depthwise = false, dataFormat = 'channelsLast') {
+ let [batchSize, inHeight, inWidth, inChannels] = [-1, -1, -1, -1];
+ if (dataFormat === 'channelsLast') {
+ [batchSize, inHeight, inWidth, inChannels] = inShape;
+ }
+ else if (dataFormat === 'channelsFirst') {
+ [batchSize, inChannels, inHeight, inWidth] = inShape;
+ }
+ else {
+ throw new Error(`Unknown dataFormat ${dataFormat}`);
+ }
+ const [filterHeight, filterWidth, , filterChannels] = filterShape;
+ const [strideHeight, strideWidth] = parseTupleParam(strides);
+ const [dilationHeight, dilationWidth] = parseTupleParam(dilations);
+ const effectiveFilterHeight = getEffectiveFilterSize(filterHeight, dilationHeight);
+ const effectiveFilterWidth = getEffectiveFilterSize(filterWidth, dilationWidth);
+ const { padInfo, outHeight, outWidth } = getPadAndOutInfo(pad, inHeight, inWidth, strideHeight, strideWidth, effectiveFilterHeight, effectiveFilterWidth, roundingMode, dataFormat);
+ const outChannels = depthwise ? filterChannels * inChannels : filterChannels;
+ let outShape;
+ if (dataFormat === 'channelsFirst') {
+ outShape = [batchSize, outChannels, outHeight, outWidth];
+ }
+ else if (dataFormat === 'channelsLast') {
+ outShape = [batchSize, outHeight, outWidth, outChannels];
+ }
+ return {
+ batchSize,
+ dataFormat,
+ inHeight,
+ inWidth,
+ inChannels,
+ outHeight,
+ outWidth,
+ outChannels,
+ padInfo,
+ strideHeight,
+ strideWidth,
+ filterHeight,
+ filterWidth,
+ effectiveFilterHeight,
+ effectiveFilterWidth,
+ dilationHeight,
+ dilationWidth,
+ inShape,
+ outShape,
+ filterShape
+ };
+}
+/**
+ * Computes the information for a forward pass of a 3D convolution/pooling
+ * operation.
+ */
+function computeConv3DInfo(inShape, filterShape, strides, dilations, pad, depthwise = false, dataFormat = 'channelsLast', roundingMode) {
+ let [batchSize, inDepth, inHeight, inWidth, inChannels] = [-1, -1, -1, -1, -1];
+ if (dataFormat === 'channelsLast') {
+ [batchSize, inDepth, inHeight, inWidth, inChannels] = inShape;
+ }
+ else if (dataFormat === 'channelsFirst') {
+ [batchSize, inChannels, inDepth, inHeight, inWidth] = inShape;
+ }
+ else {
+ throw new Error(`Unknown dataFormat ${dataFormat}`);
+ }
+ const [filterDepth, filterHeight, filterWidth, , filterChannels] = filterShape;
+ const [strideDepth, strideHeight, strideWidth] = parse3TupleParam(strides);
+ const [dilationDepth, dilationHeight, dilationWidth] = parse3TupleParam(dilations);
+ const effectiveFilterDepth = getEffectiveFilterSize(filterDepth, dilationDepth);
+ const effectiveFilterHeight = getEffectiveFilterSize(filterHeight, dilationHeight);
+ const effectiveFilterWidth = getEffectiveFilterSize(filterWidth, dilationWidth);
+ const { padInfo, outDepth, outHeight, outWidth } = get3DPadAndOutInfo(pad, inDepth, inHeight, inWidth, strideDepth, strideHeight, strideWidth, effectiveFilterDepth, effectiveFilterHeight, effectiveFilterWidth, roundingMode);
+ const outChannels = depthwise ? filterChannels * inChannels : filterChannels;
+ let outShape;
+ if (dataFormat === 'channelsFirst') {
+ outShape = [batchSize, outChannels, outDepth, outHeight, outWidth];
+ }
+ else if (dataFormat === 'channelsLast') {
+ outShape = [batchSize, outDepth, outHeight, outWidth, outChannels];
+ }
+ return {
+ batchSize,
+ dataFormat,
+ inDepth,
+ inHeight,
+ inWidth,
+ inChannels,
+ outDepth,
+ outHeight,
+ outWidth,
+ outChannels,
+ padInfo,
+ strideDepth,
+ strideHeight,
+ strideWidth,
+ filterDepth,
+ filterHeight,
+ filterWidth,
+ effectiveFilterDepth,
+ effectiveFilterHeight,
+ effectiveFilterWidth,
+ dilationDepth,
+ dilationHeight,
+ dilationWidth,
+ inShape,
+ outShape,
+ filterShape
+ };
+}
+function computeOutputShape2D(inShape, fieldSize, stride, zeroPad, roundingMode) {
+ if (zeroPad == null) {
+ zeroPad = computeDefaultPad(inShape, fieldSize, stride);
+ }
+ const inputRows = inShape[0];
+ const inputCols = inShape[1];
+ const outputRows = conditionalRound((inputRows - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+ util["assert"](util["isInt"](outputRows), () => `The output # of rows (${outputRows}) must be an integer. ` +
+ `Change the stride and/or zero pad parameters`);
+ const outputCols = conditionalRound((inputCols - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+ util["assert"](util["isInt"](outputCols), () => `The output # of columns (${outputCols}) must be an integer. ` +
+ `Change the stride and/or zero pad parameters`);
+ return [outputRows, outputCols];
+}
+function computeOutputShape4D(inShape, fieldSize, outChannels, stride, zeroPad, roundingMode) {
+ if (zeroPad == null) {
+ zeroPad = computeDefaultPad(inShape, fieldSize, stride);
+ }
+ const inputDepth = inShape[0];
+ const inputRows = inShape[1];
+ const inputCols = inShape[2];
+ const outputDepths = conditionalRound((inputDepth - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+ util["assert"](util["isInt"](outputDepths), () => `The output # of depths (${outputDepths}) must be an integer. ` +
+ `Change the stride and/or zero pad parameters`);
+ const outputRows = conditionalRound((inputRows - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+ util["assert"](util["isInt"](outputRows), () => `The output # of rows (${outputRows}) must be an integer. ` +
+ `Change the stride and/or zero pad parameters`);
+ const outputCols = conditionalRound((inputCols - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+ util["assert"](util["isInt"](outputCols), () => `The output # of columns (${outputCols}) must be an integer. ` +
+ `Change the stride and/or zero pad parameters`);
+ return [outputDepths, outputRows, outputCols, outChannels];
+}
+function computeDefaultPad(inputShape, fieldSize, stride, dilation = 1) {
+ const effectiveFieldSize = getEffectiveFilterSize(fieldSize, dilation);
+ return Math.floor((inputShape[0] * (stride - 1) - stride + effectiveFieldSize) / 2);
+}
+function parseTupleParam(param) {
+ if (typeof param === 'number') {
+ return [param, param, param];
+ }
+ if (param.length === 2) {
+ return [param[0], param[1], 1];
+ }
+ return param;
+}
+function parse3TupleParam(param) {
+ return typeof param === 'number' ? [param, param, param] : param;
+}
+/* See https://www.tensorflow.org/api_docs/python/tf/nn/atrous_conv2d
+ * Atrous convolution is equivalent to standard convolution with upsampled
+ * filters with effective_filter_height =
+ * filter_height + (filter_height - 1) * (dilation - 1)
+ * and effective_filter_width =
+ * filter_width + (filter_width - 1) * (dilation - 1),
+ * produced by inserting dilation - 1 zeros along consecutive elements across
+ * the filters' spatial dimensions.
+ * When there is a dilation, this converts a filter dimension to the
+ * effective filter dimension, so it can be used in a standard convolution.
+ */
+function getEffectiveFilterSize(filterSize, dilation) {
+ if (dilation <= 1) {
+ return filterSize;
+ }
+ return filterSize + (filterSize - 1) * (dilation - 1);
+}
+function getPadAndOutInfo(pad, inHeight, inWidth, strideHeight, strideWidth, filterHeight, filterWidth, roundingMode, dataFormat) {
+ let padInfo;
+ let outHeight;
+ let outWidth;
+ if (typeof pad === 'number') {
+ const padType = (pad === 0) ? 'VALID' : 'NUMBER';
+ padInfo = { top: pad, bottom: pad, left: pad, right: pad, type: padType };
+ const outShape = computeOutputShape2D([inHeight, inWidth], filterHeight, strideHeight, pad, roundingMode);
+ outHeight = outShape[0];
+ outWidth = outShape[1];
+ }
+ else if (pad === 'same') {
+ outHeight = Math.ceil(inHeight / strideHeight);
+ outWidth = Math.ceil(inWidth / strideWidth);
+ const padAlongHeight = Math.max(0, (outHeight - 1) * strideHeight + filterHeight - inHeight);
+ const padAlongWidth = Math.max(0, (outWidth - 1) * strideWidth + filterWidth - inWidth);
+ const top = Math.floor(padAlongHeight / 2);
+ const bottom = padAlongHeight - top;
+ const left = Math.floor(padAlongWidth / 2);
+ const right = padAlongWidth - left;
+ padInfo = { top, bottom, left, right, type: 'SAME' };
+ }
+ else if (pad === 'valid') {
+ padInfo = { top: 0, bottom: 0, left: 0, right: 0, type: 'VALID' };
+ outHeight = Math.ceil((inHeight - filterHeight + 1) / strideHeight);
+ outWidth = Math.ceil((inWidth - filterWidth + 1) / strideWidth);
+ }
+ else if (typeof pad === 'object') {
+ const top = dataFormat === 'channelsLast' ? pad[1][0] : pad[2][0];
+ const bottom = dataFormat === 'channelsLast' ? pad[1][1] : pad[2][1];
+ const left = dataFormat === 'channelsLast' ? pad[2][0] : pad[3][0];
+ const right = dataFormat === 'channelsLast' ? pad[2][1] : pad[3][1];
+ const padType = (top === 0 && bottom === 0 && left === 0 && right === 0) ?
+ 'VALID' :
+ 'EXPLICIT';
+ padInfo = { top, bottom, left, right, type: padType };
+ outHeight = conditionalRound((inHeight - filterHeight + top + bottom) / strideHeight + 1, roundingMode);
+ outWidth = conditionalRound((inWidth - filterWidth + left + right) / strideWidth + 1, roundingMode);
+ }
+ else {
+ throw Error(`Unknown padding parameter: ${pad}`);
+ }
+ return { padInfo, outHeight, outWidth };
+}
+function get3DPadAndOutInfo(pad, inDepth, inHeight, inWidth, strideDepth, strideHeight, strideWidth, filterDepth, filterHeight, filterWidth, roundingMode) {
+ let padInfo;
+ let outDepth;
+ let outHeight;
+ let outWidth;
+ if (typeof pad === 'number') {
+ const padType = (pad === 0) ? 'VALID' : 'NUMBER';
+ padInfo = {
+ top: pad,
+ bottom: pad,
+ left: pad,
+ right: pad,
+ front: pad,
+ back: pad,
+ type: padType
+ };
+ const outShape = computeOutputShape4D([inDepth, inHeight, inWidth, 1], filterDepth, 1, strideDepth, pad, roundingMode);
+ outDepth = outShape[0];
+ outHeight = outShape[1];
+ outWidth = outShape[2];
+ }
+ else if (pad === 'same') {
+ outDepth = Math.ceil(inDepth / strideDepth);
+ outHeight = Math.ceil(inHeight / strideHeight);
+ outWidth = Math.ceil(inWidth / strideWidth);
+ const padAlongDepth = (outDepth - 1) * strideDepth + filterDepth - inDepth;
+ const padAlongHeight = (outHeight - 1) * strideHeight + filterHeight - inHeight;
+ const padAlongWidth = (outWidth - 1) * strideWidth + filterWidth - inWidth;
+ const front = Math.floor(padAlongDepth / 2);
+ const back = padAlongDepth - front;
+ const top = Math.floor(padAlongHeight / 2);
+ const bottom = padAlongHeight - top;
+ const left = Math.floor(padAlongWidth / 2);
+ const right = padAlongWidth - left;
+ padInfo = { top, bottom, left, right, front, back, type: 'SAME' };
+ }
+ else if (pad === 'valid') {
+ padInfo = {
+ top: 0,
+ bottom: 0,
+ left: 0,
+ right: 0,
+ front: 0,
+ back: 0,
+ type: 'VALID'
+ };
+ outDepth = Math.ceil((inDepth - filterDepth + 1) / strideDepth);
+ outHeight = Math.ceil((inHeight - filterHeight + 1) / strideHeight);
+ outWidth = Math.ceil((inWidth - filterWidth + 1) / strideWidth);
+ }
+ else {
+ throw Error(`Unknown padding parameter: ${pad}`);
+ }
+ return { padInfo, outDepth, outHeight, outWidth };
+}
+/**
+ * Rounds a value depending on the rounding mode
+ * @param value
+ * @param roundingMode
+ */
+function conditionalRound(value, roundingMode) {
+ if (!roundingMode) {
+ return value;
+ }
+ switch (roundingMode) {
+ case 'round':
+ // used for Caffe Conv
+ return Math.round(value);
+ case 'ceil':
+ // used for Caffe Pool
+ return Math.ceil(value);
+ case 'floor':
+ return Math.floor(value);
+ default:
+ throw new Error(`Unknown roundingMode ${roundingMode}`);
+ }
+}
+function tupleValuesAreOne(param) {
+ const [dimA, dimB, dimC] = parseTupleParam(param);
+ return dimA === 1 && dimB === 1 && dimC === 1;
+}
+function eitherStridesOrDilationsAreOne(strides, dilations) {
+ return tupleValuesAreOne(strides) || tupleValuesAreOne(dilations);
+}
+/**
+ * Convert Conv2D dataFormat from 'NHWC'|'NCHW' to
+ * 'channelsLast'|'channelsFirst'
+ * @param dataFormat in 'NHWC'|'NCHW' mode
+ * @return dataFormat in 'channelsLast'|'channelsFirst' mode
+ * @throws unknown dataFormat
+ */
+function convertConv2DDataFormat(dataFormat) {
+ if (dataFormat === 'NHWC') {
+ return 'channelsLast';
+ }
+ else if (dataFormat === 'NCHW') {
+ return 'channelsFirst';
+ }
+ else {
+ throw new Error(`Unknown dataFormat ${dataFormat}`);
+ }
+}
+//# sourceMappingURL=conv_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/avg_pool_3d_backprop.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Computes the backprop of a 3d avg pool.
+ *
+ * @param dy The dy error, of rank 5 of shape
+ * [batchSize, depth, height, width, channels].
+ * assumed.
+ * @param input The original input image, of rank 5 or rank4 of shape
+ * [batchSize, depth, height, width, channels].
+ * @param filterSize The filter size:
+ * `[filterDepth, filterHeight, filterWidth]`.
+ * `filterSize` is a single number,
+ * then `filterDepth == filterHeight == filterWidth`.
+ * @param strides The strides of the pooling:
+ * `[strideDepth, strideHeight, strideWidth]`. If
+ * `strides` is a single number, then `strideHeight == strideWidth`.
+ * @param dilations Deprecated, this field will be gone in v3.0.0. The dilation
+ * rates: `[dilationDepth, dilationHeight, dilationWidth]`
+ * in which we sample input values across the depth, height and width
+ * dimensions in dilated pooling.
+ * Defaults to `[1, 1, 1]`. If `dilations` is a single number,
+ * then `dilationDepth == dilationHeight == dilationWidth`.
+ * If it is greater than 1, then all values of `strides` must be 1.
+ * @param pad A string from: 'same', 'valid'. The type of padding algorithm
+ * used in the forward prop of the op.
+ * @param dimRoundingMode A string from: 'ceil', 'round', 'floor'. The
+ * rounding mode used when computing output dimensions if pad is a
+ * number. If none is provided, it will not round and error if the output
+ * is of fractional size.
+ */
+function avgPool3dBackprop_(dy, input, filterSize, strides, dilations = [1, 1, 1], pad, dimRoundingMode) {
+ const $dy = Object(tensor_util_env["a" /* convertToTensor */])(dy, 'dy', 'avgPool3dBackprop');
+ const $input = Object(tensor_util_env["a" /* convertToTensor */])(input, 'input', 'avgPool3dBackprop');
+ let dy5D = $dy;
+ let input5D = $input;
+ let reshapedTo5D = false;
+ if ($input.rank === 4) {
+ reshapedTo5D = true;
+ dy5D = reshape($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
+ input5D = reshape($input, [
+ 1, $input.shape[0], $input.shape[1], $input.shape[2], $input.shape[3]
+ ]);
+ }
+ util["assert"](dy5D.rank === 5, () => `Error in avgPool3dBackprop: dy must be rank 5 but got rank ` +
+ `${dy5D.rank}.`);
+ util["assert"](input5D.rank === 5, () => `Error in avgPool3dBackprop: input must be rank 5 but got rank ` +
+ `${input5D.rank}.`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in avgPool3dBackprop: Either strides or dilations ' +
+ `must be 1. Got strides ${strides} and dilations '${dilations}'`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in maxPool3dBackprop: pad must be an integer when ` +
+ `using, dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = backend => {
+ const convInfo = computePool3DInfo(input5D.shape, filterSize, strides, dilations, pad, dimRoundingMode);
+ return backend.avgPool3dBackprop(dy5D, input5D, convInfo);
+ };
+ const inputs = { dy: dy5D, input: input5D };
+ const attrs = { filterSize, strides, dilations, pad, dimRoundingMode };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["f" /* AvgPool3DBackprop */], attrs);
+ if (reshapedTo5D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+ }
+ return res;
+}
+const avgPool3dBackprop = Object(operation["a" /* op */])({ avgPool3dBackprop_ });
+//# sourceMappingURL=avg_pool_3d_backprop.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/AvgPool3D_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const avgPool3DGradConfig = {
+ kernelName: kernel_names["e" /* AvgPool3D */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved, attrs) => {
+ const [x] = saved;
+ const { filterSize, strides, dilations, pad, dimRoundingMode } = attrs;
+ const $dilations = dilations == null ? [1, 1, 1] : dilations;
+ return {
+ x: () => avgPool3dBackprop(dy, x, filterSize, strides, $dilations, pad, dimRoundingMode)
+ };
+ }
+};
+//# sourceMappingURL=AvgPool3D_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/avg_pool_backprop.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Computes the backprop of an 2D avg pool.
+ *
+ * @param dy The dy error, of rank 4 or rank 3 of shape
+ * [batchSize, height, width, channels]. If rank 3, batch of 1 is
+ * assumed.
+ * @param input The input image, of rank 4 or rank 3 of shape
+ * [batchSize, height, width, channels]. If rank 3, batch of 1 is
+ * assumed.
+ * @param filterSize The filter size: `[filterHeight, filterWidth]`. If
+ * `filterSize` is a single number, then `filterHeight == filterWidth`.
+ * @param strides The strides of the pooling: `[strideHeight, strideWidth]`. If
+ * `strides` is a single number, then `strideHeight == strideWidth`.
+ * @param pad A string from: 'same', 'valid'. The type of padding algorithm
+ * used in the forward prop of the op.
+ */
+function avgPoolBackprop_(dy, input, filterSize, strides, pad) {
+ const $dy = Object(tensor_util_env["a" /* convertToTensor */])(dy, 'dy', 'avgPoolBackprop');
+ const $input = Object(tensor_util_env["a" /* convertToTensor */])(input, 'input', 'avgPoolBackprop');
+ util["assert"]($input.rank === $dy.rank, () => `Rank of input (${$input.rank}) does not match rank of dy (${$dy.rank})`);
+ let input4D = $input;
+ let dy4D = $dy;
+ let reshapedTo4D = false;
+ if ($input.rank === 3) {
+ reshapedTo4D = true;
+ input4D =
+ reshape($input, [1, $input.shape[0], $input.shape[1], $input.shape[2]]);
+ dy4D = reshape($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2]]);
+ }
+ util["assert"](dy4D.rank === 4, () => `Error in avgPoolBackprop: dy must be rank 4 but got rank ` +
+ `${dy4D.rank}.`);
+ util["assert"](input4D.rank === 4, () => `Error in avgPoolBackprop: input must be rank 4 but got rank ` +
+ `${input4D.rank}.`);
+ const forward = backend => {
+ const convInfo = computePool2DInfo(input4D.shape, filterSize, strides, 1 /* dilations */, pad);
+ return backend.avgPoolBackprop(dy4D, input4D, convInfo);
+ };
+ const inputs = { dy: dy4D, input: input4D };
+ const attrs = { filterSize, strides, pad };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null, kernel_names["g" /* AvgPoolBackprop */], attrs);
+ if (reshapedTo4D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
+ }
+ return res;
+}
+const avgPoolBackprop = Object(operation["a" /* op */])({ avgPoolBackprop_ });
+//# sourceMappingURL=avg_pool_backprop.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/AvgPool_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const avgPoolGradConfig = {
+ kernelName: kernel_names["d" /* AvgPool */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved, attrs) => {
+ const [x] = saved;
+ const { filterSize, strides, pad } = attrs;
+ return {
+ x: () => avgPoolBackprop(dy, x, filterSize, strides, pad)
+ };
+ }
+};
+//# sourceMappingURL=AvgPool_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/mat_mul.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Computes the dot product of two matrices, A * B. These must be matrices.
+ *
+ * ```js
+ * const a = tf.tensor2d([1, 2], [1, 2]);
+ * const b = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * a.matMul(b).print(); // or tf.matMul(a, b)
+ * ```
+ * @param a First matrix in dot product operation.
+ * @param b Second matrix in dot product operation.
+ * @param transposeA If true, `a` is transposed before multiplication.
+ * @param transposeB If true, `b` is transposed before multiplication.
+ */
+/** @doc {heading: 'Operations', subheading: 'Matrices'} */
+function matMul_(a, b, transposeA = false, transposeB = false) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'matMul');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'matMul');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ util["assert"]($a.rank >= 2 && $b.rank >= 2 && $a.rank === $b.rank, () => `Error in matMul: inputs must have the same rank of at least 2, ` +
+ `got ranks ${$a.rank} and ${$b.rank}.`);
+ const innerShapeA = transposeA ? $a.shape[$a.rank - 2] : $a.shape[$a.rank - 1];
+ const innerShapeB = transposeB ? $b.shape[$b.rank - 1] : $b.shape[$b.rank - 2];
+ const outerShapeA = transposeA ? $a.shape[$a.rank - 1] : $a.shape[$a.rank - 2];
+ const outerShapeB = transposeB ? $b.shape[$b.rank - 2] : $b.shape[$b.rank - 1];
+ const outerDimsA = $a.shape.slice(0, -2);
+ const outerDimsB = $b.shape.slice(0, -2);
+ const batchDimA = util["sizeFromShape"](outerDimsA);
+ const batchDimB = util["sizeFromShape"](outerDimsB);
+ util["assert"](util["arraysEqual"](outerDimsA, outerDimsB), () => `Error in matMul: outer dimensions (${outerDimsA}) and (` +
+ `${outerDimsB}) of Tensors with shapes ${$a.shape} and ` +
+ `${$b.shape} must match.`);
+ util["assert"](innerShapeA === innerShapeB, () => `Error in matMul: inner shapes (${innerShapeA}) and (` +
+ `${innerShapeB}) of Tensors with shapes ${$a.shape} and ` +
+ `${$b.shape} and transposeA=${transposeA}` +
+ ` and transposeB=${transposeB} must match.`);
+ const outShape = $a.shape.slice(0, -2).concat([outerShapeA, outerShapeB]);
+ const a3D = transposeA ? reshape($a, [batchDimA, innerShapeA, outerShapeA]) :
+ reshape($a, [batchDimA, outerShapeA, innerShapeA]);
+ const b3D = transposeB ? reshape($b, [batchDimB, outerShapeB, innerShapeB]) :
+ reshape($b, [batchDimB, innerShapeB, outerShapeB]);
+ const forward = (backend, save) => {
+ save([a3D, b3D]);
+ return backend.batchMatMul(a3D, b3D, transposeA, transposeB);
+ };
+ const inputs = { a: a3D, b: b3D };
+ const attrs = { transposeA, transposeB };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["h" /* BatchMatMul */], attrs);
+ return reshape(res, outShape);
+}
+const matMul = Object(operation["a" /* op */])({ matMul_ });
+//# sourceMappingURL=mat_mul.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/BatchMatMul_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const batchMatMulGradConfig = {
+ kernelName: kernel_names["h" /* BatchMatMul */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved, attrs) => {
+ const [a, b] = saved;
+ const { transposeA, transposeB } = attrs;
+ if (!transposeA && !transposeB) {
+ return {
+ a: () => matMul(dy, b, false, true),
+ b: () => matMul(a, dy, true, false)
+ };
+ }
+ else if (!transposeA && transposeB) {
+ return {
+ a: () => matMul(dy, b, false, false),
+ b: () => matMul(dy, a, true, false)
+ };
+ }
+ else if (transposeA && !transposeB) {
+ return {
+ a: () => matMul(b, dy, false, true),
+ b: () => matMul(a, dy, false, false)
+ };
+ }
+ else {
+ return {
+ a: () => matMul(b, dy, true, true),
+ b: () => matMul(dy, a, true, true)
+ };
+ }
+ }
+};
+//# sourceMappingURL=BatchMatMul_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/space_to_batch_nd.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * This operation divides "spatial" dimensions `[1, ..., M]` of the input into
+ * a grid of blocks of shape `blockShape`, and interleaves these blocks with
+ * the "batch" dimension (0) such that in the output, the spatial
+ * dimensions `[1, ..., M]` correspond to the position within the grid,
+ * and the batch dimension combines both the position within a spatial block
+ * and the original batch position. Prior to division into blocks,
+ * the spatial dimensions of the input are optionally zero padded
+ * according to `paddings`. See below for a precise description.
+ *
+ * ```js
+ * const x = tf.tensor4d([1, 2, 3, 4], [1, 2, 2, 1]);
+ * const blockShape = [2, 2];
+ * const paddings = [[0, 0], [0, 0]];
+ *
+ * x.spaceToBatchND(blockShape, paddings).print();
+ * ```
+ *
+ * @param x A `tf.Tensor`. N-D with `x.shape` = `[batch] + spatialShape +
+ * remainingShape`, where spatialShape has `M` dimensions.
+ * @param blockShape A 1-D array. Must have shape `[M]`, all values must
+ * be >= 1.
+ * @param paddings A 2-D array. Must have shape `[M, 2]`, all values must be >=
+ * 0. `paddings[i] = [padStart, padEnd]` specifies the amount to zero-pad
+ * from input dimension `i + 1`, which corresponds to spatial dimension `i`. It
+ * is required that
+ * `(inputShape[i + 1] + padStart + padEnd) % blockShape[i] === 0`
+ *
+ * This operation is equivalent to the following steps:
+ *
+ * 1. Zero-pad the start and end of dimensions `[1, ..., M]` of the input
+ * according to `paddings` to produce `padded` of shape paddedShape.
+ *
+ * 2. Reshape `padded` to `reshapedPadded` of shape:
+ * `[batch] + [paddedShape[1] / blockShape[0], blockShape[0], ...,
+ * paddedShape[M] / blockShape[M-1], blockShape[M-1]] + remainingShape`
+ *
+ * 3. Permute dimensions of `reshapedPadded` to produce `permutedReshapedPadded`
+ * of shape: `blockShape + [batch] + [paddedShape[1] / blockShape[0], ...,
+ * paddedShape[M] / blockShape[M-1]] + remainingShape`
+ *
+ * 4. Reshape `permutedReshapedPadded` to flatten `blockShape` into the
+ * batch dimension, producing an output tensor of shape:
+ * `[batch * prod(blockShape)] + [paddedShape[1] / blockShape[0], ...,
+ * paddedShape[M] / blockShape[M-1]] + remainingShape`
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function spaceToBatchND_(x, blockShape, paddings) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'spaceToBatchND');
+ util["assert"]($x.rank >= 1 + blockShape.length, () => `input rank ${$x.rank} should be > than [blockShape] ${blockShape.length}`);
+ util["assert"](paddings.length === blockShape.length, () => `paddings.shape[0] ${paddings.length} must be equal to [blockShape] ${blockShape.length}`);
+ util["assert"]($x.shape.reduce((a, b, i) => {
+ if (i > 0 && i <= blockShape.length) {
+ return a &&
+ ((b + paddings[i - 1][0] + paddings[i - 1][1]) %
+ blockShape[i - 1] ===
+ 0);
+ }
+ return a;
+ }, true), () => `input spatial dimensions ${$x.shape.slice(1)} with paddings ${paddings.toString()} must be divisible by blockShapes ${blockShape.toString()}`);
+ const forward = backend => backend.spaceToBatchND($x, blockShape, paddings);
+ const inputs = { x: $x };
+ const attrs = { blockShape, paddings };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["mb" /* SpaceToBatchND */], attrs);
+}
+const spaceToBatchND = Object(operation["a" /* op */])({ spaceToBatchND_ });
+//# sourceMappingURL=space_to_batch_nd.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/BatchToSpaceND_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const batchToSpaceNDGradConfig = {
+ kernelName: kernel_names["i" /* BatchToSpaceND */],
+ gradFunc: (dy, saved, attrs) => {
+ const { blockShape, crops } = attrs;
+ return { x: () => spaceToBatchND(dy, blockShape, crops) };
+ }
+};
+//# sourceMappingURL=BatchToSpaceND_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/BroadcastTo_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const broadcastToGradConfig = {
+ kernelName: kernel_names["j" /* BroadcastTo */],
+ gradFunc: (dy, saved, attrs) => {
+ const broadCastToAttrs = attrs;
+ const inputShape = broadCastToAttrs.inputShape;
+ const outputShape = broadCastToAttrs.shape;
+ const reps = Array.from(outputShape);
+ for (let i = inputShape.length - 1; i >= 0; i--) {
+ if (inputShape[i] === outputShape[i]) {
+ reps[i] = 1;
+ }
+ else if (inputShape[i] !== 1) {
+ throw new Error(`broadcastTo(): [${inputShape}] cannot be broadcast to [${outputShape}].`);
+ }
+ }
+ const axes = [];
+ for (let i = 0; i < reps.length; i++) {
+ if (reps[i] > 1) {
+ axes.push(i);
+ }
+ }
+ return { x: () => sum(dy, axes, true /* keepDims */) };
+ }
+};
+//# sourceMappingURL=BroadcastTo_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/split.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Splits a `tf.Tensor` into sub tensors.
+ *
+ * If `numOrSizeSplits` is a number, splits `x` along dimension `axis`
+ * into `numOrSizeSplits` smaller tensors.
+ * Requires that `numOrSizeSplits` evenly divides `x.shape[axis]`.
+ *
+ * If `numOrSizeSplits` is a number array, splits `x` into
+ * `numOrSizeSplits.length` pieces. The shape of the `i`-th piece has the
+ * same size as `x` except along dimension `axis` where the size is
+ * `numOrSizeSplits[i]`.
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4, 5, 6, 7, 8], [2, 4]);
+ * const [a, b] = tf.split(x, 2, 1);
+ * a.print();
+ * b.print();
+ *
+ * const [c, d, e] = tf.split(x, [1, 2, 1], 1);
+ * c.print();
+ * d.print();
+ * e.print();
+ * ```
+ *
+ * @param x The input tensor to split.
+ * @param numOrSizeSplits Either an integer indicating the number of
+ * splits along the axis or an array of integers containing the sizes of
+ * each output tensor along the axis. If a number then it must evenly divide
+ * `x.shape[axis]`; otherwise the sum of sizes must match `x.shape[axis]`.
+ * @param axis The dimension along which to split. Defaults to 0 (the first
+ * dim).
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+function split_(x, numOrSizeSplits, axis = 0) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'split');
+ const $axis = Object(util["parseAxisParam"])(axis, $x.shape)[0];
+ let splitSizes;
+ if (typeof (numOrSizeSplits) === 'number') {
+ Object(util["assert"])($x.shape[$axis] % numOrSizeSplits === 0, () => 'Number of splits must evenly divide the axis.');
+ splitSizes =
+ new Array(numOrSizeSplits).fill($x.shape[$axis] / numOrSizeSplits);
+ }
+ else {
+ Object(util["assert"])($x.shape[$axis] === numOrSizeSplits.reduce((a, b) => a + b), () => 'The sum of sizes must match the size of the axis dimension.');
+ splitSizes = numOrSizeSplits;
+ }
+ const forward = (backend, _) => {
+ return backend.split($x, splitSizes, $axis);
+ };
+ const inputs = { x: $x };
+ const attr = { numOrSizeSplits, axis };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["nb" /* SplitV */], attr);
+}
+const split = Object(operation["a" /* op */])({ split_ });
+//# sourceMappingURL=split.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Concat_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+const concatGradConfig = {
+ kernelName: kernel_names["l" /* Concat */],
+ saveAllInputs: true,
+ gradFunc: (dy, saved, attrs) => {
+ const shapes = saved.map(t => t.shape);
+ const { axis } = attrs;
+ const $axis = Object(util["parseAxisParam"])(axis, saved[0].shape)[0];
+ const sizeSplits = shapes.map(s => s[$axis]);
+ const derTensors = split(dy, sizeSplits, $axis);
+ return derTensors.map(t => () => t);
+ }
+};
+//# sourceMappingURL=Concat_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv2d_backprop_filter.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Computes the derivative of the filter of a 2D convolution.
+ *
+ * @param x The input tensor, of rank 4 or rank 3 of shape
+ * [batch, height, width, inChannels]. If rank 3, batch of 1 is assumed.
+ * @param dy The dy image, of rank 4 or rank 3, of shape
+ * [batch, height, width, outDepth]. If rank 3, batch of 1 is assumed.
+ * @param filterShape The shape of the filter, length 4,
+ * [filterHeight, filterWidth, inDepth, outDepth].
+ * @param strides The strides of the convolution: [strideHeight,
+ * strideWidth].
+ * @param pad A string from: 'same', 'valid'. The type of padding algorithm
+ * used in the forward prop of the op.
+ * @param dataFormat: An optional string from: "NHWC", "NCHW". Defaults to
+ * "NHWC". Specify the data format of the input and output data. With the
+ * default format "NHWC", the data is stored in the order of: [batch,
+ * height, width, channels].
+ * @param dimRoundingMode A string from: 'ceil', 'round', 'floor'. The
+ * rounding mode used when computing output dimensions if pad is a
+ * number. If none is provided, it will not round and error if the output
+ * is of fractional size.
+ */
+function conv2DBackpropFilter_(x, dy, filterShape, strides, pad, dataFormat = 'NHWC', dimRoundingMode) {
+ let x4D = x;
+ if (x.rank === 3) {
+ x4D = reshape(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
+ }
+ let dy4D = dy;
+ if (dy4D.rank === 3) {
+ dy4D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+ }
+ util["assert"](x4D.rank === 4, () => `Error in conv2dDerFilter: input must be rank 4, but got shape ` +
+ `${x4D.shape}.`);
+ util["assert"](dy4D.rank === 4, () => `Error in conv2dDerFilter: dy must be rank 4, but got shape ` +
+ `${dy4D.shape}.`);
+ util["assert"](filterShape.length === 4, () => `Error in conv2dDerFilter: filterShape must be length 4, but got ` +
+ `${filterShape}.`);
+ const inDepth = dataFormat === 'NHWC' ? x4D.shape[3] : x4D.shape[1];
+ const outDepth = dataFormat === 'NHWC' ? dy4D.shape[3] : dy4D.shape[1];
+ util["assert"](inDepth === filterShape[2], () => `Error in conv2dDerFilter: depth of input ${inDepth}) must ` +
+ `match input depth in filter (${filterShape[2]}.`);
+ util["assert"](outDepth === filterShape[3], () => `Error in conv2dDerFilter: depth of dy (${outDepth}) must ` +
+ `match output depth for filter (${filterShape[3]}).`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in conv2dDerFilter: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = backend => {
+ const dilations = 1;
+ const $dataFormat = convertConv2DDataFormat(dataFormat);
+ const convInfo = computeConv2DInfo(x4D.shape, filterShape, strides, dilations, pad, dimRoundingMode, false, $dataFormat);
+ return backend.conv2dDerFilter(x4D, dy4D, convInfo);
+ };
+ const inputs = { x: x4D, dy: dy4D };
+ const attrs = { strides, pad, dataFormat, dimRoundingMode };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null, kernel_names["n" /* Conv2DBackpropFilter */], attrs);
+}
+const conv2DBackpropFilter = Object(operation["a" /* op */])({ conv2DBackpropFilter_ });
+//# sourceMappingURL=conv2d_backprop_filter.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv2d_backprop_input.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Computes the derivative of the input of a 2D convolution.
+ *
+ * @param xShape The shape of the input: [batch, height, width, inDepth].
+ * If length of 3, batch of 1 is assumed.
+ * @param dy The derivative of the output, of rank 4 or rank 3 of shape
+ * `[batch, outHeight, outWidth, outDepth]`. If rank 3, batch of 1 is
+ * assumed.
+ * @param filter The filter, rank 4, of shape
+ * `[filterHeight, filterWidth, inDepth, outDepth]`.
+ * @param strides The strides of the convolution: `[strideHeight,
+ * strideWidth]`.
+ * @param pad The type of padding algorithm used:
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * @param dataFormat: An optional string from: "NHWC", "NCHW". Defaults to
+ * "NHWC". Specify the data format of the input and output data. With the
+ * default format "NHWC", the data is stored in the order of: [batch,
+ * height, width, channels].
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ */
+function conv2DBackpropInput_(xShape, dy, filter, strides, pad, dataFormat = 'NHWC', dimRoundingMode) {
+ util["assert"](xShape.length === dy.rank, () => `Length of inShape ` +
+ `(${xShape.length}) and rank of dy (${dy.rank}) must match`);
+ let xShape4D = xShape;
+ let dy4D = dy;
+ let reshapedTo4D = false;
+ if (dy.rank === 3) {
+ reshapedTo4D = true;
+ dy4D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+ xShape4D = [1, xShape[0], xShape[1], xShape[2]];
+ }
+ util["assert"](xShape4D.length === 4, () => `Error in conv2dDerInput: inShape must be length 4, but got length ` +
+ `${xShape4D.length}.`);
+ util["assert"](dy4D.rank === 4, () => `Error in conv2dDerInput: dy must be rank 4, but got ` +
+ `rank ${dy4D.rank}`);
+ util["assert"](filter.rank === 4, () => `Error in conv2dDerInput: filter must be rank 4, but got ` +
+ `rank ${filter.rank}`);
+ const inDepth = dataFormat === 'NHWC' ? xShape4D[3] : xShape4D[1];
+ const outDepth = dataFormat === 'NHWC' ? dy4D.shape[3] : dy4D.shape[1];
+ util["assert"](inDepth === filter.shape[2], () => `Error in conv2dDerInput: depth of input (${inDepth}) must ` +
+ `match input depth for filter ${filter.shape[2]}.`);
+ util["assert"](outDepth === filter.shape[3], () => `Error in conv2dDerInput: depth of output (${outDepth}) must ` +
+ `match output depth for filter ${filter.shape[3]}.`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in conv2dDerInput: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = (backend, save) => {
+ const dilations = 1;
+ const $dataFormat = convertConv2DDataFormat(dataFormat);
+ const convInfo = computeConv2DInfo(xShape4D, filter.shape, strides, dilations, pad, dimRoundingMode, false, $dataFormat);
+ const res = backend.conv2dDerInput(dy4D, filter, convInfo);
+ save([dy4D, filter]);
+ return res;
+ };
+ const inputs = { dy: dy4D, filter };
+ const attrs = { strides, pad, dataFormat, dimRoundingMode };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["o" /* Conv2DBackpropInput */], attrs);
+ if (reshapedTo4D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
+ }
+ return res;
+}
+const conv2DBackpropInput = Object(operation["a" /* op */])({ conv2DBackpropInput_ });
+//# sourceMappingURL=conv2d_backprop_input.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Conv2D_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const conv2DGradConfig = {
+ kernelName: kernel_names["m" /* Conv2D */],
+ inputsToSave: ['x', 'filter'],
+ gradFunc: (dy, saved, attrs) => {
+ const [x4D, $filter] = saved;
+ const { dilations, strides, pad, dataFormat } = attrs;
+ util["assert"](tupleValuesAreOne(dilations), () => 'Error in gradient of conv2D: dilation rates greater than 1 ' +
+ `are not yet supported in gradients. Got dilations '${dilations}'`);
+ return {
+ x: () => conv2DBackpropInput(x4D.shape, dy, $filter, strides, pad, dataFormat),
+ filter: () => conv2DBackpropFilter(x4D, dy, $filter.shape, strides, pad, dataFormat)
+ };
+ }
+};
+//# sourceMappingURL=Conv2D_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv2d.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Computes a 2D convolution over the input x.
+ *
+ * @param x The input tensor, of rank 4 or rank 3, of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is
+ * assumed.
+ * @param filter The filter, rank 4, of shape
+ * `[filterHeight, filterWidth, inDepth, outDepth]`.
+ * @param strides The strides of the convolution: `[strideHeight,
+ * strideWidth]`.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dataFormat: An optional string from: "NHWC", "NCHW". Defaults to
+ * "NHWC". Specify the data format of the input and output data. With the
+ * default format "NHWC", the data is stored in the order of: [batch,
+ * height, width, channels].
+ * @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
+ * in which we sample input values across the height and width dimensions
+ * in atrous convolution. Defaults to `[1, 1]`. If `dilations` is a single
+ * number, then `dilationHeight == dilationWidth`. If it is greater than
+ * 1, then all values of `strides` must be 1.
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function conv2d_(x, filter, strides, pad, dataFormat = 'NHWC', dilations = [1, 1], dimRoundingMode) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'conv2d');
+ const $filter = Object(tensor_util_env["a" /* convertToTensor */])(filter, 'filter', 'conv2d');
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
+ }
+ util["assert"](x4D.rank === 4, () => `Error in conv2d: input must be rank 4, but got rank ${x4D.rank}.`);
+ util["assert"]($filter.rank === 4, () => `Error in conv2d: filter must be rank 4, but got rank ` +
+ `${$filter.rank}.`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in conv2d: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const inDepth = dataFormat === 'NHWC' ? x4D.shape[3] : x4D.shape[1];
+ util["assert"](inDepth === $filter.shape[2], () => `Error in conv2d: depth of input (${inDepth}) must match ` +
+ `input depth for filter ${$filter.shape[2]}.`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in conv2D: Either strides or dilations must be 1. ' +
+ `Got strides ${strides} and dilations '${dilations}'`);
+ const forward = (backend, save) => {
+ const $dataFormat = convertConv2DDataFormat(dataFormat);
+ const convInfo = computeConv2DInfo(x4D.shape, $filter.shape, strides, dilations, pad, dimRoundingMode, false, $dataFormat);
+ const res = backend.conv2d(x4D, $filter, convInfo);
+ save([x4D, $filter]);
+ return res;
+ };
+ const inputs = { x: x4D, filter: $filter };
+ const attrs = { strides, pad, dataFormat, dilations, dimRoundingMode };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["m" /* Conv2D */], attrs);
+ if (reshapedTo4D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
+ }
+ return res;
+}
+const conv2d = Object(operation["a" /* op */])({ conv2d_ });
+//# sourceMappingURL=conv2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Conv2DBackpropInput_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+const conv2DBackpropInputGradConfig = {
+ kernelName: kernel_names["o" /* Conv2DBackpropInput */],
+ inputsToSave: ['dy', 'filter'],
+ gradFunc: (ddx, saved, attrs) => {
+ const [dy, filter] = saved;
+ const { strides, pad, dataFormat, dimRoundingMode } = attrs;
+ return {
+ dy: () => conv2d(ddx, filter, strides, pad, dataFormat, 1 /* dilations */, dimRoundingMode),
+ filter: () => conv2DBackpropFilter(ddx, dy, filter.shape, strides, pad, dataFormat, dimRoundingMode)
+ };
+ }
+};
+//# sourceMappingURL=Conv2DBackpropInput_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv3d_backprop_filter.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Computes the derivative of the filter of a 3D convolution.
+ *
+ * @param x The input tensor, of rank 5 or rank 4 of shape
+ * [batch, depth, height, width, inChannels]. If rank 4, batch of 1 is
+ * assumed.
+ * @param dy The dy image, of rank 5 or rank 4, of shape
+ * [batch, depth, height, width, outDepth]. If rank 4, batch of 1 is
+ * assumed.
+ * @param filterShape The shape of the filter, length 5,
+ * [filterDepth, filterHeight, filterWidth, inDepth, outDepth].
+ * @param strides The strides of the convolution: [strideDepth, strideHeight,
+ * strideWidth].
+ * @param pad A string from: 'same', 'valid'. The type of padding algorithm
+ * used in the forward prop of the op.
+ */
+function conv3DBackpropFilter_(x, dy, filterShape, strides, pad) {
+ let x5D = x;
+ if (x.rank === 4) {
+ x5D = reshape(x, [1, x.shape[0], x.shape[1], x.shape[2], x.shape[3]]);
+ }
+ let dy5D = dy;
+ if (dy5D.rank === 4) {
+ dy5D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
+ }
+ util["assert"](x5D.rank === 5, () => `Error in conv3dDerFilter: input must be rank 5, but got shape ` +
+ `${x5D.shape}.`);
+ util["assert"](dy5D.rank === 5, () => `Error in conv3dDerFilter: dy must be rank 5, but got shape ` +
+ `${dy5D.shape}.`);
+ util["assert"](filterShape.length === 5, () => `Error in conv3dDerFilter: filterShape must be length 5, but got ` +
+ `${filterShape}.`);
+ util["assert"](x5D.shape[4] === filterShape[3], () => `Error in conv3dDerFilter: depth of input ${x5D.shape[4]}) must ` +
+ `match input depth in filter (${filterShape[3]}.`);
+ util["assert"](dy5D.shape[4] === filterShape[4], () => `Error in conv3dDerFilter: depth of dy (${dy5D.shape[4]}) must ` +
+ `match output depth for filter (${filterShape[4]}).`);
+ const forward = backend => {
+ const dilations = 1;
+ const convInfo = computeConv3DInfo(x5D.shape, filterShape, strides, dilations, pad);
+ return backend.conv3dDerFilter(x5D, dy5D, convInfo);
+ };
+ const inputs = { x: x5D, y: dy5D };
+ const attrs = { strides, pad };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null, kernel_names["q" /* Conv3DBackpropFilterV2 */], attrs);
+}
+const conv3DBackpropFilter = Object(operation["a" /* op */])({ conv3DBackpropFilter_ });
+//# sourceMappingURL=conv3d_backprop_filter.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv3d_backprop_input.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Computes the derivative of the input of a 3D convolution.
+ *
+ * @param xShape The shape of the input: [batch, depth, height, width,
+ * in_channels]. If length of 4, batch of 1 is assumed.
+ * @param dy The derivative of the output, of rank 5 or rank 4 of shape
+ * `[batch, outDepth, outHeight, outWidth, in_channels]`.
+ * If rank 4, batch of 1 is assumed.
+ * @param filter The filter, rank 5, of shape
+ * `[filterDepth, filterHeight, filterWidth, inDepth, outDepth]`.
+ * @param strides The strides of the convolution: `[strideDepth, strideHeight,
+ * strideWidth]`.
+ * @param pad The type of padding algorithm used:
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ */
+function conv3DBackpropInput_(xShape, dy, filter, strides, pad) {
+ util["assert"](xShape.length === dy.rank, () => `Length of inShape ` +
+ `(${xShape.length}) and rank of dy (${dy.rank}) must match`);
+ let xShape5D = xShape;
+ let dy5D = dy;
+ let reshapedTo5D = false;
+ if (dy.rank === 4) {
+ reshapedTo5D = true;
+ dy5D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
+ xShape5D = [1, xShape[0], xShape[1], xShape[2], xShape[3]];
+ }
+ const inDepth = xShape5D[4];
+ const outDepth = dy5D.shape[4];
+ util["assert"](xShape5D.length === 5, () => `Error in conv3dDerInput: inShape must be length 5, but got length ` +
+ `${xShape5D.length}.`);
+ util["assert"](dy5D.rank === 5, () => `Error in conv3dDerInput: dy must be rank 5, but got ` +
+ `rank ${dy5D.rank}`);
+ util["assert"](filter.rank === 5, () => `Error in conv3dDerInput: filter must be rank 5, but got ` +
+ `rank ${filter.rank}`);
+ util["assert"](inDepth === filter.shape[3], () => `Error in conv3dDerInput: depth of input (${inDepth}) must ` +
+ `match input depth for filter ${filter.shape[3]}.`);
+ util["assert"](outDepth === filter.shape[4], () => `Error in conv3dDerInput: depth of output (${outDepth}) must ` +
+ `match output depth for filter ${filter.shape[4]}.`);
+ const forward = backend => {
+ const dilations = 1;
+ const convInfo = computeConv3DInfo(xShape5D, filter.shape, strides, dilations, pad);
+ return backend.conv3dDerInput(dy5D, filter, convInfo);
+ };
+ const inputs = { dy: dy5D };
+ const attrs = { pad };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null, kernel_names["r" /* Conv3DBackpropInputV2 */], attrs);
+ if (reshapedTo5D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+ }
+ return res;
+}
+const conv3DBackpropInput = Object(operation["a" /* op */])({ conv3DBackpropInput_ });
+//# sourceMappingURL=conv3d_backprop_input.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Conv3D_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const conv3DGradConfig = {
+ kernelName: kernel_names["p" /* Conv3D */],
+ inputsToSave: ['x', 'filter'],
+ gradFunc: (dy, saved, attrs) => {
+ const { dilations, strides, pad } = attrs;
+ util["assert"](tupleValuesAreOne(dilations), () => 'Error in gradient of conv3D: dilation rates greater than 1 are ' +
+ `not yet supported in gradients. Got dilations '${dilations}'`);
+ const [x5D, $filter] = saved;
+ return {
+ x: () => conv3DBackpropInput(x5D.shape, dy, $filter, strides, pad),
+ filter: () => conv3DBackpropFilter(x5D, dy, $filter.shape, strides, pad)
+ };
+ }
+};
+//# sourceMappingURL=Conv3D_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/transpose.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Transposes the `tf.Tensor`. Permutes the dimensions according to `perm`.
+ *
+ * The returned `tf.Tensor`'s dimension `i` will correspond to the input
+ * dimension `perm[i]`. If `perm` is not given, it is set to `[n-1...0]`,
+ * where `n` is the rank of the input `tf.Tensor`. Hence by default, this
+ * operation performs a regular matrix transpose on 2-D input `tf.Tensor`s.
+ *
+ * ```js
+ * const a = tf.tensor2d([1, 2, 3, 4, 5, 6], [2, 3]);
+ *
+ * a.transpose().print(); // or tf.transpose(a)
+ * ```
+ *
+ * @param x The tensor to transpose.
+ * @param perm The permutation of the dimensions of a.
+ */
+/** @doc {heading: 'Operations', subheading: 'Matrices'} */
+function transpose_(x, perm) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'transpose');
+ if (perm == null) {
+ perm = $x.shape.map((s, i) => i).reverse();
+ }
+ util["assert"]($x.rank === perm.length, () => `Error in transpose: rank of input ${$x.rank} ` +
+ `must match length of perm ${perm}.`);
+ perm.forEach(axis => {
+ util["assert"](axis >= 0 && axis < $x.rank, () => `All entries in 'perm' must be between 0 and ${$x.rank - 1}` +
+ ` but got ${perm}`);
+ });
+ if ($x.rank <= 1) {
+ return $x.clone();
+ }
+ const attrs = { perm };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.transpose($x, perm), { x: $x }, null /* gradient */, 'Transpose', attrs);
+}
+const transpose = Object(operation["a" /* op */])({ transpose_ });
+//# sourceMappingURL=transpose.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/cumsum.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Computes the cumulative sum of a `tf.Tensor` along `axis`.
+ *
+ * ```js
+ * const x = tf.tensor([1, 2, 3, 4]);
+ * x.cumsum().print();
+ * ```
+ * ```js
+ * const x = tf.tensor([[1, 2], [3, 4]]);
+ * x.cumsum().print();
+ * ```
+ *
+ * @param x The input tensor to be summed.
+ * @param axis The axis along which to sum. Optional. Defaults to 0.
+ * @param exclusive Whether to perform exclusive cumulative sum. Optional.
+ * Defaults to false. If set to true then the sum of each tensor entry
+ * does not include its own value, but only the values previous to it
+ * along the specified axis.
+ * @param reverse Whether to sum in the opposite direction. Optional.
+ * Defaults to false.
+ */
+/** @doc {heading: 'Operations', subheading: 'Scan'} */
+function cumsum_(x, axis = 0, exclusive = false, reverse = false) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'cumsum');
+ const forward = (backend, save) => {
+ const permutation = getAxesPermutation([axis], $x.rank);
+ let permutedX = $x;
+ if (permutation != null) {
+ permutedX = transpose($x, permutation);
+ }
+ const permutedAxis = getInnerMostAxes(1, $x.rank)[0];
+ let value = backend.cumsum(permutedX, permutedAxis, exclusive, reverse);
+ save([$x]);
+ if (permutation != null) {
+ value = transpose(value, permutation);
+ }
+ return value;
+ };
+ const inputs = { x: $x };
+ const attrs = { axis, exclusive, reverse };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["s" /* Cumsum */], attrs);
+}
+const cumsum = Object(operation["a" /* op */])({ cumsum_ });
+//# sourceMappingURL=cumsum.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Cumsum_grad.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+const cumsumGradConfig = {
+ kernelName: kernel_names["s" /* Cumsum */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved, attrs) => {
+ const [x] = saved;
+ const { axis, exclusive, reverse } = attrs;
+ return {
+ x: () => {
+ const permutation = getAxesPermutation([axis], x.rank);
+ let out = cumsum(dy, axis, exclusive, !reverse);
+ if (permutation != null) {
+ out = transpose(out, permutation);
+ }
+ return out;
+ }
+ };
+ }
+};
+//# sourceMappingURL=Cumsum_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/depthwise_conv2d_native_backprop_filter.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+function depthwiseConv2dNativeBackpropFilter_(x, dy, filterShape, convInfo) {
+ let x4D = x;
+ if (x.rank === 3) {
+ x4D = reshape(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
+ }
+ let dy4D = dy;
+ if (dy4D.rank === 3) {
+ dy4D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+ }
+ const forward = backend => backend.depthwiseConv2DDerFilter(x4D, dy4D, convInfo);
+ const inputs = { x: x4D, dy: dy4D };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null, kernel_names["v" /* DepthwiseConv2dNativeBackpropFilter */]);
+}
+const depthwiseConv2dNativeBackpropFilter = Object(operation["a" /* op */])({ depthwiseConv2dNativeBackpropFilter_ });
+//# sourceMappingURL=depthwise_conv2d_native_backprop_filter.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/depthwise_conv2d_native_backprop_input.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+function depthwiseConv2dNativeBackpropInput_(xShape, dy, filter, convInfo) {
+ let dy4D = dy;
+ let reshapedTo4D = false;
+ if (dy.rank === 3) {
+ reshapedTo4D = true;
+ dy4D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+ }
+ const forward = backend => backend.depthwiseConv2DDerInput(dy4D, filter, convInfo);
+ const inputs = { dy: dy4D };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null, kernel_names["w" /* DepthwiseConv2dNativeBackpropInput */]);
+ if (reshapedTo4D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
+ }
+ return res;
+}
+const depthwiseConv2dNativeBackpropInput = Object(operation["a" /* op */])({ depthwiseConv2dNativeBackpropInput_ });
+//# sourceMappingURL=depthwise_conv2d_native_backprop_input.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/DepthwiseConv2dNative_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const depthwiseConv2dNativeGradConfig = {
+ kernelName: kernel_names["u" /* DepthwiseConv2dNative */],
+ inputsToSave: ['x', 'filter'],
+ gradFunc: (dy, saved, attrs) => {
+ const { dilations, strides, pad, dimRoundingMode } = attrs;
+ const $dilations = dilations == null ? [1, 1] : dilations;
+ util["assert"](tupleValuesAreOne($dilations), () => 'Error in gradient of depthwiseConv2dNative: dilation rates ' +
+ `greater than 1 are not yet supported. Got dilations ` +
+ `'${$dilations}'`);
+ const [x, filter] = saved;
+ util["assert"](x.rank === 4, () => `Error in gradient of depthwiseConv2dNative: input must be ` +
+ `rank 4, but got rank ${x.rank}.`);
+ util["assert"](filter.rank === 4, () => `Error in gradient of depthwiseConv2dNative: filter must be ` +
+ `rank 4, but got rank ${filter.rank}.`);
+ util["assert"](x.shape[3] === filter.shape[2], () => `Error in gradient of depthwiseConv2d: number of input ` +
+ `channels (${x.shape[3]}) must match the inChannels dimension ` +
+ `in filter ${filter.shape[2]}.`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, $dilations), () => 'Error in gradient of depthwiseConv2d: Either strides or ' +
+ `dilations must be 1. Got strides ${strides} and dilations ` +
+ `'${$dilations}'.`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in depthwiseConv2d: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const convInfo = computeConv2DInfo(x.shape, filter.shape, strides, $dilations, pad, dimRoundingMode, true /* depthwise */);
+ return {
+ x: () => depthwiseConv2dNativeBackpropInput(x.shape, dy, filter, convInfo),
+ filter: () => depthwiseConv2dNativeBackpropFilter(x, dy, filter.shape, convInfo),
+ };
+ }
+};
+//# sourceMappingURL=DepthwiseConv2dNative_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Div_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+const divGradConfig = {
+ kernelName: kernel_names["y" /* Div */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
+ const derA = () => {
+ const res = div(dy, b.toFloat());
+ const reduceAxes = getReductionAxes(a.shape, outShape);
+ if (reduceAxes.length > 0) {
+ return sum(res, reduceAxes).reshape(a.shape);
+ }
+ return res;
+ };
+ const derB = () => {
+ let res = mul(dy, a.toFloat());
+ const reduceAxes = getReductionAxes(b.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = reshape(sum(res, reduceAxes), b.shape);
+ }
+ const tmp = square(b);
+ return neg(div(res, tmp.toFloat()));
+ };
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=Div_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Elu_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const eluGradConfig = {
+ kernelName: kernel_names["z" /* Elu */],
+ outputsToSave: [true],
+ gradFunc: (dy, saved) => {
+ const [y] = saved;
+ const backPropKernelFunc = (backend) => {
+ return backend.eluDer(dy, y);
+ };
+ const inputs = { dy, y };
+ return {
+ x: () => engine["a" /* ENGINE */].runKernelFunc(backPropKernelFunc, inputs, null /* grad */, kernel_names["A" /* EluGrad */])
+ };
+ }
+};
+//# sourceMappingURL=Elu_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/FloorDiv_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const floorDivGradConfig = {
+ kernelName: kernel_names["D" /* FloorDiv */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
+ const derA = () => {
+ const res = dy.div(b.toFloat());
+ const reduceAxes = getReductionAxes(a.shape, outShape);
+ if (reduceAxes.length > 0) {
+ return res.sum(reduceAxes).reshape(a.shape);
+ }
+ return res;
+ };
+ const derB = () => {
+ let res = dy.mul(a.toFloat());
+ const reduceAxes = getReductionAxes(b.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = res.sum(reduceAxes).reshape(b.shape);
+ }
+ const tmp = b.square();
+ return res.div(tmp.toFloat()).neg();
+ };
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=FloorDiv_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/sub.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Subtracts two `tf.Tensor`s element-wise, A - B. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([10, 20, 30, 40]);
+ * const b = tf.tensor1d([1, 2, 3, 4]);
+ *
+ * a.sub(b).print(); // or tf.sub(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast subtract a with b.
+ * const a = tf.tensor1d([10, 20, 30, 40]);
+ * const b = tf.scalar(5);
+ *
+ * a.sub(b).print(); // or tf.sub(a, b)
+ * ```
+ * @param a The first `tf.Tensor` to subtract from.
+ * @param b The second `tf.Tensor` to be subtracted. Must have the same dtype as
+ * `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function sub_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'sub');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'sub');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ const forward = (backend, save) => {
+ const res = backend.subtract($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["qb" /* Sub */]);
+}
+const sub = Object(operation["a" /* op */])({ sub_ });
+//# sourceMappingURL=sub.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/tile.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Construct a tensor by repeating it the number of times given by reps.
+ *
+ * This operation creates a new tensor by replicating `input` `reps`
+ * times. The output tensor's i'th dimension has `input.shape[i] *
+ * reps[i]` elements, and the values of `input` are replicated
+ * `reps[i]` times along the i'th dimension. For example, tiling
+ * `[a, b, c, d]` by `[2]` produces `[a, b, c, d, a, b, c, d]`.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2]);
+ *
+ * a.tile([2]).print(); // or a.tile([2])
+ * ```
+ *
+ * ```js
+ * const a = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * a.tile([1, 2]).print(); // or a.tile([1, 2])
+ * ```
+ * @param x The tensor to tile.
+ * @param reps Determines the number of replications per dimension.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+function tile_(x, reps) {
+ const parseAs = null;
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'tile', parseAs);
+ util["assert"]($x.rank === reps.length, () => `Error in transpose: rank of input ${$x.rank} ` +
+ `must match length of reps ${reps}.`);
+ const forward = (backend, save) => {
+ const res = backend.tile($x, reps);
+ save([$x]);
+ return res;
+ };
+ const inputsToSave = [$x];
+ const inputs = { x: $x };
+ const attrs = { reps };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["rb" /* Tile */], attrs, inputsToSave);
+}
+const tile = Object(operation["a" /* op */])({ tile_ });
+//# sourceMappingURL=tile.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/FusedBatchNorm_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+
+const fusedBatchNormGradConfig = {
+ kernelName: kernel_names["F" /* FusedBatchNorm */],
+ inputsToSave: ['x', 'mean', 'variance', 'scale'],
+ gradFunc: (dy, saved, attrs) => {
+ const { varianceEpsilon } = attrs;
+ const [x, mean, variance, scale] = saved;
+ const scaleValue = scale == null ? Object(tensor_ops["e" /* scalar */])(1) : scale;
+ const reductionAxes = getReductionAxes(mean.shape, x.shape);
+ const tileShape = [];
+ if (mean.rank === 1) {
+ for (let i = 0; i < x.shape.length - 1; ++i) {
+ tileShape.push(x.shape[i]);
+ }
+ tileShape.push(1);
+ }
+ const xMinusMean = sub(x, mean);
+ const dyTimesScaleValue = mul(dy, scaleValue);
+ const oneOverSqrtVariance = rsqrt(add(variance, Object(tensor_ops["e" /* scalar */])(varianceEpsilon)));
+ const minusHalfRCube = mul(mul(mul(oneOverSqrtVariance, oneOverSqrtVariance), oneOverSqrtVariance), Object(tensor_ops["e" /* scalar */])(-0.5));
+ const derX = () => {
+ if (mean.rank === 1) {
+ return reshape(mul(mul(dy, tile(oneOverSqrtVariance.as4D(1, 1, 1, mean.shape[0]), tileShape)), scaleValue), x.shape);
+ }
+ else {
+ return reshape(mul(mul(dy, oneOverSqrtVariance), scaleValue), x.shape);
+ }
+ };
+ const derMean = () => {
+ let meanDer = mul(mul(oneOverSqrtVariance, Object(tensor_ops["e" /* scalar */])(-1)), dyTimesScaleValue);
+ if (mean.rank === 1) {
+ meanDer = sum(meanDer, reductionAxes);
+ }
+ return reshape(meanDer, mean.shape);
+ };
+ const derVariance = () => {
+ let varianceDer = mul(mul(minusHalfRCube, xMinusMean), dyTimesScaleValue);
+ if (mean.rank === 1) {
+ varianceDer = sum(varianceDer, reductionAxes);
+ }
+ return reshape(varianceDer, mean.shape);
+ };
+ const derScale = () => {
+ const xMinusMean2TimesRsqrt = mul(xMinusMean, oneOverSqrtVariance);
+ let scaleDer = mul(dy, xMinusMean2TimesRsqrt);
+ if (mean.rank === 1) {
+ scaleDer = sum(scaleDer, reductionAxes);
+ }
+ return reshape(scaleDer, mean.shape);
+ };
+ const derOffset = () => {
+ let offsetDer = dy;
+ if (mean.rank === 1) {
+ offsetDer = sum(offsetDer, reductionAxes);
+ }
+ return reshape(offsetDer, mean.shape);
+ };
+ return {
+ x: derX,
+ mean: derMean,
+ variance: derVariance,
+ scale: derScale,
+ offset: derOffset
+ };
+ }
+};
+//# sourceMappingURL=FusedBatchNorm_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/GreaterEqual_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const greaterEqualGradConfig = {
+ kernelName: kernel_names["I" /* GreaterEqual */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ return { a: () => Object(tensor_ops["o" /* zerosLike */])(a), b: () => Object(tensor_ops["o" /* zerosLike */])(b) };
+ }
+};
+//# sourceMappingURL=GreaterEqual_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Identity_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+const identityGradConfig = {
+ kernelName: kernel_names["J" /* Identity */],
+ gradFunc: (dy) => {
+ return { x: () => dy.toFloat() };
+ }
+};
+//# sourceMappingURL=Identity_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/local_response_normalization_backprop.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+function localResponseNormalizationBackprop_(x, y, dy, depthRadius = 5, bias = 1, alpha = 1, beta = 0.5) {
+ const forward = backend => backend.LRNGrad(dy, x, y, depthRadius, bias, alpha, beta);
+ const inputs = { x, y, dy };
+ const attrs = { depthRadius, bias, alpha, beta };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["M" /* LRNBackprop */], attrs);
+}
+const localResponseNormalizationBackprop = Object(operation["a" /* op */])({ localResponseNormalizationBackprop_ });
+//# sourceMappingURL=local_response_normalization_backprop.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/LRN_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const lrnGradConfig = {
+ kernelName: kernel_names["L" /* LRN */],
+ inputsToSave: ['x'],
+ outputsToSave: [true],
+ gradFunc: (dy, saved, attrs) => {
+ const [x, y] = saved;
+ const { depthRadius, bias, alpha, beta } = attrs;
+ return {
+ x: () => localResponseNormalizationBackprop(x, y, dy, depthRadius, bias, alpha, beta)
+ };
+ }
+};
+//# sourceMappingURL=LRN_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Max_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const maxGradConfig = {
+ kernelName: kernel_names["P" /* Max */],
+ inputsToSave: ['x'],
+ outputsToSave: [true],
+ gradFunc: (dy, saved, attrs) => {
+ const maxAttrs = attrs;
+ const { reductionIndices } = maxAttrs;
+ const [x, y] = saved;
+ const origAxes = util["parseAxisParam"](reductionIndices, x.shape);
+ const permutedAxes = getAxesPermutation(origAxes, x.rank);
+ const maxGrad = gradForMinAndMax(dy, y, x, origAxes, permutedAxes);
+ return {
+ x: () => {
+ let out = maxGrad['x']();
+ if (permutedAxes != null) {
+ out = transpose(out);
+ }
+ return out;
+ }
+ };
+ }
+};
+//# sourceMappingURL=Max_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/greater_equal.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Returns the truth value of (a >= b) element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ * const b = tf.tensor1d([2, 2, 2]);
+ *
+ * a.greaterEqual(b).print();
+ * ```
+ *
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same dtype as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function greaterEqual_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'greaterEqual');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'greaterEqual');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = (backend, save) => {
+ const res = backend.greaterEqual($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["I" /* GreaterEqual */]);
+}
+const greaterEqual = Object(operation["a" /* op */])({ greaterEqual_ });
+//# sourceMappingURL=greater_equal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/less.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Returns the truth value of (a < b) element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ * const b = tf.tensor1d([2, 2, 2]);
+ *
+ * a.less(b).print();
+ * ```
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same dtype as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function less_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'less');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'less');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = backend => backend.less($a, $b);
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["N" /* Less */]);
+}
+const less = Object(operation["a" /* op */])({ less_ });
+//# sourceMappingURL=less.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Maximum_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const maximumGradConfig = {
+ kernelName: kernel_names["V" /* Maximum */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const derA = () => mul(dy, cast(greaterEqual(a, b), 'float32'));
+ const derB = () => mul(dy, cast(less(a, b), 'float32'));
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=Maximum_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/max_pool_3d_backprop.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Computes the backprop of a 3d max pool.
+ *
+ * @param dy The dy error, of rank 5 of shape
+ * [batchSize, depth, height, width, channels].
+ * assumed.
+ * @param input The original input image, of rank 5 or rank 4 of shape
+ * [batchSize, depth, height, width, channels].
+ * @param output The original output image, of rank 5 of shape
+ * [batchSize, outDepth, outHeight, outWidth, channels].
+ * @param filterSize The filter size:
+ * `[filterDepth, filterHeight, filterWidth]`.
+ * `filterSize` is a single number,
+ * then `filterDepth == filterHeight == filterWidth`.
+ * @param strides The strides of the pooling:
+ * `[strideDepth, strideHeight, strideWidth]`. If
+ * `strides` is a single number, then `strideHeight == strideWidth`.
+ * @param dilations Deprecated, this field will be gone in v3.0.0.
+ * The dilation rates: `[dilationDepth, dilationHeight, dilationWidth]`
+ * in which we sample input values across the depth, height and width
+ * dimensions in dilated pooling.
+ * Defaults to `[1, 1, 1]`. If `dilations` is a single number,
+ * then `dilationDepth == dilationHeight == dilationWidth`.
+ * If it is greater than 1, then all values of `strides` must be 1.
+ * @param pad A string from: 'same', 'valid'. The type of padding algorithm
+ * used in the forward prop of the op.
+ * @param dimRoundingMode A string from: 'ceil', 'round', 'floor'. The
+ * rounding mode used when computing output dimensions if pad is a
+ * number. If none is provided, it will not round and error if the output
+ * is of fractional size.
+ */
+function maxPool3dBackprop_(dy, input, output, filterSize, strides, dilations = [1, 1, 1], pad, dimRoundingMode) {
+ const $dy = Object(tensor_util_env["a" /* convertToTensor */])(dy, 'dy', 'maxPool3dBackprop');
+ const $input = Object(tensor_util_env["a" /* convertToTensor */])(input, 'input', 'maxPool3dBackprop');
+ const $output = Object(tensor_util_env["a" /* convertToTensor */])(output, 'output', 'maxPool3dBackprop');
+ let dy5D = $dy;
+ let input5D = $input;
+ let output5D = $output;
+ let reshapedTo5D = false;
+ if ($input.rank === 4) {
+ reshapedTo5D = true;
+ dy5D = reshape($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
+ input5D = reshape($input, [
+ 1, $input.shape[0], $input.shape[1], $input.shape[2], $input.shape[3]
+ ]);
+ output5D = reshape($output, [
+ 1, $output.shape[0], $output.shape[1], $output.shape[2], $output.shape[3]
+ ]);
+ }
+ util["assert"](dy5D.rank === 5, () => `Error in maxPool3dBackprop: dy must be rank 5 but got rank ` +
+ `${dy5D.rank}.`);
+ util["assert"](input5D.rank === 5, () => `Error in maxPool3dBackprop: input must be rank 5 but got rank ` +
+ `${input5D.rank}.`);
+ util["assert"](output5D.rank === 5, () => `Error in maxPool3dBackprop: output must be rank 5 but got rank ` +
+ `${output5D.rank}.`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool3dBackprop: Either strides or dilations ' +
+ `must be 1. Got strides ${strides} and dilations '${dilations}'`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in maxPool3dBackprop: pad must be an integer when ` +
+ `using, dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = backend => {
+ const convInfo = computePool3DInfo(input5D.shape, filterSize, strides, dilations, pad, dimRoundingMode);
+ return backend.maxPool3dBackprop(dy5D, input5D, output5D, convInfo);
+ };
+ const inputs = { dy: dy5D, input: input5D, output: output5D };
+ const attrs = { filterSize, strides, dilations, pad, dimRoundingMode };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["S" /* MaxPool3DBackprop */], attrs);
+ if (reshapedTo5D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+ }
+ return res;
+}
+const maxPool3dBackprop = Object(operation["a" /* op */])({ maxPool3dBackprop_ });
+//# sourceMappingURL=max_pool_3d_backprop.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/MaxPool3D_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const maxPool3DGradConfig = {
+ kernelName: kernel_names["R" /* MaxPool3D */],
+ inputsToSave: ['x'],
+ outputsToSave: [true],
+ gradFunc: (dy, saved, attrs) => {
+ const [x, y] = saved;
+ const { filterSize, strides, dilations, pad, dimRoundingMode } = attrs;
+ const $dilations = dilations == null ? [1, 1, 1] : dilations;
+ return {
+ x: () => maxPool3dBackprop(dy, x, y, filterSize, strides, $dilations, pad, dimRoundingMode)
+ };
+ }
+};
+//# sourceMappingURL=MaxPool3D_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/max_pool_backprop.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Computes the backprop of a 2D max pool.
+ *
+ * @param dy The dy error, of rank 4 or rank 3 of shape
+ * [batchSize, height, width, channels]. If rank 3, batch of 1 is
+ * assumed.
+ * @param input The original input image, of rank 4, of shape
+ * [batchSize, height, width, channels].
+ * @param output The original output image, of rank 4, of shape
+ * [batchSize, outHeight, outWidth, channels].
+ * @param filterSize The filter size: `[filterHeight, filterWidth]`. If
+ * `filterSize` is a single number, then `filterHeight == filterWidth`.
+ * @param strides The strides of the pooling: `[strideHeight, strideWidth]`. If
+ * `strides` is a single number, then `strideHeight == strideWidth`.
+ * @param pad A string from: 'same', 'valid'. The type of padding algorithm
+ * used in the forward prop of the op.
+ * @param dimRoundingMode A string from: 'ceil', 'round', 'floor'. The
+ * rounding mode used when computing output dimensions if pad is a
+ * number. If none is provided, it will not round and error if the output
+ * is of fractional size.
+ */
+function maxPoolBackprop_(dy, input, output, filterSize, strides, pad, dimRoundingMode) {
+ const $dy = Object(tensor_util_env["a" /* convertToTensor */])(dy, 'dy', 'maxPoolBackprop');
+ const $input = Object(tensor_util_env["a" /* convertToTensor */])(input, 'input', 'maxPoolBackprop');
+ const $output = Object(tensor_util_env["a" /* convertToTensor */])(output, 'output', 'maxPoolBackprop');
+ util["assert"]($input.rank === $dy.rank, () => `Rank of input (${$input.rank}) does not match rank of dy ` +
+ `(${$dy.rank})`);
+ util["assert"]($dy.rank === 4, () => `Error in maxPoolBackprop: dy must be rank 4 but got rank ` +
+ `${$dy.rank}.`);
+ util["assert"]($input.rank === 4, () => `Error in maxPoolBackprop: input must be rank 4 but got rank ` +
+ `${$input.rank}.`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in maxPoolBackprop: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = backend => {
+ const convInfo = computePool2DInfo($input.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
+ return backend.maxPoolBackprop($dy, $input, $output, convInfo);
+ };
+ const inputs = { dy: $dy, input: $input, output: $output };
+ const attrs = { filterSize, strides, pad, dimRoundingMode };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null, kernel_names["T" /* MaxPoolBackprop */], attrs);
+}
+const maxPoolBackprop = Object(operation["a" /* op */])({ maxPoolBackprop_ });
+//# sourceMappingURL=max_pool_backprop.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/MaxPool_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const maxPoolGradConfig = {
+ kernelName: kernel_names["Q" /* MaxPool */],
+ inputsToSave: ['x'],
+ outputsToSave: [true],
+ gradFunc: (dy, saved, attrs) => {
+ const [x, y] = saved;
+ const { filterSize, strides, pad } = attrs;
+ return {
+ x: () => maxPoolBackprop(dy, x, y, filterSize, strides, pad)
+ };
+ }
+};
+//# sourceMappingURL=MaxPool_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/greater.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Returns the truth value of (a > b) element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ * const b = tf.tensor1d([2, 2, 2]);
+ *
+ * a.greater(b).print();
+ * ```
+ *
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same dtype as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function greater_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'greater');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'greater');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = backend => backend.greater($a, $b);
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["H" /* Greater */]);
+}
+const greater = Object(operation["a" /* op */])({ greater_ });
+//# sourceMappingURL=greater.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/less_equal.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Returns the truth value of (a <= b) element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ * const b = tf.tensor1d([2, 2, 2]);
+ *
+ * a.lessEqual(b).print();
+ * ```
+ *
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same dtype as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function lessEqual_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'lessEqual');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'lessEqual');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = (backend, save) => {
+ const res = backend.lessEqual($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["O" /* LessEqual */]);
+}
+const lessEqual = Object(operation["a" /* op */])({ lessEqual_ });
+//# sourceMappingURL=less_equal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Minimum_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const minimumGradConfig = {
+ kernelName: kernel_names["W" /* Minimum */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const derA = () => mul(dy, cast(lessEqual(a, b), 'float32'));
+ const derB = () => mul(dy, cast(greater(a, b), 'float32'));
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=Minimum_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Mod_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+const modGradConfig = {
+ kernelName: kernel_names["X" /* Mod */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
+ const derA = () => {
+ const reduceAxes = getReductionAxes(a.shape, outShape);
+ if (reduceAxes.length > 0) {
+ return reshape(sum(dy, reduceAxes), a.shape);
+ }
+ return dy;
+ };
+ const derB = () => {
+ const res = mul(dy, neg(floor(div(a, b))));
+ const reduceAxes = getReductionAxes(b.shape, outShape);
+ if (reduceAxes.length > 0) {
+ return reshape(sum(res, reduceAxes), b.shape);
+ }
+ return res;
+ };
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=Mod_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Multiply_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const multiplyGradConfig = {
+ kernelName: kernel_names["Y" /* Multiply */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
+ const derA = () => {
+ const res = mul(dy, cast(b, 'float32'));
+ const reduceAxes = getReductionAxes(a.shape, outShape);
+ if (reduceAxes.length > 0) {
+ return reshape(sum(res, reduceAxes), a.shape);
+ }
+ return res;
+ };
+ const derB = () => {
+ const res = mul(dy, cast(a, 'float32'));
+ const reduceAxes = getReductionAxes(b.shape, outShape);
+ if (reduceAxes.length > 0) {
+ return reshape(sum(res, reduceAxes), b.shape);
+ }
+ return res;
+ };
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=Multiply_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/OneHot_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const oneHotGradConfig = {
+ kernelName: kernel_names["cb" /* OneHot */],
+ inputsToSave: ['indices'],
+ gradFunc: (dy, saved) => {
+ const indices = saved[0];
+ return { indices: () => Object(tensor_ops["n" /* zeros */])(indices.shape, 'float32') };
+ }
+};
+//# sourceMappingURL=OneHot_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/PadV2_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+const padV2GradConfig = {
+ kernelName: kernel_names["db" /* PadV2 */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved, attrs) => {
+ // Pad introduces values around the original tensor, so the gradient
+ // slices the original shape out of the gradient.
+ const x = saved[0];
+ const { paddings } = attrs;
+ const begin = paddings.map(p => p[0]);
+ return { x: () => dy.slice(begin, x.shape) };
+ }
+};
+//# sourceMappingURL=PadV2_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/where_impl.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/** An implementation of the Where kernel shared between cpu and webgl */
+
+function whereImpl(condShape, condVals) {
+ const indices = [];
+ for (let i = 0; i < condVals.length; i++) {
+ if (condVals[i]) {
+ indices.push(i);
+ }
+ }
+ const inBuffer = array_ops_buffer(condShape, 'int32');
+ const out = array_ops_buffer([indices.length, condShape.length], 'int32');
+ for (let i = 0; i < indices.length; i++) {
+ const loc = inBuffer.indexToLoc(indices[i]);
+ const offset = i * condShape.length;
+ out.values.set(loc, offset);
+ }
+ return out.toTensor();
+}
+//# sourceMappingURL=where_impl.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/logical_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+/**
+ * Returns the truth value of `NOT x` element-wise.
+ *
+ * ```js
+ * const a = tf.tensor1d([false, true], 'bool');
+ *
+ * a.logicalNot().print();
+ * ```
+ *
+ * @param x The input tensor. Must be of dtype 'bool'.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function logicalNot_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'logicalNot', 'bool');
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.logicalNot($x), { $x });
+}
+/**
+ * Returns the truth value of `a AND b` element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([false, false, true, true], 'bool');
+ * const b = tf.tensor1d([false, true, false, true], 'bool');
+ *
+ * a.logicalAnd(b).print();
+ * ```
+ *
+ * @param a The first input tensor. Must be of dtype bool.
+ * @param b The second input tensor. Must be of dtype bool.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function logicalAnd_(a, b) {
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'logicalAnd', 'bool');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'logicalAnd', 'bool');
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.logicalAnd($a, $b), { a: $a, b: $b }, null /* grad */, 'LogicalAnd');
+}
+/**
+ * Returns the truth value of `a OR b` element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([false, false, true, true], 'bool');
+ * const b = tf.tensor1d([false, true, false, true], 'bool');
+ *
+ * a.logicalOr(b).print();
+ * ```
+ * @param a The first input tensor. Must be of dtype bool.
+ * @param b The second input tensor. Must be of dtype bool.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function logicalOr_(a, b) {
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'logicalOr', 'bool');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'logicalOr', 'bool');
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.logicalOr($a, $b), { $a, $b });
+}
+/**
+ * Returns the truth value of `a XOR b` element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([false, false, true, true], 'bool');
+ * const b = tf.tensor1d([false, true, false, true], 'bool');
+ *
+ * a.logicalXor(b).print();
+ * ```
+ *
+ * @param a The first input tensor. Must be of dtype bool.
+ * @param b The second input tensor. Must be of dtype bool.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function logicalXor_(a, b) {
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'logicalXor', 'bool');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'logicalXor', 'bool');
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ // x ^ y = (x | y) & ~(x & y)
+ return logicalOr(a, b).logicalAnd(logicalAnd(a, b).logicalNot());
+}
+/**
+ * Returns the elements, either `a` or `b` depending on the `condition`.
+ *
+ * If the condition is true, select from `a`, otherwise select from `b`.
+ *
+ * ```js
+ * const cond = tf.tensor1d([false, false, true], 'bool');
+ * const a = tf.tensor1d([1 , 2, 3]);
+ * const b = tf.tensor1d([-1, -2, -3]);
+ *
+ * a.where(cond, b).print();
+ * ```
+ *
+ * @param condition The input condition. Must be of dtype bool.
+ * @param a If `condition` is rank 1, `a` may have a higher rank but
+ * its first dimension must match the size of `condition`.
+ * @param b A tensor with the same shape and type as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function where_(condition, a, b) {
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'where');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'where');
+ const $condition = Object(tensor_util_env["a" /* convertToTensor */])(condition, 'condition', 'where', 'bool');
+ Object(util["assertShapesMatch"])($a.shape, $b.shape, 'Error in where: ');
+ if ($condition.rank === 1) {
+ // If condition rank is 1, then the first dimension must match the size of
+ // condition.
+ Object(util["assert"])($condition.shape[0] === $a.shape[0], () => 'The first dimension of `a` must match the size of `condition`.');
+ }
+ else {
+ // A must have the same shape as condition.
+ Object(util["assertShapesMatch"])($condition.shape, $b.shape, 'Error in where: ');
+ }
+ // TODO(julianoks): Return null for condition gradient
+ // when backprop supports it.
+ const grad = (dy, saved) => {
+ const [$condition] = saved;
+ return {
+ condition: () => Object(tensor_ops["o" /* zerosLike */])($condition).toFloat(),
+ t: () => dy.mul($condition.cast(dy.dtype)),
+ e: () => dy.mul($condition.logicalNot().cast(dy.dtype))
+ };
+ };
+ const inputs = { condition: $condition, t: $a, e: $b };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.select($condition, $a, $b);
+ save([$condition]);
+ return res;
+ }, inputs, grad, kernel_names["kb" /* SelectV2 */]);
+}
+/**
+ * Returns the coordinates of true elements of condition.
+ *
+ * The coordinates are returned in a 2-D tensor where the first dimension (rows)
+ * represents the number of true elements, and the second dimension (columns)
+ * represents the coordinates of the true elements. Keep in mind, the shape of
+ * the output tensor can vary depending on how many true values there are in
+ * input. Indices are output in row-major order. The resulting tensor has the
+ * shape `[numTrueElems, condition.rank]`.
+ *
+ * This is analogous to calling the python `tf.where(cond)` without an x or y.
+ *
+ * ```js
+ * const cond = tf.tensor1d([false, false, true], 'bool');
+ * const result = await tf.whereAsync(cond);
+ * result.print();
+ * ```
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+async function whereAsync_(condition) {
+ const $condition = Object(tensor_util_env["a" /* convertToTensor */])(condition, 'condition', 'whereAsync', 'bool');
+ const vals = await $condition.data();
+ const res = whereImpl($condition.shape, vals);
+ if (condition !== $condition) {
+ $condition.dispose();
+ }
+ return res;
+}
+const logicalAnd = Object(operation["a" /* op */])({ logicalAnd_ });
+const logicalNot = Object(operation["a" /* op */])({ logicalNot_ });
+const logicalOr = Object(operation["a" /* op */])({ logicalOr_ });
+const logicalXor = Object(operation["a" /* op */])({ logicalXor_ });
+const where = Object(operation["a" /* op */])({ where_ });
+const whereAsync = whereAsync_;
+//# sourceMappingURL=logical_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/pow.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Computes the power of one `tf.Tensor` to another. Supports broadcasting.
+ *
+ * Given a `tf.Tensor` x and a `tf.Tensor` y, this operation computes x^y for
+ * corresponding elements in x and y. The result's dtype will be the upcasted
+ * type of the `base` and `exp` dtypes.
+ *
+ * ```js
+ * const a = tf.tensor([[2, 3], [4, 5]])
+ * const b = tf.tensor([[1, 2], [3, 0]]).toInt();
+ *
+ * a.pow(b).print(); // or tf.pow(a, b)
+ * ```
+ *
+ * ```js
+ * const a = tf.tensor([[1, 2], [3, 4]])
+ * const b = tf.tensor(2).toInt();
+ *
+ * a.pow(b).print(); // or tf.pow(a, b)
+ * ```
+ * We also expose `powStrict` which has the same signature as this op and
+ * asserts that `base` and `exp` are the same shape (does not broadcast).
+ *
+ * @param base The base `tf.Tensor` to pow element-wise.
+ * @param exp The exponent `tf.Tensor` to pow element-wise.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function pow_(base, exp) {
+ let $base = Object(tensor_util_env["a" /* convertToTensor */])(base, 'base', 'pow');
+ let $exp = Object(tensor_util_env["a" /* convertToTensor */])(exp, 'exp', 'pow');
+ [$base, $exp] = Object(tensor_util["makeTypesMatch"])($base, $exp);
+ const inputs = { a: $base, b: $exp };
+ const forward = (backend, save) => {
+ const y = backend.pow($base, $exp);
+ save([$base, $exp, y]);
+ return y;
+ };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["fb" /* Pow */]);
+}
+const pow = Object(operation["a" /* op */])({ pow_ });
+//# sourceMappingURL=pow.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Pow_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+
+
+const powGradConfig = {
+ kernelName: kernel_names["fb" /* Pow */],
+ inputsToSave: ['a', 'b'],
+ outputsToSave: [true],
+ gradFunc: (dy, saved) => {
+ const [a, b, y] = saved;
+ const base = a;
+ const exp = b;
+ const outShape = assertAndGetBroadcastShape(base.shape, exp.shape);
+ const derBase = () => {
+ const expFloat = cast(exp, 'float32');
+ let res = mul(dy, mul(expFloat, pow(base, sub(expFloat, Object(tensor_ops["e" /* scalar */])(1)))));
+ const reduceAxes = getReductionAxes(base.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = sum(res, reduceAxes);
+ }
+ return reshape(res, base.shape);
+ };
+ const derExp = () => {
+ const condition = greater(base, 0);
+ const logBase = where(condition, log(base), Object(tensor_ops["o" /* zerosLike */])(base));
+ let res = mul(dy, mul(y, logBase));
+ const reduceAxes = getReductionAxes(exp.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = sum(res, reduceAxes);
+ }
+ return reshape(res, exp.shape);
+ };
+ return { a: derBase, b: derExp };
+ }
+};
+//# sourceMappingURL=Pow_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Prelu_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+const preluGradConfig = {
+ kernelName: kernel_names["gb" /* Prelu */],
+ inputsToSave: ['x', 'alpha'],
+ gradFunc: (dy, saved) => {
+ const [x, alpha] = saved;
+ const mask = greater(x, 0);
+ return {
+ x: () => where(mask, dy, mul(dy, alpha)),
+ alpha: () => {
+ let res = where(mask, Object(tensor_ops["o" /* zerosLike */])(dy), mul(dy, x));
+ const reduceAxes = getReductionAxes(alpha.shape, dy.shape);
+ if (reduceAxes.length > 0) {
+ res = sum(res, reduceAxes);
+ }
+ return reshape(res, alpha.shape);
+ }
+ };
+ }
+};
+//# sourceMappingURL=Prelu_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Relu6_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const relu6GradConfig = {
+ kernelName: kernel_names["jb" /* Relu6 */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved) => {
+ const [x] = saved;
+ const mask = mul(lessEqual(x, 6), unary_ops_step(x));
+ return { x: () => mul(dy, cast(mask, 'float32')) };
+ }
+};
+//# sourceMappingURL=Relu6_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Relu_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+const reluGradConfig = {
+ kernelName: kernel_names["ib" /* Relu */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved) => {
+ const [x] = saved;
+ return { x: () => mul(dy, cast(unary_ops_step(x), 'float32')) };
+ }
+};
+//# sourceMappingURL=Relu_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/selu_util.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const SELU_SCALEALPHA = 1.7580993408473768599402175208123;
+const SELU_SCALE = 1.0507009873554804934193349852946;
+//# sourceMappingURL=selu_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Selu_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+const seluGradConfig = {
+ kernelName: kernel_names["lb" /* Selu */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved) => {
+ const [x] = saved;
+ return {
+ x: () => {
+ const mask = greater(x, Object(tensor_ops["e" /* scalar */])(0));
+ const scaleAlpha = Object(tensor_ops["e" /* scalar */])(SELU_SCALEALPHA);
+ const scale = Object(tensor_ops["e" /* scalar */])(SELU_SCALE);
+ const greaterThanZeroDer = mul(dy, scale);
+ const lessEqualZeroDer = mul(mul(dy, scaleAlpha), unary_ops_exp(cast(x, 'float32')));
+ return where(mask, greaterThanZeroDer, lessEqualZeroDer);
+ }
+ };
+ }
+};
+//# sourceMappingURL=Selu_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/batch_to_space_nd.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of
+ * shape `blockShape + [batch]`, interleaves these blocks back into the grid
+ * defined by the spatial dimensions `[1, ..., M]`, to obtain a result with
+ * the same rank as the input. The spatial dimensions of this intermediate
+ * result are then optionally cropped according to `crops` to produce the
+ * output. This is the reverse of `tf.spaceToBatchND`. See below for a precise
+ * description.
+ *
+ * ```js
+ * const x = tf.tensor4d([1, 2, 3, 4], [4, 1, 1, 1]);
+ * const blockShape = [2, 2];
+ * const crops = [[0, 0], [0, 0]];
+ *
+ * x.batchToSpaceND(blockShape, crops).print();
+ * ```
+ *
+ * @param x A `tf.Tensor`. N-D with `x.shape` = `[batch] + spatialShape +
+ * remainingShape`, where spatialShape has `M` dimensions.
+ * @param blockShape A 1-D array. Must have shape `[M]`, all values must
+ * be >= 1.
+ * @param crops A 2-D array. Must have shape `[M, 2]`, all values must be >= 0.
+ * `crops[i] = [cropStart, cropEnd]` specifies the amount to crop from input
+ * dimension `i + 1`, which corresponds to spatial dimension `i`. It is required
+ * that `cropStart[i] + cropEnd[i] <= blockShape[i] * inputShape[i + 1]`
+ *
+ * This operation is equivalent to the following steps:
+ *
+ * 1. Reshape `x` to `reshaped` of shape: `[blockShape[0], ...,
+ * blockShape[M-1], batch / prod(blockShape), x.shape[1], ...,
+ * x.shape[N-1]]`
+ *
+ * 2. Permute dimensions of `reshaped`to produce `permuted` of shape `[batch /
+ * prod(blockShape),x.shape[1], blockShape[0], ..., x.shape[M],
+ * blockShape[M-1],x.shape[M+1], ..., x.shape[N-1]]`
+ *
+ * 3. Reshape `permuted` to produce `reshapedPermuted` of shape `[batch /
+ * prod(blockShape),x.shape[1] * blockShape[0], ..., x.shape[M] *
+ * blockShape[M-1],x.shape[M+1], ..., x.shape[N-1]]`
+ *
+ * 4. Crop the start and end of dimensions `[1, ..., M]` of `reshapedPermuted`
+ * according to `crops` to produce the output of shape: `[batch /
+ * prod(blockShape),x.shape[1] * blockShape[0] - crops[0,0] - crops[0,1],
+ * ..., x.shape[M] * blockShape[M-1] - crops[M-1,0] -
+ * crops[M-1,1],x.shape[M+1], ..., x.shape[N-1]]`
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function batchToSpaceND_(x, blockShape, crops) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'batchToSpaceND');
+ const prod = blockShape.reduce((a, b) => a * b);
+ util["assert"]($x.rank >= 1 + blockShape.length, () => `input rank is ${$x.rank} but should be > than blockShape.length ${blockShape.length}`);
+ util["assert"](crops.length === blockShape.length, () => `crops.length is ${crops.length} but should be equal to blockShape.length ${blockShape.length}`);
+ util["assert"]($x.shape[0] % prod === 0, () => `input tensor batch is ${$x.shape[0]} but is not divisible by the product of ` +
+ `the elements of blockShape ${blockShape.join(' * ')} === ${prod}`);
+ const forward = backend => {
+ return backend.batchToSpaceND($x, blockShape, crops);
+ };
+ const inputs = { x: $x };
+ const attrs = { blockShape, crops };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["i" /* BatchToSpaceND */], attrs);
+}
+const batchToSpaceND = Object(operation["a" /* op */])({ batchToSpaceND_ });
+//# sourceMappingURL=batch_to_space_nd.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/SpaceToBatchND_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const spaceToBatchNDGradConfig = {
+ kernelName: kernel_names["mb" /* SpaceToBatchND */],
+ gradFunc: (dy, saved, attrs) => {
+ const { blockShape, paddings } = attrs;
+ return { x: () => batchToSpaceND(dy, blockShape, paddings) };
+ }
+};
+//# sourceMappingURL=SpaceToBatchND_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/SplitV_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const splitVGradConfig = {
+ kernelName: kernel_names["nb" /* SplitV */],
+ gradFunc: (dy, saved, attrs) => {
+ const { axis } = attrs;
+ return { x: () => concat(dy, axis) };
+ }
+};
+//# sourceMappingURL=SplitV_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Square_grad.js
+/**
+ * @license
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const squareGradConfig = {
+ kernelName: kernel_names["ob" /* Square */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved) => {
+ const [x] = saved;
+ return { x: () => mul(dy, mul(x.toFloat(), 2)) };
+ }
+};
+//# sourceMappingURL=Square_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/SquaredDifference_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+const squaredDifferenceGradConfig = {
+ kernelName: kernel_names["pb" /* SquaredDifference */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const two = Object(tensor_ops["e" /* scalar */])(2);
+ const derA = () => mul(dy, mul(two, sub(a, b)));
+ const derB = () => mul(dy, mul(two, sub(b, a)));
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=SquaredDifference_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Sub_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const subGradConfig = {
+ kernelName: kernel_names["qb" /* Sub */],
+ inputsToSave: ['a', 'b'],
+ gradFunc: (dy, saved) => {
+ const [a, b] = saved;
+ const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
+ const derA = () => {
+ let res = dy;
+ const reduceAxes = getReductionAxes(a.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = sum(res, reduceAxes);
+ }
+ return reshape(res, a.shape);
+ };
+ const derB = () => {
+ let res = dy;
+ const reduceAxes = getReductionAxes(b.shape, outShape);
+ if (reduceAxes.length > 0) {
+ res = sum(res, reduceAxes);
+ }
+ return reshape(neg(res), b.shape);
+ };
+ return { a: derA, b: derB };
+ }
+};
+//# sourceMappingURL=Sub_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/pad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Pads a `tf.Tensor` with a given value and paddings.
+ *
+ * This operation currently only implements the `CONSTANT` mode.
+ *
+ * Also available are stricter rank-specific methods with the same signature
+ * as this method that assert that `paddings` is of given length.
+ * - `tf.pad1d`
+ * - `tf.pad2d`
+ * - `tf.pad3d`
+ * - `tf.pad4d`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ * x.pad([[1, 2]]).print();
+ * ```
+ * @param x The tensor to pad.
+ * @param paddings An array of length `R` (the rank of the tensor), where
+ * each element is a length-2 tuple of ints `[padBefore, padAfter]`,
+ * specifying how much to pad along each dimension of the tensor.
+ * @param constantValue The pad value to use. Defaults to 0.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function pad_(x, paddings, constantValue = 0) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'pad');
+ if ($x.rank === 0) {
+ throw new Error('pad(scalar) is not defined. Pass non-scalar to pad');
+ }
+ const forward = (backend, save) => {
+ save([$x]);
+ return backend.pad($x, paddings, constantValue);
+ };
+ const attrs = { paddings, constantValue };
+ const inputs = { x: $x };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["db" /* PadV2 */], attrs);
+}
+const pad_pad = Object(operation["a" /* op */])({ pad_ });
+//# sourceMappingURL=pad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/slice_util.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function assertParamsValid(input, begin, size) {
+ util["assert"](input.rank === begin.length, () => `Error in slice${input.rank}D: Length of begin ${begin} must ` +
+ `match the rank of the array (${input.rank}).`);
+ util["assert"](input.rank === size.length, () => `Error in slice${input.rank}D: Length of size ${size} must ` +
+ `match the rank of the array (${input.rank}).`);
+ for (let i = 0; i < input.rank; ++i) {
+ util["assert"](begin[i] + size[i] <= input.shape[i], () => `Error in slice${input.rank}D: begin[${i}] + size[${i}] ` +
+ `(${begin[i] + size[i]}) would overflow input.shape[${i}] (${input.shape[i]})`);
+ }
+}
+/** Converts a binary mask to an array of axes. Used in stridedSlice(). */
+function maskToAxes(mask) {
+ const axes = [];
+ let axis = 0;
+ while (mask > 0) {
+ if (mask & 1) {
+ axes.push(axis);
+ }
+ mask /= 2;
+ axis++;
+ }
+ return axes;
+}
+/** Computes the output shape given the strided slice params. */
+function slice_util_computeOutShape(begin, end, strides) {
+ const size = [];
+ for (let axis = 0; axis < begin.length; axis++) {
+ size[axis] = Math.ceil((end[axis] - begin[axis]) / strides[axis]);
+ }
+ return size;
+}
+// Creates full selection at the elided dimensions. If the dimension matches
+// the ellipsis mask, override the current stride value. Otherwise, insert.
+function stridesWithElidedDims(strides, ellipsisInsertionIndex, numElidedAxes) {
+ const newStrides = [...strides];
+ for (let i = 0; i < numElidedAxes; i++) {
+ if (i === 0) {
+ newStrides[ellipsisInsertionIndex] = 1;
+ }
+ else {
+ newStrides.splice(ellipsisInsertionIndex, 0 /* num elements to delete */, 1 /* element to add */);
+ newStrides.pop();
+ }
+ }
+ return newStrides;
+}
+// Creates full selection at the elided dimensions. If the dimension matches
+// the ellipsis mask, override the current start value. Otherwise, insert.
+function startIndicesWithElidedDims(startIndices, ellipsisInsertionIndex, numElidedAxes) {
+ const newIndices = [...startIndices];
+ for (let i = 0; i < numElidedAxes; i++) {
+ if (i === 0) {
+ newIndices[ellipsisInsertionIndex] = 0;
+ }
+ else {
+ newIndices.splice(ellipsisInsertionIndex, 0 /* num elements to delete */, 0 /* element to add */);
+ newIndices.pop();
+ }
+ }
+ return newIndices;
+}
+// Creates full selection at the elided dimensions. If the dimension matches
+// the ellipsis mask, override the current stop value. Otherwise, insert.
+function stopIndicesWithElidedDims(stopIndices, ellipsisInsertionIndex, numElidedAxes, inputShape) {
+ const newIndices = [...stopIndices];
+ for (let i = 0; i < numElidedAxes; i++) {
+ if (i === 0) {
+ newIndices[ellipsisInsertionIndex] = Number.MAX_SAFE_INTEGER;
+ }
+ else {
+ newIndices.splice(ellipsisInsertionIndex, 0 /* num elements to delete */, Number.MAX_SAFE_INTEGER /* element to add */);
+ newIndices.pop();
+ }
+ }
+ for (let i = 0; i < newIndices.length; i++) {
+ newIndices[i] = util["clamp"](0, newIndices[i], inputShape[i]);
+ }
+ return newIndices;
+}
+function stridesForAxis(strides, axis, ellipsisMask) {
+ let stride = strides[axis];
+ if (ellipsisMask & (1 << axis) || stride == null) {
+ stride = 1;
+ }
+ return stride;
+}
+function startForAxis(beginMask, startIndices, strides, inputShape, axis, ellipsisMask) {
+ // Begin with the specified index
+ let start = startIndices[axis];
+ const stride = strides[axis] || 1;
+ // Check the axis bit from right of masked axes, or the begin index is not set
+ // for the axis.
+ if (beginMask & 1 << axis || ellipsisMask & 1 << axis || start == null) {
+ if (stride > 0) {
+ // Forward iteration - use the first element. These values will get
+ // clamped below (Note: We could have set them to 0 and axis_size-1, but
+ // use lowest() and max() to maintain symmetry with StopForAxis())
+ start = Number.MIN_SAFE_INTEGER;
+ }
+ else {
+ // Backward iteration - use the last element.
+ start = Number.MAX_SAFE_INTEGER;
+ }
+ }
+ // Handle negative indices
+ const axisSize = inputShape[axis];
+ if (start < 0) {
+ start += axisSize;
+ }
+ // Clamping
+ start = util["clamp"](0, start, axisSize - 1);
+ return start;
+}
+function stopForAxis(endMask, stopIndices, strides, inputShape, axis, ellipsisMask) {
+ // Begin with the specified index
+ let stop = stopIndices[axis];
+ const stride = strides[axis] || 1;
+ // Check the axis bit from right of masked axes, or if the stop index is not
+ // set for this axis.
+ if (endMask & (1 << axis) || ellipsisMask & (1 << axis) || stop == null) {
+ if (stride > 0) {
+ // Forward iteration - use the last element. These values will get
+ // clamped below
+ stop = Number.MAX_SAFE_INTEGER;
+ }
+ else {
+ // Backward iteration - use the first element.
+ stop = Number.MIN_SAFE_INTEGER;
+ }
+ }
+ // Handle negative indices
+ const axisSize = inputShape[axis];
+ if (stop < 0) {
+ stop += axisSize;
+ }
+ // Clamping
+ // Because the end index points one past the last element, we need slightly
+ // different clamping ranges depending on the direction.
+ if (stride > 0) {
+ // Forward iteration
+ stop = util["clamp"](0, stop, axisSize);
+ }
+ else {
+ // Backward iteration
+ stop = util["clamp"](-1, stop, axisSize - 1);
+ }
+ return stop;
+}
+/**
+ * Returns true if the slice occupies a continous set of elements in the
+ * 'flat' space.
+ */
+function isSliceContinous(shape, begin, size) {
+ // Index of the first axis that has size > 1.
+ let firstNonOneAxis = size.length;
+ for (let i = 0; i < size.length; i++) {
+ if (size[i] > 1) {
+ firstNonOneAxis = i;
+ break;
+ }
+ }
+ for (let i = firstNonOneAxis + 1; i < size.length; i++) {
+ if (begin[i] > 0 || size[i] !== shape[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+function computeFlatOffset(begin, strides) {
+ let flatOffset = begin.length > 0 ? begin[begin.length - 1] : 1;
+ for (let i = 0; i < begin.length - 1; i++) {
+ flatOffset += begin[i] * strides[i];
+ }
+ return flatOffset;
+}
+//# sourceMappingURL=slice_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/slice.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Extracts a 1D slice from 1D array starting at coordinates `begin` and is
+ * of length `size`. See `slice` for details.
+ */
+function slice1d_(x, begin, size) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'slice1d');
+ util["assert"]($x.rank === 1, () => `slice1d expects a rank-1 tensor, but got a rank-${$x.rank} tensor`);
+ return slice($x, [begin], [size]);
+}
+/**
+ * Extracts a 2D slice from a 2D array starting at coordinates `begin` and
+ * is of size `size`. See `slice` for details.
+ */
+function slice2d_(x, begin, size) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'slice2d');
+ util["assert"]($x.rank === 2, () => `slice2d expects a rank-2 tensor, but got a rank-${$x.rank} tensor`);
+ return slice($x, begin, size);
+}
+/**
+ * Extracts a 3D slice from a 3D array starting at coordinates `begin` and
+ * is of size `size`. See `slice` for details.
+ */
+function slice3d_(x, begin, size) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'slice3d');
+ util["assert"]($x.rank === 3, () => `slice3d expects a rank-3 tensor, but got a rank-${$x.rank} tensor`);
+ return slice($x, begin, size);
+}
+/**
+ * Extracts a 4D slice from a 4D array starting at coordinates `begin` and
+ * is of size `size`. See `slice` for details.
+ */
+function slice4d_(x, begin, size) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'slice4d');
+ util["assert"]($x.rank === 4, () => `slice4d expects a rank-4 tensor, but got a rank-${$x.rank} tensor`);
+ return slice($x, begin, size);
+}
+/**
+ * Extracts a slice from a `tf.Tensor` starting at coordinates `begin`
+ * and is of size `size`.
+ *
+ * Also available are stricter rank-specific methods with the same signature
+ * as this method that assert that `x` is of the given rank:
+ * - `tf.slice1d`
+ * - `tf.slice2d`
+ * - `tf.slice3d`
+ * - `tf.slice4d`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ *
+ * x.slice([1], [2]).print();
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * x.slice([1, 0], [1, 2]).print();
+ * ```
+ * @param x The input `tf.Tensor` to slice from.
+ * @param begin The coordinates to start the slice from. The length can be
+ * less than the rank of x - the rest of the axes will have implicit 0 as
+ * start. Can also be a single number, in which case it specifies the
+ * first axis.
+ * @param size The size of the slice. The length can be less than the rank of
+ * x - the rest of the axes will have implicit -1. A value of -1 requests
+ * the rest of the dimensions in the axis. Can also be a single number,
+ * in which case it specifies the size of the first axis.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+function slice_(x, begin, size) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'slice');
+ if ($x.rank === 0) {
+ throw new Error('Slicing scalar is not possible');
+ }
+ // The following logic allows for more ergonomic calls.
+ let begin_;
+ if (typeof begin === 'number') {
+ begin_ = [begin, ...new Array($x.rank - 1).fill(0)];
+ }
+ else if (begin.length < $x.rank) {
+ begin_ = begin.concat(new Array($x.rank - begin.length).fill(0));
+ }
+ else {
+ begin_ = begin.slice();
+ }
+ begin_.forEach(d => {
+ util["assert"](d !== -1, () => 'slice() does not support negative begin indexing.');
+ });
+ let size_;
+ if (size == null) {
+ size_ = new Array($x.rank).fill(-1);
+ }
+ else if (typeof size === 'number') {
+ size_ = [size, ...new Array($x.rank - 1).fill(-1)];
+ }
+ else if (size.length < $x.rank) {
+ size_ = size.concat(new Array($x.rank - size.length).fill(-1));
+ }
+ else {
+ size_ = size;
+ }
+ size_ = size_.map((d, i) => {
+ if (d >= 0) {
+ return d;
+ }
+ else {
+ util["assert"](d === -1, () => `Negative size values should be exactly -1 but got ` +
+ `${d} for the slice() size at index ${i}.`);
+ return $x.shape[i] - begin_[i];
+ }
+ });
+ assertParamsValid($x, begin_, size_);
+ const inputShape = $x.shape;
+ const grad = (dy) => {
+ // Create an Nx2 padding where the first column represents how many
+ // zeros are prepended (at start) for each dimension, and the second
+ // column indicates how many zeros are appended (at end).
+ // The number of zeros to append is the shape of the input
+ // elementwise-subtracted by both the begin vector and sizes vector.
+ const paddings = [];
+ for (let i = 0; i < dy.rank; i++) {
+ paddings.push([begin_[i], inputShape[i] - begin_[i] - size_[i]]);
+ }
+ return { x: () => pad_pad(dy, paddings) };
+ };
+ const attrs = { begin: begin_, size: size_ };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.slice($x, begin_, size_), { x: $x }, grad, 'Slice', attrs);
+}
+const slice = Object(operation["a" /* op */])({ slice_ });
+const slice1d = Object(operation["a" /* op */])({ slice1d_ });
+const slice2d = Object(operation["a" /* op */])({ slice2d_ });
+const slice3d = Object(operation["a" /* op */])({ slice3d_ });
+const slice4d = Object(operation["a" /* op */])({ slice4d_ });
+//# sourceMappingURL=slice.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Tile_grad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+const tileGradConfig = {
+ kernelName: kernel_names["rb" /* Tile */],
+ inputsToSave: ['x'],
+ gradFunc: (dy, saved, attrs) => {
+ const [x] = saved;
+ const { reps } = attrs;
+ const derX = () => {
+ let xGrad = Object(tensor_ops["o" /* zerosLike */])(x);
+ // TODO(cais): Maybe reduce memory footprint by avoiding repeated
+ // slicing.
+ if (x.rank === 1) {
+ for (let i = 0; i < reps[0]; ++i) {
+ xGrad = add(xGrad, slice(dy, [i * x.shape[0]], [x.shape[0]]));
+ }
+ }
+ else if (x.rank === 2) {
+ for (let i = 0; i < reps[0]; ++i) {
+ for (let j = 0; j < reps[1]; ++j) {
+ xGrad = add(xGrad, slice(dy, [i * x.shape[0], j * x.shape[1]], [
+ x.shape[0], x.shape[1]
+ ]));
+ }
+ }
+ }
+ else if (x.rank === 3) {
+ for (let i = 0; i < reps[0]; ++i) {
+ for (let j = 0; j < reps[1]; ++j) {
+ for (let k = 0; k < reps[2]; ++k) {
+ xGrad =
+ add(xGrad, slice(dy, [i * x.shape[0], j * x.shape[1], k * x.shape[2]], [x.shape[0], x.shape[1], x.shape[2]]));
+ }
+ }
+ }
+ }
+ else if (x.rank === 4) {
+ for (let i = 0; i < reps[0]; ++i) {
+ for (let j = 0; j < reps[1]; ++j) {
+ for (let k = 0; k < reps[2]; ++k) {
+ for (let l = 0; l < reps[3]; ++l) {
+ xGrad =
+ add(xGrad, slice(dy, [
+ i * x.shape[0], j * x.shape[1], k * x.shape[2],
+ l * x.shape[3]
+ ], [x.shape[0], x.shape[1], x.shape[2], x.shape[3]]));
+ }
+ }
+ }
+ }
+ }
+ else {
+ throw new Error(`Gradient for tile operation is not implemented for rank-` +
+ `${x.rank} tensors yet.`);
+ }
+ return xGrad;
+ };
+ return { x: derX };
+ },
+};
+//# sourceMappingURL=Tile_grad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/gradients/Transpose_grad.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+const transposeGradConfig = {
+ kernelName: kernel_names["sb" /* Transpose */],
+ gradFunc: (dy, saved, attrs) => {
+ const transposeAttrs = attrs;
+ const { perm } = transposeAttrs;
+ const undoPerm = getUndoAxesPermutation(perm);
+ return { x: () => transpose(dy, undoPerm) };
+ }
+};
+//# sourceMappingURL=Transpose_grad.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/kernel_registry.js
+var kernel_registry = __webpack_require__(17);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/register_all_gradients.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Export all kernel configs here so that the package can auto register them
+const gradConfigs = [
+ addGradConfig,
+ addNGradConfig,
+ atan2GradConfig,
+ avgPoolGradConfig,
+ avgPool3DGradConfig,
+ batchMatMulGradConfig,
+ batchToSpaceNDGradConfig,
+ broadcastToGradConfig,
+ concatGradConfig,
+ conv2DGradConfig,
+ conv2DBackpropInputGradConfig,
+ conv3DGradConfig,
+ cumsumGradConfig,
+ depthwiseConv2dNativeGradConfig,
+ divGradConfig,
+ eluGradConfig,
+ floorDivGradConfig,
+ fusedBatchNormGradConfig,
+ greaterEqualGradConfig,
+ identityGradConfig,
+ lrnGradConfig,
+ oneHotGradConfig,
+ padV2GradConfig,
+ splitVGradConfig,
+ maxGradConfig,
+ spaceToBatchNDGradConfig,
+ maxGradConfig,
+ maximumGradConfig,
+ maxPoolGradConfig,
+ maxPool3DGradConfig,
+ minimumGradConfig,
+ modGradConfig,
+ multiplyGradConfig,
+ oneHotGradConfig,
+ padV2GradConfig,
+ powGradConfig,
+ preluGradConfig,
+ reluGradConfig,
+ relu6GradConfig,
+ seluGradConfig,
+ spaceToBatchNDGradConfig,
+ splitVGradConfig,
+ squareGradConfig,
+ squaredDifferenceGradConfig,
+ tileGradConfig,
+ transposeGradConfig,
+ subGradConfig
+];
+for (const gradientConfig of gradConfigs) {
+ Object(kernel_registry["d" /* registerGradient */])(gradientConfig);
+}
+//# sourceMappingURL=register_all_gradients.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/environment.js
+var environment = __webpack_require__(10);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/platforms/platform_browser.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+class PlatformBrowser {
+ fetch(path, init) {
+ return fetch(path, init);
+ }
+ now() {
+ return performance.now();
+ }
+ encode(text, encoding) {
+ if (encoding !== 'utf-8' && encoding !== 'utf8') {
+ throw new Error(`Browser's encoder only supports utf-8, but got ${encoding}`);
+ }
+ if (this.textEncoder == null) {
+ this.textEncoder = new TextEncoder();
+ }
+ return this.textEncoder.encode(text);
+ }
+ decode(bytes, encoding) {
+ return new TextDecoder(encoding).decode(bytes);
+ }
+}
+if (Object(environment["c" /* env */])().get('IS_BROWSER')) {
+ Object(environment["c" /* env */])().setPlatform('browser', new PlatformBrowser());
+}
+//# sourceMappingURL=platform_browser.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/platforms/platform_node.js
+var platform_node = __webpack_require__(62);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/io/io_utils.js
+var io_utils = __webpack_require__(13);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/io/router_registry.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class IORouterRegistry {
+ constructor() {
+ this.saveRouters = [];
+ this.loadRouters = [];
+ }
+ static getInstance() {
+ if (IORouterRegistry.instance == null) {
+ IORouterRegistry.instance = new IORouterRegistry();
+ }
+ return IORouterRegistry.instance;
+ }
+ /**
+ * Register a save-handler router.
+ *
+ * @param saveRouter A function that maps a URL-like string onto an instance
+ * of `IOHandler` with the `save` method defined or `null`.
+ */
+ static registerSaveRouter(saveRouter) {
+ IORouterRegistry.getInstance().saveRouters.push(saveRouter);
+ }
+ /**
+ * Register a load-handler router.
+ *
+ * @param loadRouter A function that maps a URL-like string onto an instance
+ * of `IOHandler` with the `load` method defined or `null`.
+ */
+ static registerLoadRouter(loadRouter) {
+ IORouterRegistry.getInstance().loadRouters.push(loadRouter);
+ }
+ /**
+ * Look up IOHandler for saving, given a URL-like string.
+ *
+ * @param url
+ * @returns If only one match is found, an instance of IOHandler with the
+ * `save` method defined. If no match is found, `null`.
+ * @throws Error, if more than one match is found.
+ */
+ static getSaveHandlers(url) {
+ return IORouterRegistry.getHandlers(url, 'save');
+ }
+ /**
+ * Look up IOHandler for loading, given a URL-like string.
+ *
+ * @param url
+ * @param loadOptions Optional, custom load options.
+ * @returns All valid handlers for `url`, given the currently registered
+ * handler routers.
+ */
+ static getLoadHandlers(url, loadOptions) {
+ return IORouterRegistry.getHandlers(url, 'load', loadOptions);
+ }
+ static getHandlers(url, handlerType, loadOptions) {
+ const validHandlers = [];
+ const routers = handlerType === 'load' ?
+ IORouterRegistry.getInstance().loadRouters :
+ IORouterRegistry.getInstance().saveRouters;
+ routers.forEach(router => {
+ const handler = router(url, loadOptions);
+ if (handler !== null) {
+ validHandlers.push(handler);
+ }
+ });
+ return validHandlers;
+ }
+}
+const registerSaveRouter = (loudRouter) => IORouterRegistry.registerSaveRouter(loudRouter);
+const registerLoadRouter = (loudRouter) => IORouterRegistry.registerLoadRouter(loudRouter);
+const getSaveHandlers = (url) => IORouterRegistry.getSaveHandlers(url);
+const getLoadHandlers = (url, loadOptions) => IORouterRegistry.getLoadHandlers(url, loadOptions);
+//# sourceMappingURL=router_registry.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/io/model_management.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Classes and functions for model management across multiple storage mediums.
+ *
+ * Supported client actions:
+ * - Listing models on all registered storage mediums.
+ * - Remove model by URL from any registered storage mediums, by using URL
+ * string.
+ * - Moving or copying model from one path to another in the same medium or from
+ * one medium to another, by using URL strings.
+ */
+
+
+const URL_SCHEME_SUFFIX = '://';
+class model_management_ModelStoreManagerRegistry {
+ constructor() {
+ this.managers = {};
+ }
+ static getInstance() {
+ if (model_management_ModelStoreManagerRegistry.instance == null) {
+ model_management_ModelStoreManagerRegistry.instance = new model_management_ModelStoreManagerRegistry();
+ }
+ return model_management_ModelStoreManagerRegistry.instance;
+ }
+ /**
+ * Register a save-handler router.
+ *
+ * @param saveRouter A function that maps a URL-like string onto an instance
+ * of `IOHandler` with the `save` method defined or `null`.
+ */
+ static registerManager(scheme, manager) {
+ Object(util["assert"])(scheme != null, () => 'scheme must not be undefined or null.');
+ if (scheme.endsWith(URL_SCHEME_SUFFIX)) {
+ scheme = scheme.slice(0, scheme.indexOf(URL_SCHEME_SUFFIX));
+ }
+ Object(util["assert"])(scheme.length > 0, () => 'scheme must not be an empty string.');
+ const registry = model_management_ModelStoreManagerRegistry.getInstance();
+ Object(util["assert"])(registry.managers[scheme] == null, () => `A model store manager is already registered for scheme '${scheme}'.`);
+ registry.managers[scheme] = manager;
+ }
+ static getManager(scheme) {
+ const manager = this.getInstance().managers[scheme];
+ if (manager == null) {
+ throw new Error(`Cannot find model manager for scheme '${scheme}'`);
+ }
+ return manager;
+ }
+ static getSchemes() {
+ return Object.keys(this.getInstance().managers);
+ }
+}
+/**
+ * Helper method for parsing a URL string into a scheme and a path.
+ *
+ * @param url E.g., 'localstorage://my-model'
+ * @returns A dictionary with two fields: scheme and path.
+ * Scheme: e.g., 'localstorage' in the example above.
+ * Path: e.g., 'my-model' in the example above.
+ */
+function parseURL(url) {
+ if (url.indexOf(URL_SCHEME_SUFFIX) === -1) {
+ throw new Error(`The url string provided does not contain a scheme. ` +
+ `Supported schemes are: ` +
+ `${model_management_ModelStoreManagerRegistry.getSchemes().join(',')}`);
+ }
+ return {
+ scheme: url.split(URL_SCHEME_SUFFIX)[0],
+ path: url.split(URL_SCHEME_SUFFIX)[1],
+ };
+}
+async function cloneModelInternal(sourceURL, destURL, deleteSource = false) {
+ Object(util["assert"])(sourceURL !== destURL, () => `Old path and new path are the same: '${sourceURL}'`);
+ const loadHandlers = IORouterRegistry.getLoadHandlers(sourceURL);
+ Object(util["assert"])(loadHandlers.length > 0, () => `Copying failed because no load handler is found for source URL ${sourceURL}.`);
+ Object(util["assert"])(loadHandlers.length < 2, () => `Copying failed because more than one (${loadHandlers.length}) ` +
+ `load handlers for source URL ${sourceURL}.`);
+ const loadHandler = loadHandlers[0];
+ const saveHandlers = IORouterRegistry.getSaveHandlers(destURL);
+ Object(util["assert"])(saveHandlers.length > 0, () => `Copying failed because no save handler is found for destination ` +
+ `URL ${destURL}.`);
+ Object(util["assert"])(saveHandlers.length < 2, () => `Copying failed because more than one (${loadHandlers.length}) ` +
+ `save handlers for destination URL ${destURL}.`);
+ const saveHandler = saveHandlers[0];
+ const sourceScheme = parseURL(sourceURL).scheme;
+ const sourcePath = parseURL(sourceURL).path;
+ const sameMedium = sourceScheme === parseURL(sourceURL).scheme;
+ const modelArtifacts = await loadHandler.load();
+ // If moving within the same storage medium, remove the old model as soon as
+ // the loading is done. Without doing this, it is possible that the combined
+ // size of the two models will cause the cloning to fail.
+ if (deleteSource && sameMedium) {
+ await model_management_ModelStoreManagerRegistry.getManager(sourceScheme)
+ .removeModel(sourcePath);
+ }
+ const saveResult = await saveHandler.save(modelArtifacts);
+ // If moving between mediums, the deletion is done after the save succeeds.
+ // This guards against the case in which saving to the destination medium
+ // fails.
+ if (deleteSource && !sameMedium) {
+ await model_management_ModelStoreManagerRegistry.getManager(sourceScheme)
+ .removeModel(sourcePath);
+ }
+ return saveResult.modelArtifactsInfo;
+}
+/**
+ * List all models stored in registered storage mediums.
+ *
+ * For a web browser environment, the registered mediums are Local Storage and
+ * IndexedDB.
+ *
+ * ```js
+ * // First create and save a model.
+ * const model = tf.sequential();
+ * model.add(tf.layers.dense(
+ * {units: 1, inputShape: [10], activation: 'sigmoid'}));
+ * await model.save('localstorage://demo/management/model1');
+ *
+ * // Then list existing models.
+ * console.log(JSON.stringify(await tf.io.listModels()));
+ *
+ * // Delete the model.
+ * await tf.io.removeModel('localstorage://demo/management/model1');
+ *
+ * // List models again.
+ * console.log(JSON.stringify(await tf.io.listModels()));
+ * ```
+ *
+ * @returns A `Promise` of a dictionary mapping URLs of existing models to
+ * their model artifacts info. URLs include medium-specific schemes, e.g.,
+ * 'indexeddb://my/model/1'. Model artifacts info include type of the
+ * model's topology, byte sizes of the topology, weights, etc.
+ */
+/**
+ * @doc {
+ * heading: 'Models',
+ * subheading: 'Management',
+ * namespace: 'io',
+ * ignoreCI: true
+ * }
+ */
+async function listModels() {
+ const schemes = model_management_ModelStoreManagerRegistry.getSchemes();
+ const out = {};
+ for (const scheme of schemes) {
+ const schemeOut = await model_management_ModelStoreManagerRegistry.getManager(scheme).listModels();
+ for (const path in schemeOut) {
+ const url = scheme + URL_SCHEME_SUFFIX + path;
+ out[url] = schemeOut[path];
+ }
+ }
+ return out;
+}
+/**
+ * Remove a model specified by URL from a reigstered storage medium.
+ *
+ * ```js
+ * // First create and save a model.
+ * const model = tf.sequential();
+ * model.add(tf.layers.dense(
+ * {units: 1, inputShape: [10], activation: 'sigmoid'}));
+ * await model.save('localstorage://demo/management/model1');
+ *
+ * // Then list existing models.
+ * console.log(JSON.stringify(await tf.io.listModels()));
+ *
+ * // Delete the model.
+ * await tf.io.removeModel('localstorage://demo/management/model1');
+ *
+ * // List models again.
+ * console.log(JSON.stringify(await tf.io.listModels()));
+ * ```
+ *
+ * @param url A URL to a stored model, with a scheme prefix, e.g.,
+ * 'localstorage://my-model-1', 'indexeddb://my/model/2'.
+ * @returns ModelArtifactsInfo of the deleted model (if and only if deletion
+ * is successful).
+ * @throws Error if deletion fails, e.g., if no model exists at `path`.
+ */
+/**
+ * @doc {
+ * heading: 'Models',
+ * subheading: 'Management',
+ * namespace: 'io',
+ * ignoreCI: true
+ * }
+ */
+async function removeModel(url) {
+ const schemeAndPath = parseURL(url);
+ const manager = model_management_ModelStoreManagerRegistry.getManager(schemeAndPath.scheme);
+ return manager.removeModel(schemeAndPath.path);
+}
+/**
+ * Copy a model from one URL to another.
+ *
+ * This function supports:
+ *
+ * 1. Copying within a storage medium, e.g.,
+ * `tf.io.copyModel('localstorage://model-1', 'localstorage://model-2')`
+ * 2. Copying between two storage mediums, e.g.,
+ * `tf.io.copyModel('localstorage://model-1', 'indexeddb://model-1')`
+ *
+ * ```js
+ * // First create and save a model.
+ * const model = tf.sequential();
+ * model.add(tf.layers.dense(
+ * {units: 1, inputShape: [10], activation: 'sigmoid'}));
+ * await model.save('localstorage://demo/management/model1');
+ *
+ * // Then list existing models.
+ * console.log(JSON.stringify(await tf.io.listModels()));
+ *
+ * // Copy the model, from Local Storage to IndexedDB.
+ * await tf.io.copyModel(
+ * 'localstorage://demo/management/model1',
+ * 'indexeddb://demo/management/model1');
+ *
+ * // List models again.
+ * console.log(JSON.stringify(await tf.io.listModels()));
+ *
+ * // Remove both models.
+ * await tf.io.removeModel('localstorage://demo/management/model1');
+ * await tf.io.removeModel('indexeddb://demo/management/model1');
+ * ```
+ *
+ * @param sourceURL Source URL of copying.
+ * @param destURL Destination URL of copying.
+ * @returns ModelArtifactsInfo of the copied model (if and only if copying
+ * is successful).
+ * @throws Error if copying fails, e.g., if no model exists at `sourceURL`, or
+ * if `oldPath` and `newPath` are identical.
+ */
+/**
+ * @doc {
+ * heading: 'Models',
+ * subheading: 'Management',
+ * namespace: 'io',
+ * ignoreCI: true
+ * }
+ */
+async function copyModel(sourceURL, destURL) {
+ const deleteSource = false;
+ return cloneModelInternal(sourceURL, destURL, deleteSource);
+}
+/**
+ * Move a model from one URL to another.
+ *
+ * This function supports:
+ *
+ * 1. Moving within a storage medium, e.g.,
+ * `tf.io.moveModel('localstorage://model-1', 'localstorage://model-2')`
+ * 2. Moving between two storage mediums, e.g.,
+ * `tf.io.moveModel('localstorage://model-1', 'indexeddb://model-1')`
+ *
+ * ```js
+ * // First create and save a model.
+ * const model = tf.sequential();
+ * model.add(tf.layers.dense(
+ * {units: 1, inputShape: [10], activation: 'sigmoid'}));
+ * await model.save('localstorage://demo/management/model1');
+ *
+ * // Then list existing models.
+ * console.log(JSON.stringify(await tf.io.listModels()));
+ *
+ * // Move the model, from Local Storage to IndexedDB.
+ * await tf.io.moveModel(
+ * 'localstorage://demo/management/model1',
+ * 'indexeddb://demo/management/model1');
+ *
+ * // List models again.
+ * console.log(JSON.stringify(await tf.io.listModels()));
+ *
+ * // Remove the moved model.
+ * await tf.io.removeModel('indexeddb://demo/management/model1');
+ * ```
+ *
+ * @param sourceURL Source URL of moving.
+ * @param destURL Destination URL of moving.
+ * @returns ModelArtifactsInfo of the copied model (if and only if copying
+ * is successful).
+ * @throws Error if moving fails, e.g., if no model exists at `sourceURL`, or
+ * if `oldPath` and `newPath` are identical.
+ */
+/**
+ * @doc {
+ * heading: 'Models',
+ * subheading: 'Management',
+ * namespace: 'io',
+ * ignoreCI: true
+ * }
+ */
+async function moveModel(sourceURL, destURL) {
+ const deleteSource = true;
+ return cloneModelInternal(sourceURL, destURL, deleteSource);
+}
+
+//# sourceMappingURL=model_management.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/io/indexed_db.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+const DATABASE_NAME = 'tensorflowjs';
+const DATABASE_VERSION = 1;
+// Model data and ModelArtifactsInfo (metadata) are stored in two separate
+// stores for efficient access of the list of stored models and their metadata.
+// 1. The object store for model data: topology, weights and weight manifests.
+const MODEL_STORE_NAME = 'models_store';
+// 2. The object store for ModelArtifactsInfo, including meta-information such
+// as the type of topology (JSON vs binary), byte size of the topology, byte
+// size of the weights, etc.
+const INFO_STORE_NAME = 'model_info_store';
+/**
+ * Delete the entire database for tensorflow.js, including the models store.
+ */
+async function deleteDatabase() {
+ const idbFactory = getIndexedDBFactory();
+ return new Promise((resolve, reject) => {
+ const deleteRequest = idbFactory.deleteDatabase(DATABASE_NAME);
+ deleteRequest.onsuccess = () => resolve();
+ deleteRequest.onerror = error => reject(error);
+ });
+}
+function getIndexedDBFactory() {
+ if (!Object(environment["c" /* env */])().getBool('IS_BROWSER')) {
+ // TODO(cais): Add more info about what IOHandler subtypes are available.
+ // Maybe point to a doc page on the web and/or automatically determine
+ // the available IOHandlers and print them in the error message.
+ throw new Error('Failed to obtain IndexedDB factory because the current environment' +
+ 'is not a web browser.');
+ }
+ // tslint:disable-next-line:no-any
+ const theWindow = typeof window === 'undefined' ? self : window;
+ const factory = theWindow.indexedDB || theWindow.mozIndexedDB ||
+ theWindow.webkitIndexedDB || theWindow.msIndexedDB ||
+ theWindow.shimIndexedDB;
+ if (factory == null) {
+ throw new Error('The current browser does not appear to support IndexedDB.');
+ }
+ return factory;
+}
+function setUpDatabase(openRequest) {
+ const db = openRequest.result;
+ db.createObjectStore(MODEL_STORE_NAME, { keyPath: 'modelPath' });
+ db.createObjectStore(INFO_STORE_NAME, { keyPath: 'modelPath' });
+}
+/**
+ * IOHandler subclass: Browser IndexedDB.
+ *
+ * See the doc string of `browserIndexedDB` for more details.
+ */
+class indexed_db_BrowserIndexedDB {
+ constructor(modelPath) {
+ this.indexedDB = getIndexedDBFactory();
+ if (modelPath == null || !modelPath) {
+ throw new Error('For IndexedDB, modelPath must not be null, undefined or empty.');
+ }
+ this.modelPath = modelPath;
+ }
+ async save(modelArtifacts) {
+ // TODO(cais): Support saving GraphDef models.
+ if (modelArtifacts.modelTopology instanceof ArrayBuffer) {
+ throw new Error('BrowserLocalStorage.save() does not support saving model topology ' +
+ 'in binary formats yet.');
+ }
+ return this.databaseAction(this.modelPath, modelArtifacts);
+ }
+ async load() {
+ return this.databaseAction(this.modelPath);
+ }
+ /**
+ * Perform database action to put model artifacts into or read model artifacts
+ * from IndexedDB object store.
+ *
+ * Whether the action is put or get depends on whether `modelArtifacts` is
+ * specified. If it is specified, the action will be put; otherwise the action
+ * will be get.
+ *
+ * @param modelPath A unique string path for the model.
+ * @param modelArtifacts If specified, it will be the model artifacts to be
+ * stored in IndexedDB.
+ * @returns A `Promise` of `SaveResult`, if the action is put, or a `Promise`
+ * of `ModelArtifacts`, if the action is get.
+ */
+ databaseAction(modelPath, modelArtifacts) {
+ return new Promise((resolve, reject) => {
+ const openRequest = this.indexedDB.open(DATABASE_NAME, DATABASE_VERSION);
+ openRequest.onupgradeneeded = () => setUpDatabase(openRequest);
+ openRequest.onsuccess = () => {
+ const db = openRequest.result;
+ if (modelArtifacts == null) {
+ // Read model out from object store.
+ const modelTx = db.transaction(MODEL_STORE_NAME, 'readonly');
+ const modelStore = modelTx.objectStore(MODEL_STORE_NAME);
+ const getRequest = modelStore.get(this.modelPath);
+ getRequest.onsuccess = () => {
+ if (getRequest.result == null) {
+ db.close();
+ return reject(new Error(`Cannot find model with path '${this.modelPath}' ` +
+ `in IndexedDB.`));
+ }
+ else {
+ resolve(getRequest.result.modelArtifacts);
+ }
+ };
+ getRequest.onerror = error => {
+ db.close();
+ return reject(getRequest.error);
+ };
+ modelTx.oncomplete = () => db.close();
+ }
+ else {
+ // Put model into object store.
+ const modelArtifactsInfo = Object(io_utils["g" /* getModelArtifactsInfoForJSON */])(modelArtifacts);
+ // First, put ModelArtifactsInfo into info store.
+ const infoTx = db.transaction(INFO_STORE_NAME, 'readwrite');
+ let infoStore = infoTx.objectStore(INFO_STORE_NAME);
+ const putInfoRequest = infoStore.put({ modelPath: this.modelPath, modelArtifactsInfo });
+ let modelTx;
+ putInfoRequest.onsuccess = () => {
+ // Second, put model data into model store.
+ modelTx = db.transaction(MODEL_STORE_NAME, 'readwrite');
+ const modelStore = modelTx.objectStore(MODEL_STORE_NAME);
+ const putModelRequest = modelStore.put({
+ modelPath: this.modelPath,
+ modelArtifacts,
+ modelArtifactsInfo
+ });
+ putModelRequest.onsuccess = () => resolve({ modelArtifactsInfo });
+ putModelRequest.onerror = error => {
+ // If the put-model request fails, roll back the info entry as
+ // well.
+ infoStore = infoTx.objectStore(INFO_STORE_NAME);
+ const deleteInfoRequest = infoStore.delete(this.modelPath);
+ deleteInfoRequest.onsuccess = () => {
+ db.close();
+ return reject(putModelRequest.error);
+ };
+ deleteInfoRequest.onerror = error => {
+ db.close();
+ return reject(putModelRequest.error);
+ };
+ };
+ };
+ putInfoRequest.onerror = error => {
+ db.close();
+ return reject(putInfoRequest.error);
+ };
+ infoTx.oncomplete = () => {
+ if (modelTx == null) {
+ db.close();
+ }
+ else {
+ modelTx.oncomplete = () => db.close();
+ }
+ };
+ }
+ };
+ openRequest.onerror = error => reject(openRequest.error);
+ });
+ }
+}
+indexed_db_BrowserIndexedDB.URL_SCHEME = 'indexeddb://';
+const indexedDBRouter = (url) => {
+ if (!Object(environment["c" /* env */])().getBool('IS_BROWSER')) {
+ return null;
+ }
+ else {
+ if (!Array.isArray(url) && url.startsWith(indexed_db_BrowserIndexedDB.URL_SCHEME)) {
+ return browserIndexedDB(url.slice(indexed_db_BrowserIndexedDB.URL_SCHEME.length));
+ }
+ else {
+ return null;
+ }
+ }
+};
+IORouterRegistry.registerSaveRouter(indexedDBRouter);
+IORouterRegistry.registerLoadRouter(indexedDBRouter);
+/**
+ * Creates a browser IndexedDB IOHandler for saving and loading models.
+ *
+ * ```js
+ * const model = tf.sequential();
+ * model.add(
+ * tf.layers.dense({units: 1, inputShape: [100], activation: 'sigmoid'}));
+ *
+ * const saveResult = await model.save('indexeddb://MyModel'));
+ * console.log(saveResult);
+ * ```
+ *
+ * @param modelPath A unique identifier for the model to be saved. Must be a
+ * non-empty string.
+ * @returns An instance of `BrowserIndexedDB` (sublcass of `IOHandler`),
+ * which can be used with, e.g., `tf.Model.save`.
+ */
+function browserIndexedDB(modelPath) {
+ return new indexed_db_BrowserIndexedDB(modelPath);
+}
+function maybeStripScheme(key) {
+ return key.startsWith(indexed_db_BrowserIndexedDB.URL_SCHEME) ?
+ key.slice(indexed_db_BrowserIndexedDB.URL_SCHEME.length) :
+ key;
+}
+class BrowserIndexedDBManager {
+ constructor() {
+ this.indexedDB = getIndexedDBFactory();
+ }
+ async listModels() {
+ return new Promise((resolve, reject) => {
+ const openRequest = this.indexedDB.open(DATABASE_NAME, DATABASE_VERSION);
+ openRequest.onupgradeneeded = () => setUpDatabase(openRequest);
+ openRequest.onsuccess = () => {
+ const db = openRequest.result;
+ const tx = db.transaction(INFO_STORE_NAME, 'readonly');
+ const store = tx.objectStore(INFO_STORE_NAME);
+ // tslint:disable:max-line-length
+ // Need to cast `store` as `any` here because TypeScript's DOM
+ // library does not have the `getAll()` method even though the
+ // method is supported in the latest version of most mainstream
+ // browsers:
+ // https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore/getAll
+ // tslint:enable:max-line-length
+ // tslint:disable-next-line:no-any
+ const getAllInfoRequest = store.getAll();
+ getAllInfoRequest.onsuccess = () => {
+ const out = {};
+ for (const item of getAllInfoRequest.result) {
+ out[item.modelPath] = item.modelArtifactsInfo;
+ }
+ resolve(out);
+ };
+ getAllInfoRequest.onerror = error => {
+ db.close();
+ return reject(getAllInfoRequest.error);
+ };
+ tx.oncomplete = () => db.close();
+ };
+ openRequest.onerror = error => reject(openRequest.error);
+ });
+ }
+ async removeModel(path) {
+ path = maybeStripScheme(path);
+ return new Promise((resolve, reject) => {
+ const openRequest = this.indexedDB.open(DATABASE_NAME, DATABASE_VERSION);
+ openRequest.onupgradeneeded = () => setUpDatabase(openRequest);
+ openRequest.onsuccess = () => {
+ const db = openRequest.result;
+ const infoTx = db.transaction(INFO_STORE_NAME, 'readwrite');
+ const infoStore = infoTx.objectStore(INFO_STORE_NAME);
+ const getInfoRequest = infoStore.get(path);
+ let modelTx;
+ getInfoRequest.onsuccess = () => {
+ if (getInfoRequest.result == null) {
+ db.close();
+ return reject(new Error(`Cannot find model with path '${path}' ` +
+ `in IndexedDB.`));
+ }
+ else {
+ // First, delete the entry in the info store.
+ const deleteInfoRequest = infoStore.delete(path);
+ const deleteModelData = () => {
+ // Second, delete the entry in the model store.
+ modelTx = db.transaction(MODEL_STORE_NAME, 'readwrite');
+ const modelStore = modelTx.objectStore(MODEL_STORE_NAME);
+ const deleteModelRequest = modelStore.delete(path);
+ deleteModelRequest.onsuccess = () => resolve(getInfoRequest.result.modelArtifactsInfo);
+ deleteModelRequest.onerror = error => reject(getInfoRequest.error);
+ };
+ // Proceed with deleting model data regardless of whether deletion
+ // of info data succeeds or not.
+ deleteInfoRequest.onsuccess = deleteModelData;
+ deleteInfoRequest.onerror = error => {
+ deleteModelData();
+ db.close();
+ return reject(getInfoRequest.error);
+ };
+ }
+ };
+ getInfoRequest.onerror = error => {
+ db.close();
+ return reject(getInfoRequest.error);
+ };
+ infoTx.oncomplete = () => {
+ if (modelTx == null) {
+ db.close();
+ }
+ else {
+ modelTx.oncomplete = () => db.close();
+ }
+ };
+ };
+ openRequest.onerror = error => reject(openRequest.error);
+ });
+ }
+}
+if (Object(environment["c" /* env */])().getBool('IS_BROWSER')) {
+ // Wrap the construction and registration, to guard against browsers that
+ // don't support Local Storage.
+ try {
+ model_management_ModelStoreManagerRegistry.registerManager(indexed_db_BrowserIndexedDB.URL_SCHEME, new BrowserIndexedDBManager());
+ }
+ catch (err) {
+ }
+}
+//# sourceMappingURL=indexed_db.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/io/local_storage.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const PATH_SEPARATOR = '/';
+const PATH_PREFIX = 'tensorflowjs_models';
+const INFO_SUFFIX = 'info';
+const MODEL_TOPOLOGY_SUFFIX = 'model_topology';
+const WEIGHT_SPECS_SUFFIX = 'weight_specs';
+const WEIGHT_DATA_SUFFIX = 'weight_data';
+const MODEL_METADATA_SUFFIX = 'model_metadata';
+/**
+ * Purge all tensorflow.js-saved model artifacts from local storage.
+ *
+ * @returns Paths of the models purged.
+ */
+function purgeLocalStorageArtifacts() {
+ if (!Object(environment["c" /* env */])().getBool('IS_BROWSER') ||
+ typeof window === 'undefined' ||
+ typeof window.localStorage === 'undefined') {
+ throw new Error('purgeLocalStorageModels() cannot proceed because local storage is ' +
+ 'unavailable in the current environment.');
+ }
+ const LS = window.localStorage;
+ const purgedModelPaths = [];
+ for (let i = 0; i < LS.length; ++i) {
+ const key = LS.key(i);
+ const prefix = PATH_PREFIX + PATH_SEPARATOR;
+ if (key.startsWith(prefix) && key.length > prefix.length) {
+ LS.removeItem(key);
+ const modelName = getModelPathFromKey(key);
+ if (purgedModelPaths.indexOf(modelName) === -1) {
+ purgedModelPaths.push(modelName);
+ }
+ }
+ }
+ return purgedModelPaths;
+}
+function getModelKeys(path) {
+ return {
+ info: [PATH_PREFIX, path, INFO_SUFFIX].join(PATH_SEPARATOR),
+ topology: [PATH_PREFIX, path, MODEL_TOPOLOGY_SUFFIX].join(PATH_SEPARATOR),
+ weightSpecs: [PATH_PREFIX, path, WEIGHT_SPECS_SUFFIX].join(PATH_SEPARATOR),
+ weightData: [PATH_PREFIX, path, WEIGHT_DATA_SUFFIX].join(PATH_SEPARATOR),
+ modelMetadata: [PATH_PREFIX, path, MODEL_METADATA_SUFFIX].join(PATH_SEPARATOR)
+ };
+}
+/**
+ * Get model path from a local-storage key.
+ *
+ * E.g., 'tensorflowjs_models/my/model/1/info' --> 'my/model/1'
+ *
+ * @param key
+ */
+function getModelPathFromKey(key) {
+ const items = key.split(PATH_SEPARATOR);
+ if (items.length < 3) {
+ throw new Error(`Invalid key format: ${key}`);
+ }
+ return items.slice(1, items.length - 1).join(PATH_SEPARATOR);
+}
+function local_storage_maybeStripScheme(key) {
+ return key.startsWith(local_storage_BrowserLocalStorage.URL_SCHEME) ?
+ key.slice(local_storage_BrowserLocalStorage.URL_SCHEME.length) :
+ key;
+}
+/**
+ * IOHandler subclass: Browser Local Storage.
+ *
+ * See the doc string to `browserLocalStorage` for more details.
+ */
+class local_storage_BrowserLocalStorage {
+ constructor(modelPath) {
+ if (!Object(environment["c" /* env */])().getBool('IS_BROWSER') ||
+ typeof window === 'undefined' ||
+ typeof window.localStorage === 'undefined') {
+ // TODO(cais): Add more info about what IOHandler subtypes are
+ // available.
+ // Maybe point to a doc page on the web and/or automatically determine
+ // the available IOHandlers and print them in the error message.
+ throw new Error('The current environment does not support local storage.');
+ }
+ this.LS = window.localStorage;
+ if (modelPath == null || !modelPath) {
+ throw new Error('For local storage, modelPath must not be null, undefined or empty.');
+ }
+ this.modelPath = modelPath;
+ this.keys = getModelKeys(this.modelPath);
+ }
+ /**
+ * Save model artifacts to browser local storage.
+ *
+ * See the documentation to `browserLocalStorage` for details on the saved
+ * artifacts.
+ *
+ * @param modelArtifacts The model artifacts to be stored.
+ * @returns An instance of SaveResult.
+ */
+ async save(modelArtifacts) {
+ if (modelArtifacts.modelTopology instanceof ArrayBuffer) {
+ throw new Error('BrowserLocalStorage.save() does not support saving model topology ' +
+ 'in binary formats yet.');
+ }
+ else {
+ const topology = JSON.stringify(modelArtifacts.modelTopology);
+ const weightSpecs = JSON.stringify(modelArtifacts.weightSpecs);
+ const modelArtifactsInfo = Object(io_utils["g" /* getModelArtifactsInfoForJSON */])(modelArtifacts);
+ try {
+ this.LS.setItem(this.keys.info, JSON.stringify(modelArtifactsInfo));
+ this.LS.setItem(this.keys.topology, topology);
+ this.LS.setItem(this.keys.weightSpecs, weightSpecs);
+ this.LS.setItem(this.keys.weightData, Object(io_utils["a" /* arrayBufferToBase64String */])(modelArtifacts.weightData));
+ this.LS.setItem(this.keys.modelMetadata, JSON.stringify({
+ format: modelArtifacts.format,
+ generatedBy: modelArtifacts.generatedBy,
+ convertedBy: modelArtifacts.convertedBy,
+ userDefinedMetadata: modelArtifacts.userDefinedMetadata
+ }));
+ return { modelArtifactsInfo };
+ }
+ catch (err) {
+ // If saving failed, clean up all items saved so far.
+ this.LS.removeItem(this.keys.info);
+ this.LS.removeItem(this.keys.topology);
+ this.LS.removeItem(this.keys.weightSpecs);
+ this.LS.removeItem(this.keys.weightData);
+ this.LS.removeItem(this.keys.modelMetadata);
+ throw new Error(`Failed to save model '${this.modelPath}' to local storage: ` +
+ `size quota being exceeded is a possible cause of this failure: ` +
+ `modelTopologyBytes=${modelArtifactsInfo.modelTopologyBytes}, ` +
+ `weightSpecsBytes=${modelArtifactsInfo.weightSpecsBytes}, ` +
+ `weightDataBytes=${modelArtifactsInfo.weightDataBytes}.`);
+ }
+ }
+ }
+ /**
+ * Load a model from local storage.
+ *
+ * See the documentation to `browserLocalStorage` for details on the saved
+ * artifacts.
+ *
+ * @returns The loaded model (if loading succeeds).
+ */
+ async load() {
+ const info = JSON.parse(this.LS.getItem(this.keys.info));
+ if (info == null) {
+ throw new Error(`In local storage, there is no model with name '${this.modelPath}'`);
+ }
+ if (info.modelTopologyType !== 'JSON') {
+ throw new Error('BrowserLocalStorage does not support loading non-JSON model ' +
+ 'topology yet.');
+ }
+ const out = {};
+ // Load topology.
+ const topology = JSON.parse(this.LS.getItem(this.keys.topology));
+ if (topology == null) {
+ throw new Error(`In local storage, the topology of model '${this.modelPath}' ` +
+ `is missing.`);
+ }
+ out.modelTopology = topology;
+ // Load weight specs.
+ const weightSpecs = JSON.parse(this.LS.getItem(this.keys.weightSpecs));
+ if (weightSpecs == null) {
+ throw new Error(`In local storage, the weight specs of model '${this.modelPath}' ` +
+ `are missing.`);
+ }
+ out.weightSpecs = weightSpecs;
+ // Load meta-data fields.
+ const metadataString = this.LS.getItem(this.keys.modelMetadata);
+ if (metadataString != null) {
+ const metadata = JSON.parse(metadataString);
+ out.format = metadata['format'];
+ out.generatedBy = metadata['generatedBy'];
+ out.convertedBy = metadata['convertedBy'];
+ out.userDefinedMetadata = metadata['userDefinedMetadata'];
+ }
+ // Load weight data.
+ const weightDataBase64 = this.LS.getItem(this.keys.weightData);
+ if (weightDataBase64 == null) {
+ throw new Error(`In local storage, the binary weight values of model ` +
+ `'${this.modelPath}' are missing.`);
+ }
+ out.weightData = Object(io_utils["b" /* base64StringToArrayBuffer */])(weightDataBase64);
+ return out;
+ }
+}
+local_storage_BrowserLocalStorage.URL_SCHEME = 'localstorage://';
+const localStorageRouter = (url) => {
+ if (!Object(environment["c" /* env */])().getBool('IS_BROWSER')) {
+ return null;
+ }
+ else {
+ if (!Array.isArray(url) && url.startsWith(local_storage_BrowserLocalStorage.URL_SCHEME)) {
+ return browserLocalStorage(url.slice(local_storage_BrowserLocalStorage.URL_SCHEME.length));
+ }
+ else {
+ return null;
+ }
+ }
+};
+IORouterRegistry.registerSaveRouter(localStorageRouter);
+IORouterRegistry.registerLoadRouter(localStorageRouter);
+/**
+ * Factory function for local storage IOHandler.
+ *
+ * This `IOHandler` supports both `save` and `load`.
+ *
+ * For each model's saved artifacts, four items are saved to local storage.
+ * - `${PATH_SEPARATOR}/${modelPath}/info`: Contains meta-info about the
+ * model, such as date saved, type of the topology, size in bytes, etc.
+ * - `${PATH_SEPARATOR}/${modelPath}/topology`: Model topology. For Keras-
+ * style models, this is a stringized JSON.
+ * - `${PATH_SEPARATOR}/${modelPath}/weight_specs`: Weight specs of the
+ * model, can be used to decode the saved binary weight values (see
+ * item below).
+ * - `${PATH_SEPARATOR}/${modelPath}/weight_data`: Concatenated binary
+ * weight values, stored as a base64-encoded string.
+ *
+ * Saving may throw an `Error` if the total size of the artifacts exceed the
+ * browser-specific quota.
+ *
+ * @param modelPath A unique identifier for the model to be saved. Must be a
+ * non-empty string.
+ * @returns An instance of `IOHandler`, which can be used with, e.g.,
+ * `tf.Model.save`.
+ */
+function browserLocalStorage(modelPath) {
+ return new local_storage_BrowserLocalStorage(modelPath);
+}
+class local_storage_BrowserLocalStorageManager {
+ constructor() {
+ Object(util["assert"])(Object(environment["c" /* env */])().getBool('IS_BROWSER'), () => 'Current environment is not a web browser');
+ Object(util["assert"])(typeof window === 'undefined' ||
+ typeof window.localStorage !== 'undefined', () => 'Current browser does not appear to support localStorage');
+ this.LS = window.localStorage;
+ }
+ async listModels() {
+ const out = {};
+ const prefix = PATH_PREFIX + PATH_SEPARATOR;
+ const suffix = PATH_SEPARATOR + INFO_SUFFIX;
+ for (let i = 0; i < this.LS.length; ++i) {
+ const key = this.LS.key(i);
+ if (key.startsWith(prefix) && key.endsWith(suffix)) {
+ const modelPath = getModelPathFromKey(key);
+ out[modelPath] = JSON.parse(this.LS.getItem(key));
+ }
+ }
+ return out;
+ }
+ async removeModel(path) {
+ path = local_storage_maybeStripScheme(path);
+ const keys = getModelKeys(path);
+ if (this.LS.getItem(keys.info) == null) {
+ throw new Error(`Cannot find model at path '${path}'`);
+ }
+ const info = JSON.parse(this.LS.getItem(keys.info));
+ this.LS.removeItem(keys.info);
+ this.LS.removeItem(keys.topology);
+ this.LS.removeItem(keys.weightSpecs);
+ this.LS.removeItem(keys.weightData);
+ return info;
+ }
+}
+if (Object(environment["c" /* env */])().getBool('IS_BROWSER')) {
+ // Wrap the construction and registration, to guard against browsers that
+ // don't support Local Storage.
+ try {
+ model_management_ModelStoreManagerRegistry.registerManager(local_storage_BrowserLocalStorage.URL_SCHEME, new local_storage_BrowserLocalStorageManager());
+ }
+ catch (err) {
+ }
+}
+//# sourceMappingURL=local_storage.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/io/browser_files.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * IOHandlers related to files, such as browser-triggered file downloads,
+ * user-selected files in browser.
+ */
+
+
+
+const DEFAULT_FILE_NAME_PREFIX = 'model';
+const DEFAULT_JSON_EXTENSION_NAME = '.json';
+const DEFAULT_WEIGHT_DATA_EXTENSION_NAME = '.weights.bin';
+function defer(f) {
+ return new Promise(resolve => setTimeout(resolve)).then(f);
+}
+class browser_files_BrowserDownloads {
+ constructor(fileNamePrefix) {
+ if (!Object(environment["c" /* env */])().getBool('IS_BROWSER')) {
+ // TODO(cais): Provide info on what IOHandlers are available under the
+ // current environment.
+ throw new Error('browserDownloads() cannot proceed because the current environment ' +
+ 'is not a browser.');
+ }
+ if (fileNamePrefix.startsWith(browser_files_BrowserDownloads.URL_SCHEME)) {
+ fileNamePrefix = fileNamePrefix.slice(browser_files_BrowserDownloads.URL_SCHEME.length);
+ }
+ if (fileNamePrefix == null || fileNamePrefix.length === 0) {
+ fileNamePrefix = DEFAULT_FILE_NAME_PREFIX;
+ }
+ this.modelTopologyFileName = fileNamePrefix + DEFAULT_JSON_EXTENSION_NAME;
+ this.weightDataFileName =
+ fileNamePrefix + DEFAULT_WEIGHT_DATA_EXTENSION_NAME;
+ }
+ async save(modelArtifacts) {
+ if (typeof (document) === 'undefined') {
+ throw new Error('Browser downloads are not supported in ' +
+ 'this environment since `document` is not present');
+ }
+ const weightsURL = window.URL.createObjectURL(new Blob([modelArtifacts.weightData], { type: 'application/octet-stream' }));
+ if (modelArtifacts.modelTopology instanceof ArrayBuffer) {
+ throw new Error('BrowserDownloads.save() does not support saving model topology ' +
+ 'in binary formats yet.');
+ }
+ else {
+ const weightsManifest = [{
+ paths: ['./' + this.weightDataFileName],
+ weights: modelArtifacts.weightSpecs
+ }];
+ const modelTopologyAndWeightManifest = {
+ modelTopology: modelArtifacts.modelTopology,
+ format: modelArtifacts.format,
+ generatedBy: modelArtifacts.generatedBy,
+ convertedBy: modelArtifacts.convertedBy,
+ weightsManifest
+ };
+ const modelTopologyAndWeightManifestURL = window.URL.createObjectURL(new Blob([JSON.stringify(modelTopologyAndWeightManifest)], { type: 'application/json' }));
+ // If anchor elements are not provided, create them without attaching them
+ // to parents, so that the downloaded file names can be controlled.
+ const jsonAnchor = this.jsonAnchor == null ? document.createElement('a') :
+ this.jsonAnchor;
+ jsonAnchor.download = this.modelTopologyFileName;
+ jsonAnchor.href = modelTopologyAndWeightManifestURL;
+ // Trigger downloads by evoking a click event on the download anchors.
+ // When multiple downloads are started synchronously, Firefox will only
+ // save the last one.
+ await defer(() => jsonAnchor.dispatchEvent(new MouseEvent('click')));
+ if (modelArtifacts.weightData != null) {
+ const weightDataAnchor = this.weightDataAnchor == null ?
+ document.createElement('a') :
+ this.weightDataAnchor;
+ weightDataAnchor.download = this.weightDataFileName;
+ weightDataAnchor.href = weightsURL;
+ await defer(() => weightDataAnchor.dispatchEvent(new MouseEvent('click')));
+ }
+ return { modelArtifactsInfo: Object(io_utils["g" /* getModelArtifactsInfoForJSON */])(modelArtifacts) };
+ }
+ }
+}
+browser_files_BrowserDownloads.URL_SCHEME = 'downloads://';
+class browser_files_BrowserFiles {
+ constructor(files) {
+ if (files == null || files.length < 1) {
+ throw new Error(`When calling browserFiles, at least 1 file is required, ` +
+ `but received ${files}`);
+ }
+ this.files = files;
+ }
+ async load() {
+ const jsonFile = this.files[0];
+ const weightFiles = this.files.slice(1);
+ return new Promise((resolve, reject) => {
+ const jsonReader = new FileReader();
+ jsonReader.onload = (event) => {
+ // tslint:disable-next-line:no-any
+ const modelJSON = JSON.parse(event.target.result);
+ const modelTopology = modelJSON.modelTopology;
+ if (modelTopology == null) {
+ reject(new Error(`modelTopology field is missing from file ${jsonFile.name}`));
+ return;
+ }
+ if (weightFiles.length === 0) {
+ resolve({ modelTopology });
+ }
+ const weightsManifest = modelJSON.weightsManifest;
+ if (weightsManifest == null) {
+ reject(new Error(`weightManifest field is missing from file ${jsonFile.name}`));
+ return;
+ }
+ let pathToFile;
+ try {
+ pathToFile =
+ this.checkManifestAndWeightFiles(weightsManifest, weightFiles);
+ }
+ catch (err) {
+ reject(err);
+ return;
+ }
+ const weightSpecs = [];
+ const paths = [];
+ const perFileBuffers = [];
+ weightsManifest.forEach(weightsGroup => {
+ weightsGroup.paths.forEach(path => {
+ paths.push(path);
+ perFileBuffers.push(null);
+ });
+ weightSpecs.push(...weightsGroup.weights);
+ });
+ weightsManifest.forEach(weightsGroup => {
+ weightsGroup.paths.forEach(path => {
+ const weightFileReader = new FileReader();
+ weightFileReader.onload = (event) => {
+ // tslint:disable-next-line:no-any
+ const weightData = event.target.result;
+ const index = paths.indexOf(path);
+ perFileBuffers[index] = weightData;
+ if (perFileBuffers.indexOf(null) === -1) {
+ resolve({
+ modelTopology,
+ weightSpecs,
+ weightData: Object(io_utils["d" /* concatenateArrayBuffers */])(perFileBuffers),
+ format: modelJSON.format,
+ generatedBy: modelJSON.generatedBy,
+ convertedBy: modelJSON.convertedBy,
+ userDefinedMetadata: modelJSON.userDefinedMetadata
+ });
+ }
+ };
+ weightFileReader.onerror = error => reject(`Failed to weights data from file of path '${path}'.`);
+ weightFileReader.readAsArrayBuffer(pathToFile[path]);
+ });
+ });
+ };
+ jsonReader.onerror = error => reject(`Failed to read model topology and weights manifest JSON ` +
+ `from file '${jsonFile.name}'. BrowserFiles supports loading ` +
+ `Keras-style tf.Model artifacts only.`);
+ jsonReader.readAsText(jsonFile);
+ });
+ }
+ /**
+ * Check the compatibility between weights manifest and weight files.
+ */
+ checkManifestAndWeightFiles(manifest, files) {
+ const basenames = [];
+ const fileNames = files.map(file => Object(io_utils["c" /* basename */])(file.name));
+ const pathToFile = {};
+ for (const group of manifest) {
+ group.paths.forEach(path => {
+ const pathBasename = Object(io_utils["c" /* basename */])(path);
+ if (basenames.indexOf(pathBasename) !== -1) {
+ throw new Error(`Duplicate file basename found in weights manifest: ` +
+ `'${pathBasename}'`);
+ }
+ basenames.push(pathBasename);
+ if (fileNames.indexOf(pathBasename) === -1) {
+ throw new Error(`Weight file with basename '${pathBasename}' is not provided.`);
+ }
+ else {
+ pathToFile[path] = files[fileNames.indexOf(pathBasename)];
+ }
+ });
+ }
+ if (basenames.length !== files.length) {
+ throw new Error(`Mismatch in the number of files in weights manifest ` +
+ `(${basenames.length}) and the number of weight files provided ` +
+ `(${files.length}).`);
+ }
+ return pathToFile;
+ }
+}
+const browserDownloadsRouter = (url) => {
+ if (!Object(environment["c" /* env */])().getBool('IS_BROWSER')) {
+ return null;
+ }
+ else {
+ if (!Array.isArray(url) && url.startsWith(browser_files_BrowserDownloads.URL_SCHEME)) {
+ return browserDownloads(url.slice(browser_files_BrowserDownloads.URL_SCHEME.length));
+ }
+ else {
+ return null;
+ }
+ }
+};
+IORouterRegistry.registerSaveRouter(browserDownloadsRouter);
+/**
+ * Creates an IOHandler that triggers file downloads from the browser.
+ *
+ * The returned `IOHandler` instance can be used as model exporting methods such
+ * as `tf.Model.save` and supports only saving.
+ *
+ * ```js
+ * const model = tf.sequential();
+ * model.add(tf.layers.dense(
+ * {units: 1, inputShape: [10], activation: 'sigmoid'}));
+ * const saveResult = await model.save('downloads://mymodel');
+ * // This will trigger downloading of two files:
+ * // 'mymodel.json' and 'mymodel.weights.bin'.
+ * console.log(saveResult);
+ * ```
+ *
+ * @param fileNamePrefix Prefix name of the files to be downloaded. For use with
+ * `tf.Model`, `fileNamePrefix` should follow either of the following two
+ * formats:
+ * 1. `null` or `undefined`, in which case the default file
+ * names will be used:
+ * - 'model.json' for the JSON file containing the model topology and
+ * weights manifest.
+ * - 'model.weights.bin' for the binary file containing the binary weight
+ * values.
+ * 2. A single string or an Array of a single string, as the file name prefix.
+ * For example, if `'foo'` is provided, the downloaded JSON
+ * file and binary weights file will be named 'foo.json' and
+ * 'foo.weights.bin', respectively.
+ * @param config Additional configuration for triggering downloads.
+ * @returns An instance of `BrowserDownloads` `IOHandler`.
+ */
+/**
+ * @doc {
+ * heading: 'Models',
+ * subheading: 'Loading',
+ * namespace: 'io',
+ * ignoreCI: true
+ * }
+ */
+function browserDownloads(fileNamePrefix = 'model') {
+ return new browser_files_BrowserDownloads(fileNamePrefix);
+}
+/**
+ * Creates an IOHandler that loads model artifacts from user-selected files.
+ *
+ * This method can be used for loading from files such as user-selected files
+ * in the browser.
+ * When used in conjunction with `tf.loadLayersModel`, an instance of
+ * `tf.LayersModel` (Keras-style) can be constructed from the loaded artifacts.
+ *
+ * ```js
+ * // Note: This code snippet won't run properly without the actual file input
+ * // elements in the HTML DOM.
+ *
+ * // Suppose there are two HTML file input (` element.');
+ }
+ }
+ // If the current backend has 'FromPixels' registered, it has a more
+ // efficient way of handling pixel uploads, so we call that.
+ const kernel = Object(kernel_registry["b" /* getKernel */])(kernel_names["E" /* FromPixels */], engine["a" /* ENGINE */].backendName);
+ if (kernel != null) {
+ const inputs = { pixels };
+ const attrs = { numChannels };
+ return engine["a" /* ENGINE */].runKernel(kernel_names["E" /* FromPixels */], inputs, attrs);
+ }
+ const [width, height] = isVideo ?
+ [
+ pixels.videoWidth,
+ pixels.videoHeight
+ ] :
+ [pixels.width, pixels.height];
+ let vals;
+ if (isCanvasLike) {
+ vals =
+ // tslint:disable-next-line:no-any
+ pixels.getContext('2d').getImageData(0, 0, width, height).data;
+ }
+ else if (isImageData || isPixelData) {
+ vals = pixels.data;
+ }
+ else if (isImage || isVideo) {
+ if (fromPixels2DContext == null) {
+ fromPixels2DContext = document.createElement('canvas').getContext('2d');
+ }
+ fromPixels2DContext.canvas.width = width;
+ fromPixels2DContext.canvas.height = height;
+ fromPixels2DContext.drawImage(pixels, 0, 0, width, height);
+ vals = fromPixels2DContext.getImageData(0, 0, width, height).data;
+ }
+ let values;
+ if (numChannels === 4) {
+ values = new Int32Array(vals);
+ }
+ else {
+ const numPixels = width * height;
+ values = new Int32Array(numPixels * numChannels);
+ for (let i = 0; i < numPixels; i++) {
+ for (let channel = 0; channel < numChannels; ++channel) {
+ values[i * numChannels + channel] = vals[i * 4 + channel];
+ }
+ }
+ }
+ const outShape = [height, width, numChannels];
+ return Object(tensor_ops["i" /* tensor3d */])(values, outShape, 'int32');
+}
+/**
+ * Draws a `tf.Tensor` of pixel values to a byte array or optionally a
+ * canvas.
+ *
+ * When the dtype of the input is 'float32', we assume values in the range
+ * [0-1]. Otherwise, when input is 'int32', we assume values in the range
+ * [0-255].
+ *
+ * Returns a promise that resolves when the canvas has been drawn to.
+ *
+ * @param img A rank-2 or rank-3 tensor. If rank-2, draws grayscale. If
+ * rank-3, must have depth of 1, 3 or 4. When depth of 1, draws
+ * grayscale. When depth of 3, we draw with the first three components of
+ * the depth dimension corresponding to r, g, b and alpha = 1. When depth of
+ * 4, all four components of the depth dimension correspond to r, g, b, a.
+ * @param canvas The canvas to draw to.
+ */
+/** @doc {heading: 'Browser', namespace: 'browser'} */
+async function toPixels(img, canvas) {
+ let $img = Object(tensor_util_env["a" /* convertToTensor */])(img, 'img', 'toPixels');
+ if (!(img instanceof dist_tensor["a" /* Tensor */])) {
+ // Assume int32 if user passed a native array.
+ const originalImgTensor = $img;
+ $img = originalImgTensor.toInt();
+ originalImgTensor.dispose();
+ }
+ if ($img.rank !== 2 && $img.rank !== 3) {
+ throw new Error(`toPixels only supports rank 2 or 3 tensors, got rank ${$img.rank}.`);
+ }
+ const [height, width] = $img.shape.slice(0, 2);
+ const depth = $img.rank === 2 ? 1 : $img.shape[2];
+ if (depth > 4 || depth === 2) {
+ throw new Error(`toPixels only supports depth of size ` +
+ `1, 3 or 4 but got ${depth}`);
+ }
+ const data = await $img.data();
+ const minTensor = $img.min();
+ const maxTensor = $img.max();
+ const vals = await Promise.all([minTensor.data(), maxTensor.data()]);
+ const minVals = vals[0];
+ const maxVals = vals[1];
+ const min = minVals[0];
+ const max = maxVals[0];
+ minTensor.dispose();
+ maxTensor.dispose();
+ if ($img.dtype === 'float32') {
+ if (min < 0 || max > 1) {
+ throw new Error(`Tensor values for a float32 Tensor must be in the ` +
+ `range [0 - 1] but got range [${min} - ${max}].`);
+ }
+ }
+ else if ($img.dtype === 'int32') {
+ if (min < 0 || max > 255) {
+ throw new Error(`Tensor values for a int32 Tensor must be in the ` +
+ `range [0 - 255] but got range [${min} - ${max}].`);
+ }
+ }
+ else {
+ throw new Error(`Unsupported type for toPixels: ${$img.dtype}.` +
+ ` Please use float32 or int32 tensors.`);
+ }
+ const multiplier = $img.dtype === 'float32' ? 255 : 1;
+ const bytes = new Uint8ClampedArray(width * height * 4);
+ for (let i = 0; i < height * width; ++i) {
+ let r, g, b, a;
+ if (depth === 1) {
+ r = data[i] * multiplier;
+ g = data[i] * multiplier;
+ b = data[i] * multiplier;
+ a = 255;
+ }
+ else if (depth === 3) {
+ r = data[i * 3] * multiplier;
+ g = data[i * 3 + 1] * multiplier;
+ b = data[i * 3 + 2] * multiplier;
+ a = 255;
+ }
+ else if (depth === 4) {
+ r = data[i * 4] * multiplier;
+ g = data[i * 4 + 1] * multiplier;
+ b = data[i * 4 + 2] * multiplier;
+ a = data[i * 4 + 3] * multiplier;
+ }
+ const j = i * 4;
+ bytes[j + 0] = Math.round(r);
+ bytes[j + 1] = Math.round(g);
+ bytes[j + 2] = Math.round(b);
+ bytes[j + 3] = Math.round(a);
+ }
+ if (canvas != null) {
+ canvas.width = width;
+ canvas.height = height;
+ const ctx = canvas.getContext('2d');
+ const imageData = new ImageData(bytes, width, height);
+ ctx.putImageData(imageData, 0, 0);
+ }
+ if ($img !== img) {
+ $img.dispose();
+ }
+ return bytes;
+}
+const fromPixels = Object(operation["a" /* op */])({ fromPixels_ });
+//# sourceMappingURL=browser.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/gather_nd_util.js
+
+/**
+ * Validate gather nd inputs.
+ *
+ * @param tensor The tensor contains the source values.
+ * @param indices The tensor contains the indices to slice the source.
+ *
+ * @returns [resultShape, numUpdates, sliceSize, strides]
+ */
+function prepareAndValidate(tensor, indices) {
+ if (tensor.rank < 1) {
+ throw new Error('tf.gatherND() expects the input to be rank 1 or higher,' +
+ ` but the rank was ${tensor.rank}.`);
+ }
+ if (indices.rank < 1) {
+ throw new Error('tf.gatherND() expects the indices to be rank 1 or higher,' +
+ ` but the rank was ${indices.rank}.`);
+ }
+ if (indices.dtype !== 'int32') {
+ throw new Error('tf.gatherND() expects the indices to be int32 type,' +
+ ` but the dtype was ${indices.dtype}.`);
+ }
+ if (indices.shape[indices.rank - 1] > tensor.rank) {
+ throw new Error('index innermost dimension length must be <= tensor rank; saw: ' +
+ `${indices.shape[indices.rank - 1]} vs. ${tensor.rank}`);
+ }
+ if (tensor.size === 0) {
+ throw new Error('Requested more than 0 entries, but input is empty.' +
+ ` Input shape: ${tensor.shape}.`);
+ }
+ const indicesShape = indices.shape;
+ const sliceRank = indicesShape[indicesShape.length - 1];
+ // The result shape is
+ // indices.shape[:-1] + params.shape[indices.shape[-1]:]
+ let nResult = 1;
+ for (let i = 0; i < indicesShape.length - 1; ++i) {
+ nResult *= indicesShape[i];
+ }
+ const inputShape = tensor.shape;
+ const resultShape = indicesShape.slice();
+ resultShape.pop();
+ let sliceSize = 1;
+ for (let i = sliceRank; i < tensor.rank; ++i) {
+ sliceSize *= inputShape[i];
+ resultShape.push(inputShape[i]);
+ }
+ const strides = [...Object(util["computeStrides"])(tensor.shape).map(stride => stride / sliceSize),
+ 1].slice(0, sliceRank);
+ return [resultShape, nResult, sliceSize, strides];
+}
+//# sourceMappingURL=gather_nd_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/scatter_nd_util.js
+
+/**
+ * Check whether updates.shape = indices.shape[:batchDim] +
+ * shape[sliceDim:]
+ *
+ * @param x The input tensor.
+ */
+function validateUpdateShape(shape, indices, updates) {
+ const sliceDim = (indices.rank > 1) ? indices.shape[indices.rank - 1] : 1;
+ const batchDim = (indices.rank > 1) ? indices.rank - 1 : 1;
+ const shapeError = 'Must have updates.shape = indices.shape[:batchDim] + ' +
+ `shape[sliceDim:], got updates.shape: ${updates.shape}` +
+ `, indices.shape: ${indices.shape}, shape: ${shape}` +
+ `, sliceDim: ${sliceDim}, and batchDim: ${batchDim}.`;
+ if (updates.rank < batchDim) {
+ throw new Error(shapeError + ` update.rank < ${batchDim}. `);
+ }
+ if (shape.length < sliceDim + (updates.rank - batchDim)) {
+ throw new Error(shapeError +
+ ` Output shape length < ${sliceDim + (updates.rank - batchDim)}`);
+ }
+ if (updates.rank !== batchDim + shape.length - sliceDim) {
+ throw new Error(shapeError + ` update.rank != ${batchDim + shape.length - sliceDim}`);
+ }
+ for (let d = 0; d < batchDim; ++d) {
+ if (updates.shape[d] !== indices.shape[d]) {
+ throw new Error(shapeError +
+ ` updates.shape[${d}] (${updates.shape[d]}) != indices.shape[${d}] (${indices.shape[d]}).`);
+ }
+ }
+ for (let d = 0; d < updates.rank - batchDim; ++d) {
+ if (updates.shape[d + batchDim] !== shape[d + sliceDim]) {
+ throw new Error(shapeError +
+ ` updates.shape[${d + batchDim}] (${updates.shape[d + batchDim]}) != shape[${d + batchDim}] (${shape[d + batchDim]})`);
+ }
+ }
+}
+/**
+ * Validate scatter nd inputs.
+ *
+ * @param update The tensor contains the update values.
+ * @param indices The tensor contains the indices for the update values.
+ * @param shape The shape of the output tensor.
+ */
+function validateInput(updates, indices, shape) {
+ if (indices.rank < 1) {
+ throw new Error('tf.scatterND() expects the indices to be rank 1 or higher,' +
+ ` but the rank was ${indices.rank}.`);
+ }
+ if (updates.rank < 1) {
+ throw new Error('tf.scatterND() expects the updates to be rank 1 or higher,' +
+ ` but the rank was ${updates.rank}.`);
+ }
+ if (indices.dtype !== 'int32') {
+ throw new Error(`The dtype of 'indices' should be int32, but got dtype: ${indices.dtype}`);
+ }
+ if (shape.length < 1) {
+ throw new Error(`Output rank must be greater or equal to 1, but got shape: ${shape}`);
+ }
+ if (shape.length === 0) {
+ if (indices.size === 0) {
+ throw new Error(`Indices specified for empty output. indices shape: ${indices.shape}`);
+ }
+ if (updates.size === 0) {
+ throw new Error(`Updates specified for empty output. updates shape: ${updates.shape}`);
+ }
+ }
+ validateUpdateShape(shape, indices, updates);
+}
+/**
+ * Calculate the shape information for the output.
+ *
+ * @param update The tensor contains the update values.
+ * @param indices The tensor contains the indices for the update values.
+ * @param shape The shape of the output tensor.
+ *
+ * @returns ScatterShapeInfo
+ */
+function calculateShapes(updates, indices, shape) {
+ // Calculate the number of dimensions in indices
+ const indicesRank = indices.shape.length;
+ const sliceRank = (indicesRank > 1) ? indices.shape[indicesRank - 1] : 1;
+ // Calculate the number of elements that make up each slice of our updated
+ // tensor. This allows us to work with flattened tensors and copy over whole
+ // slices at a time.
+ const totalNd = shape.length;
+ let sliceSize = 1;
+ for (let i = sliceRank; i < totalNd; ++i) {
+ sliceSize *= shape[i];
+ }
+ const safeSliceDim = (sliceRank < 1) ? 1 : sliceRank;
+ const numUpdates = Object(util["sizeFromShape"])(indices.shape) / safeSliceDim;
+ const strides = [...Object(util["computeStrides"])(shape.slice(0, sliceRank)), 1];
+ const outputSize = Object(util["sizeFromShape"])(shape);
+ return { sliceRank, numUpdates, sliceSize, strides, outputSize };
+}
+//# sourceMappingURL=scatter_nd_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/serialization.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+/**
+ * Serializable defines the serialization contract.
+ *
+ * TFJS requires serializable classes to return their className when asked
+ * to avoid issues with minification.
+ */
+class Serializable {
+ /**
+ * Return the class name for this class to use in serialization contexts.
+ *
+ * Generally speaking this will be the same thing that constructor.name
+ * would have returned. However, the class name needs to be robust
+ * against minification for serialization/deserialization to work properly.
+ *
+ * There's also places such as initializers.VarianceScaling, where
+ * implementation details between different languages led to different
+ * class hierarchies and a non-leaf node is used for serialization purposes.
+ */
+ getClassName() {
+ return this.constructor
+ .className;
+ }
+ /**
+ * Creates an instance of T from a ConfigDict.
+ *
+ * This works for most descendants of serializable. A few need to
+ * provide special handling.
+ * @param cls A Constructor for the class to instantiate.
+ * @param config The Configuration for the object.
+ */
+ /** @nocollapse */
+ static fromConfig(cls, config) {
+ return new cls(config);
+ }
+}
+/**
+ * Maps string keys to class constructors.
+ *
+ * Used during (de)serialization from the cross-language JSON format, which
+ * requires the class name in the serialization format matches the class
+ * names as used in Python, should it exist.
+ */
+class SerializationMap {
+ constructor() {
+ this.classNameMap = {};
+ }
+ /**
+ * Returns the singleton instance of the map.
+ */
+ static getMap() {
+ if (SerializationMap.instance == null) {
+ SerializationMap.instance = new SerializationMap();
+ }
+ return SerializationMap.instance;
+ }
+ /**
+ * Registers the class as serializable.
+ */
+ static register(cls) {
+ SerializationMap.getMap().classNameMap[cls.className] =
+ [cls, cls.fromConfig];
+ }
+}
+/**
+ * Register a class with the serialization map of TensorFlow.js.
+ *
+ * This is often used for registering custom Layers, so they can be
+ * serialized and deserialized.
+ *
+ * Example:
+ *
+ * ```js
+ * class MyCustomLayer extends tf.layers.Layer {
+ * static className = 'MyCustomLayer';
+ *
+ * constructor(config) {
+ * super(config);
+ * }
+ * }
+ * tf.serialization.registerClass(MyCustomLayer);
+ * ```
+ *
+ * @param cls The class to be registered. It must have a public static member
+ * called `className` defined and the value must be a non-empty string.
+ */
+/** @doc {heading: 'Models', subheading: 'Serialization', ignoreCI: true} */
+function registerClass(cls) {
+ Object(util["assert"])(cls.className != null, () => `Class being registered does not have the static className ` +
+ `property defined.`);
+ Object(util["assert"])(typeof cls.className === 'string', () => `className is required to be a string, but got type ` +
+ typeof cls.className);
+ Object(util["assert"])(cls.className.length > 0, () => `Class being registered has an empty-string as its className, ` +
+ `which is disallowed.`);
+ SerializationMap.register(cls);
+}
+//# sourceMappingURL=serialization.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/test_util.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+const TEST_EPSILON_FLOAT32 = 1e-3;
+const TEST_EPSILON_FLOAT16 = 1e-1;
+function expectArraysClose(actual, expected, epsilon) {
+ if (epsilon == null) {
+ epsilon = testEpsilon();
+ }
+ return expectArraysPredicate(actual, expected, (a, b) => areClose(a, b, epsilon));
+}
+function testEpsilon() {
+ return engine["a" /* ENGINE */].backend.floatPrecision() === 32 ? TEST_EPSILON_FLOAT32 :
+ TEST_EPSILON_FLOAT16;
+}
+function expectArraysPredicate(actual, expected, predicate) {
+ let checkClassType = true;
+ if (Object(util["isTypedArray"])(actual) || Object(util["isTypedArray"])(expected)) {
+ checkClassType = false;
+ }
+ if (Object(util["isTypedArray"])(actual) && Object(util["isTypedArray"])(expected)) {
+ checkClassType = true;
+ }
+ if (checkClassType) {
+ const aType = actual.constructor.name;
+ const bType = expected.constructor.name;
+ if (aType !== bType) {
+ throw new Error(`Arrays are of different type. Actual: ${aType}. ` +
+ `Expected: ${bType}`);
+ }
+ }
+ if (Array.isArray(actual) && Array.isArray(expected)) {
+ const actualShape = Object(tensor_util_env["c" /* inferShape */])(actual);
+ const expectedShape = Object(tensor_util_env["c" /* inferShape */])(expected);
+ if (!Object(util["arraysEqual"])(actualShape, expectedShape)) {
+ throw new Error(`Arrays have different shapes. ` +
+ `Actual: [${actualShape}]. Expected: [${expectedShape}]`);
+ }
+ }
+ const actualFlat = Object(util["isTypedArray"])(actual) ? actual : Object(util["flatten"])(actual);
+ const expectedFlat = Object(util["isTypedArray"])(expected) ?
+ expected :
+ Object(util["flatten"])(expected);
+ if (actualFlat.length !== expectedFlat.length) {
+ throw new Error(`Arrays have different lengths actual: ${actualFlat.length} vs ` +
+ `expected: ${expectedFlat.length}.\n` +
+ `Actual: ${actualFlat}.\n` +
+ `Expected: ${expectedFlat}.`);
+ }
+ for (let i = 0; i < expectedFlat.length; ++i) {
+ const a = actualFlat[i];
+ const e = expectedFlat[i];
+ if (!predicate(a, e)) {
+ throw new Error(`Arrays differ: actual[${i}] = ${a}, expected[${i}] = ${e}.\n` +
+ `Actual: ${actualFlat}.\n` +
+ `Expected: ${expectedFlat}.`);
+ }
+ }
+}
+function expectPromiseToFail(fn, done) {
+ fn().then(() => done.fail(), () => done());
+}
+function expectArraysEqual(actual, expected) {
+ const exp = typeof expected === 'string' || typeof expected === 'number' ||
+ typeof expected === 'boolean' ?
+ [expected] :
+ expected;
+ if (Object(util["isString"])(actual) || Object(util["isString"])(actual[0]) ||
+ Object(util["isString"])(expected) || Object(util["isString"])(expected[0])) {
+ // tslint:disable-next-line: triple-equals
+ return expectArraysPredicate(actual, exp, (a, b) => a == b);
+ }
+ return expectArraysPredicate(actual, expected, (a, b) => areClose(a, b, 0));
+}
+function expectNumbersClose(a, e, epsilon) {
+ if (epsilon == null) {
+ epsilon = testEpsilon();
+ }
+ if (!areClose(a, e, epsilon)) {
+ throw new Error(`Numbers differ: actual === ${a}, expected === ${e}`);
+ }
+}
+function areClose(a, e, epsilon) {
+ if (!isFinite(a) && !isFinite(e)) {
+ return true;
+ }
+ if (isNaN(a) || isNaN(e) || Math.abs(a - e) > epsilon) {
+ return false;
+ }
+ return true;
+}
+function expectValuesInRange(actual, low, high) {
+ for (let i = 0; i < actual.length; i++) {
+ if (actual[i] < low || actual[i] > high) {
+ throw new Error(`Value out of range:${actual[i]} low: ${low}, high: ${high}`);
+ }
+ }
+}
+function expectArrayBuffersEqual(actual, expected) {
+ // Safari & Jasmine don't like comparing ArrayBuffers directly. Wrapping in
+ // a Float32Array solves this issue.
+ expect(new Float32Array(actual)).toEqual(new Float32Array(expected));
+}
+//# sourceMappingURL=test_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/version.js
+/** @license See the LICENSE file. */
+// This code is auto-generated, do not modify this file!
+const version = '2.0.1';
+
+//# sourceMappingURL=version.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/globals.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Enables production mode which disables correctness checks in favor of
+ * performance.
+ */
+/** @doc {heading: 'Environment'} */
+function enableProdMode() {
+ Object(environment["c" /* env */])().set('PROD', true);
+}
+/**
+ * Enables debug mode which will log information about all executed kernels:
+ * the elapsed time of the kernel execution, as well as the rank, shape, and
+ * size of the output tensor.
+ *
+ * Debug mode will significantly slow down your application as it will
+ * download the result of every operation to the CPU. This should not be used in
+ * production. Debug mode does not affect the timing information of the kernel
+ * execution as we do not measure download time in the kernel execution time.
+ *
+ * See also: `tf.profile`, `tf.memory`.
+ */
+/** @doc {heading: 'Environment'} */
+function enableDebugMode() {
+ Object(environment["c" /* env */])().set('DEBUG', true);
+}
+/** Globally disables deprecation warnings */
+function disableDeprecationWarnings() {
+ Object(environment["c" /* env */])().set('DEPRECATION_WARNINGS_ENABLED', false);
+ console.warn(`TensorFlow.js deprecation warnings have been disabled.`);
+}
+/** Warn users about deprecated functionality. */
+function deprecationWarn(msg) {
+ if (Object(environment["c" /* env */])().getBool('DEPRECATION_WARNINGS_ENABLED')) {
+ console.warn(msg + ' You can disable deprecation warnings with ' +
+ 'tf.disableDeprecationWarnings().');
+ }
+}
+Object(dist_tensor["d" /* setDeprecationWarningFn */])(deprecationWarn);
+/**
+ * Dispose all variables kept in backend engine.
+ */
+/** @doc {heading: 'Environment'} */
+function disposeVariables() {
+ engine["a" /* ENGINE */].disposeVariables();
+}
+/**
+ * It returns the global engine that keeps track of all tensors and backends.
+ */
+/** @doc {heading: 'Environment'} */
+function globals_engine() {
+ return engine["a" /* ENGINE */];
+}
+/**
+ * Returns memory info at the current time in the program. The result is an
+ * object with the following properties:
+ *
+ * - `numBytes`: Number of bytes allocated (undisposed) at this time.
+ * - `numTensors`: Number of unique tensors allocated.
+ * - `numDataBuffers`: Number of unique data buffers allocated
+ * (undisposed) at this time, which is ≤ the number of tensors
+ * (e.g. `a.reshape(newShape)` makes a new Tensor that shares the same
+ * data buffer with `a`).
+ * - `unreliable`: True if the memory usage is unreliable. See `reasons` when
+ * `unreliable` is true.
+ * - `reasons`: `string[]`, reasons why the memory is unreliable, present if
+ * `unreliable` is true.
+ *
+ * WebGL Properties:
+ * - `numBytesInGPU`: Number of bytes allocated (undisposed) in the GPU only at
+ * this time.
+ */
+/** @doc {heading: 'Performance', subheading: 'Memory'} */
+function memory() {
+ return engine["a" /* ENGINE */].memory();
+}
+/**
+ * Executes the provided function `f()` and returns a promise that resolves
+ * with information about the function's memory use:
+ * - `newBytes`: the number of new bytes allocated
+ * - `newTensors`: the number of new tensors created
+ * - `peakBytes`: the peak number of bytes allocated
+ * - `kernels`: an array of objects for each kernel involved that reports
+ * their input and output shapes, number of bytes used, and number of new
+ * tensors created.
+ *
+ * ```js
+ * const profile = await tf.profile(() => {
+ * const x = tf.tensor1d([1, 2, 3]);
+ * let x2 = x.square();
+ * x2.dispose();
+ * x2 = x.square();
+ * x2.dispose();
+ * return x;
+ * });
+ *
+ * console.log(`newBytes: ${profile.newBytes}`);
+ * console.log(`newTensors: ${profile.newTensors}`);
+ * console.log(`byte usage over all kernels: ${profile.kernels.map(k =>
+ * k.totalBytesSnapshot)}`);
+ * ```
+ *
+ */
+/** @doc {heading: 'Performance', subheading: 'Profile'} */
+function profile(f) {
+ return engine["a" /* ENGINE */].profile(f);
+}
+/**
+ * Executes the provided function `fn` and after it is executed, cleans up all
+ * intermediate tensors allocated by `fn` except those returned by `fn`.
+ * `fn` must not return a Promise (async functions not allowed). The returned
+ * result can be a complex object.
+ *
+ * Using this method helps avoid memory leaks. In general, wrap calls to
+ * operations in `tf.tidy` for automatic memory cleanup.
+ *
+ * NOTE: Variables do *not* get cleaned up when inside a tidy(). If you want to
+ * dispose variables, please use `tf.disposeVariables` or call dispose()
+ * directly on variables.
+ *
+ * ```js
+ * // y = 2 ^ 2 + 1
+ * const y = tf.tidy(() => {
+ * // a, b, and one will be cleaned up when the tidy ends.
+ * const one = tf.scalar(1);
+ * const a = tf.scalar(2);
+ * const b = a.square();
+ *
+ * console.log('numTensors (in tidy): ' + tf.memory().numTensors);
+ *
+ * // The value returned inside the tidy function will return
+ * // through the tidy, in this case to the variable y.
+ * return b.add(one);
+ * });
+ *
+ * console.log('numTensors (outside tidy): ' + tf.memory().numTensors);
+ * y.print();
+ * ```
+ *
+ * @param nameOrFn The name of the closure, or the function to execute.
+ * If a name is provided, the 2nd argument should be the function.
+ * If debug mode is on, the timing and the memory usage of the function
+ * will be tracked and displayed on the console using the provided name.
+ * @param fn The function to execute.
+ */
+/** @doc {heading: 'Performance', subheading: 'Memory'} */
+function tidy(nameOrFn, fn) {
+ return engine["a" /* ENGINE */].tidy(nameOrFn, fn);
+}
+/**
+ * Disposes any `tf.Tensor`s found within the provided object.
+ *
+ * @param container an object that may be a `tf.Tensor` or may directly
+ * contain `tf.Tensor`s, such as a `Tensor[]` or `{key: Tensor, ...}`. If
+ * the object is not a `tf.Tensor` or does not contain `Tensors`, nothing
+ * happens. In general it is safe to pass any object here, except that
+ * `Promise`s are not supported.
+ */
+/** @doc {heading: 'Performance', subheading: 'Memory'} */
+function dispose(container) {
+ const tensors = Object(tensor_util["getTensorsInContainer"])(container);
+ tensors.forEach(tensor => tensor.dispose());
+}
+/**
+ * Keeps a `tf.Tensor` generated inside a `tf.tidy` from being disposed
+ * automatically.
+ *
+ * ```js
+ * let b;
+ * const y = tf.tidy(() => {
+ * const one = tf.scalar(1);
+ * const a = tf.scalar(2);
+ *
+ * // b will not be cleaned up by the tidy. a and one will be cleaned up
+ * // when the tidy ends.
+ * b = tf.keep(a.square());
+ *
+ * console.log('numTensors (in tidy): ' + tf.memory().numTensors);
+ *
+ * // The value returned inside the tidy function will return
+ * // through the tidy, in this case to the variable y.
+ * return b.add(one);
+ * });
+ *
+ * console.log('numTensors (outside tidy): ' + tf.memory().numTensors);
+ * console.log('y:');
+ * y.print();
+ * console.log('b:');
+ * b.print();
+ * ```
+ *
+ * @param result The tensor to keep from being disposed.
+ */
+/** @doc {heading: 'Performance', subheading: 'Memory'} */
+function keep(result) {
+ return engine["a" /* ENGINE */].keep(result);
+}
+/**
+ * Executes `f()` and returns a promise that resolves with timing
+ * information.
+ *
+ * The result is an object with the following properties:
+ *
+ * - `wallMs`: Wall execution time.
+ * - `kernelMs`: Kernel execution time, ignoring data transfer. If using the
+ * WebGL backend and the query timer extension is not available, this will
+ * return an error object.
+ * - On `WebGL` The following additional properties exist:
+ * - `uploadWaitMs`: CPU blocking time on texture uploads.
+ * - `downloadWaitMs`: CPU blocking time on texture downloads (readPixels).
+ *
+ * ```js
+ * const x = tf.randomNormal([20, 20]);
+ * const time = await tf.time(() => x.matMul(x));
+ *
+ * console.log(`kernelMs: ${time.kernelMs}, wallTimeMs: ${time.wallMs}`);
+ * ```
+ *
+ * @param f The function to execute and time.
+ */
+/** @doc {heading: 'Performance', subheading: 'Timing'} */
+function time(f) {
+ return engine["a" /* ENGINE */].time(f);
+}
+/**
+ * Sets the backend (cpu, webgl, wasm, etc) responsible for creating tensors and
+ * executing operations on those tensors. Returns a promise that resolves
+ * to a boolean if the backend initialization was successful.
+ *
+ * Note this disposes the current backend, if any, as well as any tensors
+ * associated with it. A new backend is initialized, even if it is of the
+ * same type as the previous one.
+ *
+ * @param backendName The name of the backend. Currently supports
+ * `'webgl'|'cpu'` in the browser, `'tensorflow'` under node.js
+ * (requires tfjs-node), and `'wasm'` (requires tfjs-backend-wasm).
+ */
+/** @doc {heading: 'Backends'} */
+function setBackend(backendName) {
+ return engine["a" /* ENGINE */].setBackend(backendName);
+}
+/**
+ * Returns a promise that resolves when the currently selected backend (or the
+ * highest priority one) has initialized. Await this promise when you are using
+ * a backend that has async initialization.
+ */
+/** @doc {heading: 'Backends'} */
+function ready() {
+ return engine["a" /* ENGINE */].ready();
+}
+/**
+ * Returns the current backend name (cpu, webgl, etc). The backend is
+ * responsible for creating tensors and executing operations on those tensors.
+ */
+/** @doc {heading: 'Backends'} */
+function getBackend() {
+ return engine["a" /* ENGINE */].backendName;
+}
+/**
+ * Removes a backend and the registered factory.
+ */
+/** @doc {heading: 'Backends'} */
+function removeBackend(name) {
+ engine["a" /* ENGINE */].removeBackend(name);
+}
+/**
+ * Finds the backend registered under the provided name. Returns null if the
+ * name is not in the registry, or the registration hasn't finished yet.
+ */
+function findBackend(name) {
+ return engine["a" /* ENGINE */].findBackend(name);
+}
+/**
+ * Finds the backend factory registered under the provided name. Returns a
+ * function that produces a new backend when called. Returns null if the name
+ * is not in the registry.
+ */
+function findBackendFactory(name) {
+ return engine["a" /* ENGINE */].findBackendFactory(name);
+}
+/**
+ * Registers a global backend. The registration should happen when importing
+ * a module file (e.g. when importing `backend_webgl.ts`), and is used for
+ * modular builds (e.g. custom tfjs bundle with only webgl support).
+ *
+ * @param factory The backend factory function. When called, it should
+ * return a backend instance, or a promise of an instance.
+ * @param priority The priority of the backend (higher = more important).
+ * In case multiple backends are registered, the priority is used to find
+ * the best backend. Defaults to 1.
+ * @return False if there is already a registered backend under this name, true
+ * if not.
+ */
+/** @doc {heading: 'Backends'} */
+function registerBackend(name, factory, priority = 1) {
+ return engine["a" /* ENGINE */].registerBackend(name, factory, priority);
+}
+/**
+ * Gets the current backend. If no backends have been initialized, this will
+ * attempt to initialize the best backend. Will throw an error if the highest
+ * priority backend has async initialization, in which case, you should call
+ * 'await tf.ready()' before running other code.
+ */
+/** @doc {heading: 'Backends'} */
+function globals_backend() {
+ return engine["a" /* ENGINE */].backend;
+}
+/**
+ * Sets the global platform.
+ *
+ * @param platformName The name of this platform.
+ * @param platform A platform implementation.
+ */
+function setPlatform(platformName, platform) {
+ Object(environment["c" /* env */])().setPlatform(platformName, platform);
+}
+//# sourceMappingURL=globals.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/add_n.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Adds a list of `tf.Tensor`s element-wise, each with the same shape and dtype.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2]);
+ * const b = tf.tensor1d([3, 4]);
+ * const c = tf.tensor1d([5, 6]);
+ *
+ * tf.addN([a, b, c]).print();
+ * ```
+ * @param tensors A list of tensors with the same shape and dtype.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function addN_(tensors) {
+ util["assert"](Array.isArray(tensors), () => 'The argument passed to tf.addN() must be a list of tensors');
+ util["assert"](tensors.length >= 1, () => `Must pass at least one tensor to tf.addN(), but got ` +
+ `${tensors.length}`);
+ const $tensors = tensors.map((t, i) => Object(tensor_util_env["a" /* convertToTensor */])(t, `tensors${i}`, 'addN'));
+ const firstTensor = $tensors[0];
+ $tensors.forEach(t => {
+ if (t.dtype !== firstTensor.dtype) {
+ throw new Error('All tensors passed to tf.addN() must have the same dtype');
+ }
+ });
+ $tensors.forEach(t => {
+ if (!util["arraysEqual"](t.shape, firstTensor.shape)) {
+ throw new Error('All tensors passed to tf.addN() must have the same shape');
+ }
+ });
+ const forward = (backend, save) => {
+ const res = backend.addN($tensors);
+ save($tensors);
+ return res;
+ };
+ const inputs = $tensors;
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["b" /* AddN */]);
+}
+const addN = Object(operation["a" /* op */])({ addN_ });
+//# sourceMappingURL=add_n.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/atan2.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Computes arctangent of `tf.Tensor`s a / b element-wise: `atan2(a, b)`.
+ * Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1.0, 1.0, -1.0, .7]);
+ * const b = tf.tensor1d([2.0, 13.0, 3.5, .21]);
+ *
+ * tf.atan2(a, b).print()
+ * ```
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same dtype as `a`.
+ *
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function atan2_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'atan2');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'atan2');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ const forward = (backend, save) => {
+ const res = backend.atan2($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["c" /* Atan2 */]);
+}
+const atan2 = Object(operation["a" /* op */])({ atan2_ });
+//# sourceMappingURL=atan2.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/avg_pool.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Computes the 2D average pooling of an image.
+ *
+ * @param x The input tensor, of rank 4 or rank 3 of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is assumed.
+ * @param filterSize The filter size: `[filterHeight, filterWidth]`. If
+ * `filterSize` is a single number, then `filterHeight == filterWidth`.
+ * @param strides The strides of the pooling: `[strideHeight, strideWidth]`. If
+ * `strides` is a single number, then `strideHeight == strideWidth`.
+ * @param pad The type of padding algorithm:
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ */
+function avgPool_(x, filterSize, strides, pad, dimRoundingMode) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'avgPool', 'float32');
+ const dilations = 1;
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in avgPool: Either strides or dilations must be 1. ' +
+ `Got strides ${strides} and dilations '${dilations}'`);
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
+ }
+ util["assert"](x4D.rank === 4, () => `Error in avgPool: x must be rank 4 but got rank ${x4D.rank}.`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in avgPool: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = (backend, save) => {
+ const convInfo = computePool2DInfo(x4D.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
+ save([x4D]);
+ if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 &&
+ util["arraysEqual"](convInfo.inShape, convInfo.outShape)) {
+ return x4D.clone();
+ }
+ return backend.avgPool(x4D, convInfo);
+ };
+ const inputs = { x: x4D };
+ const attrs = { filterSize, strides, pad, dimRoundingMode };
+ let res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["d" /* AvgPool */], attrs);
+ res = cast(res, $x.dtype);
+ if (reshapedTo4D) {
+ return res.as3D(res.shape[1], res.shape[2], res.shape[3]);
+ }
+ return res;
+}
+const avgPool = Object(operation["a" /* op */])({ avgPool_ });
+//# sourceMappingURL=avg_pool.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/avg_pool_3d.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+/**
+ * Computes the 3D average pooling.
+ *
+ * ```js
+ * const x = tf.tensor5d([1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 2, 2, 1]);
+ * const result = tf.avgPool3d(x, 2, 1, 'valid');
+ * result.print();
+ * ```
+ *
+ * @param x The input tensor, of rank 5 or rank 4 of shape
+ * `[batch, depth, height, width, inChannels]`.
+ * @param filterSize The filter size:
+ * `[filterDepth, filterHeight, filterWidth]`.
+ * If `filterSize` is a single number,
+ * then `filterDepth == filterHeight == filterWidth`.
+ * @param strides The strides of the pooling:
+ * `[strideDepth, strideHeight, strideWidth]`.
+ * If `strides` is a single number,
+ * then `strideDepth == strideHeight == strideWidth`.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1*1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ * @param dataFormat An optional string from: "NDHWC", "NCDHW". Defaults to
+ * "NDHWC". Specify the data format of the input and output data. With the
+ * default format "NDHWC", the data is stored in the order of: [batch,
+ * depth, height, width, channels]. Only "NDHWC" is currently supported.
+ * @param dilations Deprecated, this field will be gone in v3.0.0.
+ * The dilation rates:
+ * `[dilationDepth, dilationHeight, dilationWidth]`
+ * in which we sample input values across the depth, height and width
+ * dimensions in dilated pooling.
+ * Defaults to `[1, 1, 1]`. If `dilations` is a single number,
+ * then `dilationDepth == dilationHeight == dilationWidth`.
+ * If it is greater than 1, then all values of `strides` must be 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function avgPool3d_(x, filterSize, strides, pad, dimRoundingMode, dataFormat = 'NDHWC', dilations) {
+ if (dilations == null) {
+ dilations = [1, 1, 1];
+ }
+ else {
+ deprecationWarn('dilations is deprecated, this field will be gone in ' +
+ 'v3.0.0.');
+ }
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'avgPool3d', 'float32');
+ let x5D = $x;
+ let reshapedTo5D = false;
+ if ($x.rank === 4) {
+ reshapedTo5D = true;
+ x5D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2], $x.shape[3]]);
+ }
+ util["assert"](x5D.rank === 5, () => `Error in avgPool3d: x must be rank 5 but got rank ${x5D.rank}.`);
+ util["assert"](dataFormat === 'NDHWC', () => `Error in avgPool3d: Only NDHWC is currently supported, ` +
+ `but got dataFormat of ${dataFormat}`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in avgPool3d: Either strides or dilations must be 1. ' +
+ `Got strides ${strides} and dilations '${dilations}'`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in avgPool3d: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = (backend, save) => {
+ if (dilations == null) {
+ dilations = [1, 1, 1];
+ }
+ const convInfo = computePool3DInfo(x5D.shape, filterSize, strides, dilations, pad, dimRoundingMode, dataFormat);
+ save([x5D]);
+ return backend.avgPool3d(x5D, convInfo);
+ };
+ const inputs = { x: x5D };
+ const attrs = { filterSize, strides, pad, dimRoundingMode, dataFormat, dilations };
+ let res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["e" /* AvgPool3D */], attrs);
+ res = cast(res, x5D.dtype);
+ if (reshapedTo5D) {
+ return res.as4D(res.shape[1], res.shape[2], res.shape[3], res.shape[4]);
+ }
+ return res;
+}
+const avgPool3d = Object(operation["a" /* op */])({ avgPool3d_ });
+//# sourceMappingURL=avg_pool_3d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm_util.js
+function xAs4D(x) {
+ let x4D;
+ if (x.rank === 0 || x.rank === 1) {
+ x4D = x.as4D(1, 1, 1, x.size);
+ }
+ else if (x.rank === 2) {
+ x4D = x.as4D(1, 1, x.shape[0], x.shape[1]);
+ }
+ else if (x.rank === 3) {
+ x4D = x.as4D(1, x.shape[0], x.shape[1], x.shape[2]);
+ }
+ else {
+ x4D = x;
+ }
+ return x4D;
+}
+//# sourceMappingURL=batchnorm_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Batch normalization.
+ *
+ * As described in
+ * [http://arxiv.org/abs/1502.03167](http://arxiv.org/abs/1502.03167).
+ *
+ * Mean, variance, scale, and offset can be of two shapes:
+ * - The same shape as the input.
+ * - In the common case, the depth dimension is the last dimension of x, so
+ * the values would be an `tf.Tensor1D` of shape [depth].
+ *
+ * Also available are stricter rank-specific methods with the same signature
+ * as this method that assert that parameters passed are of given rank
+ * - `tf.batchNorm2d`
+ * - `tf.batchNorm3d`
+ * - `tf.batchNorm4d`
+ *
+ * @param x The input Tensor.
+ * @param mean A mean Tensor.
+ * @param variance A variance Tensor.
+ * @param offset An offset Tensor.
+ * @param scale A scale Tensor.
+ * @param varianceEpsilon A small float number to avoid dividing by 0.
+ */
+/** @doc {heading: 'Operations', subheading: 'Normalization'} */
+function batchNorm_(x, mean, variance, offset, scale, varianceEpsilon) {
+ if (varianceEpsilon == null) {
+ varianceEpsilon = 0.001;
+ }
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'batchNorm');
+ const $mean = Object(tensor_util_env["a" /* convertToTensor */])(mean, 'mean', 'batchNorm');
+ const $variance = Object(tensor_util_env["a" /* convertToTensor */])(variance, 'variance', 'batchNorm');
+ let $scale;
+ if (scale != null) {
+ $scale = Object(tensor_util_env["a" /* convertToTensor */])(scale, 'scale', 'batchNorm');
+ }
+ let $offset;
+ if (offset != null) {
+ $offset = Object(tensor_util_env["a" /* convertToTensor */])(offset, 'offset', 'batchNorm');
+ }
+ util["assert"]($mean.rank === $variance.rank, () => 'Batch normalization gradient requires mean and variance to have ' +
+ 'equal ranks.');
+ util["assert"]($offset == null || $mean.rank === $offset.rank, () => 'Batch normalization gradient requires mean and offset to have ' +
+ 'equal ranks.');
+ util["assert"]($scale == null || $mean.rank === $scale.rank, () => 'Batch normalization gradient requires mean and scale to have ' +
+ 'equal ranks.');
+ const x4D = xAs4D($x);
+ const forward = (backend, save) => {
+ save([x4D, $mean, $variance, $scale]);
+ return backend.batchNorm(x4D, as1DOr4D($mean), as1DOr4D($variance), as1DOr4D($offset), as1DOr4D($scale), varianceEpsilon);
+ };
+ const inputs = {
+ x: x4D,
+ scale: $scale,
+ offset: $offset,
+ mean: $mean,
+ variance: $variance
+ };
+ const attrs = { varianceEpsilon };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["F" /* FusedBatchNorm */], attrs);
+ return reshape(res, $x.shape);
+}
+function as1DOr4D(x) {
+ if (x == null) {
+ return null;
+ }
+ if (x.rank === 0) {
+ return x.as1D();
+ }
+ else if (x.rank === 1) {
+ return x;
+ }
+ else if (x.rank === 2) {
+ return x.as4D(1, 1, x.shape[0], x.shape[1]);
+ }
+ else if (x.rank === 3) {
+ return x.as4D(1, x.shape[0], x.shape[1], x.shape[2]);
+ }
+ return x;
+}
+const batchNorm = Object(operation["a" /* op */])({ batchNorm_ });
+//# sourceMappingURL=batchnorm.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm2d.js
+
+
+
+
+/**
+ * Batch normalization, strictly for 2D. For the more relaxed version, see
+ * `tf.batchNorm`.
+ *
+ * @param x The input Tensor.
+ * @param mean A mean Tensor.
+ * @param variance A variance Tensor.
+ * @param offset An offset Tensor.
+ * @param scale A scale Tensor.
+ * @param varianceEpsilon A small float number to avoid dividing by 0.
+ */
+function batchNorm2d_(x, mean, variance, offset, scale, varianceEpsilon) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'batchNorm');
+ const $mean = Object(tensor_util_env["a" /* convertToTensor */])(mean, 'mean', 'batchNorm');
+ const $variance = Object(tensor_util_env["a" /* convertToTensor */])(variance, 'variance', 'batchNorm');
+ let $scale;
+ if (scale != null) {
+ $scale = Object(tensor_util_env["a" /* convertToTensor */])(scale, 'scale', 'batchNorm');
+ }
+ let $offset;
+ if (offset != null) {
+ $offset = Object(tensor_util_env["a" /* convertToTensor */])(offset, 'offset', 'batchNorm');
+ }
+ util["assert"]($x.rank === 2, () => `Error in batchNorm3D: x must be rank 3 but got rank ` +
+ `${$x.rank}.`);
+ util["assert"]($mean.rank === 2 || $mean.rank === 1, () => `Error in batchNorm2D: mean must be rank 2 or rank 1 but ` +
+ `got rank ${$mean.rank}.`);
+ util["assert"]($variance.rank === 2 || $variance.rank === 1, () => `Error in batchNorm2D: variance must be rank 2 or rank 1 ` +
+ `but got rank ${$variance.rank}.`);
+ if ($scale != null) {
+ util["assert"]($scale.rank === 2 || $scale.rank === 1, () => `Error in batchNorm2D: scale must be rank 2 or rank 1 ` +
+ `but got rank ${$scale.rank}.`);
+ }
+ if ($offset != null) {
+ util["assert"]($offset.rank === 2 || $offset.rank === 1, () => `Error in batchNorm2D: offset must be rank 2 or rank 1 ` +
+ `but got rank ${$offset.rank}.`);
+ }
+ return batchNorm($x, $mean, $variance, $offset, $scale, varianceEpsilon);
+}
+const batchNorm2d = Object(operation["a" /* op */])({ batchNorm2d_ });
+//# sourceMappingURL=batchnorm2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm3d.js
+
+
+
+
+/**
+ * Batch normalization, strictly for 3D. For the more relaxed version, see
+ * `tf.batchNorm`.
+ *
+ * @param x The input Tensor.
+ * @param mean A mean Tensor.
+ * @param variance A variance Tensor.
+ * @param offset An offset Tensor.
+ * @param scale A scale Tensor.
+ * @param varianceEpsilon A small float number to avoid dividing by 0.
+ */
+function batchNorm3d_(x, mean, variance, offset, scale, varianceEpsilon) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'batchNorm');
+ const $mean = Object(tensor_util_env["a" /* convertToTensor */])(mean, 'mean', 'batchNorm');
+ const $variance = Object(tensor_util_env["a" /* convertToTensor */])(variance, 'variance', 'batchNorm');
+ let $scale;
+ if (scale != null) {
+ $scale = Object(tensor_util_env["a" /* convertToTensor */])(scale, 'scale', 'batchNorm');
+ }
+ let $offset;
+ if (offset != null) {
+ $offset = Object(tensor_util_env["a" /* convertToTensor */])(offset, 'offset', 'batchNorm');
+ }
+ util["assert"]($x.rank === 3, () => `Error in batchNorm3D: x must be rank 3 but got rank ` +
+ `${$x.rank}.`);
+ util["assert"]($mean.rank === 3 || $mean.rank === 1, () => `Error in batchNorm3D: mean must be rank 3 or rank 1 but ` +
+ `got rank ${$mean.rank}.`);
+ util["assert"]($variance.rank === 3 || $variance.rank === 1, () => `Error in batchNorm3D: variance must be rank 3 or rank 1 ` +
+ `but got rank ${$variance.rank}.`);
+ if ($scale != null) {
+ util["assert"]($scale.rank === 3 || $scale.rank === 1, () => `Error in batchNorm3D: scale must be rank 3 or rank 1 ` +
+ `but got rank ${$scale.rank}.`);
+ }
+ if ($offset != null) {
+ util["assert"]($offset.rank === 3 || $offset.rank === 1, () => `Error in batchNorm3D: offset must be rank 3 or rank 1 ` +
+ `but got rank ${$offset.rank}.`);
+ }
+ return batchNorm($x, $mean, $variance, $offset, $scale, varianceEpsilon);
+}
+const batchNorm3d = Object(operation["a" /* op */])({ batchNorm3d_ });
+//# sourceMappingURL=batchnorm3d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm4d.js
+
+
+
+
+/**
+ * Batch normalization, strictly for 4D. For the more relaxed version, see
+ * `tf.batchNorm`.
+ *
+ * @param x The input Tensor.
+ * @param mean A mean Tensor.
+ * @param variance A variance Tensor.
+ * @param offset An offset Tensor.
+ * @param scale A scale Tensor.
+ * @param varianceEpsilon A small float number to avoid dividing by 0.
+ */
+function batchNorm4d_(x, mean, variance, offset, scale, varianceEpsilon) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'batchNorm');
+ const $mean = Object(tensor_util_env["a" /* convertToTensor */])(mean, 'mean', 'batchNorm');
+ const $variance = Object(tensor_util_env["a" /* convertToTensor */])(variance, 'variance', 'batchNorm');
+ let $scale;
+ if (scale != null) {
+ $scale = Object(tensor_util_env["a" /* convertToTensor */])(scale, 'scale', 'batchNorm');
+ }
+ let $offset;
+ if (offset != null) {
+ $offset = Object(tensor_util_env["a" /* convertToTensor */])(offset, 'offset', 'batchNorm');
+ }
+ util["assert"]($x.rank === 4, () => `Error in batchNorm4D: x must be rank 4 but got rank ` +
+ `${$x.rank}.`);
+ util["assert"]($mean.rank === 4 || $mean.rank === 1, () => `Error in batchNorm4D: mean must be rank 4 or rank 1 but ` +
+ `got rank ${$mean.rank}.`);
+ util["assert"]($variance.rank === 4 || $variance.rank === 1, () => `Error in batchNorm4D: variance must be rank 4 or rank 1 ` +
+ `but got rank ${$variance.rank}.`);
+ if ($scale != null) {
+ util["assert"]($scale.rank === 4 || $scale.rank === 1, () => `Error in batchNorm4D: scale must be rank 4 or rank 1 ` +
+ `but got rank ${$scale.rank}.`);
+ }
+ if ($offset != null) {
+ util["assert"]($offset.rank === 4 || $offset.rank === 1, () => `Error in batchNorm4D: offset must be rank 4 or rank 1 ` +
+ `but got rank ${$offset.rank}.`);
+ }
+ return batchNorm($x, $mean, $variance, $offset, $scale, varianceEpsilon);
+}
+const batchNorm4d = Object(operation["a" /* op */])({ batchNorm4d_ });
+//# sourceMappingURL=batchnorm4d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/clone.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Creates a new tensor with the same values and shape as the specified
+ * tensor.
+ *
+ * ```js
+ * const x = tf.tensor([1, 2]);
+ *
+ * x.clone().print();
+ * ```
+ *
+ * @param x The tensor to clone.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function clone_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'clone', null);
+ const forward = () => engine["a" /* ENGINE */].makeTensorFromDataId($x.dataId, $x.shape, $x.dtype);
+ // Note this op is called tf.identity in python. Hence the kernel name used
+ // here.
+ return engine["a" /* ENGINE */].runKernelFunc(forward, { x: $x }, null /* grad */, kernel_names["J" /* Identity */]);
+}
+const clone = Object(operation["a" /* op */])({ clone_ });
+//# sourceMappingURL=clone.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/broadcast_to.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Broadcast an array to a compatible shape NumPy-style.
+ *
+ * The tensor's shape is compared to the broadcast shape from end to beginning.
+ * Ones are prepended to the tensor's shape until is has the same length as
+ * the broadcast shape. If input.shape[i]==shape[i], the (i+1)-th axis is
+ * already broadcast-compatible. If input.shape[i]==1 and shape[i]==N, then
+ * the input tensor is tiled N times along that axis (using tf.tile).
+ *
+ * @param input The tensor that is to be broadcasted.
+ * @param shape The input is to be broadcast to this shape.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function broadcastTo_(x, shape) {
+ let input = Object(tensor_util_env["a" /* convertToTensor */])(x, 'broadcastTo', 'x');
+ const xShape = input.shape;
+ if (shape.some(d => !(d > 0) || d % 1 !== 0)) {
+ throw new Error(`broadcastTo(): Invalid broadcast shape [${shape}].`);
+ }
+ if (shape.length < input.rank) {
+ throw new Error(`broadcastTo(): shape.length=${shape.length} < input.rank=${input.rank}.`);
+ }
+ if (shape.length > input.rank) {
+ const newShape = input.shape.slice();
+ while (newShape.length < shape.length) {
+ newShape.unshift(1);
+ }
+ input = reshape(input, newShape);
+ }
+ const inputShape = input.shape;
+ const reps = Array.from(shape);
+ for (let i = shape.length - 1; i >= 0; i--) {
+ if (inputShape[i] === shape[i]) {
+ reps[i] = 1;
+ }
+ else if (input.shape[i] !== 1) {
+ throw new Error(`broadcastTo(): [${xShape}] cannot be broadcast to [${shape}].`);
+ }
+ }
+ const axes = reps.map((n, i) => n > 1 ? i : -1).filter(i => i >= 0);
+ if (axes.length === 0) {
+ return clone(input);
+ }
+ const forward = (backend) => backend.tile(input, reps);
+ const inputs = { x: input };
+ const attrs = { shape, inputShape };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["j" /* BroadcastTo */], attrs);
+}
+const broadcastTo = Object(operation["a" /* op */])({ broadcastTo_ });
+//# sourceMappingURL=broadcast_to.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/complex.js
+var complex = __webpack_require__(18);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/concat_1d.js
+
+
+/**
+ * Concatenates a list of`tf.Tensor1D`s along an axis. See `concat` for details.
+ *
+ * For example, if:
+ * A: shape(3) = |r1, g1, b1|
+ * B: shape(2) = |r2, g2|
+ * C = tf.concat1d([A, B]) == |r1, g1, b1, r2, g2|
+ *
+ * @param tensors A list of`tf.Tensor`s to concatenate.
+ * @return The concatenated array.
+ */
+function concat1d_(tensors) {
+ return concat(tensors, 0 /* axis */);
+}
+const concat1d = Object(operation["a" /* op */])({ concat1d_ });
+//# sourceMappingURL=concat_1d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/concat_2d.js
+
+
+/**
+ * Concatenates a list of`tf.Tensor2D`s along an axis. See `concat` for details.
+ *
+ * For example, if:
+ * A: shape(2, 3) = | r1, g1, b1 |
+ * | r2, g2, b2 |
+ *
+ * B: shape(2, 3) = | r3, g3, b3 |
+ * | r4, g4, b4 |
+ *
+ * C = tf.concat2d([A, B], axis)
+ *
+ * if axis = 0:
+ * C: shape(4, 3) = | r1, g1, b1 |
+ * | r2, g2, b2 |
+ * | r3, g3, b3 |
+ * | r4, g4, b4 |
+ *
+ * if axis = 1:
+ * C = shape(2, 6) = | r1, g1, b1, r3, g3, b3 |
+ * | r2, g2, b2, r4, g4, b4 |
+ *
+ *
+ * @param tensors A list of `tf.Tensor`s to concatenate.
+ * @param axis The axis to concatenate along.
+ * @return The concatenated array.
+ */
+function concat2d_(tensors, axis) {
+ return concat(tensors, axis);
+}
+const concat2d = Object(operation["a" /* op */])({ concat2d_ });
+//# sourceMappingURL=concat_2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/concat_3d.js
+
+
+/**
+ * Concatenates a list of `tf.Tensor3D`s along an axis.
+ * See `concat` for details.
+ *
+ * For example, if:
+ * A: shape(2, 1, 3) = | r1, g1, b1 |
+ * | r2, g2, b2 |
+ *
+ * B: shape(2, 1, 3) = | r3, g3, b3 |
+ * | r4, g4, b4 |
+ *
+ * C = tf.concat3d([A, B], axis)
+ *
+ * if axis = 0:
+ * C: shape(4, 1, 3) = | r1, g1, b1 |
+ * | r2, g2, b2 |
+ * | r3, g3, b3 |
+ * | r4, g4, b4 |
+ *
+ * if axis = 1:
+ * C: shape(2, 2, 3) = | r1, g1, b1, r3, g3, b3 |
+ * | r2, g2, b2, r4, g4, b4 |
+ *
+ * if axis = 2:
+ * C = shape(2, 1, 6) = | r1, g1, b1, r3, g3, b3 |
+ * | r2, g2, b2, r4, g4, b4 |
+ *
+ * @param tensors A list of`tf.Tensor`s to concatenate.
+ * @param axis The axis to concate along.
+ * @return The concatenated array.
+ */
+function concat3d_(tensors, axis) {
+ return concat(tensors, axis);
+}
+const concat3d = Object(operation["a" /* op */])({ concat3d_ });
+//# sourceMappingURL=concat_3d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/concat_4d.js
+
+
+/**
+ * Concatenates a list of `tf.Tensor4D`s along an axis.
+ * See `concat` for details.
+ *
+ * @param tensors A list of `tf.Tensor`s to concatenate.
+ * @param axis The axis to concate along.
+ * @return The concatenated array.
+ */
+function concat4d_(tensors, axis) {
+ return concat(tensors, axis);
+}
+const concat4d = Object(operation["a" /* op */])({ concat4d_ });
+//# sourceMappingURL=concat_4d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv1d.js
+
+
+
+
+
+
+/**
+ * Computes a 1D convolution over the input x.
+ *
+ * @param x The input tensor, of rank 3 or rank 2, of shape
+ * `[batch, width, inChannels]`. If rank 2, batch of 1 is assumed.
+ * @param filter The filter, rank 3, of shape
+ * `[filterWidth, inDepth, outDepth]`.
+ * @param stride The number of entries by which the filter is moved right at
+ * each step.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dataFormat An optional string from "NWC", "NCW". Defaults to "NWC",
+ * the data is stored in the order of [batch, in_width, in_channels]. Only
+ * "NWC" is currently supported.
+ * @param dilation The dilation rate in which we sample input values in
+ * atrous convolution. Defaults to `1`. If it is greater than 1, then
+ * stride must be `1`.
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function conv1d_(x, filter, stride, pad, dataFormat = 'NWC', dilation = 1, dimRoundingMode) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'conv1d');
+ const $filter = Object(tensor_util_env["a" /* convertToTensor */])(filter, 'filter', 'conv1d');
+ let x3D = $x;
+ let reshapedTo3D = false;
+ if ($x.rank === 2) {
+ reshapedTo3D = true;
+ x3D = reshape($x, [1, $x.shape[0], $x.shape[1]]);
+ }
+ util["assert"](x3D.rank === 3, () => `Error in conv1d: input must be rank 3, but got rank ${x3D.rank}.`);
+ util["assert"]($filter.rank === 3, () => `Error in conv1d: filter must be rank 3, but got rank ` +
+ `${$filter.rank}.`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in conv1d: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ util["assert"](x3D.shape[2] === $filter.shape[1], () => `Error in conv1d: depth of input (${x3D.shape[2]}) must match ` +
+ `input depth for filter ${$filter.shape[1]}.`);
+ util["assert"](eitherStridesOrDilationsAreOne(stride, dilation), () => 'Error in conv1D: Either stride or dilation must be 1. ' +
+ `Got stride ${stride} and dilation '${dilation}'`);
+ util["assert"](dataFormat === 'NWC', () => `Error in conv1d: got dataFormat of ${dataFormat} but only NWC is currently supported.`);
+ const filter4D = reshape($filter, [1, $filter.shape[0], $filter.shape[1], $filter.shape[2]]);
+ const input4D = reshape(x3D, [x3D.shape[0], 1, x3D.shape[1], x3D.shape[2]]);
+ const strides = [1, stride];
+ const dilations = [1, dilation];
+ const conv2dDataFormat = 'NHWC';
+ const res = conv2d(input4D, filter4D, strides, pad, conv2dDataFormat, dilations, dimRoundingMode);
+ if (reshapedTo3D) {
+ return reshape(res, [res.shape[2], res.shape[3]]);
+ }
+ return reshape(res, [res.shape[0], res.shape[2], res.shape[3]]);
+}
+const conv1d = Object(operation["a" /* op */])({ conv1d_ });
+//# sourceMappingURL=conv1d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv2d_transpose.js
+
+
+
+/**
+ * Computes the transposed 2D convolution of an image, also known as a
+ * deconvolution.
+ *
+ * @param x The input image, of rank 4 or rank 3, of shape
+ * `[batch, height, width, inDepth]`. If rank 3, batch of 1 is assumed.
+ * @param filter The filter, rank 4, of shape
+ * `[filterHeight, filterWidth, outDepth, inDepth]`.
+ * `inDepth` must match `inDepth` in `x`.
+ * @param outputShape Output shape, of rank 4 or rank 3:
+ * `[batch, height, width, outDepth]`. If rank 3, batch of 1 is assumed.
+ * @param strides The strides of the original convolution:
+ * `[strideHeight, strideWidth]`.
+ * @param pad The type of padding algorithm used in the non-transpose version
+ * of the op.
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function conv2dTranspose_(x, filter, outputShape, strides, pad, dimRoundingMode) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'conv2dTranspose');
+ const $filter = Object(tensor_util_env["a" /* convertToTensor */])(filter, 'filter', 'conv2dTranspose');
+ return conv2DBackpropInput(outputShape, $x, $filter, strides, pad, 'NHWC', dimRoundingMode);
+}
+const conv2dTranspose = Object(operation["a" /* op */])({ conv2dTranspose_ });
+//# sourceMappingURL=conv2d_transpose.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv3d.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+/**
+ * Computes a 3D convolution over the input x.
+ *
+ * @param x The input tensor, of rank 5 or rank 4, of shape
+ * `[batch, depth, height, width, channels]`. If rank 4,
+ * batch of 1 is assumed.
+ * @param filter The filter, rank 5, of shape
+ * `[filterDepth, filterHeight, filterWidth, inChannels, outChannels]`.
+ * inChannels must match between input and filter.
+ * @param strides The strides of the convolution: `[strideDepth, strideHeight,
+ * strideWidth]`.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dataFormat: An optional string from: "NDHWC", "NCDHW". Defaults to
+ * "NDHWC". Specify the data format of the input and output data. With the
+ * default format "NDHWC", the data is stored in the order of: [batch,
+ * depth, height, width, channels]. Only "NDHWC" is currently supported.
+ * @param dilations The dilation rates: `[dilationDepth, dilationHeight,
+ * dilationWidth]` in which we sample input values across the height
+ * and width dimensions in atrous convolution. Defaults to `[1, 1, 1]`.
+ * If `dilations` is a single number, then
+ * `dilationDepth == dilationHeight == dilationWidth`. If it is greater
+ * than 1, then all values of `strides` must be 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function conv3d_(x, filter, strides, pad, dataFormat = 'NDHWC', dilations = [1, 1, 1]) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'conv3d');
+ const $filter = Object(tensor_util_env["a" /* convertToTensor */])(filter, 'filter', 'conv3d');
+ let x5D = $x;
+ let reshapedTo5D = false;
+ if ($x.rank === 4) {
+ reshapedTo5D = true;
+ x5D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2], $x.shape[3]]);
+ }
+ util["assert"](x5D.rank === 5, () => `Error in conv3d: input must be rank 5, but got rank ${x5D.rank}.`);
+ util["assert"]($filter.rank === 5, () => `Error in conv3d: filter must be rank 5, but got rank ` +
+ `${$filter.rank}.`);
+ util["assert"](x5D.shape[4] === $filter.shape[3], () => `Error in conv3d: depth of input (${x5D.shape[4]}) must match ` +
+ `input depth for filter ${$filter.shape[3]}.`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in conv3D: Either strides or dilations must be 1. ' +
+ `Got strides ${strides} and dilations '${dilations}'`);
+ util["assert"](dataFormat === 'NDHWC', () => `Error in conv3d: got dataFormat of ${dataFormat} but only NDHWC is currently supported.`);
+ const forward = (backend, save) => {
+ const convInfo = computeConv3DInfo(x5D.shape, $filter.shape, strides, dilations, pad);
+ const res = backend.conv3d(x5D, $filter, convInfo);
+ save([x5D, $filter]);
+ return res;
+ };
+ const inputs = { x: x5D, filter: $filter };
+ const attrs = { strides, pad, dataFormat, dilations };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["p" /* Conv3D */], attrs);
+ if (reshapedTo5D) {
+ return res.as4D(res.shape[1], res.shape[2], res.shape[3], res.shape[4]);
+ }
+ return res;
+}
+const conv3d = Object(operation["a" /* op */])({ conv3d_ });
+//# sourceMappingURL=conv3d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/conv3d_transpose.js
+
+
+
+/**
+ * Computes the transposed 3D convolution of a volume, also known as a
+ * deconvolution.
+ *
+ * @param x The input image, of rank 5 or rank 4, of shape
+ * `[batch, depth, height, width, inDepth]`. If rank 4, batch of 1 is assumed.
+ * @param filter The filter, rank 4, of shape
+ * `[depth, filterHeight, filterWidth, outDepth, inDepth]`.
+ * `inDepth` must match `inDepth` in `x`.
+ * @param outputShape Output shape, of rank 5 or rank 4:
+ * `[batch, depth, height, width, outDepth]`. If rank 3, batch of 1 is
+ * assumed.
+ * @param strides The strides of the original convolution:
+ * `[strideDepth, strideHeight, strideWidth]`.
+ * @param pad The type of padding algorithm used in the non-transpose version
+ * of the op.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function conv3dTranspose_(x, filter, outputShape, strides, pad) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'conv3dTranspose');
+ const $filter = Object(tensor_util_env["a" /* convertToTensor */])(filter, 'filter', 'conv3dTranspose');
+ return conv3DBackpropInput(outputShape, $x, $filter, strides, pad);
+}
+const conv3dTranspose = Object(operation["a" /* op */])({ conv3dTranspose_ });
+//# sourceMappingURL=conv3d_transpose.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/depth_to_space.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Rearranges data from depth into blocks of spatial data. More specifically,
+ * this op outputs a copy of the input tensor where values from the `depth`
+ * dimension are moved in spatial blocks to the `height` and `width` dimensions.
+ * The attr `blockSize` indicates the input block size and how the data is
+ * moved.
+ *
+ * - Chunks of data of size `blockSize * blockSize` from depth are rearranged
+ * into non-overlapping blocks of size `blockSize x blockSize`
+ *
+ * - The width the output tensor is `inputWidth * blockSize`, whereas the
+ * height is `inputHeight * blockSize`
+ *
+ * - The Y, X coordinates within each block of the output image are determined
+ * by the high order component of the input channel index
+ *
+ * - The depth of the input tensor must be divisible by `blockSize *
+ * blockSize`
+ *
+ * The `dataFormat` attr specifies the layout of the input and output tensors
+ * with the following options: "NHWC": [ `batch, height, width, channels` ]
+ * "NCHW": [ `batch, channels, height, width` ]
+ *
+ * ```js
+ * const x = tf.tensor4d([1, 2, 3, 4], [1, 1, 1, 4]);
+ * const blockSize = 2;
+ * const dataFormat = "NHWC";
+ *
+ * tf.depthToSpace(x, blockSize, dataFormat).print();
+ * ```
+ *
+ * @param x The input tensor of rank 4
+ * @param blockSIze An `int` that is `>= 2`. The size of the spatial block
+ * @param dataFormat An optional string from: "NHWC", "NCHW". Defaults to "NHWC"
+ */
+/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
+function depthToSpace_(x, blockSize, dataFormat = 'NHWC') {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'depthToSpace');
+ const inputHeight = (dataFormat === 'NHWC') ? $x.shape[1] : $x.shape[2];
+ const inputWidth = (dataFormat === 'NHWC') ? $x.shape[2] : $x.shape[3];
+ const inputDepth = (dataFormat === 'NHWC') ? $x.shape[3] : $x.shape[1];
+ util["assert"](inputHeight * blockSize >= 0, () => `Negative dimension size caused by overflow when multiplying
+ ${inputHeight} and ${blockSize} for depthToSpace with input shape
+ ${$x.shape}`);
+ util["assert"](inputWidth * blockSize >= 0, () => `Negative dimension size caused by overflow when multiplying
+ ${inputWidth} and ${blockSize} for depthToSpace with input shape
+ ${$x.shape}`);
+ util["assert"]((inputDepth % (blockSize * blockSize) === 0), () => `Dimension size must be evenly divisible by ${blockSize * blockSize} but is ${inputDepth} for depthToSpace with input shape ${$x.shape}`);
+ const forward = backend => backend.depthToSpace($x, blockSize, dataFormat);
+ const inputs = { x: $x };
+ const attrs = { blockSize, dataFormat };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["t" /* DepthToSpace */], attrs);
+}
+const depthToSpace = Object(operation["a" /* op */])({ depthToSpace_ });
+//# sourceMappingURL=depth_to_space.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/depthwise_conv2d.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Depthwise 2D convolution.
+ *
+ * Given a 4D `input` array and a `filter` array of shape
+ * `[filterHeight, filterWidth, inChannels, channelMultiplier]` containing
+ * `inChannels` convolutional filters of depth 1, this op applies a
+ * different filter to each input channel (expanding from 1 channel to
+ * `channelMultiplier` channels for each), then concatenates the results
+ * together. The output has `inChannels * channelMultiplier` channels.
+ *
+ * See
+ * [https://www.tensorflow.org/api_docs/python/tf/nn/depthwise_conv2d](
+ * https://www.tensorflow.org/api_docs/python/tf/nn/depthwise_conv2d)
+ * for more details.
+ *
+ * @param x The input tensor, of rank 4 or rank 3, of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is
+ * assumed.
+ * @param filter The filter tensor, rank 4, of shape
+ * `[filterHeight, filterWidth, inChannels, channelMultiplier]`.
+ * @param strides The strides of the convolution: `[strideHeight,
+ * strideWidth]`. If strides is a single number, then `strideHeight ==
+ * strideWidth`.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
+ * in which we sample input values across the height and width dimensions
+ * in atrous convolution. Defaults to `[1, 1]`. If `rate` is a single
+ * number, then `dilationHeight == dilationWidth`. If it is greater than
+ * 1, then all values of `strides` must be 1.
+ * @param dataFormat: An optional string from: "NHWC", "NCHW". Defaults to
+ * "NHWC". Specify the data format of the input and output data. With the
+ * default format "NHWC", the data is stored in the order of: [batch,
+ * height, width, channels]. Only "NHWC" is currently supported.
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function depthwiseConv2d_(x, filter, strides, pad, dataFormat = 'NHWC', dilations = [1, 1], dimRoundingMode) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'depthwiseConv2d');
+ const $filter = Object(tensor_util_env["a" /* convertToTensor */])(filter, 'filter', 'depthwiseConv2d');
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
+ }
+ util["assert"](x4D.rank === 4, () => `Error in depthwiseConv2d: input must be rank 4, but got ` +
+ `rank ${x4D.rank}.`);
+ util["assert"]($filter.rank === 4, () => `Error in depthwiseConv2d: filter must be rank 4, but got rank ` +
+ `${$filter.rank}.`);
+ util["assert"](x4D.shape[3] === $filter.shape[2], () => `Error in depthwiseConv2d: number of input channels ` +
+ `(${x4D.shape[3]}) must match the inChannels dimension in ` +
+ `filter ${$filter.shape[2]}.`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in depthwiseConv2d: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = (backend, save) => {
+ if (dilations == null) {
+ dilations = [1, 1];
+ }
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in depthwiseConv2d: Either strides or dilations must be ' +
+ `1. Got strides ${strides} and dilations '${dilations}'`);
+ const convInfo = computeConv2DInfo(x4D.shape, $filter.shape, strides, dilations, pad, dimRoundingMode, true /* depthwise */);
+ const res = backend.depthwiseConv2D(x4D, $filter, convInfo);
+ save([x4D, $filter]);
+ return res;
+ };
+ const inputs = { x: x4D, filter: $filter };
+ const attrs = { strides, pad, dataFormat, dilations, dimRoundingMode };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["u" /* DepthwiseConv2dNative */], attrs);
+ if (reshapedTo4D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
+ }
+ return res;
+}
+const depthwiseConv2d = Object(operation["a" /* op */])({ depthwiseConv2d_ });
+//# sourceMappingURL=depthwise_conv2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/diag.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Returns a diagonal tensor with a given diagonal values.
+ *
+ * Given a diagonal, this operation returns a tensor with the diagonal and
+ * everything else padded with zeros.
+ *
+ * Assume the input has dimensions `[D1,..., Dk]`, then the output is a tensor
+ * of rank 2k with dimensions `[D1,..., Dk, D1,..., Dk]`
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ *
+ * tf.diag(x).print()
+ * ```
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4, 5, 6, 6, 8], [4, 2])
+ *
+ * tf.diag(x).print()
+ * ```
+ * @param x The input tensor.
+ */
+function diag_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'diag').flatten();
+ const forward = backend => {
+ const result = backend.diag($x);
+ const outShape = [...x.shape, ...x.shape];
+ return reshape(result, outShape);
+ };
+ const inputs = { x: $x };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["x" /* Diag */]);
+}
+const diag = Object(operation["a" /* op */])({ diag_ });
+//# sourceMappingURL=diag.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/div_no_nan.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Divides two `tf.Tensor`s element-wise, A / B. Supports broadcasting. Return 0
+ * if denominator is 0.
+ *
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 4, 9, 16]);
+ * const b = tf.tensor1d([1, 2, 3, 4]);
+ * const c = tf.tensor1d([0, 0, 0, 0]);
+ *
+ * a.divNoNan(b).print(); // or tf.divNoNan(a, b)
+ * a.divNoNan(c).print(); // or tf.divNoNan(a, c)
+ * ```
+ *
+ * ```js
+ * // Broadcast div a with b.
+ * const a = tf.tensor1d([2, 4, 6, 8]);
+ * const b = tf.scalar(2);
+ * const c = tf.scalar(0);
+ *
+ * a.divNoNan(b).print(); // or tf.divNoNan(a, b)
+ * a.divNoNan(c).print(); // or tf.divNoNan(a, c)
+ * ```
+ *
+ * @param a The first tensor as the numerator.
+ * @param b The second tensor as the denominator. Must have the same dtype as
+ * `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function divNoNan_(a, b) {
+ // TODO: Make this into its own kernel.
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'div');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'div');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ const divResult = div($a, $b);
+ const zeros = Object(tensor_ops["o" /* zerosLike */])(divResult);
+ const bEqualsZero = $b.equal(zeros);
+ return where(bEqualsZero, zeros, divResult);
+}
+const divNoNan = Object(operation["a" /* op */])({ divNoNan_ });
+//# sourceMappingURL=div_no_nan.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/dot.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Computes the dot product of two matrices and/or vectors, `t1` and `t2`.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2]);
+ * const b = tf.tensor2d([[1, 2], [3, 4]]);
+ * const c = tf.tensor2d([[1, 2, 3], [4, 5, 6]]);
+ *
+ * a.dot(b).print(); // or tf.dot(a, b)
+ * b.dot(a).print();
+ * b.dot(c).print();
+ * ```
+ * @param t1 The first tensor in the dot operation.
+ * @param t2 The second tensor in the dot operation.
+ */
+/** @doc {heading: 'Operations', subheading: 'Matrices'} */
+function dot_(t1, t2) {
+ const $t1 = Object(tensor_util_env["a" /* convertToTensor */])(t1, 't1', 'dot');
+ const $t2 = Object(tensor_util_env["a" /* convertToTensor */])(t2, 't2', 'dot');
+ util["assert"](($t1.rank === 1 || $t1.rank === 2) && ($t2.rank === 1 || $t2.rank === 2), () => `Error in dot: inputs must all be rank 1 or 2, but got ranks ` +
+ `${$t1.rank} and ${$t2.rank}.`);
+ const t1Inner = ($t1.rank === 1 ? $t1.size : $t1.shape[1]);
+ const t2Inner = ($t2.rank === 1 ? $t2.size : $t2.shape[0]);
+ util["assert"](t1Inner === t2Inner, () => `Error in dot: inner dimensions of inputs must match, but got ` +
+ `${t1Inner} and ${t2Inner}.`);
+ if ($t1.rank === 1 && $t2.rank === 1) {
+ const t12D = reshape($t1, [1, -1]);
+ const t22D = reshape($t2, [-1, 1]);
+ const t1t2 = matMul(t12D, t22D);
+ return reshape(t1t2, []);
+ }
+ else if ($t1.rank === 1 && $t2.rank === 2) {
+ const t12D = reshape($t1, [1, -1]);
+ const t22D = reshape($t2, [$t2.shape[0], $t2.shape[1]]);
+ const t1t2 = matMul(t12D, t22D);
+ return reshape(t1t2, [t1t2.size]);
+ }
+ else if ($t1.rank === 2 && $t2.rank === 1) {
+ const t22D = reshape($t2, [-1, 1]);
+ const t1t2 = matMul($t1, t22D);
+ return reshape(t1t2, [t1t2.size]);
+ }
+ else {
+ const t22D = reshape($t2, [$t2.shape[0], $t2.shape[1]]);
+ const t1t2 = matMul($t1, t22D);
+ return t1t2;
+ }
+}
+const dot = Object(operation["a" /* op */])({ dot_ });
+//# sourceMappingURL=dot.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/elu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Computes exponential linear element-wise: `x > 0 ? e ^ x - 1 : 0`.
+ *
+ * ```js
+ * const x = tf.tensor1d([-1, 1, -3, 2]);
+ *
+ * x.elu().print(); // or tf.elu(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function elu_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'elu');
+ const forward = (backend, save) => {
+ const y = backend.elu($x);
+ save([y]);
+ return y;
+ };
+ const inputs = { x: $x };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["z" /* Elu */]);
+}
+const elu = Object(operation["a" /* op */])({ elu_ });
+//# sourceMappingURL=elu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/equal.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Returns the truth value of (a == b) element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ * const b = tf.tensor1d([2, 2, 2]);
+ *
+ * a.equal(b).print();
+ * ```
+ *
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same dtype as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function equal_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'equal');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'equal');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = backend => backend.equal($a, $b);
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null, kernel_names["B" /* Equal */]);
+}
+const equal = Object(operation["a" /* op */])({ equal_ });
+//# sourceMappingURL=equal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/eye.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Create an identity matrix.
+ *
+ * @param numRows Number of rows.
+ * @param numColumns Number of columns. Defaults to `numRows`.
+ * @param batchShape If provided, will add the batch shape to the beginning
+ * of the shape of the returned `tf.Tensor` by repeating the identity
+ * matrix.
+ * @param dtype Data type.
+ * @returns Identity matrix of the specified size and data type, possibly
+ * with batch repetition if `batchShape` is specified.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function eye_(numRows, numColumns, batchShape, dtype = 'float32') {
+ if (numColumns == null) {
+ numColumns = numRows;
+ }
+ const buff = array_ops_buffer([numRows, numColumns], dtype);
+ const n = numRows <= numColumns ? numRows : numColumns;
+ for (let i = 0; i < n; ++i) {
+ buff.set(1, i, i);
+ }
+ const out = buff.toTensor().as2D(numRows, numColumns);
+ if (batchShape == null) {
+ return out;
+ }
+ else {
+ if (batchShape.length === 1) {
+ return tile(expandDims(out, 0), [batchShape[0], 1, 1]);
+ }
+ else if (batchShape.length === 2) {
+ return tile(expandDims(expandDims(out, 0), 0), [batchShape[0], batchShape[1], 1, 1]);
+ }
+ else if (batchShape.length === 3) {
+ return tile(expandDims(expandDims(expandDims(out, 0), 0), 0), [batchShape[0], batchShape[1], batchShape[2], 1, 1]);
+ }
+ else {
+ throw new Error(`eye() currently supports only 1D and 2D ` +
+ // tslint:disable-next-line:no-any
+ `batchShapes, but received ${batchShape.length}D.`);
+ }
+ }
+}
+const eye = Object(operation["a" /* op */])({ eye_ });
+//# sourceMappingURL=eye.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/fill.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+/**
+ * Creates a `tf.Tensor` filled with a scalar value.
+ *
+ * ```js
+ * tf.fill([2, 2], 4).print();
+ * ```
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param value The scalar value to fill the tensor with.
+ * @param dtype The type of an element in the resulting tensor. Defaults to
+ * 'float'.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function fill(shape, value, dtype) {
+ const attrs = { shape, value, dtype };
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.fill(shape, value, dtype), {}, null, kernel_names["C" /* Fill */], attrs);
+}
+
+//# sourceMappingURL=fill.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/imag.js
+var imag = __webpack_require__(25);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/maximum.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Returns the max of a and b (`a > b ? a : b`) element-wise.
+ * Supports broadcasting.
+ *
+ * We also expose `tf.maximumStrict` which has the same signature as this op and
+ * asserts that `a` and `b` are the same shape (does not broadcast).
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 4, 3, 16]);
+ * const b = tf.tensor1d([1, 2, 9, 4]);
+ *
+ * a.maximum(b).print(); // or tf.maximum(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast maximum a with b.
+ * const a = tf.tensor1d([2, 4, 6, 8]);
+ * const b = tf.scalar(5);
+ *
+ * a.maximum(b).print(); // or tf.maximum(a, b)
+ * ```
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same type as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function maximum_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'maximum');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'maximum');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ if ($a.dtype === 'bool') {
+ $a = cast($a, 'int32');
+ $b = cast($b, 'int32');
+ }
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = (backend, save) => {
+ const res = backend.maximum($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["V" /* Maximum */]);
+}
+const maximum = Object(operation["a" /* op */])({ maximum_ });
+//# sourceMappingURL=maximum.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/leaky_relu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Computes leaky rectified linear element-wise.
+ *
+ * See
+ * [http://web.stanford.edu/~awni/papers/relu_hybrid_icml2013_final.pdf](
+ * http://web.stanford.edu/~awni/papers/relu_hybrid_icml2013_final.pdf)
+ *
+ * ```js
+ * const x = tf.tensor1d([-1, 2, -3, 4]);
+ *
+ * x.leakyRelu(0.1).print(); // or tf.leakyRelu(x, 0.1)
+ * ```
+ * @param x The input tensor.
+ * @param alpha The scaling factor for negative values, defaults to 0.2.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function leakyRelu_(x, alpha = 0.2) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'leakyRelu');
+ return maximum(mul(Object(tensor_ops["e" /* scalar */])(alpha), $x), $x);
+}
+const leakyRelu = Object(operation["a" /* op */])({ leakyRelu_ });
+//# sourceMappingURL=leaky_relu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/local_response_normalization.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Normalizes the activation of a local neighborhood across or within
+ * channels.
+ *
+ * @param x The input tensor. The 4-D input tensor is treated as a 3-D array
+ * of 1D vectors (along the last dimension), and each vector is
+ * normalized independently.
+ * @param depthRadius The number of adjacent channels in the 1D normalization
+ * window.
+ * @param bias A constant bias term for the basis.
+ * @param alpha A scale factor, usually positive.
+ * @param beta An exponent.
+ */
+/** @doc {heading: 'Operations', subheading: 'Normalization'} */
+function localResponseNormalization_(x, depthRadius = 5, bias = 1, alpha = 1, beta = 0.5) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'localResponseNormalization');
+ util["assert"]($x.rank === 4 || $x.rank === 3, () => `Error in localResponseNormalization: x must be rank 3 or 4 but got
+ rank ${$x.rank}.`);
+ util["assert"](util["isInt"](depthRadius), () => `Error in localResponseNormalization: depthRadius must be an ` +
+ `integer but got depthRadius ${depthRadius}.`);
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
+ }
+ const forward = (backend, save) => {
+ const y = backend.localResponseNormalization4D(x4D, depthRadius, bias, alpha, beta);
+ save([x4D, y]);
+ return y;
+ };
+ const inputs = { x: x4D };
+ const attrs = { depthRadius, bias, alpha, beta };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["L" /* LRN */], attrs);
+ if (reshapedTo4D) {
+ return res.as3D(res.shape[1], res.shape[2], res.shape[3]);
+ }
+ else {
+ return res;
+ }
+}
+const localResponseNormalization = Object(operation["a" /* op */])({ localResponseNormalization_ });
+//# sourceMappingURL=local_response_normalization.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/max.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+/**
+ * Computes the maximum of elements across dimensions of a `tf.Tensor`.
+ *
+ * Reduces the input along the dimensions given in `axes`. Unless `keepDims`
+ * is true, the rank of the `tf.Tensor` is reduced by 1 for each entry in
+ * `axes`. If `keepDims` is true, the reduced dimensions are retained with
+ * length 1. If `axes` has no entries, all dimensions are reduced, and an
+ * `tf.Tensor` with a single element is returned.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3]);
+ *
+ * x.max().print(); // or tf.max(x)
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * const axis = 1;
+ * x.max(axis).print(); // or tf.max(x, axis)
+ * ```
+ *
+ * @param x The input tensor.
+ * @param axis The dimension(s) to reduce. By default it reduces
+ * all dimensions.
+ * @param keepDims If true, retains reduced dimensions with size 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Reduction'} */
+function max_(x, axis = null, keepDims = false) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'max');
+ const forward = (backend, save) => {
+ const origAxes = util["parseAxisParam"](axis, $x.shape);
+ let axes = origAxes;
+ const permutedAxes = getAxesPermutation(axes, $x.rank);
+ let maxInput = $x;
+ if (permutedAxes != null) {
+ maxInput = transpose($x, permutedAxes);
+ axes = getInnerMostAxes(axes.length, maxInput.rank);
+ }
+ const y = backend.max(maxInput, axes);
+ save([$x, y]);
+ if (permutedAxes != null) {
+ backend.disposeData(maxInput.dataId);
+ }
+ return y;
+ };
+ const inputs = { x: $x };
+ const attrs = { reductionIndices: axis, keepDims };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["P" /* Max */], attrs);
+ if (keepDims) {
+ return reshape(res, expandShapeToKeepDim(res.shape, util["parseAxisParam"](axis, $x.shape)));
+ }
+ return res;
+}
+const max_max = Object(operation["a" /* op */])({ max_ });
+//# sourceMappingURL=max.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/max_pool.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Computes the 2D max pooling of an image.
+ *
+ * @param x The input tensor, of rank 4 or rank 3 of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is assumed.
+ * @param filterSize The filter size: `[filterHeight, filterWidth]`. If
+ * `filterSize` is a single number, then `filterHeight == filterWidth`.
+ * @param strides The strides of the pooling: `[strideHeight, strideWidth]`. If
+ * `strides` is a single number, then `strideHeight == strideWidth`.
+ * @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
+ * in which we sample input values across the height and width dimensions
+ * in dilated pooling. Defaults to `[1, 1]`. If `dilations` is a single
+ * number, then `dilationHeight == dilationWidth`. If it is greater than
+ * 1, then all values of `strides` must be 1.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ */
+function maxPool_(x, filterSize, strides, pad, dimRoundingMode) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'maxPool');
+ const dilations = 1;
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
+ }
+ util["assert"](x4D.rank === 4, () => `Error in maxPool: input must be rank 4 but got rank ${x4D.rank}.`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool: Either strides or dilations must be 1. ' +
+ `Got strides ${strides} and dilations '${dilations}'`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in maxPool: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = (backend, save) => {
+ const convInfo = computePool2DInfo(x4D.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
+ let y;
+ if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 &&
+ util["arraysEqual"](convInfo.inShape, convInfo.outShape)) {
+ y = x4D.clone();
+ }
+ else {
+ y = backend.maxPool(x4D, convInfo);
+ }
+ save([x4D, y]);
+ return y;
+ };
+ const inputs = { x: x4D };
+ const attrs = { filterSize, strides, pad, dimRoundingMode };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["Q" /* MaxPool */], attrs);
+ if (reshapedTo4D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
+ }
+ return res;
+}
+const maxPool = Object(operation["a" /* op */])({ maxPool_ });
+//# sourceMappingURL=max_pool.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/max_pool_3d.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+/**
+ * Computes the 3D max pooling.
+ *
+ * ```js
+ * const x = tf.tensor5d([1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 2, 2, 1]);
+ * const result = tf.maxPool3d(x, 2, 1, 'valid');
+ * result.print();
+ * ```
+ *
+ * @param x The input tensor, of rank 5 or rank 4 of shape
+ * `[batch, depth, height, width, inChannels]`.
+ * @param filterSize The filter size:
+ * `[filterDepth, filterHeight, filterWidth]`.
+ * If `filterSize` is a single number,
+ * then `filterDepth == filterHeight == filterWidth`.
+ * @param strides The strides of the pooling:
+ * `[strideDepth, strideHeight, strideWidth]`.
+ * If `strides` is a single number,
+ * then `strideDepth == strideHeight == strideWidth`.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1*1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ * @param dataFormat An optional string from: "NDHWC", "NCDHW". Defaults to
+ * "NDHWC". Specify the data format of the input and output data. With the
+ * default format "NDHWC", the data is stored in the order of: [batch,
+ * depth, height, width, channels]. Only "NDHWC" is currently supported.
+ * @param dilations Deprecated, this field will be gone in v3.0.0.
+ * The dilation rates: `[dilationDepth, dilationHeight, dilationWidth]`
+ * in which we sample input values across the depth, height and width
+ * dimensions in dilated pooling.
+ * Defaults to `[1, 1, 1]`. If `dilations` is a single number,
+ * then `dilationDepth == dilationHeight == dilationWidth`.
+ * If it is greater than 1, then all values of `strides` must be 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function maxPool3d_(x, filterSize = [1, 1, 1], strides, pad, dimRoundingMode, dataFormat = 'NDHWC', dilations) {
+ if (dilations == null) {
+ dilations = [1, 1, 1];
+ }
+ else {
+ deprecationWarn('dilations is deprecated, this field will be gone in ' +
+ 'v3.0.0.');
+ }
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'maxPool3d');
+ let x5D = $x;
+ let reshapedTo5D = false;
+ if ($x.rank === 4) {
+ reshapedTo5D = true;
+ x5D = $x.as5D(1, $x.shape[0], $x.shape[1], $x.shape[2], $x.shape[3]);
+ }
+ util["assert"](x5D.rank === 5, () => `Error in maxPool3d: x must be rank 5 but got rank ${x5D.rank}.`);
+ util["assert"](dataFormat === 'NDHWC', () => `Error in maxPool3d: Only NDHWC is currently supported, ` +
+ `but got dataFormat of ${dataFormat}`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool3d: Either strides or dilations must be 1. ' +
+ `Got strides ${strides} and dilations '${dilations}'`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in maxPool3d: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const forward = (backend, save) => {
+ if (dilations == null) {
+ dilations = [1, 1, 1];
+ }
+ const convInfo = computePool3DInfo(x5D.shape, filterSize, strides, dilations, pad, dimRoundingMode, dataFormat);
+ const y = backend.maxPool3d(x5D, convInfo);
+ save([x5D, y]);
+ return y;
+ };
+ const inputs = { x: x5D };
+ const attrs = { filterSize, strides, pad, dimRoundingMode, dataFormat, dilations };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["R" /* MaxPool3D */], attrs);
+ if (reshapedTo5D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+ }
+ return res;
+}
+const maxPool3d = Object(operation["a" /* op */])({ maxPool3d_ });
+//# sourceMappingURL=max_pool_3d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/max_pool_with_argmax.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Computes the 2D max pooling of an image with Argmax index.
+ * The indices in argmax are flattened, so that a maximum value at position `[b,
+ * y, x, c]` becomes flattened index: `(y * width + x) * channels + c` if
+ * include_batch_in_index is False; `((b * height + y) * width + x) * channels
+ * +c` if include_batch_in_index is True.
+ *
+ * The indices returned are always in `[0, height) x [0, width)` before
+ * flattening.
+ *
+ * @param x The input tensor, of rank 4 or rank 3 of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is assumed.
+ * @param filterSize The filter size: `[filterHeight, filterWidth]`. If
+ * `filterSize` is a single number, then `filterHeight == filterWidth`.
+ * @param strides The strides of the pooling: `[strideHeight, strideWidth]`. If
+ * `strides` is a single number, then `strideHeight == strideWidth`.
+ * @param dataFormat An optional string from: "NDHWC", "NCDHW". Defaults to
+ * "NDHWC". Specify the data format of the input and output data. With the
+ * default format "NDHWC", the data is stored in the order of: [batch,
+ * depth, height, width, channels]. Only "NDHWC" is currently supported.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param includeBatchIndex Defaults to False. Whether to include batch
+ * dimension in flattened index of argmax.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function maxPoolWithArgmax_(x, filterSize, strides, pad, includeBatchInIndex = false) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'maxPoolWithArgmax');
+ const inputs = { x: $x };
+ const attrs = { filterSize, strides, pad, includeBatchInIndex };
+ const result = engine["a" /* ENGINE */].runKernel(kernel_names["U" /* MaxPoolWithArgmax */], inputs, attrs);
+ return { result: result[0], indexes: result[1] };
+}
+const maxPoolWithArgmax = Object(operation["a" /* op */])({ maxPoolWithArgmax_ });
+//# sourceMappingURL=max_pool_with_argmax.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/minimum.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Returns the min of a and b (`a < b ? a : b`) element-wise.
+ * Supports broadcasting.
+ *
+ * We also expose `minimumStrict` which has the same signature as this op and
+ * asserts that `a` and `b` are the same shape (does not broadcast).
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 4, 3, 16]);
+ * const b = tf.tensor1d([1, 2, 9, 4]);
+ *
+ * a.minimum(b).print(); // or tf.minimum(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast minimum a with b.
+ * const a = tf.tensor1d([2, 4, 6, 8]);
+ * const b = tf.scalar(5);
+ *
+ * a.minimum(b).print(); // or tf.minimum(a, b)
+ * ```
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same type as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function minimum_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'minimum');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'minimum');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ if ($a.dtype === 'bool') {
+ $a = cast($a, 'int32');
+ $b = cast($b, 'int32');
+ }
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = (backend, save) => {
+ const res = backend.minimum($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["W" /* Minimum */]);
+}
+const minimum = Object(operation["a" /* op */])({ minimum_ });
+//# sourceMappingURL=minimum.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/mod.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Returns the mod of a and b element-wise.
+ * `floor(x / y) * y + mod(x, y) = x`
+ * Supports broadcasting.
+ *
+ * We also expose `tf.modStrict` which has the same signature as this op and
+ * asserts that `a` and `b` are the same shape (does not broadcast).
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 4, 3, 16]);
+ * const b = tf.tensor1d([1, 2, 9, 4]);
+ *
+ * a.mod(b).print(); // or tf.mod(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast a mod b.
+ * const a = tf.tensor1d([2, 4, 6, 8]);
+ * const b = tf.scalar(5);
+ *
+ * a.mod(b).print(); // or tf.mod(a, b)
+ * ```
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same type as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function mod_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'mod');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'mod');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ const forward = (backend, save) => {
+ const res = backend.mod($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["X" /* Mod */]);
+}
+const mod = Object(operation["a" /* op */])({ mod_ });
+//# sourceMappingURL=mod.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/multinomial.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Creates a `tf.Tensor` with values drawn from a multinomial distribution.
+ *
+ * ```js
+ * const probs = tf.tensor([.75, .25]);
+ * tf.multinomial(probs, 3).print();
+ * ```
+ *
+ * @param logits 1D array with unnormalized log-probabilities, or
+ * 2D array of shape `[batchSize, numOutcomes]`. See the `normalized`
+ * parameter.
+ * @param numSamples Number of samples to draw for each row slice.
+ * @param seed The seed number.
+ * @param normalized Whether the provided `logits` are normalized true
+ * probabilities (sum to 1). Defaults to false.
+ * @return 1D array of shape `[numSamples]`, or 2D array of shape
+ * `[batchSize, numSamples]`, depending on the rank of the input.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Random'} */
+function multinomial_(logits, numSamples, seed, normalized = false) {
+ const $logits = Object(tensor_util_env["a" /* convertToTensor */])(logits, 'logits', 'multinomial');
+ const numOutcomes = $logits.size;
+ const origRank = $logits.rank;
+ if (numOutcomes < 2) {
+ throw new Error(`Error in multinomial: you need at least 2 outcomes, but got ` +
+ `${numOutcomes}.`);
+ }
+ if (origRank > 2) {
+ throw new Error(`Rank of probabilities must be 1 or 2, but is ${origRank}`);
+ }
+ seed = seed || Math.random();
+ const logits2D = origRank === 1 ? $logits.as2D(1, -1) : $logits;
+ const res = engine["a" /* ENGINE */].runKernelFunc(backend => backend.multinomial(logits2D, normalized, numSamples, seed), { logits2D });
+ return origRank === 1 ? res.as1D() : res;
+}
+const multinomial = Object(operation["a" /* op */])({ multinomial_ });
+//# sourceMappingURL=multinomial.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/not_equal.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Returns the truth value of (a != b) element-wise. Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ * const b = tf.tensor1d([0, 2, 3]);
+ *
+ * a.notEqual(b).print();
+ * ```
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same dtype as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Logical'} */
+function notEqual_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'notEqual');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'notEqual');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = (backend) => backend.notEqual($a, $b);
+ const inputs = { a: $a, b: $b };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["bb" /* NotEqual */]);
+}
+const notEqual = Object(operation["a" /* op */])({ notEqual_ });
+//# sourceMappingURL=not_equal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/outer_product.js
+
+
+
+
+
+/**
+ * Computes the outer product of two vectors, `v1` and `v2`.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ * const b = tf.tensor1d([3, 4, 5]);
+ *
+ * tf.outerProduct(a, b).print();
+ * ```
+ * @param v1 The first vector in the outer product operation.
+ * @param v2 The second vector in the outer product operation.
+ */
+/** @doc {heading: 'Operations', subheading: 'Matrices'} */
+function outerProduct_(v1, v2) {
+ const $v1 = Object(tensor_util_env["a" /* convertToTensor */])(v1, 'v1', 'outerProduct');
+ const $v2 = Object(tensor_util_env["a" /* convertToTensor */])(v2, 'v2', 'outerProduct');
+ util["assert"]($v1.rank === 1 && $v2.rank === 1, () => `Error in outerProduct: inputs must be rank 1, but got ranks ` +
+ `${$v1.rank} and ${$v2.rank}.`);
+ const v12D = reshape($v1, [-1, 1]);
+ const v22D = reshape($v2, [1, -1]);
+ return matMul(v12D, v22D);
+}
+const outerProduct = Object(operation["a" /* op */])({ outerProduct_ });
+//# sourceMappingURL=outer_product.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/pad1d.js
+
+
+
+/**
+ * Pads a `tf.Tensor1D` with a given value and paddings. See `pad` for details.
+ */
+function pad1d_(x, paddings, constantValue = 0) {
+ Object(util["assert"])(paddings.length === 2, () => 'Invalid number of paddings. Must be length of 2.');
+ return pad_pad(x, [paddings], constantValue);
+}
+const pad1d = Object(operation["a" /* op */])({ pad1d_ });
+//# sourceMappingURL=pad1d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/pad2d.js
+
+
+
+/**
+ * Pads a `tf.Tensor2D` with a given value and paddings. See `pad` for details.
+ */
+function pad2d_(x, paddings, constantValue = 0) {
+ Object(util["assert"])(paddings.length === 2 && paddings[0].length === 2 &&
+ paddings[1].length === 2, () => 'Invalid number of paddings. Must be length of 2 each.');
+ return pad_pad(x, paddings, constantValue);
+}
+const pad2d = Object(operation["a" /* op */])({ pad2d_ });
+//# sourceMappingURL=pad2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/pad3d.js
+
+
+
+/**
+ * Pads a `tf.Tensor3D` with a given value and paddings. See `pad` for details.
+ */
+function pad3d_(x, paddings, constantValue = 0) {
+ Object(util["assert"])(paddings.length === 3 && paddings[0].length === 2 &&
+ paddings[1].length === 2 && paddings[2].length === 2, () => 'Invalid number of paddings. Must be length of 2 each.');
+ return pad_pad(x, paddings, constantValue);
+}
+const pad3d = Object(operation["a" /* op */])({ pad3d_ });
+//# sourceMappingURL=pad3d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/pad4d.js
+
+
+
+/**
+ * Pads a `tf.Tensor4D` with a given value and paddings. See `pad` for details.
+ */
+function pad4d_(x, paddings, constantValue = 0) {
+ Object(util["assert"])(paddings.length === 4 && paddings[0].length === 2 &&
+ paddings[1].length === 2 && paddings[2].length === 2 &&
+ paddings[3].length === 2, () => 'Invalid number of paddings. Must be length of 2 each.');
+ return pad_pad(x, paddings, constantValue);
+}
+const pad4d = Object(operation["a" /* op */])({ pad4d_ });
+//# sourceMappingURL=pad4d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/pool.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Performs an N-D pooling operation
+ *
+ * @param input The input tensor, of rank 4 or rank 3 of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is assumed.
+ * @param windowShape The filter size: `[filterHeight, filterWidth]`. If
+ * `filterSize` is a single number, then `filterHeight == filterWidth`.
+ * @param poolingType The type of pooling, either 'max' or 'avg'.
+ * @param pad The type of padding algorithm:
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
+ * in which we sample input values across the height and width dimensions
+ * in dilated pooling. Defaults to `[1, 1]`. If `dilationRate` is a single
+ * number, then `dilationHeight == dilationWidth`. If it is greater than
+ * 1, then all values of `strides` must be 1.
+ * @param strides The strides of the pooling: `[strideHeight, strideWidth]`. If
+ * `strides` is a single number, then `strideHeight == strideWidth`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function pool_(input, windowShape, poolingType, pad, dilations, strides) {
+ if (dilations == null) {
+ dilations = [1, 1];
+ }
+ if (strides == null) {
+ strides = 1;
+ }
+ if (pad === 0) {
+ pad = 'valid';
+ }
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(input, 'x', 'maxPool');
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
+ }
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in pool: Either strides or dilations must be 1. ' +
+ `Got strides ${strides} and dilations '${dilations}'`);
+ const convInfo = computePool2DInfo(x4D.shape, windowShape, strides, dilations, pad);
+ const dilation = [convInfo.dilationHeight, convInfo.dilationWidth];
+ // The following implementation does batchToSpace(pool(spaceToBatch(x)))
+ // whenever dilation > 1 since the TF kernels do not support dilation > 1.
+ // tslint:disable-next-line:max-line-length
+ // https://github.com/tensorflow/tensorflow/blob/50f6bb67dc98c9b74630b6047aae7a4f8a40fd02/tensorflow/python/ops/nn_ops.py#L1037
+ let basePadding;
+ if (pad === 'same') {
+ basePadding = withSpaceToBatchBasePaddings([convInfo.filterHeight, convInfo.filterWidth], dilation);
+ }
+ else {
+ basePadding = [[0, 0], [0, 0]];
+ }
+ const isDilationOne = dilation[0] === 1 && dilation[1] === 1;
+ const [adjustedPadding, adjustedCrops] = requiredSpaceToBatchPaddings([convInfo.inHeight, convInfo.inWidth], dilation, basePadding);
+ const convertedPad = isDilationOne ? pad : 'valid';
+ const convertedX = isDilationOne ? x4D : spaceToBatchND(x4D, dilation, adjustedPadding);
+ const forwardOp = poolingType === 'avg' ?
+ () => avgPool(convertedX, windowShape, strides, convertedPad) :
+ () => maxPool(convertedX, windowShape, strides, convertedPad);
+ const y = forwardOp();
+ const res = isDilationOne ? y : batchToSpaceND(y, dilation, adjustedCrops);
+ if (reshapedTo4D) {
+ return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
+ }
+ return res;
+}
+// Helper function to compute crops and paddings for pool with dilation > 1.
+// tslint:disable-next-line:max-line-length
+// https://github.com/tensorflow/tensorflow/blob/50f6bb67dc98c9b74630b6047aae7a4f8a40fd02/tensorflow/python/ops/array_ops.py#L2184
+function requiredSpaceToBatchPaddings(inputShape, blockShape, basePadding) {
+ const padStart = basePadding.map(b => b[0]);
+ const origPadEnd = basePadding.map(b => b[1]);
+ const fullInputShape = inputShape.concat(padStart, origPadEnd);
+ const padEndExtra = blockShape.map((b, i) => (b - fullInputShape[i] % b) % b);
+ const padEnd = origPadEnd.map((s, i) => s + padEndExtra[i]);
+ const paddings = blockShape.map((_, i) => [padStart[i], padEnd[i]]);
+ const crops = blockShape.map((_, i) => [0, padEndExtra[i]]);
+ return [paddings, crops];
+}
+// Helper function to compute base paddings for pool with dilation > 1.
+// tslint:disable-next-line:max-line-length
+// https://github.com/tensorflow/tensorflow/blob/50f6bb67dc98c9b74630b6047aae7a4f8a40fd02/tensorflow/python/ops/nn_ops.py#L524
+function withSpaceToBatchBasePaddings(filterShape, dilation) {
+ // Spatial dimensions of the filters and the upsampled filters in which we
+ // introduce (rate - 1) zeros between consecutive filter values.
+ const dilatedFilterShape = filterShape.map((s, i) => {
+ return s + (s - 1) * (dilation[i] - 1);
+ });
+ const padExtraShape = dilatedFilterShape.map(s => s - 1);
+ // When padding is odd, we pad more at end, following the same
+ // convention as conv2d.
+ const padExtraStart = padExtraShape.map(s => Math.floor(s / 2));
+ const padExtraEnd = padExtraShape.map((s, i) => s - padExtraStart[i]);
+ return padExtraShape.map((_, i) => {
+ return [padExtraStart[i], padExtraEnd[i]];
+ });
+}
+const pool = Object(operation["a" /* op */])({ pool_ });
+//# sourceMappingURL=pool.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/prelu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Computes leaky rectified linear element-wise with parametric alphas.
+ *
+ * `x < 0 ? alpha * x : f(x) = x`
+ *
+ * ```js
+ * const x = tf.tensor1d([-1, 2, -3, 4]);
+ * const alpha = tf.scalar(0.1);
+ *
+ * x.prelu(alpha).print(); // or tf.prelu(x, alpha)
+ * ```
+ * @param x The input tensor.
+ * @param alpha Scaling factor for negative values.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function prelu_(x, alpha) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'prelu');
+ const $alpha = Object(tensor_util_env["a" /* convertToTensor */])(alpha, 'alpha', 'prelu');
+ const forward = (backend, save) => {
+ const res = backend.prelu($x, $alpha);
+ save([$x, $alpha]);
+ return res;
+ };
+ const inputs = { x: $x, alpha: $alpha };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["gb" /* Prelu */]);
+}
+const prelu = Object(operation["a" /* op */])({ prelu_ });
+//# sourceMappingURL=prelu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/rand.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Creates a `tf.Tensor` with values sampled from a random number generator
+ * function defined by the user.
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param randFunction A random number generator function which is called
+ * for each element in the output tensor.
+ * @param dtype The data type of the output tensor. Defaults to 'float32'.
+ */
+function rand_(shape, randFunction, dtype) {
+ const size = Object(util["sizeFromShape"])(shape);
+ let values = null;
+ if (dtype == null || dtype === 'float32') {
+ values = new Float32Array(size);
+ }
+ else if (dtype === 'int32') {
+ values = new Int32Array(size);
+ }
+ else if (dtype === 'bool') {
+ values = new Uint8Array(size);
+ }
+ else {
+ throw new Error(`Unknown data type ${dtype}`);
+ }
+ for (let i = 0; i < size; i++) {
+ values[i] = randFunction();
+ }
+ return engine["a" /* ENGINE */].makeTensor(values, shape, dtype);
+}
+const rand = Object(operation["a" /* op */])({ rand_ });
+//# sourceMappingURL=rand.js.map
+// EXTERNAL MODULE: ./node_modules/seedrandom/index.js
+var seedrandom = __webpack_require__(20);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/rand_util.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+// https://en.wikipedia.org/wiki/Marsaglia_polar_method
+class rand_util_MPRandGauss {
+ constructor(mean, stdDeviation, dtype, truncated, seed) {
+ this.mean = mean;
+ this.stdDev = stdDeviation;
+ this.dtype = dtype;
+ this.nextVal = NaN;
+ this.truncated = truncated;
+ if (this.truncated) {
+ this.upper = this.mean + this.stdDev * 2;
+ this.lower = this.mean - this.stdDev * 2;
+ }
+ const seedValue = seed ? seed : Math.random();
+ this.random = seedrandom["alea"](seedValue.toString());
+ }
+ /** Returns next sample from a Gaussian distribution. */
+ nextValue() {
+ if (!isNaN(this.nextVal)) {
+ const value = this.nextVal;
+ this.nextVal = NaN;
+ return value;
+ }
+ let resultX, resultY;
+ let isValid = false;
+ while (!isValid) {
+ let v1, v2, s;
+ do {
+ v1 = 2 * this.random() - 1;
+ v2 = 2 * this.random() - 1;
+ s = v1 * v1 + v2 * v2;
+ } while (s >= 1 || s === 0);
+ const mul = Math.sqrt(-2.0 * Math.log(s) / s);
+ resultX = this.mean + this.stdDev * v1 * mul;
+ resultY = this.mean + this.stdDev * v2 * mul;
+ if (!this.truncated || this.isValidTruncated(resultX)) {
+ isValid = true;
+ }
+ }
+ if (!this.truncated || this.isValidTruncated(resultY)) {
+ this.nextVal = this.convertValue(resultY);
+ }
+ return this.convertValue(resultX);
+ }
+ /** Handles proper rounding for non-floating-point numbers. */
+ convertValue(value) {
+ if (this.dtype == null || this.dtype === 'float32') {
+ return value;
+ }
+ return Math.round(value);
+ }
+ /** Returns true if less than 2-standard-deviations from the mean. */
+ isValidTruncated(value) {
+ return value <= this.upper && value >= this.lower;
+ }
+}
+// Marsaglia, George, and Wai Wan Tsang. 2000. "A Simple Method for Generating
+// Gamma Variables."
+class rand_util_RandGamma {
+ constructor(alpha, beta, dtype, seed) {
+ this.alpha = alpha;
+ this.beta = 1 / beta; // convert rate to scale parameter
+ this.dtype = dtype;
+ const seedValue = seed ? seed : Math.random();
+ this.randu = seedrandom["alea"](seedValue.toString());
+ this.randn = new rand_util_MPRandGauss(0, 1, dtype, false, this.randu());
+ if (alpha < 1) {
+ this.d = alpha + (2 / 3);
+ }
+ else {
+ this.d = alpha - (1 / 3);
+ }
+ this.c = 1 / Math.sqrt(9 * this.d);
+ }
+ /** Returns next sample from a gamma distribution. */
+ nextValue() {
+ let x2, v0, v1, x, u, v;
+ while (true) {
+ do {
+ x = this.randn.nextValue();
+ v = 1 + (this.c * x);
+ } while (v <= 0);
+ v *= v * v;
+ x2 = x * x;
+ v0 = 1 - (0.331 * x2 * x2);
+ v1 = (0.5 * x2) + (this.d * (1 - v + Math.log(v)));
+ u = this.randu();
+ if (u < v0 || Math.log(u) < v1) {
+ break;
+ }
+ }
+ v = (1 / this.beta) * this.d * v;
+ if (this.alpha < 1) {
+ v *= Math.pow(this.randu(), 1 / this.alpha);
+ }
+ return this.convertValue(v);
+ }
+ /** Handles proper rounding for non-floating-point numbers. */
+ convertValue(value) {
+ if (this.dtype === 'float32') {
+ return value;
+ }
+ return Math.round(value);
+ }
+}
+class rand_util_UniformRandom {
+ constructor(min = 0, max = 1, dtype, seed) {
+ /** Handles proper rounding for non floating point numbers. */
+ this.canReturnFloat = () => (this.dtype == null || this.dtype === 'float32');
+ this.min = min;
+ this.range = max - min;
+ this.dtype = dtype;
+ if (seed == null) {
+ seed = Math.random();
+ }
+ if (typeof seed === 'number') {
+ seed = seed.toString();
+ }
+ if (!this.canReturnFloat() && this.range <= 1) {
+ throw new Error(`The difference between ${min} - ${max} <= 1 and dtype is not float`);
+ }
+ this.random = seedrandom["alea"](seed);
+ }
+ convertValue(value) {
+ if (this.canReturnFloat()) {
+ return value;
+ }
+ return Math.round(value);
+ }
+ nextValue() {
+ return this.convertValue(this.min + this.range * this.random());
+ }
+}
+function jarqueBeraNormalityTest(values) {
+ // https://en.wikipedia.org/wiki/Jarque%E2%80%93Bera_test
+ const n = values.length;
+ const s = skewness(values);
+ const k = kurtosis(values);
+ const jb = n / 6 * (Math.pow(s, 2) + 0.25 * Math.pow(k - 3, 2));
+ // JB test requires 2-degress of freedom from Chi-Square @ 0.95:
+ // http://www.itl.nist.gov/div898/handbook/eda/section3/eda3674.htm
+ const CHI_SQUARE_2DEG = 5.991;
+ if (jb > CHI_SQUARE_2DEG) {
+ throw new Error(`Invalid p-value for JB: ${jb}`);
+ }
+}
+function expectArrayInMeanStdRange(actual, expectedMean, expectedStdDev, epsilon) {
+ if (epsilon == null) {
+ epsilon = testEpsilon();
+ }
+ const actualMean = rand_util_mean(actual);
+ expectNumbersClose(actualMean, expectedMean, epsilon);
+ expectNumbersClose(standardDeviation(actual, actualMean), expectedStdDev, epsilon);
+}
+function rand_util_mean(values) {
+ let sum = 0;
+ for (let i = 0; i < values.length; i++) {
+ sum += values[i];
+ }
+ return sum / values.length;
+}
+function standardDeviation(values, mean) {
+ let squareDiffSum = 0;
+ for (let i = 0; i < values.length; i++) {
+ const diff = values[i] - mean;
+ squareDiffSum += diff * diff;
+ }
+ return Math.sqrt(squareDiffSum / values.length);
+}
+function kurtosis(values) {
+ // https://en.wikipedia.org/wiki/Kurtosis
+ const valuesMean = rand_util_mean(values);
+ const n = values.length;
+ let sum2 = 0;
+ let sum4 = 0;
+ for (let i = 0; i < n; i++) {
+ const v = values[i] - valuesMean;
+ sum2 += Math.pow(v, 2);
+ sum4 += Math.pow(v, 4);
+ }
+ return (1 / n) * sum4 / Math.pow((1 / n) * sum2, 2);
+}
+function skewness(values) {
+ // https://en.wikipedia.org/wiki/Skewness
+ const valuesMean = rand_util_mean(values);
+ const n = values.length;
+ let sum2 = 0;
+ let sum3 = 0;
+ for (let i = 0; i < n; i++) {
+ const v = values[i] - valuesMean;
+ sum2 += Math.pow(v, 2);
+ sum3 += Math.pow(v, 3);
+ }
+ return (1 / n) * sum3 / Math.pow((1 / (n - 1)) * sum2, 3 / 2);
+}
+//# sourceMappingURL=rand_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/random_gamma.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Creates a `tf.Tensor` with values sampled from a gamma distribution.
+ *
+ * ```js
+ * tf.randomGamma([2, 2], 1).print();
+ * ```
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param alpha The shape parameter of the gamma distribution.
+ * @param beta The inverse scale parameter of the gamma distribution. Defaults
+ * to 1.
+ * @param dtype The data type of the output. Defaults to float32.
+ * @param seed The seed for the random number generator.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Random'} */
+function randomGamma_(shape, alpha, beta = 1, dtype = 'float32', seed) {
+ if (beta == null) {
+ beta = 1;
+ }
+ if (dtype == null) {
+ dtype = 'float32';
+ }
+ if (dtype !== 'float32' && dtype !== 'int32') {
+ throw new Error(`Unsupported data type ${dtype}`);
+ }
+ const rgamma = new rand_util_RandGamma(alpha, beta, dtype, seed);
+ const res = array_ops_buffer(shape, dtype);
+ for (let i = 0; i < res.values.length; i++) {
+ res.values[i] = rgamma.nextValue();
+ }
+ return res.toTensor();
+}
+const randomGamma = Object(operation["a" /* op */])({ randomGamma_ });
+//# sourceMappingURL=random_gamma.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/random_normal.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Creates a `tf.Tensor` with values sampled from a normal distribution.
+ *
+ * ```js
+ * tf.randomNormal([2, 2]).print();
+ * ```
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param mean The mean of the normal distribution.
+ * @param stdDev The standard deviation of the normal distribution.
+ * @param dtype The data type of the output.
+ * @param seed The seed for the random number generator.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Random'} */
+function randomNormal_(shape, mean = 0, stdDev = 1, dtype, seed) {
+ if (dtype != null && dtype === 'bool') {
+ throw new Error(`Unsupported data type ${dtype}`);
+ }
+ const randGauss = new rand_util_MPRandGauss(mean, stdDev, dtype, false /* truncated */, seed);
+ const res = array_ops_buffer(shape, dtype);
+ for (let i = 0; i < res.values.length; i++) {
+ res.values[i] = randGauss.nextValue();
+ }
+ return res.toTensor();
+}
+const randomNormal = Object(operation["a" /* op */])({ randomNormal_ });
+//# sourceMappingURL=random_normal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/random_uniform.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Creates a `tf.Tensor` with values sampled from a uniform distribution.
+ *
+ * The generated values follow a uniform distribution in the range [minval,
+ * maxval). The lower bound minval is included in the range, while the upper
+ * bound maxval is excluded.
+ *
+ * ```js
+ * tf.randomUniform([2, 2]).print();
+ * ```
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param minval The lower bound on the range of random values to generate.
+ * Defaults to 0.
+ * @param maxval The upper bound on the range of random values to generate.
+ * Defaults to 1.
+ * @param dtype The data type of the output tensor. Defaults to 'float32'.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Random'} */
+function randomUniform_(shape, minval = 0, maxval = 1, dtype = 'float32', seed) {
+ const res = array_ops_buffer(shape, dtype);
+ const random = new rand_util_UniformRandom(minval, maxval, null, seed);
+ for (let i = 0; i < res.values.length; i++) {
+ res.values[i] = random.nextValue();
+ }
+ return res.toTensor();
+}
+const randomUniform = Object(operation["a" /* op */])({ randomUniform_ });
+//# sourceMappingURL=random_uniform.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/real.js
+var real = __webpack_require__(22);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/relu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Computes rectified linear element-wise: `max(x, 0)`.
+ *
+ * ```js
+ * const x = tf.tensor1d([-1, 2, -3, 4]);
+ *
+ * x.relu().print(); // or tf.relu(x)
+ * ```
+ * @param x The input tensor. If the dtype is `bool`, the output dtype will be
+ * `int32'.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function relu_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'relu');
+ const forward = (backend, save) => {
+ save([$x]);
+ if ($x.dtype === 'bool') {
+ return $x.toInt();
+ }
+ return backend.relu($x);
+ };
+ const inputs = { x: $x };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["ib" /* Relu */]);
+}
+const relu = Object(operation["a" /* op */])({ relu_ });
+//# sourceMappingURL=relu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/relu6.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Computes rectified linear 6 element-wise: `min(max(x, 0), 6)`.
+ *
+ * ```js
+ * const x = tf.tensor1d([-1, 2, -3, 8]);
+ *
+ * x.relu6().print(); // or tf.relu6(x)
+ * ```
+ * @param x The input tensor. If the dtype is `bool`, the output dtype will be
+ * `int32'.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function relu6_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'relu6');
+ const forward = (backend, save) => {
+ save([$x]);
+ if ($x.dtype === 'bool') {
+ return cast($x, 'int32');
+ }
+ return backend.relu6($x);
+ };
+ const inputs = { x: $x };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["jb" /* Relu6 */]);
+}
+const relu6 = Object(operation["a" /* op */])({ relu6_ });
+//# sourceMappingURL=relu6.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/selu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Computes scaled exponential linear element-wise.
+ *
+ * `x < 0 ? scale * alpha * (exp(x) - 1) : x`
+ *
+ * ```js
+ * const x = tf.tensor1d([-1, 2, -3, 4]);
+ *
+ * x.selu().print(); // or tf.selu(x)
+ * ```
+ * @param x The input tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Basic math'} */
+function selu_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'selu');
+ const forward = (backend, save) => {
+ const res = backend.selu($x);
+ save([$x]);
+ return res;
+ };
+ const inputs = { x: $x };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["lb" /* Selu */]);
+}
+const selu = Object(operation["a" /* op */])({ selu_ });
+//# sourceMappingURL=selu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/separable_conv2d.js
+
+
+
+
+
+/**
+ * 2-D convolution with separable filters.
+ *
+ * Performs a depthwise convolution that acts separately on channels followed
+ * by a pointwise convolution that mixes channels. Note that this is
+ * separability between dimensions [1, 2] and 3, not spatial separability
+ * between dimensions 1 and 2.
+ *
+ * See
+ * [https://www.tensorflow.org/api_docs/python/tf/nn/separable_conv2d](
+ * https://www.tensorflow.org/api_docs/python/tf/nn/separable_conv2d)
+ * for more details.
+ *
+ * @param x The input tensor, of rank 4 or rank 3, of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is
+ * assumed.
+ * @param depthwiseFilter The depthwise filter tensor, rank 4, of shape
+ * `[filterHeight, filterWidth, inChannels, channelMultiplier]`. This is
+ * the filter used in the first step.
+ * @param pointwiseFilter The pointwise filter tensor, rank 4, of shape
+ * `[1, 1, inChannels * channelMultiplier, outChannels]`. This is
+ * the filter used in the second step.
+ * @param strides The strides of the convolution: `[strideHeight,
+ * strideWidth]`. If strides is a single number, then `strideHeight ==
+ * strideWidth`.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
+ * in which we sample input values across the height and width dimensions
+ * in atrous convolution. Defaults to `[1, 1]`. If `rate` is a single
+ * number, then `dilationHeight == dilationWidth`. If it is greater than
+ * 1, then all values of `strides` must be 1.
+ * @param dataFormat: An optional string from: "NHWC", "NCHW". Defaults to
+ * "NHWC". Specify the data format of the input and output data. With the
+ * default format "NHWC", the data is stored in the order of: [batch,
+ * height, width, channels]. Only "NHWC" is currently supported.
+ */
+/** @doc {heading: 'Operations', subheading: 'Convolution'} */
+function separableConv2d_(x, depthwiseFilter, pointwiseFilter, strides, pad, dilation = [1, 1], dataFormat = 'NHWC') {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'separableConv2d');
+ const $depthwiseFilter = Object(tensor_util_env["a" /* convertToTensor */])(depthwiseFilter, 'depthwiseFilter', 'separableConv2d');
+ const $pointwiseFilter = Object(tensor_util_env["a" /* convertToTensor */])(pointwiseFilter, 'pointwiseFilter', 'separableConv2d');
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = $x.as4D(1, $x.shape[0], $x.shape[1], $x.shape[2]);
+ }
+ if (dataFormat === 'NCHW') {
+ throw new Error('separableConv2d currently does not support dataFormat NCHW; only ' +
+ 'NHWC is supported');
+ }
+ util["assert"](x4D.rank === 4, () => `Error in separableConv2d: input must be rank 4, but got ` +
+ `rank ${x4D.rank}.`);
+ util["assert"]($depthwiseFilter.rank === 4, () => `Error in separableConv2d: depthwise filter must be rank 4, but ` +
+ `got rank ${$depthwiseFilter.rank}.`);
+ util["assert"]($pointwiseFilter.rank === 4, () => `Error in separableConv2d: pointwise filter must be rank 4, but ` +
+ `got rank ${$depthwiseFilter.rank}.`);
+ util["assert"]($pointwiseFilter.shape[0] === 1, () => `Error in separableConv2d: the first dimension of pointwise filter ` +
+ ` must be 1, but got ${$pointwiseFilter.shape[0]}.`);
+ util["assert"]($pointwiseFilter.shape[1] === 1, () => `Error in separableConv2d: the second dimension of pointwise ` +
+ `filter must be 1, but got ${$pointwiseFilter.shape[1]}.`);
+ const inChannels = $depthwiseFilter.shape[2];
+ const channelMultiplier = $depthwiseFilter.shape[3];
+ util["assert"]($pointwiseFilter.shape[2] === inChannels * channelMultiplier, () => `Error in separableConv2d: the third dimension of pointwise filter ` +
+ `must be ${inChannels * channelMultiplier}, ` +
+ `but got ${$pointwiseFilter.shape[2]}.`);
+ const depthwise = depthwiseConv2d(x4D, $depthwiseFilter, strides, pad, dataFormat, dilation);
+ const pointwiseStride = 1;
+ const res = conv2d(depthwise, $pointwiseFilter, pointwiseStride, 'valid', dataFormat);
+ if (reshapedTo4D) {
+ return res.as3D(res.shape[1], res.shape[2], res.shape[3]);
+ }
+ return res;
+}
+const separableConv2d = Object(operation["a" /* op */])({ separableConv2d_ });
+//# sourceMappingURL=separable_conv2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/squared_difference.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Returns (a - b) * (a - b) element-wise.
+ * Supports broadcasting.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 4, 3, 16]);
+ * const b = tf.tensor1d([1, 2, 9, 4]);
+ *
+ * a.squaredDifference(b).print(); // or tf.squaredDifference(a, b)
+ * ```
+ *
+ * ```js
+ * // Broadcast squared difference a with b.
+ * const a = tf.tensor1d([2, 4, 6, 8]);
+ * const b = tf.scalar(5);
+ *
+ * a.squaredDifference(b).print(); // or tf.squaredDifference(a, b)
+ * ```
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same type as `a`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Arithmetic'} */
+function squaredDifference_(a, b) {
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'squaredDifference');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'squaredDifference');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ assertAndGetBroadcastShape($a.shape, $b.shape);
+ const forward = (backend, save) => {
+ const res = backend.squaredDifference($a, $b);
+ save([$a, $b]);
+ return res;
+ };
+ const inputs = { a: $a, b: $b };
+ const attrs = {};
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* grad */, kernel_names["pb" /* SquaredDifference */], attrs);
+}
+const squaredDifference = Object(operation["a" /* op */])({ squaredDifference_ });
+//# sourceMappingURL=squared_difference.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/truncated_normal.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Creates a `tf.Tensor` with values sampled from a truncated normal
+ * distribution.
+ *
+ * ```js
+ * tf.truncatedNormal([2, 2]).print();
+ * ```
+ *
+ * The generated values follow a normal distribution with specified mean and
+ * standard deviation, except that values whose magnitude is more than 2
+ * standard deviations from the mean are dropped and re-picked.
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param mean The mean of the normal distribution.
+ * @param stdDev The standard deviation of the normal distribution.
+ * @param dtype The data type of the output tensor.
+ * @param seed The seed for the random number generator.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function truncatedNormal_(shape, mean = 0, stdDev = 1, dtype, seed) {
+ if (dtype != null && dtype === 'bool') {
+ throw new Error(`Unsupported data type $ { dtype }`);
+ }
+ const randGauss = new rand_util_MPRandGauss(mean, stdDev, dtype, true /* truncated */, seed);
+ const res = array_ops_buffer(shape, dtype);
+ for (let i = 0; i < res.values.length; i++) {
+ res.values[i] = randGauss.nextValue();
+ }
+ return res.toTensor();
+}
+const truncatedNormal = Object(operation["a" /* op */])({ truncatedNormal_ });
+//# sourceMappingURL=truncated_normal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/reduce_util.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Inputs of size above this threshold will be parallelized by calling multiple
+ * shader programs.
+ */
+
+const PARALLELIZE_THRESHOLD = 30;
+function computeOptimalWindowSize(inSize) {
+ if (inSize <= PARALLELIZE_THRESHOLD) {
+ return inSize;
+ }
+ return Object(util["nearestDivisor"])(inSize, Math.floor(Math.sqrt(inSize)));
+}
+//# sourceMappingURL=reduce_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/segment_util.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+function segOpComputeOptimalWindowSize(inSize, numSegments) {
+ let done = false;
+ let res;
+ if (inSize <= PARALLELIZE_THRESHOLD) {
+ res = inSize;
+ done = true;
+ }
+ else {
+ res = Object(util["nearestDivisor"])(inSize, Math.floor(Math.sqrt(inSize)));
+ }
+ while (!done) {
+ if (res > numSegments || res === inSize) {
+ done = true;
+ }
+ else {
+ res = Object(util["nearestDivisor"])(inSize, res + 1);
+ }
+ }
+ return res;
+}
+function segment_util_computeOutShape(aShape, axis, numSegments) {
+ const outShape = [];
+ const rank = aShape.length;
+ for (let dim = 0; dim < rank; dim++) {
+ if (dim !== axis) {
+ outShape.push(aShape[dim]);
+ }
+ else {
+ outShape.push(numSegments);
+ }
+ }
+ return outShape;
+}
+function collectGatherOpShapeInfo(x, indices, axis) {
+ const dimSize = x.shape[axis];
+ const outputShape = [];
+ let batchSize = 1;
+ let sliceSize = 1;
+ for (let i = 0; i < axis; i++) {
+ outputShape.push(x.shape[i]);
+ batchSize *= x.shape[i];
+ }
+ for (let i = 0; i < indices.rank; i++) {
+ outputShape.push(indices.shape[i]);
+ }
+ for (let i = axis + 1; i < x.rank; i++) {
+ outputShape.push(x.shape[i]);
+ sliceSize *= x.shape[i];
+ }
+ return { batchSize, sliceSize, dimSize, outputShape };
+}
+//# sourceMappingURL=segment_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/segment_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Computes the sum along segments of a `tf.Tensor`.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ * const segmentIds = tf.tensor1d([1, 2, 0, 1], 'int32');
+ * const numSegments = 3;
+ *
+ * x.unsortedSegmentSum(segmentIds, numSegments).print()
+ * //or tf.unsortedSegmentSum(x, segmentIds, numSegments)
+ * ```
+ * @param x The `tf.Tensor` that will be summed along its segments.
+ * @param segmentIds A `tf.Tensor1D` whose rank is equal to the rank of `x`'s
+ * dimension along the `axis`. Maps each element of `x` to a segment.
+ * @param numSegments The number of distinct `segmentIds`.
+ */
+/** @doc {heading: 'Operations', subheading: 'Segment'} */
+function unsortedSegmentSum_(x, segmentIds, numSegments) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'unsortedSegmentSum');
+ const $segmentIds = Object(tensor_util_env["a" /* convertToTensor */])(segmentIds, 'segmentIds', 'unsortedSegmentSum', 'int32');
+ Object(util["assert"])(Object(util["isInt"])(numSegments), () => 'numSegments must be of dtype int');
+ const gradFunc = (dy, saved) => {
+ const [$segmentIds] = saved;
+ const derX = () => {
+ return gatherDropNegatives(dy, $segmentIds);
+ };
+ return { $x: derX };
+ };
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.unsortedSegmentSum($x, $segmentIds, numSegments);
+ save([$segmentIds]);
+ return res;
+ }, { $x }, gradFunc);
+}
+/**
+ * Gather slices from tensor `x`'s axis `axis` according to `indices`.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ * const indices = tf.tensor1d([1, 3, 3], 'int32');
+ *
+ * x.gather(indices).print();
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ * const indices = tf.tensor1d([1, 1, 0], 'int32');
+ *
+ * x.gather(indices).print();
+ * ```
+ * @param x The input tensor whose slices to be gathered.
+ * @param indices The indices of the values to extract.
+ * @param axis The axis over which to select values. Defaults to 0.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+function gather_(x, indices, axis = 0) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'gather');
+ const $indices = Object(tensor_util_env["a" /* convertToTensor */])(indices, 'indices', 'gather', 'int32');
+ axis = Object(util["parseAxisParam"])(axis, $x.shape)[0];
+ const shapeInfo = collectGatherOpShapeInfo($x, $indices, axis);
+ const grad = (dy, saved) => {
+ const [$indices] = saved;
+ const derX = () => {
+ const paramsShape = $x.shape;
+ const indicesSize = $indices.size;
+ const outerShape = paramsShape.slice(0, axis);
+ const outerDims = outerShape.length;
+ const innerShape = paramsShape.slice(axis, paramsShape.length).slice(1);
+ const innerDims = innerShape.length;
+ const outerAxesIndices = arrayRange(0, outerDims);
+ const innerAxesIndices = arrayRange(outerDims + 1, outerDims + 1 + innerDims);
+ const valuesShape = arrayConcat([outerShape, [indicesSize], innerShape]);
+ const values = dy.reshape(valuesShape);
+ const reshapedIndices = $indices.reshape([indicesSize]);
+ const transposeDims = arrayConcat([[outerDims], outerAxesIndices, innerAxesIndices]);
+ const valuesTranspose = values.transpose(transposeDims);
+ let paramsGrad = unsortedSegmentSum(valuesTranspose, reshapedIndices, $x.shape[axis]);
+ const invertTransposeDims = getUndoAxesPermutation(transposeDims);
+ paramsGrad = paramsGrad.transpose(invertTransposeDims);
+ return paramsGrad;
+ };
+ return { x: derX, indices: () => $indices };
+ };
+ return (engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.gather($x, $indices.flatten(), axis);
+ save([$indices]);
+ return res;
+ }, { x: $x, indices: $indices }, grad, 'Gather', { axis }))
+ .reshape(shapeInfo.outputShape);
+}
+function arrayRange(start, stop) {
+ const result = [];
+ for (let i = start; i < stop; ++i) {
+ result.push(i);
+ }
+ return result;
+}
+function arrayConcat(arrays) {
+ const result = [];
+ for (let i = 0; i < arrays.length; ++i) {
+ for (let j = 0; j < arrays[i].length; ++j) {
+ result.push(arrays[i][j]);
+ }
+ }
+ return result;
+}
+function gatherDropNegatives(x, indices) {
+ // Helper function for unsorted segment ops. Gathers params for
+ // positive segment ids and gathers 0 for inputs with negative segment id.
+ // Mirrors _GatherDropNegatives from tensorflow/python/ops/math_grad.py
+ const zeroClippedIndices = maximum(indices, Object(tensor_ops["o" /* zerosLike */])(indices));
+ const gathered = gather(x, zeroClippedIndices);
+ let isPositive = greaterEqual(indices, Object(tensor_ops["e" /* scalar */])(0, 'int32'));
+ const numIters = gathered.rank - isPositive.rank;
+ for (let i = 0; i < numIters; ++i) {
+ isPositive = expandDims(isPositive, i + 1);
+ }
+ isPositive = logicalAnd(isPositive, Object(tensor_ops["b" /* ones */])(gathered.shape, 'bool'));
+ const zeroSlice = Object(tensor_ops["o" /* zerosLike */])(gathered);
+ return where(isPositive, gathered, zeroSlice);
+}
+const gather = Object(operation["a" /* op */])({ gather_ });
+const unsortedSegmentSum = Object(operation["a" /* op */])({ unsortedSegmentSum_ });
+//# sourceMappingURL=segment_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/boolean_mask.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Apply boolean mask to tensor.
+ *
+ * ```js
+ * const tensor = tf.tensor2d([1, 2, 3, 4, 5, 6], [3, 2]);
+ * const mask = tf.tensor1d([1, 0, 1], 'bool');
+ * const result = await tf.booleanMaskAsync(tensor, mask);
+ * result.print();
+ * ```
+ *
+ * @param tensor N-D tensor.
+ * @param mask K-D boolean tensor, K <= N and K must be known statically.
+ * @param axis A 0-D int Tensor representing the axis in tensor to mask from.
+ * By default, axis is 0 which will mask from the first dimension.
+ * Otherwise K + axis <= N.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+async function booleanMaskAsync_(tensor, mask, axis) {
+ const $tensor = Object(tensor_util_env["a" /* convertToTensor */])(tensor, 'tensor', 'boolMask');
+ const $mask = Object(tensor_util_env["a" /* convertToTensor */])(mask, 'mask', 'boolMask', 'bool');
+ const axisFrom = axis == null ? 0 : axis;
+ const maskDim = $mask.rank;
+ const tensorShape = $tensor.shape;
+ util["assert"](maskDim > 0, () => 'mask cannot be scalar');
+ util["assertShapesMatch"](tensorShape.slice(axisFrom, axisFrom + maskDim), $mask.shape, `mask's shape must match the first K dimensions of tensor's shape,`);
+ let leadingSize = 1;
+ for (let i = axisFrom; i < axisFrom + maskDim; i++) {
+ leadingSize *= tensorShape[i];
+ }
+ const targetTensorShape = tensorShape.slice(0, axisFrom)
+ .concat([leadingSize], tensorShape.slice(axisFrom + maskDim));
+ const reshapedTensor = $tensor.reshape(targetTensorShape);
+ const reshapedMask = $mask.reshape([-1]);
+ const positivePositions = await whereAsync(reshapedMask);
+ const indices = positivePositions.squeeze([1]);
+ const res = gather(reshapedTensor, indices, axisFrom);
+ // Ensure no memory leak.
+ if (tensor !== $tensor) {
+ $tensor.dispose();
+ }
+ if (mask !== $mask) {
+ $mask.dispose();
+ }
+ indices.dispose();
+ reshapedTensor.dispose();
+ reshapedMask.dispose();
+ positivePositions.dispose();
+ return res;
+}
+const booleanMaskAsync = booleanMaskAsync_;
+//# sourceMappingURL=boolean_mask.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/reverse.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Reverses a `tf.Tensor1D`.
+ *
+ * @param x The input tensor.
+ */
+function reverse1d_(x) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'reverse');
+ util["assert"]($x.rank === 1, () => `Error in reverse1D: x must be rank 1 but got rank ${$x.rank}.`);
+ return reverse_reverse($x, 0);
+}
+/**
+ * Reverses a `tf.Tensor2D` along a specified axis.
+ *
+ * @param x The input tensor.
+ * @param axis The set of dimensions to reverse. Must be in the
+ * range [-rank(x), rank(x)). Defaults to all axes.
+ */
+function reverse2d_(x, axis) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'reverse');
+ util["assert"]($x.rank === 2, () => `Error in reverse2D: x must be rank 2 but got rank ${$x.rank}.`);
+ return reverse_reverse($x, axis);
+}
+/**
+ * Reverses a `tf.Tensor3D` along a specified axis.
+ *
+ * @param x The input tensor.
+ * @param axis The set of dimensions to reverse. Must be in the
+ * range [-rank(x), rank(x)). Defaults to all axes.
+ */
+function reverse3d_(x, axis) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'reverse');
+ util["assert"]($x.rank === 3, () => `Error in reverse3D: x must be rank 3 but got rank ${$x.rank}.`);
+ return reverse_reverse($x, axis);
+}
+/**
+ * Reverses a `tf.Tensor4D` along a specified axis.
+ *
+ * @param x The input tensor.
+ * @param axis The set of dimensions to reverse. Must be in the
+ * range [-rank(x), rank(x)). Defaults to all axes.
+ */
+function reverse4d_(x, axis) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'reverse');
+ util["assert"]($x.rank === 4, () => `Error in reverse4D: x must be rank 4 but got rank ${$x.rank}.`);
+ return reverse_reverse($x, axis);
+}
+/**
+ * Reverses a `tf.Tensor` along a specified axis.
+ *
+ * Also available are stricter rank-specific methods that assert that `x` is
+ * of the given rank:
+ * - `tf.reverse1d`
+ * - `tf.reverse2d`
+ * - `tf.reverse3d`
+ * - `tf.reverse4d`
+ *
+ * Except `tf.reverse1d` (which does not have axis param), all methods have
+ * same signature as this method.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ *
+ * x.reverse().print();
+ * ```
+ *
+ * ```js
+ * const x = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ *
+ * const axis = 1;
+ * x.reverse(axis).print();
+ * ```
+ * @param x The input tensor to be reversed.
+ * @param axis The set of dimensions to reverse. Must be in the
+ * range [-rank(x), rank(x)). Defaults to all axes.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
+function reverse_(x, axis) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'reverse');
+ if ($x.rank === 0) {
+ return $x.clone();
+ }
+ const axes = util["parseAxisParam"](axis, $x.shape);
+ const grad = (dy) => {
+ return { $x: () => dy.reverse(axes) };
+ };
+ const res = engine["a" /* ENGINE */].runKernelFunc(backend => backend.reverse($x, axes), { $x }, grad);
+ return res.reshapeAs($x);
+}
+const reverse_reverse = Object(operation["a" /* op */])({ reverse_ });
+const reverse1d = Object(operation["a" /* op */])({ reverse1d_ });
+const reverse2d = Object(operation["a" /* op */])({ reverse2d_ });
+const reverse3d = Object(operation["a" /* op */])({ reverse3d_ });
+const reverse4d = Object(operation["a" /* op */])({ reverse4d_ });
+//# sourceMappingURL=reverse.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/compare.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * @deprecated
+ * Strict version of `tf.notEqual` that forces `a` and `b` to be of the same
+ * shape.
+ *
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same shape and dtype as
+ * `a`.
+ */
+function notEqualStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'notEqualStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'notEqualStrict');
+ Object(util["assertShapesMatch"])($a.shape, $b.shape, 'Error in notEqualStrict: ');
+ return $a.notEqual($b);
+}
+/**
+ * @deprecated
+ * Strict version of `tf.less` that forces `a` and `b` to be of the same
+ * shape.
+ *
+ * @param a The first input tensor.
+ * @param b The second input tensor. Must have the same shape and dtype as
+ * `a`.
+ */
+function lessStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'lessStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'lessStrict');
+ Object(util["assertShapesMatch"])($a.shape, $b.shape, 'Error in lessStrict: ');
+ return $a.less($b);
+}
+function equalStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'equalStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'equalStrict');
+ Object(util["assertShapesMatch"])($a.shape, $b.shape, 'Error in equalStrict: ');
+ return $a.equal($b);
+}
+function lessEqualStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'lessEqualStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'lessEqualStrict');
+ Object(util["assertShapesMatch"])($a.shape, $b.shape, 'Error in lessEqualStrict: ');
+ return $a.lessEqual($b);
+}
+function greaterStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'greaterStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'greaterStrict');
+ Object(util["assertShapesMatch"])($a.shape, $b.shape, 'Error in greaterStrict: ');
+ return $a.greater($b);
+}
+function greaterEqualStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'greaterEqualStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'greaterEqualStrict');
+ Object(util["assertShapesMatch"])($a.shape, $b.shape, 'Error in greaterEqualStrict: ');
+ return $a.greaterEqual($b);
+}
+const equalStrict = Object(operation["a" /* op */])({ equalStrict_ });
+const greaterEqualStrict = Object(operation["a" /* op */])({ greaterEqualStrict_ });
+const greaterStrict = Object(operation["a" /* op */])({ greaterStrict_ });
+const lessEqualStrict = Object(operation["a" /* op */])({ lessEqualStrict_ });
+const lessStrict = Object(operation["a" /* op */])({ lessStrict_ });
+const notEqualStrict = Object(operation["a" /* op */])({ notEqualStrict_ });
+//# sourceMappingURL=compare.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/binary_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * @deprecated
+ * Adds two `tf.Tensor`s element-wise, A + B.
+ *
+ * Inputs must be the same shape. For broadcasting support, use add() instead.
+ *
+ * @param a The first Tensor to add element-wise.
+ * @param b The second Tensor to add element-wise.
+ */
+function addStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'addStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'addStrict');
+ util["assertShapesMatch"]($a.shape, $b.shape, 'Error in addStrict: ');
+ return $a.add($b);
+}
+/**
+ * @deprecated
+ * Subtracts two `tf.Tensor`s element-wise, A - B. Inputs must
+ * be the same shape.
+ *
+ * For broadcasting support, use `tf.sub` instead.
+ *
+ * @param a The first Tensor to subtract element-wise.
+ * @param b The second Tensor to subtract element-wise.
+ */
+function subStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'subStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'subStrict');
+ util["assertShapesMatch"]($a.shape, $b.shape, 'Error in subStrict: ');
+ return $a.sub($b);
+}
+/**
+ * @deprecated
+ * Computes the power of one `tf.Tensor` to another. Inputs must
+ * be the same shape.
+ *
+ * For broadcasting support, use `tf.pow` instead.
+ *
+ * @param base The base tensor to pow element-wise.
+ * @param exp The exponent tensor to pow element-wise.
+ */
+function powStrict_(base, exp) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ util["assertShapesMatch"](base.shape, exp.shape, 'Error in powStrict: ');
+ return base.pow(exp);
+}
+/**
+ * @deprecated
+ * Multiplies two `tf.Tensor`s element-wise, A * B.
+ *
+ * Inputs must be the same shape. For broadcasting support, use `tf.mul`.
+ *
+ * @param a The first tensor to multiply.
+ * @param b The first tensor to multiply. Must have the same
+ * dtype as `a`.
+ */
+function mulStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'mul');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'mul');
+ util["assertShapesMatch"]($a.shape, $b.shape, 'Error in multiplyStrict: ');
+ return $a.mul($b);
+}
+/**
+ * @deprecated
+ * Divides two `tf.Tensor`s element-wise, A / B. Inputs must
+ * be the same shape.
+ *
+ * @param a The first tensor as the numerator for element-wise division.
+ * @param b The second tensor as the denominator for element-wise division.
+ */
+function divStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'div');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'div');
+ util["assertShapesMatch"]($a.shape, $b.shape, 'Error in divideStrict: ');
+ return $a.div($b);
+}
+/**
+ * @deprecated
+ * Returns the mod of a and b (`a < b ? a : b`) element-wise. Inputs must
+ * be the same shape. For broadcasting support, use mod().
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same dtype as `a`.
+ */
+function modStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'modStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'modStrict');
+ util["assertShapesMatch"]($a.shape, $b.shape, 'Error in modStrict: ');
+ return $a.mod($b);
+}
+/**
+ * @deprecated
+ * Returns the min of a and b (`a < b ? a : b`) element-wise. Inputs must
+ * be the same shape. For broadcasting support, use minimum().
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same dtype as `a`.
+ */
+function minimumStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'minimumStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'minimumStrict');
+ util["assertShapesMatch"]($a.shape, $b.shape, 'Error in minimumStrict: ');
+ return $a.minimum($b);
+}
+/**
+ * @deprecated
+ * Returns the max of a and b (`a > b ? a : b`) element-wise. Inputs must
+ * be the same shape. For broadcasting support, use maximum().
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same dtype as `a`.
+ */
+function maximumStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'maximumStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'maximumStrict');
+ util["assertShapesMatch"]($a.shape, $b.shape, 'Error in maximumStrict: ');
+ return $a.maximum($b);
+}
+/**
+ * @deprecated
+ * Returns (a - b) * (a - b) element-wise.
+ *
+ * Inputs must be the same shape. For broadcasting support, use
+ * `tf.squaredDifference` instead.
+ *
+ * @param a The first tensor.
+ * @param b The second tensor. Must have the same type as `a`.
+ */
+function squaredDifferenceStrict_(a, b) {
+ deprecationWarn('strict variants of ops have been deprecated ' +
+ 'and will be removed in future');
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'squaredDifferenceStrict');
+ const $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'squaredDifferenceStrict');
+ util["assertShapesMatch"]($a.shape, $b.shape, 'Error in squaredDifferenceStrict: ');
+ return $a.squaredDifference($b);
+}
+const addStrict = Object(operation["a" /* op */])({ addStrict_ });
+const divStrict = Object(operation["a" /* op */])({ divStrict_ });
+const maximumStrict = Object(operation["a" /* op */])({ maximumStrict_ });
+const minimumStrict = Object(operation["a" /* op */])({ minimumStrict_ });
+const modStrict = Object(operation["a" /* op */])({ modStrict_ });
+const mulStrict = Object(operation["a" /* op */])({ mulStrict_ });
+const powStrict = Object(operation["a" /* op */])({ powStrict_ });
+const squaredDifferenceStrict = Object(operation["a" /* op */])({ squaredDifferenceStrict_ });
+const subStrict = Object(operation["a" /* op */])({ subStrict_ });
+//# sourceMappingURL=binary_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/softmax.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Computes the softmax normalized vector given the logits.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ *
+ * a.softmax().print(); // or tf.softmax(a)
+ * ```
+ *
+ * ```js
+ * const a = tf.tensor2d([2, 4, 6, 1, 2, 3], [2, 3]);
+ *
+ * a.softmax().print(); // or tf.softmax(a)
+ * ```
+ *
+ * @param logits The logits array.
+ * @param dim The dimension softmax would be performed on. Defaults to `-1`
+ * which indicates the last dimension.
+ */
+/** @doc {heading: 'Operations', subheading: 'Normalization'} */
+function softmax_(logits, dim = -1) {
+ const $logits = Object(tensor_util_env["a" /* convertToTensor */])(logits, 'logits', 'softmax', 'float32');
+ if (dim === -1) {
+ dim = $logits.rank - 1;
+ }
+ if (dim !== $logits.rank - 1) {
+ throw Error('Softmax along a non-last dimension is not yet supported. ' +
+ `Logits was rank ${$logits.rank} and dim was ${dim}`);
+ }
+ const inputsToSave = [];
+ const outputsToSave = [true];
+ return engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const y = backend.softmax($logits, dim);
+ save([y]);
+ return y;
+ }, { logits: $logits }, (dy, saved) => {
+ const [y] = saved;
+ const dyTimesY = dy.mul(y);
+ const keepDims = true;
+ return {
+ logits: () => dyTimesY.sub(dyTimesY.sum([dim], keepDims).mul(y))
+ };
+ }, 'Softmax', { dim }, inputsToSave, outputsToSave);
+}
+/**
+ * Computes the log softmax.
+ *
+ * ```js
+ * const a = tf.tensor1d([1, 2, 3]);
+ *
+ * a.logSoftmax().print(); // or tf.logSoftmax(a)
+ * ```
+ *
+ * ```js
+ * const a = tf.tensor2d([2, 4, 6, 1, 2, 3], [2, 3]);
+ *
+ * a.logSoftmax().print(); // or tf.logSoftmax(a)
+ * ```
+ *
+ * @param logits The logits array.
+ * @param axis The dimension softmax would be performed on. Defaults to `-1`
+ * which indicates the last dimension.
+ */
+/** @doc {heading: 'Operations', subheading: 'Normalization'} */
+function logSoftmax_(logits, axis = -1) {
+ const $logits = Object(tensor_util_env["a" /* convertToTensor */])(logits, 'logits', 'logSoftmax');
+ if (axis === -1) {
+ axis = $logits.rank - 1;
+ }
+ if (axis !== $logits.rank - 1) {
+ throw Error('Log Softmax along a non-last dimension is not yet supported. ' +
+ `Logits was rank ${$logits.rank} and axis was ${axis}`);
+ }
+ const customOp = customGrad((logits, save) => {
+ const keepDims = true;
+ const xMax = logits.max(axis, true);
+ const shifted = logits.sub(xMax);
+ const value = shifted.toFloat().sub(shifted.exp().sum(axis, keepDims).log());
+ save([value]);
+ const gradFunc = (dy, saved) => {
+ const [value] = saved;
+ const softmax = value.exp();
+ return dy.sub(dy.sum(axis, keepDims).mul(softmax));
+ };
+ return { value, gradFunc };
+ });
+ return customOp($logits);
+}
+const softmax = Object(operation["a" /* op */])({ softmax_ });
+const logSoftmax = Object(operation["a" /* op */])({ logSoftmax_ });
+//# sourceMappingURL=softmax.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/norm.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Computes the norm of scalar, vectors, and matrices.
+ * This function can compute several different vector norms (the 1-norm, the
+ * Euclidean or 2-norm, the inf-norm, and in general the p-norm for p > 0)
+ * and matrix norms (Frobenius, 1-norm, and inf-norm).
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 3, 4]);
+ *
+ * x.norm().print(); // or tf.norm(x)
+ * ```
+ *
+ * @param x The input array.
+ * @param ord Optional. Order of the norm. Supported norm types are
+ * following:
+ *
+ * | ord | norm for matrices | norm for vectors
+ * |------------|---------------------------|---------------------
+ * |'euclidean' |Frobenius norm |2-norm
+ * |'fro' |Frobenius norm |
+ * |Infinity |max(sum(abs(x), axis=1)) |max(abs(x))
+ * |-Infinity |min(sum(abs(x), axis=1)) |min(abs(x))
+ * |1 |max(sum(abs(x), axis=0)) |sum(abs(x))
+ * |2 | |sum(abs(x)^2)^1/2*
+ *
+ * @param axis Optional. If axis is null (the default), the input is
+ * considered a vector and a single vector norm is computed over the entire
+ * set of values in the Tensor, i.e. norm(x, ord) is equivalent
+ * to norm(x.reshape([-1]), ord). If axis is a integer, the input
+ * is considered a batch of vectors, and axis determines the axis in x
+ * over which to compute vector norms. If axis is a 2-tuple of integer it is
+ * considered a batch of matrices and axis determines the axes in NDArray
+ * over which to compute a matrix norm.
+ * @param keepDims Optional. If true, the norm have the same dimensionality
+ * as the input.
+ */
+/** @doc {heading: 'Operations', subheading: 'Matrices'} */
+function norm_(x, ord = 'euclidean', axis = null, keepDims = false) {
+ x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'norm');
+ const norm = normImpl(x, ord, axis);
+ let keepDimsShape = norm.shape;
+ if (keepDims) {
+ const axes = Object(util["parseAxisParam"])(axis, x.shape);
+ keepDimsShape = expandShapeToKeepDim(norm.shape, axes);
+ }
+ return norm.reshape(keepDimsShape);
+}
+function normImpl(x, p, axis = null) {
+ if (x.rank === 0) {
+ return x.abs();
+ }
+ // consider vector when no axis is specified
+ if (x.rank !== 1 && axis === null) {
+ return normImpl(x.reshape([-1]), p, axis);
+ }
+ // vector
+ if (x.rank === 1 || typeof axis === 'number' ||
+ Array.isArray(axis) && axis.length === 1) {
+ if (p === 1) {
+ return x.abs().sum(axis);
+ }
+ if (p === Infinity) {
+ return x.abs().max(axis);
+ }
+ if (p === -Infinity) {
+ return x.abs().min(axis);
+ }
+ if (p === 'euclidean' || p === 2) {
+ // norm(x, 2) = sum(abs(xi) ^ 2) ^ 1/2
+ return x.abs().pow(Object(tensor_ops["e" /* scalar */])(2, 'int32')).sum(axis).sqrt();
+ }
+ throw new Error(`Error in norm: invalid ord value: ${p}`);
+ }
+ // matrix (assumption axis[0] < axis[1])
+ if (Array.isArray(axis) && axis.length === 2) {
+ if (p === 1) {
+ return x.abs().sum(axis[0]).max(axis[1] - 1);
+ }
+ if (p === Infinity) {
+ return x.abs().sum(axis[1]).max(axis[0]);
+ }
+ if (p === -Infinity) {
+ return x.abs().sum(axis[1]).min(axis[0]);
+ }
+ if (p === 'fro' || p === 'euclidean') {
+ // norm(x) = sqrt(sum(pow(x, 2)))
+ return x.square().sum(axis).sqrt();
+ }
+ throw new Error(`Error in norm: invalid ord value: ${p}`);
+ }
+ throw new Error(`Error in norm: invalid axis: ${axis}`);
+}
+const norm_norm = Object(operation["a" /* op */])({ norm_ });
+//# sourceMappingURL=norm.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/lstm.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+/**
+ * Computes the next states and outputs of a stack of LSTMCells.
+ *
+ * Each cell output is used as input to the next cell.
+ *
+ * Returns `[cellState, cellOutput]`.
+ *
+ * Derived from tf.contrib.rn.MultiRNNCell.
+ *
+ * @param lstmCells Array of LSTMCell functions.
+ * @param data The input to the cell.
+ * @param c Array of previous cell states.
+ * @param h Array of previous cell outputs.
+ */
+/** @doc {heading: 'Operations', subheading: 'RNN'} */
+function multiRNNCell_(lstmCells, data, c, h) {
+ const $data = Object(tensor_util_env["a" /* convertToTensor */])(data, 'data', 'multiRNNCell');
+ const $c = Object(tensor_util_env["b" /* convertToTensorArray */])(c, 'c', 'multiRNNCell');
+ const $h = Object(tensor_util_env["b" /* convertToTensorArray */])(h, 'h', 'multiRNNCell');
+ let input = $data;
+ const newStates = [];
+ for (let i = 0; i < lstmCells.length; i++) {
+ const output = lstmCells[i](input, $c[i], $h[i]);
+ newStates.push(output[0]);
+ newStates.push(output[1]);
+ input = output[1];
+ }
+ const newC = [];
+ const newH = [];
+ for (let i = 0; i < newStates.length; i += 2) {
+ newC.push(newStates[i]);
+ newH.push(newStates[i + 1]);
+ }
+ return [newC, newH];
+}
+/**
+ * Computes the next state and output of a BasicLSTMCell.
+ *
+ * Returns `[newC, newH]`.
+ *
+ * Derived from tf.contrib.rnn.BasicLSTMCell.
+ *
+ * @param forgetBias Forget bias for the cell.
+ * @param lstmKernel The weights for the cell.
+ * @param lstmBias The bias for the cell.
+ * @param data The input to the cell.
+ * @param c Previous cell state.
+ * @param h Previous cell output.
+ */
+/** @doc {heading: 'Operations', subheading: 'RNN'} */
+function basicLSTMCell_(forgetBias, lstmKernel, lstmBias, data, c, h) {
+ const $forgetBias = Object(tensor_util_env["a" /* convertToTensor */])(forgetBias, 'forgetBias', 'basicLSTMCell');
+ const $lstmKernel = Object(tensor_util_env["a" /* convertToTensor */])(lstmKernel, 'lstmKernel', 'basicLSTMCell');
+ const $lstmBias = Object(tensor_util_env["a" /* convertToTensor */])(lstmBias, 'lstmBias', 'basicLSTMCell');
+ const $data = Object(tensor_util_env["a" /* convertToTensor */])(data, 'data', 'basicLSTMCell');
+ const $c = Object(tensor_util_env["a" /* convertToTensor */])(c, 'c', 'basicLSTMCell');
+ const $h = Object(tensor_util_env["a" /* convertToTensor */])(h, 'h', 'basicLSTMCell');
+ const combined = $data.concat($h, 1);
+ const weighted = combined.matMul($lstmKernel);
+ const res = weighted.add($lstmBias);
+ // i = input_gate, j = new_input, f = forget_gate, o = output_gate
+ const batchSize = res.shape[0];
+ const sliceCols = res.shape[1] / 4;
+ const sliceSize = [batchSize, sliceCols];
+ const i = res.slice([0, 0], sliceSize);
+ const j = res.slice([0, sliceCols], sliceSize);
+ const f = res.slice([0, sliceCols * 2], sliceSize);
+ const o = res.slice([0, sliceCols * 3], sliceSize);
+ const newC = i.sigmoid().mul(j.tanh()).add($c.mul($forgetBias.add(f).sigmoid()));
+ const newH = newC.tanh().mul(o.sigmoid());
+ return [newC, newH];
+}
+const basicLSTMCell = Object(operation["a" /* op */])({ basicLSTMCell_ });
+const multiRNNCell = Object(operation["a" /* op */])({ multiRNNCell_ });
+//# sourceMappingURL=lstm.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/moving_average.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Compute the moving average of a variable.
+ *
+ * Without zeroDebias, the moving average operation is defined by:
+ * `v += delta`
+ * where
+ * `delta = (1 - decay) * (x - v)`
+ *
+ * With zeroDebias (default), the `delta` term is scaled to debias the
+ * effect of the (assumed) zero-initialization of `v`.
+ * `delta /= (1 - decay ^ step)`
+ *
+ * For more details on the zero-debiasing algorithm, see:
+ * https://arxiv.org/abs/1412.6980
+ *
+ * Note that this function is completely stateless and does not keep track of
+ * step count. The step count needs to be maintained by the caller and passed
+ * in as `step`.
+ *
+ * @param v The current moving average value.
+ * @param x New input value, must have the same shape and dtype as `v`.
+ * @param decay The decay factor. Typical values are 0.95 and 0.99.
+ * @param step Step count.
+ * @param zeroDebias: Whether zeroDebias is to be performed (default: `true`).
+ * @returns The new moving average value.
+ */
+/** @doc {heading: 'Operations', subheading: 'Moving Average'} */
+function movingAverage_(v, x, decay, step, zeroDebias = true) {
+ const $v = Object(tensor_util_env["a" /* convertToTensor */])(v, 'v', 'movingAverage');
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'movingAverage');
+ const $decay = Object(tensor_util_env["a" /* convertToTensor */])(decay, 'decay', 'movingAverage');
+ Object(tensor_util["assertTypesMatch"])($v, $x);
+ util["assert"](util["arraysEqual"]($v.shape, $x.shape), () => 'Shape mismatch in v and x');
+ const one = Object(tensor_ops["e" /* scalar */])(1);
+ const oneMinusDecay = one.sub($decay);
+ let update = $x.sub($v).mul(oneMinusDecay);
+ if (zeroDebias) {
+ util["assert"](step != null, () => 'When using zeroDebias: true, step is required.');
+ const $step = Object(tensor_util_env["a" /* convertToTensor */])(step, 'step', 'movingAverage');
+ update = update.div(one.sub(pow($decay, $step)));
+ }
+ return $v.add(update);
+}
+const movingAverage = Object(operation["a" /* op */])({ movingAverage_ });
+//# sourceMappingURL=moving_average.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/strided_slice.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Extracts a strided slice of a tensor.
+ *
+ * Roughly speaking, this op extracts a slice of size (end-begin)/stride from
+ * the given input tensor (x). Starting at the location specified by begin the
+ * slice continues by adding stride to the index until all dimensions are not
+ * less than end. Note that a stride can be negative, which causes a reverse
+ * slice.
+ *
+ * ```js
+ * const t = tf.tensor3d([1, 1, 1 ,2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6],
+ * [3, 2, 3]);
+ * t.stridedSlice([1, 0, 0], [2, 1, 3], [1, 1, 1]).print() // [[[3, 3, 3]]]
+ * t.stridedSlice([1, 0, 0], [2, 2, 3], [1, 1, 1]).print() // [[[3, 3, 3],
+ * // [4, 4, 4]]]
+ * t.stridedSlice([1, -1, 0], [2, -3, 3], [1, -1, 1]).print() // [[[4, 4, 4],
+ * // [3, 3, 3]]]
+ * ```
+ *
+ * @param x The tensor to stride slice.
+ * @param begin The coordinates to start the slice from.
+ * @param end: The coordinates to end the slice at.
+ * @param strides: The size of the slice.
+ * @param beginMask: If the ith bit of beginMask is set, begin[i] is ignored
+ * and the fullest possible range in that dimension is used instead.
+ * @param endMask: If the ith bit of endMask is set, end[i] is ignored
+ * and the fullest possible range in that dimension is used instead.
+ * @param shrinkAxisMask: a bitmask where bit i implies that
+ * the ith specification should shrink the dimensionality. begin and end must
+ * imply a slice of size 1 in the dimension.
+ */
+/** @doc {heading: 'Operations', subheading: 'Slicing and Joining'} */
+function stridedSlice_(x, begin, end, strides, beginMask = 0, endMask = 0, ellipsisMask = 0, newAxisMask = 0, shrinkAxisMask = 0) {
+ if (strides == null) {
+ strides = new Array(begin.length);
+ }
+ const ellipsisAxes = maskToAxes(ellipsisMask);
+ if (ellipsisAxes.length > 1) {
+ throw new Error('Multiple ellipses in slice is not allowed.');
+ }
+ if (ellipsisMask !== 0 && newAxisMask !== 0) {
+ throw new Error('Using both ellipsisMask and newAxisMask is not yet supported.');
+ }
+ if (ellipsisMask !== 0 && shrinkAxisMask !== 0) {
+ throw new Error('Using both ellipsisMask and shrinkAxisMask is not yet supported.');
+ }
+ let $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'stridedSlice');
+ const numInterpolatedAxes = $x.rank - begin.length;
+ // Expand the dims of x based on the newAxisMask.
+ const expandAxes = maskToAxes(newAxisMask);
+ const newShape = $x.shape.slice();
+ expandAxes.forEach(axis => {
+ begin[axis] = 0;
+ end[axis] = 1;
+ newShape.splice(axis, 0, 1);
+ });
+ $x = $x.reshape(newShape);
+ // Normalize the start, end and strides.
+ for (let axis = 0; axis < $x.rank; axis++) {
+ begin[axis] =
+ startForAxis(beginMask, begin, strides, $x.shape, axis, ellipsisMask);
+ end[axis] =
+ stopForAxis(endMask, end, strides, $x.shape, axis, ellipsisMask);
+ strides[axis] = stridesForAxis(strides, axis, ellipsisMask);
+ }
+ if (ellipsisAxes.length && numInterpolatedAxes > 0) {
+ const fullIndex = ellipsisAxes[0];
+ // The ellipsis applies to the masked index as well as any dimensions that
+ // were interpolated as full selection.
+ const numElidedAxes = numInterpolatedAxes + 1;
+ begin = startIndicesWithElidedDims(begin, fullIndex, numElidedAxes);
+ end = stopIndicesWithElidedDims(end, fullIndex, numElidedAxes, $x.shape);
+ strides = stridesWithElidedDims(strides, fullIndex, numElidedAxes);
+ }
+ const shrinkAxes = maskToAxes(shrinkAxisMask);
+ // Adjust the ends based on the shrink mask.
+ shrinkAxes.forEach(axis => {
+ end[axis] = begin[axis] + 1;
+ strides[axis] = 1;
+ });
+ // Figure out the output shape.
+ const size = slice_util_computeOutShape(begin, end, strides);
+ // Remove the axes based on shrinkMask.
+ const outShape = size.filter((_, axis) => shrinkAxes.indexOf(axis) === -1);
+ const nonStrided = strides.every(v => v === 1);
+ if (nonStrided) {
+ return slice($x, begin, size).reshape(outShape);
+ }
+ const res = engine["a" /* ENGINE */].runKernelFunc(backend => backend.stridedSlice($x, begin, end, strides), { $x });
+ return res.reshape(outShape);
+}
+const stridedSlice = Object(operation["a" /* op */])({ stridedSlice_ });
+//# sourceMappingURL=strided_slice.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/topk.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Finds the values and indices of the `k` largest entries along the last
+ * dimension.
+ *
+ * If the input is a vector (rank=1), finds the k largest entries in the vector
+ * and outputs their values and indices as vectors. Thus values[j] is the j-th
+ * largest entry in input, and its index is indices[j].
+ * For higher rank inputs, computes the top k entries along the last dimension.
+ *
+ * If two elements are equal, the lower-index element appears first.
+ *
+ * ```js
+ * const a = tf.tensor2d([[1, 5], [4, 3]]);
+ * const {values, indices} = tf.topk(a);
+ * values.print();
+ * indices.print();
+ * ```
+ * @param x 1-D or higher `tf.Tensor` with last dimension being at least `k`.
+ * @param k Number of top elements to look for along the last dimension.
+ * @param sorted If true, the resulting `k` elements will be sorted by the
+ * values in descending order.
+ */
+/** @doc {heading: 'Operations', subheading: 'Evaluation'} */
+function topk_(x, k = 1, sorted = true) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'topk');
+ if ($x.rank === 0) {
+ throw new Error('topk() expects the input to be of rank 1 or higher');
+ }
+ const lastDim = $x.shape[$x.shape.length - 1];
+ if (k > lastDim) {
+ throw new Error(`'k' passed to topk() must be <= the last dimension (${lastDim}) ` +
+ `but got ${k}`);
+ }
+ const [values, indices] = engine["a" /* ENGINE */].runKernelFunc(b => b.topk($x, k, sorted), { $x });
+ return { values, indices };
+}
+const topk = Object(operation["a" /* op */])({ topk_ });
+//# sourceMappingURL=topk.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/scatter_nd.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Creates a new tensor by applying sparse updates to individual
+ * values or slices within a zero tensor of the given shape tensor according to
+ * indices. This operator is the inverse of the `tf.gatherND` operator which
+ * extracts values or slices from a given tensor.
+ *
+ * ```js
+ * const indices = tf.tensor2d([4, 3, 1, 7], [4, 1], 'int32');
+ * const updates = tf.tensor1d([9, 10, 11, 12]);
+ * const shape = [8];
+ * tf.scatterND(indices, updates, shape).print() //[0, 11, 0, 10, 9, 0, 0, 12]
+ * ```
+ *
+ * @param indices The tensor contains the indices into the output tensor.
+ * @param updates The tensor contains the value for the indices.
+ * @param shape: The shape of the output tensor.
+ */
+/** @doc {heading: 'Operations', subheading: 'Slicing and Joining'} */
+function scatterND_(indices, updates, shape) {
+ const $indices = Object(tensor_util_env["a" /* convertToTensor */])(indices, 'indices', 'scatterND', 'int32');
+ const $updates = Object(tensor_util_env["a" /* convertToTensor */])(updates, 'updates', 'scatterND');
+ validateInput($updates, $indices, shape);
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.scatterND($indices, $updates, shape), { indices: $indices, updates: $updates }, null /* backward */, 'ScatterNd', { shape });
+}
+const scatterND = Object(operation["a" /* op */])({ scatterND_ });
+//# sourceMappingURL=scatter_nd.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/spectral_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Fast Fourier transform.
+ *
+ * Computes the 1-dimensional discrete Fourier transform over the inner-most
+ * dimension of input.
+ *
+ * ```js
+ * const real = tf.tensor1d([1, 2, 3]);
+ * const imag = tf.tensor1d([1, 2, 3]);
+ * const x = tf.complex(real, imag);
+ *
+ * x.fft().print(); // tf.spectral.fft(x).print();
+ * ```
+ * @param input The complex input to compute an fft over.
+ */
+/**
+ * @doc {heading: 'Operations', subheading: 'Spectral', namespace: 'spectral'}
+ */
+function fft_(input) {
+ Object(util["assert"])(input.dtype === 'complex64', () => `The dtype for tf.spectral.fft() must be complex64 ` +
+ `but got ${input.dtype}.`);
+ // Collapse all outer dimensions to a single batch dimension.
+ const innerDimensionSize = input.shape[input.shape.length - 1];
+ const batch = input.size / innerDimensionSize;
+ const input2D = input.as2D(batch, innerDimensionSize);
+ const ret = engine["a" /* ENGINE */].runKernelFunc(backend => backend.fft(input2D), { input });
+ return ret.reshape(input.shape);
+}
+/**
+ * Inverse fast Fourier transform.
+ *
+ * Computes the inverse 1-dimensional discrete Fourier transform over the
+ * inner-most dimension of input.
+ *
+ * ```js
+ * const real = tf.tensor1d([1, 2, 3]);
+ * const imag = tf.tensor1d([1, 2, 3]);
+ * const x = tf.complex(real, imag);
+ *
+ * x.ifft().print(); // tf.spectral.ifft(x).print();
+ * ```
+ * @param input The complex input to compute an ifft over.
+ */
+/**
+ * @doc {heading: 'Operations', subheading: 'Spectral', namespace: 'spectral'}
+ */
+function ifft_(input) {
+ Object(util["assert"])(input.dtype === 'complex64', () => `The dtype for tf.spectral.ifft() must be complex64 ` +
+ `but got ${input.dtype}.`);
+ // Collapse all outer dimensions to a single batch dimension.
+ const innerDimensionSize = input.shape[input.shape.length - 1];
+ const batch = input.size / innerDimensionSize;
+ const input2D = input.as2D(batch, innerDimensionSize);
+ const ret = engine["a" /* ENGINE */].runKernelFunc(backend => backend.ifft(input2D), { input });
+ return ret.reshape(input.shape);
+}
+/**
+ * Real value input fast Fourier transform.
+ *
+ * Computes the 1-dimensional discrete Fourier transform over the
+ * inner-most dimension of the real input.
+ *
+ * ```js
+ * const real = tf.tensor1d([1, 2, 3]);
+ *
+ * real.rfft().print();
+ * ```
+ * @param input The real value input to compute an rfft over.
+ */
+/**
+ * @doc {heading: 'Operations', subheading: 'Spectral', namespace: 'spectral'}
+ */
+function rfft_(input, fftLength) {
+ Object(util["assert"])(input.dtype === 'float32', () => `The dtype for rfft() must be real value but got ${input.dtype}`);
+ let innerDimensionSize = input.shape[input.shape.length - 1];
+ const batch = input.size / innerDimensionSize;
+ let adjustedInput;
+ if (fftLength != null && fftLength < innerDimensionSize) {
+ // Need to crop
+ const begin = input.shape.map(v => 0);
+ const size = input.shape.map(v => v);
+ size[input.shape.length - 1] = fftLength;
+ adjustedInput = input.slice(begin, size);
+ innerDimensionSize = fftLength;
+ }
+ else if (fftLength != null && fftLength > innerDimensionSize) {
+ // Need to pad with zeros
+ const zerosShape = input.shape.map(v => v);
+ zerosShape[input.shape.length - 1] = fftLength - innerDimensionSize;
+ adjustedInput = input.concat(Object(tensor_ops["n" /* zeros */])(zerosShape), input.shape.length - 1);
+ innerDimensionSize = fftLength;
+ }
+ else {
+ adjustedInput = input;
+ }
+ // Complement the input with zero imaginary numbers.
+ const zerosInput = adjustedInput.zerosLike();
+ const complexInput = Object(complex["a" /* complex */])(adjustedInput, zerosInput).as2D(batch, innerDimensionSize);
+ const ret = fft(complexInput);
+ // Exclude complex conjugations. These conjugations are put symmetrically.
+ const half = Math.floor(innerDimensionSize / 2) + 1;
+ const realValues = Object(real["a" /* real */])(ret);
+ const imagValues = Object(imag["a" /* imag */])(ret);
+ const realComplexConjugate = realValues.split([half, innerDimensionSize - half], realValues.shape.length - 1);
+ const imagComplexConjugate = imagValues.split([half, innerDimensionSize - half], imagValues.shape.length - 1);
+ const outputShape = adjustedInput.shape.slice();
+ outputShape[adjustedInput.shape.length - 1] = half;
+ return Object(complex["a" /* complex */])(realComplexConjugate[0], imagComplexConjugate[0])
+ .reshape(outputShape);
+}
+/**
+ * Inversed real value input fast Fourier transform.
+ *
+ * Computes the 1-dimensional inversed discrete Fourier transform over the
+ * inner-most dimension of the real input.
+ *
+ * ```js
+ * const real = tf.tensor1d([1, 2, 3]);
+ * const imag = tf.tensor1d([0, 0, 0]);
+ * const x = tf.complex(real, imag);
+ *
+ * x.irfft().print();
+ * ```
+ * @param input The real value input to compute an irfft over.
+ */
+/**
+ * @doc {heading: 'Operations', subheading: 'Spectral', namespace: 'spectral'}
+ */
+function irfft_(input) {
+ const innerDimensionSize = input.shape[input.shape.length - 1];
+ const batch = input.size / innerDimensionSize;
+ if (innerDimensionSize <= 2) {
+ const complexInput = input.as2D(batch, innerDimensionSize);
+ const ret = ifft(complexInput);
+ return Object(real["a" /* real */])(ret);
+ }
+ else {
+ // The length of unique components of the DFT of a real-valued signal
+ // is 2 * (input_len - 1)
+ const outputShape = [batch, 2 * (innerDimensionSize - 1)];
+ const realInput = Object(real["a" /* real */])(input).as2D(batch, innerDimensionSize);
+ const imagInput = Object(imag["a" /* imag */])(input).as2D(batch, innerDimensionSize);
+ const realConjugate = realInput.slice([0, 1], [batch, innerDimensionSize - 2]).reverse(1);
+ const imagConjugate = imagInput.slice([0, 1], [batch, innerDimensionSize - 2])
+ .reverse(1)
+ .mul(Object(tensor_ops["e" /* scalar */])(-1));
+ const r = realInput.concat(realConjugate, 1);
+ const i = imagInput.concat(imagConjugate, 1);
+ const complexInput = Object(complex["a" /* complex */])(r, i).as2D(outputShape[0], outputShape[1]);
+ const ret = ifft(complexInput);
+ return Object(real["a" /* real */])(ret);
+ }
+}
+const fft = Object(operation["a" /* op */])({ fft_ });
+const ifft = Object(operation["a" /* op */])({ ifft_ });
+const rfft = Object(operation["a" /* op */])({ rfft_ });
+const irfft = Object(operation["a" /* op */])({ irfft_ });
+//# sourceMappingURL=spectral_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/sparse_to_dense_util.js
+/**
+ * Validate sparseToDense inputs.
+ *
+ * @param sparseIndices A 0-D, 1-D, or 2-D Tensor of type int32.
+ * sparseIndices[i] contains the complete index where sparseValues[i] will be
+ * placed.
+ * @param sparseValues A 0-D or 1-D Tensor. Values
+ * corresponding to each row of sparseIndices, or a scalar value to be used for
+ * all sparse indices.
+ * @param outputShape number[]. Shape of the dense output tensor.
+ * @param validateIndices boolean. indice validation is not supported, error
+ * will be thrown if it is set.
+ */
+function sparse_to_dense_util_validateInput(sparseIndices, sparseValues, outputShape, defaultValues) {
+ if (sparseIndices.dtype !== 'int32') {
+ throw new Error('tf.sparseToDense() expects the indices to be int32 type,' +
+ ` but the dtype was ${sparseIndices.dtype}.`);
+ }
+ if (sparseIndices.rank > 2) {
+ throw new Error('sparseIndices should be a scalar, vector, or matrix,' +
+ ` but got shape ${sparseIndices.shape}.`);
+ }
+ const numElems = sparseIndices.rank > 0 ? sparseIndices.shape[0] : 1;
+ const numDims = sparseIndices.rank > 1 ? sparseIndices.shape[1] : 1;
+ if (outputShape.length !== numDims) {
+ throw new Error('outputShape has incorrect number of elements:,' +
+ ` ${outputShape.length}, should be: ${numDims}.`);
+ }
+ const numValues = sparseValues.size;
+ if (!(sparseValues.rank === 0 ||
+ sparseValues.rank === 1 && numValues === numElems)) {
+ throw new Error('sparseValues has incorrect shape ' +
+ `${sparseValues.shape}, should be [] or [${numElems}]`);
+ }
+ if (sparseValues.dtype !== defaultValues.dtype) {
+ throw new Error('sparseValues.dtype must match defaultValues.dtype');
+ }
+}
+//# sourceMappingURL=sparse_to_dense_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/sparse_to_dense.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Converts a sparse representation into a dense tensor.
+ *
+ * Builds an array dense with shape outputShape such that:
+ *
+ * // If sparseIndices is scalar
+ * dense[i] = (i == sparseIndices ? sparseValues : defaultValue)
+ *
+ * // If sparseIndices is a vector, then for each i
+ * dense[sparseIndices[i]] = sparseValues[i]
+ *
+ * // If sparseIndices is an n by d matrix, then for each i in [0, n)
+ * dense[sparseIndices[i][0], ..., sparseIndices[i][d-1]] = sparseValues[i]
+ * All other values in dense are set to defaultValue. If sparseValues is a
+ * scalar, all sparse indices are set to this single value.
+ *
+ * If indices are repeated the final value is summed over all values for those
+ * indices.
+ *
+ * ```js
+ * const indices = tf.tensor1d([4, 5, 6, 1, 2, 3], 'int32');
+ * const values = tf.tensor1d([10, 11, 12, 13, 14, 15], 'float32');
+ * const shape = [8];
+ * tf.sparseToDense(indices, values, shape).print();
+ * ```
+ *
+ * @param sparseIndices A 0-D, 1-D, or 2-D Tensor of type int32.
+ * sparseIndices[i] contains the complete index where sparseValues[i] will be
+ * placed.
+ * @param sparseValues A 0-D or 1-D Tensor. Values
+ * corresponding to each row of sparseIndices, or a scalar value to be used for
+ * all sparse indices.
+ * @param outputShape Shape of the dense output tensor. the type is inferred.
+ * @param defaultValue Scalar. Value to set for indices not specified in
+ * sparseIndices. Defaults to zero.
+ */
+/** @doc {heading: 'Operations', subheading: 'Normalization'} */
+function sparseToDense_(sparseIndices, sparseValues, outputShape, defaultValue = 0) {
+ const $sparseIndices = Object(tensor_util_env["a" /* convertToTensor */])(sparseIndices, 'sparseIndices', 'sparseToDense', 'int32');
+ const $sparseValues = Object(tensor_util_env["a" /* convertToTensor */])(sparseValues, 'sparseValues', 'sparseToDense');
+ const $defaultValue = Object(tensor_util_env["a" /* convertToTensor */])(defaultValue, 'defaultValue', 'sparseToDense', $sparseValues.dtype);
+ sparse_to_dense_util_validateInput($sparseIndices, $sparseValues, outputShape, $defaultValue);
+ return engine["a" /* ENGINE */].runKernelFunc(backend => backend.sparseToDense($sparseIndices, $sparseValues, outputShape, $defaultValue), { $sparseIndices, $sparseValues, $defaultValue });
+}
+const sparseToDense = Object(operation["a" /* op */])({ sparseToDense_ });
+//# sourceMappingURL=sparse_to_dense.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/gather_nd.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Gather slices from input tensor into a Tensor with shape specified by
+ * `indices`.
+ *
+ * `indices` is an K-dimensional integer tensor, best thought of as a
+ * (K-1)-dimensional tensor of indices into input, where each element defines a
+ * slice of input:
+ * output[\\(i_0, ..., i_{K-2}\\)] = input[indices[\\(i_0, ..., i_{K-2}\\)]]
+ *
+ * Whereas in `tf.gather`, `indices` defines slices into the first dimension of
+ * input, in `tf.gatherND`, `indices` defines slices into the first N dimensions
+ * of input, where N = indices.shape[-1].
+ *
+ * The last dimension of indices can be at most the rank of input:
+ * indices.shape[-1] <= input.rank
+ *
+ * The last dimension of `indices` corresponds to elements
+ * (if indices.shape[-1] == input.rank) or slices
+ * (if indices.shape[-1] < input.rank) along dimension indices.shape[-1] of
+ * input.
+ * The output tensor has shape
+ * indices.shape[:-1] + input.shape[indices.shape[-1]:]
+ *
+ * Note that on CPU, if an out of bound index is found, an error is returned. On
+ * GPU, if an out of bound index is found, a 0 is stored in the corresponding
+ * output value.
+ *
+ * ```js
+ * const indices = tf.tensor2d([0, 1, 1, 0], [2,2], 'int32');
+ * const input = tf.tensor2d([9, 10, 11, 12], [2, 2]);
+ * tf.gatherND(input, indices).print() // [10, 11]
+ * ```
+ *
+ * @param x The tensor from which to gather values.
+ * @param indices Index tensor, must be of type int32.
+ */
+/** @doc {heading: 'Operations', subheading: 'Slicing and Joining'} */
+function gatherND_(x, indices) {
+ const $indices = Object(tensor_util_env["a" /* convertToTensor */])(indices, 'indices', 'gatherND', 'int32');
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'gatherND');
+ const forward = (backend) => {
+ return backend.gatherND($x, $indices);
+ };
+ const inputs = { params: $x, indices: $indices };
+ return engine["a" /* ENGINE */].runKernelFunc(forward, inputs, null /* gradient */, kernel_names["G" /* GatherNd */]);
+}
+const gatherND = Object(operation["a" /* op */])({ gatherND_ });
+//# sourceMappingURL=gather_nd.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/dropout_util.js
+/**
+ * @license
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+/**
+ * Normalize noise shape based on provided tensor and noise shape.
+ *
+ * @param x Tensor.
+ * @param noiseShape The shape for the randomly generated keep/drop flags, as
+ * an array of numbers. Optional.
+ * @returns Normalized noise shape.
+ */
+function getNoiseShape(x, noiseShape) {
+ if (noiseShape == null) {
+ return x.shape.slice();
+ }
+ if (util["arraysEqual"](x.shape, noiseShape)) {
+ return noiseShape;
+ }
+ if (x.shape.length === noiseShape.length) {
+ const newDimension = [];
+ for (let i = 0; i < x.shape.length; i++) {
+ if (noiseShape[i] == null && x.shape[i] != null) {
+ newDimension.push(x.shape[i]);
+ }
+ else {
+ newDimension.push(noiseShape[i]);
+ }
+ }
+ return newDimension;
+ }
+ return noiseShape;
+}
+//# sourceMappingURL=dropout_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/dropout.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+/**
+ * Computes dropout.
+ *
+ * ```js
+ * const x = tf.tensor1d([1, 2, 2, 1]);
+ * const rate = 0.75;
+ * const output = tf.dropout(x, rate);
+ * output.print();
+ * ```
+ *
+ * @param x A floating point Tensor or TensorLike.
+ * @param rate A float in the range [0, 1). The probability that each element
+ * of x is discarded.
+ * @param noiseShape An array of numbers of type int32, representing the
+ * shape for randomly generated keep/drop flags. If the noiseShape has null
+ * value, it will be automatically replaced with the x's relative dimension
+ * size. Optional.
+ * @param seed Used to create random seeds. Optional.
+ * @returns A Tensor of the same shape of x.
+ */
+/** @doc {heading: 'Operations', subheading: 'Dropout'} */
+function dropout_(x, rate, noiseShape, seed) {
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'dropout');
+ util["assert"]($x.dtype === 'float32', () => `x has to be a floating point tensor since it's going to be ` +
+ `scaled, but got a ${$x.dtype} tensor instead.`);
+ util["assert"](rate >= 0 && rate < 1, () => `rate must be a float in the range [0, 1), but got ${rate}.`);
+ if (rate === 0) {
+ return x instanceof dist_tensor["a" /* Tensor */] ? $x.clone() : $x;
+ }
+ const $noiseShape = getNoiseShape($x, noiseShape);
+ const keepProb = 1 - rate;
+ const multiplier = randomUniform($noiseShape, 0, 1, 'float32', seed)
+ .add(keepProb)
+ .floor()
+ .div(keepProb);
+ return $x.mul(multiplier);
+}
+const dropout = Object(operation["a" /* op */])({ dropout_ });
+//# sourceMappingURL=dropout.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/signal_ops.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Generate a Hann window.
+ *
+ * See: https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows
+ *
+ * ```js
+ * tf.signal.hannWindow(10).print();
+ * ```
+ * @param The length of window
+ */
+/**
+ * @doc {heading: 'Operations', subheading: 'Signal', namespace: 'signal'}
+ */
+function hannWindow_(windowLength) {
+ return cosineWindow(windowLength, 0.5, 0.5);
+}
+/**
+ * Generate a hamming window.
+ *
+ * See: https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows
+ *
+ * ```js
+ * tf.signal.hammingWindow(10).print();
+ * ```
+ * @param The length of window
+ */
+/**
+ * @doc {heading: 'Operations', subheading: 'Signal', namespace: 'signal'}
+ */
+function hammingWindow_(windowLength) {
+ return cosineWindow(windowLength, 0.54, 0.46);
+}
+/**
+ * Expands input into frames of frameLength.
+ * Slides a window size with frameStep.
+ *
+ * ```js
+ * tf.signal.frame([1, 2, 3], 2, 1).print();
+ * ```
+ * @param signal The input tensor to be expanded
+ * @param frameLength Length of each frame
+ * @param frameStep The frame hop size in samples.
+ * @param padEnd Whether to pad the end of signal with padValue.
+ * @param padValue An number to use where the input signal does
+ * not exist when padEnd is True.
+ */
+/**
+ * @doc {heading: 'Operations', subheading: 'Signal', namespace: 'signal'}
+ */
+function frame_(signal, frameLength, frameStep, padEnd = false, padValue = 0) {
+ let start = 0;
+ const output = [];
+ while (start + frameLength <= signal.size) {
+ output.push(slice(signal, start, frameLength));
+ start += frameStep;
+ }
+ if (padEnd) {
+ while (start < signal.size) {
+ const padLen = (start + frameLength) - signal.size;
+ const pad = concat([
+ slice(signal, start, frameLength - padLen), fill([padLen], padValue)
+ ]);
+ output.push(pad);
+ start += frameStep;
+ }
+ }
+ if (output.length === 0) {
+ return Object(tensor_ops["h" /* tensor2d */])([], [0, frameLength]);
+ }
+ return concat(output).as2D(output.length, frameLength);
+}
+/**
+ * Computes the Short-time Fourier Transform of signals
+ * See: https://en.wikipedia.org/wiki/Short-time_Fourier_transform
+ *
+ * ```js
+ * const input = tf.tensor1d([1, 1, 1, 1, 1])
+ * tf.signal.stft(input, 3, 1).print();
+ * ```
+ * @param signal 1-dimensional real value tensor.
+ * @param frameLength The window length of samples.
+ * @param frameStep The number of samples to step.
+ * @param fftLength The size of the FFT to apply.
+ * @param windowFn A callable that takes a window length and returns 1-d tensor.
+ */
+/**
+ * @doc {heading: 'Operations', subheading: 'Signal', namespace: 'signal'}
+ */
+function stft_(signal, frameLength, frameStep, fftLength, windowFn = hannWindow) {
+ if (fftLength == null) {
+ fftLength = enclosingPowerOfTwo(frameLength);
+ }
+ const framedSignal = signal_ops_frame(signal, frameLength, frameStep);
+ const windowedSignal = mul(framedSignal, windowFn(frameLength));
+ const output = [];
+ for (let i = 0; i < framedSignal.shape[0]; i++) {
+ output.push(rfft(windowedSignal.slice([i, 0], [1, frameLength]), fftLength));
+ }
+ return concat(output);
+}
+function enclosingPowerOfTwo(value) {
+ // Return 2**N for integer N such that 2**N >= value.
+ return Math.floor(Math.pow(2, Math.ceil(Math.log(value) / Math.log(2.0))));
+}
+function cosineWindow(windowLength, a, b) {
+ const even = 1 - windowLength % 2;
+ const newValues = new Float32Array(windowLength);
+ for (let i = 0; i < windowLength; ++i) {
+ const cosArg = (2.0 * Math.PI * i) / (windowLength + even - 1);
+ newValues[i] = a - b * Math.cos(cosArg);
+ }
+ return Object(tensor_ops["g" /* tensor1d */])(newValues, 'float32');
+}
+const hannWindow = Object(operation["a" /* op */])({ hannWindow_ });
+const hammingWindow = Object(operation["a" /* op */])({ hammingWindow_ });
+const signal_ops_frame = Object(operation["a" /* op */])({ frame_ });
+const stft = Object(operation["a" /* op */])({ stft_ });
+//# sourceMappingURL=signal_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/in_top_k.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * Returns whether the targets are in the top K predictions.
+ *
+ * ```js
+ * const predictions = tf.tensor2d([[20, 10, 40, 30], [30, 50, -20, 10]]);
+ * const targets = tf.tensor1d([2, 0]);
+ * const precision = await tf.inTopKAsync(predictions, targets);
+ * precision.print();
+ * ```
+ * @param predictions 2-D or higher `tf.Tensor` with last dimension being
+ * at least `k`.
+ * @param targets 1-D or higher `tf.Tensor`.
+ * @param k Optional Number of top elements to look at for computing precision,
+ * default to 1.
+ */
+/** @doc {heading: 'Operations', subheading: 'Evaluation'} */
+async function inTopKAsync_(predictions, targets, k = 1) {
+ const $predictions = Object(tensor_util_env["a" /* convertToTensor */])(predictions, 'predictions', 'inTopK');
+ const $targets = Object(tensor_util_env["a" /* convertToTensor */])(targets, 'targets', 'inTopK');
+ Object(util["assert"])($predictions.rank > 1, () => 'inTopK() expects the predictions to be of rank 2 or higher, ' +
+ `but got ${$predictions.rank}`);
+ Object(util["assert"])($predictions.rank - 1 === $targets.rank, () => `predictions rank should be 1 larger than ` +
+ `targets rank, but got predictions rank ` +
+ `${$predictions.rank} and targets rank ${$targets.rank}`);
+ Object(util["assertShapesMatch"])($predictions.shape.slice(0, $predictions.shape.length - 1), $targets.shape, `predictions's shape should be align with the targets' shape, ` +
+ 'except the last dimension.');
+ const lastDim = $predictions.shape[$predictions.shape.length - 1];
+ Object(util["assert"])(k > 0 && k <= lastDim, () => `'k' passed to inTopK() must be > 0 && <= the predictions last ` +
+ `dimension (${lastDim}), but got ${k}`);
+ const predictionsVals = await $predictions.data();
+ const targetsVals = await $targets.data();
+ // Reshape predictionsVals into a 2d tensor [batch, lastDim]
+ // and look up topK along lastDim.
+ const [batch, size] = [predictionsVals.length / lastDim, lastDim];
+ const precision = Object(util["getTypedArrayFromDType"])('bool', batch);
+ for (let b = 0; b < batch; b++) {
+ const offset = b * size;
+ const vals = predictionsVals.subarray(offset, offset + size);
+ const valAndInd = [];
+ for (let i = 0; i < vals.length; i++) {
+ valAndInd.push({ value: vals[i], index: i });
+ }
+ valAndInd.sort((a, b) => b.value - a.value);
+ precision[b] = 0;
+ for (let i = 0; i < k; i++) {
+ if (valAndInd[i].index === targetsVals[b]) {
+ precision[b] = 1;
+ break;
+ }
+ }
+ }
+ if (predictions !== $predictions) {
+ $predictions.dispose();
+ }
+ if (targets !== $targets) {
+ $targets.dispose();
+ }
+ // Output precision has the same shape as targets.
+ return Object(tensor_ops["f" /* tensor */])(precision, $targets.shape, 'bool');
+}
+const inTopKAsync = inTopKAsync_;
+//# sourceMappingURL=in_top_k.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/loss_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+var Reduction;
+(function (Reduction) {
+ Reduction[Reduction["NONE"] = 0] = "NONE";
+ Reduction[Reduction["MEAN"] = 1] = "MEAN";
+ Reduction[Reduction["SUM"] = 2] = "SUM";
+ Reduction[Reduction["SUM_BY_NONZERO_WEIGHTS"] = 3] = "SUM_BY_NONZERO_WEIGHTS";
+})(Reduction || (Reduction = {}));
+/**
+ * Computes the weighted loss between two tensors.
+ *
+ * @param losses Tensor of shape `[batch_size, d1, ... dN]`.
+ * @param weights Tensor whose rank is either 0, or the same rank as
+ * `losses`, and must be broadcastable to `losses` (i.e., all
+ * dimensions must be either `1`, or the same as the corresponding
+ * `losses` dimension).
+ */
+/** @doc {heading: 'Training', subheading: 'Losses', namespace: 'losses'} */
+function computeWeightedLoss_(losses, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ const $losses = Object(tensor_util_env["a" /* convertToTensor */])(losses, 'losses', 'computeWeightedLoss');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'computeWeightedLoss');
+ }
+ const weightedLoss = ($weights == null) ? $losses : $losses.mul($weights);
+ if (reduction === Reduction.NONE) {
+ return weightedLoss;
+ }
+ if (reduction === Reduction.SUM) {
+ return weightedLoss.sum();
+ }
+ if (reduction === Reduction.MEAN) {
+ if ($weights == null) {
+ return weightedLoss.mean();
+ }
+ else {
+ const broadcastFactor = $losses.size / $weights.size;
+ const result = weightedLoss.sum().div($weights.sum());
+ return broadcastFactor > 1 ? result.div(Object(tensor_ops["e" /* scalar */])(broadcastFactor)) :
+ result;
+ }
+ }
+ if (reduction === Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ if ($weights == null) {
+ return weightedLoss.sum().div(Object(tensor_ops["e" /* scalar */])($losses.size));
+ }
+ else {
+ const broadcastedWeights = $weights.mul(Object(tensor_ops["b" /* ones */])($losses.shape));
+ const numNonZeros = broadcastedWeights.notEqual(Object(tensor_ops["e" /* scalar */])(0)).sum().toFloat();
+ return weightedLoss.sum().div(numNonZeros);
+ }
+ }
+ throw Error(`Unknown reduction: ${reduction}`);
+}
+/**
+ * Computes the absolute difference loss between two tensors.
+ *
+ * @param labels The ground truth output tensor, same dimensions as
+ * 'predictions'.
+ * @param predictions The predicted outputs.
+ * @param weights Tensor whose rank is either 0, or the same rank as
+ * `labels`, and must be broadcastable to `labels` (i.e., all dimensions
+ * must be either `1`, or the same as the corresponding `losses`
+ * dimension).
+ * @param reduction Type of reduction to apply to loss. Should be of type
+ * `Reduction`
+ */
+/** @doc {heading: 'Training', subheading: 'Losses', namespace: 'losses'} */
+function absoluteDifference_(labels, predictions, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ const $labels = Object(tensor_util_env["a" /* convertToTensor */])(labels, 'labels', 'absoluteDifference');
+ const $predictions = Object(tensor_util_env["a" /* convertToTensor */])(predictions, 'predictions', 'absoluteDifference');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'absoluteDifference');
+ }
+ Object(util["assertShapesMatch"])($labels.shape, $predictions.shape, 'Error in absoluteDifference: ');
+ const losses = $labels.sub($predictions).abs();
+ return computeWeightedLoss(losses, $weights, reduction);
+}
+/**
+ * Computes the mean squared error between two tensors.
+ *
+ * @param labels The ground truth output tensor, same dimensions as
+ * 'predictions'.
+ * @param predictions The predicted outputs.
+ * @param weights Tensor whose rank is either 0, or the same rank as
+ * `labels`, and must be broadcastable to `labels` (i.e., all dimensions
+ * must be either `1`, or the same as the corresponding `losses`
+ * dimension).
+ * @param reduction Type of reduction to apply to loss. Should be of type
+ * `Reduction`
+ */
+/** @doc {heading: 'Training', subheading: 'Losses', namespace: 'losses'} */
+function meanSquaredError_(labels, predictions, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ const $labels = Object(tensor_util_env["a" /* convertToTensor */])(labels, 'labels', 'meanSquaredError');
+ const $predictions = Object(tensor_util_env["a" /* convertToTensor */])(predictions, 'predictions', 'meanSquaredError');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'meanSquaredError');
+ }
+ Object(util["assertShapesMatch"])($labels.shape, $predictions.shape, 'Error in meanSquaredError: ');
+ const losses = $labels.squaredDifference($predictions);
+ return computeWeightedLoss(losses, $weights, reduction);
+}
+/**
+ * Computes the cosine distance loss between two tensors.
+ *
+ * @param labels The ground truth output tensor, same dimensions as
+ * 'predictions'.
+ * @param predictions The predicted outputs.
+ * @param axis The dimension along which the cosine distance is computed.
+ * @param weights Tensor whose rank is either 0, or the same rank as
+ * `labels`, and must be broadcastable to `labels` (i.e., all dimensions
+ * must be either `1`, or the same as the corresponding `losses`
+ * dimension).
+ * @param reduction Type of reduction to apply to loss. Should be of type
+ * `Reduction`
+ */
+/** @doc {heading: 'Training', subheading: 'Losses', namespace: 'losses'} */
+function cosineDistance_(labels, predictions, axis, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ const $labels = Object(tensor_util_env["a" /* convertToTensor */])(labels, 'labels', 'cosineDistance');
+ const $predictions = Object(tensor_util_env["a" /* convertToTensor */])(predictions, 'predictions', 'cosineDistance');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'cosineDistance');
+ }
+ Object(util["assertShapesMatch"])($labels.shape, $predictions.shape, 'Error in cosineDistance: ');
+ const one = Object(tensor_ops["e" /* scalar */])(1);
+ const losses = one.sub($labels.mul($predictions).sum(axis, true));
+ return computeWeightedLoss(losses, $weights, reduction);
+}
+/**
+ * Computes the Hinge loss between two tensors.
+ *
+ * @param labels The ground truth output tensor, same dimensions as
+ * 'predictions'.
+ * @param predictions The predicted outputs.
+ * @param weights Tensor whose rank is either 0, or the same rank as
+ * `labels`, and must be broadcastable to `labels` (i.e., all dimensions
+ * must be either `1`, or the same as the corresponding `losses`
+ * dimension).
+ * @param reduction Type of reduction to apply to loss. Should be of type
+ * `Reduction`
+ */
+/** @doc {heading: 'Training', subheading: 'Losses', namespace: 'losses'} */
+function hingeLoss_(labels, predictions, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ let $labels = Object(tensor_util_env["a" /* convertToTensor */])(labels, 'labels', 'hingeLoss');
+ const $predictions = Object(tensor_util_env["a" /* convertToTensor */])(predictions, 'predictions', 'hingeLoss');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'hingeLoss');
+ }
+ Object(util["assertShapesMatch"])($labels.shape, $predictions.shape, 'Error in hingeLoss: ');
+ const one = Object(tensor_ops["e" /* scalar */])(1);
+ // Convert binary labels to (-1, 1)
+ $labels = Object(tensor_ops["e" /* scalar */])(2).mul($labels).sub(one);
+ const losses = one.sub($labels.mul($predictions)).relu();
+ return computeWeightedLoss(losses, $weights, reduction);
+}
+/**
+ * Computes the log loss between two tensors.
+ *
+ * @param labels The ground truth output tensor, same dimensions as
+ * 'predictions'.
+ * @param predictions The predicted outputs.
+ * @param weights Tensor whose rank is either 0, or the same rank as
+ * `labels`, and must be broadcastable to `labels` (i.e., all dimensions
+ * must be either `1`, or the same as the corresponding `losses`
+ * dimension).
+ * @param epsilon A small increment to avoid taking log of zero
+ * @param reduction Type of reduction to apply to loss. Should be of type
+ * `Reduction`
+ */
+/** @doc {heading: 'Training', subheading: 'Losses', namespace: 'losses'} */
+function logLoss_(labels, predictions, weights, epsilon = 1e-7, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ const $labels = Object(tensor_util_env["a" /* convertToTensor */])(labels, 'labels', 'logLoss');
+ const $predictions = Object(tensor_util_env["a" /* convertToTensor */])(predictions, 'predictions', 'logLoss');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'logLoss');
+ }
+ Object(util["assertShapesMatch"])($labels.shape, $predictions.shape, 'Error in logLoss: ');
+ const one = Object(tensor_ops["e" /* scalar */])(1);
+ const epsilonScalar = Object(tensor_ops["e" /* scalar */])(epsilon);
+ const losses = $labels.mul($predictions.add(epsilonScalar).log())
+ .neg()
+ .sub(one.sub($labels).mul(one.sub($predictions).add(epsilonScalar).log()));
+ return computeWeightedLoss(losses, $weights, reduction);
+}
+function sigmoidCrossEntropyWithLogits_(labels, logits) {
+ const $labels = Object(tensor_util_env["a" /* convertToTensor */])(labels, 'labels', 'sigmoidCrossEntropyWithLogits');
+ const $logits = Object(tensor_util_env["a" /* convertToTensor */])(logits, 'logits', 'sigmoidCrossEntropyWithLogits');
+ Object(util["assertShapesMatch"])($labels.shape, $logits.shape, 'Error in sigmoidCrossEntropyWithLogits: ');
+ /**
+ * Implementation Details:
+ *
+ * For brevity, let `x = logits`, `z = labels`. The logistic loss is
+ * z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))
+ * = z * -log(1 / (1 + exp(-x))) + (1 - z) * -log(exp(-x) / (1 + exp(-x)))
+ * = z * log(1 + exp(-x)) + (1 - z) * (-log(exp(-x)) + log(1 + exp(-x)))
+ * = z * log(1 + exp(-x)) + (1 - z) * (x + log(1 + exp(-x))
+ * = (1 - z) * x + log(1 + exp(-x))
+ * = x - x * z + log(1 + exp(-x))
+ *
+ * For x < 0, to avoid overflow in exp(-x), we reformulate the above
+ * x - x * z + log(1 + exp(-x))
+ * = log(exp(x)) - x * z + log(1 + exp(-x))
+ * = - x * z + log(1 + exp(x))
+ *
+ * Hence, to ensure stability and avoid overflow, the implementation uses
+ * this equivalent formulation:
+ * max(x, 0) - x * z + log(1 + exp(-abs(x)))
+ */
+ const maxOutput = $logits.relu();
+ const outputXTarget = $logits.mul($labels);
+ const sigmoidOutput = $logits.abs().neg().exp().log1p();
+ return maxOutput.sub(outputXTarget).add(sigmoidOutput);
+}
+/**
+ * Computes the sigmoid cross entropy loss between two tensors.
+ *
+ * If labelSmoothing is nonzero, smooth the labels towards 1/2:
+ *
+ * newMulticlassLabels = multiclassLabels * (1 - labelSmoothing)
+ * + 0.5 * labelSmoothing
+ *
+ * @param multiClassLabels The ground truth output tensor of shape
+ * [batch_size, num_classes], same dimensions as 'predictions'.
+ * @param logits The predicted outputs.
+ * @param weights Tensor whose rank is either 0, or the same rank as
+ * `labels`, and must be broadcastable to `labels` (i.e., all dimensions
+ * must be either `1`, or the same as the corresponding `losses`
+ * dimension).
+ * @param labelSmoothing If greater than 0, then smooth the labels.
+ * @param reduction Type of reduction to apply to loss. Should be of type
+ * `Reduction`
+ */
+/** @doc { heading: 'Training', subheading: 'Losses', namespace: 'losses' } */
+function sigmoidCrossEntropy_(multiClassLabels, logits, weights, labelSmoothing = 0, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ let $multiClassLabels = Object(tensor_util_env["a" /* convertToTensor */])(multiClassLabels, 'multiClassLabels', 'sigmoidCrossEntropy');
+ const $logits = Object(tensor_util_env["a" /* convertToTensor */])(logits, 'logits', 'sigmoidCrossEntropy');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'sigmoidCrossEntropy');
+ }
+ Object(util["assertShapesMatch"])($multiClassLabels.shape, $logits.shape, 'Error in sigmoidCrossEntropy: ');
+ if (labelSmoothing > 0) {
+ const labelSmoothingScalar = Object(tensor_ops["e" /* scalar */])(labelSmoothing);
+ const one = Object(tensor_ops["e" /* scalar */])(1);
+ const half = Object(tensor_ops["e" /* scalar */])(0.5);
+ $multiClassLabels = $multiClassLabels.mul(one.sub(labelSmoothingScalar))
+ .add(half.mul(labelSmoothingScalar));
+ }
+ const losses = sigmoidCrossEntropyWithLogits_($multiClassLabels, $logits);
+ return computeWeightedLoss(losses, $weights, reduction);
+}
+/**
+ * Computes the huber loss between two tensors.
+ *
+ * @param labels The ground truth output tensor, same dimensions as
+ * 'predictions'.
+ * @param predictions The predicted outputs.
+ * @param weights Tensor whose rank is either 0, or the same rank as
+ * `labels`, and must be broadcastable to `labels` (i.e., all dimensions
+ * must be either `1`, or the same as the corresponding `losses`
+ * dimension).
+ * @param delta Point where huber loss changes from quadratic to linear.
+ * @param reduction Type of reduction to apply to loss. Should be of type
+ * `Reduction`.
+ */
+/** @doc {heading: 'Training', subheading: 'Losses', namespace: 'losses'} */
+function huberLoss_(labels, predictions, weights, delta = 1.0, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ const $labels = Object(tensor_util_env["a" /* convertToTensor */])(labels, 'labels', 'huberLoss');
+ const $predictions = Object(tensor_util_env["a" /* convertToTensor */])(predictions, 'predictions', 'huberLoss');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'huberLoss');
+ }
+ Object(util["assertShapesMatch"])($labels.shape, $predictions.shape, 'Error in huberLoss: ');
+ const deltaScalar = Object(tensor_ops["e" /* scalar */])(delta);
+ const error = $predictions.sub($labels).abs();
+ const quadratic = minimum(error, deltaScalar);
+ const linear = error.sub(quadratic);
+ const losses = Object(tensor_ops["e" /* scalar */])(0.5).mul(quadratic.square()).add(deltaScalar.mul(linear));
+ return computeWeightedLoss(losses, $weights, reduction);
+}
+/**
+ * Computes softmax cross entropy between logits and labels.
+ *
+ * Measures the probability error in discrete classification tasks in which
+ * the classes are mutually exclusive (each entry is in exactly one class).
+ * For example, each CIFAR-10 image is labeled with one and only one label: an
+ * image can be a dog or a truck, but not both.
+ *
+ * `NOTE`: While the classes are mutually exclusive, their probabilities need
+ * not be. All that is required is that each row of labels is a valid
+ * probability distribution. If they are not, the computation of the gradient
+ * will be incorrect.
+ *
+ * `WARNING`: This op expects unscaled logits, since it performs a softmax on
+ * logits internally for efficiency. Do not call this op with the output of
+ * softmax, as it will produce incorrect results.
+ *
+ * logits and labels must have the same shape, e.g. [batch_size, num_classes]
+ * and the same dtype.
+ * @param labels The labels array.
+ * @param logits The logits array.
+ * @param dim The dimension softmax would be performed on. Defaults to `-1`
+ * which indicates the last dimension.
+ */
+function softmaxCrossEntropyWithLogits_(labels, logits, dim = -1) {
+ if (dim === -1) {
+ dim = logits.rank - 1;
+ }
+ if (dim !== logits.rank - 1) {
+ throw Error(`Softmax cross entropy along a non-last dimension is not yet ` +
+ `supported. Labels / logits was rank ${logits.rank} ` +
+ `and dim was ${dim}`);
+ }
+ // Use a custom gradient for numerical stability.
+ const customOp = customGrad((labels, logits, save) => {
+ // Reference:
+ // 1. http://cs231n.github.io/linear-classify/#softmax
+ // 2. https://blog.feedly.com/tricks-of-the-trade-logsumexp/
+ const keepDims = true;
+ const lse = logits.logSumExp([dim], keepDims);
+ const logResult = logits.toFloat().sub(lse);
+ save([labels, logResult]);
+ const costVector = logResult.mul(labels).neg();
+ const value = costVector.sum([dim]);
+ const gradFunc = (dy, saved) => {
+ const [labels, logResult] = saved;
+ const dyShape = expandShapeToKeepDim(dy.shape, [dim]);
+ return [
+ dy.reshape(dyShape).mul(labels.toFloat().sub(logResult.exp())),
+ dy.reshape(dyShape).mul(logResult.exp().sub(labels.toFloat())),
+ ];
+ };
+ return { value, gradFunc };
+ });
+ return customOp(labels, logits);
+}
+/**
+ * Computes the softmax cross entropy loss between two tensors.
+ *
+ * If labelSmoothing is nonzero, smooth the labels towards 1/2:
+ *
+ * newOnehotLabels = onehotLabels * (1 - labelSmoothing)
+ * + labelSmoothing / numClasses
+ *
+ * @param onehotLabels One hot encoded labels
+ * [batch_size, num_classes], same dimensions as 'predictions'.
+ * @param logits The predicted outputs.
+ * @param weights Tensor whose rank is either 0, or 1, and must be
+ * broadcastable to `loss` of shape [batch_size]
+ * @param labelSmoothing If greater than 0, then smooth the labels.
+ * @param reduction Type of reduction to apply to loss. Should be of type
+ * `Reduction`
+ */
+/** @doc { heading: 'Training', subheading: 'Losses', namespace: 'losses' } */
+function softmaxCrossEntropy_(onehotLabels, logits, weights, labelSmoothing = 0, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
+ let $onehotLabels = Object(tensor_util_env["a" /* convertToTensor */])(onehotLabels, 'onehotLabels', 'softmaxCrossEntropy');
+ const $logits = Object(tensor_util_env["a" /* convertToTensor */])(logits, 'logits', 'softmaxCrossEntropy');
+ let $weights = null;
+ if (weights != null) {
+ $weights = Object(tensor_util_env["a" /* convertToTensor */])(weights, 'weights', 'softmaxCrossEntropy');
+ }
+ Object(util["assertShapesMatch"])($onehotLabels.shape, $logits.shape, 'Error in softmaxCrossEntropy: ');
+ if (labelSmoothing > 0) {
+ const labelSmoothingScalar = Object(tensor_ops["e" /* scalar */])(labelSmoothing);
+ const one = Object(tensor_ops["e" /* scalar */])(1);
+ const numClasses = Object(tensor_ops["e" /* scalar */])($onehotLabels.shape[1]);
+ $onehotLabels = $onehotLabels.mul(one.sub(labelSmoothingScalar))
+ .add(labelSmoothingScalar.div(numClasses));
+ }
+ const losses = softmaxCrossEntropyWithLogits_($onehotLabels, $logits);
+ return computeWeightedLoss(losses, $weights, reduction);
+}
+const absoluteDifference = Object(operation["a" /* op */])({ absoluteDifference_ });
+const computeWeightedLoss = Object(operation["a" /* op */])({ computeWeightedLoss_ });
+const cosineDistance = Object(operation["a" /* op */])({ cosineDistance_ });
+const hingeLoss = Object(operation["a" /* op */])({ hingeLoss_ });
+const huberLoss = Object(operation["a" /* op */])({ huberLoss_ });
+const logLoss = Object(operation["a" /* op */])({ logLoss_ });
+const meanSquaredError = Object(operation["a" /* op */])({ meanSquaredError_ });
+const sigmoidCrossEntropy = Object(operation["a" /* op */])({ sigmoidCrossEntropy_ });
+const softmaxCrossEntropy = Object(operation["a" /* op */])({ softmaxCrossEntropy_ });
+//# sourceMappingURL=loss_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/linalg_ops.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Linear algebra ops.
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Copy a tensor setting everything outside a central band in each innermost
+ * matrix to zero.
+ *
+ * The band part is computed as follows: Assume input has `k` dimensions
+ * `[I, J, K, ..., M, N]`, then the output is a tensor with the same shape where
+ * `band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n]`.
+ * The indicator function
+ * `in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower))`
+ * `&& (num_upper < 0 || (n-m) <= num_upper)`
+ *
+ * ```js
+ * const x = tf.tensor2d([[ 0, 1, 2, 3],
+ * [-1, 0, 1, 2],
+ * [-2, -1, 0, 1],
+ * [-3, -2, -1, 0]]);
+ * let y = tf.linalg.bandPart(x, 1, -1);
+ * y.print(); // [[ 0, 1, 2, 3],
+ * // [-1, 0, 1, 2],
+ * // [ 0, -1, 0, 1],
+ * // [ 0, 0 , -1, 0]]
+ * let z = tf.linalg.bandPart(x, 2, 1);
+ * z.print(); // [[ 0, 1, 0, 0],
+ * // [-1, 0, 1, 0],
+ * // [-2, -1, 0, 1],
+ * // [ 0, -2, -1, 0]]
+ * ```
+ *
+ * @param x Rank `k` tensor
+ * @param numLower Number of subdiagonals to keep.
+ * If negative, keep entire lower triangle.
+ * @param numUpper Number of subdiagonals to keep.
+ * If negative, keep entire upper triangle.
+ * @returns Rank `k` tensor of the same shape as input.
+ * The extracted banded tensor.
+ */
+/**
+ * @doc {heading:'Operations',
+ * subheading:'Linear Algebra',
+ * namespace:'linalg'}
+ */
+function bandPart_(a, numLower, numUpper) {
+ if (numLower % 1 !== 0) {
+ throw new Error(`bandPart(): numLower must be an integer, got ${numLower}.`);
+ }
+ if (numUpper % 1 !== 0) {
+ throw new Error(`bandPart(): numUpper must be an integer, got ${numUpper}.`);
+ }
+ const $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'bandPart');
+ if ($a.rank < 2) {
+ throw new Error(`bandPart(): Rank must be at least 2, got ${$a.rank}.`);
+ }
+ const shape = $a.shape, [M, N] = $a.shape.slice(-2);
+ if (!(numLower <= M)) {
+ throw new Error(`bandPart(): numLower (${numLower})` +
+ ` must not be greater than the number of rows (${M}).`);
+ }
+ if (!(numUpper <= N)) {
+ throw new Error(`bandPart(): numUpper (${numUpper})` +
+ ` must not be greater than the number of columns (${N}).`);
+ }
+ if (numLower < 0) {
+ numLower = M;
+ }
+ if (numUpper < 0) {
+ numUpper = N;
+ }
+ const i = Object(tensor_ops["d" /* range */])(0, M, 1, 'int32').reshape([-1, 1]), j = Object(tensor_ops["d" /* range */])(0, N, 1, 'int32'), ij = sub(i, j);
+ const inBand = logicalAnd(ij.lessEqual(Object(tensor_ops["e" /* scalar */])(+numLower, 'int32')), ij.greaterEqual(Object(tensor_ops["e" /* scalar */])(-numUpper, 'int32')));
+ const zero = Object(tensor_ops["n" /* zeros */])([M, N], $a.dtype);
+ return stack(unstack($a.reshape([-1, M, N]))
+ .map(mat => where(inBand, mat, zero)))
+ .reshape(shape);
+}
+/**
+ * Gram-Schmidt orthogonalization.
+ *
+ * ```js
+ * const x = tf.tensor2d([[1, 2], [3, 4]]);
+ * let y = tf.linalg.gramSchmidt(x);
+ * y.print();
+ * console.log('Othogonalized:');
+ * y.dot(y.transpose()).print(); // should be nearly the identity matrix.
+ * console.log('First row direction maintained:');
+ * const data = await y.array();
+ * console.log(data[0][1] / data[0][0]); // should be nearly 2.
+ * ```
+ *
+ * @param xs The vectors to be orthogonalized, in one of the two following
+ * formats:
+ * - An Array of `tf.Tensor1D`.
+ * - A `tf.Tensor2D`, i.e., a matrix, in which case the vectors are the rows
+ * of `xs`.
+ * In each case, all the vectors must have the same length and the length
+ * must be greater than or equal to the number of vectors.
+ * @returns The orthogonalized and normalized vectors or matrix.
+ * Orthogonalization means that the vectors or the rows of the matrix
+ * are orthogonal (zero inner products). Normalization means that each
+ * vector or each row of the matrix has an L2 norm that equals `1`.
+ */
+/**
+ * @doc {heading:'Operations',
+ * subheading:'Linear Algebra',
+ * namespace:'linalg'}
+ */
+function gramSchmidt_(xs) {
+ let inputIsTensor2D;
+ if (Array.isArray(xs)) {
+ inputIsTensor2D = false;
+ Object(util["assert"])(xs != null && xs.length > 0, () => 'Gram-Schmidt process: input must not be null, undefined, or ' +
+ 'empty');
+ const dim = xs[0].shape[0];
+ for (let i = 1; i < xs.length; ++i) {
+ Object(util["assert"])(xs[i].shape[0] === dim, () => 'Gram-Schmidt: Non-unique lengths found in the input vectors: ' +
+ `(${xs[i].shape[0]} vs. ${dim})`);
+ }
+ }
+ else {
+ inputIsTensor2D = true;
+ xs = split(xs, xs.shape[0], 0).map(x => squeeze(x, [0]));
+ }
+ Object(util["assert"])(xs.length <= xs[0].shape[0], () => `Gram-Schmidt: Number of vectors (${xs.length}) exceeds ` +
+ `number of dimensions (${xs[0].shape[0]}).`);
+ const ys = [];
+ const xs1d = xs;
+ for (let i = 0; i < xs.length; ++i) {
+ ys.push(engine["a" /* ENGINE */].tidy(() => {
+ let x = xs1d[i];
+ if (i > 0) {
+ for (let j = 0; j < i; ++j) {
+ const proj = sum(ys[j].mul(x)).mul(ys[j]);
+ x = x.sub(proj);
+ }
+ }
+ return x.div(norm_norm(x, 'euclidean'));
+ }));
+ }
+ if (inputIsTensor2D) {
+ return stack(ys, 0);
+ }
+ else {
+ return ys;
+ }
+}
+/**
+ * Compute QR decomposition of m-by-n matrix using Householder transformation.
+ *
+ * Implementation based on
+ * [http://www.cs.cornell.edu/~bindel/class/cs6210-f09/lec18.pdf]
+ * (http://www.cs.cornell.edu/~bindel/class/cs6210-f09/lec18.pdf)
+ *
+ * ```js
+ * const a = tf.tensor2d([[1, 2], [3, 4]]);
+ * let [q, r] = tf.linalg.qr(a);
+ * console.log('Q');
+ * q.print();
+ * console.log('R');
+ * r.print();
+ * console.log('Orthogonalized');
+ * q.dot(q.transpose()).print() // should be nearly the identity matrix.
+ * console.log('Reconstructed');
+ * q.dot(r).print(); // should be nearly [[1, 2], [3, 4]];
+ * ```
+ *
+ * @param x The `tf.Tensor` to be QR-decomposed. Must have rank >= 2. Suppose
+ * it has the shape `[..., M, N]`.
+ * @param fullMatrices An optional boolean parameter. Defaults to `false`.
+ * If `true`, compute full-sized `Q`. If `false` (the default),
+ * compute only the leading N columns of `Q` and `R`.
+ * @returns An `Array` of two `tf.Tensor`s: `[Q, R]`. `Q` is a unitary matrix,
+ * i.e., its columns all have unit norm and are mutually orthogonal.
+ * If `M >= N`,
+ * If `fullMatrices` is `false` (default),
+ * - `Q` has a shape of `[..., M, N]`,
+ * - `R` has a shape of `[..., N, N]`.
+ * If `fullMatrices` is `true` (default),
+ * - `Q` has a shape of `[..., M, M]`,
+ * - `R` has a shape of `[..., M, N]`.
+ * If `M < N`,
+ * - `Q` has a shape of `[..., M, M]`,
+ * - `R` has a shape of `[..., M, N]`.
+ * @throws If the rank of `x` is less than 2.
+ */
+/**
+ * @doc {heading:'Operations',
+ * subheading:'Linear Algebra',
+ * namespace:'linalg'}
+ */
+function qr_(x, fullMatrices = false) {
+ if (x.rank < 2) {
+ throw new Error(`qr() requires input tensor to have a rank >= 2, but got rank ${x.rank}`);
+ }
+ else if (x.rank === 2) {
+ return qr2d(x, fullMatrices);
+ }
+ else {
+ // Rank > 2.
+ // TODO(cais): Below we split the input into individual 2D tensors,
+ // perform QR decomposition on them and then stack the results back
+ // together. We should explore whether this can be parallelized.
+ const outerDimsProd = x.shape.slice(0, x.shape.length - 2)
+ .reduce((value, prev) => value * prev);
+ const x2ds = unstack(x.reshape([
+ outerDimsProd, x.shape[x.shape.length - 2],
+ x.shape[x.shape.length - 1]
+ ]), 0);
+ const q2ds = [];
+ const r2ds = [];
+ x2ds.forEach(x2d => {
+ const [q2d, r2d] = qr2d(x2d, fullMatrices);
+ q2ds.push(q2d);
+ r2ds.push(r2d);
+ });
+ const q = stack(q2ds, 0).reshape(x.shape);
+ const r = stack(r2ds, 0).reshape(x.shape);
+ return [q, r];
+ }
+}
+function qr2d(x, fullMatrices = false) {
+ return engine["a" /* ENGINE */].tidy(() => {
+ if (x.shape.length !== 2) {
+ throw new Error(`qr2d() requires a 2D Tensor, but got a ${x.shape.length}D Tensor.`);
+ }
+ const m = x.shape[0];
+ const n = x.shape[1];
+ let q = eye(m); // Orthogonal transform so far.
+ let r = x.clone(); // Transformed matrix so far.
+ const one2D = Object(tensor_ops["h" /* tensor2d */])([[1]], [1, 1]);
+ let w = one2D.clone();
+ const iters = m >= n ? n : m;
+ for (let j = 0; j < iters; ++j) {
+ // This tidy within the for-loop ensures we clean up temporary
+ // tensors as soon as they are no longer needed.
+ const rTemp = r;
+ const wTemp = w;
+ const qTemp = q;
+ [w, r, q] = engine["a" /* ENGINE */].tidy(() => {
+ // Find H = I - tau * w * w', to put zeros below R(j, j).
+ const rjEnd1 = r.slice([j, j], [m - j, 1]);
+ const normX = rjEnd1.norm();
+ const rjj = r.slice([j, j], [1, 1]);
+ // The sign() function returns 0 on 0, which causes division by zero.
+ const s = Object(tensor_ops["h" /* tensor2d */])([[-1]]).where(rjj.greater(0), Object(tensor_ops["h" /* tensor2d */])([[1]]));
+ const u1 = rjj.sub(s.mul(normX));
+ const wPre = rjEnd1.div(u1);
+ if (wPre.shape[0] === 1) {
+ w = one2D.clone();
+ }
+ else {
+ w = one2D.concat(wPre.slice([1, 0], [wPre.shape[0] - 1, wPre.shape[1]]), 0);
+ }
+ const tau = s.matMul(u1).div(normX).neg();
+ // -- R := HR, Q := QH.
+ const rjEndAll = r.slice([j, 0], [m - j, n]);
+ const tauTimesW = tau.mul(w);
+ const wT = w.transpose();
+ if (j === 0) {
+ r = rjEndAll.sub(tauTimesW.matMul(wT.matMul(rjEndAll)));
+ }
+ else {
+ const rTimesTau = rjEndAll.sub(tauTimesW.matMul(wT.matMul(rjEndAll)));
+ r = r.slice([0, 0], [j, n]).concat(rTimesTau, 0);
+ }
+ const tawTimesWT = tauTimesW.transpose();
+ const qAllJEnd = q.slice([0, j], [m, q.shape[1] - j]);
+ if (j === 0) {
+ q = qAllJEnd.sub(qAllJEnd.matMul(w).matMul(tawTimesWT));
+ }
+ else {
+ const qTimesTau = qAllJEnd.sub(qAllJEnd.matMul(w).matMul(tawTimesWT));
+ q = q.slice([0, 0], [m, j]).concat(qTimesTau, 1);
+ }
+ return [w, r, q];
+ });
+ dispose([rTemp, wTemp, qTemp]);
+ }
+ if (!fullMatrices && m > n) {
+ q = q.slice([0, 0], [m, n]);
+ r = r.slice([0, 0], [n, n]);
+ }
+ return [q, r];
+ });
+}
+const bandPart = Object(operation["a" /* op */])({ bandPart_ });
+const gramSchmidt = Object(operation["a" /* op */])({ gramSchmidt_ });
+const qr = Object(operation["a" /* op */])({ qr_ });
+//# sourceMappingURL=linalg_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/array_util.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Inserts a value into a sorted array. This method allows duplicate, meaning it
+ * allows inserting duplicate value, in which case, the element will be inserted
+ * at the lowest index of the value.
+ * @param arr The array to modify.
+ * @param element The element to insert.
+ * @param comparator Optional. If no comparator is specified, elements are
+ * compared using array_util.defaultComparator, which is suitable for Strings
+ * and Numbers in ascending arrays. If the array contains multiple instances of
+ * the target value, the left-most instance will be returned. To provide a
+ * comparator, it should take 2 arguments to compare and return a negative,
+ * zero, or a positive number.
+ */
+function binaryInsert(arr, element, comparator) {
+ const index = binarySearch(arr, element, comparator);
+ const insertionPoint = index < 0 ? -(index + 1) : index;
+ arr.splice(insertionPoint, 0, element);
+}
+/**
+ * Searches the array for the target using binary search, returns the index
+ * of the found element, or position to insert if element not found. If no
+ * comparator is specified, elements are compared using array_
+ * util.defaultComparator, which is suitable for Strings and Numbers in
+ * ascending arrays. If the array contains multiple instances of the target
+ * value, the left-most instance will be returned.
+ * @param arr The array to be searched in.
+ * @param target The target to be searched for.
+ * @param comparator Should take 2 arguments to compare and return a negative,
+ * zero, or a positive number.
+ * @return Lowest index of the target value if found, otherwise the insertion
+ * point where the target should be inserted, in the form of
+ * (-insertionPoint - 1).
+ */
+function binarySearch(arr, target, comparator) {
+ return binarySearch_(arr, target, comparator || defaultComparator);
+}
+/**
+ * Compares its two arguments for order.
+ * @param a The first element to be compared.
+ * @param b The second element to be compared.
+ * @return A negative number, zero, or a positive number as the first
+ * argument is less than, equal to, or greater than the second.
+ */
+function defaultComparator(a, b) {
+ return a > b ? 1 : a < b ? -1 : 0;
+}
+function binarySearch_(arr, target, comparator) {
+ let left = 0;
+ let right = arr.length;
+ let middle = 0;
+ let found = false;
+ while (left < right) {
+ middle = left + ((right - left) >>> 1);
+ const compareResult = comparator(target, arr[middle]);
+ if (compareResult > 0) {
+ left = middle + 1;
+ }
+ else {
+ right = middle;
+ // If compareResult is 0, the value is found. We record it is found,
+ // and then keep looking because there may be duplicate.
+ found = !compareResult;
+ }
+ }
+ return found ? left : -left - 1;
+}
+//# sourceMappingURL=array_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/non_max_suppression_impl.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Implementation of the NonMaxSuppression kernel shared between webgl and cpu.
+ */
+
+
+function nonMaxSuppressionV3(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
+ const dummySoftNmsSigma = 0.0;
+ const result = nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, dummySoftNmsSigma);
+ result.selectedScores.dispose();
+ result.numValidOutputs.dispose();
+ return result.selectedIndices;
+}
+function nonMaxSuppressionV5(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma) {
+ // For NonMaxSuppressionV5Op, we always return a second output holding
+ // corresponding scores.
+ const returnScoresTensor = true;
+ const result = nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, returnScoresTensor);
+ result.numValidOutputs.dispose();
+ return {
+ selectedIndices: result.selectedIndices,
+ selectedScores: result.selectedScores
+ };
+}
+function nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, returnScoresTensor = false, padToMaxOutputSize = false) {
+ // The list is sorted in ascending order, so that we can always pop the
+ // candidate with the largest score in O(1) time.
+ const candidates = [];
+ for (let i = 0; i < scores.length; i++) {
+ if (scores[i] > scoreThreshold) {
+ candidates.push({ score: scores[i], boxIndex: i, suppressBeginIndex: 0 });
+ }
+ }
+ candidates.sort(ascendingComparator);
+ // If softNmsSigma is 0, the outcome of this algorithm is exactly same as
+ // before.
+ const scale = softNmsSigma > 0 ? (-0.5 / softNmsSigma) : 0.0;
+ const selectedIndices = [];
+ const selectedScores = [];
+ while (selectedIndices.length < maxOutputSize && candidates.length > 0) {
+ const candidate = candidates.pop();
+ const { score: originalScore, boxIndex, suppressBeginIndex } = candidate;
+ if (originalScore < scoreThreshold) {
+ break;
+ }
+ // Overlapping boxes are likely to have similar scores, therefore we
+ // iterate through the previously selected boxes backwards in order to
+ // see if candidate's score should be suppressed. We use
+ // suppressBeginIndex to track and ensure a candidate can be suppressed
+ // by a selected box no more than once. Also, if the overlap exceeds
+ // iouThreshold, we simply ignore the candidate.
+ let ignoreCandidate = false;
+ for (let j = selectedIndices.length - 1; j >= suppressBeginIndex; --j) {
+ const iou = intersectionOverUnion(boxes, boxIndex, selectedIndices[j]);
+ if (iou >= iouThreshold) {
+ ignoreCandidate = true;
+ break;
+ }
+ candidate.score =
+ candidate.score * suppressWeight(iouThreshold, scale, iou);
+ if (candidate.score <= scoreThreshold) {
+ break;
+ }
+ }
+ // At this point, if `candidate.score` has not dropped below
+ // `scoreThreshold`, then we know that we went through all of the
+ // previous selections and can safely update `suppressBeginIndex` to the
+ // end of the selected array. Then we can re-insert the candidate with
+ // the updated score and suppressBeginIndex back in the candidate list.
+ // If on the other hand, `candidate.score` has dropped below the score
+ // threshold, we will not add it back to the candidates list.
+ candidate.suppressBeginIndex = selectedIndices.length;
+ if (!ignoreCandidate) {
+ // Candidate has passed all the tests, and is not suppressed, so
+ // select the candidate.
+ if (candidate.score === originalScore) {
+ selectedIndices.push(boxIndex);
+ selectedScores.push(candidate.score);
+ }
+ else if (candidate.score > scoreThreshold) {
+ // Candidate's score is suppressed but is still high enough to be
+ // considered, so add back to the candidates list.
+ binaryInsert(candidates, candidate, ascendingComparator);
+ }
+ }
+ }
+ // NonMaxSuppressionV4 feature: padding output to maxOutputSize.
+ const numValidOutputs = selectedIndices.length;
+ if (padToMaxOutputSize) {
+ selectedIndices.fill(0, numValidOutputs);
+ selectedScores.fill(0.0, numValidOutputs);
+ }
+ return {
+ selectedIndices: Object(tensor_ops["g" /* tensor1d */])(selectedIndices, 'int32'),
+ selectedScores: Object(tensor_ops["g" /* tensor1d */])(selectedScores, 'float32'),
+ numValidOutputs: Object(tensor_ops["e" /* scalar */])(numValidOutputs, 'int32')
+ };
+}
+function intersectionOverUnion(boxes, i, j) {
+ const iCoord = boxes.subarray(i * 4, i * 4 + 4);
+ const jCoord = boxes.subarray(j * 4, j * 4 + 4);
+ const yminI = Math.min(iCoord[0], iCoord[2]);
+ const xminI = Math.min(iCoord[1], iCoord[3]);
+ const ymaxI = Math.max(iCoord[0], iCoord[2]);
+ const xmaxI = Math.max(iCoord[1], iCoord[3]);
+ const yminJ = Math.min(jCoord[0], jCoord[2]);
+ const xminJ = Math.min(jCoord[1], jCoord[3]);
+ const ymaxJ = Math.max(jCoord[0], jCoord[2]);
+ const xmaxJ = Math.max(jCoord[1], jCoord[3]);
+ const areaI = (ymaxI - yminI) * (xmaxI - xminI);
+ const areaJ = (ymaxJ - yminJ) * (xmaxJ - xminJ);
+ if (areaI <= 0 || areaJ <= 0) {
+ return 0.0;
+ }
+ const intersectionYmin = Math.max(yminI, yminJ);
+ const intersectionXmin = Math.max(xminI, xminJ);
+ const intersectionYmax = Math.min(ymaxI, ymaxJ);
+ const intersectionXmax = Math.min(xmaxI, xmaxJ);
+ const intersectionArea = Math.max(intersectionYmax - intersectionYmin, 0.0) *
+ Math.max(intersectionXmax - intersectionXmin, 0.0);
+ return intersectionArea / (areaI + areaJ - intersectionArea);
+}
+// A Gaussian penalty function, this method always returns values in [0, 1].
+// The weight is a function of similarity, the more overlap two boxes are, the
+// smaller the weight is, meaning highly overlapping boxe will be significantly
+// penalized. On the other hand, a non-overlapping box will not be penalized.
+function suppressWeight(iouThreshold, scale, iou) {
+ const weight = Math.exp(scale * iou * iou);
+ return iou <= iouThreshold ? weight : 0.0;
+}
+function ascendingComparator(c1, c2) {
+ // For objects with same scores, we make the object with the larger index go
+ // first. In an array that pops from the end, this means that the object with
+ // the smaller index will be popped first. This ensures the same output as
+ // the TensorFlow python version.
+ return (c1.score - c2.score) ||
+ ((c1.score === c2.score) && (c2.boxIndex - c1.boxIndex));
+}
+//# sourceMappingURL=non_max_suppression_impl.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/nonmax_util.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function nonMaxSuppSanityCheck(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma) {
+ if (iouThreshold == null) {
+ iouThreshold = 0.5;
+ }
+ if (scoreThreshold == null) {
+ scoreThreshold = Number.NEGATIVE_INFINITY;
+ }
+ if (softNmsSigma == null) {
+ softNmsSigma = 0.0;
+ }
+ const numBoxes = boxes.shape[0];
+ maxOutputSize = Math.min(maxOutputSize, numBoxes);
+ util["assert"](0 <= iouThreshold && iouThreshold <= 1, () => `iouThreshold must be in [0, 1], but was '${iouThreshold}'`);
+ util["assert"](boxes.rank === 2, () => `boxes must be a 2D tensor, but was of rank '${boxes.rank}'`);
+ util["assert"](boxes.shape[1] === 4, () => `boxes must have 4 columns, but 2nd dimension was ${boxes.shape[1]}`);
+ util["assert"](scores.rank === 1, () => 'scores must be a 1D tensor');
+ util["assert"](scores.shape[0] === numBoxes, () => `scores has incompatible shape with boxes. Expected ${numBoxes}, ` +
+ `but was ${scores.shape[0]}`);
+ util["assert"](0 <= softNmsSigma && softNmsSigma <= 1, () => `softNmsSigma must be in [0, 1], but was '${softNmsSigma}'`);
+ return { maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma };
+}
+
+//# sourceMappingURL=nonmax_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/non_max_suppression.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+function nonMaxSuppression_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY) {
+ const $boxes = Object(tensor_util_env["a" /* convertToTensor */])(boxes, 'boxes', 'nonMaxSuppression');
+ const $scores = Object(tensor_util_env["a" /* convertToTensor */])(scores, 'scores', 'nonMaxSuppression');
+ const inputs = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold);
+ maxOutputSize = inputs.maxOutputSize;
+ iouThreshold = inputs.iouThreshold;
+ scoreThreshold = inputs.scoreThreshold;
+ const attrs = { maxOutputSize, iouThreshold, scoreThreshold };
+ return engine["a" /* ENGINE */].runKernelFunc(b => b.nonMaxSuppression($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold), { boxes: $boxes, scores: $scores }, null /* grad */, kernel_names["Z" /* NonMaxSuppressionV3 */], attrs);
+}
+const nonMaxSuppression = Object(operation["a" /* op */])({ nonMaxSuppression_ });
+//# sourceMappingURL=non_max_suppression.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/image_ops.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+/**
+ * Bilinear resize a batch of 3D images to a new shape.
+ *
+ * @param images The images, of rank 4 or rank 3, of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is assumed.
+ * @param size The new shape `[newHeight, newWidth]` to resize the
+ * images to. Each channel is resized individually.
+ * @param alignCorners Defaults to False. If true, rescale
+ * input by `(new_height - 1) / (height - 1)`, which exactly aligns the 4
+ * corners of images and resized images. If false, rescale by
+ * `new_height / height`. Treat similarly the width dimension.
+ */
+/** @doc {heading: 'Operations', subheading: 'Images', namespace: 'image'} */
+function resizeBilinear_(images, size, alignCorners = false) {
+ const $images = Object(tensor_util_env["a" /* convertToTensor */])(images, 'images', 'resizeBilinear');
+ util["assert"]($images.rank === 3 || $images.rank === 4, () => `Error in resizeBilinear: x must be rank 3 or 4, but got ` +
+ `rank ${$images.rank}.`);
+ util["assert"](size.length === 2, () => `Error in resizeBilinear: new shape must 2D, but got shape ` +
+ `${size}.`);
+ let batchImages = $images;
+ let reshapedTo4D = false;
+ if ($images.rank === 3) {
+ reshapedTo4D = true;
+ batchImages =
+ $images.as4D(1, $images.shape[0], $images.shape[1], $images.shape[2]);
+ }
+ const [newHeight, newWidth] = size;
+ const forward = (backend, save) => {
+ save([batchImages]);
+ return backend.resizeBilinear(batchImages, newHeight, newWidth, alignCorners);
+ };
+ const backward = (dy, saved) => {
+ return {
+ x: () => engine["a" /* ENGINE */].runKernelFunc(backend => backend.resizeBilinearBackprop(dy, saved[0], alignCorners), {})
+ };
+ };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, { x: batchImages }, backward, 'ResizeBilinear', { alignCorners, newHeight, newWidth });
+ if (reshapedTo4D) {
+ return res.as3D(res.shape[1], res.shape[2], res.shape[3]);
+ }
+ return res;
+}
+/**
+ * NearestNeighbor resize a batch of 3D images to a new shape.
+ *
+ * @param images The images, of rank 4 or rank 3, of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is assumed.
+ * @param size The new shape `[newHeight, newWidth]` to resize the
+ * images to. Each channel is resized individually.
+ * @param alignCorners Defaults to False. If true, rescale
+ * input by `(new_height - 1) / (height - 1)`, which exactly aligns the 4
+ * corners of images and resized images. If false, rescale by
+ * `new_height / height`. Treat similarly the width dimension.
+ */
+/** @doc {heading: 'Operations', subheading: 'Images', namespace: 'image'} */
+function resizeNearestNeighbor_(images, size, alignCorners = false) {
+ const $images = Object(tensor_util_env["a" /* convertToTensor */])(images, 'images', 'resizeNearestNeighbor');
+ util["assert"]($images.rank === 3 || $images.rank === 4, () => `Error in resizeNearestNeighbor: x must be rank 3 or 4, but got ` +
+ `rank ${$images.rank}.`);
+ util["assert"](size.length === 2, () => `Error in resizeNearestNeighbor: new shape must 2D, but got shape ` +
+ `${size}.`);
+ util["assert"]($images.dtype === 'float32' || $images.dtype === 'int32', () => '`images` must have `int32` or `float32` as dtype');
+ let batchImages = $images;
+ let reshapedTo4D = false;
+ if ($images.rank === 3) {
+ reshapedTo4D = true;
+ batchImages =
+ $images.as4D(1, $images.shape[0], $images.shape[1], $images.shape[2]);
+ }
+ const [newHeight, newWidth] = size;
+ const forward = (backend, save) => {
+ save([batchImages]);
+ return backend.resizeNearestNeighbor(batchImages, newHeight, newWidth, alignCorners);
+ };
+ const backward = (dy, saved) => {
+ return {
+ batchImages: () => engine["a" /* ENGINE */].runKernelFunc(backend => backend.resizeNearestNeighborBackprop(dy, saved[0], alignCorners), {})
+ };
+ };
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, { batchImages }, backward);
+ if (reshapedTo4D) {
+ return res.as3D(res.shape[1], res.shape[2], res.shape[3]);
+ }
+ return res;
+}
+/**
+ * Performs non maximum suppression of bounding boxes based on
+ * iou (intersection over union).
+ *
+ * @param boxes a 2d tensor of shape `[numBoxes, 4]`. Each entry is
+ * `[y1, x1, y2, x2]`, where `(y1, x1)` and `(y2, x2)` are the corners of
+ * the bounding box.
+ * @param scores a 1d tensor providing the box scores of shape `[numBoxes]`.
+ * @param maxOutputSize The maximum number of boxes to be selected.
+ * @param iouThreshold A float representing the threshold for deciding whether
+ * boxes overlap too much with respect to IOU. Must be between [0, 1].
+ * Defaults to 0.5 (50% box overlap).
+ * @param scoreThreshold A threshold for deciding when to remove boxes based
+ * on score. Defaults to -inf, which means any score is accepted.
+ * @return A 1D tensor with the selected box indices.
+ */
+/** @doc {heading: 'Operations', subheading: 'Images', namespace: 'image'} */
+/** This is the async version of `nonMaxSuppression` */
+async function nonMaxSuppressionAsync_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY) {
+ const $boxes = Object(tensor_util_env["a" /* convertToTensor */])(boxes, 'boxes', 'nonMaxSuppressionAsync');
+ const $scores = Object(tensor_util_env["a" /* convertToTensor */])(scores, 'scores', 'nonMaxSuppressionAsync');
+ const inputs = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold);
+ maxOutputSize = inputs.maxOutputSize;
+ iouThreshold = inputs.iouThreshold;
+ scoreThreshold = inputs.scoreThreshold;
+ const boxesAndScores = await Promise.all([$boxes.data(), $scores.data()]);
+ const boxesVals = boxesAndScores[0];
+ const scoresVals = boxesAndScores[1];
+ const res = nonMaxSuppressionV3(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
+ if ($boxes !== boxes) {
+ $boxes.dispose();
+ }
+ if ($scores !== scores) {
+ $scores.dispose();
+ }
+ return res;
+}
+/**
+ * Performs non maximum suppression of bounding boxes based on
+ * iou (intersection over union).
+ *
+ * This op also supports a Soft-NMS mode (c.f.
+ * Bodla et al, https://arxiv.org/abs/1704.04503) where boxes reduce the score
+ * of other overlapping boxes, therefore favoring different regions of the image
+ * with high scores. To enable this Soft-NMS mode, set the `softNmsSigma`
+ * parameter to be larger than 0.
+ *
+ * @param boxes a 2d tensor of shape `[numBoxes, 4]`. Each entry is
+ * `[y1, x1, y2, x2]`, where `(y1, x1)` and `(y2, x2)` are the corners of
+ * the bounding box.
+ * @param scores a 1d tensor providing the box scores of shape `[numBoxes]`.
+ * @param maxOutputSize The maximum number of boxes to be selected.
+ * @param iouThreshold A float representing the threshold for deciding whether
+ * boxes overlap too much with respect to IOU. Must be between [0, 1].
+ * Defaults to 0.5 (50% box overlap).
+ * @param scoreThreshold A threshold for deciding when to remove boxes based
+ * on score. Defaults to -inf, which means any score is accepted.
+ * @param softNmsSigma A float representing the sigma parameter for Soft NMS.
+ * When sigma is 0, it falls back to nonMaxSuppression.
+ * @return A map with the following properties:
+ * - selectedIndices: A 1D tensor with the selected box indices.
+ * - selectedScores: A 1D tensor with the corresponding scores for each
+ * selected box.
+ */
+/** @doc {heading: 'Operations', subheading: 'Images', namespace: 'image'} */
+function nonMaxSuppressionWithScore_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY, softNmsSigma = 0.0) {
+ const $boxes = Object(tensor_util_env["a" /* convertToTensor */])(boxes, 'boxes', 'nonMaxSuppression');
+ const $scores = Object(tensor_util_env["a" /* convertToTensor */])(scores, 'scores', 'nonMaxSuppression');
+ const inputs = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma);
+ maxOutputSize = inputs.maxOutputSize;
+ iouThreshold = inputs.iouThreshold;
+ scoreThreshold = inputs.scoreThreshold;
+ softNmsSigma = inputs.softNmsSigma;
+ const attrs = { maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma };
+ const result = engine["a" /* ENGINE */].runKernel('NonMaxSuppressionV5', { boxes: $boxes, scores: $scores }, attrs);
+ return { selectedIndices: result[0], selectedScores: result[1] };
+}
+/** This is the async version of `nonMaxSuppressionWithScore` */
+async function nonMaxSuppressionWithScoreAsync_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY, softNmsSigma = 0.0) {
+ const $boxes = Object(tensor_util_env["a" /* convertToTensor */])(boxes, 'boxes', 'nonMaxSuppressionAsync');
+ const $scores = Object(tensor_util_env["a" /* convertToTensor */])(scores, 'scores', 'nonMaxSuppressionAsync');
+ const inputs = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma);
+ maxOutputSize = inputs.maxOutputSize;
+ iouThreshold = inputs.iouThreshold;
+ scoreThreshold = inputs.scoreThreshold;
+ softNmsSigma = inputs.softNmsSigma;
+ const boxesAndScores = await Promise.all([$boxes.data(), $scores.data()]);
+ const boxesVals = boxesAndScores[0];
+ const scoresVals = boxesAndScores[1];
+ const res = nonMaxSuppressionV5(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma);
+ if ($boxes !== boxes) {
+ $boxes.dispose();
+ }
+ if ($scores !== scores) {
+ $scores.dispose();
+ }
+ return res;
+}
+/**
+ * Extracts crops from the input image tensor and resizes them using bilinear
+ * sampling or nearest neighbor sampling (possibly with aspect ratio change)
+ * to a common output size specified by crop_size.
+ *
+ * @param image 4d tensor of shape `[batch,imageHeight,imageWidth, depth]`,
+ * where imageHeight and imageWidth must be positive, specifying the
+ * batch of images from which to take crops
+ * @param boxes 2d float32 tensor of shape `[numBoxes, 4]`. Each entry is
+ * `[y1, x1, y2, x2]`, where `(y1, x1)` and `(y2, x2)` are the normalized
+ * coordinates of the box in the boxInd[i]'th image in the batch
+ * @param boxInd 1d int32 tensor of shape `[numBoxes]` with values in range
+ * `[0, batch)` that specifies the image that the `i`-th box refers to.
+ * @param cropSize 1d int32 tensor of 2 elements `[cropHeigh, cropWidth]`
+ * specifying the size to which all crops are resized to.
+ * @param method Optional string from `'bilinear' | 'nearest'`,
+ * defaults to bilinear, which specifies the sampling method for resizing
+ * @param extrapolationValue A threshold for deciding when to remove boxes based
+ * on score. Defaults to 0.
+ * @return A 4D tensor of the shape `[numBoxes,cropHeight,cropWidth,depth]`
+ */
+/** @doc {heading: 'Operations', subheading: 'Images', namespace: 'image'} */
+function cropAndResize_(image, boxes, boxInd, cropSize, method, extrapolationValue) {
+ const $image = Object(tensor_util_env["a" /* convertToTensor */])(image, 'image', 'cropAndResize');
+ const $boxes = Object(tensor_util_env["a" /* convertToTensor */])(boxes, 'boxes', 'cropAndResize', 'float32');
+ const $boxInd = Object(tensor_util_env["a" /* convertToTensor */])(boxInd, 'boxInd', 'cropAndResize', 'int32');
+ method = method || 'bilinear';
+ extrapolationValue = extrapolationValue || 0;
+ const numBoxes = $boxes.shape[0];
+ util["assert"]($image.rank === 4, () => 'Error in cropAndResize: image must be rank 4,' +
+ `but got rank ${$image.rank}.`);
+ util["assert"]($boxes.rank === 2 && $boxes.shape[1] === 4, () => `Error in cropAndResize: boxes must be have size [${numBoxes},4] ` +
+ `but had shape ${$boxes.shape}.`);
+ util["assert"]($boxInd.rank === 1 && $boxInd.shape[0] === numBoxes, () => `Error in cropAndResize: boxInd must be have size [${numBoxes}] ` +
+ `but had shape ${$boxes.shape}.`);
+ util["assert"](cropSize.length === 2, () => `Error in cropAndResize: cropSize must be of length 2, but got ` +
+ `length ${cropSize.length}.`);
+ util["assert"](cropSize[0] >= 1 && cropSize[1] >= 1, () => `cropSize must be atleast [1,1], but was ${cropSize}`);
+ util["assert"](method === 'bilinear' || method === 'nearest', () => `method must be bilinear or nearest, but was ${method}`);
+ const forward = (backend, save) => backend.cropAndResize($image, $boxes, $boxInd, cropSize, method, extrapolationValue);
+ const res = engine["a" /* ENGINE */].runKernelFunc(forward, { images: $image, boxes: $boxes, boxInd: $boxInd }, null /* der */, 'CropAndResize', { method, extrapolationValue, cropSize });
+ return res;
+}
+const resizeBilinear = Object(operation["a" /* op */])({ resizeBilinear_ });
+const resizeNearestNeighbor = Object(operation["a" /* op */])({ resizeNearestNeighbor_ });
+const nonMaxSuppressionAsync = nonMaxSuppressionAsync_;
+const nonMaxSuppressionWithScore = Object(operation["a" /* op */])({ nonMaxSuppressionWithScore_ });
+const nonMaxSuppressionWithScoreAsync = nonMaxSuppressionWithScoreAsync_;
+const cropAndResize = Object(operation["a" /* op */])({ cropAndResize_ });
+//# sourceMappingURL=image_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/fused_util.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// Whether we should call fused ops.
+const shouldFuse = (gradientDepth, activation) => {
+ const gradientMode = gradientDepth > 0;
+ return !gradientMode || activation === 'linear';
+};
+//# sourceMappingURL=fused_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/fused_ops.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Returns gradient for fused activation.
+const getFusedDyActivation = (dy, y, activation) => {
+ if (activation == null || activation === 'linear') {
+ return dy;
+ }
+ if (activation === 'relu') {
+ return dy.mul(y.step());
+ }
+ throw new Error(`Gradient for activation ${activation} has not been ` +
+ `implemented yet.`);
+};
+// Returns gradient for fused bias.
+const getFusedBiasGradient = (bias, dyActivation) => {
+ let res = dyActivation;
+ const reduceAxes = getReductionAxes(bias.shape, dyActivation.shape);
+ if (reduceAxes.length > 0) {
+ res = res.sum(reduceAxes);
+ }
+ return res.reshape(bias.shape);
+};
+const applyActivation = (x, activation, preluActivationWeights) => {
+ if (activation === 'linear') {
+ return x;
+ }
+ else if (activation === 'relu') {
+ return relu(x);
+ }
+ else if (activation === 'elu') {
+ return elu(x);
+ }
+ else if (activation === 'relu6') {
+ return relu6(x);
+ }
+ else if (activation === 'prelu') {
+ return prelu(x, preluActivationWeights);
+ }
+ throw new Error(`Unknown fused activation ${activation}.`);
+};
+/**
+ * Computes the dot product of two matrices with optional activation and bias.
+ *
+ * ```js
+ * const a = tf.tensor2d([-1, -2], [1, 2]);
+ * const b = tf.tensor2d([1, 2, 3, 4], [2, 2]);
+ * const bias = tf.tensor2d([1, 2], [1, 2]);
+ *
+ * tf.fused.matMul({a, b, bias, activation: 'relu'}).print();
+ * ```
+ *
+ * @param obj An object with the following properties:
+ * - `a` First matrix in dot product operation.
+ * - `b` Second matrix in dot product operation.
+ * - `transposeA` If true, `a` is transposed before multiplication.
+ * - `transposeB` If true, `b` is transposed before multiplication.
+ * - `bias` Matrix to be added to the result.
+ * - `activation` Name of activation kernel (defaults to `linear`).
+ * - `preluActivationWeights` Tensor of prelu weights.
+ */
+function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, activation = 'linear', preluActivationWeights }) {
+ if (shouldFuse(engine["a" /* ENGINE */].state.gradientDepth, activation) === false) {
+ let result = matMul(a, b, transposeA, transposeB);
+ if (bias != null) {
+ result = add(result, bias);
+ }
+ return applyActivation(result, activation, preluActivationWeights);
+ }
+ let $a = Object(tensor_util_env["a" /* convertToTensor */])(a, 'a', 'fused matMul');
+ let $b = Object(tensor_util_env["a" /* convertToTensor */])(b, 'b', 'fused matMul');
+ [$a, $b] = Object(tensor_util["makeTypesMatch"])($a, $b);
+ const innerShapeA = transposeA ? $a.shape[$a.rank - 2] : $a.shape[$a.rank - 1];
+ const innerShapeB = transposeB ? $b.shape[$b.rank - 1] : $b.shape[$b.rank - 2];
+ const outerShapeA = transposeA ? $a.shape[$a.rank - 1] : $a.shape[$a.rank - 2];
+ const outerShapeB = transposeB ? $b.shape[$b.rank - 2] : $b.shape[$b.rank - 1];
+ const outerDimsA = $a.shape.slice(0, -2);
+ const outerDimsB = $b.shape.slice(0, -2);
+ const batchDimA = util["sizeFromShape"](outerDimsA);
+ const batchDimB = util["sizeFromShape"](outerDimsB);
+ util["assert"]($a.rank >= 2 && $b.rank >= 2 && $a.rank === $b.rank, () => `Error in fused matMul: inputs must have the same rank of at least ` +
+ `2, got ranks ${$a.rank} and ${$b.rank}.`);
+ util["assert"](util["arraysEqual"](outerDimsA, outerDimsB), () => `Error in fused matMul: outer dimensions (${outerDimsA}) and (` +
+ `${outerDimsB}) of Tensors with shapes ${$a.shape} and ` +
+ `${$b.shape} must match.`);
+ util["assert"](innerShapeA === innerShapeB, () => `Error in fused matMul: inner shapes (${innerShapeA}) and (` +
+ `${innerShapeB}) of Tensors with shapes ${$a.shape} and ` +
+ `${$b.shape} and transposeA=${transposeA}` +
+ ` and transposeB=${transposeB} must match.`);
+ const outShape = $a.shape.slice(0, -2).concat([outerShapeA, outerShapeB]);
+ const a3D = transposeA ? $a.as3D(batchDimA, innerShapeA, outerShapeA) :
+ $a.as3D(batchDimA, outerShapeA, innerShapeA);
+ const b3D = transposeB ? $b.as3D(batchDimB, outerShapeB, innerShapeB) :
+ $b.as3D(batchDimB, innerShapeB, outerShapeB);
+ let $bias;
+ if (bias != null) {
+ $bias = Object(tensor_util_env["a" /* convertToTensor */])(bias, 'bias', 'fused matMul');
+ [$bias] = Object(tensor_util["makeTypesMatch"])($bias, $a);
+ assertAndGetBroadcastShape(outShape, $bias.shape);
+ }
+ let $preluActivationWeights;
+ if (preluActivationWeights != null) {
+ $preluActivationWeights = Object(tensor_util_env["a" /* convertToTensor */])(preluActivationWeights, 'prelu weights', 'fused matMul');
+ }
+ const grad = (dy, saved) => {
+ const [a3D, b3D, y] = saved;
+ const dyActivation = getFusedDyActivation(dy, y, activation);
+ let biasGradient = {};
+ if (bias != null) {
+ biasGradient = { bias: () => getFusedBiasGradient($bias, dyActivation) };
+ }
+ if (!transposeA && !transposeB) {
+ return Object.assign({
+ a: () => dyActivation.matMul(b3D, false, true),
+ b: () => a3D.matMul(dyActivation, true, false)
+ }, biasGradient);
+ }
+ else if (!transposeA && transposeB) {
+ return Object.assign({
+ a: () => dyActivation.matMul(b3D, false, false),
+ b: () => dyActivation.matMul(a3D, true, false)
+ }, biasGradient);
+ }
+ else if (transposeA && !transposeB) {
+ return Object.assign({
+ a: () => b3D.matMul(dyActivation, false, true),
+ b: () => a3D.matMul(dyActivation, false, false)
+ }, biasGradient);
+ }
+ else {
+ return Object.assign({
+ a: () => b3D.matMul(dyActivation, true, true),
+ b: () => dyActivation.matMul(a3D, true, true)
+ }, biasGradient);
+ }
+ };
+ const inputs = { a: a3D, b: b3D };
+ if (bias != null) {
+ inputs.bias = $bias;
+ }
+ if (preluActivationWeights != null) {
+ inputs.preluActivationWeights = $preluActivationWeights;
+ }
+ const inputsToSave = [a3D, b3D];
+ const outputsToSave = [true];
+ const res = engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const y = backend.fusedBatchMatMul({
+ a: a3D,
+ b: b3D,
+ transposeA,
+ transposeB,
+ bias: $bias,
+ activation,
+ preluActivationWeights: $preluActivationWeights
+ });
+ save([a3D, b3D, y]);
+ return y;
+ }, inputs, grad, '_FusedMatMul', { transposeA, transposeB, activation }, inputsToSave, outputsToSave);
+ return res.reshape(outShape);
+}
+/**
+ * Computes a 2D convolution over the input x, optionally fused with adding a
+ * bias and applying an activation.
+ *
+ * ```js
+ * const inputDepth = 2;
+ * const inShape = [2, 2, 2, inputDepth];
+ * const outputDepth = 2;
+ * const fSize = 1;
+ * const pad = 0;
+ * const strides = 1;
+ *
+ * const x = tf.tensor4d( [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ * 16], inShape);
+ * const w = tf.tensor4d([-1, 1, -2, 0.5], [fSize, fSize, inputDepth,
+ * outputDepth]);
+ *
+ * tf.fused.conv2d({ x, filter: w, strides, pad, dataFormat: 'NHWC',
+ * dilations: [1, 1], bias: tf.scalar(5), activation: 'relu' }).print();
+ * ```
+ *
+ * @param obj An object with the following properties:
+ * @param x The input tensor, of rank 4 or rank 3, of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is
+ * assumed.
+ * @param filter The filter, rank 4, of shape
+ * `[filterHeight, filterWidth, inDepth, outDepth]`.
+ * @param strides The strides of the convolution: `[strideHeight,
+ * strideWidth]`.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid` output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dataFormat An optional string from: "NHWC", "NCHW". Defaults to
+ * "NHWC". Specify the data format of the input and output data. With the
+ * default format "NHWC", the data is stored in the order of: [batch,
+ * height, width, channels]. Only "NHWC" is currently supported.
+ * @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
+ * in which we sample input values across the height and width dimensions
+ * in atrous convolution. Defaults to `[1, 1]`. If `dilations` is a single
+ * number, then `dilationHeight == dilationWidth`. If it is greater than
+ * 1, then all values of `strides` must be 1.
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ * @param bias Tensor to be added to the result.
+ * @param activation Name of activation kernel (defaults to `linear`) to be
+ * applied
+ * after biasAdd.
+ * @param preluActivationWeights Tensor of prelu weights to be applied as part
+ * of a `prelu` activation, typically the same shape as `x`.
+ */
+function fusedConv2d_({ x, filter, strides, pad, dataFormat = 'NHWC', dilations = [1, 1], dimRoundingMode, bias, activation = 'linear', preluActivationWeights }) {
+ activation = activation || 'linear';
+ if (shouldFuse(engine["a" /* ENGINE */].state.gradientDepth, activation) === false) {
+ let result = conv2d(x, filter, strides, pad, dataFormat, dilations, dimRoundingMode);
+ if (bias != null) {
+ result = add(result, bias);
+ }
+ return applyActivation(result, activation, preluActivationWeights);
+ }
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'conv2d');
+ const $filter = Object(tensor_util_env["a" /* convertToTensor */])(filter, 'filter', 'conv2d');
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = $x.as4D(1, $x.shape[0], $x.shape[1], $x.shape[2]);
+ }
+ util["assert"](x4D.rank === 4, () => `Error in fused conv2d: input must be rank 4, but got rank ` +
+ `${x4D.rank}.`);
+ util["assert"]($filter.rank === 4, () => `Error in fused conv2d: filter must be rank 4, but got rank ` +
+ `${$filter.rank}.`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in fused conv2d: pad must be an integer when using, ` +
+ `dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ util["assert"](x4D.shape[3] === $filter.shape[2], () => `Error in conv2d: depth of input (${x4D.shape[3]}) must match ` +
+ `input depth for filter ${$filter.shape[2]}.`);
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in conv2D: Either strides or dilations must be 1. ' +
+ `Got strides ${strides} and dilations '${dilations}'`);
+ util["assert"](dataFormat === 'NHWC', () => `Error in conv2d: got dataFormat of ${dataFormat} but only NHWC is currently supported.`);
+ const convInfo = computeConv2DInfo(x4D.shape, $filter.shape, strides, dilations, pad, dimRoundingMode);
+ let $bias;
+ if (bias != null) {
+ $bias = Object(tensor_util_env["a" /* convertToTensor */])(bias, 'bias', 'fused conv2d');
+ [$bias] = Object(tensor_util["makeTypesMatch"])($bias, $x);
+ assertAndGetBroadcastShape(convInfo.outShape, $bias.shape);
+ }
+ let $preluActivationWeights;
+ if (preluActivationWeights != null) {
+ $preluActivationWeights = Object(tensor_util_env["a" /* convertToTensor */])(preluActivationWeights, 'prelu weights', 'fused conv2d');
+ }
+ const grad = (dy, saved) => {
+ const [$filter, x4D, y] = saved;
+ const dyActivation = getFusedDyActivation(dy, y, activation);
+ util["assert"](tupleValuesAreOne(dilations), () => 'Error in gradient of fused conv2D: ' +
+ `dilation rates greater than 1 ` +
+ `are not yet supported in gradients. Got dilations '${dilations}'`);
+ let biasGradient = {};
+ if (bias != null) {
+ biasGradient = { bias: () => getFusedBiasGradient($bias, dyActivation) };
+ }
+ return Object.assign({
+ x: () => conv2DBackpropInput(x4D.shape, dyActivation, $filter, strides, pad),
+ filter: () => conv2DBackpropFilter(x4D, dyActivation, $filter.shape, strides, pad)
+ }, biasGradient);
+ };
+ const inputs = { x: x4D, filter: $filter };
+ if (bias != null) {
+ inputs.bias = $bias;
+ }
+ if (preluActivationWeights != null) {
+ inputs.preluActivationWeights = $preluActivationWeights;
+ }
+ const inputsToSave = [$filter, x4D];
+ const outputsToSave = [true]; // Save the only output.
+ const res = engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.fusedConv2d({
+ input: x4D,
+ filter: $filter,
+ convInfo,
+ bias: $bias,
+ activation,
+ preluActivationWeights: $preluActivationWeights
+ });
+ save([$filter, x4D, res]);
+ return res;
+ }, inputs, grad, 'FusedConv2D', { convInfo, activation }, inputsToSave, outputsToSave);
+ if (reshapedTo4D) {
+ return res.as3D(res.shape[1], res.shape[2], res.shape[3]);
+ }
+ return res;
+}
+/**
+ * Computes depthwise 2D convolution, optionally fused with adding a
+ * bias and applying an activation.
+ *
+ * Given a 4D `input` array and a `filter` array of shape
+ * `[filterHeight, filterWidth, inChannels, channelMultiplier]` containing
+ * `inChannels` convolutional filters of depth 1, this op applies a
+ * different filter to each input channel (expanding from 1 channel to
+ * `channelMultiplier` channels for each), then concatenates the results
+ * together. The output has `inChannels * channelMultiplier` channels.
+ *
+ * See
+ * [https://www.tensorflow.org/api_docs/python/tf/nn/depthwise_conv2d](
+ * https://www.tensorflow.org/api_docs/python/tf/nn/depthwise_conv2d)
+ * for more details.
+ *
+ * @param obj An object with the following properties:
+ * @param x The input tensor, of rank 4 or rank 3, of shape
+ * `[batch, height, width, inChannels]`. If rank 3, batch of 1 is
+ * assumed.
+ * @param filter The filter tensor, rank 4, of shape
+ * `[filterHeight, filterWidth, inChannels, channelMultiplier]`.
+ * @param strides The strides of the convolution: `[strideHeight,
+ * strideWidth]`. If strides is a single number, then `strideHeight ==
+ * strideWidth`.
+ * @param pad The type of padding algorithm.
+ * - `same` and stride 1: output will be of same size as input,
+ * regardless of filter size.
+ * - `valid`: output will be smaller than input if filter is larger
+ * than 1x1.
+ * - For more info, see this guide:
+ * [https://www.tensorflow.org/api_guides/python/nn#Convolution](
+ * https://www.tensorflow.org/api_guides/python/nn#Convolution)
+ * @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
+ * in which we sample input values across the height and width dimensions
+ * in atrous convolution. Defaults to `[1, 1]`. If `rate` is a single
+ * number, then `dilationHeight == dilationWidth`. If it is greater than
+ * 1, then all values of `strides` must be 1.
+ * @param dataFormat: An optional string from: "NHWC", "NCHW". Defaults to
+ * "NHWC". Specify the data format of the input and output data. With the
+ * default format "NHWC", the data is stored in the order of: [batch,
+ * height, width, channels]. Only "NHWC" is currently supported.
+ * @param dimRoundingMode The rounding mode used when computing output
+ * dimensions if pad is a number. If none is provided, it will not round
+ * and error if the output is of fractional size.
+ * @param bias Tensor to be added to the result.
+ * @param activation Name of activation kernel (defaults to `linear`).
+ * @param preluActivationWeights Tensor of prelu weights to be applied as part
+ * of a `prelu` activation, typically the same shape as `x`.
+ */
+function fusedDepthwiseConv2d_({ x, filter, strides, pad, dataFormat = 'NHWC', dilations = [1, 1], dimRoundingMode, bias, activation = 'linear', preluActivationWeights }) {
+ if (shouldFuse(engine["a" /* ENGINE */].state.gradientDepth, activation) === false) {
+ let result = depthwiseConv2d(x, filter, strides, pad, dataFormat, dilations, dimRoundingMode);
+ if (bias != null) {
+ result = add(result, bias);
+ }
+ return applyActivation(result, activation, preluActivationWeights);
+ }
+ const $x = Object(tensor_util_env["a" /* convertToTensor */])(x, 'x', 'depthwiseConv2d');
+ const $filter = Object(tensor_util_env["a" /* convertToTensor */])(filter, 'filter', 'depthwiseConv2d');
+ let x4D = $x;
+ let reshapedTo4D = false;
+ if ($x.rank === 3) {
+ reshapedTo4D = true;
+ x4D = $x.as4D(1, $x.shape[0], $x.shape[1], $x.shape[2]);
+ }
+ util["assert"](x4D.rank === 4, () => `Error in fused depthwiseConv2d: input must be rank 4, but got ` +
+ `rank ${x4D.rank}.`);
+ util["assert"]($filter.rank === 4, () => `Error in fused depthwiseConv2d: filter must be rank 4, ` +
+ `but got rank ${$filter.rank}.`);
+ util["assert"](x4D.shape[3] === $filter.shape[2], () => `Error in fused depthwiseConv2d: number of input channels ` +
+ `(${x4D.shape[3]}) must match the inChannels dimension in ` +
+ `filter ${$filter.shape[2]}.`);
+ if (dilations == null) {
+ dilations = [1, 1];
+ }
+ util["assert"](eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in fused depthwiseConv2d: Either strides or dilations must ' +
+ `be 1. Got strides ${strides} and dilations '${dilations}'`);
+ if (dimRoundingMode != null) {
+ util["assert"](util["isInt"](pad), () => `Error in fused depthwiseConv2d: pad must be an integer when ` +
+ `using dimRoundingMode ${dimRoundingMode} but got pad ${pad}.`);
+ }
+ const convInfo = computeConv2DInfo(x4D.shape, $filter.shape, strides, dilations, pad, dimRoundingMode, true /* depthwise */);
+ let $bias;
+ if (bias != null) {
+ $bias = Object(tensor_util_env["a" /* convertToTensor */])(bias, 'bias', 'fused conv2d');
+ [$bias] = Object(tensor_util["makeTypesMatch"])($bias, $x);
+ assertAndGetBroadcastShape(convInfo.outShape, $bias.shape);
+ }
+ let $preluActivationWeights;
+ if (preluActivationWeights != null) {
+ $preluActivationWeights = Object(tensor_util_env["a" /* convertToTensor */])(preluActivationWeights, 'prelu weights', 'fused depthwiseConv2d');
+ }
+ const grad = (dy, saved) => {
+ util["assert"](tupleValuesAreOne(dilations), () => 'Error in gradient of fused depthwiseConv2d: dilation rates ' +
+ `greater than 1 are not yet supported. Got dilations ` +
+ `'${dilations}'`);
+ const [$filter, x4D, y] = saved;
+ const dyActivation = getFusedDyActivation(dy, y, activation);
+ let biasGradient = {};
+ if (bias != null) {
+ biasGradient = { bias: () => getFusedBiasGradient($bias, dyActivation) };
+ }
+ return Object.assign({
+ x: () => depthwiseConv2dNativeBackpropInput(x4D.shape, dyActivation, $filter, convInfo),
+ filter: () => depthwiseConv2dNativeBackpropFilter(x4D, dyActivation, $filter.shape, convInfo),
+ }, biasGradient);
+ };
+ const inputs = { x: x4D, filter: $filter };
+ if (bias != null) {
+ inputs.bias = $bias;
+ }
+ if (preluActivationWeights != null) {
+ inputs.preluActivationWeights = $preluActivationWeights;
+ }
+ const inputsToSave = [$filter, x4D];
+ const outputsToSave = [true];
+ const res = engine["a" /* ENGINE */].runKernelFunc((backend, save) => {
+ const res = backend.fusedDepthwiseConv2D({
+ input: x4D,
+ filter: $filter,
+ convInfo,
+ bias: $bias,
+ activation,
+ preluActivationWeights: $preluActivationWeights
+ });
+ save([$filter, x4D, res]);
+ return res;
+ }, inputs, grad, 'FusedDepthwiseConv2D', { convInfo, activation }, inputsToSave, outputsToSave);
+ if (reshapedTo4D) {
+ return res.as3D(res.shape[1], res.shape[2], res.shape[3]);
+ }
+ return res;
+}
+const fused_ops_matMul = Object(operation["a" /* op */])({ fusedMatMul_ });
+const fused_ops_conv2d = Object(operation["a" /* op */])({ fusedConv2d_ });
+const fused_ops_depthwiseConv2d = Object(operation["a" /* op */])({ fusedDepthwiseConv2d_ });
+//# sourceMappingURL=fused_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/ops.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// Modularized ops.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Second level exports.
+
+
+
+
+
+
+
+//# sourceMappingURL=ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/** @doc {heading: 'Training', subheading: 'Classes', namespace: 'train'} */
+class optimizer_Optimizer extends Serializable {
+ /**
+ * Executes `f()` and minimizes the scalar output of `f()` by computing
+ * gradients of y with respect to the list of trainable variables provided by
+ * `varList`. If no list is provided, it defaults to all trainable variables.
+ *
+ * @param f The function to execute and whose output to minimize.
+ * @param returnCost Whether to return the scalar cost value produced by
+ * executing `f()`.
+ * @param varList An optional list of variables to update. If specified, only
+ * the trainable variables in varList will be updated by minimize. Defaults to
+ * all trainable variables.
+ */
+ /** @doc {heading: 'Training', subheading: 'Optimizers'} */
+ minimize(f, returnCost = false, varList) {
+ const { value, grads } = this.computeGradients(f, varList);
+ if (varList != null) {
+ const gradArray = varList.map(v => ({ name: v.name, tensor: grads[v.name] }));
+ this.applyGradients(gradArray);
+ }
+ else {
+ this.applyGradients(grads);
+ }
+ // Dispose gradients.
+ dispose(grads);
+ if (returnCost) {
+ return value;
+ }
+ else {
+ value.dispose();
+ return null;
+ }
+ }
+ /**
+ * The number of iterations that this optimizer instance has been invoked for.
+ */
+ get iterations() {
+ if (this.iterations_ == null) {
+ this.iterations_ = 0;
+ }
+ return this.iterations_;
+ }
+ incrementIterations() {
+ this.iterations_ = this.iterations + 1;
+ }
+ /**
+ * Executes f() and computes the gradient of the scalar output of f() with
+ * respect to the list of trainable variables provided by `varList`. If no
+ * list is provided, it defaults to all trainable variables.
+ *
+ * @param f The function to execute and whose output to use for computing
+ * gradients with respect to variables.
+ * @param varList An optional list of variables to compute gradients with
+ * respect to. If specified, only the trainable variables in varList will have
+ * gradients computed with respect to. Defaults to all trainable variables.
+ */
+ computeGradients(f, varList) {
+ return variableGrads(f, varList);
+ }
+ /**
+ * Dispose the variables (if any) owned by this optimizer instance.
+ */
+ dispose() {
+ if (this.iterations_ != null) {
+ dispose(this.iterations_);
+ }
+ }
+ async saveIterations() {
+ if (this.iterations_ == null) {
+ this.iterations_ = 0;
+ }
+ return {
+ name: 'iter',
+ // TODO(cais): Use 'int64' type when available.
+ tensor: Object(tensor_ops["e" /* scalar */])(this.iterations_, 'int32')
+ };
+ }
+ async getWeights() {
+ throw new Error('getWeights() is not implemented for this optimizer yet.');
+ }
+ async setWeights(weightValues) {
+ throw new Error(`setWeights() is not implemented for this optimizer class ` +
+ `${this.getClassName()}`);
+ }
+ /**
+ * Extract the first element of the weight values and set it
+ * as the iterations counter variable of this instance of optimizer.
+ *
+ * @param weightValues
+ * @returns Weight values with the first element consumed and excluded.
+ */
+ async extractIterations(weightValues) {
+ this.iterations_ = (await weightValues[0].tensor.data())[0];
+ return weightValues.slice(1);
+ }
+}
+Object.defineProperty(optimizer_Optimizer, Symbol.hasInstance, {
+ value: (instance) => {
+ return instance.minimize != null && instance.computeGradients != null &&
+ instance.applyGradients != null;
+ }
+});
+//# sourceMappingURL=optimizer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/adadelta_optimizer.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/** @doclink Optimizer */
+class adadelta_optimizer_AdadeltaOptimizer extends optimizer_Optimizer {
+ constructor(learningRate, rho, epsilon = null) {
+ super();
+ this.learningRate = learningRate;
+ this.rho = rho;
+ this.epsilon = epsilon;
+ this.accumulatedGrads = [];
+ this.accumulatedUpdates = [];
+ if (epsilon == null) {
+ this.epsilon = engine["a" /* ENGINE */].backend.epsilon();
+ }
+ }
+ applyGradients(variableGradients) {
+ const variableNames = Array.isArray(variableGradients) ?
+ variableGradients.map(item => item.name) :
+ Object.keys(variableGradients);
+ variableNames.forEach((name, i) => {
+ const value = engine["a" /* ENGINE */].registeredVariables[name];
+ const trainable = false;
+ if (this.accumulatedGrads[i] == null) {
+ this.accumulatedGrads[i] = {
+ originalName: `${name}/accum_grad`,
+ variable: tidy(() => Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable))
+ };
+ }
+ if (this.accumulatedUpdates[i] == null) {
+ this.accumulatedUpdates[i] = {
+ originalName: `${name}/accum_var`,
+ variable: tidy(() => Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable))
+ };
+ }
+ const gradient = Array.isArray(variableGradients) ?
+ variableGradients[i].tensor :
+ variableGradients[name];
+ if (gradient == null) {
+ return;
+ }
+ const accumulatedGrad = this.accumulatedGrads[i].variable;
+ const accumulatedUpdate = this.accumulatedUpdates[i].variable;
+ tidy(() => {
+ const newAccumulatedGrad = accumulatedGrad.mul(this.rho).add(gradient.square().mul(1 - this.rho));
+ const updates = accumulatedUpdate.add(this.epsilon)
+ .sqrt()
+ .div(accumulatedGrad.add(this.epsilon).sqrt())
+ .mul(gradient);
+ const newAccumulatedUpdate = accumulatedUpdate.mul(this.rho).add(updates.square().mul(1 - this.rho));
+ accumulatedGrad.assign(newAccumulatedGrad);
+ accumulatedUpdate.assign(newAccumulatedUpdate);
+ const newValue = updates.mul(-this.learningRate).add(value);
+ value.assign(newValue);
+ });
+ });
+ this.incrementIterations();
+ }
+ dispose() {
+ if (this.accumulatedUpdates != null) {
+ dispose(this.accumulatedGrads.map(v => v.variable));
+ dispose(this.accumulatedUpdates.map(v => v.variable));
+ }
+ }
+ async getWeights() {
+ // Order matters for Python compatibility.
+ const variables = [...this.accumulatedGrads, ...this.accumulatedUpdates];
+ return [await this.saveIterations()].concat(variables.map(v => ({ name: v.originalName, tensor: v.variable })));
+ }
+ async setWeights(weightValues) {
+ weightValues = await this.extractIterations(weightValues);
+ const variableCount = weightValues.length / 2;
+ const trainable = false;
+ this.accumulatedGrads =
+ weightValues.slice(0, variableCount).map(v => ({
+ originalName: v.name,
+ variable: v.tensor.variable(trainable)
+ }));
+ this.accumulatedUpdates =
+ weightValues.slice(variableCount, variableCount * 2)
+ .map(v => ({
+ originalName: v.name,
+ variable: v.tensor.variable(trainable)
+ }));
+ }
+ getConfig() {
+ return {
+ 'learningRate': this.learningRate,
+ 'rho': this.rho,
+ 'epsilon': this.epsilon
+ };
+ }
+ /** @nocollapse */
+ static fromConfig(cls, config) {
+ return new cls(config['learningRate'], config['rho'], config['epsilon']);
+ }
+}
+/** @nocollapse */
+adadelta_optimizer_AdadeltaOptimizer.className = 'Adadelta'; // Name matters for Python compatibility.
+registerClass(adadelta_optimizer_AdadeltaOptimizer);
+//# sourceMappingURL=adadelta_optimizer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/adagrad_optimizer.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/** @doclink Optimizer */
+class adagrad_optimizer_AdagradOptimizer extends optimizer_Optimizer {
+ constructor(learningRate, initialAccumulatorValue = 0.1) {
+ super();
+ this.learningRate = learningRate;
+ this.initialAccumulatorValue = initialAccumulatorValue;
+ this.accumulatedGrads = [];
+ }
+ applyGradients(variableGradients) {
+ const variableNames = Array.isArray(variableGradients) ?
+ variableGradients.map(item => item.name) :
+ Object.keys(variableGradients);
+ variableNames.forEach((name, i) => {
+ const value = engine["a" /* ENGINE */].registeredVariables[name];
+ if (this.accumulatedGrads[i] == null) {
+ const trainable = false;
+ this.accumulatedGrads[i] = {
+ originalName: `${name}/accumulator`,
+ variable: tidy(() => fill(value.shape, this.initialAccumulatorValue)
+ .variable(trainable))
+ };
+ }
+ const gradient = Array.isArray(variableGradients) ?
+ variableGradients[i].tensor :
+ variableGradients[name];
+ if (gradient == null) {
+ return;
+ }
+ const accumulatedGrad = this.accumulatedGrads[i].variable;
+ tidy(() => {
+ const newAccumulatedGrad = accumulatedGrad.add(gradient.square());
+ accumulatedGrad.assign(newAccumulatedGrad);
+ const newValue = gradient
+ .div(newAccumulatedGrad.add(engine["a" /* ENGINE */].backend.epsilon()).sqrt())
+ .mul(-this.learningRate)
+ .add(value);
+ value.assign(newValue);
+ });
+ });
+ this.incrementIterations();
+ }
+ dispose() {
+ if (this.accumulatedGrads != null) {
+ dispose(this.accumulatedGrads.map(v => v.variable));
+ }
+ }
+ async getWeights() {
+ // Order matters for Python compatibility.
+ return [await this.saveIterations()].concat(this.accumulatedGrads.map(v => ({ name: v.originalName, tensor: v.variable })));
+ }
+ async setWeights(weightValues) {
+ weightValues = await this.extractIterations(weightValues);
+ const trainable = false;
+ this.accumulatedGrads = weightValues.map(v => ({ originalName: v.name, variable: v.tensor.variable(trainable) }));
+ }
+ getConfig() {
+ return {
+ 'learningRate': this.learningRate,
+ 'initialAccumulatorValue': this.initialAccumulatorValue,
+ };
+ }
+ /** @nocollapse */
+ static fromConfig(cls, config) {
+ return new cls(config['learningRate'], config['initialAccumulatorValue']);
+ }
+}
+/** @nocollapse */
+adagrad_optimizer_AdagradOptimizer.className = 'Adagrad'; // Note: Name matters for Python compatibility.
+registerClass(adagrad_optimizer_AdagradOptimizer);
+//# sourceMappingURL=adagrad_optimizer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/adam_optimizer.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+class adam_optimizer_AdamOptimizer extends optimizer_Optimizer {
+ constructor(learningRate, beta1, beta2, epsilon = null) {
+ super();
+ this.learningRate = learningRate;
+ this.beta1 = beta1;
+ this.beta2 = beta2;
+ this.epsilon = epsilon;
+ this.accumulatedFirstMoment = [];
+ this.accumulatedSecondMoment = [];
+ tidy(() => {
+ // accB* will be updated by batch.
+ this.accBeta1 = Object(tensor_ops["e" /* scalar */])(beta1).variable();
+ this.accBeta2 = Object(tensor_ops["e" /* scalar */])(beta2).variable();
+ });
+ if (epsilon == null) {
+ this.epsilon = engine["a" /* ENGINE */].backend.epsilon();
+ }
+ }
+ applyGradients(variableGradients) {
+ const varNames = Array.isArray(variableGradients) ?
+ variableGradients.map(v => v.name) :
+ Object.keys(variableGradients);
+ tidy(() => {
+ const oneMinusAccBeta1 = sub(1, this.accBeta1);
+ const oneMinusAccBeta2 = sub(1, this.accBeta2);
+ varNames.forEach((name, i) => {
+ const value = engine["a" /* ENGINE */].registeredVariables[name];
+ const trainable = false;
+ if (this.accumulatedFirstMoment[i] == null) {
+ this.accumulatedFirstMoment[i] = {
+ originalName: `${name}/m`,
+ variable: tidy(() => Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable))
+ };
+ }
+ if (this.accumulatedSecondMoment[i] == null) {
+ this.accumulatedSecondMoment[i] = {
+ originalName: `${name}/v`,
+ variable: tidy(() => Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable))
+ };
+ }
+ const gradient = Array.isArray(variableGradients) ?
+ variableGradients[i].tensor :
+ variableGradients[name];
+ if (gradient == null) {
+ return;
+ }
+ const firstMoment = this.accumulatedFirstMoment[i].variable;
+ const secondMoment = this.accumulatedSecondMoment[i].variable;
+ const newFirstMoment = firstMoment.mul(this.beta1).add(gradient.mul(1 - this.beta1));
+ const newSecondMoment = secondMoment.mul(this.beta2)
+ .add(gradient.square().mul(1 - this.beta2));
+ const biasCorrectedFirstMoment = newFirstMoment.div(oneMinusAccBeta1);
+ const biasCorrectedSecondMoment = newSecondMoment.div(oneMinusAccBeta2);
+ firstMoment.assign(newFirstMoment);
+ secondMoment.assign(newSecondMoment);
+ const newValue = biasCorrectedFirstMoment
+ .div(biasCorrectedSecondMoment.sqrt().add(this.epsilon))
+ .mul(-this.learningRate)
+ .add(value);
+ value.assign(newValue);
+ });
+ this.accBeta1.assign(this.accBeta1.mul(this.beta1));
+ this.accBeta2.assign(this.accBeta2.mul(this.beta2));
+ });
+ this.incrementIterations();
+ }
+ dispose() {
+ this.accBeta1.dispose();
+ this.accBeta2.dispose();
+ if (this.accumulatedFirstMoment != null) {
+ dispose(this.accumulatedFirstMoment.map(v => v.variable));
+ }
+ if (this.accumulatedSecondMoment != null) {
+ dispose(this.accumulatedSecondMoment.map(v => v.variable));
+ }
+ }
+ async getWeights() {
+ // Order matters for Python compatibility.
+ const variables = [...this.accumulatedFirstMoment, ...this.accumulatedSecondMoment];
+ return [await this.saveIterations()].concat(variables.map(v => ({ name: v.originalName, tensor: v.variable })));
+ }
+ async setWeights(weightValues) {
+ weightValues = await this.extractIterations(weightValues);
+ tidy(() => {
+ this.accBeta1.assign(pow(this.beta1, this.iterations_ + 1));
+ this.accBeta2.assign(pow(this.beta2, this.iterations_ + 1));
+ });
+ const variableCount = weightValues.length / 2;
+ const trainable = false;
+ this.accumulatedFirstMoment =
+ weightValues.slice(0, variableCount).map(v => ({
+ originalName: v.name,
+ variable: v.tensor.variable(trainable)
+ }));
+ this.accumulatedSecondMoment =
+ weightValues.slice(variableCount, variableCount * 2)
+ .map(v => ({
+ originalName: v.name,
+ variable: v.tensor.variable(trainable)
+ }));
+ }
+ getConfig() {
+ return {
+ 'learningRate': this.learningRate,
+ 'beta1': this.beta1,
+ 'beta2': this.beta2,
+ 'epsilon': this.epsilon,
+ };
+ }
+ /** @nocollapse */
+ static fromConfig(cls, config) {
+ return new cls(config['learningRate'], config['beta1'], config['beta2'], config['epsilon']);
+ }
+}
+/** @nocollapse */
+adam_optimizer_AdamOptimizer.className = 'Adam'; // Note: Name matters for Python compatibility.
+registerClass(adam_optimizer_AdamOptimizer);
+//# sourceMappingURL=adam_optimizer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/adamax_optimizer.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+class adamax_optimizer_AdamaxOptimizer extends optimizer_Optimizer {
+ constructor(learningRate, beta1, beta2, epsilon = null, decay = 0.0) {
+ super();
+ this.learningRate = learningRate;
+ this.beta1 = beta1;
+ this.beta2 = beta2;
+ this.epsilon = epsilon;
+ this.decay = decay;
+ this.accumulatedFirstMoment = [];
+ this.accumulatedWeightedInfNorm = [];
+ tidy(() => {
+ this.iteration = Object(tensor_ops["e" /* scalar */])(0).variable();
+ this.accBeta1 = Object(tensor_ops["e" /* scalar */])(beta1).variable();
+ });
+ if (epsilon == null) {
+ this.epsilon = engine["a" /* ENGINE */].backend.epsilon();
+ }
+ }
+ applyGradients(variableGradients) {
+ const variableNames = Array.isArray(variableGradients) ?
+ variableGradients.map(item => item.name) :
+ Object.keys(variableGradients);
+ tidy(() => {
+ const oneMinusAccBeta1 = sub(1, this.accBeta1);
+ const lr = div(-this.learningRate, this.iteration.mul(this.decay).add(1));
+ variableNames.forEach((name, i) => {
+ const value = engine["a" /* ENGINE */].registeredVariables[name];
+ const trainable = false;
+ if (this.accumulatedFirstMoment[i] == null) {
+ this.accumulatedFirstMoment[i] = {
+ originalName: `${name}/m`,
+ variable: Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable)
+ };
+ }
+ if (this.accumulatedWeightedInfNorm[i] == null) {
+ this.accumulatedWeightedInfNorm[i] = {
+ originalName: `${name}/v`,
+ variable: Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable)
+ };
+ }
+ const gradient = Array.isArray(variableGradients) ?
+ variableGradients[i].tensor :
+ variableGradients[name];
+ if (gradient == null) {
+ return;
+ }
+ const firstMoment = this.accumulatedFirstMoment[i].variable;
+ const weightedInfNorm = this.accumulatedWeightedInfNorm[i].variable;
+ const newFirstMoment = firstMoment.mul(this.beta1).add(gradient.mul(1 - this.beta1));
+ const ut0 = weightedInfNorm.mul(this.beta2);
+ const ut1 = gradient.abs();
+ const newWeightedInfNorm = ut0.maximum(ut1);
+ firstMoment.assign(newFirstMoment);
+ weightedInfNorm.assign(newWeightedInfNorm);
+ const newValue = lr.div(oneMinusAccBeta1)
+ .mul(newFirstMoment.div(newWeightedInfNorm.add(this.epsilon)))
+ .add(value);
+ value.assign(newValue);
+ });
+ this.iteration.assign(this.iteration.add(1));
+ this.accBeta1.assign(this.accBeta1.mul(this.beta1));
+ });
+ this.incrementIterations();
+ }
+ dispose() {
+ this.accBeta1.dispose();
+ this.iteration.dispose();
+ if (this.accumulatedFirstMoment != null) {
+ dispose(this.accumulatedFirstMoment.map(v => v.variable));
+ }
+ if (this.accumulatedWeightedInfNorm != null) {
+ dispose(this.accumulatedWeightedInfNorm.map(v => v.variable));
+ }
+ }
+ async getWeights() {
+ throw new Error('getWeights() is not implemented for Adamax yet.');
+ }
+ async setWeights(weightValues) {
+ throw new Error('setWeights() is not implemented for Adamax yet.');
+ }
+ getConfig() {
+ return {
+ 'learningRate': this.learningRate,
+ 'beta1': this.beta1,
+ 'beta2': this.beta2,
+ 'epsilon': this.epsilon,
+ 'decay': this.decay
+ };
+ }
+ /** @nocollapse */
+ static fromConfig(cls, config) {
+ return new cls(config['learningRate'], config['beta1'], config['beta2'], config['epsilon'], config['decay']);
+ }
+}
+/** @nocollapse */
+adamax_optimizer_AdamaxOptimizer.className = 'Adamax'; // Note: Name matters for Python compatbility.
+registerClass(adamax_optimizer_AdamaxOptimizer);
+//# sourceMappingURL=adamax_optimizer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/sgd_optimizer.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/** @doclink Optimizer */
+class sgd_optimizer_SGDOptimizer extends optimizer_Optimizer {
+ constructor(learningRate) {
+ super();
+ this.learningRate = learningRate;
+ this.setLearningRate(learningRate);
+ }
+ applyGradients(variableGradients) {
+ const varNames = Array.isArray(variableGradients) ?
+ variableGradients.map(v => v.name) :
+ Object.keys(variableGradients);
+ varNames.forEach((name, i) => {
+ const gradient = Array.isArray(variableGradients) ?
+ variableGradients[i].tensor :
+ variableGradients[name];
+ if (gradient == null) {
+ return;
+ }
+ const value = engine["a" /* ENGINE */].registeredVariables[name];
+ tidy(() => {
+ const newValue = this.c.mul(gradient).add(value);
+ value.assign(newValue);
+ });
+ });
+ this.incrementIterations();
+ }
+ /**
+ * Sets the learning rate of the optimizer.
+ */
+ setLearningRate(learningRate) {
+ this.learningRate = learningRate;
+ if (this.c != null) {
+ this.c.dispose();
+ }
+ this.c = keep(Object(tensor_ops["e" /* scalar */])(-learningRate));
+ }
+ dispose() {
+ this.c.dispose();
+ }
+ async getWeights() {
+ return [await this.saveIterations()];
+ }
+ async setWeights(weightValues) {
+ weightValues = await this.extractIterations(weightValues);
+ if (weightValues.length !== 0) {
+ throw new Error('SGD optimizer does not have settable weights.');
+ }
+ }
+ getConfig() {
+ return { 'learningRate': this.learningRate };
+ }
+ /** @nocollapse */
+ static fromConfig(cls, config) {
+ return new cls(config['learningRate']);
+ }
+}
+/** @nocollapse */
+sgd_optimizer_SGDOptimizer.className = 'SGD'; // Note: Name matters for Python compatibility.
+registerClass(sgd_optimizer_SGDOptimizer);
+//# sourceMappingURL=sgd_optimizer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/momentum_optimizer.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/** @doclink Optimizer */
+class momentum_optimizer_MomentumOptimizer extends sgd_optimizer_SGDOptimizer {
+ constructor(learningRate, momentum, useNesterov = false) {
+ super(learningRate);
+ this.learningRate = learningRate;
+ this.momentum = momentum;
+ this.useNesterov = useNesterov;
+ this.accumulations = [];
+ this.m = Object(tensor_ops["e" /* scalar */])(this.momentum);
+ }
+ applyGradients(variableGradients) {
+ const variableNames = Array.isArray(variableGradients) ?
+ variableGradients.map(item => item.name) :
+ Object.keys(variableGradients);
+ variableNames.forEach((name, i) => {
+ const value = engine["a" /* ENGINE */].registeredVariables[name];
+ if (this.accumulations[i] == null) {
+ const trainable = false;
+ this.accumulations[i] = {
+ originalName: `${name}/momentum`,
+ variable: tidy(() => Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable))
+ };
+ }
+ const accumulation = this.accumulations[i].variable;
+ const gradient = Array.isArray(variableGradients) ?
+ variableGradients[i].tensor :
+ variableGradients[name];
+ if (gradient == null) {
+ return;
+ }
+ tidy(() => {
+ let newValue;
+ const newAccumulation = this.m.mul(accumulation).add(gradient);
+ if (this.useNesterov) {
+ newValue =
+ this.c.mul(gradient.add(newAccumulation.mul(this.m))).add(value);
+ }
+ else {
+ newValue = this.c.mul(newAccumulation).add(value);
+ }
+ accumulation.assign(newAccumulation);
+ value.assign(newValue);
+ });
+ });
+ this.incrementIterations();
+ }
+ dispose() {
+ this.m.dispose();
+ if (this.accumulations != null) {
+ dispose(this.accumulations.map(v => v.variable));
+ }
+ }
+ /**
+ * Sets the momentum of the optimizer.
+ *
+ * @param momentum
+ */
+ setMomentum(momentum) {
+ this.momentum = momentum;
+ }
+ async getWeights() {
+ // Order matters for Python compatibility.
+ return [await this.saveIterations()].concat(this.accumulations.map(v => ({ name: v.originalName, tensor: v.variable })));
+ }
+ async setWeights(weightValues) {
+ weightValues = await this.extractIterations(weightValues);
+ const trainable = false;
+ this.accumulations = weightValues.map(v => ({ originalName: v.name, variable: v.tensor.variable(trainable) }));
+ }
+ getConfig() {
+ return {
+ 'learningRate': this.learningRate,
+ 'momentum': this.momentum,
+ 'useNesterov': this.useNesterov
+ };
+ }
+ /** @nocollapse */
+ static fromConfig(cls, config) {
+ return new cls(config['learningRate'], config['momentum'], config['useNesterov']);
+ }
+}
+/** @nocollapse */
+momentum_optimizer_MomentumOptimizer.className = 'Momentum'; // Name matters for Python compatibility.
+registerClass(momentum_optimizer_MomentumOptimizer);
+//# sourceMappingURL=momentum_optimizer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/rmsprop_optimizer.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/** @doclink Optimizer */
+class rmsprop_optimizer_RMSPropOptimizer extends optimizer_Optimizer {
+ constructor(learningRate, decay = 0.9, momentum = 0.0, epsilon = null, centered = false) {
+ super();
+ this.learningRate = learningRate;
+ this.decay = decay;
+ this.momentum = momentum;
+ this.epsilon = epsilon;
+ this.accumulatedMeanSquares = [];
+ this.accumulatedMoments = [];
+ this.accumulatedMeanGrads = [];
+ this.centered = centered;
+ if (epsilon == null) {
+ this.epsilon = engine["a" /* ENGINE */].backend.epsilon();
+ }
+ if (learningRate == null) {
+ throw new Error(`learningRate for RMSPropOptimizer must be defined.`);
+ }
+ }
+ applyGradients(variableGradients) {
+ const variableNames = Array.isArray(variableGradients) ?
+ variableGradients.map(item => item.name) :
+ Object.keys(variableGradients);
+ variableNames.forEach((name, i) => {
+ const value = engine["a" /* ENGINE */].registeredVariables[name];
+ const trainable = false;
+ if (this.accumulatedMeanSquares[i] == null) {
+ this.accumulatedMeanSquares[i] = {
+ originalName: `${name}/rms`,
+ variable: tidy(() => Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable))
+ };
+ }
+ if (this.accumulatedMoments[i] == null) {
+ this.accumulatedMoments[i] = {
+ originalName: `${name}/momentum`,
+ variable: tidy(() => Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable))
+ };
+ }
+ if (this.accumulatedMeanGrads[i] == null && this.centered) {
+ this.accumulatedMeanGrads[i] = {
+ originalName: `${name}/mg`,
+ variable: tidy(() => Object(tensor_ops["o" /* zerosLike */])(value).variable(trainable))
+ };
+ }
+ const gradient = Array.isArray(variableGradients) ?
+ variableGradients[i].tensor :
+ variableGradients[name];
+ if (gradient == null) {
+ return;
+ }
+ const accumulatedMeanSquare = this.accumulatedMeanSquares[i].variable;
+ const accumulatedMoments = this.accumulatedMoments[i].variable;
+ tidy(() => {
+ const newAccumulatedMeanSquare = accumulatedMeanSquare.mul(this.decay)
+ .add(gradient.square().mul(1 - this.decay));
+ if (this.centered) {
+ const accumulatedMeanGrad = this.accumulatedMeanGrads[i].variable;
+ // Centered gradient
+ const newAccumulatedMeanGrad = accumulatedMeanGrad.mul(this.decay)
+ .add(gradient.mul(1 - this.decay));
+ const newAccumulatedMoments = accumulatedMoments.mul(this.momentum)
+ .add(gradient.mul(this.learningRate)
+ .div(newAccumulatedMeanSquare
+ .sub(newAccumulatedMeanGrad.square().add(this.epsilon))
+ .sqrt()));
+ accumulatedMeanSquare.assign(newAccumulatedMeanSquare);
+ accumulatedMeanGrad.assign(newAccumulatedMeanGrad);
+ accumulatedMoments.assign(newAccumulatedMoments);
+ const newValue = value.sub(newAccumulatedMoments);
+ value.assign(newValue);
+ }
+ else {
+ // Plain gradient
+ const newAccumulatedMeanSquare = accumulatedMeanSquare.mul(this.decay)
+ .add(gradient.square().mul(1 - this.decay));
+ const newAccumulatedMoments = accumulatedMoments.mul(this.momentum)
+ .add(gradient.mul(this.learningRate)
+ .div(newAccumulatedMeanSquare.add(this.epsilon)
+ .sqrt()));
+ accumulatedMeanSquare.assign(newAccumulatedMeanSquare);
+ accumulatedMoments.assign(newAccumulatedMoments);
+ const newValue = value.sub(newAccumulatedMoments);
+ value.assign(newValue);
+ }
+ });
+ });
+ this.incrementIterations();
+ }
+ dispose() {
+ if (this.accumulatedMeanSquares != null) {
+ dispose(this.accumulatedMeanSquares.map(v => v.variable));
+ }
+ if (this.accumulatedMeanGrads != null && this.centered) {
+ dispose(this.accumulatedMeanGrads.map(v => v.variable));
+ }
+ if (this.accumulatedMoments != null) {
+ dispose(this.accumulatedMoments.map(v => v.variable));
+ }
+ }
+ async getWeights() {
+ // Order matters for Python compatibility.
+ const variables = [...this.accumulatedMeanSquares, ...this.accumulatedMoments];
+ if (this.centered) {
+ variables.push(...this.accumulatedMeanGrads);
+ }
+ return [await this.saveIterations()].concat(variables.map(v => ({ name: v.originalName, tensor: v.variable })));
+ }
+ async setWeights(weightValues) {
+ weightValues = await this.extractIterations(weightValues);
+ const variableCount = this.centered ? weightValues.length / 3 : weightValues.length / 2;
+ const trainable = false;
+ this.accumulatedMeanSquares =
+ weightValues.slice(0, variableCount).map(v => ({
+ originalName: v.name,
+ variable: v.tensor.variable(trainable)
+ }));
+ this.accumulatedMoments =
+ weightValues.slice(variableCount, variableCount * 2)
+ .map(v => ({
+ originalName: v.name,
+ variable: v.tensor.variable(trainable)
+ }));
+ if (this.centered) {
+ this.accumulatedMeanGrads =
+ weightValues.slice(variableCount * 2, variableCount * 3)
+ .map(v => ({
+ originalName: v.name,
+ variable: v.tensor.variable(trainable)
+ }));
+ }
+ }
+ getConfig() {
+ return {
+ 'learningRate': this.learningRate,
+ 'decay': this.decay,
+ 'momentum': this.momentum,
+ 'epsilon': this.epsilon,
+ 'centered': this.centered
+ };
+ }
+ /** @nocollapse */
+ static fromConfig(cls, config) {
+ return new cls(config['learningRate'], config['decay'], config['momentum'], config['epsilon'], config['centered']);
+ }
+}
+/** @nocollapse */
+rmsprop_optimizer_RMSPropOptimizer.className = 'RMSProp'; // Note: Name matters for Python compatibility.
+registerClass(rmsprop_optimizer_RMSPropOptimizer);
+//# sourceMappingURL=rmsprop_optimizer.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/types.js
+var dist_types = __webpack_require__(23);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer_constructors.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+class optimizer_constructors_OptimizerConstructors {
+ /**
+ * Constructs a `tf.SGDOptimizer` that uses stochastic gradient descent.
+ *
+ * ```js
+ * // Fit a quadratic function by learning the coefficients a, b, c.
+ * const xs = tf.tensor1d([0, 1, 2, 3]);
+ * const ys = tf.tensor1d([1.1, 5.9, 16.8, 33.9]);
+ *
+ * const a = tf.scalar(Math.random()).variable();
+ * const b = tf.scalar(Math.random()).variable();
+ * const c = tf.scalar(Math.random()).variable();
+ *
+ * // y = a * x^2 + b * x + c.
+ * const f = x => a.mul(x.square()).add(b.mul(x)).add(c);
+ * const loss = (pred, label) => pred.sub(label).square().mean();
+ *
+ * const learningRate = 0.01;
+ * const optimizer = tf.train.sgd(learningRate);
+ *
+ * // Train the model.
+ * for (let i = 0; i < 10; i++) {
+ * optimizer.minimize(() => loss(f(xs), ys));
+ * }
+ *
+ * // Make predictions.
+ * console.log(
+ * `a: ${a.dataSync()}, b: ${b.dataSync()}, c: ${c.dataSync()}`);
+ * const preds = f(xs).dataSync();
+ * preds.forEach((pred, i) => {
+ * console.log(`x: ${i}, pred: ${pred}`);
+ * });
+ * ```
+ *
+ * @param learningRate The learning rate to use for the SGD algorithm.
+ */
+ /**
+ * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+ */
+ static sgd(learningRate) {
+ return new sgd_optimizer_SGDOptimizer(learningRate);
+ }
+ /**
+ * Constructs a `tf.MomentumOptimizer` that uses momentum gradient
+ * descent.
+ *
+ * See
+ * [http://proceedings.mlr.press/v28/sutskever13.pdf](
+ * http://proceedings.mlr.press/v28/sutskever13.pdf)
+ *
+ * @param learningRate The learning rate to use for the Momentum gradient
+ * descent algorithm.
+ * @param momentum The momentum to use for the momentum gradient descent
+ * algorithm.
+ */
+ /**
+ * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+ */
+ static momentum(learningRate, momentum, useNesterov = false) {
+ return new momentum_optimizer_MomentumOptimizer(learningRate, momentum, useNesterov);
+ }
+ /**
+ * Constructs a `tf.RMSPropOptimizer` that uses RMSProp gradient
+ * descent. This implementation uses plain momentum and is not centered
+ * version of RMSProp.
+ *
+ * See
+ * [http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf](
+ * http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf)
+ *
+ * @param learningRate The learning rate to use for the RMSProp gradient
+ * descent algorithm.
+ * @param decay The discounting factor for the history/coming gradient.
+ * @param momentum The momentum to use for the RMSProp gradient descent
+ * algorithm.
+ * @param epsilon Small value to avoid zero denominator.
+ * @param centered If true, gradients are normalized by the estimated
+ * variance of the gradient.
+ */
+ /**
+ * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+ */
+ static rmsprop(learningRate, decay = .9, momentum = 0.0, epsilon = null, centered = false) {
+ return new rmsprop_optimizer_RMSPropOptimizer(learningRate, decay, momentum, epsilon, centered);
+ }
+ /**
+ * Constructs a `tf.AdamOptimizer` that uses the Adam algorithm.
+ * See [https://arxiv.org/abs/1412.6980](https://arxiv.org/abs/1412.6980)
+ *
+ * @param learningRate The learning rate to use for the Adam gradient
+ * descent algorithm.
+ * @param beta1 The exponential decay rate for the 1st moment estimates.
+ * @param beta2 The exponential decay rate for the 2nd moment estimates.
+ * @param epsilon A small constant for numerical stability.
+ */
+ /**
+ * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+ */
+ static adam(learningRate = 0.001, beta1 = 0.9, beta2 = 0.999, epsilon = null) {
+ return new adam_optimizer_AdamOptimizer(learningRate, beta1, beta2, epsilon);
+ }
+ /**
+ * Constructs a `tf.AdadeltaOptimizer` that uses the Adadelta algorithm.
+ * See [https://arxiv.org/abs/1212.5701](https://arxiv.org/abs/1212.5701)
+ *
+ * @param learningRate The learning rate to use for the Adadelta gradient
+ * descent algorithm.
+ * @param rho The learning rate decay over each update.
+ * @param epsilon A constant epsilon used to better condition the grad
+ * update.
+ */
+ /**
+ * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+ */
+ static adadelta(learningRate = .001, rho = .95, epsilon = null) {
+ return new adadelta_optimizer_AdadeltaOptimizer(learningRate, rho, epsilon);
+ }
+ /**
+ * Constructs a `tf.AdamaxOptimizer` that uses the Adamax algorithm.
+ * See [https://arxiv.org/abs/1412.6980](https://arxiv.org/abs/1412.6980)
+ *
+ * @param learningRate The learning rate to use for the Adamax gradient
+ * descent algorithm.
+ * @param beta1 The exponential decay rate for the 1st moment estimates.
+ * @param beta2 The exponential decay rate for the 2nd moment estimates.
+ * @param epsilon A small constant for numerical stability.
+ * @param decay The learning rate decay over each update.
+ */
+ /**
+ * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+ */
+ static adamax(learningRate = 0.002, beta1 = 0.9, beta2 = 0.999, epsilon = null, decay = 0.0) {
+ return new adamax_optimizer_AdamaxOptimizer(learningRate, beta1, beta2, epsilon, decay);
+ }
+ /**
+ * Constructs a `tf.AdagradOptimizer` that uses the Adagrad algorithm.
+ * See
+ * [http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf](
+ * http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf)
+ * or
+ * [http://ruder.io/optimizing-gradient-descent/index.html#adagrad](
+ * http://ruder.io/optimizing-gradient-descent/index.html#adagrad)
+ *
+ * @param learningRate The learning rate to use for the Adagrad gradient
+ * descent algorithm.
+ * @param initialAccumulatorValue Starting value for the accumulators, must be
+ * positive.
+ */
+ /**
+ * @doc {heading: 'Training', subheading: 'Optimizers', namespace: 'train'}
+ */
+ static adagrad(learningRate, initialAccumulatorValue = 0.1) {
+ return new adagrad_optimizer_AdagradOptimizer(learningRate, initialAccumulatorValue);
+ }
+}
+//# sourceMappingURL=optimizer_constructors.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/train.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// So typings can propagate.
+
+
+
+
+
+
+
+
+// tslint:disable-next-line:no-unused-expression
+[momentum_optimizer_MomentumOptimizer, sgd_optimizer_SGDOptimizer, adadelta_optimizer_AdadeltaOptimizer, adagrad_optimizer_AdagradOptimizer,
+ rmsprop_optimizer_RMSPropOptimizer, adamax_optimizer_AdamaxOptimizer, adam_optimizer_AdamOptimizer];
+const train = {
+ sgd: optimizer_constructors_OptimizerConstructors.sgd,
+ momentum: optimizer_constructors_OptimizerConstructors.momentum,
+ adadelta: optimizer_constructors_OptimizerConstructors.adadelta,
+ adagrad: optimizer_constructors_OptimizerConstructors.adagrad,
+ rmsprop: optimizer_constructors_OptimizerConstructors.rmsprop,
+ adamax: optimizer_constructors_OptimizerConstructors.adamax,
+ adam: optimizer_constructors_OptimizerConstructors.adam
+};
+//# sourceMappingURL=train.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/browser_util.js
+var browser_util = __webpack_require__(40);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/array_ops_util.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Gets the new shape of the input Tensor after it's been reshaped
+ * to:
+ * [blockShape[0], ..., blockShape[M-1], batch / prod(blockShape),
+ * inputShape[1], ..., inputShape[N-1]]
+ *
+ * See step 1: https://www.tensorflow.org/api_docs/python/tf/batch_to_space_nd
+ */
+function getReshaped(inputShape, blockShape, prod, batchToSpace = true) {
+ let reshaped = [];
+ if (batchToSpace) {
+ reshaped = reshaped.concat(blockShape.slice(0));
+ reshaped.push(inputShape[0] / prod);
+ reshaped = reshaped.concat(inputShape.slice(1));
+ }
+ else {
+ reshaped = reshaped.concat(inputShape[0]);
+ const spatialLength = blockShape.length;
+ for (let i = 0; i < spatialLength; ++i) {
+ reshaped =
+ reshaped.concat([inputShape[i + 1] / blockShape[i], blockShape[i]]);
+ }
+ reshaped = reshaped.concat(inputShape.slice(spatialLength + 1));
+ }
+ return reshaped;
+}
+/**
+ * Gets the permutation that will transpose the dimensions of the
+ * reshaped tensor to shape:
+ *
+ * [batch / prod(block_shape),inputShape[1], blockShape[0], ...,
+ * inputShape[M], blockShape[M-1],inputShape[M+1], ..., inputShape[N-1]]
+ *
+ * see step 2: https://www.tensorflow.org/api_docs/python/tf/batch_to_space_nd
+ */
+function getPermuted(reshapedRank, blockShapeRank, batchToSpace = true) {
+ const permuted = [];
+ if (batchToSpace) {
+ permuted.push(blockShapeRank);
+ for (let i = blockShapeRank + 1; i < reshapedRank; ++i) {
+ if (i <= 2 * blockShapeRank) {
+ permuted.push(i);
+ permuted.push(i - (blockShapeRank + 1));
+ }
+ else {
+ permuted.push(i);
+ }
+ }
+ }
+ else {
+ const permutedBeforeBatch = [];
+ const permutedAfterBatch = [];
+ for (let i = 1; i < reshapedRank; ++i) {
+ if (i >= blockShapeRank * 2 + 1 || i % 2 === 1) {
+ permutedAfterBatch.push(i);
+ }
+ else {
+ permutedBeforeBatch.push(i);
+ }
+ }
+ permuted.push(...permutedBeforeBatch);
+ permuted.push(0);
+ permuted.push(...permutedAfterBatch);
+ }
+ return permuted;
+}
+/**
+ * Gets the shape of the reshaped and permuted input Tensor before any cropping
+ * is applied. The new shape will be:
+ *
+ * [batch / prod(blockShape),inputShape[1] * blockShape[0], ...,
+ * inputShape[M] * blockShape[M-1],inputShape[M+1], ..., inputShape[N-1]]
+ *
+ * See step 3: https://www.tensorflow.org/api_docs/python/tf/batch_to_space_nd
+ */
+function getReshapedPermuted(inputShape, blockShape, prod, batchToSpace = true) {
+ const reshapedPermuted = [];
+ if (batchToSpace) {
+ reshapedPermuted.push(inputShape[0] / prod);
+ }
+ else {
+ reshapedPermuted.push(inputShape[0] * prod);
+ }
+ for (let i = 1; i < inputShape.length; ++i) {
+ if (i <= blockShape.length) {
+ if (batchToSpace) {
+ reshapedPermuted.push(blockShape[i - 1] * inputShape[i]);
+ }
+ else {
+ reshapedPermuted.push(inputShape[i] / blockShape[i - 1]);
+ }
+ }
+ else {
+ reshapedPermuted.push(inputShape[i]);
+ }
+ }
+ return reshapedPermuted;
+}
+/**
+ * Converts the crops argument into the beginning coordinates of a slice
+ * operation.
+ */
+function getSliceBeginCoords(crops, blockShape) {
+ const sliceBeginCoords = [0];
+ for (let i = 0; i < blockShape; ++i) {
+ sliceBeginCoords.push(crops[i][0]);
+ }
+ return sliceBeginCoords;
+}
+/**
+ * Converts the crops argument into the size of a slice operation. When
+ * combined with getSliceBeginCoords this function allows the reshaped and
+ * permuted Tensor to be cropped to its final output shape of:
+ *
+ * inputShape[1] * blockShape[0] - crops[0,0] - crops[0,1], ...,
+ * inputShape[M] * blockShape[M-1] -crops[M-1,0] -
+ * crops[M-1,1],inputShape[M+1], ..., inputShape[N-1]]
+ *
+ * See step 4: https://www.tensorflow.org/api_docs/python/tf/batch_to_space_nd
+ */
+function getSliceSize(uncroppedShape, crops, blockShape) {
+ const sliceSize = uncroppedShape.slice(0, 1);
+ for (let i = 0; i < blockShape; ++i) {
+ sliceSize.push(uncroppedShape[i + 1] - crops[i][0] - crops[i][1]);
+ }
+ return sliceSize;
+}
+//# sourceMappingURL=array_ops_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/ops/erf_util.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const ERF_P = 0.3275911;
+const ERF_A1 = 0.254829592;
+const ERF_A2 = -0.284496736;
+const ERF_A3 = 1.421413741;
+const ERF_A4 = -1.453152027;
+const ERF_A5 = 1.061405429;
+//# sourceMappingURL=erf_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/log.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function warn(...msg) {
+ if (!Object(environment["c" /* env */])().getBool('IS_TEST')) {
+ console.warn(...msg);
+ }
+}
+function log_log(...msg) {
+ if (!Object(environment["c" /* env */])().getBool('IS_TEST')) {
+ console.log(...msg);
+ }
+}
+//# sourceMappingURL=log.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/complex_util.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Merges real and imaginary Float32Arrays into a single complex Float32Array.
+ *
+ * The memory layout is interleaved as follows:
+ * real: [r0, r1, r2]
+ * imag: [i0, i1, i2]
+ * complex: [r0, i0, r1, i1, r2, i2]
+ *
+ * This is the inverse of splitRealAndImagArrays.
+ *
+ * @param real The real values of the complex tensor values.
+ * @param imag The imag values of the complex tensor values.
+ * @returns A complex tensor as a Float32Array with merged values.
+ */
+function mergeRealAndImagArrays(real, imag) {
+ if (real.length !== imag.length) {
+ throw new Error(`Cannot merge real and imag arrays of different lengths. real:` +
+ `${real.length}, imag: ${imag.length}.`);
+ }
+ const result = new Float32Array(real.length * 2);
+ for (let i = 0; i < result.length; i += 2) {
+ result[i] = real[i / 2];
+ result[i + 1] = imag[i / 2];
+ }
+ return result;
+}
+/**
+ * Splits a complex Float32Array into real and imag parts.
+ *
+ * The memory layout is interleaved as follows:
+ * complex: [r0, i0, r1, i1, r2, i2]
+ * real: [r0, r1, r2]
+ * imag: [i0, i1, i2]
+ *
+ * This is the inverse of mergeRealAndImagArrays.
+ *
+ * @param complex The complex tensor values.
+ * @returns An object with real and imag Float32Array components of the complex
+ * tensor.
+ */
+function splitRealAndImagArrays(complex) {
+ const real = new Float32Array(complex.length / 2);
+ const imag = new Float32Array(complex.length / 2);
+ for (let i = 0; i < complex.length; i += 2) {
+ real[i / 2] = complex[i];
+ imag[i / 2] = complex[i + 1];
+ }
+ return { real, imag };
+}
+/**
+ * Extracts even indexed complex values in the given array.
+ * @param complex The complex tensor values
+ */
+function complexWithEvenIndex(complex) {
+ const len = Math.ceil(complex.length / 4);
+ const real = new Float32Array(len);
+ const imag = new Float32Array(len);
+ for (let i = 0; i < complex.length; i += 4) {
+ real[Math.floor(i / 4)] = complex[i];
+ imag[Math.floor(i / 4)] = complex[i + 1];
+ }
+ return { real, imag };
+}
+/**
+ * Extracts odd indexed comple values in the given array.
+ * @param complex The complex tensor values
+ */
+function complexWithOddIndex(complex) {
+ const len = Math.floor(complex.length / 4);
+ const real = new Float32Array(len);
+ const imag = new Float32Array(len);
+ for (let i = 2; i < complex.length; i += 4) {
+ real[Math.floor(i / 4)] = complex[i];
+ imag[Math.floor(i / 4)] = complex[i + 1];
+ }
+ return { real, imag };
+}
+/**
+ * Get the map representing a complex value in the given array.
+ * @param complex The complex tensor values.
+ * @param index An index of the target complex value.
+ */
+function getComplexWithIndex(complex, index) {
+ const real = complex[index * 2];
+ const imag = complex[index * 2 + 1];
+ return { real, imag };
+}
+/**
+ * Insert a given complex value into the TypedArray.
+ * @param data The array in which the complex value is inserted.
+ * @param c The complex value to be inserted.
+ * @param index An index of the target complex value.
+ */
+function assignToTypedArray(data, real, imag, index) {
+ data[index * 2] = real;
+ data[index * 2 + 1] = imag;
+}
+/**
+ * Make the list of exponent terms used by FFT.
+ */
+function exponents(n, inverse) {
+ const real = new Float32Array(n / 2);
+ const imag = new Float32Array(n / 2);
+ for (let i = 0; i < Math.ceil(n / 2); i++) {
+ const x = (inverse ? 2 : -2) * Math.PI * (i / n);
+ real[i] = Math.cos(x);
+ imag[i] = Math.sin(x);
+ }
+ return { real, imag };
+}
+/**
+ * Make the exponent term used by FFT.
+ */
+function exponent(k, n, inverse) {
+ const x = (inverse ? 2 : -2) * Math.PI * (k / n);
+ const real = Math.cos(x);
+ const imag = Math.sin(x);
+ return { real, imag };
+}
+//# sourceMappingURL=complex_util.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/backend_util.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+// Utilities needed by backend consumers of tf-core.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function castTensor(x, dtype, backend) {
+ if (dtype === 'complex64') {
+ if (x.dtype === 'complex64') {
+ return x.clone();
+ }
+ const zerosTensor = Object(tensor_ops["n" /* zeros */])(x.shape);
+ const floatX = x.toFloat();
+ const result = backend.complex(floatX, zerosTensor);
+ zerosTensor.dispose();
+ floatX.dispose();
+ return result;
+ }
+ if (!Object(util["hasEncodingLoss"])(x.dtype, dtype)) {
+ // We don't change the underlying data, since we cast to higher
+ // precision.
+ return engine["a" /* ENGINE */].makeTensorFromDataId(x.dataId, x.shape, dtype);
+ }
+ if (x.dtype === 'complex64') {
+ const real = backend.real(x);
+ const result = real.cast(dtype);
+ real.dispose();
+ return result;
+ }
+ if (dtype === 'int32') {
+ return backend.int(x);
+ }
+ else if (dtype === 'bool') {
+ const zero = Object(tensor_ops["e" /* scalar */])(0, x.dtype);
+ const result = backend.notEqual(x, zero);
+ zero.dispose();
+ return result;
+ }
+ else {
+ throw new Error(`Error in Cast: failed to cast ${x.dtype} to ${dtype}`);
+ }
+}
+function reshapeTensor(x, shape) {
+ return engine["a" /* ENGINE */].makeTensorFromDataId(x.dataId, shape, x.dtype);
+}
+function linspaceImpl(start, stop, num) {
+ const step = (stop - start) / (num - 1);
+ const values = Object(util["makeZerosTypedArray"])(num, 'float32');
+ values[0] = start;
+ for (let i = 1; i < values.length; i++) {
+ values[i] = values[i - 1] + step;
+ }
+ return Object(tensor_ops["g" /* tensor1d */])(values, 'float32');
+}
+//# sourceMappingURL=backend_util.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/device_util.js
+var device_util = __webpack_require__(36);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/split_shared.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// TODO(annxingyuan): Use this helper in WASM Split kernel once intermediate
+// kernels have been modularized in WebGL and CPU
+// https://github.com/tensorflow/tfjs/issues/2822.
+/** Shared implementation of the split kernel across WebGL and CPU. */
+function split_shared_split(x, sizeSplits, axis) {
+ const begin = new Array(x.rank).fill(0);
+ const size = x.shape.slice();
+ return sizeSplits.map(s => {
+ const sliceSize = [...size];
+ sliceSize[axis] = s;
+ const slice = x.slice(begin, sliceSize);
+ begin[axis] += s;
+ return slice;
+ });
+}
+//# sourceMappingURL=split_shared.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/tile_impl.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * An implementation of the tile kernel shared between webgl and cpu for string
+ * tensors only.
+ */
+
+function tile_impl_tile(xBuf, reps) {
+ const newShape = new Array(xBuf.rank);
+ for (let i = 0; i < newShape.length; i++) {
+ newShape[i] = xBuf.shape[i] * reps[i];
+ }
+ const result = array_ops_buffer(newShape, xBuf.dtype);
+ for (let i = 0; i < result.values.length; ++i) {
+ const newLoc = result.indexToLoc(i);
+ const originalLoc = new Array(xBuf.rank);
+ for (let j = 0; j < originalLoc.length; j++) {
+ originalLoc[j] = newLoc[j] % xBuf.shape[j];
+ }
+ const originalIndex = xBuf.locToIndex(originalLoc);
+ result.values[i] = xBuf.values[originalIndex];
+ }
+ return result.toTensor();
+}
+//# sourceMappingURL=tile_impl.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/topk_impl.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/** An implementation of the TopK kernel shared between webgl and cpu. */
+
+
+function topkImpl(x, xShape, xDtype, k, sorted) {
+ // Reshape into a 2d tensor [batch, lastDim] and compute topk along lastDim.
+ const lastDim = xShape[xShape.length - 1];
+ const [batch, size] = [x.length / lastDim, lastDim];
+ const allTopKVals = Object(util["getTypedArrayFromDType"])(xDtype, batch * k);
+ const allTopKIndices = Object(util["getTypedArrayFromDType"])('int32', batch * k);
+ for (let b = 0; b < batch; b++) {
+ const offset = b * size;
+ const vals = x.subarray(offset, offset + size);
+ const valAndInd = [];
+ for (let i = 0; i < vals.length; i++) {
+ valAndInd.push({ value: vals[i], index: i });
+ }
+ valAndInd.sort((a, b) => b.value - a.value);
+ const outOffset = b * k;
+ const topKVals = allTopKVals.subarray(outOffset, outOffset + k);
+ const topKIndices = allTopKIndices.subarray(outOffset, outOffset + k);
+ for (let i = 0; i < k; i++) {
+ topKVals[i] = valAndInd[i].value;
+ topKIndices[i] = valAndInd[i].index;
+ }
+ }
+ // Reshape back to the original input shape, except that the last
+ // dimension is k.
+ const outputShape = xShape.slice();
+ outputShape[outputShape.length - 1] = k;
+ return [
+ Object(tensor_ops["f" /* tensor */])(allTopKVals, outputShape, xDtype),
+ Object(tensor_ops["f" /* tensor */])(allTopKIndices, outputShape, 'int32')
+ ];
+}
+//# sourceMappingURL=topk_impl.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/kernel_impls.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+//# sourceMappingURL=kernel_impls.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/backends/backend.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const EPSILON_FLOAT32 = 1e-7;
+const EPSILON_FLOAT16 = 1e-4;
+/** Convenient class for storing tensor-related data. */
+class DataStorage {
+ constructor(backend, dataMover) {
+ this.backend = backend;
+ this.dataMover = dataMover;
+ this.data = new WeakMap();
+ this.dataIdsCount = 0;
+ }
+ get(dataId) {
+ if (!this.data.has(dataId)) {
+ this.dataMover.moveData(this.backend, dataId);
+ }
+ return this.data.get(dataId);
+ }
+ set(dataId, value) {
+ this.dataIdsCount++;
+ this.data.set(dataId, value);
+ }
+ has(dataId) {
+ return this.data.has(dataId);
+ }
+ delete(dataId) {
+ this.dataIdsCount--;
+ return this.data.delete(dataId);
+ }
+ numDataIds() {
+ return this.dataIdsCount;
+ }
+}
+/**
+ * The interface that defines the kernels that should be implemented when
+ * adding a new backend. New backends don't need to implement every one of the
+ * methods, this can be done gradually (throw an error for unimplemented
+ * methods).
+ */
+class KernelBackend {
+ time(f) {
+ return notYetImplemented('time');
+ }
+ read(dataId) {
+ return notYetImplemented('read');
+ }
+ readSync(dataId) {
+ return notYetImplemented('readSync');
+ }
+ numDataIds() {
+ return notYetImplemented('numDataIds');
+ }
+ disposeData(dataId) {
+ return notYetImplemented('disposeData');
+ }
+ write(values, shape, dtype) {
+ return notYetImplemented('write');
+ }
+ move(dataId, values, shape, dtype) {
+ return notYetImplemented('move');
+ }
+ memory() {
+ return notYetImplemented('memory');
+ }
+ /** Returns the highest precision for floats in bits (e.g. 16 or 32) */
+ floatPrecision() {
+ return notYetImplemented('floatPrecision');
+ }
+ /** Returns the smallest representable number. */
+ epsilon() {
+ return this.floatPrecision() === 32 ? EPSILON_FLOAT32 : EPSILON_FLOAT16;
+ }
+ batchMatMul(a, b, transposeA, transposeB) {
+ return notYetImplemented('batchMatMul');
+ }
+ fusedBatchMatMul({ a, b, transposeA, transposeB, bias, activation, preluActivationWeights }) {
+ return notYetImplemented('fusedBatchMatMul');
+ }
+ slice(x, begin, size) {
+ return notYetImplemented('slice');
+ }
+ stridedSlice(x, begin, end, strides) {
+ return notYetImplemented('stridedSlice');
+ }
+ unstack(x, axis) {
+ return notYetImplemented('unstack');
+ }
+ reverse(a, axis) {
+ return notYetImplemented('reverse');
+ }
+ concat(tensors, axis) {
+ return notYetImplemented('concat');
+ }
+ neg(a) {
+ return notYetImplemented('neg');
+ }
+ add(a, b) {
+ return notYetImplemented('add');
+ }
+ addN(tensors) {
+ return notYetImplemented('addN');
+ }
+ subtract(a, b) {
+ return notYetImplemented('subtract');
+ }
+ multiply(a, b) {
+ return notYetImplemented('multiply');
+ }
+ realDivide(a, b) {
+ return notYetImplemented('realDivide');
+ }
+ floorDiv(a, b) {
+ return notYetImplemented('floorDiv');
+ }
+ sum(x, axes) {
+ return notYetImplemented('sum');
+ }
+ prod(x, axes) {
+ return notYetImplemented('prod');
+ }
+ unsortedSegmentSum(x, segmentIds, numSegments) {
+ return notYetImplemented('unsortedSegmentSum');
+ }
+ argMin(x, axis) {
+ return notYetImplemented('argMin');
+ }
+ argMax(x, axis) {
+ return notYetImplemented('argMax');
+ }
+ equal(a, b) {
+ return notYetImplemented('equal');
+ }
+ notEqual(a, b) {
+ return notYetImplemented('notEqual');
+ }
+ less(a, b) {
+ return notYetImplemented('less');
+ }
+ lessEqual(a, b) {
+ return notYetImplemented('lessEqual');
+ }
+ greater(a, b) {
+ return notYetImplemented('greater');
+ }
+ greaterEqual(a, b) {
+ return notYetImplemented('greaterEqual');
+ }
+ logicalNot(a) {
+ return notYetImplemented('logicalNot');
+ }
+ logicalAnd(a, b) {
+ return notYetImplemented('logicalAnd');
+ }
+ logicalOr(a, b) {
+ return notYetImplemented('logicalOr');
+ }
+ where(condition) {
+ return notYetImplemented('where');
+ }
+ select(condition, a, b) {
+ return notYetImplemented('select');
+ }
+ topk(x, k, sorted) {
+ return notYetImplemented('topk');
+ }
+ min(x, axes) {
+ return notYetImplemented('min');
+ }
+ minimum(a, b) {
+ return notYetImplemented('minimum');
+ }
+ mod(a, b) {
+ return notYetImplemented('mod');
+ }
+ max(x, axes) {
+ return notYetImplemented('max');
+ }
+ maximum(a, b) {
+ return notYetImplemented('maximum');
+ }
+ all(x, axes) {
+ return notYetImplemented('all');
+ }
+ any(x, axes) {
+ return notYetImplemented('any');
+ }
+ squaredDifference(a, b) {
+ return notYetImplemented('squaredDifference');
+ }
+ ceil(x) {
+ return notYetImplemented('ceil');
+ }
+ floor(x) {
+ return notYetImplemented('floor');
+ }
+ round(x) {
+ return notYetImplemented('round');
+ }
+ sign(x) {
+ return notYetImplemented('sign');
+ }
+ isNaN(x) {
+ return notYetImplemented('isNaN');
+ }
+ isInf(x) {
+ return notYetImplemented('isInf');
+ }
+ isFinite(x) {
+ return notYetImplemented('isFinite');
+ }
+ pow(a, b) {
+ return notYetImplemented('pow');
+ }
+ exp(x) {
+ return notYetImplemented('exp');
+ }
+ expm1(x) {
+ return notYetImplemented('expm1');
+ }
+ softmax(x, dim) {
+ return notYetImplemented('softmax');
+ }
+ log(x) {
+ return notYetImplemented('log');
+ }
+ log1p(x) {
+ return notYetImplemented('log1p');
+ }
+ sqrt(x) {
+ return notYetImplemented('sqrt');
+ }
+ rsqrt(x) {
+ return notYetImplemented('rsqrt');
+ }
+ square(x) {
+ return notYetImplemented('square');
+ }
+ reciprocal(x) {
+ return notYetImplemented('reciprocal');
+ }
+ relu(x) {
+ return notYetImplemented('relu');
+ }
+ relu6(x) {
+ return notYetImplemented('relu6');
+ }
+ prelu(x, a) {
+ return notYetImplemented('prelu');
+ }
+ elu(x) {
+ return notYetImplemented('elu');
+ }
+ eluDer(dy, y) {
+ return notYetImplemented('eluDer');
+ }
+ selu(x) {
+ return notYetImplemented('selu');
+ }
+ int(x) {
+ return notYetImplemented('int');
+ }
+ clip(x, min, max) {
+ return notYetImplemented('clip');
+ }
+ abs(x) {
+ return notYetImplemented('abs');
+ }
+ complexAbs(x) {
+ return notYetImplemented('complexAbs');
+ }
+ sigmoid(x) {
+ return notYetImplemented('sigmoid');
+ }
+ softplus(x) {
+ return notYetImplemented('softplus');
+ }
+ sin(x) {
+ return notYetImplemented('sin');
+ }
+ cos(x) {
+ return notYetImplemented('cos');
+ }
+ tan(x) {
+ return notYetImplemented('tan');
+ }
+ asin(x) {
+ return notYetImplemented('asin');
+ }
+ acos(x) {
+ return notYetImplemented('acos');
+ }
+ atan(x) {
+ return notYetImplemented('atan');
+ }
+ atan2(a, b) {
+ return notYetImplemented('atan2');
+ }
+ sinh(x) {
+ return notYetImplemented('sinh');
+ }
+ cosh(x) {
+ return notYetImplemented('cosh');
+ }
+ tanh(x) {
+ return notYetImplemented('tanh');
+ }
+ asinh(x) {
+ return notYetImplemented('asinh');
+ }
+ acosh(x) {
+ return notYetImplemented('acosh');
+ }
+ atanh(x) {
+ return notYetImplemented('atanh');
+ }
+ erf(x) {
+ return notYetImplemented('erf');
+ }
+ step(x, alpha) {
+ return notYetImplemented('step');
+ }
+ fusedConv2d({ input, filter, convInfo, bias, activation, preluActivationWeights }) {
+ return notYetImplemented('fusedConv2d');
+ }
+ conv2d(x, filter, convInfo) {
+ return notYetImplemented('conv2d');
+ }
+ conv2dDerInput(dy, filter, convInfo) {
+ return notYetImplemented('conv2dDerInput');
+ }
+ conv2dDerFilter(x, dY, convInfo) {
+ return notYetImplemented('conv2dDerFilter');
+ }
+ fusedDepthwiseConv2D({ input, filter, convInfo, bias, activation, preluActivationWeights }) {
+ return notYetImplemented('fusedDepthwiseConv2D');
+ }
+ depthwiseConv2D(input, filter, convInfo) {
+ return notYetImplemented('depthwiseConv2D');
+ }
+ depthwiseConv2DDerInput(dy, filter, convInfo) {
+ return notYetImplemented('depthwiseConv2DDerInput');
+ }
+ depthwiseConv2DDerFilter(x, dY, convInfo) {
+ return notYetImplemented('depthwiseConv2DDerFilter');
+ }
+ conv3d(x, filter, convInfo) {
+ return notYetImplemented('conv3d');
+ }
+ conv3dDerInput(dy, filter, convInfo) {
+ return notYetImplemented('conv3dDerInput');
+ }
+ conv3dDerFilter(x, dY, convInfo) {
+ return notYetImplemented('conv3dDerFilter');
+ }
+ maxPool(x, convInfo) {
+ return notYetImplemented('maxPool');
+ }
+ maxPoolBackprop(dy, x, y, convInfo) {
+ return notYetImplemented('maxPoolBackprop');
+ }
+ avgPool(x, convInfo) {
+ return notYetImplemented('avgPool');
+ }
+ avgPoolBackprop(dy, x, convInfo) {
+ return notYetImplemented('avgPoolBackprop');
+ }
+ avgPool3d(x, convInfo) {
+ return notYetImplemented('avgPool3d');
+ }
+ avgPool3dBackprop(dy, x, convInfo) {
+ return notYetImplemented('avgPool3dBackprop');
+ }
+ maxPool3d(x, convInfo) {
+ return notYetImplemented('maxPool3d');
+ }
+ maxPool3dBackprop(dy, x, y, convInfo) {
+ return notYetImplemented('maxPool3dBackprop');
+ }
+ reshape(x, shape) {
+ return notYetImplemented('reshape');
+ }
+ cast(x, dtype) {
+ return notYetImplemented('cast');
+ }
+ tile(x, reps) {
+ return notYetImplemented('tile');
+ }
+ pad(x, paddings, constantValue) {
+ return notYetImplemented('pad');
+ }
+ transpose(x, perm) {
+ return notYetImplemented('transpose');
+ }
+ gather(x, indices, axis) {
+ return notYetImplemented('gather');
+ }
+ gatherND(x, indices) {
+ return notYetImplemented('gatherND');
+ }
+ scatterND(indices, updates, shape) {
+ return notYetImplemented('scatterND');
+ }
+ batchToSpaceND(x, blockShape, crops) {
+ return notYetImplemented('batchToSpaceND');
+ }
+ spaceToBatchND(x, blockShape, paddings) {
+ return notYetImplemented('spaceToBatchND');
+ }
+ resizeBilinear(x, newHeight, newWidth, alignCorners) {
+ return notYetImplemented('resizeBilinear');
+ }
+ resizeBilinearBackprop(dy, x, alignCorners) {
+ return notYetImplemented('resizeBilinearBackprop');
+ }
+ resizeNearestNeighbor(x, newHEight, newWidth, alignCorners) {
+ return notYetImplemented('resizeNearestNeighbor');
+ }
+ resizeNearestNeighborBackprop(dy, x, alignCorners) {
+ return notYetImplemented('resizeNearestNeighborBackprop');
+ }
+ batchNorm(x, mean, variance, offset, scale, varianceEpsilon) {
+ return notYetImplemented('batchNorm');
+ }
+ localResponseNormalization4D(x, radius, bias, alpha, beta) {
+ return notYetImplemented('localResponseNormalization4D');
+ }
+ LRNGrad(dy, inputImage, outputImage, radius, bias, alpha, beta) {
+ return notYetImplemented('LRNGrad');
+ }
+ multinomial(logits, normalized, numSamples, seed) {
+ return notYetImplemented('multinomial');
+ }
+ oneHot(indices, depth, onValue, offValue) {
+ return notYetImplemented('oneHot');
+ }
+ cumsum(x, axis, exclusive, reverse) {
+ return notYetImplemented('cumsum');
+ }
+ nonMaxSuppression(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
+ return notYetImplemented('nonMaxSuppression');
+ }
+ fft(x) {
+ return notYetImplemented('fft');
+ }
+ ifft(x) {
+ return notYetImplemented('ifft');
+ }
+ complex(real, imag) {
+ return notYetImplemented('complex');
+ }
+ real(input) {
+ return notYetImplemented('real');
+ }
+ imag(input) {
+ return notYetImplemented('imag');
+ }
+ cropAndResize(image, boxes, boxIndex, cropSize, method, extrapolationValue) {
+ return notYetImplemented('cropAndResize');
+ }
+ depthToSpace(x, blockSize, dataFormat) {
+ return notYetImplemented('depthToSpace');
+ }
+ // Aligns with the "SplitV" kernel in TensorFlow.
+ split(value, sizeSplits, axis) {
+ return notYetImplemented('split');
+ }
+ sparseToDense(sparseIndices, sparseValues, outputShape, defaultValue) {
+ return notYetImplemented('sparseToDense');
+ }
+ diag(x) {
+ return notYetImplemented('diag');
+ }
+ fill(shape, value, dtype) {
+ return notYetImplemented('fill');
+ }
+ onesLike(x) {
+ return notYetImplemented('onesLike');
+ }
+ zerosLike(x) {
+ return notYetImplemented('zerosLike');
+ }
+ linspace(start, stop, num) {
+ return notYetImplemented('linspace');
+ }
+ dispose() {
+ return notYetImplemented('dispose');
+ }
+}
+function notYetImplemented(kernelName) {
+ throw new Error(`'${kernelName}' not yet implemented or not found in the registry. ` +
+ `Did you forget to import the kernel?`);
+}
+//# sourceMappingURL=backend.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/add.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.add = function (b) {
+ this.throwIfDisposed();
+ return add(this, b);
+};
+//# sourceMappingURL=add.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/atan2.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.atan2 = function (b) {
+ this.throwIfDisposed();
+ return atan2(this, b);
+};
+//# sourceMappingURL=atan2.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/avg_pool.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.avgPool = function (filterSize, strides, pad, dimRoundingMode) {
+ this.throwIfDisposed();
+ return avgPool(this, filterSize, strides, pad, dimRoundingMode);
+};
+//# sourceMappingURL=avg_pool.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/batchnorm.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.batchNorm = function (mean, variance, offset, scale, varianceEpsilon) {
+ this.throwIfDisposed();
+ return batchNorm(this, mean, variance, offset, scale, varianceEpsilon);
+};
+//# sourceMappingURL=batchnorm.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/broadcast_to.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.broadcastTo = function (shape) {
+ this.throwIfDisposed();
+ return broadcastTo(this, shape);
+};
+//# sourceMappingURL=broadcast_to.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/batch_to_space_nd.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.batchToSpaceND = function (blockShape, crops) {
+ this.throwIfDisposed();
+ return batchToSpaceND(this, blockShape, crops);
+};
+//# sourceMappingURL=batch_to_space_nd.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/concat.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.concat = function (x, axis) {
+ this.throwIfDisposed();
+ if (x instanceof dist_tensor["a" /* Tensor */]) {
+ x = [x];
+ }
+ return concat([this, ...x], axis);
+};
+//# sourceMappingURL=concat.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/conv1d.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.conv1d = function (filter, stride, pad, dataFormat, dilation, dimRoundingMode) {
+ this.throwIfDisposed();
+ return conv1d(this, filter, stride, pad, dataFormat, dilation, dimRoundingMode);
+};
+//# sourceMappingURL=conv1d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/conv2d.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.conv2d = function (filter, strides, pad, dataFormat, dilations, dimRoundingMode) {
+ this.throwIfDisposed();
+ return conv2d(this, filter, strides, pad, dataFormat, dilations, dimRoundingMode);
+};
+//# sourceMappingURL=conv2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/conv2d_transpose.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.conv2dTranspose = function (filter, outputShape, strides, pad, dimRoundingMode) {
+ this.throwIfDisposed();
+ return conv2dTranspose(this, filter, outputShape, strides, pad, dimRoundingMode);
+};
+//# sourceMappingURL=conv2d_transpose.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/cumsum.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.cumsum = function (axis, exclusive, reverse) {
+ this.throwIfDisposed();
+ return cumsum(this, axis, exclusive, reverse);
+};
+//# sourceMappingURL=cumsum.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/depth_to_space.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.depthToSpace = function (blockSize, dataFormat) {
+ this.throwIfDisposed();
+ return depthToSpace(this, blockSize, dataFormat);
+};
+//# sourceMappingURL=depth_to_space.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/depthwise_conv2d.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.depthwiseConv2d = function (filter, strides, pad, dataFormat, dilations, dimRoundingMode) {
+ this.throwIfDisposed();
+ return depthwiseConv2d(this, filter, strides, pad, dataFormat, dilations, dimRoundingMode);
+};
+//# sourceMappingURL=depthwise_conv2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/depthwise_conv2D_deprecated.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * @deprecated Use `depthwiseConv2d` instead.
+ */
+dist_tensor["a" /* Tensor */].prototype.depthwiseConv2D = function (filter, strides, pad, dataFormat, dilations, dimRoundingMode) {
+ deprecationWarn('depthwiseConv2D is deprecated, use depthwiseConv2d instead');
+ this.throwIfDisposed();
+ return depthwiseConv2d(this, filter, strides, pad, dataFormat, dilations, dimRoundingMode);
+};
+//# sourceMappingURL=depthwise_conv2D_deprecated.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/div.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.div = function (b) {
+ this.throwIfDisposed();
+ return div(this, b);
+};
+//# sourceMappingURL=div.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/div_no_nan.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.divNoNan = function (b) {
+ this.throwIfDisposed();
+ return divNoNan(this, b);
+};
+//# sourceMappingURL=div_no_nan.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/dot.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.dot = function (b) {
+ this.throwIfDisposed();
+ return dot(this, b);
+};
+//# sourceMappingURL=dot.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/elu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.elu = function () {
+ this.throwIfDisposed();
+ return elu(this);
+};
+//# sourceMappingURL=elu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/equal.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.equal = function (b) {
+ this.throwIfDisposed();
+ return equal(this, b);
+};
+//# sourceMappingURL=equal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/floorDiv.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.floorDiv = function (b) {
+ this.throwIfDisposed();
+ return floorDiv(this, b);
+};
+//# sourceMappingURL=floorDiv.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/greater.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.greater = function (b) {
+ this.throwIfDisposed();
+ return greater(this, b);
+};
+//# sourceMappingURL=greater.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/greater_equal.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.greaterEqual = function (b) {
+ this.throwIfDisposed();
+ return greaterEqual(this, b);
+};
+//# sourceMappingURL=greater_equal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/leaky_relu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.leakyRelu = function (alpha) {
+ this.throwIfDisposed();
+ return leakyRelu(this, alpha);
+};
+//# sourceMappingURL=leaky_relu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/less.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.less = function (b) {
+ this.throwIfDisposed();
+ return less(this, b);
+};
+//# sourceMappingURL=less.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/less_equal.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.lessEqual = function (b) {
+ this.throwIfDisposed();
+ return lessEqual(this, b);
+};
+//# sourceMappingURL=less_equal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/local_response_normalization.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.localResponseNormalization = function (depthRadius, bias, alpha, beta) {
+ this.throwIfDisposed();
+ return localResponseNormalization(this, depthRadius, bias, alpha, beta);
+};
+//# sourceMappingURL=local_response_normalization.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/mat_mul.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.matMul = function (b, transposeA, transposeB) {
+ this.throwIfDisposed();
+ return matMul(this, b, transposeA, transposeB);
+};
+//# sourceMappingURL=mat_mul.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/max.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.max = function (axis, keepDims) {
+ this.throwIfDisposed();
+ return max_max(this, axis, keepDims);
+};
+//# sourceMappingURL=max.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/max_pool.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.maxPool = function (filterSize, strides, pad, dimRoundingMode) {
+ this.throwIfDisposed();
+ return maxPool(this, filterSize, strides, pad, dimRoundingMode);
+};
+//# sourceMappingURL=max_pool.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/maximum.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.maximum = function (b) {
+ this.throwIfDisposed();
+ return maximum(this, b);
+};
+//# sourceMappingURL=maximum.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/minimum.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.minimum = function (b) {
+ this.throwIfDisposed();
+ return minimum(this, b);
+};
+//# sourceMappingURL=minimum.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/mod.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.mod = function (b) {
+ this.throwIfDisposed();
+ return mod(this, b);
+};
+//# sourceMappingURL=mod.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/mul.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.mul = function (b) {
+ this.throwIfDisposed();
+ return mul(this, b);
+};
+//# sourceMappingURL=mul.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/not_equal.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.notEqual = function (b) {
+ this.throwIfDisposed();
+ return notEqual(this, b);
+};
+//# sourceMappingURL=not_equal.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/one_hot.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.oneHot = function (depth, onValue = 1, offValue = 0) {
+ this.throwIfDisposed();
+ return oneHot(this, depth, onValue, offValue);
+};
+//# sourceMappingURL=one_hot.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/pad.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.pad = function (paddings, constantValue) {
+ this.throwIfDisposed();
+ return pad_pad(this, paddings, constantValue);
+};
+//# sourceMappingURL=pad.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/pool.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.pool = function (windowShape, poolingType, padding, dilationRate, strides) {
+ this.throwIfDisposed();
+ return pool(this, windowShape, poolingType, padding, dilationRate, strides);
+};
+//# sourceMappingURL=pool.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/pow.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.pow = function (exp) {
+ this.throwIfDisposed();
+ return pow(this, exp);
+};
+//# sourceMappingURL=pow.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/prelu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.prelu = function (alpha) {
+ this.throwIfDisposed();
+ return prelu(this, alpha);
+};
+//# sourceMappingURL=prelu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/relu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.relu = function () {
+ this.throwIfDisposed();
+ return relu(this);
+};
+//# sourceMappingURL=relu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/relu6.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.relu6 = function () {
+ this.throwIfDisposed();
+ return relu6(this);
+};
+//# sourceMappingURL=relu6.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/selu.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.selu = function () {
+ this.throwIfDisposed();
+ return selu(this);
+};
+//# sourceMappingURL=selu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/separable_conv2d.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.separableConv2d = function (depthwiseFilter, pointwiseFilter, strides, pad, dilation, dataFormat) {
+ this.throwIfDisposed();
+ return separableConv2d(this, depthwiseFilter, pointwiseFilter, strides, pad, dilation, dataFormat);
+};
+//# sourceMappingURL=separable_conv2d.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/split.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.split = function (numOrSizeSplits, axis) {
+ this.throwIfDisposed();
+ return split(this, numOrSizeSplits, axis);
+};
+//# sourceMappingURL=split.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/squared_difference.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.squaredDifference = function (b) {
+ this.throwIfDisposed();
+ return squaredDifference(this, b);
+};
+//# sourceMappingURL=squared_difference.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/space_to_batch_nd.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.spaceToBatchND = function (blockShape, paddings) {
+ this.throwIfDisposed();
+ return spaceToBatchND(this, blockShape, paddings);
+};
+//# sourceMappingURL=space_to_batch_nd.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/sub.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.sub = function (b) {
+ this.throwIfDisposed();
+ return sub(this, b);
+};
+//# sourceMappingURL=sub.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/tile.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.tile = function (reps) {
+ this.throwIfDisposed();
+ return tile(this, reps);
+};
+//# sourceMappingURL=tile.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/transpose.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+dist_tensor["a" /* Tensor */].prototype.transpose = function (perm) {
+ this.throwIfDisposed();
+ return transpose(this, perm);
+};
+//# sourceMappingURL=transpose.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/public/chained_ops/register_all_chained_ops.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=register_all_chained_ops.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/index.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * @fileoverview
+ * @suppress {partialAlias} Optimization disabled due to passing the module
+ * object into a function below:
+ *
+ * import * as ops from './ops/ops';
+ * setOpHandler(ops);
+ */
+// Engine is the global singleton that needs to be initialized before the rest
+// of the app.
+
+// Register backend-agnostic flags.
+
+// Register all the gradients.
+
+
+
+// Serialization.
+
+
+
+
+
+
+
+
+
+
+
+
+// Optimizers.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Top-level method exports.
+
+// Second level exports.
+
+
+
+
+
+// Backend specific.
+
+
+Object(dist_tensor["e" /* setOpHandler */])(ops_namespaceObject);
+// Export all kernel names / info.
+
+// Import all op chainers and add type info to Tensor.
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+/* 1 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "shuffle", function() { return shuffle; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clamp", function() { return clamp; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "nearestLargerEven", function() { return nearestLargerEven; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sum", function() { return sum; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "randUniform", function() { return randUniform; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "distSquared", function() { return distSquared; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assert", function() { return assert; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assertShapesMatch", function() { return assertShapesMatch; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assertNonNull", function() { return assertNonNull; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "flatten", function() { return flatten; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sizeFromShape", function() { return sizeFromShape; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isScalarShape", function() { return isScalarShape; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "arraysEqual", function() { return arraysEqual; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isInt", function() { return isInt; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tanh", function() { return tanh; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sizeToSquarishShape", function() { return sizeToSquarishShape; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createShuffledIndices", function() { return createShuffledIndices; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rightPad", function() { return rightPad; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "repeatedTry", function() { return repeatedTry; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "inferFromImplicitShape", function() { return inferFromImplicitShape; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseAxisParam", function() { return parseAxisParam; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squeezeShape", function() { return squeezeShape; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getTypedArrayFromDType", function() { return getTypedArrayFromDType; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getArrayFromDType", function() { return getArrayFromDType; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "checkConversionForErrors", function() { return checkConversionForErrors; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isValidDtype", function() { return isValidDtype; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hasEncodingLoss", function() { return hasEncodingLoss; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isTypedArray", function() { return isTypedArray; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bytesPerElement", function() { return bytesPerElement; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bytesFromStringArray", function() { return bytesFromStringArray; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isString", function() { return isString; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isBoolean", function() { return isBoolean; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isNumber", function() { return isNumber; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "inferDtype", function() { return inferDtype; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isFunction", function() { return isFunction; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "nearestDivisor", function() { return nearestDivisor; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computeStrides", function() { return computeStrides; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toTypedArray", function() { return toTypedArray; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toNestedArray", function() { return toNestedArray; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "makeOnesTypedArray", function() { return makeOnesTypedArray; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "makeZerosTypedArray", function() { return makeZerosTypedArray; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "now", function() { return now; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assertNonNegativeIntegerDimensions", function() { return assertNonNegativeIntegerDimensions; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fetch", function() { return fetch; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "encodeString", function() { return encodeString; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "decodeString", function() { return decodeString; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "locToIndex", function() { return locToIndex; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "indexToLoc", function() { return indexToLoc; });
+/* harmony import */ var _environment__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+/**
+ * Shuffles the array in-place using Fisher-Yates algorithm.
+ *
+ * ```js
+ * const a = [1, 2, 3, 4, 5];
+ * tf.util.shuffle(a);
+ * console.log(a);
+ * ```
+ *
+ * @param array The array to shuffle in-place.
+ */
+/** @doc {heading: 'Util', namespace: 'util'} */
+// tslint:disable-next-line:no-any
+function shuffle(array) {
+ let counter = array.length;
+ let temp = 0;
+ let index = 0;
+ // While there are elements in the array
+ while (counter > 0) {
+ // Pick a random index
+ index = (Math.random() * counter) | 0;
+ // Decrease counter by 1
+ counter--;
+ // And swap the last element with it
+ temp = array[counter];
+ array[counter] = array[index];
+ array[index] = temp;
+ }
+}
+/** Clamps a value to a specified range. */
+function clamp(min, x, max) {
+ return Math.max(min, Math.min(x, max));
+}
+function nearestLargerEven(val) {
+ return val % 2 === 0 ? val : val + 1;
+}
+function sum(arr) {
+ let sum = 0;
+ for (let i = 0; i < arr.length; i++) {
+ sum += arr[i];
+ }
+ return sum;
+}
+/**
+ * Returns a sample from a uniform [a, b) distribution.
+ *
+ * @param a The minimum support (inclusive).
+ * @param b The maximum support (exclusive).
+ * @return A pseudorandom number on the half-open interval [a,b).
+ */
+function randUniform(a, b) {
+ const r = Math.random();
+ return (b * r) + (1 - r) * a;
+}
+/** Returns the squared Euclidean distance between two vectors. */
+function distSquared(a, b) {
+ let result = 0;
+ for (let i = 0; i < a.length; i++) {
+ const diff = Number(a[i]) - Number(b[i]);
+ result += diff * diff;
+ }
+ return result;
+}
+/**
+ * Asserts that the expression is true. Otherwise throws an error with the
+ * provided message.
+ *
+ * ```js
+ * const x = 2;
+ * tf.util.assert(x === 2, 'x is not 2');
+ * ```
+ *
+ * @param expr The expression to assert (as a boolean).
+ * @param msg A function that returns the message to report when throwing an
+ * error. We use a function for performance reasons.
+ */
+/** @doc {heading: 'Util', namespace: 'util'} */
+function assert(expr, msg) {
+ if (!expr) {
+ throw new Error(typeof msg === 'string' ? msg : msg());
+ }
+}
+function assertShapesMatch(shapeA, shapeB, errorMessagePrefix = '') {
+ assert(arraysEqual(shapeA, shapeB), () => errorMessagePrefix + ` Shapes ${shapeA} and ${shapeB} must match`);
+}
+function assertNonNull(a) {
+ assert(a != null, () => `The input to the tensor constructor must be a non-null value.`);
+}
+// NOTE: We explicitly type out what T extends instead of any so that
+// util.flatten on a nested array of number doesn't try to infer T as a
+// number[][], causing us to explicitly type util.flatten().
+/**
+ * Flattens an arbitrarily nested array.
+ *
+ * ```js
+ * const a = [[1, 2], [3, 4], [5, [6, [7]]]];
+ * const flat = tf.util.flatten(a);
+ * console.log(flat);
+ * ```
+ *
+ * @param arr The nested array to flatten.
+ * @param result The destination array which holds the elements.
+ * @param skipTypedArray If true, avoids flattening the typed arrays. Defaults
+ * to false.
+ */
+/** @doc {heading: 'Util', namespace: 'util'} */
+function flatten(arr, result = [], skipTypedArray = false) {
+ if (result == null) {
+ result = [];
+ }
+ if (Array.isArray(arr) || isTypedArray(arr) && !skipTypedArray) {
+ for (let i = 0; i < arr.length; ++i) {
+ flatten(arr[i], result, skipTypedArray);
+ }
+ }
+ else {
+ result.push(arr);
+ }
+ return result;
+}
+/**
+ * Returns the size (number of elements) of the tensor given its shape.
+ *
+ * ```js
+ * const shape = [3, 4, 2];
+ * const size = tf.util.sizeFromShape(shape);
+ * console.log(size);
+ * ```
+ */
+/** @doc {heading: 'Util', namespace: 'util'} */
+function sizeFromShape(shape) {
+ if (shape.length === 0) {
+ // Scalar.
+ return 1;
+ }
+ let size = shape[0];
+ for (let i = 1; i < shape.length; i++) {
+ size *= shape[i];
+ }
+ return size;
+}
+function isScalarShape(shape) {
+ return shape.length === 0;
+}
+function arraysEqual(n1, n2) {
+ if (n1 === n2) {
+ return true;
+ }
+ if (n1 == null || n2 == null) {
+ return false;
+ }
+ if (n1.length !== n2.length) {
+ return false;
+ }
+ for (let i = 0; i < n1.length; i++) {
+ if (n1[i] !== n2[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+function isInt(a) {
+ return a % 1 === 0;
+}
+function tanh(x) {
+ // tslint:disable-next-line:no-any
+ if (Math.tanh != null) {
+ // tslint:disable-next-line:no-any
+ return Math.tanh(x);
+ }
+ if (x === Infinity) {
+ return 1;
+ }
+ else if (x === -Infinity) {
+ return -1;
+ }
+ else {
+ const e2x = Math.exp(2 * x);
+ return (e2x - 1) / (e2x + 1);
+ }
+}
+function sizeToSquarishShape(size) {
+ const width = Math.ceil(Math.sqrt(size));
+ return [width, Math.ceil(size / width)];
+}
+/**
+ * Creates a new array with randomized indicies to a given quantity.
+ *
+ * ```js
+ * const randomTen = tf.util.createShuffledIndices(10);
+ * console.log(randomTen);
+ * ```
+ *
+ * @param number Quantity of how many shuffled indicies to create.
+ */
+/** @doc {heading: 'Util', namespace: 'util'} */
+function createShuffledIndices(n) {
+ const shuffledIndices = new Uint32Array(n);
+ for (let i = 0; i < n; ++i) {
+ shuffledIndices[i] = i;
+ }
+ shuffle(shuffledIndices);
+ return shuffledIndices;
+}
+function rightPad(a, size) {
+ if (size <= a.length) {
+ return a;
+ }
+ return a + ' '.repeat(size - a.length);
+}
+function repeatedTry(checkFn, delayFn = (counter) => 0, maxCounter) {
+ return new Promise((resolve, reject) => {
+ let tryCount = 0;
+ const tryFn = () => {
+ if (checkFn()) {
+ resolve();
+ return;
+ }
+ tryCount++;
+ const nextBackoff = delayFn(tryCount);
+ if (maxCounter != null && tryCount >= maxCounter) {
+ reject();
+ return;
+ }
+ setTimeout(tryFn, nextBackoff);
+ };
+ tryFn();
+ });
+}
+/**
+ * Given the full size of the array and a shape that may contain -1 as the
+ * implicit dimension, returns the inferred shape where -1 is replaced.
+ * E.g. For shape=[2, -1, 3] and size=24, it will return [2, 4, 3].
+ *
+ * @param shape The shape, which may contain -1 in some dimension.
+ * @param size The full size (number of elements) of the array.
+ * @return The inferred shape where -1 is replaced with the inferred size.
+ */
+function inferFromImplicitShape(shape, size) {
+ let shapeProd = 1;
+ let implicitIdx = -1;
+ for (let i = 0; i < shape.length; ++i) {
+ if (shape[i] >= 0) {
+ shapeProd *= shape[i];
+ }
+ else if (shape[i] === -1) {
+ if (implicitIdx !== -1) {
+ throw Error(`Shapes can only have 1 implicit size. ` +
+ `Found -1 at dim ${implicitIdx} and dim ${i}`);
+ }
+ implicitIdx = i;
+ }
+ else if (shape[i] < 0) {
+ throw Error(`Shapes can not be < 0. Found ${shape[i]} at dim ${i}`);
+ }
+ }
+ if (implicitIdx === -1) {
+ if (size > 0 && size !== shapeProd) {
+ throw Error(`Size(${size}) must match the product of shape ${shape}`);
+ }
+ return shape;
+ }
+ if (shapeProd === 0) {
+ throw Error(`Cannot infer the missing size in [${shape}] when ` +
+ `there are 0 elements`);
+ }
+ if (size % shapeProd !== 0) {
+ throw Error(`The implicit shape can't be a fractional number. ` +
+ `Got ${size} / ${shapeProd}`);
+ }
+ const newShape = shape.slice();
+ newShape[implicitIdx] = size / shapeProd;
+ return newShape;
+}
+function parseAxisParam(axis, shape) {
+ const rank = shape.length;
+ // Normalize input
+ axis = axis == null ? shape.map((s, i) => i) : [].concat(axis);
+ // Check for valid range
+ assert(axis.every(ax => ax >= -rank && ax < rank), () => `All values in axis param must be in range [-${rank}, ${rank}) but ` +
+ `got axis ${axis}`);
+ // Check for only integers
+ assert(axis.every(ax => isInt(ax)), () => `All values in axis param must be integers but ` +
+ `got axis ${axis}`);
+ // Handle negative axis.
+ return axis.map(a => a < 0 ? rank + a : a);
+}
+/** Reduces the shape by removing all dimensions of shape 1. */
+function squeezeShape(shape, axis) {
+ const newShape = [];
+ const keptDims = [];
+ const isEmptyArray = axis != null && Array.isArray(axis) && axis.length === 0;
+ const axes = (axis == null || isEmptyArray) ?
+ null :
+ parseAxisParam(axis, shape).sort();
+ let j = 0;
+ for (let i = 0; i < shape.length; ++i) {
+ if (axes != null) {
+ if (axes[j] === i && shape[i] !== 1) {
+ throw new Error(`Can't squeeze axis ${i} since its dim '${shape[i]}' is not 1`);
+ }
+ if ((axes[j] == null || axes[j] > i) && shape[i] === 1) {
+ newShape.push(shape[i]);
+ keptDims.push(i);
+ }
+ if (axes[j] <= i) {
+ j++;
+ }
+ }
+ if (shape[i] !== 1) {
+ newShape.push(shape[i]);
+ keptDims.push(i);
+ }
+ }
+ return { newShape, keptDims };
+}
+function getTypedArrayFromDType(dtype, size) {
+ let values = null;
+ if (dtype == null || dtype === 'float32') {
+ values = new Float32Array(size);
+ }
+ else if (dtype === 'int32') {
+ values = new Int32Array(size);
+ }
+ else if (dtype === 'bool') {
+ values = new Uint8Array(size);
+ }
+ else {
+ throw new Error(`Unknown data type ${dtype}`);
+ }
+ return values;
+}
+function getArrayFromDType(dtype, size) {
+ let values = null;
+ if (dtype == null || dtype === 'float32') {
+ values = new Float32Array(size);
+ }
+ else if (dtype === 'int32') {
+ values = new Int32Array(size);
+ }
+ else if (dtype === 'bool') {
+ values = new Uint8Array(size);
+ }
+ else if (dtype === 'string') {
+ values = new Array(size);
+ }
+ else {
+ throw new Error(`Unknown data type ${dtype}`);
+ }
+ return values;
+}
+function checkConversionForErrors(vals, dtype) {
+ for (let i = 0; i < vals.length; i++) {
+ const num = vals[i];
+ if (isNaN(num) || !isFinite(num)) {
+ throw Error(`A tensor of type ${dtype} being uploaded contains ${num}.`);
+ }
+ }
+}
+/** Returns true if the dtype is valid. */
+function isValidDtype(dtype) {
+ return dtype === 'bool' || dtype === 'complex64' || dtype === 'float32' ||
+ dtype === 'int32' || dtype === 'string';
+}
+/**
+ * Returns true if the new type can't encode the old type without loss of
+ * precision.
+ */
+function hasEncodingLoss(oldType, newType) {
+ if (newType === 'complex64') {
+ return false;
+ }
+ if (newType === 'float32' && oldType !== 'complex64') {
+ return false;
+ }
+ if (newType === 'int32' && oldType !== 'float32' && oldType !== 'complex64') {
+ return false;
+ }
+ if (newType === 'bool' && oldType === 'bool') {
+ return false;
+ }
+ return true;
+}
+function isTypedArray(a) {
+ return a instanceof Float32Array || a instanceof Int32Array ||
+ a instanceof Uint8Array;
+}
+function bytesPerElement(dtype) {
+ if (dtype === 'float32' || dtype === 'int32') {
+ return 4;
+ }
+ else if (dtype === 'complex64') {
+ return 8;
+ }
+ else if (dtype === 'bool') {
+ return 1;
+ }
+ else {
+ throw new Error(`Unknown dtype ${dtype}`);
+ }
+}
+/**
+ * Returns the approximate number of bytes allocated in the string array - 2
+ * bytes per character. Computing the exact bytes for a native string in JS is
+ * not possible since it depends on the encoding of the html page that serves
+ * the website.
+ */
+function bytesFromStringArray(arr) {
+ if (arr == null) {
+ return 0;
+ }
+ let bytes = 0;
+ arr.forEach(x => bytes += x.length);
+ return bytes;
+}
+/** Returns true if the value is a string. */
+function isString(value) {
+ return typeof value === 'string' || value instanceof String;
+}
+function isBoolean(value) {
+ return typeof value === 'boolean';
+}
+function isNumber(value) {
+ return typeof value === 'number';
+}
+function inferDtype(values) {
+ if (Array.isArray(values)) {
+ return inferDtype(values[0]);
+ }
+ if (values instanceof Float32Array) {
+ return 'float32';
+ }
+ else if (values instanceof Int32Array || values instanceof Uint8Array) {
+ return 'int32';
+ }
+ else if (isNumber(values)) {
+ return 'float32';
+ }
+ else if (isString(values)) {
+ return 'string';
+ }
+ else if (isBoolean(values)) {
+ return 'bool';
+ }
+ return 'float32';
+}
+function isFunction(f) {
+ return !!(f && f.constructor && f.call && f.apply);
+}
+function nearestDivisor(size, start) {
+ for (let i = start; i < size; ++i) {
+ if (size % i === 0) {
+ return i;
+ }
+ }
+ return size;
+}
+function computeStrides(shape) {
+ const rank = shape.length;
+ if (rank < 2) {
+ return [];
+ }
+ // Last dimension has implicit stride of 1, thus having D-1 (instead of D)
+ // strides.
+ const strides = new Array(rank - 1);
+ strides[rank - 2] = shape[rank - 1];
+ for (let i = rank - 3; i >= 0; --i) {
+ strides[i] = strides[i + 1] * shape[i + 1];
+ }
+ return strides;
+}
+function toTypedArray(a, dtype, debugMode) {
+ if (dtype === 'string') {
+ throw new Error('Cannot convert a string[] to a TypedArray');
+ }
+ if (Array.isArray(a)) {
+ a = flatten(a);
+ }
+ if (debugMode) {
+ checkConversionForErrors(a, dtype);
+ }
+ if (noConversionNeeded(a, dtype)) {
+ return a;
+ }
+ if (dtype == null || dtype === 'float32' || dtype === 'complex64') {
+ return new Float32Array(a);
+ }
+ else if (dtype === 'int32') {
+ return new Int32Array(a);
+ }
+ else if (dtype === 'bool') {
+ const bool = new Uint8Array(a.length);
+ for (let i = 0; i < bool.length; ++i) {
+ if (Math.round(a[i]) !== 0) {
+ bool[i] = 1;
+ }
+ }
+ return bool;
+ }
+ else {
+ throw new Error(`Unknown data type ${dtype}`);
+ }
+}
+function createNestedArray(offset, shape, a) {
+ const ret = new Array();
+ if (shape.length === 1) {
+ const d = shape[0];
+ for (let i = 0; i < d; i++) {
+ ret[i] = a[offset + i];
+ }
+ }
+ else {
+ const d = shape[0];
+ const rest = shape.slice(1);
+ const len = rest.reduce((acc, c) => acc * c);
+ for (let i = 0; i < d; i++) {
+ ret[i] = createNestedArray(offset + i * len, rest, a);
+ }
+ }
+ return ret;
+}
+// Provide a nested array of TypedArray in given shape.
+function toNestedArray(shape, a) {
+ if (shape.length === 0) {
+ // Scalar type should return a single number.
+ return a[0];
+ }
+ const size = shape.reduce((acc, c) => acc * c);
+ if (size === 0) {
+ // A tensor with shape zero should be turned into empty list.
+ return [];
+ }
+ if (size !== a.length) {
+ throw new Error(`[${shape}] does not match the input size.`);
+ }
+ return createNestedArray(0, shape, a);
+}
+function noConversionNeeded(a, dtype) {
+ return (a instanceof Float32Array && dtype === 'float32') ||
+ (a instanceof Int32Array && dtype === 'int32') ||
+ (a instanceof Uint8Array && dtype === 'bool');
+}
+function makeOnesTypedArray(size, dtype) {
+ const array = makeZerosTypedArray(size, dtype);
+ for (let i = 0; i < array.length; i++) {
+ array[i] = 1;
+ }
+ return array;
+}
+function makeZerosTypedArray(size, dtype) {
+ if (dtype == null || dtype === 'float32' || dtype === 'complex64') {
+ return new Float32Array(size);
+ }
+ else if (dtype === 'int32') {
+ return new Int32Array(size);
+ }
+ else if (dtype === 'bool') {
+ return new Uint8Array(size);
+ }
+ else {
+ throw new Error(`Unknown data type ${dtype}`);
+ }
+}
+/**
+ * Returns the current high-resolution time in milliseconds relative to an
+ * arbitrary time in the past. It works across different platforms (node.js,
+ * browsers).
+ *
+ * ```js
+ * console.log(tf.util.now());
+ * ```
+ */
+/** @doc {heading: 'Util', namespace: 'util'} */
+function now() {
+ return Object(_environment__WEBPACK_IMPORTED_MODULE_0__[/* env */ "c"])().platform.now();
+}
+function assertNonNegativeIntegerDimensions(shape) {
+ shape.forEach(dimSize => {
+ assert(Number.isInteger(dimSize) && dimSize >= 0, () => `Tensor must have a shape comprised of positive integers but got ` +
+ `shape [${shape}].`);
+ });
+}
+/**
+ * Returns a platform-specific implementation of
+ * [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).
+ *
+ * If `fetch` is defined on the global object (`window`, `process`, etc.),
+ * `tf.util.fetch` returns that function.
+ *
+ * If not, `tf.util.fetch` returns a platform-specific solution.
+ *
+ * ```js
+ * const resource = await tf.util.fetch('https://unpkg.com/@tensorflow/tfjs');
+ * // handle response
+ * ```
+ */
+/** @doc {heading: 'Util'} */
+function fetch(path, requestInits) {
+ return Object(_environment__WEBPACK_IMPORTED_MODULE_0__[/* env */ "c"])().platform.fetch(path, requestInits);
+}
+/**
+ * Encodes the provided string into bytes using the provided encoding scheme.
+ *
+ * @param s The string to encode.
+ * @param encoding The encoding scheme. Defaults to utf-8.
+ *
+ */
+/** @doc {heading: 'Util'} */
+function encodeString(s, encoding = 'utf-8') {
+ encoding = encoding || 'utf-8';
+ return Object(_environment__WEBPACK_IMPORTED_MODULE_0__[/* env */ "c"])().platform.encode(s, encoding);
+}
+/**
+ * Decodes the provided bytes into a string using the provided encoding scheme.
+ * @param bytes The bytes to decode.
+ *
+ * @param encoding The encoding scheme. Defaults to utf-8.
+ */
+/** @doc {heading: 'Util'} */
+function decodeString(bytes, encoding = 'utf-8') {
+ encoding = encoding || 'utf-8';
+ return Object(_environment__WEBPACK_IMPORTED_MODULE_0__[/* env */ "c"])().platform.decode(bytes, encoding);
+}
+/**
+ * Computes flat index for a given location (multidimentionsal index) in a
+ * Tensor/multidimensional array.
+ *
+ * @param locs Location in the tensor.
+ * @param rank Rank of the tensor.
+ * @param strides Tensor strides.
+ */
+function locToIndex(locs, rank, strides) {
+ if (rank === 0) {
+ return 0;
+ }
+ else if (rank === 1) {
+ return locs[0];
+ }
+ let index = locs[locs.length - 1];
+ for (let i = 0; i < locs.length - 1; ++i) {
+ index += strides[i] * locs[i];
+ }
+ return index;
+}
+/**
+ * Computes the location (multidimensional index) in a tensor/multidimentional
+ * array for a given flat index.
+ *
+ * @param index Index in flat array.
+ * @param rank Rank of tensor.
+ * @param strides Strides of tensor.
+ */
+function indexToLoc(index, rank, strides) {
+ if (rank === 0) {
+ return [];
+ }
+ else if (rank === 1) {
+ return [index];
+ }
+ const locs = new Array(rank);
+ for (let i = 0; i < locs.length - 1; ++i) {
+ locs[i] = Math.floor(index / strides[i]);
+ index -= locs[i] * strides[i];
+ }
+ locs[locs.length - 1] = index;
+ return locs;
+}
+//# sourceMappingURL=util.js.map
+
+/***/ }),
+/* 2 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getParamValue; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return getTensor; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return getTensorsForCurrentContenxt; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getNodeNameAndIndex; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return parseNodeName; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return split; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function getParamValue(paramName, node, tensorMap, context) {
+ const inputParam = node.inputParams[paramName];
+ if (inputParam && inputParam.inputIndexStart !== undefined) {
+ const start = inputParam.inputIndexStart;
+ const end = inputParam.inputIndexEnd === 0 ?
+ undefined :
+ (inputParam.inputIndexEnd === undefined ? start + 1 :
+ inputParam.inputIndexEnd);
+ if (inputParam.type === 'tensor') {
+ return getTensor(node.inputNames[inputParam.inputIndexStart], tensorMap, context);
+ }
+ if (inputParam.type === 'tensors') {
+ const inputs = node.inputNames.slice(start, end);
+ return inputs.map(name => getTensor(name, tensorMap, context));
+ }
+ const data = Array.prototype.slice.call(getTensor(node.inputNames.slice(start)[0], tensorMap, context)
+ .dataSync());
+ return inputParam.type === 'number' ? data[0] : data;
+ }
+ const attrParam = node.attrParams[paramName];
+ return attrParam && attrParam.value;
+}
+/**
+ * Retrieve the tensor based on input name by extracting the node name and
+ * output index information.
+ * @param name Node input name
+ * @param tensorsMap Tensors map keyed by the node
+ */
+function getTensor(name, tensorsMap, context) {
+ const [nodeName, index] = parseNodeName(name);
+ const contextId = context.currentContextIds.find(contextId => {
+ return !!tensorsMap[getNodeNameWithContextId(nodeName, contextId)];
+ });
+ return contextId !== undefined ?
+ tensorsMap[getNodeNameWithContextId(nodeName, contextId)][index] :
+ undefined;
+}
+/**
+ * Retrieve the tensors based on input name for current context.
+ * @param name Node input name
+ * @param tensorsMap Tensors map keyed by the node
+ */
+function getTensorsForCurrentContenxt(name, tensorsMap, context) {
+ return tensorsMap[getNodeNameWithContextId(name, context.currentContextId)];
+}
+/**
+ * Returns the node name and index from the Node input name.
+ * @param inputName The input name of the node, in format of
+ * node_name:output_index, i.e. MatMul:0, if the output_index is not set, it is
+ * default to 0.
+ */
+function getNodeNameAndIndex(inputName, context) {
+ const [nodeName, index] = parseNodeName(inputName);
+ return [
+ getNodeNameWithContextId(nodeName, context && context.currentContextId),
+ index
+ ];
+}
+function getNodeNameWithContextId(name, contextId) {
+ return !!contextId ? `${name}-${contextId}` : name;
+}
+function parseNodeName(name) {
+ const parts = name.split(':');
+ if (parts.length === 1) {
+ return [name, 0];
+ }
+ const nodeName = parts[0];
+ return [nodeName, Number(parts[parts.length - 1])];
+}
+function split(arr, size) {
+ const res = [];
+ for (let i = 0; i < arr.length; i += size) {
+ res.push(arr.slice(i, i + size));
+ }
+ return res;
+}
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+/* 3 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return inferShape; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return convertToTensor; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return convertToTensorArray; });
+/* harmony import */ var _engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
+/* harmony import */ var _environment__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
+/* harmony import */ var _tensor__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1);
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+function inferShape(val, dtype) {
+ let firstElem = val;
+ if (Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(val)) {
+ return dtype === 'string' ? [] : [val.length];
+ }
+ if (!Array.isArray(val)) {
+ return []; // Scalar.
+ }
+ const shape = [];
+ while (Array.isArray(firstElem) ||
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(firstElem) && dtype !== 'string') {
+ shape.push(firstElem.length);
+ firstElem = firstElem[0];
+ }
+ if (Array.isArray(val) &&
+ Object(_environment__WEBPACK_IMPORTED_MODULE_1__[/* env */ "c"])().getBool('TENSORLIKE_CHECK_SHAPE_CONSISTENCY')) {
+ deepAssertShapeConsistency(val, shape, []);
+ }
+ return shape;
+}
+function deepAssertShapeConsistency(val, shape, indices) {
+ indices = indices || [];
+ if (!(Array.isArray(val)) && !Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(val)) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assert"])(shape.length === 0, () => `Element arr[${indices.join('][')}] is a primitive, ` +
+ `but should be an array/TypedArray of ${shape[0]} elements`);
+ return;
+ }
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assert"])(shape.length > 0, () => `Element arr[${indices.join('][')}] should be a primitive, ` +
+ `but is an array of ${val.length} elements`);
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assert"])(val.length === shape[0], () => `Element arr[${indices.join('][')}] should have ${shape[0]} ` +
+ `elements, but has ${val.length} elements`);
+ const subShape = shape.slice(1);
+ for (let i = 0; i < val.length; ++i) {
+ deepAssertShapeConsistency(val[i], subShape, indices.concat(i));
+ }
+}
+function assertDtype(expectedDtype, actualDType, argName, functionName) {
+ if (expectedDtype == null) {
+ return;
+ }
+ if (expectedDtype !== 'numeric' && expectedDtype !== actualDType ||
+ expectedDtype === 'numeric' && actualDType === 'string') {
+ throw new Error(`Argument '${argName}' passed to '${functionName}' must ` +
+ `be ${expectedDtype} tensor, but got ${actualDType} tensor`);
+ }
+}
+function convertToTensor(x, argName, functionName, parseAsDtype = 'numeric') {
+ if (x instanceof _tensor__WEBPACK_IMPORTED_MODULE_2__[/* Tensor */ "a"]) {
+ assertDtype(parseAsDtype, x.dtype, argName, functionName);
+ return x;
+ }
+ let inferredDtype = Object(_util__WEBPACK_IMPORTED_MODULE_3__["inferDtype"])(x);
+ // If the user expects a bool/int/float, use that info to update the
+ // inferredDtype when it is not a string.
+ if (inferredDtype !== 'string' &&
+ ['bool', 'int32', 'float32'].indexOf(parseAsDtype) >= 0) {
+ inferredDtype = parseAsDtype;
+ }
+ assertDtype(parseAsDtype, inferredDtype, argName, functionName);
+ if ((x == null) ||
+ (!Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(x) && !Array.isArray(x) && typeof x !== 'number' &&
+ typeof x !== 'boolean' && typeof x !== 'string')) {
+ const type = x == null ? 'null' : x.constructor.name;
+ throw new Error(`Argument '${argName}' passed to '${functionName}' must be a ` +
+ `Tensor or TensorLike, but got '${type}'`);
+ }
+ const inferredShape = inferShape(x, inferredDtype);
+ if (!Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(x) && !Array.isArray(x)) {
+ x = [x];
+ }
+ const skipTypedArray = true;
+ const values = inferredDtype !== 'string' ?
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["toTypedArray"])(x, inferredDtype, Object(_environment__WEBPACK_IMPORTED_MODULE_1__[/* env */ "c"])().getBool('DEBUG')) :
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["flatten"])(x, [], skipTypedArray);
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].makeTensor(values, inferredShape, inferredDtype);
+}
+function convertToTensorArray(arg, argName, functionName, parseAsDtype = 'numeric') {
+ if (!Array.isArray(arg)) {
+ throw new Error(`Argument ${argName} passed to ${functionName} must be a ` +
+ '`Tensor[]` or `TensorLike[]`');
+ }
+ const tensors = arg;
+ return tensors.map((t, i) => convertToTensor(t, `${argName}[${i}]`, functionName), parseAsDtype);
+}
+//# sourceMappingURL=tensor_util_env.js.map
+
+/***/ }),
+/* 4 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return op; });
+/* harmony import */ var _engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+/**
+ * Used for wrapping functions that perform math operations on
+ * Tensors. The function will be wrapped in a named scope that cleans all
+ * memory usage after the function is done.
+ */
+function op(f) {
+ const keys = Object.keys(f);
+ if (keys.length !== 1) {
+ throw new Error(`Please provide an object with a single key ` +
+ `(operation name) mapping to a function. Got an object with ` +
+ `${keys.length} keys.`);
+ }
+ let opName = keys[0];
+ const fn = f[opName];
+ // Strip the underscore from the end of the function name.
+ if (opName.endsWith('_')) {
+ opName = opName.substring(0, opName.length - 1);
+ }
+ // tslint:disable-next-line:no-any
+ const f2 = (...args) => {
+ _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].startScope(opName);
+ try {
+ const result = fn(...args);
+ if (result instanceof Promise) {
+ console.error('Cannot return a Promise inside of tidy.');
+ }
+ _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].endScope(result);
+ return result;
+ }
+ catch (ex) {
+ _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].endScope(null);
+ throw ex;
+ }
+ };
+ Object.defineProperty(f2, 'name', { value: opName, configurable: true });
+ // tslint:disable-next-line:no-any
+ return f2;
+}
+//# sourceMappingURL=operation.js.map
+
+/***/ }),
+/* 5 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ ENGINE; });
+
+// UNUSED EXPORTS: Engine
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/environment.js
+var dist_environment = __webpack_require__(10);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/global_util.js
+var global_util = __webpack_require__(33);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/kernel_registry.js
+var kernel_registry = __webpack_require__(17);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/util.js
+var util = __webpack_require__(1);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/profiler.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+class Profiler {
+ constructor(backendTimer, logger) {
+ this.backendTimer = backendTimer;
+ this.logger = logger;
+ if (logger == null) {
+ this.logger = new profiler_Logger();
+ }
+ }
+ profileKernel(kernelName, inputs, f) {
+ let outputs;
+ const holdResultWrapperFn = () => {
+ outputs = f();
+ };
+ const timer = this.backendTimer.time(holdResultWrapperFn);
+ outputs.forEach(r => {
+ // Dangling promise here because we don't want to propagate up
+ // asynchronicity.
+ r.data().then(vals => {
+ checkComputationForErrors(vals, r.dtype, kernelName);
+ timer.then(timing => {
+ let extraInfo = '';
+ if (timing.getExtraProfileInfo != null) {
+ extraInfo = timing.getExtraProfileInfo();
+ }
+ this.logger.logKernelProfile(kernelName, r, vals, timing.kernelMs, inputs, extraInfo);
+ });
+ });
+ });
+ return outputs;
+ }
+}
+function checkComputationForErrors(vals, dtype, kernelName) {
+ if (dtype !== 'float32') {
+ // Only floating point computations will generate NaN values
+ return false;
+ }
+ for (let i = 0; i < vals.length; i++) {
+ const num = vals[i];
+ if (isNaN(num) || !isFinite(num)) {
+ // Throwing custom exception so behavior is testable.
+ console.warn(`Found ${num} in the result of '${kernelName}'`);
+ return true;
+ }
+ }
+ return false;
+}
+class profiler_Logger {
+ logKernelProfile(name, result, vals, timeMs, inputs, extraInfo) {
+ const time = typeof timeMs === 'number' ? util["rightPad"](`${timeMs}ms`, 9) :
+ timeMs['error'];
+ const paddedName = util["rightPad"](name, 25);
+ const rank = result.rank;
+ const size = result.size;
+ const shape = util["rightPad"](result.shape.toString(), 14);
+ let inputShapesDescription = '';
+ for (const name in inputs) {
+ const input = inputs[name];
+ // The input might be a non-tensor (e.g HTMLImageElement), in which case
+ // we claim the output shape as input shape.
+ const inputShape = input.shape || result.shape;
+ const inputRank = inputShape.length;
+ inputShapesDescription +=
+ `${name}: ${inputRank}D ${inputRank > 0 ? inputShape : ''} `;
+ }
+ console.log(`%c${paddedName}\t%c${time}\t%c${rank}D ${shape}\t%c${size}\t%c${inputShapesDescription}\t%c${extraInfo}`, 'font-weight:bold', 'color:red', 'color:blue', 'color: orange', 'color: green', 'color: steelblue');
+ }
+}
+//# sourceMappingURL=profiler.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/tape.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+/**
+ * Computes a list of TapeNodes that connect x to y, filtering everything else
+ * out and preserving the order of the original tape elements.
+ *
+ * @param tape The tape elements to filter.
+ * @param xs The input Tensors.
+ * @param y The output Tensor.
+ */
+function getFilteredNodesXToY(tape, xs, y) {
+ // Forward pass to compute all the nodes and Tensors that are transitively a
+ // function of x.
+ const tensorsFromX = {};
+ const nodesFromX = {};
+ for (let i = 0; i < xs.length; i++) {
+ tensorsFromX[xs[i].id] = true;
+ }
+ for (let i = 0; i < tape.length; i++) {
+ const node = tape[i];
+ const nodeInputs = node.inputs;
+ for (const inputName in nodeInputs) {
+ const input = nodeInputs[inputName];
+ let anyInputFromX = false;
+ for (let j = 0; j < xs.length; j++) {
+ if (tensorsFromX[input.id]) {
+ node.outputs.forEach(output => tensorsFromX[output.id] = true);
+ anyInputFromX = true;
+ nodesFromX[node.id] = true;
+ break;
+ }
+ }
+ if (anyInputFromX) {
+ break;
+ }
+ }
+ }
+ // Backward pass to find all of the nodes and Tensors that lead to y.
+ const tensorsLeadToY = {};
+ tensorsLeadToY[y.id] = true;
+ const nodesToY = {};
+ for (let i = tape.length - 1; i >= 0; i--) {
+ const node = tape[i];
+ const nodeInputs = node.inputs;
+ // If any of the outputs lead to y, mark all of the inputs as leading to y.
+ for (let j = 0; j < node.outputs.length; j++) {
+ if (tensorsLeadToY[node.outputs[j].id]) {
+ for (const inputName in nodeInputs) {
+ tensorsLeadToY[nodeInputs[inputName].id] = true;
+ nodesToY[node.id] = true;
+ }
+ break;
+ }
+ }
+ }
+ // Return the paths that come from x and lead to y.
+ const filteredTape = [];
+ for (let i = 0; i < tape.length; i++) {
+ const node = tape[i];
+ if (nodesFromX[node.id] && nodesToY[node.id]) {
+ // Prune the inputs from the node that aren't a function of x.
+ const prunedInputs = {};
+ for (const inputName in node.inputs) {
+ const nodeInput = node.inputs[inputName];
+ if (tensorsFromX[nodeInput.id]) {
+ prunedInputs[inputName] = nodeInput;
+ }
+ }
+ // Copy the node and overwrite inputsAndArgs to the pruned version.
+ const prunedNode = Object.assign({}, node);
+ prunedNode.inputs = prunedInputs;
+ prunedNode.outputs = node.outputs;
+ filteredTape.push(prunedNode);
+ }
+ }
+ return filteredTape;
+}
+/**
+ * Backpropagate gradients through the filtered TapeNodes.
+ *
+ * @param tensorAccumulatedGradientMap A map of Tensor to its gradient. This map
+ * is mutated by this method.
+ * @param filteredTape The filtered TapeNodes to backprop through.
+ */
+function backpropagateGradients(tensorAccumulatedGradientMap, filteredTape, tidy) {
+ // Walk the tape backward and keep a map of Tensor to its gradient.
+ for (let i = filteredTape.length - 1; i >= 0; i--) {
+ const node = filteredTape[i];
+ const dys = [];
+ node.outputs.forEach(o => {
+ const gradTensor = tensorAccumulatedGradientMap[o.id];
+ if (gradTensor != null) {
+ dys.push(gradTensor);
+ }
+ else {
+ // This particular output is not in the back-propagation subgraph, so it
+ // does not affect the final output, thus we put null for its dy.
+ dys.push(null);
+ }
+ });
+ if (node.gradient == null) {
+ throw new Error(`Cannot compute gradient: gradient function not found ` +
+ `for ${node.kernelName}.`);
+ }
+ // Backprop dy through this node and accumulate gradients over the inputs.
+ const inputGradients = node.gradient(dys);
+ for (const inputName in node.inputs) {
+ if (!(inputName in inputGradients)) {
+ throw new Error(`Cannot backprop through input ${inputName}. ` +
+ `Available gradients found: ${Object.keys(inputGradients)}.`);
+ }
+ // Call the gradient function.
+ const dx = tidy(() => inputGradients[inputName]());
+ if (dx.dtype !== 'float32') {
+ throw new Error(`Error in gradient for op ${node.kernelName}. The gradient of input ` +
+ `${inputName} must have 'float32' dtype, but has '${dx.dtype}'`);
+ }
+ const x = node.inputs[inputName];
+ if (!util["arraysEqual"](dx.shape, x.shape)) {
+ throw new Error(`Error in gradient for op ${node.kernelName}. The gradient of input ` +
+ `'${inputName}' has shape '${dx.shape}', which does not match ` +
+ `the shape of the input '${x.shape}'`);
+ }
+ if (tensorAccumulatedGradientMap[x.id] == null) {
+ tensorAccumulatedGradientMap[x.id] = dx;
+ }
+ else {
+ const curGradient = tensorAccumulatedGradientMap[x.id];
+ tensorAccumulatedGradientMap[x.id] = curGradient.add(dx);
+ curGradient.dispose();
+ }
+ }
+ }
+}
+//# sourceMappingURL=tape.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/tensor.js + 1 modules
+var tensor = __webpack_require__(7);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/tensor_util.js
+var tensor_util = __webpack_require__(11);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/engine.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+class EngineState {
+ constructor() {
+ // Public since optimizers will use it.
+ this.registeredVariables = {};
+ this.nextTapeNodeId = 0;
+ this.numBytes = 0;
+ this.numTensors = 0;
+ this.numStringTensors = 0;
+ this.numDataBuffers = 0;
+ // Number of nested tf.grad() statements when computing higher-order
+ // gradients. E.g. `1` for first-order gradients and `2` for second-order
+ // gradients. Used to track if the tape should be removed after a backprop.
+ this.gradientDepth = 0;
+ // Number of nested kernel calls. When kernel depth is greater than 1, we turn
+ // off the tape.
+ this.kernelDepth = 0;
+ this.scopeStack = [];
+ /**
+ * Keeps track of the number of data moves during a kernel execution. We
+ * maintain a stack since kernels can call other kernels, recursively.
+ */
+ this.numDataMovesStack = [];
+ this.nextScopeId = 0;
+ this.tensorInfo = new WeakMap();
+ this.profiling = false;
+ this.activeProfile = { newBytes: 0, newTensors: 0, peakBytes: 0, kernels: [], result: null };
+ }
+ dispose() {
+ for (const variableName in this.registeredVariables) {
+ this.registeredVariables[variableName].dispose();
+ }
+ }
+}
+class engine_Engine {
+ constructor(ENV) {
+ this.ENV = ENV;
+ this.registry = {};
+ this.registryFactory = {};
+ this.pendingBackendInitId = 0;
+ this.state = new EngineState();
+ }
+ async ready() {
+ if (this.pendingBackendInit != null) {
+ return this.pendingBackendInit.then(() => { });
+ }
+ if (this.backendInstance != null) {
+ return;
+ }
+ const sortedBackends = this.getSortedBackends();
+ for (let i = 0; i < sortedBackends.length; i++) {
+ const backendName = sortedBackends[i];
+ const success = await this.initializeBackend(backendName).success;
+ if (success) {
+ await this.setBackend(backendName);
+ return;
+ }
+ }
+ throw new Error(`Could not initialize any backends, all backend initializations ` +
+ `failed.`);
+ }
+ get backend() {
+ if (this.pendingBackendInit != null) {
+ throw new Error(`Backend '${this.backendName}' has not yet been initialized. Make ` +
+ `sure to await tf.ready() or await tf.setBackend() before calling ` +
+ `other methods`);
+ }
+ if (this.backendInstance == null) {
+ const { name, asyncInit } = this.initializeBackendsAndReturnBest();
+ if (asyncInit) {
+ throw new Error(`The highest priority backend '${name}' has not yet been ` +
+ `initialized. Make sure to await tf.ready() or ` +
+ `await tf.setBackend() before calling other methods`);
+ }
+ this.setBackend(name);
+ }
+ return this.backendInstance;
+ }
+ backendNames() {
+ return Object.keys(this.registryFactory);
+ }
+ findBackend(backendName) {
+ if (!(backendName in this.registry)) {
+ // If the backend hasn't been initialized but we have a registry entry for
+ // it, initialize it and return it.
+ if (backendName in this.registryFactory) {
+ const { asyncInit } = this.initializeBackend(backendName);
+ if (asyncInit) {
+ // Backend is not ready yet.
+ return null;
+ }
+ }
+ else {
+ return null;
+ }
+ }
+ return this.registry[backendName];
+ }
+ findBackendFactory(backendName) {
+ if (!(backendName in this.registryFactory)) {
+ return null;
+ }
+ return this.registryFactory[backendName].factory;
+ }
+ registerBackend(backendName, factory, priority = 1) {
+ if (backendName in this.registryFactory) {
+ console.warn(`${backendName} backend was already registered. ` +
+ `Reusing existing backend factory.`);
+ return false;
+ }
+ this.registryFactory[backendName] = { factory, priority };
+ return true;
+ }
+ async setBackend(backendName) {
+ if (this.registryFactory[backendName] == null) {
+ throw new Error(`Backend name '${backendName}' not found in registry`);
+ }
+ this.backendName = backendName;
+ if (this.registry[backendName] == null) {
+ this.backendInstance = null;
+ const { success, asyncInit } = this.initializeBackend(backendName);
+ const result = asyncInit ? await success : success;
+ if (!result) {
+ return false;
+ }
+ }
+ this.backendInstance = this.registry[backendName];
+ this.setupRegisteredKernels();
+ // Reset the profiler.
+ this.profiler = new Profiler(this.backendInstance);
+ return true;
+ }
+ setupRegisteredKernels() {
+ const kernels = Object(kernel_registry["c" /* getKernelsForBackend */])(this.backendName);
+ kernels.forEach(kernel => {
+ if (kernel.setupFunc != null) {
+ kernel.setupFunc(this.backendInstance);
+ }
+ });
+ }
+ disposeRegisteredKernels(backendName) {
+ const kernels = Object(kernel_registry["c" /* getKernelsForBackend */])(backendName);
+ kernels.forEach(kernel => {
+ if (kernel.disposeFunc != null) {
+ kernel.disposeFunc(this.registry[backendName]);
+ }
+ });
+ }
+ /**
+ * Initializes a backend by looking up the backend name in the factory
+ * registry and calling the factory method. Returns a boolean representing
+ * whether the initialization of the backend suceeded. Throws an error if
+ * there is no backend in the factory registry.
+ */
+ initializeBackend(backendName) {
+ const registryFactoryEntry = this.registryFactory[backendName];
+ if (registryFactoryEntry == null) {
+ throw new Error(`Cannot initialize backend ${backendName}, no registration found.`);
+ }
+ try {
+ const backend = registryFactoryEntry.factory();
+ // Test if the factory returns a promise.
+ if (Promise.resolve(backend) === backend) {
+ const promiseId = ++this.pendingBackendInitId;
+ const success = backend
+ .then(backendInstance => {
+ // Outdated promise. Another backend was set in the meantime.
+ if (promiseId < this.pendingBackendInitId) {
+ return false;
+ }
+ this.registry[backendName] = backendInstance;
+ this.pendingBackendInit = null;
+ return true;
+ })
+ .catch(err => {
+ // Outdated promise. Another backend was set in the meantime.
+ if (promiseId < this.pendingBackendInitId) {
+ return false;
+ }
+ this.pendingBackendInit = null;
+ console.warn(`Initialization of backend ${backendName} failed`);
+ console.warn(err.stack || err.message);
+ return false;
+ });
+ this.pendingBackendInit = success;
+ return { success, asyncInit: true };
+ }
+ else {
+ this.registry[backendName] = backend;
+ return { success: true, asyncInit: false };
+ }
+ }
+ catch (err) {
+ console.warn(`Initialization of backend ${backendName} failed`);
+ console.warn(err.stack || err.message);
+ return { success: false, asyncInit: false };
+ }
+ }
+ removeBackend(backendName) {
+ if (!(backendName in this.registryFactory)) {
+ throw new Error(`${backendName} backend not found in registry`);
+ }
+ if (this.backendName === backendName && this.pendingBackendInit != null) {
+ // There is a pending promise of the backend we want to remove. Make it
+ // obsolete.
+ this.pendingBackendInitId++;
+ }
+ if (backendName in this.registry) {
+ this.disposeRegisteredKernels(backendName);
+ this.registry[backendName].dispose();
+ delete this.registry[backendName];
+ }
+ delete this.registryFactory[backendName];
+ // Unset the backend if it is active.
+ if (this.backendName === backendName) {
+ this.pendingBackendInit = null;
+ this.backendName = null;
+ this.backendInstance = null;
+ }
+ }
+ getSortedBackends() {
+ if (Object.keys(this.registryFactory).length === 0) {
+ throw new Error('No backend found in registry.');
+ }
+ return Object.keys(this.registryFactory).sort((a, b) => {
+ // Highest priority comes first.
+ return this.registryFactory[b].priority -
+ this.registryFactory[a].priority;
+ });
+ }
+ initializeBackendsAndReturnBest() {
+ const sortedBackends = this.getSortedBackends();
+ for (let i = 0; i < sortedBackends.length; i++) {
+ const backendName = sortedBackends[i];
+ const { success, asyncInit } = this.initializeBackend(backendName);
+ if (asyncInit || success) {
+ return { name: backendName, asyncInit };
+ }
+ }
+ throw new Error(`Could not initialize any backends, all backend initializations ` +
+ `failed.`);
+ }
+ moveData(backend, dataId) {
+ const info = this.state.tensorInfo.get(dataId);
+ const srcBackend = info.backend;
+ const values = this.readSync(dataId);
+ // Delete the tensor from the old backend and move it to the new
+ // backend.
+ srcBackend.disposeData(dataId);
+ info.backend = backend;
+ backend.move(dataId, values, info.shape, info.dtype);
+ if (this.shouldCheckForMemLeaks()) {
+ // Track the number of moves during a kernel execution to correctly
+ // detect memory leaks.
+ this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1]++;
+ }
+ }
+ tidy(nameOrFn, fn) {
+ let name = null;
+ if (fn == null) {
+ // Called with only 1 argument.
+ if (typeof nameOrFn !== 'function') {
+ throw new Error('Please provide a function to tidy()');
+ }
+ fn = nameOrFn;
+ }
+ else {
+ // Called with 2 arguments.
+ if (typeof nameOrFn !== 'string' && !(nameOrFn instanceof String)) {
+ throw new Error('When calling with two arguments, the first argument ' +
+ 'to tidy() must be a string');
+ }
+ if (typeof fn !== 'function') {
+ throw new Error('When calling with two arguments, the 2nd argument ' +
+ 'to tidy() must be a function');
+ }
+ name = nameOrFn;
+ // TODO(nsthorat,smilkov): Do operation logging and performance
+ // profiling.
+ }
+ let result;
+ return this.scopedRun(() => this.startScope(name), () => this.endScope(result), () => {
+ result = fn();
+ if (result instanceof Promise) {
+ console.error('Cannot return a Promise inside of tidy.');
+ }
+ return result;
+ });
+ }
+ scopedRun(start, end, f) {
+ start();
+ try {
+ const res = f();
+ end();
+ return res;
+ }
+ catch (ex) {
+ end();
+ throw ex;
+ }
+ }
+ nextTensorId() {
+ return engine_Engine.nextTensorId++;
+ }
+ nextVariableId() {
+ return engine_Engine.nextVariableId++;
+ }
+ /**
+ * This method is called instead of the public-facing tensor.clone() when
+ * saving a tensor for backwards pass. It makes sure to add the clone
+ * operation to the tape regardless of being called inside a kernel
+ * execution.
+ *
+ * This method will go away once all kernels are modularized since we won't
+ * need to turn off the tape inside runKernel().
+ */
+ clone(x) {
+ const y = this.makeTensorFromDataId(x.dataId, x.shape, x.dtype);
+ const inputs = { x };
+ const grad = (dy) => ({ x: () => dy.toFloat() });
+ const saved = [];
+ this.addTapeNode(this.state.activeScope.name, inputs, [y], grad, saved, {});
+ return y;
+ }
+ /**
+ * Execute a kernel with the given name and return the output tensor.
+ *
+ * @param kernelName The name of the kernel to execute.
+ * @param inputs A map of input names to tensors.
+ * @param attrs A map of attribute names to their values. An attribute is a
+ * primitive (non-tensor) input to the kernel.
+ * @param inputsToSave A list of tensors, inputs to save for the backprop
+ * computation.
+ * @param outputsToSave A list of booleans, specifying which output to save
+ * for the backprop computation. These are booleans since the output
+ * tensors are not visible to the user.
+ */
+ runKernel(kernelName, inputs, attrs, inputsToSave, outputsToSave) {
+ const forwardFunc = null;
+ const backwardsFunc = null;
+ // Call runKernel as a stop-gap until we modularize all kernels.
+ // Once we modularize all kernels, we will remove the existing
+ // `runKernelFunc`.
+ return this.runKernelFunc(forwardFunc, inputs, backwardsFunc, kernelName, attrs, inputsToSave, outputsToSave);
+ }
+ shouldCheckForMemLeaks() {
+ return this.ENV.getBool('IS_TEST');
+ }
+ checkKernelForMemLeak(kernelName, numDataIdsBefore, outInfos) {
+ const numDataIdsAfter = this.backend.numDataIds();
+ // Count the number of data ids associated with the result of the kernel.
+ let numOutputDataIds = 0;
+ outInfos.forEach(info => {
+ // Complex numbers allocate 3 data ids, one for 'real', one for
+ // 'imaginary', and one for the container that holds the former two.
+ numOutputDataIds += (info.dtype === 'complex64' ? 3 : 1);
+ });
+ // Account for the number of moves during kernel execution. A "data move"
+ // can happen in the middle of a kernel execution, placing a new (key,value)
+ // pair in the data storage. Since data moves have net zero effect (we
+ // always remove the data from the old backend), we have to cancel them out
+ // when detecting memory leaks.
+ const numMoves = this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1];
+ const dataIdsLeaked = numDataIdsAfter - numDataIdsBefore - numOutputDataIds - numMoves;
+ if (dataIdsLeaked > 0) {
+ throw new Error(`Backend '${this.backendName}' has an internal memory leak ` +
+ `(${dataIdsLeaked} data ids) after running '${kernelName}'`);
+ }
+ }
+ /**
+ * @deprecated Use `runKernel` for newly added kernels. Keep using this method
+ * only for kernels that are not yet fully modularized.
+ */
+ runKernelFunc(forwardFunc, inputs, backwardsFunc, kernelName, attrs, inputsToSave, outputsToSave) {
+ let outputs;
+ let saved = [];
+ const isTapeOn = this.isTapeOn();
+ if (kernelName == null) {
+ kernelName =
+ this.state.activeScope != null ? this.state.activeScope.name : '';
+ }
+ const startingBytecount = this.state.numBytes;
+ const startingNumTensors = this.state.numTensors;
+ if (this.shouldCheckForMemLeaks()) {
+ this.state.numDataMovesStack.push(0);
+ }
+ let kernelFunc;
+ const kernel = Object(kernel_registry["b" /* getKernel */])(kernelName, this.backendName);
+ let out;
+ if (kernel != null) {
+ kernelFunc = () => {
+ const numDataIdsBefore = this.backend.numDataIds();
+ out = kernel.kernelFunc({ inputs, attrs, backend: this.backend });
+ const outInfos = Array.isArray(out) ? out : [out];
+ if (this.shouldCheckForMemLeaks()) {
+ this.checkKernelForMemLeak(kernelName, numDataIdsBefore, outInfos);
+ }
+ const outTensors = outInfos.map(({ dataId, shape, dtype }) => this.makeTensorFromDataId(dataId, shape, dtype));
+ // Save the inputs and outputs.
+ // Do not save unless we are recording to the tape. Otherwise it would
+ // cause a mem leak since we would never run backprop, which disposes
+ // the kept tensors.
+ if (isTapeOn) {
+ let tensorsToSave = this.getTensorsForGradient(kernelName, inputs, outTensors);
+ if (tensorsToSave == null) {
+ // Fallback for ops that call runKernelFunc and pass in
+ // inputsToSave and outputsToSave. Currently this is the set of ops
+ // with kernel support in the WASM backend. Once those ops and
+ // respective gradients are modularised we can remove this path.
+ if (outputsToSave == null) {
+ outputsToSave = [];
+ }
+ const outsToSave = outTensors.filter((_, i) => outputsToSave[i]);
+ tensorsToSave = (inputsToSave || []).slice().concat(outsToSave);
+ }
+ saved = this.saveTensorsForBackwardMode(tensorsToSave);
+ }
+ return outTensors;
+ };
+ }
+ else {
+ const saveFunc = (tensors) => {
+ // Do not save unless we are recording to the tape. Otherwise it would
+ // cause a mem leak since we would never run backprop, which disposes
+ // the kept tensors.
+ if (!isTapeOn) {
+ return;
+ }
+ saved = tensors.map(tensor => this.keep(this.clone(tensor)));
+ };
+ kernelFunc = () => {
+ const numDataIdsBefore = this.backend.numDataIds();
+ out = this.tidy(() => forwardFunc(this.backend, saveFunc));
+ const outs = (Array.isArray(out) ? out : [out]);
+ if (this.shouldCheckForMemLeaks()) {
+ this.checkKernelForMemLeak(kernelName, numDataIdsBefore, outs);
+ }
+ return outs;
+ };
+ }
+ // Stop recording to a tape when running a kernel.
+ this.scopedRun(() => this.state.kernelDepth++, () => this.state.kernelDepth--, () => {
+ if (!this.ENV.getBool('DEBUG')) {
+ outputs = kernelFunc();
+ }
+ else {
+ outputs = this.profiler.profileKernel(kernelName, inputs, () => kernelFunc());
+ }
+ });
+ if (isTapeOn) {
+ this.addTapeNode(kernelName, inputs, outputs, backwardsFunc, saved, attrs);
+ }
+ if (this.state.profiling) {
+ this.state.activeProfile.kernels.push({
+ name: kernelName,
+ bytesAdded: this.state.numBytes - startingBytecount,
+ totalBytesSnapshot: this.state.numBytes,
+ tensorsAdded: this.state.numTensors - startingNumTensors,
+ totalTensorsSnapshot: this.state.numTensors,
+ inputShapes: Object.keys(inputs).map(key => inputs[key].shape),
+ outputShapes: outputs.map(item => item.shape)
+ });
+ }
+ return (Array.isArray(out) ? outputs : outputs[0]);
+ }
+ /**
+ * Saves tensors used in forward mode for use in backward mode.
+ *
+ * @param tensors the list of tensors to save.
+ */
+ saveTensorsForBackwardMode(tensors) {
+ const saved = tensors.map(tensor => this.keep(this.clone(tensor)));
+ return saved;
+ }
+ /**
+ * Returns a list of tensors to save for a given gradient calculation.
+ *
+ * Returns undefined if their is no registered gradient for this kernel in the
+ * gradient registry.
+ *
+ * @param kernelName name of kernel to look up gradient for.
+ * @param inputs a map of input tensors.
+ * @param outputs an array of output tensors from forward mode of kernel.
+ */
+ getTensorsForGradient(kernelName, inputs, outputs) {
+ const gradConfig = Object(kernel_registry["a" /* getGradient */])(kernelName);
+ if (gradConfig != null) {
+ const inputsToSave = gradConfig.inputsToSave || [];
+ const outputsToSave = gradConfig.outputsToSave || [];
+ // If saveAllInputs is true, all inputs will be saved. Otherwise, inputs
+ // specified in inputsToSave will be saved.
+ let inputTensorsToSave;
+ if (gradConfig.saveAllInputs) {
+ util["assert"](Array.isArray(inputs), () => 'saveAllInputs is true, expected inputs to be an array.');
+ inputTensorsToSave = Object.keys(inputs).map((key) => inputs[key]);
+ }
+ else {
+ inputTensorsToSave = inputsToSave.map((inputName) => inputs[inputName]);
+ }
+ const outputTensorsToSave = outputs.filter((_, i) => outputsToSave[i]);
+ return inputTensorsToSave.concat(outputTensorsToSave);
+ }
+ // TODO(yassogba) throw exception here once all runkernelFunc calls with
+ // inputsToSave/outputsToSave are removed
+ return null;
+ }
+ /**
+ * Internal method used by public APIs for tensor creation. Makes a new
+ * tensor with the provided shape, dtype and values. It always
+ * creates a new data id and writes the values to the underlying backend.
+ */
+ makeTensor(values, shape, dtype, backend) {
+ if (values == null) {
+ throw new Error('Values passed to engine.makeTensor() are null');
+ }
+ dtype = dtype || 'float32';
+ backend = backend || this.backend;
+ let backendVals = values;
+ if (dtype === 'string' && util["isString"](values[0])) {
+ backendVals = values.map(d => util["encodeString"](d));
+ }
+ const dataId = backend.write(backendVals, shape, dtype);
+ const t = new tensor["a" /* Tensor */](shape, dtype, dataId, this.nextTensorId());
+ this.incRef(t, backend);
+ // Count bytes for string tensors.
+ if (dtype === 'string') {
+ const info = this.state.tensorInfo.get(dataId);
+ const newBytes = Object(util["bytesFromStringArray"])(backendVals);
+ this.state.numBytes += newBytes - info.bytes;
+ info.bytes = newBytes;
+ }
+ return t;
+ }
+ /**
+ * Internal method used by backends. Makes a new tensor
+ * that is a wrapper around an existing data id. It doesn't create
+ * a new data id, only increments the ref count used in memory tracking.
+ */
+ makeTensorFromDataId(dataId, shape, dtype, backend) {
+ dtype = dtype || 'float32';
+ const t = new tensor["a" /* Tensor */](shape, dtype, dataId, this.nextTensorId());
+ this.incRef(t, backend);
+ return t;
+ }
+ makeVariable(initialValue, trainable = true, name, dtype) {
+ name = name || this.nextVariableId().toString();
+ if (dtype != null && dtype !== initialValue.dtype) {
+ initialValue = initialValue.asType(dtype);
+ }
+ const v = new tensor["c" /* Variable */](initialValue, trainable, name, this.nextTensorId());
+ if (this.state.registeredVariables[v.name] != null) {
+ throw new Error(`Variable with name ${v.name} was already registered`);
+ }
+ this.state.registeredVariables[v.name] = v;
+ this.incRef(v, this.backend);
+ return v;
+ }
+ incRef(a, backend) {
+ const refCount = this.state.tensorInfo.has(a.dataId) ?
+ this.state.tensorInfo.get(a.dataId).refCount :
+ 0;
+ this.state.numTensors++;
+ if (a.dtype === 'string') {
+ this.state.numStringTensors++;
+ }
+ if (refCount === 0) {
+ this.state.numDataBuffers++;
+ // Bytes for complex numbers are counted by their components. Bytes for
+ // string tensors are counted when writing values.
+ let bytes = 0;
+ if (a.dtype !== 'complex64' && a.dtype !== 'string') {
+ bytes = a.size * util["bytesPerElement"](a.dtype);
+ }
+ this.state.tensorInfo.set(a.dataId, {
+ backend: backend || this.backend,
+ dtype: a.dtype,
+ shape: a.shape,
+ bytes,
+ refCount: 0
+ });
+ this.state.numBytes += bytes;
+ }
+ this.state.tensorInfo.get(a.dataId).refCount++;
+ if (!(a instanceof tensor["c" /* Variable */])) {
+ this.track(a);
+ }
+ }
+ disposeTensor(a) {
+ if (!this.state.tensorInfo.has(a.dataId)) {
+ return;
+ }
+ this.state.numTensors--;
+ if (a.dtype === 'string') {
+ this.state.numStringTensors--;
+ }
+ const info = this.state.tensorInfo.get(a.dataId);
+ const refCount = info.refCount;
+ if (refCount <= 1) {
+ // Don't count bytes for complex numbers as they are counted by their
+ // components.
+ if (a.dtype !== 'complex64') {
+ this.state.numBytes -= info.bytes;
+ }
+ this.state.numDataBuffers--;
+ info.backend.disposeData(a.dataId);
+ this.state.tensorInfo.delete(a.dataId);
+ }
+ else {
+ this.state.tensorInfo.get(a.dataId).refCount--;
+ }
+ // TODO(nsthorat): Construct an error and save the stack trace for
+ // debugging when in debug mode. Creating a stack trace is too expensive
+ // to do unconditionally.
+ }
+ disposeVariables() {
+ for (const varName in this.state.registeredVariables) {
+ const v = this.state.registeredVariables[varName];
+ this.disposeVariable(v);
+ }
+ }
+ disposeVariable(v) {
+ this.disposeTensor(v);
+ if (this.state.registeredVariables[v.name] != null) {
+ delete this.state.registeredVariables[v.name];
+ }
+ }
+ memory() {
+ const info = this.backend.memory();
+ info.numTensors = this.state.numTensors;
+ info.numDataBuffers = this.state.numDataBuffers;
+ info.numBytes = this.state.numBytes;
+ if (this.state.numStringTensors > 0) {
+ info.unreliable = true;
+ if (info.reasons == null) {
+ info.reasons = [];
+ }
+ info.reasons.push('Memory usage by string tensors is approximate ' +
+ '(2 bytes per character)');
+ }
+ return info;
+ }
+ async profile(query) {
+ this.state.profiling = true;
+ const startBytes = this.state.numBytes;
+ const startNumTensors = this.state.numTensors;
+ this.state.activeProfile.kernels = [];
+ this.state.activeProfile.result = query();
+ this.state.profiling = false;
+ this.state.activeProfile.peakBytes = Math.max(...this.state.activeProfile.kernels.map(d => d.totalBytesSnapshot));
+ this.state.activeProfile.newBytes = this.state.numBytes - startBytes;
+ this.state.activeProfile.newTensors =
+ this.state.numTensors - startNumTensors;
+ return this.state.activeProfile;
+ }
+ isTapeOn() {
+ return this.state.gradientDepth > 0 && this.state.kernelDepth === 0;
+ }
+ addTapeNode(kernelName, inputs, outputs, gradientsFunc, saved, attrs) {
+ const tapeNode = { id: this.state.nextTapeNodeId++, kernelName, inputs, outputs, saved };
+ const gradConfig = Object(kernel_registry["a" /* getGradient */])(kernelName);
+ if (gradConfig != null) {
+ gradientsFunc = gradConfig.gradFunc;
+ }
+ if (gradientsFunc != null) {
+ tapeNode.gradient = (dys) => {
+ // TODO(smilkov): To optimize back-prop, pass dys that are not used in
+ // the backprop graph to the user as null instead of zeros
+ dys = dys.map((dy, i) => {
+ if (dy == null) {
+ const output = outputs[i];
+ const vals = util["makeZerosTypedArray"](output.size, output.dtype);
+ return this.makeTensor(vals, output.shape, output.dtype);
+ }
+ return dy;
+ });
+ // Grad functions of ops with single outputs expect a dy, while ops
+ // with multiple outputs expect dys (array of dy).
+ return gradientsFunc(dys.length > 1 ? dys : dys[0], saved, attrs);
+ };
+ }
+ this.state.activeTape.push(tapeNode);
+ }
+ keep(result) {
+ result.kept = true;
+ return result;
+ }
+ startTape() {
+ if (this.state.gradientDepth === 0) {
+ this.state.activeTape = [];
+ }
+ this.state.gradientDepth++;
+ }
+ endTape() {
+ this.state.gradientDepth--;
+ }
+ /**
+ * Start a scope. Use this with endScope() to achieve the same functionality
+ * as scope() without the need for a function closure.
+ */
+ startScope(name) {
+ const scopeInfo = {
+ track: [],
+ name: 'unnamed scope',
+ id: this.state.nextScopeId++
+ };
+ if (name) {
+ scopeInfo.name = name;
+ }
+ this.state.scopeStack.push(scopeInfo);
+ this.state.activeScope = scopeInfo;
+ }
+ /**
+ * End a scope. Use this with startScope() to achieve the same functionality
+ * as scope() without the need for a function closure.
+ */
+ endScope(result) {
+ const tensorsToTrackInParent = Object(tensor_util["getTensorsInContainer"])(result);
+ const tensorsToTrackInParentSet = new Set(tensorsToTrackInParent.map(t => t.id));
+ // Dispose the arrays tracked in this scope.
+ for (let i = 0; i < this.state.activeScope.track.length; i++) {
+ const tensor = this.state.activeScope.track[i];
+ if (!tensor.kept && !tensorsToTrackInParentSet.has(tensor.id)) {
+ tensor.dispose();
+ }
+ }
+ const oldScope = this.state.scopeStack.pop();
+ this.state.activeScope = this.state.scopeStack.length === 0 ?
+ null :
+ this.state.scopeStack[this.state.scopeStack.length - 1];
+ // Track the current result in the parent scope.
+ tensorsToTrackInParent.forEach(tensor => {
+ // Only track the tensor if was allocated in the inner scope and is not
+ // globally kept.
+ if (!tensor.kept && tensor.scopeId === oldScope.id) {
+ this.track(tensor);
+ }
+ });
+ }
+ /**
+ * Returns gradients of `f` with respect to each of the `xs`. The gradients
+ * returned are of the same length as `xs`, but some might be null if `f`
+ * was not a function of that `x`. It also takes optional dy to multiply the
+ * gradient, which defaults to `1`.
+ */
+ gradients(f, xs, dy, allowNoGradients = false) {
+ util["assert"](xs.length > 0, () => 'gradients() received an empty list of xs.');
+ if (dy != null && dy.dtype !== 'float32') {
+ throw new Error(`dy must have 'float32' dtype, but has '${dy.dtype}'`);
+ }
+ const y = this.scopedRun(() => this.startTape(), () => this.endTape(), () => this.tidy('forward', f));
+ util["assert"](y instanceof tensor["a" /* Tensor */], () => 'The result y returned by f() must be a tensor.');
+ // Filter out the nodes that don't connect x => y.
+ const filteredTape = getFilteredNodesXToY(this.state.activeTape, xs, y);
+ if (!allowNoGradients && filteredTape.length === 0 && xs.length > 0) {
+ throw new Error('Cannot compute gradient of y=f(x) with respect to x. Make sure ' +
+ 'that the f you passed encloses all operations that lead from x ' +
+ 'to y.');
+ }
+ return this.tidy('backward', () => {
+ const accumulatedGradientMap = {};
+ accumulatedGradientMap[y.id] = (dy == null) ? ones(y.shape) : dy;
+ // Backprop gradients through the filtered nodes.
+ backpropagateGradients(accumulatedGradientMap, filteredTape,
+ // Pass the tidy function to avoid circular dep with `tape.ts`.
+ f => this.tidy(f));
+ const grads = xs.map(x => accumulatedGradientMap[x.id]);
+ if (this.state.gradientDepth === 0) {
+ // This means that we are not computing higher-order gradients
+ // and can clean up the tape.
+ this.state.activeTape.forEach(node => {
+ for (const tensor of node.saved) {
+ tensor.dispose();
+ }
+ });
+ this.state.activeTape = null;
+ }
+ return { value: y, grads };
+ });
+ }
+ customGrad(f) {
+ util["assert"](util["isFunction"](f), () => 'The f passed in customGrad(f) must be a function.');
+ return (...inputs) => {
+ util["assert"](inputs.every(t => t instanceof tensor["a" /* Tensor */]), () => 'The args passed in customGrad(f)(x1, x2,...) must all be ' +
+ 'tensors');
+ let res;
+ const inputMap = {};
+ inputs.forEach((input, i) => {
+ inputMap[i] = input;
+ });
+ return this.runKernelFunc((_, save) => {
+ res = f(...[...inputs, save]);
+ util["assert"](res.value instanceof tensor["a" /* Tensor */], () => 'The function f passed in customGrad(f) must return an ' +
+ 'object where `obj.value` is a tensor');
+ util["assert"](util["isFunction"](res.gradFunc), () => 'The function f passed in customGrad(f) must return an ' +
+ 'object where `obj.gradFunc` is a function.');
+ return res.value;
+ }, inputMap, (dy, saved) => {
+ const gradRes = res.gradFunc(dy, saved);
+ const grads = Array.isArray(gradRes) ? gradRes : [gradRes];
+ util["assert"](grads.length === inputs.length, () => 'The function f passed in customGrad(f) must return an ' +
+ 'object where `obj.gradFunc` is a function that returns ' +
+ 'the same number of tensors as inputs passed to f(...).');
+ util["assert"](grads.every(t => t instanceof tensor["a" /* Tensor */]), () => 'The function f passed in customGrad(f) must return an ' +
+ 'object where `obj.gradFunc` is a function that returns ' +
+ 'a list of only tensors.');
+ const gradMap = {};
+ grads.forEach((grad, i) => {
+ gradMap[i] = () => grad;
+ });
+ return gradMap;
+ });
+ };
+ }
+ readSync(dataId) {
+ // Route the read to the correct backend.
+ const info = this.state.tensorInfo.get(dataId);
+ return info.backend.readSync(dataId);
+ }
+ read(dataId) {
+ // Route the read to the correct backend.
+ const info = this.state.tensorInfo.get(dataId);
+ return info.backend.read(dataId);
+ }
+ async time(query) {
+ const start = Object(util["now"])();
+ const timingInfo = await this.backend.time(query);
+ timingInfo.wallMs = Object(util["now"])() - start;
+ return timingInfo;
+ }
+ /**
+ * Tracks a Tensor in the current scope to be automatically cleaned up
+ * when the current scope ends, and returns the value.
+ *
+ * @param result The Tensor to track in the current scope.
+ */
+ track(result) {
+ if (this.state.activeScope != null) {
+ result.scopeId = this.state.activeScope.id;
+ this.state.activeScope.track.push(result);
+ }
+ return result;
+ }
+ get registeredVariables() {
+ return this.state.registeredVariables;
+ }
+ /**
+ * Resets the engine state. Removes all backends but does not remove
+ * registered backend factories.
+ */
+ reset() {
+ // Make any pending promise obsolete.
+ this.pendingBackendInitId++;
+ this.state.dispose();
+ this.ENV.reset();
+ this.state = new EngineState();
+ for (const backendName in this.registry) {
+ this.disposeRegisteredKernels(backendName);
+ this.registry[backendName].dispose();
+ delete this.registry[backendName];
+ }
+ this.backendName = null;
+ this.backendInstance = null;
+ this.pendingBackendInit = null;
+ }
+}
+engine_Engine.nextTensorId = 0;
+engine_Engine.nextVariableId = 0;
+function ones(shape) {
+ const values = Object(util["makeOnesTypedArray"])(Object(util["sizeFromShape"])(shape), 'float32');
+ return ENGINE.makeTensor(values, shape, 'float32');
+}
+function getOrMakeEngine() {
+ const ns = Object(global_util["b" /* getGlobalNamespace */])();
+ if (ns._tfengine == null) {
+ const environment = new dist_environment["b" /* Environment */](ns);
+ ns._tfengine = new engine_Engine(environment);
+ }
+ Object(dist_environment["d" /* setEnvironmentGlobal */])(ns._tfengine.ENV);
+ // Tell the current tensor interface that the global engine is responsible
+ // for tracking.
+ Object(tensor["f" /* setTensorTracker */])(() => ns._tfengine);
+ return ns._tfengine;
+}
+const ENGINE = getOrMakeEngine();
+//# sourceMappingURL=engine.js.map
+
+/***/ }),
+/* 6 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Add; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return AddN; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return Atan2; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return AvgPool; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return AvgPoolBackprop; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return AvgPool3D; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return AvgPool3DBackprop; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return BatchMatMul; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return BatchToSpaceND; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return BroadcastTo; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return Complex; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return Concat; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return Conv2D; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return Conv2DBackpropFilter; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return Conv2DBackpropInput; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "p", function() { return Conv3D; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "q", function() { return Conv3DBackpropFilterV2; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "r", function() { return Conv3DBackpropInputV2; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "s", function() { return Cumsum; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "t", function() { return DepthToSpace; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "u", function() { return DepthwiseConv2dNative; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "v", function() { return DepthwiseConv2dNativeBackpropFilter; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "w", function() { return DepthwiseConv2dNativeBackpropInput; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "x", function() { return Diag; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "y", function() { return Div; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "z", function() { return Elu; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "A", function() { return EluGrad; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "B", function() { return Equal; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "D", function() { return FloorDiv; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "C", function() { return Fill; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "F", function() { return FusedBatchNorm; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "G", function() { return GatherNd; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "H", function() { return Greater; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "I", function() { return GreaterEqual; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "J", function() { return Identity; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "K", function() { return Imag; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "N", function() { return Less; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "O", function() { return LessEqual; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "L", function() { return LRN; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "M", function() { return LRNBackprop; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "P", function() { return Max; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "V", function() { return Maximum; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Q", function() { return MaxPool; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "T", function() { return MaxPoolBackprop; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "R", function() { return MaxPool3D; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "S", function() { return MaxPool3DBackprop; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "U", function() { return MaxPoolWithArgmax; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "W", function() { return Minimum; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "X", function() { return Mod; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Y", function() { return Multiply; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bb", function() { return NotEqual; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Z", function() { return NonMaxSuppressionV3; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ab", function() { return NonMaxSuppressionV5; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cb", function() { return OneHot; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "db", function() { return PadV2; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "eb", function() { return Pool; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fb", function() { return Pow; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "gb", function() { return Prelu; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hb", function() { return Real; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ib", function() { return Relu; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "jb", function() { return Relu6; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "kb", function() { return SelectV2; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lb", function() { return Selu; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mb", function() { return SpaceToBatchND; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "nb", function() { return SplitV; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pb", function() { return SquaredDifference; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ob", function() { return Square; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "qb", function() { return Sub; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rb", function() { return Tile; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sb", function() { return Transpose; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "E", function() { return FromPixels; });
+const Add = 'Add';
+const AddN = 'AddN';
+const Atan2 = 'Atan2';
+const AvgPool = 'AvgPool';
+const AvgPoolBackprop = 'AvgPoolBackprop';
+const AvgPool3D = 'AvgPool3D';
+const AvgPool3DBackprop = 'AvgPool3DBackprop';
+const BatchMatMul = 'BatchMatMul';
+const BatchToSpaceND = 'BatchToSpaceND';
+const BroadcastTo = 'BroadcastTo';
+const Complex = 'Complex';
+const Concat = 'Concat';
+const Conv2D = 'Conv2D';
+const Conv2DBackpropFilter = 'Conv2DBackpropFilter';
+const Conv2DBackpropInput = 'Conv2DBackpropInput';
+const Conv3D = 'Conv3D';
+const Conv3DBackpropFilterV2 = 'Conv3DBackpropFilterV2';
+const Conv3DBackpropInputV2 = 'Conv3DBackpropInputV2';
+const Cumsum = 'Cumsum';
+const DepthToSpace = 'DepthToSpace';
+const DepthwiseConv2dNative = 'DepthwiseConv2dNative';
+const DepthwiseConv2dNativeBackpropFilter = 'DepthwiseConv2dNativeBackpropFilter';
+const DepthwiseConv2dNativeBackpropInput = 'DepthwiseConv2dNativeBackpropInput';
+const Diag = 'Diag';
+const Div = 'Div';
+const Elu = 'Elu';
+const EluGrad = 'EluGrad';
+const Equal = 'Equal';
+const FloorDiv = 'FloorDiv';
+const Fill = 'Fill';
+const FusedBatchNorm = 'FusedBatchNorm';
+const GatherNd = 'GatherNd';
+const Greater = 'Greater';
+const GreaterEqual = 'GreaterEqual';
+const Identity = 'Identity';
+const Imag = 'Imag';
+const Less = 'Less';
+const LessEqual = 'LessEqual';
+const LRN = 'LRN';
+const LRNBackprop = 'LRNBackprop';
+const Max = 'Max';
+const Maximum = 'Maximum';
+const MaxPool = 'MaxPool';
+const MaxPoolBackprop = 'MaxPoolBackprop';
+const MaxPool3D = 'MaxPool3D';
+const MaxPool3DBackprop = 'MaxPool3DBackprop';
+const MaxPoolWithArgmax = 'MaxPoolWithArgmax';
+const Minimum = 'Minimum';
+const Mod = 'Mod';
+const Multiply = 'Multiply';
+const NotEqual = 'NotEqual';
+const NonMaxSuppressionV3 = 'NonMaxSuppressionV3';
+const NonMaxSuppressionV5 = 'NonMaxSuppressionV5';
+const OneHot = 'OneHot';
+const PadV2 = 'PadV2';
+const Pool = 'Pool';
+const Pow = 'Pow';
+const Prelu = 'Prelu';
+const Real = 'Real';
+const Relu = 'Relu';
+const Relu6 = 'Relu6';
+const SelectV2 = 'SelectV2';
+const Selu = 'Selu';
+const SpaceToBatchND = 'SpaceToBatchND';
+const SplitV = 'SplitV';
+const SquaredDifference = 'SquaredDifference';
+const Square = 'Square';
+const Sub = 'Sub';
+const Tile = 'Tile';
+const Transpose = 'Transpose';
+/**
+ * TensorFlow.js-only kernels
+ */
+const FromPixels = 'FromPixels';
+//# sourceMappingURL=kernel_names.js.map
+
+/***/ }),
+/* 7 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ tensor_TensorBuffer; });
+__webpack_require__.d(__webpack_exports__, "f", function() { return /* binding */ setTensorTracker; });
+__webpack_require__.d(__webpack_exports__, "e", function() { return /* binding */ setOpHandler; });
+__webpack_require__.d(__webpack_exports__, "d", function() { return /* binding */ setDeprecationWarningFn; });
+__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ tensor_Tensor; });
+__webpack_require__.d(__webpack_exports__, "c", function() { return /* binding */ tensor_Variable; });
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/util.js
+var util = __webpack_require__(1);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/tensor_format.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+// Maximum number of values before we decide to show ellipsis.
+const FORMAT_LIMIT_NUM_VALS = 20;
+// Number of first and last values to show when displaying a, b,...,y, z.
+const FORMAT_NUM_FIRST_LAST_VALS = 3;
+// Number of significant digits to show.
+const FORMAT_NUM_SIG_DIGITS = 7;
+function tensorToString(vals, shape, dtype, verbose) {
+ const strides = Object(util["computeStrides"])(shape);
+ const padPerCol = computeMaxSizePerColumn(vals, shape, dtype, strides);
+ const rank = shape.length;
+ const valsLines = subTensorToString(vals, shape, dtype, strides, padPerCol);
+ const lines = ['Tensor'];
+ if (verbose) {
+ lines.push(` dtype: ${dtype}`);
+ lines.push(` rank: ${rank}`);
+ lines.push(` shape: [${shape}]`);
+ lines.push(` values:`);
+ }
+ lines.push(valsLines.map(l => ' ' + l).join('\n'));
+ return lines.join('\n');
+}
+function computeMaxSizePerColumn(vals, shape, dtype, strides) {
+ const n = Object(util["sizeFromShape"])(shape);
+ const numCols = strides[strides.length - 1];
+ const padPerCol = new Array(numCols).fill(0);
+ const rank = shape.length;
+ const valuesOrTuples = dtype === 'complex64' ? createComplexTuples(vals) : vals;
+ if (rank > 1) {
+ for (let row = 0; row < n / numCols; row++) {
+ const offset = row * numCols;
+ for (let j = 0; j < numCols; j++) {
+ padPerCol[j] = Math.max(padPerCol[j], valToString(valuesOrTuples[offset + j], 0, dtype).length);
+ }
+ }
+ }
+ return padPerCol;
+}
+function valToString(val, pad, dtype) {
+ let valStr;
+ if (Array.isArray(val)) {
+ valStr = `${parseFloat(val[0].toFixed(FORMAT_NUM_SIG_DIGITS))} + ` +
+ `${parseFloat(val[1].toFixed(FORMAT_NUM_SIG_DIGITS))}j`;
+ }
+ else if (Object(util["isString"])(val)) {
+ valStr = `'${val}'`;
+ }
+ else if (dtype === 'bool') {
+ valStr = boolNumToString(val);
+ }
+ else {
+ valStr = parseFloat(val.toFixed(FORMAT_NUM_SIG_DIGITS)).toString();
+ }
+ return Object(util["rightPad"])(valStr, pad);
+}
+function boolNumToString(v) {
+ return v === 0 ? 'false' : 'true';
+}
+function subTensorToString(vals, shape, dtype, strides, padPerCol, isLast = true) {
+ const storagePerElement = dtype === 'complex64' ? 2 : 1;
+ const size = shape[0];
+ const rank = shape.length;
+ if (rank === 0) {
+ if (dtype === 'complex64') {
+ const complexTuple = createComplexTuples(vals);
+ return [valToString(complexTuple[0], 0, dtype)];
+ }
+ if (dtype === 'bool') {
+ return [boolNumToString(vals[0])];
+ }
+ return [vals[0].toString()];
+ }
+ if (rank === 1) {
+ if (size > FORMAT_LIMIT_NUM_VALS) {
+ const firstValsSize = FORMAT_NUM_FIRST_LAST_VALS * storagePerElement;
+ let firstVals = Array.from(vals.slice(0, firstValsSize));
+ let lastVals = Array.from(vals.slice((size - FORMAT_NUM_FIRST_LAST_VALS) * storagePerElement, size * storagePerElement));
+ if (dtype === 'complex64') {
+ firstVals = createComplexTuples(firstVals);
+ lastVals = createComplexTuples(lastVals);
+ }
+ return [
+ '[' +
+ firstVals.map((x, i) => valToString(x, padPerCol[i], dtype))
+ .join(', ') +
+ ', ..., ' +
+ lastVals
+ .map((x, i) => valToString(x, padPerCol[size - FORMAT_NUM_FIRST_LAST_VALS + i], dtype))
+ .join(', ') +
+ ']'
+ ];
+ }
+ const displayVals = dtype === 'complex64' ? createComplexTuples(vals) :
+ Array.from(vals);
+ return [
+ '[' +
+ displayVals.map((x, i) => valToString(x, padPerCol[i], dtype))
+ .join(', ') +
+ ']'
+ ];
+ }
+ // The array is rank 2 or more.
+ const subshape = shape.slice(1);
+ const substrides = strides.slice(1);
+ const stride = strides[0] * storagePerElement;
+ const lines = [];
+ if (size > FORMAT_LIMIT_NUM_VALS) {
+ for (let i = 0; i < FORMAT_NUM_FIRST_LAST_VALS; i++) {
+ const start = i * stride;
+ const end = start + stride;
+ lines.push(...subTensorToString(vals.slice(start, end), subshape, dtype, substrides, padPerCol, false /* isLast */));
+ }
+ lines.push('...');
+ for (let i = size - FORMAT_NUM_FIRST_LAST_VALS; i < size; i++) {
+ const start = i * stride;
+ const end = start + stride;
+ lines.push(...subTensorToString(vals.slice(start, end), subshape, dtype, substrides, padPerCol, i === size - 1 /* isLast */));
+ }
+ }
+ else {
+ for (let i = 0; i < size; i++) {
+ const start = i * stride;
+ const end = start + stride;
+ lines.push(...subTensorToString(vals.slice(start, end), subshape, dtype, substrides, padPerCol, i === size - 1 /* isLast */));
+ }
+ }
+ const sep = rank === 2 ? ',' : '';
+ lines[0] = '[' + lines[0] + sep;
+ for (let i = 1; i < lines.length - 1; i++) {
+ lines[i] = ' ' + lines[i] + sep;
+ }
+ let newLineSep = ',\n';
+ for (let i = 2; i < rank; i++) {
+ newLineSep += '\n';
+ }
+ lines[lines.length - 1] =
+ ' ' + lines[lines.length - 1] + ']' + (isLast ? '' : newLineSep);
+ return lines;
+}
+function createComplexTuples(vals) {
+ const complexTuples = [];
+ for (let i = 0; i < vals.length; i += 2) {
+ complexTuples.push([vals[i], vals[i + 1]]);
+ }
+ return complexTuples;
+}
+//# sourceMappingURL=tensor_format.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-core/dist/tensor.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+/**
+ * A mutable object, similar to `tf.Tensor`, that allows users to set values
+ * at locations before converting to an immutable `tf.Tensor`.
+ *
+ * See `tf.buffer` for creating a tensor buffer.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Classes'} */
+class tensor_TensorBuffer {
+ constructor(shape, dtype, values) {
+ this.dtype = dtype;
+ this.shape = shape.slice();
+ this.size = util["sizeFromShape"](shape);
+ if (values != null) {
+ const n = values.length;
+ util["assert"](n === this.size, () => `Length of values '${n}' does not match the size ` +
+ `inferred by the shape '${this.size}'.`);
+ }
+ if (dtype === 'complex64') {
+ throw new Error(`complex64 dtype TensorBuffers are not supported. Please create ` +
+ `a TensorBuffer for the real and imaginary parts separately and ` +
+ `call tf.complex(real, imag).`);
+ }
+ this.values = values || util["getArrayFromDType"](dtype, this.size);
+ this.strides = Object(util["computeStrides"])(shape);
+ }
+ /**
+ * Sets a value in the buffer at a given location.
+ *
+ * @param value The value to set.
+ * @param locs The location indices.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Creation'} */
+ set(value, ...locs) {
+ if (locs.length === 0) {
+ locs = [0];
+ }
+ util["assert"](locs.length === this.rank, () => `The number of provided coordinates (${locs.length}) must ` +
+ `match the rank (${this.rank})`);
+ const index = this.locToIndex(locs);
+ this.values[index] = value;
+ }
+ /**
+ * Returns the value in the buffer at the provided location.
+ *
+ * @param locs The location indices.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Creation'} */
+ get(...locs) {
+ if (locs.length === 0) {
+ locs = [0];
+ }
+ let i = 0;
+ for (const loc of locs) {
+ if (loc < 0 || loc >= this.shape[i]) {
+ const msg = `Requested out of range element at ${locs}. ` +
+ ` Buffer shape=${this.shape}`;
+ throw new Error(msg);
+ }
+ i++;
+ }
+ let index = locs[locs.length - 1];
+ for (let i = 0; i < locs.length - 1; ++i) {
+ index += this.strides[i] * locs[i];
+ }
+ return this.values[index];
+ }
+ locToIndex(locs) {
+ if (this.rank === 0) {
+ return 0;
+ }
+ else if (this.rank === 1) {
+ return locs[0];
+ }
+ let index = locs[locs.length - 1];
+ for (let i = 0; i < locs.length - 1; ++i) {
+ index += this.strides[i] * locs[i];
+ }
+ return index;
+ }
+ indexToLoc(index) {
+ if (this.rank === 0) {
+ return [];
+ }
+ else if (this.rank === 1) {
+ return [index];
+ }
+ const locs = new Array(this.shape.length);
+ for (let i = 0; i < locs.length - 1; ++i) {
+ locs[i] = Math.floor(index / this.strides[i]);
+ index -= locs[i] * this.strides[i];
+ }
+ locs[locs.length - 1] = index;
+ return locs;
+ }
+ get rank() {
+ return this.shape.length;
+ }
+ /**
+ * Creates an immutable `tf.Tensor` object from the buffer.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Creation'} */
+ toTensor() {
+ return trackerFn().makeTensor(this.values, this.shape, this.dtype);
+ }
+}
+// For tracking tensor creation and disposal.
+let trackerFn = null;
+// Used by chaining methods to call into ops.
+let opHandler = null;
+// Used to warn about deprecated methods.
+let deprecationWarningFn = null;
+// This here so that we can use this method on dev branches and keep the
+// functionality at master.
+// tslint:disable-next-line:no-unused-expression
+[deprecationWarningFn];
+/**
+ * An external consumer can register itself as the tensor tracker. This way
+ * the Tensor class can notify the tracker for every tensor created and
+ * disposed.
+ */
+function setTensorTracker(fn) {
+ trackerFn = fn;
+}
+/**
+ * An external consumer can register itself as the op handler. This way the
+ * Tensor class can have chaining methods that call into ops via the op
+ * handler.
+ */
+function setOpHandler(handler) {
+ opHandler = handler;
+}
+/**
+ * Sets the deprecation warning function to be used by this file. This way the
+ * Tensor class can be a leaf but still use the environment.
+ */
+function setDeprecationWarningFn(fn) {
+ deprecationWarningFn = fn;
+}
+/**
+ * A `tf.Tensor` object represents an immutable, multidimensional array of
+ * numbers that has a shape and a data type.
+ *
+ * See `tf.tensor` for details on how to create a `tf.Tensor`.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Classes'} */
+class tensor_Tensor {
+ constructor(shape, dtype, dataId, id) {
+ /** Whether this tensor has been globally kept. */
+ this.kept = false;
+ this.isDisposedInternal = false;
+ this.shape = shape.slice();
+ this.dtype = dtype || 'float32';
+ this.size = util["sizeFromShape"](shape);
+ this.strides = Object(util["computeStrides"])(shape);
+ this.dataId = dataId;
+ this.id = id;
+ this.rankType = (this.rank < 5 ? this.rank.toString() : 'higher');
+ }
+ /** Flatten a Tensor to a 1D array. */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ flatten() {
+ this.throwIfDisposed();
+ return this.as1D();
+ }
+ /** Converts a size-1 `tf.Tensor` to a `tf.Scalar`. */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ asScalar() {
+ this.throwIfDisposed();
+ util["assert"](this.size === 1, () => 'The array must have only 1 element.');
+ return this.reshape([]);
+ }
+ /** Converts a `tf.Tensor` to a `tf.Tensor1D`. */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ as1D() {
+ this.throwIfDisposed();
+ return this.reshape([this.size]);
+ }
+ /**
+ * Converts a `tf.Tensor` to a `tf.Tensor2D`.
+ *
+ * @param rows Number of rows in `tf.Tensor2D`.
+ * @param columns Number of columns in `tf.Tensor2D`.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ as2D(rows, columns) {
+ this.throwIfDisposed();
+ return this.reshape([rows, columns]);
+ }
+ /**
+ * Converts a `tf.Tensor` to a `tf.Tensor3D`.
+ *
+ * @param rows Number of rows in `tf.Tensor3D`.
+ * @param columns Number of columns in `tf.Tensor3D`.
+ * @param depth Depth of `tf.Tensor3D`.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ as3D(rows, columns, depth) {
+ this.throwIfDisposed();
+ return this.reshape([rows, columns, depth]);
+ }
+ /**
+ * Converts a `tf.Tensor` to a `tf.Tensor4D`.
+ *
+ * @param rows Number of rows in `tf.Tensor4D`.
+ * @param columns Number of columns in `tf.Tensor4D`.
+ * @param depth Depth of `tf.Tensor4D`.
+ * @param depth2 4th dimension of `tf.Tensor4D`.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ as4D(rows, columns, depth, depth2) {
+ this.throwIfDisposed();
+ return this.reshape([rows, columns, depth, depth2]);
+ }
+ /**
+ * Converts a `tf.Tensor` to a `tf.Tensor5D`.
+ *
+ * @param rows Number of rows in `tf.Tensor5D`.
+ * @param columns Number of columns in `tf.Tensor5D`.
+ * @param depth Depth of `tf.Tensor5D`.
+ * @param depth2 4th dimension of `tf.Tensor5D`.
+ * @param depth3 5th dimension of 'tf.Tensor5D'
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ as5D(rows, columns, depth, depth2, depth3) {
+ this.throwIfDisposed();
+ return this.reshape([rows, columns, depth, depth2, depth3]);
+ }
+ /**
+ * Casts a `tf.Tensor` to a specified dtype.
+ *
+ * @param dtype Data-type to cast the tensor to.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ asType(dtype) {
+ this.throwIfDisposed();
+ return opHandler.cast(this, dtype);
+ }
+ get rank() {
+ return this.shape.length;
+ }
+ /**
+ * Returns a promise of `tf.TensorBuffer` that holds the underlying data.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ async buffer() {
+ const vals = await this.data();
+ return opHandler.buffer(this.shape, this.dtype, vals);
+ }
+ /** Returns a `tf.TensorBuffer` that holds the underlying data. */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ bufferSync() {
+ return opHandler.buffer(this.shape, this.dtype, this.dataSync());
+ }
+ /**
+ * Returns the tensor data as a nested array. The transfer of data is done
+ * asynchronously.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ async array() {
+ const vals = await this.data();
+ return Object(util["toNestedArray"])(this.shape, vals);
+ }
+ /**
+ * Returns the tensor data as a nested array. The transfer of data is done
+ * synchronously.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ arraySync() {
+ return Object(util["toNestedArray"])(this.shape, this.dataSync());
+ }
+ /**
+ * Asynchronously downloads the values from the `tf.Tensor`. Returns a
+ * promise of `TypedArray` that resolves when the computation has finished.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ async data() {
+ this.throwIfDisposed();
+ const data = trackerFn().read(this.dataId);
+ if (this.dtype === 'string') {
+ const bytes = await data;
+ try {
+ return bytes.map(b => util["decodeString"](b));
+ }
+ catch (_a) {
+ throw new Error('Failed to decode the string bytes into utf-8. ' +
+ 'To get the original bytes, call tensor.bytes().');
+ }
+ }
+ return data;
+ }
+ /**
+ * Synchronously downloads the values from the `tf.Tensor`. This blocks the
+ * UI thread until the values are ready, which can cause performance issues.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ dataSync() {
+ this.throwIfDisposed();
+ const data = trackerFn().readSync(this.dataId);
+ if (this.dtype === 'string') {
+ try {
+ return data.map(b => util["decodeString"](b));
+ }
+ catch (_a) {
+ throw new Error('Failed to decode the string bytes into utf-8. ' +
+ 'To get the original bytes, call tensor.bytes().');
+ }
+ }
+ return data;
+ }
+ /** Returns the underlying bytes of the tensor's data. */
+ async bytes() {
+ this.throwIfDisposed();
+ const data = await trackerFn().read(this.dataId);
+ if (this.dtype === 'string') {
+ return data;
+ }
+ else {
+ return new Uint8Array(data.buffer);
+ }
+ }
+ /**
+ * Disposes `tf.Tensor` from memory.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ dispose() {
+ if (this.isDisposed) {
+ return;
+ }
+ trackerFn().disposeTensor(this);
+ this.isDisposedInternal = true;
+ }
+ get isDisposed() {
+ return this.isDisposedInternal;
+ }
+ throwIfDisposed() {
+ if (this.isDisposed) {
+ throw new Error(`Tensor is disposed.`);
+ }
+ }
+ /** Casts the array to type `float32` */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ toFloat() {
+ return this.asType('float32');
+ }
+ /** Casts the array to type `int32` */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ toInt() {
+ return this.asType('int32');
+ }
+ /** Casts the array to type `bool` */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ toBool() {
+ return this.asType('bool');
+ }
+ /**
+ * Prints the `tf.Tensor`. See `tf.print` for details.
+ *
+ * @param verbose Whether to print verbose information about the tensor,
+ * including dtype and size.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ print(verbose = false) {
+ return opHandler.print(this, verbose);
+ }
+ /**
+ * Reshapes the tensor into the provided shape.
+ * See `tf.reshape` for more details.
+ *
+ * @param newShape An array of integers defining the output tensor shape.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ reshape(newShape) {
+ this.throwIfDisposed();
+ return opHandler.reshape(this, newShape);
+ }
+ /**
+ * Reshapes the tensor into the shape of the provided tensor.
+ *
+ * @param x The tensor of required shape.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ reshapeAs(x) {
+ this.throwIfDisposed();
+ return this.reshape(x.shape);
+ }
+ /**
+ * Returns a `tf.Tensor` that has expanded rank, by inserting a dimension
+ * into the tensor's shape. See `tf.expandDims` for details.
+ *
+ * @param axis The dimension index at which to insert shape of 1. Defaults to
+ * 0 (the first dimension).
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ expandDims(axis = 0) {
+ return opHandler.expandDims(this, axis);
+ }
+ /**
+ * Returns a `tf.Tensor` with dimensions of size 1 removed from the shape.
+ * See `tf.squeeze` for more details.
+ *
+ * @param axis A list of numbers. If specified, only squeezes the
+ * dimensions listed. The dimension index starts at 0. It is an error to
+ * squeeze a dimension that is not 1.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ squeeze(axis) {
+ this.throwIfDisposed();
+ return opHandler.squeeze(this, axis);
+ }
+ /** Returns a copy of the tensor. See `tf.clone` for details. */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ clone() {
+ this.throwIfDisposed();
+ return opHandler.clone(this);
+ }
+ /**
+ * Returns a human-readable description of the tensor. Useful for logging.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ toString(verbose = false) {
+ const vals = this.dataSync();
+ return tensorToString(vals, this.shape, this.dtype, verbose);
+ }
+ // Below is chain API that is not exposed to docs to avoid repetition. To
+ // expose a method, move it above this comment and add @doc and jsdoc.
+ gather(indices, axis = 0) {
+ this.throwIfDisposed();
+ return opHandler.gather(this, indices, axis);
+ }
+ norm(ord = 'euclidean', axis = null, keepDims = false) {
+ this.throwIfDisposed();
+ return opHandler.norm(this, ord, axis, keepDims);
+ }
+ slice(begin, size) {
+ this.throwIfDisposed();
+ return opHandler.slice(this, begin, size);
+ }
+ reverse(axis) {
+ this.throwIfDisposed();
+ return opHandler.reverse(this, axis);
+ }
+ stack(x, axis = 0) {
+ return opHandler.stack([this, x], axis);
+ }
+ unstack(axis = 0) {
+ return opHandler.unstack(this, axis);
+ }
+ // Reduction ops.
+ all(axis = null, keepDims = false) {
+ this.throwIfDisposed();
+ return opHandler.all(this, axis, keepDims);
+ }
+ any(axis = null, keepDims = false) {
+ this.throwIfDisposed();
+ return opHandler.any(this, axis, keepDims);
+ }
+ logSumExp(axis = null, keepDims = false) {
+ this.throwIfDisposed();
+ return opHandler.logSumExp(this, axis, keepDims);
+ }
+ sum(axis = null, keepDims = false) {
+ this.throwIfDisposed();
+ return opHandler.sum(this, axis, keepDims);
+ }
+ prod(axis = null, keepDims = false) {
+ this.throwIfDisposed();
+ return opHandler.prod(this, axis, keepDims);
+ }
+ mean(axis = null, keepDims = false) {
+ this.throwIfDisposed();
+ return opHandler.mean(this, axis, keepDims);
+ }
+ min(axis = null, keepDims = false) {
+ this.throwIfDisposed();
+ return opHandler.min(this, axis, keepDims);
+ }
+ argMin(axis = null) {
+ this.throwIfDisposed();
+ return opHandler.argMin(this, axis);
+ }
+ argMax(axis = null) {
+ this.throwIfDisposed();
+ return opHandler.argMax(this, axis);
+ }
+ // Transformations
+ cast(dtype) {
+ this.throwIfDisposed();
+ return opHandler.cast(this, dtype);
+ }
+ // Binary ops.
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ addStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.addStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ subStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.subStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ powStrict(exp) {
+ this.throwIfDisposed();
+ return opHandler.powStrict(this, exp);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ mulStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.mulStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ divStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.divStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ minimumStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.minimumStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ maximumStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.maximumStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ modStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.modStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ squaredDifferenceStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.squaredDifferenceStrict(this, x);
+ }
+ // Compare ops.
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ notEqualStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.notEqualStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ lessStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.lessStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ equalStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.equalStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ lessEqualStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.lessEqualStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ greaterStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.greaterStrict(this, x);
+ }
+ /**
+ * @deprecated strict variants of ops have been deprecated
+ */
+ greaterEqualStrict(x) {
+ this.throwIfDisposed();
+ return opHandler.greaterEqualStrict(this, x);
+ }
+ // Compare ops.
+ logicalAnd(x) {
+ this.throwIfDisposed();
+ return opHandler.logicalAnd(this, x);
+ }
+ logicalOr(x) {
+ this.throwIfDisposed();
+ return opHandler.logicalOr(this, x);
+ }
+ logicalNot() {
+ this.throwIfDisposed();
+ return opHandler.logicalNot(this);
+ }
+ logicalXor(x) {
+ this.throwIfDisposed();
+ return opHandler.logicalXor(this, x);
+ }
+ where(condition, x) {
+ this.throwIfDisposed();
+ return opHandler.where(condition, this, x);
+ }
+ // Unary ops.
+ neg() {
+ this.throwIfDisposed();
+ return opHandler.neg(this);
+ }
+ ceil() {
+ this.throwIfDisposed();
+ return opHandler.ceil(this);
+ }
+ floor() {
+ this.throwIfDisposed();
+ return opHandler.floor(this);
+ }
+ sign() {
+ this.throwIfDisposed();
+ return opHandler.sign(this);
+ }
+ isNaN() {
+ this.throwIfDisposed();
+ return opHandler.isNaN(this);
+ }
+ isInf() {
+ this.throwIfDisposed();
+ return opHandler.isInf(this);
+ }
+ isFinite() {
+ this.throwIfDisposed();
+ return opHandler.isFinite(this);
+ }
+ exp() {
+ this.throwIfDisposed();
+ return opHandler.exp(this);
+ }
+ expm1() {
+ this.throwIfDisposed();
+ return opHandler.expm1(this);
+ }
+ log() {
+ this.throwIfDisposed();
+ return opHandler.log(this);
+ }
+ log1p() {
+ this.throwIfDisposed();
+ return opHandler.log1p(this);
+ }
+ sqrt() {
+ this.throwIfDisposed();
+ return opHandler.sqrt(this);
+ }
+ rsqrt() {
+ this.throwIfDisposed();
+ return opHandler.rsqrt(this);
+ }
+ square() {
+ this.throwIfDisposed();
+ return opHandler.square(this);
+ }
+ reciprocal() {
+ this.throwIfDisposed();
+ return opHandler.reciprocal(this);
+ }
+ abs() {
+ this.throwIfDisposed();
+ return opHandler.abs(this);
+ }
+ clipByValue(min, max) {
+ this.throwIfDisposed();
+ return opHandler.clipByValue(this, min, max);
+ }
+ sigmoid() {
+ this.throwIfDisposed();
+ return opHandler.sigmoid(this);
+ }
+ logSigmoid() {
+ this.throwIfDisposed();
+ return opHandler.logSigmoid(this);
+ }
+ softplus() {
+ this.throwIfDisposed();
+ return opHandler.softplus(this);
+ }
+ zerosLike() {
+ this.throwIfDisposed();
+ return opHandler.zerosLike(this);
+ }
+ onesLike() {
+ this.throwIfDisposed();
+ return opHandler.onesLike(this);
+ }
+ sin() {
+ this.throwIfDisposed();
+ return opHandler.sin(this);
+ }
+ cos() {
+ this.throwIfDisposed();
+ return opHandler.cos(this);
+ }
+ tan() {
+ this.throwIfDisposed();
+ return opHandler.tan(this);
+ }
+ asin() {
+ this.throwIfDisposed();
+ return opHandler.asin(this);
+ }
+ acos() {
+ this.throwIfDisposed();
+ return opHandler.acos(this);
+ }
+ atan() {
+ this.throwIfDisposed();
+ return opHandler.atan(this);
+ }
+ sinh() {
+ this.throwIfDisposed();
+ return opHandler.sinh(this);
+ }
+ cosh() {
+ this.throwIfDisposed();
+ return opHandler.cosh(this);
+ }
+ tanh() {
+ this.throwIfDisposed();
+ return opHandler.tanh(this);
+ }
+ asinh() {
+ this.throwIfDisposed();
+ return opHandler.asinh(this);
+ }
+ acosh() {
+ this.throwIfDisposed();
+ return opHandler.acosh(this);
+ }
+ atanh() {
+ this.throwIfDisposed();
+ return opHandler.atanh(this);
+ }
+ erf() {
+ this.throwIfDisposed();
+ return opHandler.erf(this);
+ }
+ round() {
+ this.throwIfDisposed();
+ return opHandler.round(this);
+ }
+ step(alpha = 0.0) {
+ this.throwIfDisposed();
+ return opHandler.step(this, alpha);
+ }
+ softmax(dim = -1) {
+ this.throwIfDisposed();
+ return opHandler.softmax(this, dim);
+ }
+ logSoftmax(axis = -1) {
+ this.throwIfDisposed();
+ return opHandler.logSoftmax(this, axis);
+ }
+ // Image ops.
+ resizeBilinear(newShape2D, alignCorners = false) {
+ this.throwIfDisposed();
+ return opHandler.image.resizeBilinear(this, newShape2D, alignCorners);
+ }
+ resizeNearestNeighbor(newShape2D, alignCorners = false) {
+ this.throwIfDisposed();
+ return opHandler.image.resizeNearestNeighbor(this, newShape2D, alignCorners);
+ }
+ // Pooling.
+ variable(trainable = true, name, dtype) {
+ this.throwIfDisposed();
+ return trackerFn().makeVariable(this, trainable, name, dtype);
+ }
+ unsortedSegmentSum(segmentIds, numSegments) {
+ this.throwIfDisposed();
+ return opHandler.unsortedSegmentSum(this, segmentIds, numSegments);
+ }
+ topk(k = 1, sorted = true) {
+ this.throwIfDisposed();
+ return opHandler.topk(this, k, sorted);
+ }
+ stridedSlice(begin, end, strides, beginMask = 0, endMask = 0, ellipsisMask = 0, newAxisMask = 0, shrinkAxisMask = 0) {
+ this.throwIfDisposed();
+ return opHandler.stridedSlice(this, begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask);
+ }
+ fft() {
+ this.throwIfDisposed();
+ return opHandler.spectral.fft(this);
+ }
+ ifft() {
+ this.throwIfDisposed();
+ return opHandler.spectral.ifft(this);
+ }
+ rfft() {
+ this.throwIfDisposed();
+ return opHandler.spectral.rfft(this);
+ }
+ irfft() {
+ this.throwIfDisposed();
+ return opHandler.spectral.irfft(this);
+ }
+}
+Object.defineProperty(tensor_Tensor, Symbol.hasInstance, {
+ value: (instance) => {
+ return !!instance && instance.dataId != null && instance.shape != null &&
+ instance.dtype != null;
+ }
+});
+/**
+ * A mutable `tf.Tensor`, useful for persisting state, e.g. for training.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Classes'} */
+class tensor_Variable extends tensor_Tensor {
+ constructor(initialValue, trainable, name, tensorId) {
+ super(initialValue.shape, initialValue.dtype, initialValue.dataId, tensorId);
+ this.trainable = trainable;
+ this.name = name;
+ }
+ /**
+ * Assign a new `tf.Tensor` to this variable. The new `tf.Tensor` must have
+ * the same shape and dtype as the old `tf.Tensor`.
+ *
+ * @param newValue New tensor to be assigned to this variable.
+ */
+ /** @doc {heading: 'Tensors', subheading: 'Classes'} */
+ assign(newValue) {
+ if (newValue.dtype !== this.dtype) {
+ throw new Error(`dtype of the new value (${newValue.dtype}) and ` +
+ `previous value (${this.dtype}) must match`);
+ }
+ if (!util["arraysEqual"](newValue.shape, this.shape)) {
+ throw new Error(`shape of the new value (${newValue.shape}) and ` +
+ `previous value (${this.shape}) must match`);
+ }
+ trackerFn().disposeTensor(this);
+ this.dataId = newValue.dataId;
+ trackerFn().incRef(this, null /* backend */);
+ }
+ dispose() {
+ trackerFn().disposeVariable(this);
+ this.isDisposedInternal = true;
+ }
+}
+Object.defineProperty(tensor_Variable, Symbol.hasInstance, {
+ value: (instance) => {
+ return instance instanceof tensor_Tensor && instance.assign != null &&
+ instance.assign instanceof Function;
+ }
+});
+//# sourceMappingURL=tensor.js.map
+
+/***/ }),
+/* 8 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return linspace; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return ones; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return range; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return scalar; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return tensor; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return tensor1d; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return tensor2d; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return tensor3d; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return tensor4d; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return tensor5d; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return tensor6d; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return variable; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return zeros; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return onesLike; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return zerosLike; });
+/* harmony import */ var _engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
+/* harmony import */ var _environment__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
+/* harmony import */ var _tensor_util_env__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1);
+/* harmony import */ var _complex__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(18);
+/* harmony import */ var _imag__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(25);
+/* harmony import */ var _operation__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(4);
+/* harmony import */ var _real__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(22);
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+/**
+ * Creates a `tf.Tensor` with the provided values, shape and dtype.
+ *
+ * ```js
+ * // Pass an array of values to create a vector.
+ * tf.tensor([1, 2, 3, 4]).print();
+ * ```
+ *
+ * ```js
+ * // Pass a nested array of values to make a matrix or a higher
+ * // dimensional tensor.
+ * tf.tensor([[1, 2], [3, 4]]).print();
+ * ```
+ *
+ * ```js
+ * // Pass a flat array and specify a shape yourself.
+ * tf.tensor([1, 2, 3, 4], [2, 2]).print();
+ * ```
+ *
+ * @param values The values of the tensor. Can be nested array of numbers,
+ * or a flat array, or a `TypedArray`. If the values are strings,
+ * they will be encoded as utf-8 and kept as `Uint8Array[]`.
+ * @param shape The shape of the tensor. Optional. If not provided,
+ * it is inferred from `values`.
+ * @param dtype The data type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function tensor(values, shape, dtype) {
+ const inferredShape = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* inferShape */ "c"])(values, dtype);
+ return makeTensor(values, shape, inferredShape, dtype);
+}
+/** This is shared code across all tensor creation methods. */
+function makeTensor(values, shape, inferredShape, dtype) {
+ if (dtype == null) {
+ dtype = Object(_util__WEBPACK_IMPORTED_MODULE_3__["inferDtype"])(values);
+ }
+ if (dtype === 'complex64') {
+ throw new Error(`Cannot construct a complex64 tensor directly. ` +
+ `Please use tf.complex(real, imag).`);
+ }
+ if (!Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(values) && !Array.isArray(values) &&
+ typeof values !== 'number' && typeof values !== 'boolean' &&
+ typeof values !== 'string') {
+ throw new Error('values passed to tensor(values) must be a number/boolean/string or ' +
+ 'an array of numbers/booleans/strings, or a TypedArray');
+ }
+ if (shape != null) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assertNonNegativeIntegerDimensions"])(shape);
+ const providedSize = Object(_util__WEBPACK_IMPORTED_MODULE_3__["sizeFromShape"])(shape);
+ const inferredSize = Object(_util__WEBPACK_IMPORTED_MODULE_3__["sizeFromShape"])(inferredShape);
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assert"])(providedSize === inferredSize, () => `Based on the provided shape, [${shape}], the tensor should have ` +
+ `${providedSize} values but has ${inferredSize}`);
+ for (let i = 0; i < inferredShape.length; ++i) {
+ const inferred = inferredShape[i];
+ const flatDimsDontMatch = i === inferredShape.length - 1 ?
+ inferred !== Object(_util__WEBPACK_IMPORTED_MODULE_3__["sizeFromShape"])(shape.slice(i)) :
+ true;
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assert"])(inferredShape[i] === shape[i] || !flatDimsDontMatch, () => `Error creating a new Tensor. Inferred shape ` +
+ `(${inferredShape}) does not match the provided ` +
+ `shape (${shape}). `);
+ }
+ }
+ if (!Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(values) && !Array.isArray(values)) {
+ values = [values];
+ }
+ shape = shape || inferredShape;
+ values = dtype !== 'string' ?
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["toTypedArray"])(values, dtype, Object(_environment__WEBPACK_IMPORTED_MODULE_1__[/* env */ "c"])().getBool('DEBUG')) :
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["flatten"])(values, [], true);
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].makeTensor(values, shape, dtype);
+}
+/**
+ * Creates rank-0 `tf.Tensor` (scalar) with the provided value and dtype.
+ *
+ * The same functionality can be achieved with `tf.tensor`, but in general
+ * we recommend using `tf.scalar` as it makes the code more readable.
+ *
+ * ```js
+ * tf.scalar(3.14).print();
+ * ```
+ *
+ * @param value The value of the scalar.
+ * @param dtype The data type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function scalar(value, dtype) {
+ if (((Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(value) && dtype !== 'string') || Array.isArray(value)) &&
+ dtype !== 'complex64') {
+ throw new Error('Error creating a new Scalar: value must be a primitive ' +
+ '(number|boolean|string)');
+ }
+ if (dtype === 'string' && Object(_util__WEBPACK_IMPORTED_MODULE_3__["isTypedArray"])(value) &&
+ !(value instanceof Uint8Array)) {
+ throw new Error('When making a scalar from encoded string, ' +
+ 'the value must be `Uint8Array`.');
+ }
+ const shape = [];
+ const inferredShape = [];
+ return makeTensor(value, shape, inferredShape, dtype);
+}
+/**
+ * Creates rank-1 `tf.Tensor` with the provided values, shape and dtype.
+ *
+ * The same functionality can be achieved with `tf.tensor`, but in general
+ * we recommend using `tf.tensor1d` as it makes the code more readable.
+ *
+ * ```js
+ * tf.tensor1d([1, 2, 3]).print();
+ * ```
+ *
+ * @param values The values of the tensor. Can be array of numbers,
+ * or a `TypedArray`.
+ * @param dtype The data type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function tensor1d(values, dtype) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assertNonNull"])(values);
+ const inferredShape = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* inferShape */ "c"])(values, dtype);
+ if (inferredShape.length !== 1) {
+ throw new Error('tensor1d() requires values to be a flat/TypedArray');
+ }
+ const shape = null;
+ return makeTensor(values, shape, inferredShape, dtype);
+}
+/**
+ * Creates rank-2 `tf.Tensor` with the provided values, shape and dtype.
+ *
+ * The same functionality can be achieved with `tf.tensor`, but in general
+ * we recommend using `tf.tensor2d` as it makes the code more readable.
+ *
+ * ```js
+ * // Pass a nested array.
+ * tf.tensor2d([[1, 2], [3, 4]]).print();
+ * ```
+ * ```js
+ * // Pass a flat array and specify a shape.
+ * tf.tensor2d([1, 2, 3, 4], [2, 2]).print();
+ * ```
+ *
+ * @param values The values of the tensor. Can be nested array of numbers,
+ * or a flat array, or a `TypedArray`.
+ * @param shape The shape of the tensor. If not provided, it is inferred from
+ * `values`.
+ * @param dtype The data type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function tensor2d(values, shape, dtype) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assertNonNull"])(values);
+ if (shape != null && shape.length !== 2) {
+ throw new Error('tensor2d() requires shape to have two numbers');
+ }
+ const inferredShape = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* inferShape */ "c"])(values, dtype);
+ if (inferredShape.length !== 2 && inferredShape.length !== 1) {
+ throw new Error('tensor2d() requires values to be number[][] or flat/TypedArray');
+ }
+ if (inferredShape.length === 1 && shape == null) {
+ throw new Error('tensor2d() requires shape to be provided when `values` ' +
+ 'are a flat/TypedArray');
+ }
+ return makeTensor(values, shape, inferredShape, dtype);
+}
+/**
+ * Creates rank-3 `tf.Tensor` with the provided values, shape and dtype.
+ *
+ * The same functionality can be achieved with `tf.tensor`, but in general
+ * we recommend using `tf.tensor3d` as it makes the code more readable.
+ *
+ * ```js
+ * // Pass a nested array.
+ * tf.tensor3d([[[1], [2]], [[3], [4]]]).print();
+ * ```
+ * ```js
+ * // Pass a flat array and specify a shape.
+ * tf.tensor3d([1, 2, 3, 4], [2, 2, 1]).print();
+ * ```
+ *
+ * @param values The values of the tensor. Can be nested array of numbers,
+ * or a flat array, or a `TypedArray`.
+ * @param shape The shape of the tensor. If not provided, it is inferred from
+ * `values`.
+ * @param dtype The data type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function tensor3d(values, shape, dtype) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assertNonNull"])(values);
+ if (shape != null && shape.length !== 3) {
+ throw new Error('tensor3d() requires shape to have three numbers');
+ }
+ const inferredShape = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* inferShape */ "c"])(values, dtype);
+ if (inferredShape.length !== 3 && inferredShape.length !== 1) {
+ throw new Error('tensor3d() requires values to be number[][][] or flat/TypedArray');
+ }
+ if (inferredShape.length === 1 && shape == null) {
+ throw new Error('tensor3d() requires shape to be provided when `values` ' +
+ 'are a flat array');
+ }
+ return makeTensor(values, shape, inferredShape, dtype);
+}
+/**
+ * Creates rank-4 `tf.Tensor` with the provided values, shape and dtype.
+ *
+ * The same functionality can be achieved with `tf.tensor`, but in general
+ * we recommend using `tf.tensor4d` as it makes the code more readable.
+ *
+ * ```js
+ * // Pass a nested array.
+ * tf.tensor4d([[[[1], [2]], [[3], [4]]]]).print();
+ * ```
+ * ```js
+ * // Pass a flat array and specify a shape.
+ * tf.tensor4d([1, 2, 3, 4], [1, 2, 2, 1]).print();
+ * ```
+ *
+ * @param values The values of the tensor. Can be nested array of numbers,
+ * or a flat array, or a `TypedArray`.
+ * @param shape The shape of the tensor. Optional. If not provided,
+ * it is inferred from `values`.
+ * @param dtype The data type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function tensor4d(values, shape, dtype) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assertNonNull"])(values);
+ if (shape != null && shape.length !== 4) {
+ throw new Error('tensor4d() requires shape to have four numbers');
+ }
+ const inferredShape = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* inferShape */ "c"])(values, dtype);
+ if (inferredShape.length !== 4 && inferredShape.length !== 1) {
+ throw new Error('tensor4d() requires values to be number[][][][] or flat/TypedArray');
+ }
+ if (inferredShape.length === 1 && shape == null) {
+ throw new Error('tensor4d() requires shape to be provided when `values` ' +
+ 'are a flat array');
+ }
+ return makeTensor(values, shape, inferredShape, dtype);
+}
+/**
+ * Creates rank-5 `tf.Tensor` with the provided values, shape and dtype.
+ *
+ * The same functionality can be achieved with `tf.tensor`, but in general
+ * we recommend using `tf.tensor5d` as it makes the code more readable.
+ *
+ * ```js
+ * // Pass a nested array.
+ * tf.tensor5d([[[[[1], [2]], [[3], [4]]]]]).print();
+ * ```
+ * ```js
+ * // Pass a flat array and specify a shape.
+ * tf.tensor5d([1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 2, 2, 1]).print();
+ * ```
+ *
+ * @param values The values of the tensor. Can be nested array of numbers,
+ * or a flat array, or a `TypedArray`.
+ * @param shape The shape of the tensor. Optional. If not provided,
+ * it is inferred from `values`.
+ * @param dtype The data type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function tensor5d(values, shape, dtype) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assertNonNull"])(values);
+ if (shape != null && shape.length !== 5) {
+ throw new Error('tensor5d() requires shape to have five numbers');
+ }
+ const inferredShape = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* inferShape */ "c"])(values, dtype);
+ if (inferredShape.length !== 5 && inferredShape.length !== 1) {
+ throw new Error('tensor5d() requires values to be ' +
+ 'number[][][][][] or flat/TypedArray');
+ }
+ if (inferredShape.length === 1 && shape == null) {
+ throw new Error('tensor5d() requires shape to be provided when `values` ' +
+ 'are a flat array');
+ }
+ return makeTensor(values, shape, inferredShape, dtype);
+}
+/**
+ * Creates rank-6 `tf.Tensor` with the provided values, shape and dtype.
+ *
+ * The same functionality can be achieved with `tf.tensor`, but in general
+ * we recommend using `tf.tensor6d` as it makes the code more readable.
+ *
+ * ```js
+ * // Pass a nested array.
+ * tf.tensor6d([[[[[[1],[2]],[[3],[4]]],[[[5],[6]],[[7],[8]]]]]]).print();
+ * ```
+ * ```js
+ * // Pass a flat array and specify a shape.
+ * tf.tensor6d([1, 2, 3, 4, 5, 6, 7, 8], [1, 1, 2, 2, 2, 1]).print();
+ * ```
+ *
+ * @param values The values of the tensor. Can be nested array of numbers,
+ * or a flat array, or a `TypedArray`.
+ * @param shape The shape of the tensor. Optional. If not provided,
+ * it is inferred from `values`.
+ * @param dtype The data type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function tensor6d(values, shape, dtype) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_3__["assertNonNull"])(values);
+ if (shape != null && shape.length !== 6) {
+ throw new Error('tensor6d() requires shape to have six numbers');
+ }
+ const inferredShape = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* inferShape */ "c"])(values, dtype);
+ if (inferredShape.length !== 6 && inferredShape.length !== 1) {
+ throw new Error('tensor6d() requires values to be number[][][][][][] or ' +
+ 'flat/TypedArray');
+ }
+ if (inferredShape.length === 1 && shape == null) {
+ throw new Error('tensor6d() requires shape to be provided when `values` ' +
+ 'are a flat array');
+ }
+ shape = shape ||
+ inferredShape;
+ return makeTensor(values, shape, inferredShape, dtype);
+}
+/**
+ * Creates a new variable with the provided initial value.
+ * ```js
+ * const x = tf.variable(tf.tensor([1, 2, 3]));
+ * x.assign(tf.tensor([4, 5, 6]));
+ *
+ * x.print();
+ * ```
+ *
+ * @param initialValue Initial value for the tensor.
+ * @param trainable If true, optimizers are allowed to update it.
+ * @param name Name of the variable. Defaults to a unique id.
+ * @param dtype If set, initialValue will be converted to the given type.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function variable(initialValue, trainable = true, name, dtype) {
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].makeVariable(initialValue, trainable, name, dtype);
+}
+/**
+ * Creates a `tf.Tensor` with all elements set to 1.
+ *
+ * ```js
+ * tf.ones([2, 2]).print();
+ * ```
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param dtype The type of an element in the resulting tensor. Defaults to
+ * 'float'.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function ones(shape, dtype = 'float32') {
+ if (dtype === 'complex64') {
+ const real = ones(shape, 'float32');
+ const imag = zeros(shape, 'float32');
+ return Object(_complex__WEBPACK_IMPORTED_MODULE_4__[/* complex */ "a"])(real, imag);
+ }
+ const values = Object(_util__WEBPACK_IMPORTED_MODULE_3__["makeOnesTypedArray"])(Object(_util__WEBPACK_IMPORTED_MODULE_3__["sizeFromShape"])(shape), dtype);
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].makeTensor(values, shape, dtype);
+}
+/**
+ * Creates a `tf.Tensor` with all elements set to 0.
+ *
+ * ```js
+ * tf.zeros([2, 2]).print();
+ * ```
+ *
+ * @param shape An array of integers defining the output tensor shape.
+ * @param dtype The type of an element in the resulting tensor. Can
+ * be 'float32', 'int32' or 'bool'. Defaults to 'float'.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function zeros(shape, dtype = 'float32') {
+ if (dtype === 'complex64') {
+ const real = zeros(shape, 'float32');
+ const imag = zeros(shape, 'float32');
+ return Object(_complex__WEBPACK_IMPORTED_MODULE_4__[/* complex */ "a"])(real, imag);
+ }
+ const values = Object(_util__WEBPACK_IMPORTED_MODULE_3__["makeZerosTypedArray"])(Object(_util__WEBPACK_IMPORTED_MODULE_3__["sizeFromShape"])(shape), dtype);
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].makeTensor(values, shape, dtype);
+}
+/**
+ * Creates a `tf.Tensor` with all elements set to 1 with the same shape as the
+ * given tensor.
+ *
+ * ```js
+ * const x = tf.tensor([1, 2]);
+ * tf.onesLike(x).print();
+ * ```
+ * @param x A tensor.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function onesLike_(x) {
+ const $x = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* convertToTensor */ "a"])(x, 'x', 'onesLike');
+ if ($x.dtype === 'complex64') {
+ const r = onesLike(Object(_real__WEBPACK_IMPORTED_MODULE_7__[/* real */ "a"])($x));
+ const i = zerosLike(Object(_imag__WEBPACK_IMPORTED_MODULE_5__[/* imag */ "a"])($x));
+ return Object(_complex__WEBPACK_IMPORTED_MODULE_4__[/* complex */ "a"])(r, i);
+ }
+ const der = (dy, saved) => ({ x: () => zerosLike(dy) });
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].runKernelFunc(backend => backend.onesLike($x), { x: $x }, der, 'OnesLike');
+}
+/**
+ * Creates a `tf.Tensor` with all elements set to 0 with the same shape as the
+ * given tensor.
+ *
+ * ```js
+ * const x = tf.tensor([1, 2]);
+ * tf.zerosLike(x).print();
+ * ```
+ *
+ * @param x The tensor of required shape.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function zerosLike_(x) {
+ const $x = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* convertToTensor */ "a"])(x, 'x', 'zerosLike');
+ const der = (dy, saved) => ({ x: () => zerosLike(dy) });
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].runKernelFunc(backend => backend.zerosLike($x), { x: $x }, der, 'ZerosLike');
+}
+/**
+ * Return an evenly spaced sequence of numbers over the given interval.
+ *
+ * ```js
+ * tf.linspace(0, 9, 10).print();
+ * ```
+ * @param start The start value of the sequence.
+ * @param stop The end value of the sequence.
+ * @param num The number of values to generate.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function linspace(start, stop, num) {
+ if (num <= 0) {
+ throw new Error('The number of values should be positive.');
+ }
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].runKernelFunc(backend => backend.linspace(start, stop, num), {});
+}
+/**
+ * Creates a new `tf.Tensor1D` filled with the numbers in the range provided.
+ *
+ * The tensor is a is half-open interval meaning it includes start, but
+ * excludes stop. Decrementing ranges and negative step values are also
+ * supported.
+ *
+ * ```js
+ * tf.range(0, 9, 2).print();
+ * ```
+ *
+ * @param start An integer start value
+ * @param stop An integer stop value
+ * @param step An integer increment (will default to 1 or -1)
+ * @param dtype The data type of the output tensor. Defaults to 'float32'.
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function range(start, stop, step = 1, dtype = 'float32') {
+ if (step === 0) {
+ throw new Error('Cannot have a step of zero');
+ }
+ const sameStartStop = start === stop;
+ const increasingRangeNegativeStep = start < stop && step < 0;
+ const decreasingRangePositiveStep = stop < start && step > 1;
+ if (sameStartStop || increasingRangeNegativeStep ||
+ decreasingRangePositiveStep) {
+ return zeros([0], dtype);
+ }
+ const numElements = Math.abs(Math.ceil((stop - start) / step));
+ const values = Object(_util__WEBPACK_IMPORTED_MODULE_3__["makeZerosTypedArray"])(numElements, dtype);
+ if (stop < start && step === 1) {
+ // Auto adjust the step's sign if it hasn't been set
+ // (or was set to 1)
+ step = -1;
+ }
+ values[0] = start;
+ for (let i = 1; i < values.length; i++) {
+ values[i] = values[i - 1] + step;
+ }
+ return tensor1d(values, dtype);
+}
+
+const onesLike = Object(_operation__WEBPACK_IMPORTED_MODULE_6__[/* op */ "a"])({ onesLike_ });
+const zerosLike = Object(_operation__WEBPACK_IMPORTED_MODULE_6__[/* op */ "a"])({ zerosLike_ });
+//# sourceMappingURL=tensor_ops.js.map
+
+/***/ }),
+/* 9 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return assertNotComplex; });
+/* harmony import */ var _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function assertNotComplex(tensor, opName) {
+ if (!Array.isArray(tensor)) {
+ tensor = [tensor];
+ }
+ tensor.forEach(t => {
+ if (t != null) {
+ _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].assert(t.dtype !== 'complex64', () => `${opName} does not support complex64 tensors in the CPU backend.`);
+ }
+ });
+}
+//# sourceMappingURL=cpu_util.js.map
+
+/***/ }),
+/* 10 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return Environment; });
+/* unused harmony export getQueryParams */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return env; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ENV; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return setEnvironmentGlobal; });
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// Expects flags from URL in the format ?tfjsflags=FLAG1:1,FLAG2:true.
+const TENSORFLOWJS_FLAGS_PREFIX = 'tfjsflags';
+/**
+ * The environment contains evaluated flags as well as the registered platform.
+ * This is always used as a global singleton and can be retrieved with
+ * `tf.env()`.
+ */
+/** @doc {heading: 'Environment'} */
+class Environment {
+ // tslint:disable-next-line: no-any
+ constructor(global) {
+ this.global = global;
+ this.flags = {};
+ this.flagRegistry = {};
+ this.urlFlags = {};
+ this.populateURLFlags();
+ }
+ setPlatform(platformName, platform) {
+ if (this.platform != null) {
+ console.warn(`Platform ${this.platformName} has already been set. ` +
+ `Overwriting the platform with ${platform}.`);
+ }
+ this.platformName = platformName;
+ this.platform = platform;
+ }
+ registerFlag(flagName, evaluationFn, setHook) {
+ this.flagRegistry[flagName] = { evaluationFn, setHook };
+ // Override the flag value from the URL. This has to happen here because the
+ // environment is initialized before flags get registered.
+ if (this.urlFlags[flagName] != null) {
+ const flagValue = this.urlFlags[flagName];
+ console.warn(`Setting feature override from URL ${flagName}: ${flagValue}.`);
+ this.set(flagName, flagValue);
+ }
+ }
+ async getAsync(flagName) {
+ if (flagName in this.flags) {
+ return this.flags[flagName];
+ }
+ this.flags[flagName] = await this.evaluateFlag(flagName);
+ return this.flags[flagName];
+ }
+ get(flagName) {
+ if (flagName in this.flags) {
+ return this.flags[flagName];
+ }
+ const flagValue = this.evaluateFlag(flagName);
+ if (flagValue instanceof Promise) {
+ throw new Error(`Flag ${flagName} cannot be synchronously evaluated. ` +
+ `Please use getAsync() instead.`);
+ }
+ this.flags[flagName] = flagValue;
+ return this.flags[flagName];
+ }
+ getNumber(flagName) {
+ return this.get(flagName);
+ }
+ getBool(flagName) {
+ return this.get(flagName);
+ }
+ getFlags() {
+ return this.flags;
+ }
+ // For backwards compatibility.
+ get features() {
+ return this.flags;
+ }
+ set(flagName, value) {
+ if (this.flagRegistry[flagName] == null) {
+ throw new Error(`Cannot set flag ${flagName} as it has not been registered.`);
+ }
+ this.flags[flagName] = value;
+ if (this.flagRegistry[flagName].setHook != null) {
+ this.flagRegistry[flagName].setHook(value);
+ }
+ }
+ evaluateFlag(flagName) {
+ if (this.flagRegistry[flagName] == null) {
+ throw new Error(`Cannot evaluate flag '${flagName}': no evaluation function found.`);
+ }
+ return this.flagRegistry[flagName].evaluationFn();
+ }
+ setFlags(flags) {
+ this.flags = Object.assign({}, flags);
+ }
+ reset() {
+ this.flags = {};
+ this.urlFlags = {};
+ this.populateURLFlags();
+ }
+ populateURLFlags() {
+ if (typeof this.global === 'undefined' ||
+ typeof this.global.location === 'undefined' ||
+ typeof this.global.location.search === 'undefined') {
+ return;
+ }
+ const urlParams = getQueryParams(this.global.location.search);
+ if (TENSORFLOWJS_FLAGS_PREFIX in urlParams) {
+ const keyValues = urlParams[TENSORFLOWJS_FLAGS_PREFIX].split(',');
+ keyValues.forEach(keyValue => {
+ const [key, value] = keyValue.split(':');
+ this.urlFlags[key] = parseValue(key, value);
+ });
+ }
+ }
+}
+function getQueryParams(queryString) {
+ const params = {};
+ queryString.replace(/[?&]([^=?&]+)(?:=([^&]*))?/g, (s, ...t) => {
+ decodeParam(params, t[0], t[1]);
+ return t.join('=');
+ });
+ return params;
+}
+function decodeParam(params, name, value) {
+ params[decodeURIComponent(name)] = decodeURIComponent(value || '');
+}
+function parseValue(flagName, value) {
+ value = value.toLowerCase();
+ if (value === 'true' || value === 'false') {
+ return value === 'true';
+ }
+ else if (`${+value}` === value) {
+ return +value;
+ }
+ throw new Error(`Could not parse value flag value ${value} for flag ${flagName}.`);
+}
+/**
+ * Returns the current environment (a global singleton).
+ *
+ * The environment object contains the evaluated feature values as well as the
+ * active platform.
+ */
+/** @doc {heading: 'Environment'} */
+function env() {
+ return ENV;
+}
+let ENV = null;
+function setEnvironmentGlobal(environment) {
+ ENV = environment;
+}
+//# sourceMappingURL=environment.js.map
+
+/***/ }),
+/* 11 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "makeTypesMatch", function() { return makeTypesMatch; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assertTypesMatch", function() { return assertTypesMatch; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isTensorInList", function() { return isTensorInList; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getTensorsInContainer", function() { return getTensorsInContainer; });
+/* harmony import */ var _tensor__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(23);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1);
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+function makeTypesMatch(a, b) {
+ if (a.dtype === b.dtype) {
+ return [a, b];
+ }
+ const dtype = Object(_types__WEBPACK_IMPORTED_MODULE_1__[/* upcastType */ "c"])(a.dtype, b.dtype);
+ return [a.cast(dtype), b.cast(dtype)];
+}
+function assertTypesMatch(a, b) {
+ Object(_util__WEBPACK_IMPORTED_MODULE_2__["assert"])(a.dtype === b.dtype, () => `The dtypes of the first(${a.dtype}) and` +
+ ` second(${b.dtype}) input must match`);
+}
+function isTensorInList(tensor, tensorList) {
+ return tensorList.some(x => x.id === tensor.id);
+}
+/**
+ * Extracts any `Tensor`s found within the provided object.
+ *
+ * @param container an object that may be a `Tensor` or may directly contain
+ * `Tensor`s, such as a `Tensor[]` or `{key: Tensor, ...}`. In general it
+ * is safe to pass any object here, except that `Promise`s are not
+ * supported.
+ * @returns An array of `Tensors` found within the passed object. If the
+ * argument is simply a `Tensor', a list containing that `Tensor` is
+ * returned. If the object is not a `Tensor` or does not
+ * contain `Tensors`, an empty list is returned.
+ */
+function getTensorsInContainer(result) {
+ const list = [];
+ const seen = new Set();
+ walkTensorContainer(result, list, seen);
+ return list;
+}
+function walkTensorContainer(container, list, seen) {
+ if (container == null) {
+ return;
+ }
+ if (container instanceof _tensor__WEBPACK_IMPORTED_MODULE_0__[/* Tensor */ "a"]) {
+ list.push(container);
+ return;
+ }
+ if (!isIterable(container)) {
+ return;
+ }
+ // Iteration over keys works also for arrays.
+ const iterable = container;
+ for (const k in iterable) {
+ const val = iterable[k];
+ if (!seen.has(val)) {
+ seen.add(val);
+ walkTensorContainer(val, list, seen);
+ }
+ }
+}
+// tslint:disable-next-line:no-any
+function isIterable(obj) {
+ return Array.isArray(obj) || typeof obj === 'object';
+}
+//# sourceMappingURL=tensor_util.js.map
+
+/***/ }),
+/* 12 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+
+var numeric = ( false)?(undefined):(exports);
+if(typeof global !== "undefined") { global.numeric = numeric; }
+
+numeric.version = "1.2.6";
+
+// 1. Utility functions
+numeric.bench = function bench (f,interval) {
+ var t1,t2,n,i;
+ if(typeof interval === "undefined") { interval = 15; }
+ n = 0.5;
+ t1 = new Date();
+ while(1) {
+ n*=2;
+ for(i=n;i>3;i-=4) { f(); f(); f(); f(); }
+ while(i>0) { f(); i--; }
+ t2 = new Date();
+ if(t2-t1 > interval) break;
+ }
+ for(i=n;i>3;i-=4) { f(); f(); f(); f(); }
+ while(i>0) { f(); i--; }
+ t2 = new Date();
+ return 1000*(3*n-1)/(t2-t1);
+}
+
+numeric._myIndexOf = (function _myIndexOf(w) {
+ var n = this.length,k;
+ for(k=0;k numeric.largeArray) { ret.push('...Large Array...'); return true; }
+ var flag = false;
+ ret.push('[');
+ for(k=0;k0) { ret.push(','); if(flag) ret.push('\n '); } flag = foo(x[k]); }
+ ret.push(']');
+ return true;
+ }
+ ret.push('{');
+ var flag = false;
+ for(k in x) { if(x.hasOwnProperty(k)) { if(flag) ret.push(',\n'); flag = true; ret.push(k); ret.push(': \n'); foo(x[k]); } }
+ ret.push('}');
+ return true;
+ }
+ foo(x);
+ return ret.join('');
+}
+
+numeric.parseDate = function parseDate(d) {
+ function foo(d) {
+ if(typeof d === 'string') { return Date.parse(d.replace(/-/g,'/')); }
+ if(!(d instanceof Array)) { throw new Error("parseDate: parameter must be arrays of strings"); }
+ var ret = [],k;
+ for(k=0;k0) {
+ ret[count] = [];
+ for(j=0;j> 2;
+ q = ((x & 3) << 4) + (y >> 4);
+ r = ((y & 15) << 2) + (z >> 6);
+ s = z & 63;
+ if(i+1>=n) { r = s = 64; }
+ else if(i+2>=n) { s = 64; }
+ ret += key.charAt(p) + key.charAt(q) + key.charAt(r) + key.charAt(s);
+ }
+ return ret;
+ }
+ function crc32Array (a,from,to) {
+ if(typeof from === "undefined") { from = 0; }
+ if(typeof to === "undefined") { to = a.length; }
+ var table = [0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+ 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+ 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+ 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+ 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+ 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+ 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+ 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+ 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+ 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+ 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+ 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+ 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+ 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+ 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+ 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+ 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+ 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+ 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+ 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+ 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+ 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+ 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+ 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+ 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+ 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+ 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+ 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+ 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+ 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+ 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+ 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D];
+
+ var crc = -1, y = 0, n = a.length,i;
+
+ for (i = from; i < to; i++) {
+ y = (crc ^ a[i]) & 0xFF;
+ crc = (crc >>> 8) ^ table[y];
+ }
+
+ return crc ^ (-1);
+ }
+
+ var h = img[0].length, w = img[0][0].length, s1, s2, next,k,length,a,b,i,j,adler32,crc32;
+ var stream = [
+ 137, 80, 78, 71, 13, 10, 26, 10, // 0: PNG signature
+ 0,0,0,13, // 8: IHDR Chunk length
+ 73, 72, 68, 82, // 12: "IHDR"
+ (w >> 24) & 255, (w >> 16) & 255, (w >> 8) & 255, w&255, // 16: Width
+ (h >> 24) & 255, (h >> 16) & 255, (h >> 8) & 255, h&255, // 20: Height
+ 8, // 24: bit depth
+ 2, // 25: RGB
+ 0, // 26: deflate
+ 0, // 27: no filter
+ 0, // 28: no interlace
+ -1,-2,-3,-4, // 29: CRC
+ -5,-6,-7,-8, // 33: IDAT Chunk length
+ 73, 68, 65, 84, // 37: "IDAT"
+ // RFC 1950 header starts here
+ 8, // 41: RFC1950 CMF
+ 29 // 42: RFC1950 FLG
+ ];
+ crc32 = crc32Array(stream,12,29);
+ stream[29] = (crc32>>24)&255;
+ stream[30] = (crc32>>16)&255;
+ stream[31] = (crc32>>8)&255;
+ stream[32] = (crc32)&255;
+ s1 = 1;
+ s2 = 0;
+ for(i=0;i>8)&255;
+ stream.push(a); stream.push(b);
+ stream.push((~a)&255); stream.push((~b)&255);
+ if(i===0) stream.push(0);
+ for(j=0;j255) a = 255;
+ else if(a<0) a=0;
+ else a = Math.round(a);
+ s1 = (s1 + a )%65521;
+ s2 = (s2 + s1)%65521;
+ stream.push(a);
+ }
+ }
+ stream.push(0);
+ }
+ adler32 = (s2<<16)+s1;
+ stream.push((adler32>>24)&255);
+ stream.push((adler32>>16)&255);
+ stream.push((adler32>>8)&255);
+ stream.push((adler32)&255);
+ length = stream.length - 41;
+ stream[33] = (length>>24)&255;
+ stream[34] = (length>>16)&255;
+ stream[35] = (length>>8)&255;
+ stream[36] = (length)&255;
+ crc32 = crc32Array(stream,37);
+ stream.push((crc32>>24)&255);
+ stream.push((crc32>>16)&255);
+ stream.push((crc32>>8)&255);
+ stream.push((crc32)&255);
+ stream.push(0);
+ stream.push(0);
+ stream.push(0);
+ stream.push(0);
+// a = stream.length;
+ stream.push(73); // I
+ stream.push(69); // E
+ stream.push(78); // N
+ stream.push(68); // D
+ stream.push(174); // CRC1
+ stream.push(66); // CRC2
+ stream.push(96); // CRC3
+ stream.push(130); // CRC4
+ return 'data:image/png;base64,'+base64(stream);
+}
+
+// 2. Linear algebra with Arrays.
+numeric._dim = function _dim(x) {
+ var ret = [];
+ while(typeof x === "object") { ret.push(x.length); x = x[0]; }
+ return ret;
+}
+
+numeric.dim = function dim(x) {
+ var y,z;
+ if(typeof x === "object") {
+ y = x[0];
+ if(typeof y === "object") {
+ z = y[0];
+ if(typeof z === "object") {
+ return numeric._dim(x);
+ }
+ return [x.length,y.length];
+ }
+ return [x.length];
+ }
+ return [];
+}
+
+numeric.mapreduce = function mapreduce(body,init) {
+ return Function('x','accum','_s','_k',
+ 'if(typeof accum === "undefined") accum = '+init+';\n'+
+ 'if(typeof x === "number") { var xi = x; '+body+'; return accum; }\n'+
+ 'if(typeof _s === "undefined") _s = numeric.dim(x);\n'+
+ 'if(typeof _k === "undefined") _k = 0;\n'+
+ 'var _n = _s[_k];\n'+
+ 'var i,xi;\n'+
+ 'if(_k < _s.length-1) {\n'+
+ ' for(i=_n-1;i>=0;i--) {\n'+
+ ' accum = arguments.callee(x[i],accum,_s,_k+1);\n'+
+ ' }'+
+ ' return accum;\n'+
+ '}\n'+
+ 'for(i=_n-1;i>=1;i-=2) { \n'+
+ ' xi = x[i];\n'+
+ ' '+body+';\n'+
+ ' xi = x[i-1];\n'+
+ ' '+body+';\n'+
+ '}\n'+
+ 'if(i === 0) {\n'+
+ ' xi = x[i];\n'+
+ ' '+body+'\n'+
+ '}\n'+
+ 'return accum;'
+ );
+}
+numeric.mapreduce2 = function mapreduce2(body,setup) {
+ return Function('x',
+ 'var n = x.length;\n'+
+ 'var i,xi;\n'+setup+';\n'+
+ 'for(i=n-1;i!==-1;--i) { \n'+
+ ' xi = x[i];\n'+
+ ' '+body+';\n'+
+ '}\n'+
+ 'return accum;'
+ );
+}
+
+
+numeric.same = function same(x,y) {
+ var i,n;
+ if(!(x instanceof Array) || !(y instanceof Array)) { return false; }
+ n = x.length;
+ if(n !== y.length) { return false; }
+ for(i=0;i=0;i-=2) { ret[i+1] = v; ret[i] = v; }
+ if(i===-1) { ret[0] = v; }
+ return ret;
+ }
+ for(i=n-1;i>=0;i--) { ret[i] = numeric.rep(s,v,k+1); }
+ return ret;
+}
+
+
+numeric.dotMMsmall = function dotMMsmall(x,y) {
+ var i,j,k,p,q,r,ret,foo,bar,woo,i0,k0,p0,r0;
+ p = x.length; q = y.length; r = y[0].length;
+ ret = Array(p);
+ for(i=p-1;i>=0;i--) {
+ foo = Array(r);
+ bar = x[i];
+ for(k=r-1;k>=0;k--) {
+ woo = bar[q-1]*y[q-1][k];
+ for(j=q-2;j>=1;j-=2) {
+ i0 = j-1;
+ woo += bar[j]*y[j][k] + bar[i0]*y[i0][k];
+ }
+ if(j===0) { woo += bar[0]*y[0][k]; }
+ foo[k] = woo;
+ }
+ ret[i] = foo;
+ }
+ return ret;
+}
+numeric._getCol = function _getCol(A,j,x) {
+ var n = A.length, i;
+ for(i=n-1;i>0;--i) {
+ x[i] = A[i][j];
+ --i;
+ x[i] = A[i][j];
+ }
+ if(i===0) x[0] = A[0][j];
+}
+numeric.dotMMbig = function dotMMbig(x,y){
+ var gc = numeric._getCol, p = y.length, v = Array(p);
+ var m = x.length, n = y[0].length, A = new Array(m), xj;
+ var VV = numeric.dotVV;
+ var i,j,k,z;
+ --p;
+ --m;
+ for(i=m;i!==-1;--i) A[i] = Array(n);
+ --n;
+ for(i=n;i!==-1;--i) {
+ gc(y,i,v);
+ for(j=m;j!==-1;--j) {
+ z=0;
+ xj = x[j];
+ A[j][i] = VV(xj,v);
+ }
+ }
+ return A;
+}
+
+numeric.dotMV = function dotMV(x,y) {
+ var p = x.length, q = y.length,i;
+ var ret = Array(p), dotVV = numeric.dotVV;
+ for(i=p-1;i>=0;i--) { ret[i] = dotVV(x[i],y); }
+ return ret;
+}
+
+numeric.dotVM = function dotVM(x,y) {
+ var i,j,k,p,q,r,ret,foo,bar,woo,i0,k0,p0,r0,s1,s2,s3,baz,accum;
+ p = x.length; q = y[0].length;
+ ret = Array(q);
+ for(k=q-1;k>=0;k--) {
+ woo = x[p-1]*y[p-1][k];
+ for(j=p-2;j>=1;j-=2) {
+ i0 = j-1;
+ woo += x[j]*y[j][k] + x[i0]*y[i0][k];
+ }
+ if(j===0) { woo += x[0]*y[0][k]; }
+ ret[k] = woo;
+ }
+ return ret;
+}
+
+numeric.dotVV = function dotVV(x,y) {
+ var i,n=x.length,i1,ret = x[n-1]*y[n-1];
+ for(i=n-2;i>=1;i-=2) {
+ i1 = i-1;
+ ret += x[i]*y[i] + x[i1]*y[i1];
+ }
+ if(i===0) { ret += x[0]*y[0]; }
+ return ret;
+}
+
+numeric.dot = function dot(x,y) {
+ var d = numeric.dim;
+ switch(d(x).length*1000+d(y).length) {
+ case 2002:
+ if(y.length < 10) return numeric.dotMMsmall(x,y);
+ else return numeric.dotMMbig(x,y);
+ case 2001: return numeric.dotMV(x,y);
+ case 1002: return numeric.dotVM(x,y);
+ case 1001: return numeric.dotVV(x,y);
+ case 1000: return numeric.mulVS(x,y);
+ case 1: return numeric.mulSV(x,y);
+ case 0: return x*y;
+ default: throw new Error('numeric.dot only works on vectors and matrices');
+ }
+}
+
+numeric.diag = function diag(d) {
+ var i,i1,j,n = d.length, A = Array(n), Ai;
+ for(i=n-1;i>=0;i--) {
+ Ai = Array(n);
+ i1 = i+2;
+ for(j=n-1;j>=i1;j-=2) {
+ Ai[j] = 0;
+ Ai[j-1] = 0;
+ }
+ if(j>i) { Ai[j] = 0; }
+ Ai[i] = d[i];
+ for(j=i-1;j>=1;j-=2) {
+ Ai[j] = 0;
+ Ai[j-1] = 0;
+ }
+ if(j===0) { Ai[0] = 0; }
+ A[i] = Ai;
+ }
+ return A;
+}
+numeric.getDiag = function(A) {
+ var n = Math.min(A.length,A[0].length),i,ret = Array(n);
+ for(i=n-1;i>=1;--i) {
+ ret[i] = A[i][i];
+ --i;
+ ret[i] = A[i][i];
+ }
+ if(i===0) {
+ ret[0] = A[0][0];
+ }
+ return ret;
+}
+
+numeric.identity = function identity(n) { return numeric.diag(numeric.rep([n],1)); }
+numeric.pointwise = function pointwise(params,body,setup) {
+ if(typeof setup === "undefined") { setup = ""; }
+ var fun = [];
+ var k;
+ var avec = /\[i\]$/,p,thevec = '';
+ var haveret = false;
+ for(k=0;k=0;i--) ret[i] = arguments.callee('+params.join(',')+',_s,_k+1);\n'+
+ ' return ret;\n'+
+ '}\n'+
+ setup+'\n'+
+ 'for(i=_n-1;i!==-1;--i) {\n'+
+ ' '+body+'\n'+
+ '}\n'+
+ 'return ret;'
+ );
+ return Function.apply(null,fun);
+}
+numeric.pointwise2 = function pointwise2(params,body,setup) {
+ if(typeof setup === "undefined") { setup = ""; }
+ var fun = [];
+ var k;
+ var avec = /\[i\]$/,p,thevec = '';
+ var haveret = false;
+ for(k=0;k=0;i--) { _biforeach(typeof x==="object"?x[i]:x,typeof y==="object"?y[i]:y,s,k+1,f); }
+});
+numeric._biforeach2 = (function _biforeach2(x,y,s,k,f) {
+ if(k === s.length-1) { return f(x,y); }
+ var i,n=s[k],ret = Array(n);
+ for(i=n-1;i>=0;--i) { ret[i] = _biforeach2(typeof x==="object"?x[i]:x,typeof y==="object"?y[i]:y,s,k+1,f); }
+ return ret;
+});
+numeric._foreach = (function _foreach(x,s,k,f) {
+ if(k === s.length-1) { f(x); return; }
+ var i,n=s[k];
+ for(i=n-1;i>=0;i--) { _foreach(x[i],s,k+1,f); }
+});
+numeric._foreach2 = (function _foreach2(x,s,k,f) {
+ if(k === s.length-1) { return f(x); }
+ var i,n=s[k], ret = Array(n);
+ for(i=n-1;i>=0;i--) { ret[i] = _foreach2(x[i],s,k+1,f); }
+ return ret;
+});
+
+/*numeric.anyV = numeric.mapreduce('if(xi) return true;','false');
+numeric.allV = numeric.mapreduce('if(!xi) return false;','true');
+numeric.any = function(x) { if(typeof x.length === "undefined") return x; return numeric.anyV(x); }
+numeric.all = function(x) { if(typeof x.length === "undefined") return x; return numeric.allV(x); }*/
+
+numeric.ops2 = {
+ add: '+',
+ sub: '-',
+ mul: '*',
+ div: '/',
+ mod: '%',
+ and: '&&',
+ or: '||',
+ eq: '===',
+ neq: '!==',
+ lt: '<',
+ gt: '>',
+ leq: '<=',
+ geq: '>=',
+ band: '&',
+ bor: '|',
+ bxor: '^',
+ lshift: '<<',
+ rshift: '>>',
+ rrshift: '>>>'
+};
+numeric.opseq = {
+ addeq: '+=',
+ subeq: '-=',
+ muleq: '*=',
+ diveq: '/=',
+ modeq: '%=',
+ lshifteq: '<<=',
+ rshifteq: '>>=',
+ rrshifteq: '>>>=',
+ bandeq: '&=',
+ boreq: '|=',
+ bxoreq: '^='
+};
+numeric.mathfuns = ['abs','acos','asin','atan','ceil','cos',
+ 'exp','floor','log','round','sin','sqrt','tan',
+ 'isNaN','isFinite'];
+numeric.mathfuns2 = ['atan2','pow','max','min'];
+numeric.ops1 = {
+ neg: '-',
+ not: '!',
+ bnot: '~',
+ clone: ''
+};
+numeric.mapreducers = {
+ any: ['if(xi) return true;','var accum = false;'],
+ all: ['if(!xi) return false;','var accum = true;'],
+ sum: ['accum += xi;','var accum = 0;'],
+ prod: ['accum *= xi;','var accum = 1;'],
+ norm2Squared: ['accum += xi*xi;','var accum = 0;'],
+ norminf: ['accum = max(accum,abs(xi));','var accum = 0, max = Math.max, abs = Math.abs;'],
+ norm1: ['accum += abs(xi)','var accum = 0, abs = Math.abs;'],
+ sup: ['accum = max(accum,xi);','var accum = -Infinity, max = Math.max;'],
+ inf: ['accum = min(accum,xi);','var accum = Infinity, min = Math.min;']
+};
+
+(function () {
+ var i,o;
+ for(i=0;iv0) { i0 = i; v0 = k; } }
+ Aj = A[i0]; A[i0] = A[j]; A[j] = Aj;
+ Ij = I[i0]; I[i0] = I[j]; I[j] = Ij;
+ x = Aj[j];
+ for(k=j;k!==n;++k) Aj[k] /= x;
+ for(k=n-1;k!==-1;--k) Ij[k] /= x;
+ for(i=m-1;i!==-1;--i) {
+ if(i!==j) {
+ Ai = A[i];
+ Ii = I[i];
+ x = Ai[j];
+ for(k=j+1;k!==n;++k) Ai[k] -= Aj[k]*x;
+ for(k=n-1;k>0;--k) { Ii[k] -= Ij[k]*x; --k; Ii[k] -= Ij[k]*x; }
+ if(k===0) Ii[0] -= Ij[0]*x;
+ }
+ }
+ }
+ return I;
+}
+
+numeric.det = function det(x) {
+ var s = numeric.dim(x);
+ if(s.length !== 2 || s[0] !== s[1]) { throw new Error('numeric: det() only works on square matrices'); }
+ var n = s[0], ret = 1,i,j,k,A = numeric.clone(x),Aj,Ai,alpha,temp,k1,k2,k3;
+ for(j=0;j Math.abs(A[k][j])) { k = i; } }
+ if(k !== j) {
+ temp = A[k]; A[k] = A[j]; A[j] = temp;
+ ret *= -1;
+ }
+ Aj = A[j];
+ for(i=j+1;i=1;i-=2) {
+ A1 = x[i];
+ A0 = x[i-1];
+ for(j=n-1;j>=1;--j) {
+ Bj = ret[j]; Bj[i] = A1[j]; Bj[i-1] = A0[j];
+ --j;
+ Bj = ret[j]; Bj[i] = A1[j]; Bj[i-1] = A0[j];
+ }
+ if(j===0) {
+ Bj = ret[0]; Bj[i] = A1[0]; Bj[i-1] = A0[0];
+ }
+ }
+ if(i===0) {
+ A0 = x[0];
+ for(j=n-1;j>=1;--j) {
+ ret[j][0] = A0[j];
+ --j;
+ ret[j][0] = A0[j];
+ }
+ if(j===0) { ret[0][0] = A0[0]; }
+ }
+ return ret;
+}
+numeric.negtranspose = function negtranspose(x) {
+ var i,j,m = x.length,n = x[0].length, ret=Array(n),A0,A1,Bj;
+ for(j=0;j=1;i-=2) {
+ A1 = x[i];
+ A0 = x[i-1];
+ for(j=n-1;j>=1;--j) {
+ Bj = ret[j]; Bj[i] = -A1[j]; Bj[i-1] = -A0[j];
+ --j;
+ Bj = ret[j]; Bj[i] = -A1[j]; Bj[i-1] = -A0[j];
+ }
+ if(j===0) {
+ Bj = ret[0]; Bj[i] = -A1[0]; Bj[i-1] = -A0[0];
+ }
+ }
+ if(i===0) {
+ A0 = x[0];
+ for(j=n-1;j>=1;--j) {
+ ret[j][0] = -A0[j];
+ --j;
+ ret[j][0] = -A0[j];
+ }
+ if(j===0) { ret[0][0] = -A0[0]; }
+ }
+ return ret;
+}
+
+numeric._random = function _random(s,k) {
+ var i,n=s[k],ret=Array(n), rnd;
+ if(k === s.length-1) {
+ rnd = Math.random;
+ for(i=n-1;i>=1;i-=2) {
+ ret[i] = rnd();
+ ret[i-1] = rnd();
+ }
+ if(i===0) { ret[0] = rnd(); }
+ return ret;
+ }
+ for(i=n-1;i>=0;i--) ret[i] = _random(s,k+1);
+ return ret;
+}
+numeric.random = function random(s) { return numeric._random(s,0); }
+
+numeric.norm2 = function norm2(x) { return Math.sqrt(numeric.norm2Squared(x)); }
+
+numeric.linspace = function linspace(a,b,n) {
+ if(typeof n === "undefined") n = Math.max(Math.round(b-a)+1,1);
+ if(n<2) { return n===1?[a]:[]; }
+ var i,ret = Array(n);
+ n--;
+ for(i=n;i>=0;i--) { ret[i] = (i*b+(n-i)*a)/n; }
+ return ret;
+}
+
+numeric.getBlock = function getBlock(x,from,to) {
+ var s = numeric.dim(x);
+ function foo(x,k) {
+ var i,a = from[k], n = to[k]-a, ret = Array(n);
+ if(k === s.length-1) {
+ for(i=n;i>=0;i--) { ret[i] = x[i+a]; }
+ return ret;
+ }
+ for(i=n;i>=0;i--) { ret[i] = foo(x[i+a],k+1); }
+ return ret;
+ }
+ return foo(x,0);
+}
+
+numeric.setBlock = function setBlock(x,from,to,B) {
+ var s = numeric.dim(x);
+ function foo(x,y,k) {
+ var i,a = from[k], n = to[k]-a;
+ if(k === s.length-1) { for(i=n;i>=0;i--) { x[i+a] = y[i]; } }
+ for(i=n;i>=0;i--) { foo(x[i+a],y[i],k+1); }
+ }
+ foo(x,B,0);
+ return x;
+}
+
+numeric.getRange = function getRange(A,I,J) {
+ var m = I.length, n = J.length;
+ var i,j;
+ var B = Array(m), Bi, AI;
+ for(i=m-1;i!==-1;--i) {
+ B[i] = Array(n);
+ Bi = B[i];
+ AI = A[I[i]];
+ for(j=n-1;j!==-1;--j) Bi[j] = AI[J[j]];
+ }
+ return B;
+}
+
+numeric.blockMatrix = function blockMatrix(X) {
+ var s = numeric.dim(X);
+ if(s.length<4) return numeric.blockMatrix([X]);
+ var m=s[0],n=s[1],M,N,i,j,Xij;
+ M = 0; N = 0;
+ for(i=0;i=0;i--) {
+ Ai = Array(n);
+ xi = x[i];
+ for(j=n-1;j>=3;--j) {
+ Ai[j] = xi * y[j];
+ --j;
+ Ai[j] = xi * y[j];
+ --j;
+ Ai[j] = xi * y[j];
+ --j;
+ Ai[j] = xi * y[j];
+ }
+ while(j>=0) { Ai[j] = xi * y[j]; --j; }
+ A[i] = Ai;
+ }
+ return A;
+}
+
+// 3. The Tensor type T
+numeric.T = function T(x,y) { this.x = x; this.y = y; }
+numeric.t = function t(x,y) { return new numeric.T(x,y); }
+
+numeric.Tbinop = function Tbinop(rr,rc,cr,cc,setup) {
+ var io = numeric.indexOf;
+ if(typeof setup !== "string") {
+ var k;
+ setup = '';
+ for(k in numeric) {
+ if(numeric.hasOwnProperty(k) && (rr.indexOf(k)>=0 || rc.indexOf(k)>=0 || cr.indexOf(k)>=0 || cc.indexOf(k)>=0) && k.length>1) {
+ setup += 'var '+k+' = numeric.'+k+';\n';
+ }
+ }
+ }
+ return Function(['y'],
+ 'var x = this;\n'+
+ 'if(!(y instanceof numeric.T)) { y = new numeric.T(y); }\n'+
+ setup+'\n'+
+ 'if(x.y) {'+
+ ' if(y.y) {'+
+ ' return new numeric.T('+cc+');\n'+
+ ' }\n'+
+ ' return new numeric.T('+cr+');\n'+
+ '}\n'+
+ 'if(y.y) {\n'+
+ ' return new numeric.T('+rc+');\n'+
+ '}\n'+
+ 'return new numeric.T('+rr+');\n'
+ );
+}
+
+numeric.T.prototype.add = numeric.Tbinop(
+ 'add(x.x,y.x)',
+ 'add(x.x,y.x),y.y',
+ 'add(x.x,y.x),x.y',
+ 'add(x.x,y.x),add(x.y,y.y)');
+numeric.T.prototype.sub = numeric.Tbinop(
+ 'sub(x.x,y.x)',
+ 'sub(x.x,y.x),neg(y.y)',
+ 'sub(x.x,y.x),x.y',
+ 'sub(x.x,y.x),sub(x.y,y.y)');
+numeric.T.prototype.mul = numeric.Tbinop(
+ 'mul(x.x,y.x)',
+ 'mul(x.x,y.x),mul(x.x,y.y)',
+ 'mul(x.x,y.x),mul(x.y,y.x)',
+ 'sub(mul(x.x,y.x),mul(x.y,y.y)),add(mul(x.x,y.y),mul(x.y,y.x))');
+
+numeric.T.prototype.reciprocal = function reciprocal() {
+ var mul = numeric.mul, div = numeric.div;
+ if(this.y) {
+ var d = numeric.add(mul(this.x,this.x),mul(this.y,this.y));
+ return new numeric.T(div(this.x,d),div(numeric.neg(this.y),d));
+ }
+ return new T(div(1,this.x));
+}
+numeric.T.prototype.div = function div(y) {
+ if(!(y instanceof numeric.T)) y = new numeric.T(y);
+ if(y.y) { return this.mul(y.reciprocal()); }
+ var div = numeric.div;
+ if(this.y) { return new numeric.T(div(this.x,y.x),div(this.y,y.x)); }
+ return new numeric.T(div(this.x,y.x));
+}
+numeric.T.prototype.dot = numeric.Tbinop(
+ 'dot(x.x,y.x)',
+ 'dot(x.x,y.x),dot(x.x,y.y)',
+ 'dot(x.x,y.x),dot(x.y,y.x)',
+ 'sub(dot(x.x,y.x),dot(x.y,y.y)),add(dot(x.x,y.y),dot(x.y,y.x))'
+ );
+numeric.T.prototype.transpose = function transpose() {
+ var t = numeric.transpose, x = this.x, y = this.y;
+ if(y) { return new numeric.T(t(x),t(y)); }
+ return new numeric.T(t(x));
+}
+numeric.T.prototype.transjugate = function transjugate() {
+ var t = numeric.transpose, x = this.x, y = this.y;
+ if(y) { return new numeric.T(t(x),numeric.negtranspose(y)); }
+ return new numeric.T(t(x));
+}
+numeric.Tunop = function Tunop(r,c,s) {
+ if(typeof s !== "string") { s = ''; }
+ return Function(
+ 'var x = this;\n'+
+ s+'\n'+
+ 'if(x.y) {'+
+ ' '+c+';\n'+
+ '}\n'+
+ r+';\n'
+ );
+}
+
+numeric.T.prototype.exp = numeric.Tunop(
+ 'return new numeric.T(ex)',
+ 'return new numeric.T(mul(cos(x.y),ex),mul(sin(x.y),ex))',
+ 'var ex = numeric.exp(x.x), cos = numeric.cos, sin = numeric.sin, mul = numeric.mul;');
+numeric.T.prototype.conj = numeric.Tunop(
+ 'return new numeric.T(x.x);',
+ 'return new numeric.T(x.x,numeric.neg(x.y));');
+numeric.T.prototype.neg = numeric.Tunop(
+ 'return new numeric.T(neg(x.x));',
+ 'return new numeric.T(neg(x.x),neg(x.y));',
+ 'var neg = numeric.neg;');
+numeric.T.prototype.sin = numeric.Tunop(
+ 'return new numeric.T(numeric.sin(x.x))',
+ 'return x.exp().sub(x.neg().exp()).div(new numeric.T(0,2));');
+numeric.T.prototype.cos = numeric.Tunop(
+ 'return new numeric.T(numeric.cos(x.x))',
+ 'return x.exp().add(x.neg().exp()).div(2);');
+numeric.T.prototype.abs = numeric.Tunop(
+ 'return new numeric.T(numeric.abs(x.x));',
+ 'return new numeric.T(numeric.sqrt(numeric.add(mul(x.x,x.x),mul(x.y,x.y))));',
+ 'var mul = numeric.mul;');
+numeric.T.prototype.log = numeric.Tunop(
+ 'return new numeric.T(numeric.log(x.x));',
+ 'var theta = new numeric.T(numeric.atan2(x.y,x.x)), r = x.abs();\n'+
+ 'return new numeric.T(numeric.log(r.x),theta.x);');
+numeric.T.prototype.norm2 = numeric.Tunop(
+ 'return numeric.norm2(x.x);',
+ 'var f = numeric.norm2Squared;\n'+
+ 'return Math.sqrt(f(x.x)+f(x.y));');
+numeric.T.prototype.inv = function inv() {
+ var A = this;
+ if(typeof A.y === "undefined") { return new numeric.T(numeric.inv(A.x)); }
+ var n = A.x.length, i, j, k;
+ var Rx = numeric.identity(n),Ry = numeric.rep([n,n],0);
+ var Ax = numeric.clone(A.x), Ay = numeric.clone(A.y);
+ var Aix, Aiy, Ajx, Ajy, Rix, Riy, Rjx, Rjy;
+ var i,j,k,d,d1,ax,ay,bx,by,temp;
+ for(i=0;i d) { k=j; d = d1; }
+ }
+ if(k!==i) {
+ temp = Ax[i]; Ax[i] = Ax[k]; Ax[k] = temp;
+ temp = Ay[i]; Ay[i] = Ay[k]; Ay[k] = temp;
+ temp = Rx[i]; Rx[i] = Rx[k]; Rx[k] = temp;
+ temp = Ry[i]; Ry[i] = Ry[k]; Ry[k] = temp;
+ }
+ Aix = Ax[i]; Aiy = Ay[i];
+ Rix = Rx[i]; Riy = Ry[i];
+ ax = Aix[i]; ay = Aiy[i];
+ for(j=i+1;j0;i--) {
+ Rix = Rx[i]; Riy = Ry[i];
+ for(j=i-1;j>=0;j--) {
+ Rjx = Rx[j]; Rjy = Ry[j];
+ ax = Ax[j][i]; ay = Ay[j][i];
+ for(k=n-1;k>=0;k--) {
+ bx = Rix[k]; by = Riy[k];
+ Rjx[k] -= ax*bx - ay*by;
+ Rjy[k] -= ax*by + ay*bx;
+ }
+ }
+ }
+ return new numeric.T(Rx,Ry);
+}
+numeric.T.prototype.get = function get(i) {
+ var x = this.x, y = this.y, k = 0, ik, n = i.length;
+ if(y) {
+ while(k= 0 ? 1 : -1;
+ var alpha = s*numeric.norm2(x);
+ v[0] += alpha;
+ var foo = numeric.norm2(v);
+ if(foo === 0) { /* this should not happen */ throw new Error('eig: internal error'); }
+ return numeric.div(v,foo);
+}
+
+numeric.toUpperHessenberg = function toUpperHessenberg(me) {
+ var s = numeric.dim(me);
+ if(s.length !== 2 || s[0] !== s[1]) { throw new Error('numeric: toUpperHessenberg() only works on square matrices'); }
+ var m = s[0], i,j,k,x,v,A = numeric.clone(me),B,C,Ai,Ci,Q = numeric.identity(m),Qi;
+ for(j=0;j0) {
+ v = numeric.house(x);
+ B = numeric.getBlock(A,[j+1,j],[m-1,m-1]);
+ C = numeric.tensor(v,numeric.dot(v,B));
+ for(i=j+1;i=4*det) {
+ var s1,s2;
+ s1 = 0.5*(tr+Math.sqrt(tr*tr-4*det));
+ s2 = 0.5*(tr-Math.sqrt(tr*tr-4*det));
+ Hloc = numeric.add(numeric.sub(numeric.dot(Hloc,Hloc),
+ numeric.mul(Hloc,s1+s2)),
+ numeric.diag(numeric.rep([3],s1*s2)));
+ } else {
+ Hloc = numeric.add(numeric.sub(numeric.dot(Hloc,Hloc),
+ numeric.mul(Hloc,tr)),
+ numeric.diag(numeric.rep([3],det)));
+ }
+ x = [Hloc[0][0],Hloc[1][0],Hloc[2][0]];
+ v = numeric.house(x);
+ B = [H[0],H[1],H[2]];
+ C = numeric.tensor(v,numeric.dot(v,B));
+ for(i=0;i<3;i++) { Hi = H[i]; Ci = C[i]; for(k=0;k=0) {
+ if(p1<0) x = -0.5*(p1-sqrt(disc));
+ else x = -0.5*(p1+sqrt(disc));
+ n1 = (a-x)*(a-x)+b*b;
+ n2 = c*c+(d-x)*(d-x);
+ if(n1>n2) {
+ n1 = sqrt(n1);
+ p = (a-x)/n1;
+ q = b/n1;
+ } else {
+ n2 = sqrt(n2);
+ p = c/n2;
+ q = (d-x)/n2;
+ }
+ Q0 = new T([[q,-p],[p,q]]);
+ Q.setRows(i,j,Q0.dot(Q.getRows(i,j)));
+ } else {
+ x = -0.5*p1;
+ y = 0.5*sqrt(-disc);
+ n1 = (a-x)*(a-x)+b*b;
+ n2 = c*c+(d-x)*(d-x);
+ if(n1>n2) {
+ n1 = sqrt(n1+y*y);
+ p = (a-x)/n1;
+ q = b/n1;
+ x = 0;
+ y /= n1;
+ } else {
+ n2 = sqrt(n2+y*y);
+ p = c/n2;
+ q = (d-x)/n2;
+ x = y/n2;
+ y = 0;
+ }
+ Q0 = new T([[q,-p],[p,q]],[[x,y],[y,-x]]);
+ Q.setRows(i,j,Q0.dot(Q.getRows(i,j)));
+ }
+ }
+ }
+ var R = Q.dot(A).dot(Q.transjugate()), n = A.length, E = numeric.T.identity(n);
+ for(j=0;j0) {
+ for(k=j-1;k>=0;k--) {
+ var Rk = R.get([k,k]), Rj = R.get([j,j]);
+ if(numeric.neq(Rk.x,Rj.x) || numeric.neq(Rk.y,Rj.y)) {
+ x = R.getRow(k).getBlock([k],[j-1]);
+ y = E.getRow(j).getBlock([k],[j-1]);
+ E.set([j,k],(R.get([k,j]).neg().sub(x.dot(y))).div(Rk.sub(Rj)));
+ } else {
+ E.setRow(j,E.getRow(k));
+ continue;
+ }
+ }
+ }
+ }
+ for(j=0;j=counts.length) counts[counts.length] = 0;
+ if(foo[j]!==0) counts[j]++;
+ }
+ }
+ var n = counts.length;
+ var Ai = Array(n+1);
+ Ai[0] = 0;
+ for(i=0;i= k11) {
+ xj[n] = j[m];
+ if(m===0) return;
+ ++n;
+ --m;
+ km = k[m];
+ k11 = k1[m];
+ } else {
+ foo = Pinv[Aj[km]];
+ if(x[foo] === 0) {
+ x[foo] = 1;
+ k[m] = km;
+ ++m;
+ j[m] = foo;
+ km = Ai[foo];
+ k1[m] = k11 = Ai[foo+1];
+ } else ++km;
+ }
+ }
+}
+numeric.ccsLPSolve = function ccsLPSolve(A,B,x,xj,I,Pinv,dfs) {
+ var Ai = A[0], Aj = A[1], Av = A[2],m = Ai.length-1, n=0;
+ var Bi = B[0], Bj = B[1], Bv = B[2];
+
+ var i,i0,i1,j,J,j0,j1,k,l,l0,l1,a;
+ i0 = Bi[I];
+ i1 = Bi[I+1];
+ xj.length = 0;
+ for(i=i0;i a) { e = k; a = c; }
+ }
+ if(abs(x[i])= k11) {
+ xj[n] = Pinv[j[m]];
+ if(m===0) return;
+ ++n;
+ --m;
+ km = k[m];
+ k11 = k1[m];
+ } else {
+ foo = Aj[km];
+ if(x[foo] === 0) {
+ x[foo] = 1;
+ k[m] = km;
+ ++m;
+ j[m] = foo;
+ foo = Pinv[foo];
+ km = Ai[foo];
+ k1[m] = k11 = Ai[foo+1];
+ } else ++km;
+ }
+ }
+}
+numeric.ccsLPSolve0 = function ccsLPSolve0(A,B,y,xj,I,Pinv,P,dfs) {
+ var Ai = A[0], Aj = A[1], Av = A[2],m = Ai.length-1, n=0;
+ var Bi = B[0], Bj = B[1], Bv = B[2];
+
+ var i,i0,i1,j,J,j0,j1,k,l,l0,l1,a;
+ i0 = Bi[I];
+ i1 = Bi[I+1];
+ xj.length = 0;
+ for(i=i0;i a) { e = k; a = c; }
+ }
+ if(abs(y[P[i]]) ret[k]) ret[k] = A.length;
+ var i;
+ for(i in A) {
+ if(A.hasOwnProperty(i)) dim(A[i],ret,k+1);
+ }
+ return ret;
+};
+
+numeric.sclone = function clone(A,k,n) {
+ if(typeof k === "undefined") { k=0; }
+ if(typeof n === "undefined") { n = numeric.sdim(A).length; }
+ var i,ret = Array(A.length);
+ if(k === n-1) {
+ for(i in A) { if(A.hasOwnProperty(i)) ret[i] = A[i]; }
+ return ret;
+ }
+ for(i in A) {
+ if(A.hasOwnProperty(i)) ret[i] = clone(A[i],k+1,n);
+ }
+ return ret;
+}
+
+numeric.sdiag = function diag(d) {
+ var n = d.length,i,ret = Array(n),i1,i2,i3;
+ for(i=n-1;i>=1;i-=2) {
+ i1 = i-1;
+ ret[i] = []; ret[i][i] = d[i];
+ ret[i1] = []; ret[i1][i1] = d[i1];
+ }
+ if(i===0) { ret[0] = []; ret[0][0] = d[i]; }
+ return ret;
+}
+
+numeric.sidentity = function identity(n) { return numeric.sdiag(numeric.rep([n],1)); }
+
+numeric.stranspose = function transpose(A) {
+ var ret = [], n = A.length, i,j,Ai;
+ for(i in A) {
+ if(!(A.hasOwnProperty(i))) continue;
+ Ai = A[i];
+ for(j in Ai) {
+ if(!(Ai.hasOwnProperty(j))) continue;
+ if(typeof ret[j] !== "object") { ret[j] = []; }
+ ret[j][i] = Ai[j];
+ }
+ }
+ return ret;
+}
+
+numeric.sLUP = function LUP(A,tol) {
+ throw new Error("The function numeric.sLUP had a bug in it and has been removed. Please use the new numeric.ccsLUP function instead.");
+};
+
+numeric.sdotMM = function dotMM(A,B) {
+ var p = A.length, q = B.length, BT = numeric.stranspose(B), r = BT.length, Ai, BTk;
+ var i,j,k,accum;
+ var ret = Array(p),reti;
+ for(i=p-1;i>=0;i--) {
+ reti = [];
+ Ai = A[i];
+ for(k=r-1;k>=0;k--) {
+ accum = 0;
+ BTk = BT[k];
+ for(j in Ai) {
+ if(!(Ai.hasOwnProperty(j))) continue;
+ if(j in BTk) { accum += Ai[j]*BTk[j]; }
+ }
+ if(accum) reti[k] = accum;
+ }
+ ret[i] = reti;
+ }
+ return ret;
+}
+
+numeric.sdotMV = function dotMV(A,x) {
+ var p = A.length, Ai, i,j;
+ var ret = Array(p), accum;
+ for(i=p-1;i>=0;i--) {
+ Ai = A[i];
+ accum = 0;
+ for(j in Ai) {
+ if(!(Ai.hasOwnProperty(j))) continue;
+ if(x[j]) accum += Ai[j]*x[j];
+ }
+ if(accum) ret[i] = accum;
+ }
+ return ret;
+}
+
+numeric.sdotVM = function dotMV(x,A) {
+ var i,j,Ai,alpha;
+ var ret = [], accum;
+ for(i in x) {
+ if(!x.hasOwnProperty(i)) continue;
+ Ai = A[i];
+ alpha = x[i];
+ for(j in Ai) {
+ if(!Ai.hasOwnProperty(j)) continue;
+ if(!ret[j]) { ret[j] = 0; }
+ ret[j] += alpha*Ai[j];
+ }
+ }
+ return ret;
+}
+
+numeric.sdotVV = function dotVV(x,y) {
+ var i,ret=0;
+ for(i in x) { if(x[i] && y[i]) ret+= x[i]*y[i]; }
+ return ret;
+}
+
+numeric.sdot = function dot(A,B) {
+ var m = numeric.sdim(A).length, n = numeric.sdim(B).length;
+ var k = m*1000+n;
+ switch(k) {
+ case 0: return A*B;
+ case 1001: return numeric.sdotVV(A,B);
+ case 2001: return numeric.sdotMV(A,B);
+ case 1002: return numeric.sdotVM(A,B);
+ case 2002: return numeric.sdotMM(A,B);
+ default: throw new Error('numeric.sdot not implemented for tensors of order '+m+' and '+n);
+ }
+}
+
+numeric.sscatter = function scatter(V) {
+ var n = V[0].length, Vij, i, j, m = V.length, A = [], Aj;
+ for(i=n-1;i>=0;--i) {
+ if(!V[m-1][i]) continue;
+ Aj = A;
+ for(j=0;j=0;--i) ret[i] = [];
+ }
+ for(i=n;i>=0;--i) ret[i].push(k[i]);
+ ret[n+1].push(Ai);
+ }
+ } else gather(Ai,ret,k);
+ }
+ }
+ if(k.length>n) k.pop();
+ return ret;
+}
+
+// 6. Coordinate matrices
+numeric.cLU = function LU(A) {
+ var I = A[0], J = A[1], V = A[2];
+ var p = I.length, m=0, i,j,k,a,b,c;
+ for(i=0;im) m=I[i];
+ m++;
+ var L = Array(m), U = Array(m), left = numeric.rep([m],Infinity), right = numeric.rep([m],-Infinity);
+ var Ui, Uj,alpha;
+ for(k=0;kright[i]) right[i] = j;
+ }
+ for(i=0;i right[i+1]) right[i+1] = right[i]; }
+ for(i=m-1;i>=1;i--) { if(left[i]=0;i--) {
+ while(Uj[k] > i) {
+ ret[i] -= Uv[k]*ret[Uj[k]];
+ k--;
+ }
+ ret[i] /= Uv[k];
+ k--;
+ }
+ return ret;
+};
+
+numeric.cgrid = function grid(n,shape) {
+ if(typeof n === "number") n = [n,n];
+ var ret = numeric.rep(n,-1);
+ var i,j,count;
+ if(typeof shape !== "function") {
+ switch(shape) {
+ case 'L':
+ shape = function(i,j) { return (i>=n[0]/2 || jN) N = Ai[k]; }
+ N++;
+ ret = numeric.rep([N],0);
+ for(k=0;k1) {
+ mid = floor((p+q)/2);
+ if(x[mid] <= x0) p = mid;
+ else q = mid;
+ }
+ return this._at(x0,p);
+ }
+ var n = x0.length, i, ret = Array(n);
+ for(i=n-1;i!==-1;--i) ret[i] = this.at(x0[i]);
+ return ret;
+}
+numeric.Spline.prototype.diff = function diff() {
+ var x = this.x;
+ var yl = this.yl;
+ var yr = this.yr;
+ var kl = this.kl;
+ var kr = this.kr;
+ var n = yl.length;
+ var i,dx,dy;
+ var zl = kl, zr = kr, pl = Array(n), pr = Array(n);
+ var add = numeric.add, mul = numeric.mul, div = numeric.div, sub = numeric.sub;
+ for(i=n-1;i!==-1;--i) {
+ dx = x[i+1]-x[i];
+ dy = sub(yr[i+1],yl[i]);
+ pl[i] = div(add(mul(dy, 6),mul(kl[i],-4*dx),mul(kr[i+1],-2*dx)),dx*dx);
+ pr[i+1] = div(add(mul(dy,-6),mul(kl[i], 2*dx),mul(kr[i+1], 4*dx)),dx*dx);
+ }
+ return new numeric.Spline(x,zl,zr,pl,pr);
+}
+numeric.Spline.prototype.roots = function roots() {
+ function sqr(x) { return x*x; }
+ function heval(y0,y1,k0,k1,x) {
+ var A = k0*2-(y1-y0);
+ var B = -k1*2+(y1-y0);
+ var t = (x+1)*0.5;
+ var s = t*(1-t);
+ return (1-t)*y0+t*y1+A*s*(1-t)+B*s*t;
+ }
+ var ret = [];
+ var x = this.x, yl = this.yl, yr = this.yr, kl = this.kl, kr = this.kr;
+ if(typeof yl[0] === "number") {
+ yl = [yl];
+ yr = [yr];
+ kl = [kl];
+ kr = [kr];
+ }
+ var m = yl.length,n=x.length-1,i,j,k,y,s,t;
+ var ai,bi,ci,di, ret = Array(m),ri,k0,k1,y0,y1,A,B,D,dx,cx,stops,z0,z1,zm,t0,t1,tm;
+ var sqrt = Math.sqrt;
+ for(i=0;i!==m;++i) {
+ ai = yl[i];
+ bi = yr[i];
+ ci = kl[i];
+ di = kr[i];
+ ri = [];
+ for(j=0;j!==n;j++) {
+ if(j>0 && bi[j]*ai[j]<0) ri.push(x[j]);
+ dx = (x[j+1]-x[j]);
+ cx = x[j];
+ y0 = ai[j];
+ y1 = bi[j+1];
+ k0 = ci[j]/dx;
+ k1 = di[j+1]/dx;
+ D = sqr(k0-k1+3*(y0-y1)) + 12*k1*y0;
+ A = k1+3*y0+2*k0-3*y1;
+ B = 3*(k1+k0+2*(y0-y1));
+ if(D<=0) {
+ z0 = A/B;
+ if(z0>x[j] && z0x[j] && z0x[j] && z10) {
+ t0 = t1;
+ z0 = z1;
+ continue;
+ }
+ var side = 0;
+ while(1) {
+ tm = (z0*t1-z1*t0)/(z0-z1);
+ if(tm <= t0 || tm >= t1) { break; }
+ zm = this._at(tm,j);
+ if(zm*z1>0) {
+ t1 = tm;
+ z1 = zm;
+ if(side === -1) z0*=0.5;
+ side = -1;
+ } else if(zm*z0>0) {
+ t0 = tm;
+ z0 = zm;
+ if(side === 1) z1*=0.5;
+ side = 1;
+ } else break;
+ }
+ ri.push(tm);
+ t0 = stops[k+1];
+ z0 = this._at(t0, j);
+ }
+ if(z1 === 0) ri.push(t1);
+ }
+ ret[i] = ri;
+ }
+ if(typeof this.yl[0] === "number") return ret[0];
+ return ret;
+}
+numeric.spline = function spline(x,y,k1,kn) {
+ var n = x.length, b = [], dx = [], dy = [];
+ var i;
+ var sub = numeric.sub,mul = numeric.mul,add = numeric.add;
+ for(i=n-2;i>=0;i--) { dx[i] = x[i+1]-x[i]; dy[i] = sub(y[i+1],y[i]); }
+ if(typeof k1 === "string" || typeof kn === "string") {
+ k1 = kn = "periodic";
+ }
+ // Build sparse tridiagonal system
+ var T = [[],[],[]];
+ switch(typeof k1) {
+ case "undefined":
+ b[0] = mul(3/(dx[0]*dx[0]),dy[0]);
+ T[0].push(0,0);
+ T[1].push(0,1);
+ T[2].push(2/dx[0],1/dx[0]);
+ break;
+ case "string":
+ b[0] = add(mul(3/(dx[n-2]*dx[n-2]),dy[n-2]),mul(3/(dx[0]*dx[0]),dy[0]));
+ T[0].push(0,0,0);
+ T[1].push(n-2,0,1);
+ T[2].push(1/dx[n-2],2/dx[n-2]+2/dx[0],1/dx[0]);
+ break;
+ default:
+ b[0] = k1;
+ T[0].push(0);
+ T[1].push(0);
+ T[2].push(1);
+ break;
+ }
+ for(i=1;i20) { throw new Error("Numerical gradient fails"); }
+ x0[i] = x[i]+h;
+ f1 = f(x0);
+ x0[i] = x[i]-h;
+ f2 = f(x0);
+ x0[i] = x[i];
+ if(isNaN(f1) || isNaN(f2)) { h/=16; continue; }
+ J[i] = (f1-f2)/(2*h);
+ t0 = x[i]-h;
+ t1 = x[i];
+ t2 = x[i]+h;
+ d1 = (f1-f0)/h;
+ d2 = (f0-f2)/h;
+ N = max(abs(J[i]),abs(f0),abs(f1),abs(f2),abs(t0),abs(t1),abs(t2),1e-8);
+ errest = min(max(abs(d1-J[i]),abs(d2-J[i]),abs(d1-d2))/N,h/N);
+ if(errest>eps) { h/=16; }
+ else break;
+ }
+ }
+ return J;
+}
+
+numeric.uncmin = function uncmin(f,x0,tol,gradient,maxit,callback,options) {
+ var grad = numeric.gradient;
+ if(typeof options === "undefined") { options = {}; }
+ if(typeof tol === "undefined") { tol = 1e-8; }
+ if(typeof gradient === "undefined") { gradient = function(x) { return grad(f,x); }; }
+ if(typeof maxit === "undefined") maxit = 1000;
+ x0 = numeric.clone(x0);
+ var n = x0.length;
+ var f0 = f(x0),f1,df0;
+ if(isNaN(f0)) throw new Error('uncmin: f(x0) is a NaN!');
+ var max = Math.max, norm2 = numeric.norm2;
+ tol = max(tol,numeric.epsilon);
+ var step,g0,g1,H1 = options.Hinv || numeric.identity(n);
+ var dot = numeric.dot, inv = numeric.inv, sub = numeric.sub, add = numeric.add, ten = numeric.tensor, div = numeric.div, mul = numeric.mul;
+ var all = numeric.all, isfinite = numeric.isFinite, neg = numeric.neg;
+ var it=0,i,s,x1,y,Hy,Hs,ys,i0,t,nstep,t1,t2;
+ var msg = "";
+ g0 = gradient(x0);
+ while(it= 0.1*t*df0 || isNaN(f1)) {
+ t *= 0.5;
+ ++it;
+ continue;
+ }
+ break;
+ }
+ if(t*nstep < tol) { msg = "Line search step size smaller than tol"; break; }
+ if(it === maxit) { msg = "maxit reached during line search"; break; }
+ g1 = gradient(x1);
+ y = sub(g1,g0);
+ ys = dot(y,s);
+ Hy = dot(H1,y);
+ H1 = sub(add(H1,
+ mul(
+ (ys+dot(y,Hy))/(ys*ys),
+ ten(s,s) )),
+ div(add(ten(Hy,s),ten(s,Hy)),ys));
+ x0 = x1;
+ f0 = f1;
+ g0 = g1;
+ ++it;
+ }
+ return {solution: x0, f: f0, gradient: g0, invHessian: H1, iterations:it, message: msg};
+}
+
+// 10. Ode solver (Dormand-Prince)
+numeric.Dopri = function Dopri(x,y,f,ymid,iterations,msg,events) {
+ this.x = x;
+ this.y = y;
+ this.f = f;
+ this.ymid = ymid;
+ this.iterations = iterations;
+ this.events = events;
+ this.message = msg;
+}
+numeric.Dopri.prototype._at = function _at(xi,j) {
+ function sqr(x) { return x*x; }
+ var sol = this;
+ var xs = sol.x;
+ var ys = sol.y;
+ var k1 = sol.f;
+ var ymid = sol.ymid;
+ var n = xs.length;
+ var x0,x1,xh,y0,y1,yh,xi;
+ var floor = Math.floor,h;
+ var c = 0.5;
+ var add = numeric.add, mul = numeric.mul,sub = numeric.sub, p,q,w;
+ x0 = xs[j];
+ x1 = xs[j+1];
+ y0 = ys[j];
+ y1 = ys[j+1];
+ h = x1-x0;
+ xh = x0+c*h;
+ yh = ymid[j];
+ p = sub(k1[j ],mul(y0,1/(x0-xh)+2/(x0-x1)));
+ q = sub(k1[j+1],mul(y1,1/(x1-xh)+2/(x1-x0)));
+ w = [sqr(xi - x1) * (xi - xh) / sqr(x0 - x1) / (x0 - xh),
+ sqr(xi - x0) * sqr(xi - x1) / sqr(x0 - xh) / sqr(x1 - xh),
+ sqr(xi - x0) * (xi - xh) / sqr(x1 - x0) / (x1 - xh),
+ (xi - x0) * sqr(xi - x1) * (xi - xh) / sqr(x0-x1) / (x0 - xh),
+ (xi - x1) * sqr(xi - x0) * (xi - xh) / sqr(x0-x1) / (x1 - xh)];
+ return add(add(add(add(mul(y0,w[0]),
+ mul(yh,w[1])),
+ mul(y1,w[2])),
+ mul( p,w[3])),
+ mul( q,w[4]));
+}
+numeric.Dopri.prototype.at = function at(x) {
+ var i,j,k,floor = Math.floor;
+ if(typeof x !== "number") {
+ var n = x.length, ret = Array(n);
+ for(i=n-1;i!==-1;--i) {
+ ret[i] = this.at(x[i]);
+ }
+ return ret;
+ }
+ var x0 = this.x;
+ i = 0; j = x0.length-1;
+ while(j-i>1) {
+ k = floor(0.5*(i+j));
+ if(x0[k] <= x) i = k;
+ else j = k;
+ }
+ return this._at(x,i);
+}
+
+numeric.dopri = function dopri(x0,x1,y0,f,tol,maxit,event) {
+ if(typeof tol === "undefined") { tol = 1e-6; }
+ if(typeof maxit === "undefined") { maxit = 1000; }
+ var xs = [x0], ys = [y0], k1 = [f(x0,y0)], k2,k3,k4,k5,k6,k7, ymid = [];
+ var A2 = 1/5;
+ var A3 = [3/40,9/40];
+ var A4 = [44/45,-56/15,32/9];
+ var A5 = [19372/6561,-25360/2187,64448/6561,-212/729];
+ var A6 = [9017/3168,-355/33,46732/5247,49/176,-5103/18656];
+ var b = [35/384,0,500/1113,125/192,-2187/6784,11/84];
+ var bm = [0.5*6025192743/30085553152,
+ 0,
+ 0.5*51252292925/65400821598,
+ 0.5*-2691868925/45128329728,
+ 0.5*187940372067/1594534317056,
+ 0.5*-1776094331/19743644256,
+ 0.5*11237099/235043384];
+ var c = [1/5,3/10,4/5,8/9,1,1];
+ var e = [-71/57600,0,71/16695,-71/1920,17253/339200,-22/525,1/40];
+ var i = 0,er,j;
+ var h = (x1-x0)/10;
+ var it = 0;
+ var add = numeric.add, mul = numeric.mul, y1,erinf;
+ var max = Math.max, min = Math.min, abs = Math.abs, norminf = numeric.norminf,pow = Math.pow;
+ var any = numeric.any, lt = numeric.lt, and = numeric.and, sub = numeric.sub;
+ var e0, e1, ev;
+ var ret = new numeric.Dopri(xs,ys,k1,ymid,-1,"");
+ if(typeof event === "function") e0 = event(x0,y0);
+ while(x0x1) h = x1-x0;
+ k2 = f(x0+c[0]*h, add(y0,mul( A2*h,k1[i])));
+ k3 = f(x0+c[1]*h, add(add(y0,mul(A3[0]*h,k1[i])),mul(A3[1]*h,k2)));
+ k4 = f(x0+c[2]*h, add(add(add(y0,mul(A4[0]*h,k1[i])),mul(A4[1]*h,k2)),mul(A4[2]*h,k3)));
+ k5 = f(x0+c[3]*h, add(add(add(add(y0,mul(A5[0]*h,k1[i])),mul(A5[1]*h,k2)),mul(A5[2]*h,k3)),mul(A5[3]*h,k4)));
+ k6 = f(x0+c[4]*h,add(add(add(add(add(y0,mul(A6[0]*h,k1[i])),mul(A6[1]*h,k2)),mul(A6[2]*h,k3)),mul(A6[3]*h,k4)),mul(A6[4]*h,k5)));
+ y1 = add(add(add(add(add(y0,mul(k1[i],h*b[0])),mul(k3,h*b[2])),mul(k4,h*b[3])),mul(k5,h*b[4])),mul(k6,h*b[5]));
+ k7 = f(x0+h,y1);
+ er = add(add(add(add(add(mul(k1[i],h*e[0]),mul(k3,h*e[2])),mul(k4,h*e[3])),mul(k5,h*e[4])),mul(k6,h*e[5])),mul(k7,h*e[6]));
+ if(typeof er === "number") erinf = abs(er);
+ else erinf = norminf(er);
+ if(erinf > tol) { // reject
+ h = 0.2*h*pow(tol/erinf,0.25);
+ if(x0+h === x0) {
+ ret.msg = "Step size became too small";
+ break;
+ }
+ continue;
+ }
+ ymid[i] = add(add(add(add(add(add(y0,
+ mul(k1[i],h*bm[0])),
+ mul(k3 ,h*bm[2])),
+ mul(k4 ,h*bm[3])),
+ mul(k5 ,h*bm[4])),
+ mul(k6 ,h*bm[5])),
+ mul(k7 ,h*bm[6]));
+ ++i;
+ xs[i] = x0+h;
+ ys[i] = y1;
+ k1[i] = k7;
+ if(typeof event === "function") {
+ var yi,xl = x0,xr = x0+0.5*h,xi;
+ e1 = event(xr,ymid[i-1]);
+ ev = and(lt(e0,0),lt(0,e1));
+ if(!any(ev)) { xl = xr; xr = x0+h; e0 = e1; e1 = event(xr,y1); ev = and(lt(e0,0),lt(0,e1)); }
+ if(any(ev)) {
+ var xc, yc, en,ei;
+ var side=0, sl = 1.0, sr = 1.0;
+ while(1) {
+ if(typeof e0 === "number") xi = (sr*e1*xl-sl*e0*xr)/(sr*e1-sl*e0);
+ else {
+ xi = xr;
+ for(j=e0.length-1;j!==-1;--j) {
+ if(e0[j]<0 && e1[j]>0) xi = min(xi,(sr*e1[j]*xl-sl*e0[j]*xr)/(sr*e1[j]-sl*e0[j]));
+ }
+ }
+ if(xi <= xl || xi >= xr) break;
+ yi = ret._at(xi, i-1);
+ ei = event(xi,yi);
+ en = and(lt(e0,0),lt(0,ei));
+ if(any(en)) {
+ xr = xi;
+ e1 = ei;
+ ev = en;
+ sr = 1.0;
+ if(side === -1) sl *= 0.5;
+ else sl = 1.0;
+ side = -1;
+ } else {
+ xl = xi;
+ e0 = ei;
+ sl = 1.0;
+ if(side === 1) sr *= 0.5;
+ else sr = 1.0;
+ side = 1;
+ }
+ }
+ y1 = ret._at(0.5*(x0+xi),i-1);
+ ret.f[i] = f(xi,yi);
+ ret.x[i] = xi;
+ ret.y[i] = yi;
+ ret.ymid[i-1] = y1;
+ ret.events = ev;
+ ret.iterations = it;
+ return ret;
+ }
+ }
+ x0 += h;
+ y0 = y1;
+ e0 = e1;
+ h = min(0.8*h*pow(tol/erinf,0.25),4*h);
+ }
+ ret.iterations = it;
+ return ret;
+}
+
+// 11. Ax = b
+numeric.LU = function(A, fast) {
+ fast = fast || false;
+
+ var abs = Math.abs;
+ var i, j, k, absAjk, Akk, Ak, Pk, Ai;
+ var max;
+ var n = A.length, n1 = n-1;
+ var P = new Array(n);
+ if(!fast) A = numeric.clone(A);
+
+ for (k = 0; k < n; ++k) {
+ Pk = k;
+ Ak = A[k];
+ max = abs(Ak[k]);
+ for (j = k + 1; j < n; ++j) {
+ absAjk = abs(A[j][k]);
+ if (max < absAjk) {
+ max = absAjk;
+ Pk = j;
+ }
+ }
+ P[k] = Pk;
+
+ if (Pk != k) {
+ A[k] = A[Pk];
+ A[Pk] = Ak;
+ Ak = A[k];
+ }
+
+ Akk = Ak[k];
+
+ for (i = k + 1; i < n; ++i) {
+ A[i][k] /= Akk;
+ }
+
+ for (i = k + 1; i < n; ++i) {
+ Ai = A[i];
+ for (j = k + 1; j < n1; ++j) {
+ Ai[j] -= Ai[k] * Ak[j];
+ ++j;
+ Ai[j] -= Ai[k] * Ak[j];
+ }
+ if(j===n1) Ai[j] -= Ai[k] * Ak[j];
+ }
+ }
+
+ return {
+ LU: A,
+ P: P
+ };
+}
+
+numeric.LUsolve = function LUsolve(LUP, b) {
+ var i, j;
+ var LU = LUP.LU;
+ var n = LU.length;
+ var x = numeric.clone(b);
+ var P = LUP.P;
+ var Pi, LUi, LUii, tmp;
+
+ for (i=n-1;i!==-1;--i) x[i] = b[i];
+ for (i = 0; i < n; ++i) {
+ Pi = P[i];
+ if (P[i] !== i) {
+ tmp = x[i];
+ x[i] = x[Pi];
+ x[Pi] = tmp;
+ }
+
+ LUi = LU[i];
+ for (j = 0; j < i; ++j) {
+ x[i] -= x[j] * LUi[j];
+ }
+ }
+
+ for (i = n - 1; i >= 0; --i) {
+ LUi = LU[i];
+ for (j = i + 1; j < n; ++j) {
+ x[i] -= x[j] * LUi[j];
+ }
+
+ x[i] /= LUi[i];
+ }
+
+ return x;
+}
+
+numeric.solve = function solve(A,b,fast) { return numeric.LUsolve(numeric.LU(A,fast), b); }
+
+// 12. Linear programming
+numeric.echelonize = function echelonize(A) {
+ var s = numeric.dim(A), m = s[0], n = s[1];
+ var I = numeric.identity(m);
+ var P = Array(m);
+ var i,j,k,l,Ai,Ii,Z,a;
+ var abs = Math.abs;
+ var diveq = numeric.diveq;
+ A = numeric.clone(A);
+ for(i=0;ia1) alpha = a1;
+ g = add(c,mul(alpha,p));
+ H = dot(A1,A0);
+ for(i=m-1;i!==-1;--i) H[i][i] += 1;
+ d = solve(H,div(g,alpha),true);
+ var t0 = div(z,dot(A,d));
+ var t = 1.0;
+ for(i=n-1;i!==-1;--i) if(t0[i]<0) t = min(t,-0.999*t0[i]);
+ y = sub(x,mul(d,t));
+ z = sub(b,dot(A,y));
+ if(!all(gt(z,0))) return { solution: x, message: "", iterations: count };
+ x = y;
+ if(alpha=0) unbounded = false;
+ else unbounded = true;
+ }
+ if(unbounded) return { solution: y, message: "Unbounded", iterations: count };
+ }
+ return { solution: x, message: "maximum iteration count exceeded", iterations:count };
+}
+
+numeric._solveLP = function _solveLP(c,A,b,tol,maxit) {
+ var m = c.length, n = b.length,y;
+ var sum = numeric.sum, log = numeric.log, mul = numeric.mul, sub = numeric.sub, dot = numeric.dot, div = numeric.div, add = numeric.add;
+ var c0 = numeric.rep([m],0).concat([1]);
+ var J = numeric.rep([n,1],-1);
+ var A0 = numeric.blockMatrix([[A , J ]]);
+ var b0 = b;
+ var y = numeric.rep([m],0).concat(Math.max(0,numeric.sup(numeric.neg(b)))+1);
+ var x0 = numeric.__solveLP(c0,A0,b0,tol,maxit,y,false);
+ var x = numeric.clone(x0.solution);
+ x.length = m;
+ var foo = numeric.inf(sub(b,dot(A,x)));
+ if(foo<0) { return { solution: NaN, message: "Infeasible", iterations: x0.iterations }; }
+ var ret = numeric.__solveLP(c, A, b, tol, maxit-x0.iterations, x, true);
+ ret.iterations += x0.iterations;
+ return ret;
+};
+
+numeric.solveLP = function solveLP(c,A,b,Aeq,beq,tol,maxit) {
+ if(typeof maxit === "undefined") maxit = 1000;
+ if(typeof tol === "undefined") tol = numeric.epsilon;
+ if(typeof Aeq === "undefined") return numeric._solveLP(c,A,b,tol,maxit);
+ var m = Aeq.length, n = Aeq[0].length, o = A.length;
+ var B = numeric.echelonize(Aeq);
+ var flags = numeric.rep([n],0);
+ var P = B.P;
+ var Q = [];
+ var i;
+ for(i=P.length-1;i!==-1;--i) flags[P[i]] = 1;
+ for(i=n-1;i!==-1;--i) if(flags[i]===0) Q.push(i);
+ var g = numeric.getRange;
+ var I = numeric.linspace(0,m-1), J = numeric.linspace(0,o-1);
+ var Aeq2 = g(Aeq,I,Q), A1 = g(A,J,P), A2 = g(A,J,Q), dot = numeric.dot, sub = numeric.sub;
+ var A3 = dot(A1,B.I);
+ var A4 = sub(A2,dot(A3,Aeq2)), b4 = sub(b,dot(A3,beq));
+ var c1 = Array(P.length), c2 = Array(Q.length);
+ for(i=P.length-1;i!==-1;--i) c1[i] = c[P[i]];
+ for(i=Q.length-1;i!==-1;--i) c2[i] = c[Q[i]];
+ var c4 = sub(c2,dot(c1,dot(B.I,Aeq2)));
+ var S = numeric._solveLP(c4,A4,b4,tol,maxit);
+ var x2 = S.solution;
+ if(x2!==x2) return S;
+ var x1 = dot(B.I,sub(beq,dot(Aeq2,x2)));
+ var x = Array(c.length);
+ for(i=P.length-1;i!==-1;--i) x[P[i]] = x1[i];
+ for(i=Q.length-1;i!==-1;--i) x[Q[i]] = x2[i];
+ return { solution: x, message:S.message, iterations: S.iterations };
+}
+
+numeric.MPStoLP = function MPStoLP(MPS) {
+ if(MPS instanceof String) { MPS.split('\n'); }
+ var state = 0;
+ var states = ['Initial state','NAME','ROWS','COLUMNS','RHS','BOUNDS','ENDATA'];
+ var n = MPS.length;
+ var i,j,z,N=0,rows = {}, sign = [], rl = 0, vars = {}, nv = 0;
+ var name;
+ var c = [], A = [], b = [];
+ function err(e) { throw new Error('MPStoLP: '+e+'\nLine '+i+': '+MPS[i]+'\nCurrent state: '+states[state]+'\n'); }
+ for(i=0;i
+//
+// Math.seedrandom('yipee'); Sets Math.random to a function that is
+// initialized using the given explicit seed.
+//
+// Math.seedrandom(); Sets Math.random to a function that is
+// seeded using the current time, dom state,
+// and other accumulated local entropy.
+// The generated seed string is returned.
+//
+// Math.seedrandom('yowza', true);
+// Seeds using the given explicit seed mixed
+// together with accumulated entropy.
+//
+//
+// Seeds using physical random bits downloaded
+// from random.org.
+//
+// Seeds using urandom bits from call.jsonlib.com,
+// which is faster than random.org.
+//
+// Examples:
+//
+// Math.seedrandom("hello"); // Use "hello" as the seed.
+// document.write(Math.random()); // Always 0.5463663768140734
+// document.write(Math.random()); // Always 0.43973793770592234
+// var rng1 = Math.random; // Remember the current prng.
+//
+// var autoseed = Math.seedrandom(); // New prng with an automatic seed.
+// document.write(Math.random()); // Pretty much unpredictable.
+//
+// Math.random = rng1; // Continue "hello" prng sequence.
+// document.write(Math.random()); // Always 0.554769432473455
+//
+// Math.seedrandom(autoseed); // Restart at the previous seed.
+// document.write(Math.random()); // Repeat the 'unpredictable' value.
+//
+// Notes:
+//
+// Each time seedrandom('arg') is called, entropy from the passed seed
+// is accumulated in a pool to help generate future seeds for the
+// zero-argument form of Math.seedrandom, so entropy can be injected over
+// time by calling seedrandom with explicit data repeatedly.
+//
+// On speed - This javascript implementation of Math.random() is about
+// 3-10x slower than the built-in Math.random() because it is not native
+// code, but this is typically fast enough anyway. Seeding is more expensive,
+// especially if you use auto-seeding. Some details (timings on Chrome 4):
+//
+// Our Math.random() - avg less than 0.002 milliseconds per call
+// seedrandom('explicit') - avg less than 0.5 milliseconds per call
+// seedrandom('explicit', true) - avg less than 2 milliseconds per call
+// seedrandom() - avg about 38 milliseconds per call
+//
+// LICENSE (BSD):
+//
+// Copyright 2010 David Bau, all rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of this module nor the names of its contributors may
+// be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+/**
+ * All code is in an anonymous closure to keep the global namespace clean.
+ *
+ * @param {number=} overflow
+ * @param {number=} startdenom
+ */
+
+// Patched by Seb so that seedrandom.js does not pollute the Math object.
+// My tests suggest that doing Math.trouble = 1 makes Math lookups about 5%
+// slower.
+numeric.seedrandom = { pow:Math.pow, random:Math.random };
+
+(function (pool, math, width, chunks, significance, overflow, startdenom) {
+
+
+//
+// seedrandom()
+// This is the seedrandom function described above.
+//
+math['seedrandom'] = function seedrandom(seed, use_entropy) {
+ var key = [];
+ var arc4;
+
+ // Flatten the seed string or build one from local entropy if needed.
+ seed = mixkey(flatten(
+ use_entropy ? [seed, pool] :
+ arguments.length ? seed :
+ [new Date().getTime(), pool, window], 3), key);
+
+ // Use the seed to initialize an ARC4 generator.
+ arc4 = new ARC4(key);
+
+ // Mix the randomness into accumulated entropy.
+ mixkey(arc4.S, pool);
+
+ // Override Math.random
+
+ // This function returns a random double in [0, 1) that contains
+ // randomness in every bit of the mantissa of the IEEE 754 value.
+
+ math['random'] = function random() { // Closure to return a random double:
+ var n = arc4.g(chunks); // Start with a numerator n < 2 ^ 48
+ var d = startdenom; // and denominator d = 2 ^ 48.
+ var x = 0; // and no 'extra last byte'.
+ while (n < significance) { // Fill up all significant digits by
+ n = (n + x) * width; // shifting numerator and
+ d *= width; // denominator and generating a
+ x = arc4.g(1); // new least-significant-byte.
+ }
+ while (n >= overflow) { // To avoid rounding up, before adding
+ n /= 2; // last byte, shift everything
+ d /= 2; // right using integer math until
+ x >>>= 1; // we have exactly the desired bits.
+ }
+ return (n + x) / d; // Form the number within [0, 1).
+ };
+
+ // Return the seed that was used
+ return seed;
+};
+
+//
+// ARC4
+//
+// An ARC4 implementation. The constructor takes a key in the form of
+// an array of at most (width) integers that should be 0 <= x < (width).
+//
+// The g(count) method returns a pseudorandom integer that concatenates
+// the next (count) outputs from ARC4. Its return value is a number x
+// that is in the range 0 <= x < (width ^ count).
+//
+/** @constructor */
+function ARC4(key) {
+ var t, u, me = this, keylen = key.length;
+ var i = 0, j = me.i = me.j = me.m = 0;
+ me.S = [];
+ me.c = [];
+
+ // The empty key [] is treated as [0].
+ if (!keylen) { key = [keylen++]; }
+
+ // Set up S using the standard key scheduling algorithm.
+ while (i < width) { me.S[i] = i++; }
+ for (i = 0; i < width; i++) {
+ t = me.S[i];
+ j = lowbits(j + t + key[i % keylen]);
+ u = me.S[j];
+ me.S[i] = u;
+ me.S[j] = t;
+ }
+
+ // The "g" method returns the next (count) outputs as one number.
+ me.g = function getnext(count) {
+ var s = me.S;
+ var i = lowbits(me.i + 1); var t = s[i];
+ var j = lowbits(me.j + t); var u = s[j];
+ s[i] = u;
+ s[j] = t;
+ var r = s[lowbits(t + u)];
+ while (--count) {
+ i = lowbits(i + 1); t = s[i];
+ j = lowbits(j + t); u = s[j];
+ s[i] = u;
+ s[j] = t;
+ r = r * width + s[lowbits(t + u)];
+ }
+ me.i = i;
+ me.j = j;
+ return r;
+ };
+ // For robust unpredictability discard an initial batch of values.
+ // See http://www.rsa.com/rsalabs/node.asp?id=2009
+ me.g(width);
+}
+
+//
+// flatten()
+// Converts an object tree to nested arrays of strings.
+//
+/** @param {Object=} result
+ * @param {string=} prop
+ * @param {string=} typ */
+function flatten(obj, depth, result, prop, typ) {
+ result = [];
+ typ = typeof(obj);
+ if (depth && typ == 'object') {
+ for (prop in obj) {
+ if (prop.indexOf('S') < 5) { // Avoid FF3 bug (local/sessionStorage)
+ try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
+ }
+ }
+ }
+ return (result.length ? result : obj + (typ != 'string' ? '\0' : ''));
+}
+
+//
+// mixkey()
+// Mixes a string seed into a key that is an array of integers, and
+// returns a shortened string seed that is equivalent to the result key.
+//
+/** @param {number=} smear
+ * @param {number=} j */
+function mixkey(seed, key, smear, j) {
+ seed += ''; // Ensure the seed is a string
+ smear = 0;
+ for (j = 0; j < seed.length; j++) {
+ key[lowbits(j)] =
+ lowbits((smear ^= key[lowbits(j)] * 19) + seed.charCodeAt(j));
+ }
+ seed = '';
+ for (j in key) { seed += String.fromCharCode(key[j]); }
+ return seed;
+}
+
+//
+// lowbits()
+// A quick "n mod width" for width a power of 2.
+//
+function lowbits(n) { return n & (width - 1); }
+
+//
+// The following constants are related to IEEE 754 limits.
+//
+startdenom = math.pow(width, chunks);
+significance = math.pow(2, significance);
+overflow = significance * 2;
+
+//
+// When seedrandom.js is loaded, we immediately mix a few bits
+// from the built-in RNG into the entropy pool. Because we do
+// not want to intefere with determinstic PRNG state later,
+// seedrandom will not call math.random on its own again after
+// initialization.
+//
+mixkey(math.random(), pool);
+
+// End anonymous scope, and pass initial values.
+}(
+ [], // pool: entropy pool starts empty
+ numeric.seedrandom, // math: package containing random, pow, and seedrandom
+ 256, // width: each RC4 output is 0 <= x < 256
+ 6, // chunks: at least six RC4 outputs for each double
+ 52 // significance: there are 52 significant digits in a double
+ ));
+/* This file is a slightly modified version of quadprog.js from Alberto Santini.
+ * It has been slightly modified by Sébastien Loisel to make sure that it handles
+ * 0-based Arrays instead of 1-based Arrays.
+ * License is in resources/LICENSE.quadprog */
+(function(exports) {
+
+function base0to1(A) {
+ if(typeof A !== "object") { return A; }
+ var ret = [], i,n=A.length;
+ for(i=0;i meq) {
+ work[l] = sum;
+ } else {
+ work[l] = -Math.abs(sum);
+ if (sum > 0) {
+ for (j = 1; j <= n; j = j + 1) {
+ amat[j][i] = -amat[j][i];
+ }
+ bvec[i] = -bvec[i];
+ }
+ }
+ }
+
+ for (i = 1; i <= nact; i = i + 1) {
+ work[iwsv + iact[i]] = 0;
+ }
+
+ nvl = 0;
+ temp = 0;
+ for (i = 1; i <= q; i = i + 1) {
+ if (work[iwsv + i] < temp * work[iwnbv + i]) {
+ nvl = i;
+ temp = work[iwsv + i] / work[iwnbv + i];
+ }
+ }
+ if (nvl === 0) {
+ return 999;
+ }
+
+ return 0;
+ }
+
+ function fn_goto_55() {
+ for (i = 1; i <= n; i = i + 1) {
+ sum = 0;
+ for (j = 1; j <= n; j = j + 1) {
+ sum = sum + dmat[j][i] * amat[j][nvl];
+ }
+ work[i] = sum;
+ }
+
+ l1 = iwzv;
+ for (i = 1; i <= n; i = i + 1) {
+ work[l1 + i] = 0;
+ }
+ for (j = nact + 1; j <= n; j = j + 1) {
+ for (i = 1; i <= n; i = i + 1) {
+ work[l1 + i] = work[l1 + i] + dmat[i][j] * work[j];
+ }
+ }
+
+ t1inf = true;
+ for (i = nact; i >= 1; i = i - 1) {
+ sum = work[i];
+ l = iwrm + (i * (i + 3)) / 2;
+ l1 = l - i;
+ for (j = i + 1; j <= nact; j = j + 1) {
+ sum = sum - work[l] * work[iwrv + j];
+ l = l + j;
+ }
+ sum = sum / work[l1];
+ work[iwrv + i] = sum;
+ if (iact[i] < meq) {
+ // continue;
+ break;
+ }
+ if (sum < 0) {
+ // continue;
+ break;
+ }
+ t1inf = false;
+ it1 = i;
+ }
+
+ if (!t1inf) {
+ t1 = work[iwuv + it1] / work[iwrv + it1];
+ for (i = 1; i <= nact; i = i + 1) {
+ if (iact[i] < meq) {
+ // continue;
+ break;
+ }
+ if (work[iwrv + i] < 0) {
+ // continue;
+ break;
+ }
+ temp = work[iwuv + i] / work[iwrv + i];
+ if (temp < t1) {
+ t1 = temp;
+ it1 = i;
+ }
+ }
+ }
+
+ sum = 0;
+ for (i = iwzv + 1; i <= iwzv + n; i = i + 1) {
+ sum = sum + work[i] * work[i];
+ }
+ if (Math.abs(sum) <= vsmall) {
+ if (t1inf) {
+ ierr[1] = 1;
+ // GOTO 999
+ return 999;
+ } else {
+ for (i = 1; i <= nact; i = i + 1) {
+ work[iwuv + i] = work[iwuv + i] - t1 * work[iwrv + i];
+ }
+ work[iwuv + nact + 1] = work[iwuv + nact + 1] + t1;
+ // GOTO 700
+ return 700;
+ }
+ } else {
+ sum = 0;
+ for (i = 1; i <= n; i = i + 1) {
+ sum = sum + work[iwzv + i] * amat[i][nvl];
+ }
+ tt = -work[iwsv + nvl] / sum;
+ t2min = true;
+ if (!t1inf) {
+ if (t1 < tt) {
+ tt = t1;
+ t2min = false;
+ }
+ }
+
+ for (i = 1; i <= n; i = i + 1) {
+ sol[i] = sol[i] + tt * work[iwzv + i];
+ if (Math.abs(sol[i]) < vsmall) {
+ sol[i] = 0;
+ }
+ }
+
+ crval[1] = crval[1] + tt * sum * (tt / 2 + work[iwuv + nact + 1]);
+ for (i = 1; i <= nact; i = i + 1) {
+ work[iwuv + i] = work[iwuv + i] - tt * work[iwrv + i];
+ }
+ work[iwuv + nact + 1] = work[iwuv + nact + 1] + tt;
+
+ if (t2min) {
+ nact = nact + 1;
+ iact[nact] = nvl;
+
+ l = iwrm + ((nact - 1) * nact) / 2 + 1;
+ for (i = 1; i <= nact - 1; i = i + 1) {
+ work[l] = work[i];
+ l = l + 1;
+ }
+
+ if (nact === n) {
+ work[l] = work[n];
+ } else {
+ for (i = n; i >= nact + 1; i = i - 1) {
+ if (work[i] === 0) {
+ // continue;
+ break;
+ }
+ gc = Math.max(Math.abs(work[i - 1]), Math.abs(work[i]));
+ gs = Math.min(Math.abs(work[i - 1]), Math.abs(work[i]));
+ if (work[i - 1] >= 0) {
+ temp = Math.abs(gc * Math.sqrt(1 + gs * gs / (gc * gc)));
+ } else {
+ temp = -Math.abs(gc * Math.sqrt(1 + gs * gs / (gc * gc)));
+ }
+ gc = work[i - 1] / temp;
+ gs = work[i] / temp;
+
+ if (gc === 1) {
+ // continue;
+ break;
+ }
+ if (gc === 0) {
+ work[i - 1] = gs * temp;
+ for (j = 1; j <= n; j = j + 1) {
+ temp = dmat[j][i - 1];
+ dmat[j][i - 1] = dmat[j][i];
+ dmat[j][i] = temp;
+ }
+ } else {
+ work[i - 1] = temp;
+ nu = gs / (1 + gc);
+ for (j = 1; j <= n; j = j + 1) {
+ temp = gc * dmat[j][i - 1] + gs * dmat[j][i];
+ dmat[j][i] = nu * (dmat[j][i - 1] + temp) - dmat[j][i];
+ dmat[j][i - 1] = temp;
+
+ }
+ }
+ }
+ work[l] = work[nact];
+ }
+ } else {
+ sum = -bvec[nvl];
+ for (j = 1; j <= n; j = j + 1) {
+ sum = sum + sol[j] * amat[j][nvl];
+ }
+ if (nvl > meq) {
+ work[iwsv + nvl] = sum;
+ } else {
+ work[iwsv + nvl] = -Math.abs(sum);
+ if (sum > 0) {
+ for (j = 1; j <= n; j = j + 1) {
+ amat[j][nvl] = -amat[j][nvl];
+ }
+ bvec[nvl] = -bvec[nvl];
+ }
+ }
+ // GOTO 700
+ return 700;
+ }
+ }
+
+ return 0;
+ }
+
+ function fn_goto_797() {
+ l = iwrm + (it1 * (it1 + 1)) / 2 + 1;
+ l1 = l + it1;
+ if (work[l1] === 0) {
+ // GOTO 798
+ return 798;
+ }
+ gc = Math.max(Math.abs(work[l1 - 1]), Math.abs(work[l1]));
+ gs = Math.min(Math.abs(work[l1 - 1]), Math.abs(work[l1]));
+ if (work[l1 - 1] >= 0) {
+ temp = Math.abs(gc * Math.sqrt(1 + gs * gs / (gc * gc)));
+ } else {
+ temp = -Math.abs(gc * Math.sqrt(1 + gs * gs / (gc * gc)));
+ }
+ gc = work[l1 - 1] / temp;
+ gs = work[l1] / temp;
+
+ if (gc === 1) {
+ // GOTO 798
+ return 798;
+ }
+ if (gc === 0) {
+ for (i = it1 + 1; i <= nact; i = i + 1) {
+ temp = work[l1 - 1];
+ work[l1 - 1] = work[l1];
+ work[l1] = temp;
+ l1 = l1 + i;
+ }
+ for (i = 1; i <= n; i = i + 1) {
+ temp = dmat[i][it1];
+ dmat[i][it1] = dmat[i][it1 + 1];
+ dmat[i][it1 + 1] = temp;
+ }
+ } else {
+ nu = gs / (1 + gc);
+ for (i = it1 + 1; i <= nact; i = i + 1) {
+ temp = gc * work[l1 - 1] + gs * work[l1];
+ work[l1] = nu * (work[l1 - 1] + temp) - work[l1];
+ work[l1 - 1] = temp;
+ l1 = l1 + i;
+ }
+ for (i = 1; i <= n; i = i + 1) {
+ temp = gc * dmat[i][it1] + gs * dmat[i][it1 + 1];
+ dmat[i][it1 + 1] = nu * (dmat[i][it1] + temp) - dmat[i][it1 + 1];
+ dmat[i][it1] = temp;
+ }
+ }
+
+ return 0;
+ }
+
+ function fn_goto_798() {
+ l1 = l - it1;
+ for (i = 1; i <= it1; i = i + 1) {
+ work[l1] = work[l];
+ l = l + 1;
+ l1 = l1 + 1;
+ }
+
+ work[iwuv + it1] = work[iwuv + it1 + 1];
+ iact[it1] = iact[it1 + 1];
+ it1 = it1 + 1;
+ if (it1 < nact) {
+ // GOTO 797
+ return 797;
+ }
+
+ return 0;
+ }
+
+ function fn_goto_799() {
+ work[iwuv + nact] = work[iwuv + nact + 1];
+ work[iwuv + nact + 1] = 0;
+ iact[nact] = 0;
+ nact = nact - 1;
+ iter[2] = iter[2] + 1;
+
+ return 0;
+ }
+
+ go = 0;
+ while (true) {
+ go = fn_goto_50();
+ if (go === 999) {
+ return;
+ }
+ while (true) {
+ go = fn_goto_55();
+ if (go === 0) {
+ break;
+ }
+ if (go === 999) {
+ return;
+ }
+ if (go === 700) {
+ if (it1 === nact) {
+ fn_goto_799();
+ } else {
+ while (true) {
+ fn_goto_797();
+ go = fn_goto_798();
+ if (go !== 797) {
+ break;
+ }
+ }
+ fn_goto_799();
+ }
+ }
+ }
+ }
+
+}
+
+function solveQP(Dmat, dvec, Amat, bvec, meq, factorized) {
+ Dmat = base0to1(Dmat);
+ dvec = base0to1(dvec);
+ Amat = base0to1(Amat);
+ var i, n, q,
+ nact, r,
+ crval = [], iact = [], sol = [], work = [], iter = [],
+ message;
+
+ meq = meq || 0;
+ factorized = factorized ? base0to1(factorized) : [undefined, 0];
+ bvec = bvec ? base0to1(bvec) : [];
+
+ // In Fortran the array index starts from 1
+ n = Dmat.length - 1;
+ q = Amat[1].length - 1;
+
+ if (!bvec) {
+ for (i = 1; i <= q; i = i + 1) {
+ bvec[i] = 0;
+ }
+ }
+ for (i = 1; i <= q; i = i + 1) {
+ iact[i] = 0;
+ }
+ nact = 0;
+ r = Math.min(n, q);
+ for (i = 1; i <= n; i = i + 1) {
+ sol[i] = 0;
+ }
+ crval[1] = 0;
+ for (i = 1; i <= (2 * n + (r * (r + 5)) / 2 + 2 * q + 1); i = i + 1) {
+ work[i] = 0;
+ }
+ for (i = 1; i <= 2; i = i + 1) {
+ iter[i] = 0;
+ }
+
+ qpgen2(Dmat, dvec, n, n, sol, crval, Amat,
+ bvec, n, q, meq, iact, nact, iter, work, factorized);
+
+ message = "";
+ if (factorized[1] === 1) {
+ message = "constraints are inconsistent, no solution!";
+ }
+ if (factorized[1] === 2) {
+ message = "matrix D in quadratic function is not positive definite!";
+ }
+
+ return {
+ solution: base1to0(sol),
+ value: base1to0(crval),
+ unconstrained_solution: base1to0(dvec),
+ iterations: base1to0(iter),
+ iact: base1to0(iact),
+ message: message
+ };
+}
+exports.solveQP = solveQP;
+}(numeric));
+/*
+Shanti Rao sent me this routine by private email. I had to modify it
+slightly to work on Arrays instead of using a Matrix object.
+It is apparently translated from http://stitchpanorama.sourceforge.net/Python/svd.py
+*/
+
+numeric.svd= function svd(A) {
+ var temp;
+//Compute the thin SVD from G. H. Golub and C. Reinsch, Numer. Math. 14, 403-420 (1970)
+ var prec= numeric.epsilon; //Math.pow(2,-52) // assumes double prec
+ var tolerance= 1.e-64/prec;
+ var itmax= 50;
+ var c=0;
+ var i=0;
+ var j=0;
+ var k=0;
+ var l=0;
+
+ var u= numeric.clone(A);
+ var m= u.length;
+
+ var n= u[0].length;
+
+ if (m < n) throw "Need more rows than columns"
+
+ var e = new Array(n);
+ var q = new Array(n);
+ for (i=0; i b)
+ return a*Math.sqrt(1.0+(b*b/a/a))
+ else if (b == 0.0)
+ return a
+ return b*Math.sqrt(1.0+(a*a/b/b))
+ }
+
+ //Householder's reduction to bidiagonal form
+
+ var f= 0.0;
+ var g= 0.0;
+ var h= 0.0;
+ var x= 0.0;
+ var y= 0.0;
+ var z= 0.0;
+ var s= 0.0;
+
+ for (i=0; i < n; i++)
+ {
+ e[i]= g;
+ s= 0.0;
+ l= i+1;
+ for (j=i; j < m; j++)
+ s += (u[j][i]*u[j][i]);
+ if (s <= tolerance)
+ g= 0.0;
+ else
+ {
+ f= u[i][i];
+ g= Math.sqrt(s);
+ if (f >= 0.0) g= -g;
+ h= f*g-s
+ u[i][i]=f-g;
+ for (j=l; j < n; j++)
+ {
+ s= 0.0
+ for (k=i; k < m; k++)
+ s += u[k][i]*u[k][j]
+ f= s/h
+ for (k=i; k < m; k++)
+ u[k][j]+=f*u[k][i]
+ }
+ }
+ q[i]= g
+ s= 0.0
+ for (j=l; j < n; j++)
+ s= s + u[i][j]*u[i][j]
+ if (s <= tolerance)
+ g= 0.0
+ else
+ {
+ f= u[i][i+1]
+ g= Math.sqrt(s)
+ if (f >= 0.0) g= -g
+ h= f*g - s
+ u[i][i+1] = f-g;
+ for (j=l; j < n; j++) e[j]= u[i][j]/h
+ for (j=l; j < m; j++)
+ {
+ s=0.0
+ for (k=l; k < n; k++)
+ s += (u[j][k]*u[i][k])
+ for (k=l; k < n; k++)
+ u[j][k]+=s*e[k]
+ }
+ }
+ y= Math.abs(q[i])+Math.abs(e[i])
+ if (y>x)
+ x=y
+ }
+
+ // accumulation of right hand gtransformations
+ for (i=n-1; i != -1; i+= -1)
+ {
+ if (g != 0.0)
+ {
+ h= g*u[i][i+1]
+ for (j=l; j < n; j++)
+ v[j][i]=u[i][j]/h
+ for (j=l; j < n; j++)
+ {
+ s=0.0
+ for (k=l; k < n; k++)
+ s += u[i][k]*v[k][j]
+ for (k=l; k < n; k++)
+ v[k][j]+=(s*v[k][i])
+ }
+ }
+ for (j=l; j < n; j++)
+ {
+ v[i][j] = 0;
+ v[j][i] = 0;
+ }
+ v[i][i] = 1;
+ g= e[i]
+ l= i
+ }
+
+ // accumulation of left hand transformations
+ for (i=n-1; i != -1; i+= -1)
+ {
+ l= i+1
+ g= q[i]
+ for (j=l; j < n; j++)
+ u[i][j] = 0;
+ if (g != 0.0)
+ {
+ h= u[i][i]*g
+ for (j=l; j < n; j++)
+ {
+ s=0.0
+ for (k=l; k < m; k++) s += u[k][i]*u[k][j];
+ f= s/h
+ for (k=i; k < m; k++) u[k][j]+=f*u[k][i];
+ }
+ for (j=i; j < m; j++) u[j][i] = u[j][i]/g;
+ }
+ else
+ for (j=i; j < m; j++) u[j][i] = 0;
+ u[i][i] += 1;
+ }
+
+ // diagonalization of the bidiagonal form
+ prec= prec*x
+ for (k=n-1; k != -1; k+= -1)
+ {
+ for (var iteration=0; iteration < itmax; iteration++)
+ { // test f splitting
+ var test_convergence = false
+ for (l=k; l != -1; l+= -1)
+ {
+ if (Math.abs(e[l]) <= prec)
+ { test_convergence= true
+ break
+ }
+ if (Math.abs(q[l-1]) <= prec)
+ break
+ }
+ if (!test_convergence)
+ { // cancellation of e[l] if l>0
+ c= 0.0
+ s= 1.0
+ var l1= l-1
+ for (i =l; i= itmax-1)
+ throw 'Error: no convergence.'
+ // shift from bottom 2x2 minor
+ x= q[l]
+ y= q[k-1]
+ g= e[k-1]
+ h= e[k]
+ f= ((y-z)*(y+z)+(g-h)*(g+h))/(2.0*h*y)
+ g= pythag(f,1.0)
+ if (f < 0.0)
+ f= ((x-z)*(x+z)+h*(y/(f-g)-h))/x
+ else
+ f= ((x-z)*(x+z)+h*(y/(f+g)-h))/x
+ // next QR transformation
+ c= 1.0
+ s= 1.0
+ for (i=l+1; i< k+1; i++)
+ {
+ g= e[i]
+ y= q[i]
+ h= s*g
+ g= c*g
+ z= pythag(f,h)
+ e[i-1]= z
+ c= f/z
+ s= h/z
+ f= x*c+g*s
+ g= -x*s+g*c
+ h= y*s
+ y= y*c
+ for (j=0; j < n; j++)
+ {
+ x= v[j][i-1]
+ z= v[j][i]
+ v[j][i-1] = x*c+z*s
+ v[j][i] = -x*s+z*c
+ }
+ z= pythag(f,h)
+ q[i-1]= z
+ c= f/z
+ s= h/z
+ f= c*g+s*y
+ x= -s*g+c*y
+ for (j=0; j < m; j++)
+ {
+ y= u[j][i-1]
+ z= u[j][i]
+ u[j][i-1] = y*c+z*s
+ u[j][i] = -y*s+z*c
+ }
+ }
+ e[l]= 0.0
+ e[k]= f
+ q[k]= x
+ }
+ }
+
+ //vt= transpose(v)
+ //return (u,q,vt)
+ for (i=0;i= 0; j--)
+ {
+ if (q[j] < q[i])
+ {
+ // writeln(i,'-',j)
+ c = q[j]
+ q[j] = q[i]
+ q[i] = c
+ for(k=0;k tensor.name) :
+ Object.keys(tensors);
+ for (let i = 0; i < names.length; ++i) {
+ const name = names[i];
+ const t = Array.isArray(tensors) ? tensors[i].tensor : tensors[name];
+ if (t.dtype !== 'float32' && t.dtype !== 'int32' && t.dtype !== 'bool' &&
+ t.dtype !== 'string' && t.dtype !== 'complex64') {
+ throw new Error(`Unsupported dtype in weight '${name}': ${t.dtype}`);
+ }
+ const spec = { name, shape: t.shape, dtype: t.dtype };
+ if (t.dtype === 'string') {
+ const utf8bytes = new Promise(async (resolve) => {
+ const vals = await t.bytes();
+ const totalNumBytes = vals.reduce((p, c) => p + c.length, 0) +
+ NUM_BYTES_STRING_LENGTH * vals.length;
+ const bytes = new Uint8Array(totalNumBytes);
+ let offset = 0;
+ for (let i = 0; i < vals.length; i++) {
+ const val = vals[i];
+ const bytesOfLength = new Uint8Array(new Uint32Array([val.length]).buffer);
+ bytes.set(bytesOfLength, offset);
+ offset += NUM_BYTES_STRING_LENGTH;
+ bytes.set(val, offset);
+ offset += val.length;
+ }
+ resolve(bytes);
+ });
+ dataPromises.push(utf8bytes);
+ }
+ else {
+ dataPromises.push(t.data());
+ }
+ if (group != null) {
+ spec.group = group;
+ }
+ specs.push(spec);
+ }
+ const tensorValues = await Promise.all(dataPromises);
+ return { data: concatenateTypedArrays(tensorValues), specs };
+}
+/**
+ * Decode flat ArrayBuffer as weights.
+ *
+ * This function does not handle sharding.
+ *
+ * This function is the reverse of `encodeWeights`.
+ *
+ * @param buffer A flat ArrayBuffer carrying the binary values of the tensors
+ * concatenated in the order specified in `specs`.
+ * @param specs Specifications of the names, dtypes and shapes of the tensors
+ * whose value are encoded by `buffer`.
+ * @return A map from tensor name to tensor value, with the names corresponding
+ * to names in `specs`.
+ * @throws Error, if any of the tensors has unsupported dtype.
+ */
+function decodeWeights(buffer, specs) {
+ // TODO(adarob, cais): Support quantization.
+ const out = {};
+ let float16Decode;
+ let offset = 0;
+ for (const spec of specs) {
+ const name = spec.name;
+ const dtype = spec.dtype;
+ const shape = spec.shape;
+ const size = Object(_util__WEBPACK_IMPORTED_MODULE_2__["sizeFromShape"])(shape);
+ let values;
+ if ('quantization' in spec) {
+ const quantization = spec.quantization;
+ if (quantization.dtype === 'uint8' || quantization.dtype === 'uint16') {
+ if (!('min' in quantization && 'scale' in quantization)) {
+ throw new Error(`Weight ${spec.name} with quantization ${quantization.dtype} ` +
+ `doesn't have corresponding metadata min and scale.`);
+ }
+ }
+ else if (quantization.dtype === 'float16') {
+ if (dtype !== 'float32') {
+ throw new Error(`Weight ${spec.name} is quantized with ${quantization.dtype} ` +
+ `which only supports weights of type float32 not ${dtype}.`);
+ }
+ }
+ else {
+ throw new Error(`Weight ${spec.name} has unknown ` +
+ `quantization dtype ${quantization.dtype}. ` +
+ `Supported quantization dtypes are: ` +
+ `'uint8', 'uint16', and 'float16'.`);
+ }
+ const quantizationSizeFactor = _types__WEBPACK_IMPORTED_MODULE_3__[/* DTYPE_VALUE_SIZE_MAP */ "a"][quantization.dtype];
+ const byteBuffer = buffer.slice(offset, offset + size * quantizationSizeFactor);
+ const quantizedArray = (quantization.dtype === 'uint8') ?
+ new Uint8Array(byteBuffer) :
+ new Uint16Array(byteBuffer);
+ if (dtype === 'float32') {
+ if (quantization.dtype === 'uint8' || quantization.dtype === 'uint16') {
+ values = new Float32Array(quantizedArray.length);
+ for (let i = 0; i < quantizedArray.length; i++) {
+ const v = quantizedArray[i];
+ values[i] = v * quantization.scale + quantization.min;
+ }
+ }
+ else if (quantization.dtype === 'float16') {
+ if (float16Decode === undefined) {
+ float16Decode = getFloat16Decoder();
+ }
+ values = float16Decode(quantizedArray);
+ }
+ else {
+ throw new Error(`Unsupported quantization type ${quantization.dtype} ` +
+ `for weight type float32.`);
+ }
+ }
+ else if (dtype === 'int32') {
+ if (quantization.dtype !== 'uint8' && quantization.dtype !== 'uint16') {
+ throw new Error(`Unsupported quantization type ${quantization.dtype} ` +
+ `for weight type int32.`);
+ }
+ values = new Int32Array(quantizedArray.length);
+ for (let i = 0; i < quantizedArray.length; i++) {
+ const v = quantizedArray[i];
+ values[i] = Math.round(v * quantization.scale + quantization.min);
+ }
+ }
+ else {
+ throw new Error(`Unsupported dtype in weight '${name}': ${dtype}`);
+ }
+ offset += size * quantizationSizeFactor;
+ }
+ else if (dtype === 'string') {
+ const size = Object(_util__WEBPACK_IMPORTED_MODULE_2__["sizeFromShape"])(spec.shape);
+ values = [];
+ for (let i = 0; i < size; i++) {
+ const byteLength = new Uint32Array(buffer.slice(offset, offset + NUM_BYTES_STRING_LENGTH))[0];
+ offset += NUM_BYTES_STRING_LENGTH;
+ const bytes = new Uint8Array(buffer.slice(offset, offset + byteLength));
+ values.push(bytes);
+ offset += byteLength;
+ }
+ }
+ else {
+ const dtypeFactor = _types__WEBPACK_IMPORTED_MODULE_3__[/* DTYPE_VALUE_SIZE_MAP */ "a"][dtype];
+ const byteBuffer = buffer.slice(offset, offset + size * dtypeFactor);
+ if (dtype === 'float32') {
+ values = new Float32Array(byteBuffer);
+ }
+ else if (dtype === 'int32') {
+ values = new Int32Array(byteBuffer);
+ }
+ else if (dtype === 'bool') {
+ values = new Uint8Array(byteBuffer);
+ }
+ else if (dtype === 'complex64') {
+ values = new Float32Array(byteBuffer);
+ const real = new Float32Array(values.length / 2);
+ const image = new Float32Array(values.length / 2);
+ for (let i = 0; i < real.length; i++) {
+ real[i] = values[i * 2];
+ image[i] = values[i * 2 + 1];
+ }
+ const realTensor = Object(_ops_tensor_ops__WEBPACK_IMPORTED_MODULE_1__[/* tensor */ "f"])(real, shape, 'float32');
+ const imageTensor = Object(_ops_tensor_ops__WEBPACK_IMPORTED_MODULE_1__[/* tensor */ "f"])(image, shape, 'float32');
+ out[name] = Object(_ops_complex__WEBPACK_IMPORTED_MODULE_0__[/* complex */ "a"])(realTensor, imageTensor);
+ }
+ else {
+ throw new Error(`Unsupported dtype in weight '${name}': ${dtype}`);
+ }
+ offset += size * dtypeFactor;
+ }
+ if (dtype !== 'complex64') {
+ out[name] = Object(_ops_tensor_ops__WEBPACK_IMPORTED_MODULE_1__[/* tensor */ "f"])(values, shape, dtype);
+ }
+ }
+ return out;
+}
+/**
+ * Concatenate TypedArrays into an ArrayBuffer.
+ */
+function concatenateTypedArrays(xs) {
+ // TODO(adarob, cais): Support quantization.
+ if (xs === null) {
+ throw new Error(`Invalid input value: ${JSON.stringify(xs)}`);
+ }
+ let totalByteLength = 0;
+ // `normalizedXs` is here for this reason: a `TypedArray`'s `buffer'
+ // can have a different byte length from that of the `TypedArray` itself,
+ // for example, when the `TypedArray` is created from an offset in an
+ // `ArrayBuffer`. `normliazedXs` holds `TypedArray`s whose `buffer`s match
+ // the `TypedArray` in byte length. If an element of `xs` does not show
+ // this property, a new `TypedArray` that satisfy this property will be
+ // constructed and pushed into `normalizedXs`.
+ const normalizedXs = [];
+ xs.forEach((x) => {
+ totalByteLength += x.byteLength;
+ // tslint:disable:no-any
+ normalizedXs.push(x.byteLength === x.buffer.byteLength ? x :
+ new x.constructor(x));
+ if (!(x instanceof Float32Array || x instanceof Int32Array ||
+ x instanceof Uint8Array)) {
+ throw new Error(`Unsupported TypedArray subtype: ${x.constructor.name}`);
+ }
+ // tslint:enable:no-any
+ });
+ const y = new Uint8Array(totalByteLength);
+ let offset = 0;
+ normalizedXs.forEach((x) => {
+ y.set(new Uint8Array(x.buffer), offset);
+ offset += x.byteLength;
+ });
+ return y.buffer;
+}
+// Use Buffer on Node.js instead of Blob/atob/btoa
+const useNodeBuffer = typeof Buffer !== 'undefined' &&
+ (typeof Blob === 'undefined' || typeof atob === 'undefined' ||
+ typeof btoa === 'undefined');
+/**
+ * Calculate the byte length of a JavaScript string.
+ *
+ * Note that a JavaScript string can contain wide characters, therefore the
+ * length of the string is not necessarily equal to the byte length.
+ *
+ * @param str Input string.
+ * @returns Byte length.
+ */
+function stringByteLength(str) {
+ if (useNodeBuffer) {
+ return Buffer.byteLength(str);
+ }
+ return new Blob([str]).size;
+}
+/**
+ * Encode an ArrayBuffer as a base64 encoded string.
+ *
+ * @param buffer `ArrayBuffer` to be converted.
+ * @returns A string that base64-encodes `buffer`.
+ */
+function arrayBufferToBase64String(buffer) {
+ if (useNodeBuffer) {
+ return Buffer.from(buffer).toString('base64');
+ }
+ const buf = new Uint8Array(buffer);
+ let s = '';
+ for (let i = 0, l = buf.length; i < l; i++) {
+ s += String.fromCharCode(buf[i]);
+ }
+ return btoa(s);
+}
+/**
+ * Decode a base64 string as an ArrayBuffer.
+ *
+ * @param str Base64 string.
+ * @returns Decoded `ArrayBuffer`.
+ */
+function base64StringToArrayBuffer(str) {
+ if (useNodeBuffer) {
+ const buf = Buffer.from(str, 'base64');
+ return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+ }
+ const s = atob(str);
+ const buffer = new Uint8Array(s.length);
+ for (let i = 0; i < s.length; ++i) {
+ buffer.set([s.charCodeAt(i)], i);
+ }
+ return buffer.buffer;
+}
+/**
+ * Concatenate a number of ArrayBuffers into one.
+ *
+ * @param buffers A number of array buffers to concatenate.
+ * @returns Result of concatenating `buffers` in order.
+ */
+function concatenateArrayBuffers(buffers) {
+ if (buffers.length === 1) {
+ return buffers[0];
+ }
+ let totalByteLength = 0;
+ buffers.forEach((buffer) => {
+ totalByteLength += buffer.byteLength;
+ });
+ const temp = new Uint8Array(totalByteLength);
+ let offset = 0;
+ buffers.forEach((buffer) => {
+ temp.set(new Uint8Array(buffer), offset);
+ offset += buffer.byteLength;
+ });
+ return temp.buffer;
+}
+/**
+ * Get the basename of a path.
+ *
+ * Behaves in a way analogous to Linux's basename command.
+ *
+ * @param path
+ */
+function basename(path) {
+ const SEPARATOR = '/';
+ path = path.trim();
+ while (path.endsWith(SEPARATOR)) {
+ path = path.slice(0, path.length - 1);
+ }
+ const items = path.split(SEPARATOR);
+ return items[items.length - 1];
+}
+/**
+ * Populate ModelArtifactsInfo fields for a model with JSON topology.
+ * @param modelArtifacts
+ * @returns A ModelArtifactsInfo object.
+ */
+function getModelArtifactsInfoForJSON(modelArtifacts) {
+ if (modelArtifacts.modelTopology instanceof ArrayBuffer) {
+ throw new Error('Expected JSON model topology, received ArrayBuffer.');
+ }
+ return {
+ dateSaved: new Date(),
+ modelTopologyType: 'JSON',
+ modelTopologyBytes: modelArtifacts.modelTopology == null ?
+ 0 :
+ stringByteLength(JSON.stringify(modelArtifacts.modelTopology)),
+ weightSpecsBytes: modelArtifacts.weightSpecs == null ?
+ 0 :
+ stringByteLength(JSON.stringify(modelArtifacts.weightSpecs)),
+ weightDataBytes: modelArtifacts.weightData == null ?
+ 0 :
+ modelArtifacts.weightData.byteLength,
+ };
+}
+/**
+ * Computes mantisa table for casting Float16 to Float32
+ * See http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
+ *
+ * @returns Uint32Array, 2048 mantissa lookup values.
+ */
+function computeFloat16MantisaTable() {
+ const convertMantissa = (i) => {
+ let m = i << 13;
+ let e = 0;
+ while ((m & 0x00800000) === 0) {
+ e -= 0x00800000;
+ m <<= 1;
+ }
+ m &= ~0x00800000;
+ e += 0x38800000;
+ return m | e;
+ };
+ const mantisaTable = new Uint32Array(2048);
+ mantisaTable[0] = 0;
+ for (let i = 1; i < 1024; i++) {
+ mantisaTable[i] = convertMantissa(i);
+ }
+ for (let i = 1024; i < 2048; i++) {
+ mantisaTable[i] = 0x38000000 + ((i - 1024) << 13);
+ }
+ return mantisaTable;
+}
+/**
+ * Computes exponent table for casting Float16 to Float32
+ * See http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
+ *
+ * @returns Uint32Array, 64 exponent lookup values.
+ */
+function computeFloat16ExponentTable() {
+ const exponentTable = new Uint32Array(64);
+ exponentTable[0] = 0;
+ exponentTable[31] = 0x47800000;
+ exponentTable[32] = 0x80000000;
+ exponentTable[63] = 0xc7800000;
+ for (let i = 1; i < 31; i++) {
+ exponentTable[i] = i << 23;
+ }
+ for (let i = 33; i < 63; i++) {
+ exponentTable[i] = 0x80000000 + ((i - 32) << 23);
+ }
+ return exponentTable;
+}
+/**
+ * Computes offset table for casting Float16 to Float32
+ * See http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
+ *
+ * @returns Uint32Array, 6d offset values.
+ */
+function computeFloat16OffsetTable() {
+ const offsetTable = new Uint32Array(64);
+ for (let i = 0; i < 64; i++) {
+ offsetTable[i] = 1024;
+ }
+ offsetTable[0] = offsetTable[32] = 0;
+ return offsetTable;
+}
+/**
+ * Retrieve a Float16 decoder which will decode a ByteArray of Float16 values
+ * to a Float32Array.
+ *
+ * @returns Function (buffer: Uint16Array) => Float32Array which decodes
+ * the Uint16Array of Float16 bytes to a Float32Array.
+ */
+function getFloat16Decoder() {
+ // Algorithm is based off of http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
+ // Cache lookup tables
+ const mantisaTable = computeFloat16MantisaTable();
+ const exponentTable = computeFloat16ExponentTable();
+ const offsetTable = computeFloat16OffsetTable();
+ return (quantizedArray) => {
+ const buffer = new ArrayBuffer(4 * quantizedArray.length);
+ const bufferUint32View = new Uint32Array(buffer);
+ for (let index = 0; index < quantizedArray.length; index++) {
+ const float16Bits = quantizedArray[index];
+ const float32Bits = mantisaTable[offsetTable[float16Bits >> 10] + (float16Bits & 0x3ff)] +
+ exponentTable[float16Bits >> 10];
+ bufferUint32View[index] = float32Bits;
+ }
+ return new Float32Array(buffer);
+ };
+}
+//# sourceMappingURL=io_utils.js.map
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(39).Buffer))
+
+/***/ }),
+/* 14 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "f", function() { return /* binding */ iteratorFromItems; });
+__webpack_require__.d(__webpack_exports__, "e", function() { return /* binding */ iteratorFromFunction; });
+__webpack_require__.d(__webpack_exports__, "d", function() { return /* binding */ iteratorFromConcatenated; });
+__webpack_require__.d(__webpack_exports__, "g", function() { return /* binding */ iteratorFromZipped; });
+__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ lazy_iterator_LazyIterator; });
+__webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ lazy_iterator_OneToManyIterator; });
+__webpack_require__.d(__webpack_exports__, "c", function() { return /* binding */ ZipMismatchMode; });
+
+// UNUSED EXPORTS: iteratorFromIncrementing, iteratorFromConcatenatedFunction, ChainedIterator, PrefetchIterator, ShuffleIterator
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/index.js + 269 modules
+var dist = __webpack_require__(0);
+
+// EXTERNAL MODULE: ./node_modules/seedrandom/index.js
+var seedrandom = __webpack_require__(20);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-data/dist/util/deep_map.js
+var deep_map = __webpack_require__(19);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-data/dist/util/deep_clone.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * =============================================================================
+ */
+
+
+function deepClone(container) {
+ return Object(deep_map["b" /* deepMap */])(container, cloneIfTensor);
+}
+// tslint:disable-next-line: no-any
+function cloneIfTensor(item) {
+ if (item instanceof dist["Tensor"]) {
+ return ({ value: item.clone(), recurse: false });
+ }
+ else if (Object(deep_map["e" /* isIterable */])(item)) {
+ return { value: null, recurse: true };
+ }
+ else {
+ return { value: item, recurse: false };
+ }
+}
+//# sourceMappingURL=deep_clone.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-data/dist/util/ring_buffer.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * =============================================================================
+ */
+/**
+ * A ring buffer, providing O(1) FIFO, LIFO, and related operations.
+ */
+class RingBuffer {
+ /**
+ * Constructs a `RingBuffer`.
+ * @param capacity The number of items that the buffer can accomodate.
+ */
+ constructor(capacity) {
+ this.capacity = capacity;
+ // Note we store the indices in the range 0 <= index < 2*capacity.
+ // This allows us to distinguish the full from the empty case.
+ // See https://www.snellman.net/blog/archive/2016-12-13-ring-buffers/
+ this.begin = 0; // inclusive
+ this.end = 0; // exclusive
+ if (capacity == null) {
+ throw new RangeError('Can\'t create a ring buffer of unknown capacity.');
+ }
+ if (capacity < 1) {
+ throw new RangeError('Can\'t create ring buffer of capacity < 1.');
+ }
+ this.data = new Array(capacity);
+ this.doubledCapacity = 2 * capacity;
+ }
+ /**
+ * Map any index into the range 0 <= index < 2*capacity.
+ */
+ wrap(index) {
+ // don't trust % on negative numbers
+ while (index < 0) {
+ index += this.doubledCapacity;
+ }
+ return index % this.doubledCapacity;
+ }
+ get(index) {
+ if (index < 0) {
+ throw new RangeError('Can\'t get item at a negative index.');
+ }
+ return this.data[index % this.capacity];
+ }
+ set(index, value) {
+ if (index < 0) {
+ throw new RangeError('Can\'t set item at a negative index.');
+ }
+ this.data[index % this.capacity] = value;
+ }
+ /**
+ * Returns the current number of items in the buffer.
+ */
+ length() {
+ let length = this.end - this.begin;
+ if (length < 0) {
+ length = this.doubledCapacity + length;
+ }
+ return length;
+ }
+ /**
+ * Reports whether the buffer is full.
+ * @returns true if the number of items in the buffer equals its capacity, and
+ * false otherwise.
+ */
+ isFull() {
+ return this.length() === this.capacity;
+ }
+ /**
+ * Reports whether the buffer is empty.
+ * @returns true if the number of items in the buffer equals zero, and
+ * false otherwise.
+ */
+ isEmpty() {
+ return this.length() === 0;
+ }
+ /**
+ * Adds an item to the end of the buffer.
+ */
+ push(value) {
+ if (this.isFull()) {
+ throw new RangeError('Ring buffer is full.');
+ }
+ this.set(this.end, value);
+ this.end = this.wrap(this.end + 1);
+ }
+ /**
+ * Adds many items to the end of the buffer, in order.
+ */
+ pushAll(values) {
+ for (const value of values) {
+ this.push(value);
+ }
+ }
+ /**
+ * Removes and returns the last item in the buffer.
+ */
+ pop() {
+ if (this.isEmpty()) {
+ throw new RangeError('Ring buffer is empty.');
+ }
+ this.end = this.wrap(this.end - 1);
+ const result = this.get(this.end);
+ this.set(this.end, undefined);
+ return result;
+ }
+ /**
+ * Adds an item to the beginning of the buffer.
+ */
+ unshift(value) {
+ if (this.isFull()) {
+ throw new RangeError('Ring buffer is full.');
+ }
+ this.begin = this.wrap(this.begin - 1);
+ this.set(this.begin, value);
+ }
+ /**
+ * Removes and returns the first item in the buffer.
+ */
+ shift() {
+ if (this.isEmpty()) {
+ throw new RangeError('Ring buffer is empty.');
+ }
+ const result = this.get(this.begin);
+ this.set(this.begin, undefined);
+ this.begin = this.wrap(this.begin + 1);
+ return result;
+ }
+ /**
+ * Removes and returns a specific item in the buffer, and moves the last item
+ * to the vacated slot. This is useful for implementing a shuffling stream.
+ * Note that this operation necessarily scrambles the original order.
+ *
+ * @param relativeIndex: the index of the item to remove, relative to the
+ * first item in the buffer (e.g., hiding the ring nature of the underlying
+ * storage).
+ */
+ shuffleExcise(relativeIndex) {
+ if (this.isEmpty()) {
+ throw new RangeError('Ring buffer is empty.');
+ }
+ const index = this.wrap(this.begin + relativeIndex);
+ const result = this.get(index);
+ this.set(index, this.pop());
+ return result;
+ }
+}
+//# sourceMappingURL=ring_buffer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-data/dist/util/growing_ring_buffer.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * =============================================================================
+ */
+
+class growing_ring_buffer_GrowingRingBuffer extends RingBuffer {
+ /**
+ * Constructs a `GrowingRingBuffer`.
+ */
+ constructor() {
+ super(growing_ring_buffer_GrowingRingBuffer.INITIAL_CAPACITY);
+ }
+ isFull() {
+ return false;
+ }
+ push(value) {
+ if (super.isFull()) {
+ this.expand();
+ }
+ super.push(value);
+ }
+ unshift(value) {
+ if (super.isFull()) {
+ this.expand();
+ }
+ super.unshift(value);
+ }
+ /**
+ * Doubles the capacity of the buffer.
+ */
+ expand() {
+ const newCapacity = this.capacity * 2;
+ const newData = new Array(newCapacity);
+ const len = this.length();
+ // Rotate the buffer to start at index 0 again, since we can't just
+ // allocate more space at the end.
+ for (let i = 0; i < len; i++) {
+ newData[i] = this.get(this.wrap(this.begin + i));
+ }
+ this.data = newData;
+ this.capacity = newCapacity;
+ this.doubledCapacity = 2 * this.capacity;
+ this.begin = 0;
+ this.end = len;
+ }
+}
+growing_ring_buffer_GrowingRingBuffer.INITIAL_CAPACITY = 32;
+//# sourceMappingURL=growing_ring_buffer.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-data/dist/iterators/lazy_iterator.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * =============================================================================
+ */
+
+
+
+
+
+
+// Here we implement a simple asynchronous iterator.
+// This lets us avoid using either third-party stream libraries or
+// recent TypeScript language support requiring polyfills.
+/**
+ * Create a `LazyIterator` from an array of items.
+ */
+function iteratorFromItems(items) {
+ return new lazy_iterator_ArrayIterator(items);
+}
+/**
+ * Create a `LazyIterator` of incrementing integers.
+ */
+function iteratorFromIncrementing(start) {
+ let i = start;
+ return iteratorFromFunction(() => ({ value: i++, done: false }));
+}
+/**
+ * Create a `LazyIterator` from a function.
+ *
+ * ```js
+ * let i = -1;
+ * const func = () =>
+ * ++i < 5 ? {value: i, done: false} : {value: null, done: true};
+ * const iter = tf.data.iteratorFromFunction(func);
+ * await iter.forEachAsync(e => console.log(e));
+ * ```
+ *
+ * @param func A function that produces data on each call.
+ */
+function iteratorFromFunction(func) {
+ return new FunctionCallIterator(func);
+}
+/**
+ * Create a `LazyIterator` by concatenating underlying streams, which are
+ * themselves provided as a stream.
+ *
+ * This can also be thought of as a "stream flatten" operation.
+ *
+ * @param baseIterators A stream of streams to be concatenated.
+ * @param baseErrorHandler An optional function that can intercept `Error`s
+ * raised during a `next()` call on the base stream. This function can decide
+ * whether the error should be propagated, whether the error should be
+ * ignored, or whether the base stream should be terminated.
+ */
+function iteratorFromConcatenated(baseIterators, baseErrorHandler) {
+ return new ChainedIterator(baseIterators, baseErrorHandler);
+}
+/**
+ * Create a `LazyIterator` by concatenating streams produced by calling a
+ * stream-generating function a given number of times.
+ *
+ * Since a `LazyIterator` is read-once, it cannot be repeated, but this
+ * function can be used to achieve a similar effect:
+ *
+ * LazyIterator.ofConcatenatedFunction(() => new MyIterator(), 6);
+ *
+ * @param iteratorFunc: A function that produces a new stream on each call.
+ * @param count: The number of times to call the function.
+ * @param baseErrorHandler An optional function that can intercept `Error`s
+ * raised during a `next()` call on the base stream. This function can decide
+ * whether the error should be propagated, whether the error should be
+ * ignored, or whether the base stream should be terminated.
+ */
+function iteratorFromConcatenatedFunction(iteratorFunc, count, baseErrorHandler) {
+ return iteratorFromConcatenated(iteratorFromFunction(iteratorFunc).take(count), baseErrorHandler);
+}
+/**
+ * Create a `LazyIterator` by zipping together an array, dict, or nested
+ * structure of `LazyIterator`s (and perhaps additional constants).
+ *
+ * The underlying streams must provide elements in a consistent order such
+ * that they correspond.
+ *
+ * Typically, the underlying streams should have the same number of
+ * elements. If they do not, the behavior is determined by the
+ * `mismatchMode` argument.
+ *
+ * The nested structure of the `iterators` argument determines the
+ * structure of elements in the resulting iterator.
+ *
+ * @param iterators: An array or object containing LazyIterators at the
+ * leaves.
+ * @param mismatchMode: Determines what to do when one underlying iterator
+ * is exhausted before the others. `ZipMismatchMode.FAIL` (the default)
+ * causes an error to be thrown in this case. `ZipMismatchMode.SHORTEST`
+ * causes the zipped iterator to terminate with the furst underlying
+ * streams, so elements remaining on the longer streams are ignored.
+ * `ZipMismatchMode.LONGEST` causes the zipped stream to continue, filling
+ * in nulls for the exhausted streams, until all streams are exhausted.
+ */
+function iteratorFromZipped(iterators, mismatchMode = ZipMismatchMode.FAIL) {
+ return new lazy_iterator_ZipIterator(iterators, mismatchMode);
+}
+/**
+ * An asynchronous iterator, providing lazy access to a potentially
+ * unbounded stream of elements.
+ *
+ * Iterator can be obtained from a dataset:
+ * `const iter = await dataset.iterator();`
+ */
+class lazy_iterator_LazyIterator {
+ /**
+ * Collect all remaining elements of a bounded stream into an array.
+ * Obviously this will succeed only for small streams that fit in memory.
+ * Useful for testing.
+ *
+ * @returns A Promise for an array of stream elements, which will resolve
+ * when the stream is exhausted.
+ */
+ async toArray() {
+ const result = [];
+ let x = await this.next();
+ while (!x.done) {
+ result.push(x.value);
+ x = await this.next();
+ }
+ return result;
+ }
+ /**
+ * Collect all elements of this dataset into an array with prefetching 100
+ * elements. This is useful for testing, because the prefetch changes the
+ * order in which the Promises are resolved along the processing pipeline.
+ * This may help expose bugs where results are dependent on the order of
+ * Promise resolution rather than on the logical order of the stream (i.e.,
+ * due to hidden mutable state).
+ *
+ * @returns A Promise for an array of stream elements, which will resolve
+ * when the stream is exhausted.
+ */
+ async toArrayForTest() {
+ const stream = this.prefetch(100);
+ const result = [];
+ let x = await stream.next();
+ while (!x.done) {
+ result.push(x.value);
+ x = await stream.next();
+ }
+ return result;
+ }
+ /**
+ * Draw items from the stream until it is exhausted.
+ *
+ * This can be useful when the stream has side effects but no output. In
+ * that case, calling this function guarantees that the stream will be
+ * fully processed.
+ */
+ async resolveFully() {
+ let x = await this.next();
+ while (!x.done) {
+ x = await this.next();
+ }
+ }
+ /**
+ * Draw items from the stream until it is exhausted, or a predicate fails.
+ *
+ * This can be useful when the stream has side effects but no output. In
+ * that case, calling this function guarantees that the stream will be
+ * fully processed.
+ */
+ async resolveWhile(predicate) {
+ let x = await this.next();
+ let shouldContinue = predicate(x.value);
+ while ((!x.done) && shouldContinue) {
+ x = await this.next();
+ shouldContinue = predicate(x.value);
+ }
+ }
+ /**
+ * Handles errors thrown on this stream using a provided handler function.
+ *
+ * @param handler A function that handles any `Error` thrown during a `next()`
+ * call and returns true if the stream should continue (dropping the failed
+ * call) or false if the stream should quietly terminate. If the handler
+ * itself throws (or rethrows) an `Error`, that will be propagated.
+ *
+ * @returns A `LazyIterator` of elements passed through from upstream,
+ * possibly filtering or terminating on upstream `next()` calls that
+ * throw an `Error`.
+ */
+ handleErrors(handler) {
+ return new ErrorHandlingLazyIterator(this, handler);
+ }
+ // TODO(soergel): Implement reduce() etc.
+ /**
+ * Filters this stream according to `predicate`.
+ *
+ * @param predicate A function mapping a stream element to a boolean or a
+ * `Promise` for one.
+ *
+ * @returns A `LazyIterator` of elements for which the predicate was true.
+ */
+ filter(predicate) {
+ return new lazy_iterator_FilterIterator(this, predicate);
+ }
+ /**
+ * Maps this stream through a 1-to-1 transform.
+ *
+ * @param transform A function mapping a stream element to a transformed
+ * element.
+ *
+ * @returns A `LazyIterator` of transformed elements.
+ */
+ map(transform) {
+ return new lazy_iterator_MapIterator(this, transform);
+ }
+ /**
+ * Maps this stream through an async 1-to-1 transform.
+ *
+ * @param transform A function mapping a stream element to a `Promise` for a
+ * transformed stream element.
+ *
+ * @returns A `LazyIterator` of transformed elements.
+ */
+ mapAsync(transform) {
+ return new lazy_iterator_AsyncMapIterator(this, transform);
+ }
+ /**
+ * Maps this stream through a 1-to-1 transform, forcing serial execution.
+ *
+ * @param transform A function mapping a stream element to a transformed
+ * element.
+ *
+ * @returns A `LazyIterator` of transformed elements.
+ */
+ serialMapAsync(transform) {
+ return new lazy_iterator_AsyncMapIterator(this, transform).serial();
+ }
+ /**
+ * Maps this stream through a 1-to-many transform.
+ *
+ * @param transform A function mapping a stream element to an array of
+ * transformed elements.
+ *
+ * @returns A `DataStream` of transformed elements.
+ */
+ flatmap(transform) {
+ return new lazy_iterator_FlatmapIterator(this, transform);
+ }
+ /**
+ * Apply a function to every element of the stream.
+ *
+ * @param f A function to apply to each stream element.
+ */
+ async forEachAsync(f) {
+ return this.map(f).resolveFully();
+ }
+ /**
+ * Apply a function to every element of the stream, forcing serial execution.
+ *
+ * @param f A function to apply to each stream element. Should return 'true'
+ * to indicate that the stream should continue, or 'false' to cause it to
+ * terminate.
+ */
+ async serialForEach(f) {
+ return this.serialMapAsync(f).resolveWhile(x => (x === true));
+ }
+ /**
+ * Groups elements into batches, represented as arrays of elements.
+ *
+ * We can think of the elements of this iterator as 'rows' (even if they are
+ * nested structures). By the same token, consecutive values for a given
+ * key within the elements form a 'column'. This matches the usual sense of
+ * 'row' and 'column' when processing tabular data (e.g., parsing a CSV).
+ *
+ * Thus, "Row-major" means that the resulting batch is simply a collection of
+ * rows: `[row1, row2, row3, ...]`. This is contrast to the column-major
+ * form, which is needed for vectorized computation.
+ *
+ * @param batchSize The number of elements desired per batch.
+ * @param smallLastBatch Whether to emit the final batch when it has fewer
+ * than batchSize elements. Default true.
+ * @returns A `LazyIterator` of batches of elements, represented as arrays
+ * of the original element type.
+ */
+ rowMajorBatch(batchSize, smallLastBatch = true) {
+ return new RowMajorBatchIterator(this, batchSize, smallLastBatch);
+ }
+ /**
+ * Groups elements into batches, represented in column-major form.
+ *
+ * We can think of the elements of this iterator as 'rows' (even if they are
+ * nested structures). By the same token, consecutive values for a given
+ * key within the elements form a 'column'. This matches the usual sense of
+ * 'row' and 'column' when processing tabular data (e.g., parsing a CSV).
+ *
+ * Thus, "column-major" means that the resulting batch is a (potentially
+ * nested) structure representing the columns. Each column entry, then,
+ * contains a collection of the values found in that column for a range of
+ * input elements. This representation allows for vectorized computation, in
+ * contrast to the row-major form.
+ *
+ * The inputs should all have the same nested structure (i.e., of arrays and
+ * dicts). The result is a single object with the same nested structure,
+ * where the leaves are arrays collecting the values of the inputs at that
+ * location (or, optionally, the result of a custom function applied to those
+ * arrays).
+ *
+ * @param batchSize The number of elements desired per batch.
+ * @param smallLastBatch Whether to emit the final batch when it has fewer
+ * than batchSize elements. Default true.
+ * @param zipFn: (optional) A function that expects an array of elements at a
+ * single node of the object tree, and returns a `DeepMapResult`. The
+ * `DeepMapResult` either provides a result value for that node (i.e.,
+ * representing the subtree), or indicates that the node should be processed
+ * recursively. The default zipFn recurses as far as possible and places
+ * arrays at the leaves.
+ * @returns A `LazyIterator` of batches of elements, represented as an object
+ * with collections at the leaves.
+ */
+ columnMajorBatch(batchSize, smallLastBatch = true,
+ // tslint:disable-next-line:no-any
+ zipFn = deep_map["f" /* zipToList */]) {
+ // First collect the desired number of input elements as a row-major batch.
+ const rowBatches = this.rowMajorBatch(batchSize, smallLastBatch);
+ // Now 'rotate' or 'pivot' the data, collecting all values from each column
+ // in the batch (i.e., for each key within the elements) into an array.
+ return rowBatches.map(x => Object(deep_map["d" /* deepZip */])(x, zipFn));
+ }
+ /**
+ * Concatenate this `LazyIterator` with another.
+ *
+ * @param iterator A `LazyIterator` to be concatenated onto this one.
+ * @param baseErrorHandler An optional function that can intercept `Error`s
+ * raised during a `next()` call on the base stream. This function can
+ * decide whether the error should be propagated, whether the error should
+ * be ignored, or whether the base stream should be terminated.
+ * @returns A `LazyIterator`.
+ */
+ concatenate(iterator, baseErrorHandler) {
+ return new ChainedIterator(iteratorFromItems([this, iterator]), baseErrorHandler);
+ }
+ /**
+ * Limits this stream to return at most `count` items.
+ *
+ * @param count The maximum number of items to provide from the stream. If
+ * a negative or undefined value is given, the entire stream is returned
+ * unaltered.
+ */
+ take(count) {
+ if (count < 0 || count == null) {
+ return this;
+ }
+ return new TakeIterator(this, count);
+ }
+ /**
+ * Skips the first `count` items in this stream.
+ *
+ * @param count The number of items to skip. If a negative or undefined
+ * value is given, the entire stream is returned unaltered.
+ */
+ skip(count) {
+ if (count < 0 || count == null) {
+ return this;
+ }
+ return new lazy_iterator_SkipIterator(this, count);
+ }
+ /**
+ * Prefetch the first `bufferSize` items in this stream.
+ *
+ * Note this prefetches Promises, but makes no guarantees about when those
+ * Promises resolve.
+ *
+ * @param bufferSize: An integer specifying the number of elements to be
+ * prefetched.
+ */
+ prefetch(bufferSize) {
+ return new lazy_iterator_PrefetchIterator(this, bufferSize);
+ }
+ // TODO(soergel): deep sharded shuffle, where supported
+ /**
+ * Randomly shuffles the elements of this stream.
+ *
+ * @param bufferSize: An integer specifying the number of elements from
+ * this stream from which the new stream will sample.
+ * @param seed: (Optional.) An integer specifying the random seed that
+ * will be used to create the distribution.
+ */
+ shuffle(windowSize, seed) {
+ return new lazy_iterator_ShuffleIterator(this, windowSize, seed);
+ }
+ /**
+ * Force an iterator to execute serially: each next() call will await the
+ * prior one, so that they cannot execute concurrently.
+ */
+ serial() {
+ return new SerialIterator(this);
+ }
+}
+// ============================================================================
+// The following private classes serve to implement the chainable methods
+// on LazyIterator. Unfortunately they can't be placed in separate files,
+// due to resulting trouble with circular imports.
+// ============================================================================
+// Iterators that just extend LazyIterator directly
+// ============================================================================
+class lazy_iterator_ArrayIterator extends lazy_iterator_LazyIterator {
+ constructor(items) {
+ super();
+ this.items = items;
+ this.trav = 0;
+ }
+ summary() {
+ return `Array of ${this.items.length} items`;
+ }
+ async next() {
+ if (this.trav >= this.items.length) {
+ return { value: null, done: true };
+ }
+ const item = this.items[this.trav];
+ this.trav++;
+ return { value: deepClone(item), done: false };
+ }
+}
+class FunctionCallIterator extends lazy_iterator_LazyIterator {
+ constructor(nextFn) {
+ super();
+ this.nextFn = nextFn;
+ }
+ summary() {
+ return `Function call`;
+ }
+ async next() {
+ try {
+ return this.nextFn();
+ }
+ catch (e) {
+ // Modify the error message but leave the stack trace intact
+ e.message =
+ `Error thrown while iterating through a dataset: ${e.message}`;
+ throw e;
+ }
+ }
+}
+class SerialIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream) {
+ super();
+ this.upstream = upstream;
+ this.lastRead = Promise.resolve({ value: null, done: false });
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Serial`;
+ }
+ async next() {
+ // This sets this.lastRead to a new Promise right away, as opposed to
+ // saying `await this.lastRead; this.lastRead = this.serialNext();` which
+ // would not work because this.nextRead would be updated only after the
+ // promise resolves.
+ this.lastRead = this.lastRead.then(() => this.serialNext());
+ return this.lastRead;
+ }
+ async serialNext() {
+ return this.upstream.next();
+ }
+}
+class lazy_iterator_SkipIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream, maxCount) {
+ super();
+ this.upstream = upstream;
+ this.maxCount = maxCount;
+ // Local state that should not be clobbered by out-of-order execution.
+ this.count = 0;
+ this.lastRead = Promise.resolve({ value: null, done: false });
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Skip`;
+ }
+ async next() {
+ // This sets this.lastRead to a new Promise right away, as opposed to
+ // saying `await this.lastRead; this.lastRead = this.serialNext();` which
+ // would not work because this.nextRead would be updated only after the
+ // promise resolves.
+ this.lastRead = this.lastRead.then(() => this.serialNext());
+ return this.lastRead;
+ }
+ async serialNext() {
+ // TODO(soergel): consider tradeoffs of reading in parallel, eg.
+ // collecting next() promises in an Array and then waiting for
+ // Promise.all() of those. Benefit: pseudo-parallel execution. Drawback:
+ // maybe delayed GC.
+ while (this.count++ < this.maxCount) {
+ const skipped = await this.upstream.next();
+ // short-circuit if upstream is already empty
+ if (skipped.done) {
+ return skipped;
+ }
+ dist["dispose"](skipped.value);
+ }
+ return this.upstream.next();
+ }
+}
+class TakeIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream, maxCount) {
+ super();
+ this.upstream = upstream;
+ this.maxCount = maxCount;
+ this.count = 0;
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Take`;
+ }
+ async next() {
+ if (this.count++ >= this.maxCount) {
+ return { value: null, done: true };
+ }
+ return this.upstream.next();
+ }
+}
+// Note this batch just groups items into row-wise element arrays.
+// Rotating these to a column-wise representation happens only at the dataset
+// level.
+class RowMajorBatchIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream, batchSize, enableSmallLastBatch = true) {
+ super();
+ this.upstream = upstream;
+ this.batchSize = batchSize;
+ this.enableSmallLastBatch = enableSmallLastBatch;
+ this.lastRead = Promise.resolve({ value: null, done: false });
+ }
+ summary() {
+ return `${this.upstream.summary()} -> RowMajorBatch`;
+ }
+ async next() {
+ // This sets this.lastRead to a new Promise right away, as opposed to
+ // saying `await this.lastRead; this.lastRead = this.serialNext();` which
+ // would not work because this.nextRead would be updated only after the
+ // promise resolves.
+ this.lastRead = this.lastRead.then(() => this.serialNext());
+ return this.lastRead;
+ }
+ async serialNext() {
+ const batch = [];
+ while (batch.length < this.batchSize) {
+ const item = await this.upstream.next();
+ if (item.done) {
+ if (this.enableSmallLastBatch && batch.length > 0) {
+ return { value: batch, done: false };
+ }
+ return { value: null, done: true };
+ }
+ batch.push(item.value);
+ }
+ return { value: batch, done: false };
+ }
+}
+class lazy_iterator_FilterIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream, predicate) {
+ super();
+ this.upstream = upstream;
+ this.predicate = predicate;
+ this.lastRead = Promise.resolve({ value: null, done: false });
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Filter`;
+ }
+ async next() {
+ // This sets this.lastRead to a new Promise right away, as opposed to
+ // saying `await this.lastRead; this.lastRead = this.serialNext();` which
+ // would not work because this.nextRead would be updated only after the
+ // promise resolves.
+ this.lastRead = this.lastRead.then(() => this.serialNext());
+ return this.lastRead;
+ }
+ async serialNext() {
+ while (true) {
+ const item = await this.upstream.next();
+ if (item.done || this.predicate(item.value)) {
+ return item;
+ }
+ dist["dispose"](item.value);
+ }
+ }
+}
+class lazy_iterator_MapIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream, transform) {
+ super();
+ this.upstream = upstream;
+ this.transform = transform;
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Map`;
+ }
+ async next() {
+ const item = await this.upstream.next();
+ if (item.done) {
+ return { value: null, done: true };
+ }
+ const inputTensors = dist["tensor_util"].getTensorsInContainer(item.value);
+ // Careful: the transform may mutate the item in place.
+ // That's why we have to remember the input Tensors above, and then
+ // below dispose only those that were not passed through to the output.
+ // Note too that the transform function is responsible for tidying
+ // any intermediate Tensors. Here we are concerned only about the
+ // inputs.
+ const mapped = this.transform(item.value);
+ const outputTensors = dist["tensor_util"].getTensorsInContainer(mapped);
+ // TODO(soergel) faster intersection
+ // TODO(soergel) move to tf.disposeExcept(in, out)?
+ for (const t of inputTensors) {
+ if (!dist["tensor_util"].isTensorInList(t, outputTensors)) {
+ t.dispose();
+ }
+ }
+ return { value: mapped, done: false };
+ }
+}
+class ErrorHandlingLazyIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream, handler) {
+ super();
+ this.upstream = upstream;
+ this.handler = handler;
+ this.count = 0;
+ this.lastRead = Promise.resolve({ value: null, done: false });
+ }
+ summary() {
+ return `${this.upstream.summary()} -> handleErrors`;
+ }
+ async next() {
+ // This sets this.lastRead to a new Promise right away, as opposed to
+ // saying `await this.lastRead; this.lastRead = this.serialNext();` which
+ // would not work because this.nextRead would be updated only after the
+ // promise resolves.
+ this.lastRead = this.lastRead.then(() => this.serialNext());
+ return this.lastRead;
+ }
+ async serialNext() {
+ while (true) {
+ try {
+ return await this.upstream.next();
+ }
+ catch (e) {
+ if (!this.handler(e)) {
+ return { value: null, done: true };
+ }
+ // If the handler returns true, loop and fetch the next upstream item.
+ // If the upstream iterator throws an endless stream of errors, and if
+ // the handler says to ignore them, then we loop forever here. That is
+ // the correct behavior-- it's up to the handler to decide when to stop.
+ }
+ }
+ }
+}
+class lazy_iterator_AsyncMapIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream, transform) {
+ super();
+ this.upstream = upstream;
+ this.transform = transform;
+ }
+ summary() {
+ return `${this.upstream.summary()} -> AsyncMap`;
+ }
+ async next() {
+ const item = await this.upstream.next();
+ if (item.done) {
+ return { value: null, done: true };
+ }
+ const inputTensors = dist["tensor_util"].getTensorsInContainer(item.value);
+ // Careful: the transform may mutate the item in place.
+ // That's why we have to remember the input Tensors above, and then
+ // below dispose only those that were not passed through to the output.
+ // Note too that the transform function is responsible for tidying
+ // any intermediate Tensors. Here we are concerned only about the
+ // inputs.
+ const mapped = await this.transform(item.value);
+ const outputTensors = dist["tensor_util"].getTensorsInContainer(mapped);
+ // TODO(soergel) faster intersection
+ // TODO(soergel) move to tf.disposeExcept(in, out)?
+ for (const t of inputTensors) {
+ if (!dist["tensor_util"].isTensorInList(t, outputTensors)) {
+ t.dispose();
+ }
+ }
+ return { value: mapped, done: false };
+ }
+}
+// Iterators that maintain a queue of pending items
+// ============================================================================
+/**
+ * A base class for transforming streams that operate by maintaining an
+ * output queue of elements that are ready to return via next(). This is
+ * commonly required when the transformation is 1-to-many: A call to next()
+ * may trigger a call to the underlying stream, which will produce many
+ * mapped elements of this stream-- of which we need to return only one, so
+ * we have to queue the rest.
+ */
+class lazy_iterator_OneToManyIterator extends lazy_iterator_LazyIterator {
+ constructor() {
+ super();
+ this.outputQueue = new growing_ring_buffer_GrowingRingBuffer();
+ this.lastRead = Promise.resolve({ value: null, done: false });
+ }
+ async next() {
+ // This sets this.lastRead to a new Promise right away, as opposed to
+ // saying `await this.lastRead; this.lastRead = this.serialNext();` which
+ // would not work because this.nextRead would be updated only after the
+ // promise resolves.
+ this.lastRead = this.lastRead.then(() => this.serialNext());
+ return this.lastRead;
+ }
+ async serialNext() {
+ // Fetch so that the queue contains at least one item if possible.
+ // If the upstream source is exhausted, AND there are no items left in
+ // the output queue, then this stream is also exhausted.
+ while (this.outputQueue.length() === 0) {
+ // TODO(soergel): consider parallel reads.
+ if (!await this.pump()) {
+ return { value: null, done: true };
+ }
+ }
+ return { value: this.outputQueue.shift(), done: false };
+ }
+}
+class lazy_iterator_FlatmapIterator extends lazy_iterator_OneToManyIterator {
+ constructor(upstream, transform) {
+ super();
+ this.upstream = upstream;
+ this.transform = transform;
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Flatmap`;
+ }
+ async pump() {
+ const item = await this.upstream.next();
+ if (item.done) {
+ return false;
+ }
+ const inputTensors = dist["tensor_util"].getTensorsInContainer(item.value);
+ // Careful: the transform may mutate the item in place.
+ // that's why we have to remember the input Tensors above, and then
+ // below dispose only those that were not passed through to the output.
+ // Note too that the transform function is responsible for tidying any
+ // intermediate Tensors. Here we are concerned only about the inputs.
+ const mappedArray = this.transform(item.value);
+ const outputTensors = dist["tensor_util"].getTensorsInContainer(mappedArray);
+ this.outputQueue.pushAll(mappedArray);
+ // TODO(soergel) faster intersection, and deduplicate outputTensors
+ // TODO(soergel) move to tf.disposeExcept(in, out)?
+ for (const t of inputTensors) {
+ if (!dist["tensor_util"].isTensorInList(t, outputTensors)) {
+ t.dispose();
+ }
+ }
+ return true;
+ }
+}
+/**
+ * Provides a `LazyIterator` that concatenates a stream of underlying
+ * streams.
+ *
+ * Doing this in a concurrency-safe way requires some trickery. In
+ * particular, we want this stream to return the elements from the
+ * underlying streams in the correct order according to when next() was
+ * called, even if the resulting Promises resolve in a different order.
+ */
+class ChainedIterator extends lazy_iterator_LazyIterator {
+ constructor(iterators, baseErrorHandler) {
+ super();
+ this.baseErrorHandler = baseErrorHandler;
+ // Strict Promise execution order:
+ // a next() call may not even begin until the previous one completes.
+ this.lastRead = null;
+ // Local state that should not be clobbered by out-of-order execution.
+ this.iterator = null;
+ this.moreIterators = iterators;
+ }
+ summary() {
+ const upstreamSummaries = 'TODO: fill in upstream of chained summaries';
+ return `${upstreamSummaries} -> Chained`;
+ }
+ async next() {
+ this.lastRead = this.readFromChain(this.lastRead);
+ return this.lastRead;
+ }
+ async readFromChain(lastRead) {
+ // Must await on the previous read since the previous read may have advanced
+ // the stream of streams, from which we need to read.
+ // This is unfortunate since we can't parallelize reads. Which means
+ // prefetching of chained streams is a no-op.
+ // One solution is to prefetch immediately upstream of this.
+ await lastRead;
+ if (this.iterator == null) {
+ const iteratorResult = await this.moreIterators.next();
+ if (iteratorResult.done) {
+ // No more streams to stream from.
+ return { value: null, done: true };
+ }
+ this.iterator = iteratorResult.value;
+ if (this.baseErrorHandler != null) {
+ this.iterator = this.iterator.handleErrors(this.baseErrorHandler);
+ }
+ }
+ const itemResult = await this.iterator.next();
+ if (itemResult.done) {
+ this.iterator = null;
+ return this.readFromChain(lastRead);
+ }
+ return itemResult;
+ }
+}
+var ZipMismatchMode;
+(function (ZipMismatchMode) {
+ ZipMismatchMode[ZipMismatchMode["FAIL"] = 0] = "FAIL";
+ ZipMismatchMode[ZipMismatchMode["SHORTEST"] = 1] = "SHORTEST";
+ ZipMismatchMode[ZipMismatchMode["LONGEST"] = 2] = "LONGEST"; // use nulls for exhausted streams; use up the longest stream.
+})(ZipMismatchMode || (ZipMismatchMode = {}));
+/**
+ * Provides a `LazyIterator` that zips together an array, dict, or nested
+ * structure of `LazyIterator`s (and perhaps additional constants).
+ *
+ * The underlying streams must provide elements in a consistent order such
+ * that they correspond.
+ *
+ * Typically, the underlying streams should have the same number of
+ * elements. If they do not, the behavior is determined by the
+ * `mismatchMode` argument.
+ *
+ * The nested structure of the `iterators` argument determines the
+ * structure of elements in the resulting iterator.
+ *
+ * Doing this in a concurrency-safe way requires some trickery. In
+ * particular, we want this stream to return the elements from the
+ * underlying streams in the correct order according to when next() was
+ * called, even if the resulting Promises resolve in a different order.
+ *
+ * @param iterators: An array or object containing LazyIterators at the
+ * leaves.
+ * @param mismatchMode: Determines what to do when one underlying iterator
+ * is exhausted before the others. `ZipMismatchMode.FAIL` (the default)
+ * causes an error to be thrown in this case. `ZipMismatchMode.SHORTEST`
+ * causes the zipped iterator to terminate with the furst underlying
+ * streams, so elements remaining on the longer streams are ignored.
+ * `ZipMismatchMode.LONGEST` causes the zipped stream to continue, filling
+ * in nulls for the exhausted streams, until all streams are exhausted.
+ */
+class lazy_iterator_ZipIterator extends lazy_iterator_LazyIterator {
+ constructor(iterators, mismatchMode = ZipMismatchMode.FAIL) {
+ super();
+ this.iterators = iterators;
+ this.mismatchMode = mismatchMode;
+ this.count = 0;
+ this.currentPromise = null;
+ }
+ summary() {
+ const upstreamSummaries = 'TODO: fill in upstream of zip summaries';
+ return `{${upstreamSummaries}} -> Zip`;
+ }
+ async nextState(afterState) {
+ // This chaining ensures that the underlying next() are not even called
+ // before the previous ones have resolved.
+ await afterState;
+ // Collect underlying iterator "done" signals as a side effect in
+ // getNext()
+ let numIterators = 0;
+ let iteratorsDone = 0;
+ function getNext(container) {
+ if (container instanceof lazy_iterator_LazyIterator) {
+ const result = container.next();
+ return {
+ value: result.then(x => {
+ numIterators++;
+ if (x.done) {
+ iteratorsDone++;
+ }
+ return x.value;
+ }),
+ recurse: false
+ };
+ }
+ else {
+ return { value: null, recurse: true };
+ }
+ }
+ const mapped = await Object(deep_map["c" /* deepMapAndAwaitAll */])(this.iterators, getNext);
+ if (numIterators === iteratorsDone) {
+ // The streams have all ended.
+ return { value: null, done: true };
+ }
+ if (iteratorsDone > 0) {
+ switch (this.mismatchMode) {
+ case ZipMismatchMode.FAIL:
+ throw new Error('Zipped streams should have the same length. ' +
+ `Mismatched at element ${this.count}.`);
+ case ZipMismatchMode.SHORTEST:
+ return { value: null, done: true };
+ case ZipMismatchMode.LONGEST:
+ default:
+ // Continue. The exhausted streams already produced value: null.
+ }
+ }
+ this.count++;
+ return { value: mapped, done: false };
+ }
+ async next() {
+ this.currentPromise = this.nextState(this.currentPromise);
+ return this.currentPromise;
+ }
+}
+// Iterators that maintain a ring buffer of pending promises
+// ============================================================================
+/**
+ * A stream that prefetches a given number of items from an upstream source,
+ * returning them in FIFO order.
+ *
+ * Note this prefetches Promises, but makes no guarantees about when those
+ * Promises resolve.
+ */
+class lazy_iterator_PrefetchIterator extends lazy_iterator_LazyIterator {
+ constructor(upstream, bufferSize) {
+ super();
+ this.upstream = upstream;
+ this.bufferSize = bufferSize;
+ this.buffer = new RingBuffer(bufferSize);
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Prefetch`;
+ }
+ /**
+ * Refill the prefetch buffer. Returns only after the buffer is full, or
+ * the upstream source is exhausted.
+ */
+ refill() {
+ while (!this.buffer.isFull()) {
+ const v = this.upstream.next();
+ this.buffer.push(v);
+ }
+ }
+ next() {
+ this.refill();
+ // This shift will never throw an error because the buffer is always
+ // full after a refill. If the stream is exhausted, the buffer will be
+ // full of Promises that will resolve to the end-of-stream signal.
+ return this.buffer.shift();
+ }
+}
+/**
+ * A stream that performs a sliding-window random shuffle on an upstream
+ * source. This is like a `PrefetchIterator` except that the items are
+ * returned in randomized order. Mixing naturally improves as the buffer
+ * size increases.
+ */
+class lazy_iterator_ShuffleIterator extends lazy_iterator_PrefetchIterator {
+ constructor(upstream, windowSize, seed) {
+ super(upstream, windowSize);
+ this.upstream = upstream;
+ this.windowSize = windowSize;
+ // Local state that should not be clobbered by out-of-order execution.
+ this.upstreamExhausted = false;
+ this.random = seedrandom["alea"](seed || dist["util"].now().toString());
+ this.lastRead = Promise.resolve({ value: null, done: false });
+ }
+ async next() {
+ // This sets this.lastRead to a new Promise right away, as opposed to
+ // saying `await this.lastRead; this.lastRead = this.serialNext();` which
+ // would not work because this.nextRead would be updated only after the
+ // promise resolves.
+ this.lastRead = this.lastRead.then(() => this.serialNext());
+ return this.lastRead;
+ }
+ randomInt(max) {
+ return Math.floor(this.random() * max);
+ }
+ chooseIndex() {
+ return this.randomInt(this.buffer.length());
+ }
+ async serialNext() {
+ // TODO(soergel): consider performance
+ if (!this.upstreamExhausted) {
+ this.refill();
+ }
+ while (!this.buffer.isEmpty()) {
+ const chosenIndex = this.chooseIndex();
+ const result = await this.buffer.shuffleExcise(chosenIndex);
+ if (result.done) {
+ this.upstreamExhausted = true;
+ }
+ else {
+ this.refill();
+ return result;
+ }
+ }
+ return { value: null, done: true };
+ }
+}
+//# sourceMappingURL=lazy_iterator.js.map
+
+/***/ }),
+/* 15 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(Buffer) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return OperationMapper; });
+/* unused harmony export decodeBase64 */
+/* unused harmony export parseStringParam */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return getStringParam; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return getBoolParam; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return getNumberParam; });
+/* unused harmony export parseDtypeParam */
+/* unused harmony export getFuncParam */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return getDtypeParam; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return getDtypeArrayParam; });
+/* unused harmony export parseTensorShapeParam */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return getTensorShapeParam; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return getNumericArrayParam; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return getStringArrayParam; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return getTensorShapeArrayParam; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getBoolArrayParam; });
+/* harmony import */ var _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(21);
+/* harmony import */ var _custom_op_register__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(24);
+/* harmony import */ var _executors_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2);
+/* harmony import */ var _op_list_arithmetic__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(41);
+/* harmony import */ var _op_list_basic_math__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(42);
+/* harmony import */ var _op_list_control__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(43);
+/* harmony import */ var _op_list_convolution__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(44);
+/* harmony import */ var _op_list_creation__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(45);
+/* harmony import */ var _op_list_dynamic__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(46);
+/* harmony import */ var _op_list_evaluation__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(47);
+/* harmony import */ var _op_list_graph__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(48);
+/* harmony import */ var _op_list_image__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(49);
+/* harmony import */ var _op_list_logical__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(50);
+/* harmony import */ var _op_list_matrices__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(51);
+/* harmony import */ var _op_list_normalization__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(52);
+/* harmony import */ var _op_list_reduction__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(53);
+/* harmony import */ var _op_list_slice_join__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(54);
+/* harmony import */ var _op_list_spectral__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(55);
+/* harmony import */ var _op_list_transformation__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(56);
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class OperationMapper {
+ // Singleton instance for the mapper
+ static get Instance() {
+ return this._instance || (this._instance = new this());
+ }
+ // Loads the op mapping from the JSON file.
+ constructor() {
+ const ops = [
+ _op_list_arithmetic__WEBPACK_IMPORTED_MODULE_4__, _op_list_basic_math__WEBPACK_IMPORTED_MODULE_5__, _op_list_control__WEBPACK_IMPORTED_MODULE_6__, _op_list_convolution__WEBPACK_IMPORTED_MODULE_7__, _op_list_creation__WEBPACK_IMPORTED_MODULE_8__, _op_list_dynamic__WEBPACK_IMPORTED_MODULE_9__,
+ _op_list_evaluation__WEBPACK_IMPORTED_MODULE_10__, _op_list_logical__WEBPACK_IMPORTED_MODULE_13__, _op_list_image__WEBPACK_IMPORTED_MODULE_12__, _op_list_graph__WEBPACK_IMPORTED_MODULE_11__, _op_list_matrices__WEBPACK_IMPORTED_MODULE_14__, _op_list_normalization__WEBPACK_IMPORTED_MODULE_15__, _op_list_reduction__WEBPACK_IMPORTED_MODULE_16__,
+ _op_list_slice_join__WEBPACK_IMPORTED_MODULE_17__, _op_list_spectral__WEBPACK_IMPORTED_MODULE_18__, _op_list_transformation__WEBPACK_IMPORTED_MODULE_19__
+ ];
+ const mappersJson = [].concat(...ops.map(op => op.json));
+ this.opMappers = mappersJson.reduce((map, mapper) => {
+ map[mapper.tfOpName] = mapper;
+ return map;
+ }, {});
+ }
+ // Converts the model from Tensorflow GraphDef to local representation for
+ // TensorFlow.js API
+ transformGraph(graph, signature = {}) {
+ const tfNodes = graph.node;
+ const placeholders = [];
+ const weights = [];
+ const nodes = tfNodes.reduce((map, node) => {
+ map[node.name] = this.mapNode(node);
+ if (node.op.startsWith('Placeholder')) {
+ placeholders.push(map[node.name]);
+ }
+ if (node.op === 'Const') {
+ weights.push(map[node.name]);
+ }
+ return map;
+ }, {});
+ let inputs = [];
+ const outputs = [];
+ let inputNodeNameToKey = {};
+ let outputNodeNameToKey = {};
+ if (signature != null) {
+ inputNodeNameToKey = this.mapSignatureEntries(signature.inputs);
+ outputNodeNameToKey = this.mapSignatureEntries(signature.outputs);
+ }
+ const allNodes = Object.keys(nodes);
+ allNodes.forEach(key => {
+ const node = nodes[key];
+ node.inputNames.forEach(name => {
+ const [nodeName,] = Object(_executors_utils__WEBPACK_IMPORTED_MODULE_3__[/* getNodeNameAndIndex */ "a"])(name);
+ node.inputs.push(nodes[nodeName]);
+ nodes[nodeName].children.push(node);
+ });
+ });
+ // if signature has not outputs set, add any node that does not have
+ // outputs.
+ if (Object.keys(outputNodeNameToKey).length === 0) {
+ allNodes.forEach(key => {
+ const node = nodes[key];
+ if (node.children.length === 0) {
+ outputs.push(node);
+ }
+ });
+ }
+ else {
+ Object.keys(outputNodeNameToKey).forEach(name => {
+ const [nodeName,] = Object(_executors_utils__WEBPACK_IMPORTED_MODULE_3__[/* getNodeNameAndIndex */ "a"])(name);
+ const node = nodes[nodeName];
+ if (node != null) {
+ node.signatureKey = outputNodeNameToKey[name];
+ outputs.push(node);
+ }
+ });
+ }
+ if (Object.keys(inputNodeNameToKey).length > 0) {
+ Object.keys(inputNodeNameToKey).forEach(name => {
+ const [nodeName,] = Object(_executors_utils__WEBPACK_IMPORTED_MODULE_3__[/* getNodeNameAndIndex */ "a"])(name);
+ const node = nodes[nodeName];
+ if (node) {
+ node.signatureKey = inputNodeNameToKey[name];
+ inputs.push(node);
+ }
+ });
+ }
+ else {
+ inputs = placeholders;
+ }
+ let functions = {};
+ if (graph.library != null && graph.library.function != null) {
+ functions = graph.library.function.reduce((functions, func) => {
+ functions[func.signature.name] = this.mapFunction(func);
+ return functions;
+ }, {});
+ }
+ return {
+ nodes,
+ inputs,
+ outputs,
+ weights,
+ placeholders,
+ signature,
+ functions
+ };
+ }
+ mapSignatureEntries(entries) {
+ return Object.keys(entries || {})
+ .reduce((prev, curr) => {
+ prev[entries[curr].name] = curr;
+ return prev;
+ }, {});
+ }
+ mapNode(node) {
+ // Unsupported ops will cause an error at run-time (not parse time), since
+ // they may not be used by the actual execution subgraph.
+ const mapper = Object(_custom_op_register__WEBPACK_IMPORTED_MODULE_2__[/* getRegisteredOp */ "b"])(node.op) || this.opMappers[node.op] || {};
+ if (node.attr == null) {
+ node.attr = {};
+ }
+ const newNode = {
+ name: node.name,
+ op: node.op,
+ category: mapper.category,
+ inputNames: (node.input ||
+ []).map(input => input.startsWith('^') ? input.substr(1) : input),
+ inputs: [],
+ children: [],
+ inputParams: {},
+ attrParams: {},
+ rawAttrs: node.attr
+ };
+ if (mapper.inputs != null) {
+ newNode.inputParams =
+ mapper.inputs.reduce((map, param) => {
+ map[param.name] = {
+ type: param.type,
+ inputIndexStart: param.start,
+ inputIndexEnd: param.end
+ };
+ return map;
+ }, {});
+ }
+ if (mapper.attrs != null) {
+ newNode.attrParams =
+ mapper.attrs.reduce((map, param) => {
+ const type = param.type;
+ let value = undefined;
+ switch (param.type) {
+ case 'string':
+ value = getStringParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getStringParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'string[]':
+ value = getStringArrayParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getStringArrayParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'number':
+ value = getNumberParam(node.attr, param.tfName, (param.defaultValue || 0));
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getNumberParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'number[]':
+ value = getNumericArrayParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getNumericArrayParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'bool':
+ value = getBoolParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getBoolParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'bool[]':
+ value = getBoolArrayParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getBoolArrayParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'shape':
+ value = getTensorShapeParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getTensorShapeParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'shape[]':
+ value = getTensorShapeArrayParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getTensorShapeArrayParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'dtype':
+ value = getDtypeParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getDtypeParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'dtype[]':
+ value = getDtypeArrayParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getDtypeArrayParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'func':
+ value = getFuncParam(node.attr, param.tfName, param.defaultValue);
+ if (value === undefined && !!param.tfDeprecatedName) {
+ value = getFuncParam(node.attr, param.tfDeprecatedName, param.defaultValue);
+ }
+ break;
+ case 'tensor':
+ case 'tensors':
+ break;
+ default:
+ throw new Error(`Unsupported param type: ${param.type} for op: ${node.op}`);
+ }
+ map[param.name] = { value, type };
+ return map;
+ }, {});
+ }
+ return newNode;
+ }
+ // map the TFunctionDef to TFJS graph object
+ mapFunction(functionDef) {
+ const tfNodes = functionDef.nodeDef;
+ const placeholders = [];
+ const weights = [];
+ let nodes = {};
+ if (tfNodes != null) {
+ nodes = tfNodes.reduce((map, node) => {
+ map[node.name] = this.mapNode(node);
+ if (node.op === 'Const') {
+ weights.push(map[node.name]);
+ }
+ return map;
+ }, {});
+ }
+ const inputs = [];
+ const outputs = [];
+ functionDef.signature.inputArg.forEach(arg => {
+ const [nodeName,] = Object(_executors_utils__WEBPACK_IMPORTED_MODULE_3__[/* getNodeNameAndIndex */ "a"])(arg.name);
+ const node = {
+ name: nodeName,
+ op: 'Placeholder',
+ inputs: [],
+ inputNames: [],
+ category: 'graph',
+ inputParams: {},
+ attrParams: { dtype: { value: parseDtypeParam(arg.type), type: 'dtype' } },
+ children: []
+ };
+ node.signatureKey = arg.name;
+ inputs.push(node);
+ nodes[nodeName] = node;
+ });
+ const allNodes = Object.keys(nodes);
+ allNodes.forEach(key => {
+ const node = nodes[key];
+ node.inputNames.forEach(name => {
+ const [nodeName,] = Object(_executors_utils__WEBPACK_IMPORTED_MODULE_3__[/* getNodeNameAndIndex */ "a"])(name);
+ node.inputs.push(nodes[nodeName]);
+ nodes[nodeName].children.push(node);
+ });
+ });
+ const returnNodeMap = functionDef.ret;
+ functionDef.signature.outputArg.forEach(output => {
+ const [nodeName, index] = Object(_executors_utils__WEBPACK_IMPORTED_MODULE_3__[/* getNodeNameAndIndex */ "a"])(returnNodeMap[output.name]);
+ const node = nodes[nodeName];
+ if (node != null) {
+ node.defaultOutput = index;
+ outputs.push(node);
+ }
+ });
+ const signature = this.mapArgsToSignature(functionDef);
+ return { nodes, inputs, outputs, weights, placeholders, signature };
+ }
+ mapArgsToSignature(functionDef) {
+ return {
+ methodName: functionDef.signature.name,
+ inputs: functionDef.signature.inputArg.reduce((map, arg) => {
+ map[arg.name] = this.mapArgToTensorInfo(arg);
+ return map;
+ }, {}),
+ outputs: functionDef.signature.outputArg.reduce((map, arg) => {
+ map[arg.name] = this.mapArgToTensorInfo(arg, functionDef.ret);
+ return map;
+ }, {}),
+ };
+ }
+ mapArgToTensorInfo(arg, nameMap) {
+ let name = arg.name;
+ if (nameMap != null) {
+ name = nameMap[name];
+ }
+ return { name, dtype: arg.type };
+ }
+}
+function decodeBase64(text) {
+ const global = Object(_tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["env"])().global;
+ if (typeof global.atob !== 'undefined') {
+ return global.atob(text);
+ }
+ else if (typeof Buffer !== 'undefined') {
+ return new Buffer(text, 'base64').toString();
+ }
+ else {
+ throw new Error('Unable to decode base64 in this environment. ' +
+ 'Missing built-in atob() or Buffer()');
+ }
+}
+function parseStringParam(s, keepCase) {
+ const value = Array.isArray(s) ? String.fromCharCode.apply(null, s) : decodeBase64(s);
+ return keepCase ? value : value.toLowerCase();
+}
+function getStringParam(attrs, name, def, keepCase = false) {
+ const param = attrs[name];
+ if (param != null) {
+ return parseStringParam(param.s, keepCase);
+ }
+ return def;
+}
+function getBoolParam(attrs, name, def) {
+ const param = attrs[name];
+ return param ? param.b : def;
+}
+function getNumberParam(attrs, name, def) {
+ const param = attrs[name] || {};
+ const value = param['i'] != null ? param['i'] : (param['f'] != null ? param['f'] : def);
+ return (typeof value === 'number') ? value : parseInt(value, 10);
+}
+function parseDtypeParam(value) {
+ if (typeof (value) === 'string') {
+ // tslint:disable-next-line:no-any
+ value = _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"][value];
+ }
+ switch (value) {
+ case _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"].DT_FLOAT:
+ return 'float32';
+ case _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"].DT_INT32:
+ case _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"].DT_INT64:
+ case _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"].DT_INT8:
+ case _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"].DT_UINT8:
+ return 'int32';
+ case _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"].DT_BOOL:
+ return 'bool';
+ case _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"].DT_DOUBLE:
+ return 'float32';
+ case _data_compiled_api__WEBPACK_IMPORTED_MODULE_1__[/* DataType */ "a"].DT_STRING:
+ return 'string';
+ default:
+ // Unknown dtype error will happen at runtime (instead of parse time),
+ // since these nodes might not be used by the actual subgraph execution.
+ return null;
+ }
+}
+function getFuncParam(attrs, name, def) {
+ const param = attrs[name];
+ if (param && param.func) {
+ return param.func.name;
+ }
+ return def;
+}
+function getDtypeParam(attrs, name, def) {
+ const param = attrs[name];
+ if (param && param.type) {
+ return parseDtypeParam(param.type);
+ }
+ return def;
+}
+function getDtypeArrayParam(attrs, name, def) {
+ const param = attrs[name];
+ if (param && param.list && param.list.type) {
+ return param.list.type.map(v => parseDtypeParam(v));
+ }
+ return def;
+}
+function parseTensorShapeParam(shape) {
+ if (shape.unknownRank) {
+ return undefined;
+ }
+ if (shape.dim != null) {
+ return shape.dim.map(dim => (typeof dim.size === 'number') ? dim.size : parseInt(dim.size, 10));
+ }
+ return [];
+}
+function getTensorShapeParam(attrs, name, def) {
+ const param = attrs[name];
+ if (param && param.shape) {
+ return parseTensorShapeParam(param.shape);
+ }
+ return def;
+}
+function getNumericArrayParam(attrs, name, def) {
+ const param = attrs[name];
+ if (param) {
+ return ((param.list.f && param.list.f.length ? param.list.f :
+ param.list.i) ||
+ [])
+ .map(v => (typeof v === 'number') ? v : parseInt(v, 10));
+ }
+ return def;
+}
+function getStringArrayParam(attrs, name, def, keepCase = false) {
+ const param = attrs[name];
+ if (param && param.list && param.list.s) {
+ return param.list.s.map((v) => {
+ return parseStringParam(v, keepCase);
+ });
+ }
+ return def;
+}
+function getTensorShapeArrayParam(attrs, name, def) {
+ const param = attrs[name];
+ if (param && param.list && param.list.shape) {
+ return param.list.shape.map((v) => {
+ return parseTensorShapeParam(v);
+ });
+ }
+ return def;
+}
+function getBoolArrayParam(attrs, name, def) {
+ const param = attrs[name];
+ if (param && param.list && param.list.b) {
+ return param.list.b;
+ }
+ return def;
+}
+//# sourceMappingURL=operation_mapper.js.map
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(39).Buffer))
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports) {
+
+module.exports = function() {
+ throw new Error("define cannot be used indirect");
+};
+
+
+/***/ }),
+/* 17 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getKernel; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getGradient; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return getKernelsForBackend; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return registerKernel; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return registerGradient; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return unregisterKernel; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return unregisterGradient; });
+/* harmony import */ var _global_util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33);
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+const kernelRegistry = Object(_global_util__WEBPACK_IMPORTED_MODULE_0__[/* getGlobal */ "a"])('kernelRegistry', () => new Map());
+const gradRegistry = Object(_global_util__WEBPACK_IMPORTED_MODULE_0__[/* getGlobal */ "a"])('gradRegistry', () => new Map());
+/**
+ * Returns the kernel function (code) associated with the provided names.
+ *
+ * @param kernelName The official name of the kernel.
+ * @param backendName The official name of the backend.
+ */
+function getKernel(kernelName, backendName) {
+ const key = makeKey(kernelName, backendName);
+ return kernelRegistry.get(key);
+}
+/**
+ * Returns the registered gradient info associated with the provided kernel.
+ * @param kernelName The official TF kernel name.
+ */
+function getGradient(kernelName) {
+ return gradRegistry.get(kernelName);
+}
+function getKernelsForBackend(backendName) {
+ const it = kernelRegistry.entries();
+ const result = [];
+ while (true) {
+ const { done, value } = it.next();
+ if (done) {
+ break;
+ }
+ const [key, config] = value;
+ const [backend,] = key.split('_');
+ if (backend === backendName) {
+ result.push(config);
+ }
+ }
+ return result;
+}
+/**
+ * Registers the function (forward pass) for the kernel in a global registry.
+ *
+ * @param config A config object with the following properties:
+ * - `kernelName` The official name of the kernel.
+ * - `backendName` The official name of the backend.
+ * - `kernelFunc` The function to run during the forward pass of the kernel.
+ * - `setupFunc` Optional. Gets called once, after the backend initializes.
+ * - `disposeFunc` Optional. Gets called once, right before the backend is
+ * disposed.
+ */
+function registerKernel(config) {
+ const { kernelName, backendName } = config;
+ const key = makeKey(kernelName, backendName);
+ if (kernelRegistry.has(key)) {
+ console.warn(`The kernel '${kernelName}' for backend ` +
+ `'${backendName}' is already registered`);
+ }
+ kernelRegistry.set(key, config);
+}
+/**
+ * Registers a gradient function for a given kernel in the global registry,
+ * to be used during the back-propagation of that kernel.
+ *
+ * @param config An object with the following properties:
+ * - `kernelName` The name of the kernel that the gradient function is for.
+ * - `gradFunc` The function to run during back-propagation.
+ */
+function registerGradient(config) {
+ const { kernelName } = config;
+ if (gradRegistry.has(kernelName)) {
+ console.warn(`Overriding the gradient for '${kernelName}'`);
+ }
+ gradRegistry.set(kernelName, config);
+}
+/**
+ * Removes the kernel function from the registry.
+ *
+ * @param kernelName The official name of the kernel.
+ * @param backendName The official name of the backend.
+ *
+ */
+function unregisterKernel(kernelName, backendName) {
+ const key = makeKey(kernelName, backendName);
+ if (!kernelRegistry.has(key)) {
+ throw new Error(`The kernel '${kernelName}' for backend ` +
+ `'${backendName}' is not registered`);
+ }
+ kernelRegistry.delete(key);
+}
+/** Removes the registered gradient from the global registry. */
+function unregisterGradient(kernelName) {
+ if (!gradRegistry.has(kernelName)) {
+ throw new Error(`The gradient '${kernelName}' for backend is not registered`);
+ }
+ gradRegistry.delete(kernelName);
+}
+function makeKey(kernelName, backendName) {
+ return `${backendName}_${kernelName}`;
+}
+//# sourceMappingURL=kernel_registry.js.map
+
+/***/ }),
+/* 18 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return complex; });
+/* harmony import */ var _engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
+/* harmony import */ var _kernel_names__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
+/* harmony import */ var _tensor_util_env__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1);
+/* harmony import */ var _operation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4);
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+/**
+ * Converts two real numbers to a complex number.
+ *
+ * Given a tensor `real` representing the real part of a complex number, and a
+ * tensor `imag` representing the imaginary part of a complex number, this
+ * operation returns complex numbers elementwise of the form [r0, i0, r1, i1],
+ * where r represents the real part and i represents the imag part.
+ *
+ * The input tensors real and imag must have the same shape.
+ *
+ * ```js
+ * const real = tf.tensor1d([2.25, 3.25]);
+ * const imag = tf.tensor1d([4.75, 5.75]);
+ * const complex = tf.complex(real, imag);
+ *
+ * complex.print();
+ * ```
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function complex_(real, imag) {
+ const $real = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* convertToTensor */ "a"])(real, 'real', 'complex');
+ const $imag = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* convertToTensor */ "a"])(imag, 'imag', 'complex');
+ _util__WEBPACK_IMPORTED_MODULE_3__["assertShapesMatch"]($real.shape, $imag.shape, `real and imag shapes, ${$real.shape} and ${$imag.shape}, ` +
+ `must match in call to tf.complex().`);
+ const forward = (backend) => {
+ return backend.complex($real, $imag);
+ };
+ const inputs = { real: $real, imag: $imag };
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].runKernelFunc(forward, inputs, null /* gradient */, _kernel_names__WEBPACK_IMPORTED_MODULE_1__[/* Complex */ "k"]);
+}
+const complex = Object(_operation__WEBPACK_IMPORTED_MODULE_4__[/* op */ "a"])({ complex_ });
+//# sourceMappingURL=complex.js.map
+
+/***/ }),
+/* 19 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return deepMap; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return deepZip; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return zipToList; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return deepMapAndAwaitAll; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return isIterable; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return canTensorify; });
+/* harmony import */ var _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * =============================================================================
+ */
+
+/**
+ * Apply a mapping function to a nested structure in a recursive manner.
+ *
+ * The result of the mapping is an object with the same nested structure (i.e.,
+ * of arrays and dicts) as the input, except that some subtrees are replaced,
+ * according to the results of the mapping function.
+ *
+ * Mappings are memoized. Thus, if the nested structure contains the same
+ * object in multiple positions, the output will contain the same mapped object
+ * in those positions. Cycles are not supported, however.
+ *
+ * @param input: The object to which to apply the mapping function.
+ * @param mapFn: A function that expects a single node of the object tree, and
+ * returns a `DeepMapResult`. The `DeepMapResult` either provides a
+ * replacement value for that node (i.e., replacing the subtree), or indicates
+ * that the node should be processed recursively.
+ */
+function deepMap(input, mapFn) {
+ return deepMapInternal(input, mapFn);
+}
+/**
+ * @param seen: A Map of known object mappings (i.e., memoized results of
+ * `mapFn()`)
+ * @param containedIn: An set containing objects on the reference path currently
+ * being processed (used to detect cycles).
+ */
+function deepMapInternal(input, mapFn, seen = new Map(), containedIn = new Set()) {
+ if (input == null) {
+ return null;
+ }
+ if (containedIn.has(input)) {
+ throw new Error('Circular references are not supported.');
+ }
+ if (seen.has(input)) {
+ return seen.get(input);
+ }
+ const result = mapFn(input);
+ if (result.recurse && result.value !== null) {
+ throw new Error('A deep map function may not return both a value and recurse=true.');
+ }
+ if (!result.recurse) {
+ seen.set(input, result.value);
+ return result.value;
+ }
+ else if (isIterable(input)) {
+ // tslint:disable-next-line:no-any
+ const mappedIterable = Array.isArray(input) ? [] : {};
+ containedIn.add(input);
+ for (const k in input) {
+ const child = input[k];
+ const childResult = deepMapInternal(child, mapFn, seen, containedIn);
+ mappedIterable[k] = childResult;
+ }
+ containedIn.delete(input);
+ return mappedIterable;
+ }
+ else {
+ throw new Error(`Can't recurse into non-iterable type: ${input}`);
+ }
+}
+// TODO(soergel, kangyizhang) Reconsider naming of deepZip() to avoid confusion
+// with zip()
+/**
+ * Zip nested structures together in a recursive manner.
+ *
+ * This has the effect of transposing or pivoting data, e.g. converting it from
+ * a row-major representation to a column-major representation.
+ *
+ * For example, `deepZip([{a: 1, b: 2}, {a: 3, b: 4}])` returns
+ * `{a: [1, 3], b: [2, 4]}`.
+ *
+ * The inputs should all have the same nested structure (i.e., of arrays and
+ * dicts). The result is a single object with the same nested structure, where
+ * the leaves are arrays collecting the values of the inputs at that location
+ * (or, optionally, the result of a custom function applied to those arrays).
+ *
+ * @param inputs: An array of the objects to zip together.
+ * @param zipFn: (optional) A function that expects an array of elements at a
+ * single node of the object tree, and returns a `DeepMapResult`. The
+ * `DeepMapResult` either provides a result value for that node (i.e.,
+ * representing the subtree), or indicates that the node should be processed
+ * recursively. The default zipFn recurses as far as possible and places
+ * arrays at the leaves.
+ */
+function deepZip(inputs, zipFn = zipToList) {
+ return deepZipInternal(inputs, zipFn);
+}
+/**
+ * @param containedIn: An set containing objects on the reference path currently
+ * being processed (used to detect cycles).
+ */
+function deepZipInternal(inputs, zipFn, containedIn = new Set()) {
+ // The recursion follows the structure of input 0; it's assumed that all the
+ // other inputs have the same structure.
+ const input = inputs[0];
+ if (containedIn.has(input)) {
+ throw new Error('Circular references are not supported.');
+ }
+ const result = zipFn(inputs);
+ if (result.recurse && result.value !== null) {
+ throw new Error('A deep zip function may not return both a value and recurse=true.');
+ }
+ if (!result.recurse) {
+ return result.value;
+ }
+ else if (isIterable(input)) {
+ // tslint:disable-next-line:no-any
+ const mappedIterable = Array.isArray(input) ? [] : {};
+ containedIn.add(input);
+ for (const k in input) {
+ const children = inputs.map(x => x[k]);
+ const childResult = deepZipInternal(children, zipFn, containedIn);
+ mappedIterable[k] = childResult;
+ }
+ containedIn.delete(input);
+ return mappedIterable;
+ }
+ else {
+ throw new Error(`Can't recurse into non-iterable type: ${input}`);
+ }
+}
+// tslint:disable-next-line:no-any
+function zipToList(x) {
+ if (x === null) {
+ return null;
+ }
+ // TODO(soergel): validate array type?
+ if (isIterable(x[0])) {
+ return { value: null, recurse: true };
+ }
+ else {
+ return { value: x, recurse: false };
+ }
+}
+/**
+ * Apply an async mapping function to a nested structure in a recursive manner.
+ *
+ * This first creates a nested structure of Promises, and then awaits all of
+ * those, resulting in a single Promise for a resolved nested structure.
+ *
+ * The result of the mapping is an object with the same nested structure (i.e.,
+ * of arrays and dicts) as the input, except that some subtrees are replaced,
+ * according to the results of the mapping function.
+ *
+ * Mappings are memoized. Thus, if the nested structure contains the same
+ * object in multiple positions, the output will contain the same mapped object
+ * in those positions. Cycles are not supported, however.
+ *
+ * @param input: The object to which to apply the mapping function.
+ * @param mapFn: A function that expects a single node of the object tree, and
+ * returns a `DeepMapAsyncResult`. The `DeepMapAsyncResult` either provides
+ * a `Promise` for a replacement value for that node (i.e., replacing the
+ * subtree), or indicates that the node should be processed recursively. Note
+ * that the decision whether or not to recurse must be made immediately; only
+ * the mapped value may be promised.
+ */
+async function deepMapAndAwaitAll(input, mapFn) {
+ const seen = new Map();
+ // First do a normal deepMap, collecting Promises in 'seen' as a side effect.
+ deepMapInternal(input, mapFn, seen);
+ // Replace the Promises in 'seen' in place.
+ // Note TypeScript provides no async map iteration, and regular map iteration
+ // is broken too, so sadly we have to do Array.from() to make it work.
+ // (There's no advantage to Promise.all(), and that would be tricky anyway.)
+ for (const key of Array.from(seen.keys())) {
+ const value = seen.get(key);
+ if (value instanceof Promise) {
+ const mappedValue = await value;
+ seen.set(key, mappedValue);
+ }
+ }
+ // Normal deepMap again, this time filling in the resolved values.
+ // It's unfortunate that we have to do two passes.
+ // TODO(soergel): test performance and think harder about a fast solution.
+ const result = deepMapInternal(input, mapFn, seen);
+ return result;
+}
+/**
+ * Determine whether the argument is iterable.
+ *
+ * @returns true if the argument is an array or any non-Tensor object.
+ */
+// tslint:disable-next-line:no-any
+function isIterable(obj) {
+ return obj != null && (!ArrayBuffer.isView(obj)) &&
+ (Array.isArray(obj) ||
+ (typeof obj === 'object' && !(obj instanceof _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["Tensor"])));
+}
+/**
+ * Determine whether the argument can be converted to Tensor.
+ *
+ * Tensors, primitives, arrays, and TypedArrays all qualify; anything else does
+ * not.
+ *
+ * @returns true if the argument can be converted to Tensor.
+ */
+// tslint:disable-next-line:no-any
+function canTensorify(obj) {
+ return obj == null || isPrimitive(obj) || Array.isArray(obj) ||
+ (typeof obj === 'object' && (obj instanceof _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["Tensor"])) ||
+ _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].isTypedArray(obj);
+}
+/**
+ * Returns true if the given `value` is a primitive type. Otherwise returns
+ * false. This is equivalant to node util.isPrimitive
+ */
+function isPrimitive(value) {
+ return (value === null ||
+ (typeof value !== 'object' && typeof value !== 'function'));
+}
+//# sourceMappingURL=deep_map.js.map
+
+/***/ }),
+/* 20 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// A library of seedable RNGs implemented in Javascript.
+//
+// Usage:
+//
+// var seedrandom = require('seedrandom');
+// var random = seedrandom(1); // or any seed.
+// var x = random(); // 0 <= x < 1. Every bit is random.
+// var x = random.quick(); // 0 <= x < 1. 32 bits of randomness.
+
+// alea, a 53-bit multiply-with-carry generator by Johannes Baagøe.
+// Period: ~2^116
+// Reported to pass all BigCrush tests.
+var alea = __webpack_require__(68);
+
+// xor128, a pure xor-shift generator by George Marsaglia.
+// Period: 2^128-1.
+// Reported to fail: MatrixRank and LinearComp.
+var xor128 = __webpack_require__(69);
+
+// xorwow, George Marsaglia's 160-bit xor-shift combined plus weyl.
+// Period: 2^192-2^32
+// Reported to fail: CollisionOver, SimpPoker, and LinearComp.
+var xorwow = __webpack_require__(70);
+
+// xorshift7, by François Panneton and Pierre L'ecuyer, takes
+// a different approach: it adds robustness by allowing more shifts
+// than Marsaglia's original three. It is a 7-shift generator
+// with 256 bits, that passes BigCrush with no systmatic failures.
+// Period 2^256-1.
+// No systematic BigCrush failures reported.
+var xorshift7 = __webpack_require__(71);
+
+// xor4096, by Richard Brent, is a 4096-bit xor-shift with a
+// very long period that also adds a Weyl generator. It also passes
+// BigCrush with no systematic failures. Its long period may
+// be useful if you have many generators and need to avoid
+// collisions.
+// Period: 2^4128-2^32.
+// No systematic BigCrush failures reported.
+var xor4096 = __webpack_require__(72);
+
+// Tyche-i, by Samuel Neves and Filipe Araujo, is a bit-shifting random
+// number generator derived from ChaCha, a modern stream cipher.
+// https://eden.dei.uc.pt/~sneves/pubs/2011-snfa2.pdf
+// Period: ~2^127
+// No systematic BigCrush failures reported.
+var tychei = __webpack_require__(73);
+
+// The original ARC4-based prng included in this library.
+// Period: ~2^1600
+var sr = __webpack_require__(74);
+
+sr.alea = alea;
+sr.xor128 = xor128;
+sr.xorwow = xorwow;
+sr.xorshift7 = xorshift7;
+sr.xor4096 = xor4096;
+sr.tychei = tychei;
+
+module.exports = sr;
+
+
+/***/ }),
+/* 21 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DataType; });
+/* unused harmony export SaverDef */
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * =============================================================================
+ */
+/** DataType enum. */
+var DataType;
+(function (DataType) {
+ DataType[DataType["DT_INVALID"] = 0] = "DT_INVALID";
+ DataType[DataType["DT_FLOAT"] = 1] = "DT_FLOAT";
+ DataType[DataType["DT_DOUBLE"] = 2] = "DT_DOUBLE";
+ DataType[DataType["DT_INT32"] = 3] = "DT_INT32";
+ DataType[DataType["DT_UINT8"] = 4] = "DT_UINT8";
+ DataType[DataType["DT_INT16"] = 5] = "DT_INT16";
+ DataType[DataType["DT_INT8"] = 6] = "DT_INT8";
+ DataType[DataType["DT_STRING"] = 7] = "DT_STRING";
+ DataType[DataType["DT_COMPLEX64"] = 8] = "DT_COMPLEX64";
+ DataType[DataType["DT_INT64"] = 9] = "DT_INT64";
+ DataType[DataType["DT_BOOL"] = 10] = "DT_BOOL";
+ DataType[DataType["DT_QINT8"] = 11] = "DT_QINT8";
+ DataType[DataType["DT_QUINT8"] = 12] = "DT_QUINT8";
+ DataType[DataType["DT_QINT32"] = 13] = "DT_QINT32";
+ DataType[DataType["DT_BFLOAT16"] = 14] = "DT_BFLOAT16";
+ DataType[DataType["DT_FLOAT_REF"] = 101] = "DT_FLOAT_REF";
+ DataType[DataType["DT_DOUBLE_REF"] = 102] = "DT_DOUBLE_REF";
+ DataType[DataType["DT_INT32_REF"] = 103] = "DT_INT32_REF";
+ DataType[DataType["DT_UINT8_REF"] = 104] = "DT_UINT8_REF";
+ DataType[DataType["DT_INT16_REF"] = 105] = "DT_INT16_REF";
+ DataType[DataType["DT_INT8_REF"] = 106] = "DT_INT8_REF";
+ DataType[DataType["DT_STRING_REF"] = 107] = "DT_STRING_REF";
+ DataType[DataType["DT_COMPLEX64_REF"] = 108] = "DT_COMPLEX64_REF";
+ DataType[DataType["DT_INT64_REF"] = 109] = "DT_INT64_REF";
+ DataType[DataType["DT_BOOL_REF"] = 110] = "DT_BOOL_REF";
+ DataType[DataType["DT_QINT8_REF"] = 111] = "DT_QINT8_REF";
+ DataType[DataType["DT_QUINT8_REF"] = 112] = "DT_QUINT8_REF";
+ DataType[DataType["DT_QINT32_REF"] = 113] = "DT_QINT32_REF";
+ DataType[DataType["DT_BFLOAT16_REF"] = 114] = "DT_BFLOAT16_REF";
+})(DataType || (DataType = {}));
+var SaverDef;
+(function (SaverDef) {
+ /** CheckpointFormatVersion enum. */
+ let CheckpointFormatVersion;
+ (function (CheckpointFormatVersion) {
+ CheckpointFormatVersion[CheckpointFormatVersion["LEGACY"] = 0] = "LEGACY";
+ CheckpointFormatVersion[CheckpointFormatVersion["V1"] = 1] = "V1";
+ CheckpointFormatVersion[CheckpointFormatVersion["V2"] = 2] = "V2";
+ })(CheckpointFormatVersion = SaverDef.CheckpointFormatVersion || (SaverDef.CheckpointFormatVersion = {}));
+})(SaverDef || (SaverDef = {}));
+//# sourceMappingURL=compiled_api.js.map
+
+/***/ }),
+/* 22 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return real; });
+/* harmony import */ var _engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
+/* harmony import */ var _kernel_names__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
+/* harmony import */ var _tensor_util_env__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3);
+/* harmony import */ var _operation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4);
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Returns the real part of a complex (or real) tensor.
+ *
+ * Given a tensor input, this operation returns a tensor of type float that is
+ * the real part of each element in input considered as a complex number.
+ *
+ * If the input is real, it simply makes a clone.
+ *
+ * ```js
+ * const x = tf.complex([-2.25, 3.25], [4.75, 5.75]);
+ * tf.real(x).print();
+ * ```
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function real_(input) {
+ const $input = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* convertToTensor */ "a"])(input, 'input', 'real');
+ const forward = (backend) => {
+ return backend.real($input);
+ };
+ const inputs = { input: $input };
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].runKernelFunc(forward, inputs, null /* gradient */, _kernel_names__WEBPACK_IMPORTED_MODULE_1__[/* Real */ "hb"]);
+}
+const real = Object(_operation__WEBPACK_IMPORTED_MODULE_3__[/* op */ "a"])({ real_ });
+//# sourceMappingURL=real.js.map
+
+/***/ }),
+/* 23 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Rank; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return upcastType; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return sumOutType; });
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+var Rank;
+(function (Rank) {
+ Rank["R0"] = "R0";
+ Rank["R1"] = "R1";
+ Rank["R2"] = "R2";
+ Rank["R3"] = "R3";
+ Rank["R4"] = "R4";
+ Rank["R5"] = "R5";
+ Rank["R6"] = "R6";
+})(Rank || (Rank = {}));
+// Looks for upcasting types. Used, for example, in operations with mixed dtype
+// inputs.
+var UpcastInt32AndMap;
+(function (UpcastInt32AndMap) {
+ UpcastInt32AndMap["float32"] = "float32";
+ UpcastInt32AndMap["int32"] = "int32";
+ UpcastInt32AndMap["bool"] = "int32";
+ UpcastInt32AndMap["complex64"] = "complex64";
+})(UpcastInt32AndMap || (UpcastInt32AndMap = {}));
+var UpcastBoolAndMap;
+(function (UpcastBoolAndMap) {
+ UpcastBoolAndMap["float32"] = "float32";
+ UpcastBoolAndMap["int32"] = "int32";
+ UpcastBoolAndMap["bool"] = "bool";
+ UpcastBoolAndMap["complex64"] = "complex64";
+})(UpcastBoolAndMap || (UpcastBoolAndMap = {}));
+var UpcastFloat32AndMap;
+(function (UpcastFloat32AndMap) {
+ UpcastFloat32AndMap["float32"] = "float32";
+ UpcastFloat32AndMap["int32"] = "float32";
+ UpcastFloat32AndMap["bool"] = "float32";
+ UpcastFloat32AndMap["complex64"] = "complex64";
+})(UpcastFloat32AndMap || (UpcastFloat32AndMap = {}));
+var UpcastComplex64AndMap;
+(function (UpcastComplex64AndMap) {
+ UpcastComplex64AndMap["float32"] = "complex64";
+ UpcastComplex64AndMap["int32"] = "complex64";
+ UpcastComplex64AndMap["bool"] = "complex64";
+ UpcastComplex64AndMap["complex64"] = "complex64";
+})(UpcastComplex64AndMap || (UpcastComplex64AndMap = {}));
+const upcastTypeMap = {
+ 'float32': UpcastFloat32AndMap,
+ 'int32': UpcastInt32AndMap,
+ 'bool': UpcastBoolAndMap,
+ 'complex64': UpcastComplex64AndMap
+};
+function upcastType(typeA, typeB) {
+ if (typeA === 'string' || typeB === 'string') {
+ if (typeA === 'string' && typeB === 'string') {
+ return 'string';
+ }
+ throw new Error(`Can not upcast ${typeA} with ${typeB}`);
+ }
+ return upcastTypeMap[typeA][typeB];
+}
+/** Returns the output type after summation. */
+function sumOutType(type) {
+ return upcastType(type, 'int32');
+}
+//# sourceMappingURL=types.js.map
+
+/***/ }),
+/* 24 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return registerOp; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getRegisteredOp; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return deregisterOp; });
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const CUSTOM_OPS = {};
+/**
+ * Register an Op for graph model executor. This allow you to register
+ * TensorFlow custom op or override existing op.
+ *
+ * Here is an example of registering a new MatMul Op.
+ * ```js
+ * const customMatmul = (node) =>
+ * tf.matMul(
+ * node.inputs[0], node.inputs[1],
+ * node.attrs['transpose_a'], node.attrs['transpose_b']);
+ *
+ * tf.registerOp('MatMul', customMatmul);
+ * ```
+ * The inputs and attrs of the node object is based on the TensorFlow op
+ * registry.
+ *
+ * @param name The Tensorflow Op name.
+ * @param opFunc An op function which is called with the current graph node
+ * during execution and needs to return a tensor or a list of tensors. The node
+ * has the following attributes:
+ * - attr: A map from attribute name to its value
+ * - inputs: A list of input tensors
+ */
+/** @doc {heading: 'Models', subheading: 'Op Registry'} */
+function registerOp(name, opFunc) {
+ const opMapper = {
+ tfOpName: name,
+ category: 'custom',
+ inputs: [],
+ attrs: [],
+ customExecutor: opFunc
+ };
+ CUSTOM_OPS[name] = opMapper;
+}
+/**
+ * Retrieve the OpMapper object for the registered op.
+ *
+ * @param name The Tensorflow Op name.
+ */
+/** @doc {heading: 'Models', subheading: 'Op Registry'} */
+function getRegisteredOp(name) {
+ return CUSTOM_OPS[name];
+}
+/**
+ * Deregister the Op for graph model executor.
+ *
+ * @param name The Tensorflow Op name.
+ */
+/** @doc {heading: 'Models', subheading: 'Op Registry'} */
+function deregisterOp(name) {
+ delete CUSTOM_OPS[name];
+}
+//# sourceMappingURL=register.js.map
+
+/***/ }),
+/* 25 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return imag; });
+/* harmony import */ var _engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
+/* harmony import */ var _kernel_names__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
+/* harmony import */ var _tensor_util_env__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3);
+/* harmony import */ var _operation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4);
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+/**
+ * Returns the imaginary part of a complex (or real) tensor.
+ *
+ * Given a tensor input, this operation returns a tensor of type float that is
+ * the imaginary part of each element in input considered as a complex number.
+ * If input is real, a tensor of all zeros is returned.
+ *
+ * ```js
+ * const x = tf.complex([-2.25, 3.25], [4.75, 5.75]);
+ * tf.imag(x).print();
+ * ```
+ */
+/** @doc {heading: 'Tensors', subheading: 'Creation'} */
+function imag_(input) {
+ const $input = Object(_tensor_util_env__WEBPACK_IMPORTED_MODULE_2__[/* convertToTensor */ "a"])(input, 'input', 'imag');
+ const forward = (backend) => {
+ return backend.imag($input);
+ };
+ const inputs = { input: $input };
+ return _engine__WEBPACK_IMPORTED_MODULE_0__[/* ENGINE */ "a"].runKernelFunc(forward, inputs, null /* gradient */, _kernel_names__WEBPACK_IMPORTED_MODULE_1__[/* Imag */ "K"]);
+}
+const imag = Object(_operation__WEBPACK_IMPORTED_MODULE_3__[/* op */ "a"])({ imag_ });
+//# sourceMappingURL=imag.js.map
+
+/***/ }),
+/* 26 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return pool; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return maxPoolPositions; });
+/* harmony import */ var _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function pool(xValues, xShape, dtype, strides, convInfo, poolType) {
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+ const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+ const padTop = convInfo.padInfo.top;
+ const padLeft = convInfo.padInfo.left;
+ const initialValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY :
+ Number.POSITIVE_INFINITY);
+ const output = Object(_tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["buffer"])(convInfo.outShape, dtype);
+ const outputVals = output.values;
+ const outputBatchStrides = convInfo.outShape[1] * convInfo.outShape[2] * convInfo.outShape[3];
+ const outputRowStrides = convInfo.outShape[2] * convInfo.outShape[3];
+ const outputColStrides = convInfo.outShape[3];
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ const outputBatchOffset = b * outputBatchStrides;
+ const inputBatchOffset = b * strides[0];
+ for (let d = 0; d < convInfo.inChannels; ++d) {
+ for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+ const xRCorner = yR * strideHeight - padTop;
+ const xRMin = Math.max(0, xRCorner);
+ const xRMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRCorner);
+ const outputRowOffset = outputBatchOffset + yR * outputRowStrides;
+ for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+ const xCCorner = yC * strideWidth - padLeft;
+ const xCMin = Math.max(0, xCCorner);
+ const xCMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xCCorner);
+ let minMaxValue = initialValue;
+ let avgValue = 0;
+ let count = 0;
+ for (let xR = xRMin; xR < xRMax; xR += dilationHeight) {
+ const xROffset = inputBatchOffset + xR * strides[1];
+ for (let xC = xCMin; xC < xCMax; xC += dilationWidth) {
+ const xCOffset = xROffset + xC * strides[2];
+ const pixel = xValues[xCOffset + d];
+ if ((poolType === 'max' && pixel > minMaxValue)) {
+ minMaxValue = pixel;
+ }
+ else if (poolType === 'avg') {
+ avgValue += pixel;
+ count++;
+ }
+ }
+ if (isNaN(minMaxValue)) {
+ break;
+ }
+ }
+ const outputOffset = outputRowOffset + yC * outputColStrides + d;
+ outputVals[outputOffset] =
+ poolType === 'avg' ? avgValue / count : minMaxValue;
+ }
+ }
+ }
+ }
+ return output;
+}
+function maxPoolPositions(xValues, xShape, dtype, convInfo, flattenPositions = false, includeBatchInIndex = false) {
+ const maxPositions = Object(_tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["buffer"])(convInfo.outShape, 'int32');
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+ const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+ const padTop = convInfo.padInfo.top;
+ const padLeft = convInfo.padInfo.left;
+ const xBuf = Object(_tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["buffer"])(xShape, dtype, xValues);
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ for (let d = 0; d < convInfo.inChannels; ++d) {
+ for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+ const xRCorner = yR * strideHeight - padTop;
+ let xRMin = xRCorner;
+ while (xRMin < 0) {
+ xRMin += dilationHeight;
+ }
+ // const xRMin = Math.max(0, xRCorner);
+ const xRMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRCorner);
+ for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+ const xCCorner = yC * strideWidth - padLeft;
+ let xCMin = xCCorner;
+ while (xCMin < 0) {
+ xCMin += dilationWidth;
+ }
+ const xCMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xCCorner);
+ let maxValue = Number.NEGATIVE_INFINITY;
+ let maxPosition = -1;
+ for (let xR = xRMin; xR < xRMax; xR += dilationHeight) {
+ const wR = xR - xRCorner;
+ for (let xC = xCMin; xC < xCMax; xC += dilationWidth) {
+ const wC = xC - xCCorner;
+ const pixel = xBuf.get(b, xR, xC, d);
+ if (pixel > maxValue) {
+ maxValue = pixel;
+ if (flattenPositions) {
+ maxPosition = includeBatchInIndex ?
+ ((b * convInfo.inHeight + xR) * convInfo.inWidth + xC) *
+ convInfo.inChannels +
+ d :
+ (xR * convInfo.inWidth + xC) * convInfo.inChannels + d;
+ }
+ else {
+ maxPosition = wR * effectiveFilterWidth + wC;
+ }
+ }
+ }
+ }
+ maxPositions.set(maxPosition, b, yR, yC, d);
+ }
+ }
+ }
+ }
+ return maxPositions;
+}
+//# sourceMappingURL=pool_utils.js.map
+
+/***/ }),
+/* 27 */
+/***/ (function(module, exports) {
+
+var g;
+
+// This works in non-strict mode
+g = (function() {
+ return this;
+})();
+
+try {
+ // This works if eval is allowed (see CSP)
+ g = g || new Function("return this")();
+} catch (e) {
+ // This works if the window reference is available
+ if (typeof window === "object") g = window;
+}
+
+// g can still be undefined, but nothing to do about it...
+// We return undefined, instead of nothing here, so it's
+// easier to handle this case. if(!global) { ...}
+
+module.exports = g;
+
+
+/***/ }),
+/* 28 */
+/***/ (function(module, exports) {
+
+module.exports = function(module) {
+ if (!module.webpackPolyfill) {
+ module.deprecate = function() {};
+ module.paths = [];
+ // module.parent = undefined by default
+ if (!module.children) module.children = [];
+ Object.defineProperty(module, "loaded", {
+ enumerable: true,
+ get: function() {
+ return module.l;
+ }
+ });
+ Object.defineProperty(module, "id", {
+ enumerable: true,
+ get: function() {
+ return module.i;
+ }
+ });
+ module.webpackPolyfill = 1;
+ }
+ return module;
+};
+
+
+/***/ }),
+/* 29 */
+/***/ (function(module, exports) {
+
+/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {/* globals __webpack_amd_options__ */
+module.exports = __webpack_amd_options__;
+
+/* WEBPACK VAR INJECTION */}.call(this, {}))
+
+/***/ }),
+/* 30 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return transposeImpl; });
+/* harmony import */ var _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function transposeImpl(xVals, xShape, dtype, perm, newShape) {
+ const xRank = xShape.length;
+ const xSize = _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].sizeFromShape(xShape);
+ const xStrides = _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].computeStrides(xShape);
+ const newStrides = _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].computeStrides(newShape);
+ const result = _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].getTypedArrayFromDType(dtype, _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].sizeFromShape(newShape));
+ for (let i = 0; i < xSize; ++i) {
+ const loc = _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].indexToLoc(i, xRank, xStrides);
+ // Permute location.
+ const newLoc = new Array(loc.length);
+ for (let i = 0; i < newLoc.length; i++) {
+ newLoc[i] = loc[perm[i]];
+ }
+ const newIndex = _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].locToIndex(newLoc, xRank, newStrides);
+ result[newIndex] = xVals[i];
+ }
+ return result;
+}
+//# sourceMappingURL=Transpose_impl.js.map
+
+/***/ }),
+/* 31 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "a", function() { return /* reexport */ backend_cpu_MathBackendCPU; });
+__webpack_require__.d(__webpack_exports__, "c", function() { return /* reexport */ version; });
+__webpack_require__.d(__webpack_exports__, "b", function() { return /* reexport */ shared_namespaceObject; });
+
+// NAMESPACE OBJECT: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/shared.js
+var shared_namespaceObject = {};
+__webpack_require__.r(shared_namespaceObject);
+__webpack_require__.d(shared_namespaceObject, "maxImpl", function() { return Max_impl["a" /* maxImpl */]; });
+__webpack_require__.d(shared_namespaceObject, "transposeImpl", function() { return Transpose_impl["a" /* transposeImpl */]; });
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Max_impl.js
+var Max_impl = __webpack_require__(37);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Transpose_impl.js
+var Transpose_impl = __webpack_require__(30);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/shared.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// Shared kernel impls for use in other backends.
+
+
+//# sourceMappingURL=shared.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/index.js + 269 modules
+var dist = __webpack_require__(0);
+
+// EXTERNAL MODULE: ./node_modules/seedrandom/index.js
+var seedrandom = __webpack_require__(20);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/cpu_util.js
+var cpu_util = __webpack_require__(9);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/utils/pool_utils.js
+var pool_utils = __webpack_require__(26);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/backend_cpu.js
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+const nonMaxSuppressionV3 = dist["kernel_impls"].nonMaxSuppressionV3;
+const split = dist["kernel_impls"].split;
+const tile = dist["kernel_impls"].tile;
+const topkImpl = dist["kernel_impls"].topkImpl;
+const whereImpl = dist["kernel_impls"].whereImpl;
+
+
+
+function mapActivation(backend, x, activation, preluActivationWeights) {
+ if (activation === 'linear') {
+ return backend.linear(x);
+ }
+ else if (activation === 'relu') {
+ return backend.relu(x);
+ }
+ else if (activation === 'elu') {
+ return backend.elu(x);
+ }
+ else if (activation === 'relu6') {
+ return backend.relu6(x);
+ }
+ else if (activation === 'prelu') {
+ return backend.prelu(x, preluActivationWeights);
+ }
+ throw new Error(`Activation ${activation} has not been implemented for the CPU backend.`);
+}
+class backend_cpu_MathBackendCPU extends dist["KernelBackend"] {
+ constructor() {
+ super();
+ this.blockSize = 48;
+ this.firstUse = true;
+ this.data = new dist["DataStorage"](this, Object(dist["engine"])());
+ }
+ write(values, shape, dtype) {
+ if (this.firstUse) {
+ this.firstUse = false;
+ if (Object(dist["env"])().get('IS_NODE')) {
+ dist["backend_util"].warn('\n============================\n' +
+ 'Hi there 👋. Looks like you are running TensorFlow.js in ' +
+ 'Node.js. To speed things up dramatically, install our node ' +
+ 'backend, which binds to TensorFlow C++, by running ' +
+ 'npm i @tensorflow/tfjs-node, ' +
+ 'or npm i @tensorflow/tfjs-node-gpu if you have CUDA. ' +
+ 'Then call require(\'@tensorflow/tfjs-node\'); (-gpu ' +
+ 'suffix for CUDA) at the start of your program. ' +
+ 'Visit https://github.com/tensorflow/tfjs-node for more details.' +
+ '\n============================');
+ }
+ }
+ const dataId = {};
+ this.data.set(dataId, { values, dtype });
+ return dataId;
+ }
+ move(dataId, values, shape, dtype) {
+ this.data.set(dataId, { values, dtype });
+ }
+ numDataIds() {
+ return this.data.numDataIds();
+ }
+ async read(dataId) {
+ return this.readSync(dataId);
+ }
+ readSync(dataId) {
+ const { dtype, complexTensors } = this.data.get(dataId);
+ if (dtype === 'complex64') {
+ const realValues = this.readSync(complexTensors.real.dataId);
+ const imagValues = this.readSync(complexTensors.imag.dataId);
+ return dist["backend_util"].mergeRealAndImagArrays(realValues, imagValues);
+ }
+ return this.data.get(dataId).values;
+ }
+ bufferSync(t) {
+ const data = this.readSync(t.dataId);
+ let decodedData = data;
+ if (t.dtype === 'string') {
+ try {
+ // Decode the bytes into string.
+ decodedData = data.map(d => dist["util"].decodeString(d));
+ }
+ catch (_a) {
+ throw new Error('Failed to decode encoded string bytes into utf-8');
+ }
+ }
+ return dist["buffer"](t.shape, t.dtype, decodedData);
+ }
+ makeOutput(values, shape, dtype) {
+ const dataId = this.write(values, shape, dtype);
+ return Object(dist["engine"])().makeTensorFromDataId(dataId, shape, dtype, this);
+ }
+ disposeData(dataId) {
+ if (this.data.has(dataId)) {
+ const { complexTensors } = this.data.get(dataId);
+ if (complexTensors != null) {
+ complexTensors.real.dispose();
+ complexTensors.imag.dispose();
+ }
+ this.data.delete(dataId);
+ }
+ }
+ async time(f) {
+ const start = dist["util"].now();
+ f();
+ const kernelMs = dist["util"].now() - start;
+ return { kernelMs };
+ }
+ memory() {
+ return {
+ // Unreliable due to automatic gc. The numbers above are cumulative.
+ unreliable: true,
+ reasons: ['The reported memory is an upper bound. Due to automatic garbage ' +
+ 'collection, the true allocated memory may be less.']
+ };
+ }
+ complex(real, imag) {
+ const result = this.makeOutput(null, real.shape, 'complex64');
+ const resultData = this.data.get(result.dataId);
+ // The backend owns the reference to the underlying real and imaginary
+ // clones. These will explicitly get disposed when the complex tensor is
+ // disposed.
+ resultData.complexTensors = {
+ real: Object(dist["engine"])().keep(real.clone()),
+ imag: Object(dist["engine"])().keep(imag.clone())
+ };
+ return result;
+ }
+ real(input) {
+ const resultData = this.data.get(input.dataId);
+ return resultData.complexTensors.real.clone();
+ }
+ imag(input) {
+ const resultData = this.data.get(input.dataId);
+ return resultData.complexTensors.imag.clone();
+ }
+ slice(x, begin, size) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'slice');
+ const isContinous = dist["slice_util"].isSliceContinous(x.shape, begin, size);
+ if (isContinous) {
+ const flatOffset = dist["slice_util"].computeFlatOffset(begin, x.strides);
+ const length = dist["util"].sizeFromShape(size);
+ const vals = this.readSync(x.dataId);
+ return dist["tensor"](vals.subarray(flatOffset, flatOffset + length), size, x.dtype);
+ }
+ const buffer = dist["buffer"](size, x.dtype);
+ const xBuf = this.bufferSync(x);
+ for (let i = 0; i < buffer.size; ++i) {
+ const loc = buffer.indexToLoc(i);
+ const xLoc = loc.map((idx, j) => idx + begin[j]);
+ buffer.values[i] = xBuf.get(...xLoc);
+ }
+ return buffer.toTensor();
+ }
+ stridedSlice(x, begin, end, strides) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'stridedSlice');
+ const outShape = dist["slice_util"].computeOutShape(begin, end, strides);
+ if (outShape.some(axis => axis === 0)) {
+ return dist["tensor"]([], outShape);
+ }
+ const buffer = dist["buffer"](outShape, x.dtype);
+ const xBuf = this.bufferSync(x);
+ for (let i = 0; i < buffer.size; i++) {
+ const loc = buffer.indexToLoc(i);
+ const newLoc = new Array(loc.length);
+ for (let j = 0; j < newLoc.length; j++) {
+ newLoc[j] = loc[j] * strides[j] + begin[j];
+ }
+ buffer.set(xBuf.get(...newLoc), ...loc);
+ }
+ return buffer.toTensor();
+ }
+ diag(x) {
+ const xVals = this.readSync(x.dataId);
+ const buffer = dist["buffer"]([x.size, x.size], x.dtype);
+ const vals = buffer.values;
+ for (let i = 0; i < xVals.length; i++) {
+ vals[i * x.size + i] = xVals[i];
+ }
+ return buffer.toTensor();
+ }
+ unstack(x, axis) {
+ const num = x.shape[axis];
+ const outShape = new Array(x.rank - 1);
+ let outIndex = 0;
+ for (let i = 0; i < x.rank; i++) {
+ if (i !== axis) {
+ outShape[outIndex++] = x.shape[i];
+ }
+ }
+ const begin = new Array(x.rank).fill(0);
+ const size = x.shape.slice();
+ size[axis] = 1;
+ const res = new Array(num);
+ for (let i = 0; i < res.length; i++) {
+ begin[axis] = i;
+ res[i] = this.slice(x, begin, size).reshape(outShape);
+ }
+ return res;
+ }
+ reverse(x, axis) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'reverse');
+ const buffer = dist["buffer"](x.shape, x.dtype);
+ const xBuf = this.bufferSync(x);
+ for (let i = 0; i < buffer.size; i++) {
+ const outLoc = buffer.indexToLoc(i);
+ const inLoc = outLoc.slice();
+ axis.forEach(ax => inLoc[ax] = x.shape[ax] - 1 - inLoc[ax]);
+ buffer.set(xBuf.get(...inLoc), ...outLoc);
+ }
+ return buffer.toTensor();
+ }
+ concat(tensors, axis) {
+ if (tensors[0].dtype === 'complex64') {
+ const reals = tensors.map((t) => dist["real"](t));
+ const imags = tensors.map((t) => dist["imag"](t));
+ return dist["complex"](this.concat(reals, axis), this.concat(imags, axis));
+ }
+ const tensors2D = tensors.map(t => {
+ const innerSize = dist["util"].sizeFromShape(t.shape.slice(axis));
+ return t.as2D(-1, innerSize);
+ });
+ const outShape = dist["backend_util"].computeOutShape(tensors2D.map(t => t.shape), 1 /* axis
+ */);
+ const values = dist["buffer"](outShape, tensors[0].dtype)
+ .values;
+ if (tensors2D[0].shape[0] === 1) {
+ // Use built-in TypedArray.set() method for speed.
+ let offset = 0;
+ tensors2D.forEach(t => {
+ values.set(this.readSync(t.dataId), offset);
+ offset += t.size;
+ });
+ }
+ else {
+ let colOffset = 0;
+ tensors2D.forEach(t => {
+ const tVals = this.readSync(t.dataId);
+ let tIdx = 0;
+ for (let row = 0; row < t.shape[0]; ++row) {
+ const resIdx = row * outShape[1] + colOffset;
+ for (let col = 0; col < t.shape[1]; ++col) {
+ values[resIdx + col] = tVals[tIdx++];
+ }
+ }
+ colOffset += t.shape[1];
+ });
+ }
+ const finalOutShape = dist["backend_util"].computeOutShape(tensors.map(t => t.shape), axis);
+ return dist["tensor"](values, finalOutShape, tensors[0].dtype);
+ }
+ neg(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'neg');
+ return this.multiply(dist["scalar"](-1), x);
+ }
+ add(a, b) {
+ if (a.dtype === 'complex64' || b.dtype === 'complex64') {
+ return this.broadcastedBinaryComplexOp(a.cast('complex64'), b.cast('complex64'), (aReal, aImag, bReal, bImag) => {
+ return { real: aReal + bReal, imag: aImag + bImag };
+ });
+ }
+ return this.broadcastedBinaryOp(a, b, Object(dist["upcastType"])(a.dtype, b.dtype), (aValue, bValue) => aValue + bValue);
+ }
+ addN(tensors) {
+ Object(cpu_util["a" /* assertNotComplex */])(tensors, 'addN');
+ const vals = tensors.map(t => this.readSync(t.dataId));
+ const result = dist["buffer"](tensors[0].shape, tensors[0].dtype);
+ const resultVals = result.values;
+ for (let i = 0; i < tensors.length; i++) {
+ const currVals = vals[i];
+ for (let j = 0; j < resultVals.length; j++) {
+ resultVals[j] += currVals[j];
+ }
+ }
+ return result.toTensor();
+ }
+ softmax(logits, dim) {
+ const axes = dist["util"].parseAxisParam([dim], logits.shape);
+ // TODO(annxingyuan): Call maxImpl rather than op as part of softmax kernel
+ // modularization.
+ const maxLogit = Object(dist["max"])(logits, axes);
+ const expandedShape = dist["backend_util"].expandShapeToKeepDim(maxLogit.shape, axes);
+ const a = this.subtract(logits, maxLogit.reshape(expandedShape));
+ const b = this.exp(a);
+ const sumExp = this.sum(b, axes).reshape(expandedShape);
+ // TODO(annxingyuan): Call divImpl rather than op as part of softmax
+ // kernel modularization.
+ return dist["div"](b, sumExp);
+ }
+ subtract(a, b) {
+ if (a.dtype === 'complex64' || b.dtype === 'complex64') {
+ return this.broadcastedBinaryComplexOp(a.cast('complex64'), b.cast('complex64'), (aReal, aImag, bReal, bImag) => {
+ return { real: aReal - bReal, imag: aImag - bImag };
+ });
+ }
+ return this.broadcastedBinaryOp(a, b, Object(dist["upcastType"])(a.dtype, b.dtype), (aValue, bValue) => aValue - bValue);
+ }
+ pow(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'pow');
+ return this.broadcastedBinaryOp(a, b, a.dtype, (aValue, bValue) => Math.pow(aValue, bValue));
+ }
+ batchMatMul(a, b, transposeA, transposeB) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'matMul');
+ const sharedDim = transposeA ? a.shape[1] : a.shape[2];
+ const leftDim = transposeA ? a.shape[2] : a.shape[1];
+ const rightDim = transposeB ? b.shape[1] : b.shape[2];
+ const batchDim = a.shape[0];
+ const aValues = this.readSync(a.dataId);
+ const bValues = this.readSync(b.dataId);
+ const [aBatch, aOuterStep, aInnerStep] = transposeA ?
+ [a.strides[0], 1, a.strides[1]] :
+ [a.strides[0], a.strides[1], 1];
+ const [bInnerStep, bOuterStep, bBatch] = transposeB ?
+ [1, b.strides[1], b.strides[0]] :
+ [b.strides[1], 1, b.strides[0]];
+ const size = leftDim * rightDim;
+ const result = dist["buffer"]([batchDim, leftDim, rightDim], a.dtype);
+ const resVals = result.values;
+ const blockSize = this.blockSize;
+ for (let b = 0; b < batchDim; b++) {
+ for (let i0 = 0; i0 < leftDim; i0 += blockSize) {
+ for (let j0 = 0; j0 < rightDim; j0 += blockSize) {
+ for (let k0 = 0; k0 < sharedDim; k0 += blockSize) {
+ // for when blockSize doesn't evenly divide the input
+ const iBlock = Math.min(i0 + blockSize, leftDim);
+ const jBlock = Math.min(j0 + blockSize, rightDim);
+ const kBlock = Math.min(k0 + blockSize, sharedDim);
+ for (let i = i0; i < iBlock; i++) {
+ for (let j = j0; j < jBlock; j++) {
+ let sum = 0.0;
+ for (let k = k0; k < kBlock; k++) {
+ sum += aValues[b * aBatch + i * aOuterStep + k * aInnerStep] *
+ bValues[k * bInnerStep + j * bOuterStep + b * bBatch];
+ }
+ resVals[b * size + (i * rightDim + j)] += sum;
+ }
+ }
+ }
+ }
+ }
+ }
+ return result.toTensor();
+ }
+ fusedBatchMatMul({ a, b, transposeA, transposeB, bias, activation, preluActivationWeights }) {
+ let result = this.batchMatMul(a, b, transposeA, transposeB);
+ if (bias) {
+ result = this.add(result, bias);
+ }
+ if (activation) {
+ result =
+ mapActivation(this, result, activation, preluActivationWeights);
+ }
+ return result;
+ }
+ multiply(a, b) {
+ if (a.dtype === 'complex64' || b.dtype === 'complex64') {
+ return this.broadcastedBinaryComplexOp(a.cast('complex64'), b.cast('complex64'), (aReal, aImag, bReal, bImag) => {
+ return {
+ real: aReal * bReal - aImag * bImag,
+ imag: aReal * bImag + aImag * bReal
+ };
+ });
+ }
+ return this.broadcastedBinaryOp(a, b, Object(dist["upcastType"])(a.dtype, b.dtype), (aValue, bValue) => aValue * bValue);
+ }
+ floorDiv(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'floorDiv');
+ const op = (a, b) => Math.floor(a / b);
+ const outputDtype = 'int32';
+ return this.broadcastedBinaryOp(a, b, outputDtype, op);
+ }
+ sum(x, axes) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'sum');
+ dist["backend_util"].assertAxesAreInnerMostDims('sum', axes, x.rank);
+ const [outShape, reduceShape] = dist["backend_util"].computeOutAndReduceShapes(x.shape, axes);
+ const resultDtype = Object(dist["upcastType"])(x.dtype, 'int32');
+ const result = dist["zeros"](outShape, resultDtype);
+ const reduceSize = dist["util"].sizeFromShape(reduceShape);
+ const vals = this.readSync(result.dataId);
+ const aVals = this.readSync(x.dataId);
+ for (let i = 0; i < vals.length; ++i) {
+ const offset = i * reduceSize;
+ let sum = 0;
+ for (let j = 0; j < reduceSize; ++j) {
+ sum += aVals[offset + j];
+ }
+ vals[i] = sum;
+ }
+ return result;
+ }
+ prod(x, axes) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'sum');
+ const [outShape, reduceShape] = dist["backend_util"].computeOutAndReduceShapes(x.shape, axes);
+ const resultDtype = Object(dist["upcastType"])(x.dtype, 'int32');
+ const result = dist["zeros"](outShape, resultDtype);
+ const reduceSize = dist["util"].sizeFromShape(reduceShape);
+ const vals = this.readSync(result.dataId);
+ const aVals = this.readSync(x.dataId);
+ for (let i = 0; i < vals.length; ++i) {
+ const offset = i * reduceSize;
+ let prod = 1;
+ for (let j = 0; j < reduceSize; ++j) {
+ prod *= aVals[offset + j];
+ }
+ vals[i] = prod;
+ }
+ return result;
+ }
+ unsortedSegmentSum(x, segmentIds, numSegments) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'unsortedSegmentSum');
+ const res = [];
+ // Reshape the segment id's so that they can be broadcast with
+ // x. The new shape should be [segmentIds.shape, 1, ..., 1]
+ const numIters = x.rank - segmentIds.rank;
+ for (let i = 0; i < numIters; ++i) {
+ segmentIds = segmentIds.expandDims(i + 1);
+ }
+ for (let i = 0; i < numSegments; ++i) {
+ const segmentId = dist["scalar"](i, 'int32');
+ const mask = dist["equal"](segmentId, segmentIds).asType('float32');
+ const sum = mask.mul(x).sum(0);
+ res.push(sum);
+ }
+ return dist["stack"](res);
+ }
+ argMin(x, axis) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'argMin');
+ const axes = [axis];
+ dist["backend_util"].assertAxesAreInnerMostDims('argMin', axes, x.rank);
+ const [outShape, reduceShape] = dist["backend_util"].computeOutAndReduceShapes(x.shape, axes);
+ const result = dist["zeros"](outShape, 'int32');
+ const reduceSize = dist["util"].sizeFromShape(reduceShape);
+ const vals = this.readSync(result.dataId);
+ const aVals = this.readSync(x.dataId);
+ for (let i = 0; i < vals.length; ++i) {
+ const offset = i * reduceSize;
+ let min = aVals[offset];
+ let minIndex = 0;
+ for (let j = 0; j < reduceSize; ++j) {
+ const value = aVals[offset + j];
+ if (value < min) {
+ min = value;
+ minIndex = j;
+ }
+ }
+ vals[i] = minIndex;
+ }
+ return result;
+ }
+ argMax(x, axis) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'argMax');
+ const axes = [axis];
+ dist["backend_util"].assertAxesAreInnerMostDims('argMax', axes, x.rank);
+ const [outShape, reduceShape] = dist["backend_util"].computeOutAndReduceShapes(x.shape, axes);
+ const result = dist["zeros"](outShape, 'int32');
+ const reduceSize = dist["util"].sizeFromShape(reduceShape);
+ const vals = this.readSync(result.dataId);
+ const aVals = this.readSync(x.dataId);
+ for (let i = 0; i < vals.length; ++i) {
+ const offset = i * reduceSize;
+ let max = aVals[offset];
+ let maxIndex = 0;
+ for (let j = 0; j < reduceSize; ++j) {
+ const value = aVals[offset + j];
+ if (value > max) {
+ max = value;
+ maxIndex = j;
+ }
+ }
+ vals[i] = maxIndex;
+ }
+ return result;
+ }
+ cumsum(x, axis, exclusive, reverse) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'cumsum');
+ if (axis !== x.rank - 1) {
+ throw new Error(`backend.cumsum in CPU expects an inner-most axis=${x.rank - 1} ` +
+ `but got axis=${axis}`);
+ }
+ const resultDtype = Object(dist["upcastType"])(x.dtype, 'int32');
+ const result = dist["zeros"](x.shape, resultDtype);
+ const vals = this.readSync(result.dataId);
+ const aVals = this.readSync(x.dataId);
+ const finalDim = x.shape[x.rank - 1];
+ const indexAdjuster = reverse ?
+ (i, j) => i + finalDim - j - 1 :
+ (i, j) => i + j;
+ for (let i = 0; i < aVals.length; i += finalDim) {
+ for (let j = 0; j < finalDim; j++) {
+ const idx = indexAdjuster(i, j);
+ if (j === 0) {
+ vals[idx] = exclusive ? 0 : aVals[idx];
+ }
+ else {
+ const prevIdx = indexAdjuster(i, j - 1);
+ vals[idx] = exclusive ? aVals[prevIdx] + vals[prevIdx] :
+ aVals[idx] + vals[prevIdx];
+ }
+ }
+ }
+ return result;
+ }
+ equal(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'equal');
+ return this.broadcastedBinaryOp(a, b, 'bool', (aVal, bVal) => {
+ return (aVal === bVal) ? 1 : 0;
+ });
+ }
+ notEqual(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'notEqual');
+ return this.broadcastedBinaryOp(a, b, 'bool', (aVal, bVal) => {
+ return (aVal !== bVal) ? 1 : 0;
+ });
+ }
+ less(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'less');
+ return this.broadcastedBinaryOp(a, b, 'bool', (aVal, bVal) => {
+ return (aVal < bVal) ? 1 : 0;
+ });
+ }
+ lessEqual(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'lessEqual');
+ return this.broadcastedBinaryOp(a, b, 'bool', (aVal, bVal) => {
+ return (aVal <= bVal) ? 1 : 0;
+ });
+ }
+ greater(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'greater');
+ return this.broadcastedBinaryOp(a, b, 'bool', (aVal, bVal) => {
+ return (aVal > bVal) ? 1 : 0;
+ });
+ }
+ greaterEqual(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'greaterEqual');
+ return this.broadcastedBinaryOp(a, b, 'bool', (aVal, bVal) => {
+ return (aVal >= bVal) ? 1 : 0;
+ });
+ }
+ logicalNot(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'logicalNot');
+ const values = this.readSync(x.dataId);
+ const newValues = new Uint8Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ newValues[i] = values[i] ? 0 : 1;
+ }
+ return this.makeOutput(newValues, x.shape, 'bool');
+ }
+ logicalAnd(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'logicalAnd');
+ return this.broadcastedBinaryOp(a, b, 'bool', (aVal, bVal) => {
+ return aVal && bVal;
+ });
+ }
+ logicalOr(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'logicalOr');
+ return this.broadcastedBinaryOp(a, b, 'bool', (aVal, bVal) => {
+ return aVal || bVal;
+ });
+ }
+ select(condition, a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([condition, a, b], 'select');
+ const values = this.readSync(condition.dataId);
+ const aValues = this.readSync(a.dataId);
+ const bValues = this.readSync(b.dataId);
+ const result = dist["zeros"](a.shape, Object(dist["upcastType"])(a.dtype, b.dtype));
+ const newValues = this.readSync(result.dataId);
+ let index = 0;
+ const offset = condition.rank === 0 || condition.rank > 1 || a.rank === 1 ?
+ 1 :
+ dist["util"].sizeFromShape(a.shape.slice(1));
+ for (let i = 0; i < values.length; i++) {
+ for (let j = 0; j < offset; j++) {
+ if (values[i] === 1) {
+ newValues[index++] = aValues[i];
+ }
+ else {
+ newValues[index++] = bValues[i];
+ }
+ }
+ }
+ return result;
+ }
+ where(condition) {
+ Object(cpu_util["a" /* assertNotComplex */])([condition], 'where');
+ const condVals = this.readSync(condition.dataId);
+ return whereImpl(condition.shape, condVals);
+ }
+ topk(x, k, sorted) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'topk');
+ const xVals = this.readSync(x.dataId);
+ return topkImpl(xVals, x.shape, x.dtype, k, sorted);
+ }
+ min(x, axes) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'min');
+ dist["backend_util"].assertAxesAreInnerMostDims('min', axes, x.rank);
+ const [outShape, reduceShape] = dist["backend_util"].computeOutAndReduceShapes(x.shape, axes);
+ const result = dist["zeros"](outShape, x.dtype);
+ const reduceSize = dist["util"].sizeFromShape(reduceShape);
+ const vals = this.readSync(result.dataId);
+ const aVals = this.readSync(x.dataId);
+ for (let i = 0; i < vals.length; ++i) {
+ const offset = i * reduceSize;
+ let min = aVals[offset];
+ for (let j = 0; j < reduceSize; ++j) {
+ const value = aVals[offset + j];
+ if (value < min) {
+ min = value;
+ }
+ }
+ vals[i] = min;
+ }
+ return result;
+ }
+ minimum(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'minimum');
+ return this.broadcastedBinaryOp(a, b, a.dtype, (aVal, bVal) => Math.min(aVal, bVal));
+ }
+ mod(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'mod');
+ return this.broadcastedBinaryOp(a, b, a.dtype, (aVal, bVal) => {
+ const rem = aVal % bVal;
+ if ((aVal < 0 && bVal < 0) || (aVal >= 0 && bVal >= 0)) {
+ return rem;
+ }
+ else {
+ return (rem + bVal) % bVal;
+ }
+ });
+ }
+ maximum(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'maximum');
+ return this.broadcastedBinaryOp(a, b, a.dtype, (aVal, bVal) => Math.max(aVal, bVal));
+ }
+ all(x, axes) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'all');
+ dist["backend_util"].assertAxesAreInnerMostDims('all', axes, x.rank);
+ const [outShape, reduceShape] = dist["backend_util"].computeOutAndReduceShapes(x.shape, axes);
+ const result = dist["zeros"](outShape, x.dtype);
+ const reduceSize = dist["util"].sizeFromShape(reduceShape);
+ const vals = this.readSync(result.dataId);
+ const aVals = this.readSync(x.dataId);
+ for (let i = 0; i < vals.length; ++i) {
+ const offset = i * reduceSize;
+ let all = aVals[offset];
+ for (let j = 0; j < reduceSize; ++j) {
+ const value = aVals[offset + j];
+ all = all && value;
+ }
+ vals[i] = all;
+ }
+ return result;
+ }
+ any(x, axes) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'any');
+ dist["backend_util"].assertAxesAreInnerMostDims('any', axes, x.rank);
+ const [outShape, reduceShape] = dist["backend_util"].computeOutAndReduceShapes(x.shape, axes);
+ const result = dist["zeros"](outShape, x.dtype);
+ const reduceSize = dist["util"].sizeFromShape(reduceShape);
+ const vals = this.readSync(result.dataId);
+ const aVals = this.readSync(x.dataId);
+ for (let i = 0; i < vals.length; ++i) {
+ const offset = i * reduceSize;
+ let anyVal = aVals[offset];
+ for (let j = 0; j < reduceSize; ++j) {
+ const value = aVals[offset + j];
+ anyVal = anyVal || value;
+ }
+ vals[i] = anyVal;
+ }
+ return result;
+ }
+ squaredDifference(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'squaredDifference');
+ return this.broadcastedBinaryOp(a, b, a.dtype, (aVal, bVal) => {
+ const diff = aVal - bVal;
+ return diff * diff;
+ });
+ }
+ ceil(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'ceil');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ newValues[i] = Math.ceil(values[i]);
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ floor(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'floor');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ newValues[i] = Math.floor(values[i]);
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ sign(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'x');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ if (values[i] < 0) {
+ newValues[i] = -1;
+ }
+ else if (values[i] > 0) {
+ newValues[i] = 1;
+ }
+ else {
+ newValues[i] = 0;
+ }
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ isNaN(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'x');
+ const values = this.readSync(x.dataId);
+ const newValues = new Uint8Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ if (Number.isNaN(values[i])) {
+ newValues[i] = 1;
+ }
+ }
+ return this.makeOutput(newValues, x.shape, 'bool');
+ }
+ isInf(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'x');
+ const values = this.readSync(x.dataId);
+ const newValues = new Uint8Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ if (Math.abs(values[i]) === Infinity) {
+ newValues[i] = 1;
+ }
+ }
+ return this.makeOutput(newValues, x.shape, 'bool');
+ }
+ isFinite(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'x');
+ const values = this.readSync(x.dataId);
+ const newValues = new Uint8Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ if (Number.isFinite(values[i])) {
+ newValues[i] = 1;
+ }
+ }
+ return this.makeOutput(newValues, x.shape, 'bool');
+ }
+ round(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'round');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ // The algorithm is based on banker's rounding.
+ const base = Math.floor(values[i]);
+ if (values[i] - base < 0.5) {
+ newValues[i] = Math.floor(values[i]);
+ }
+ else if (values[i] - base > 0.5) {
+ newValues[i] = Math.ceil(values[i]);
+ }
+ else {
+ if (base % 2.0 === 0.0) {
+ newValues[i] = base;
+ }
+ else {
+ newValues[i] = base + 1.0;
+ }
+ }
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ exp(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'exp');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ newValues[i] = Math.exp(values[i]);
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ expm1(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'expm1');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ newValues[i] = Math.expm1(values[i]);
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ log(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'log');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ const value = values[i];
+ newValues[i] = Math.log(value);
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ log1p(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'log1p');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ const value = values[i];
+ newValues[i] = Math.log1p(value);
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ sqrt(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'sqrt');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ const value = values[i];
+ newValues[i] = Math.sqrt(value);
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ rsqrt(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'rsqrt');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ const value = values[i];
+ newValues[i] = 1 / Math.sqrt(value);
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ reciprocal(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'reciprocal');
+ const values = this.readSync(x.dataId);
+ const newValues = new Float32Array(values.length);
+ for (let i = 0; i < values.length; ++i) {
+ newValues[i] = 1 / values[i];
+ }
+ return this.makeOutput(newValues, x.shape, 'float32');
+ }
+ linear(x) {
+ return x;
+ }
+ relu(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'relu');
+ const res = dist["zeros"](x.shape, x.dtype);
+ const resVals = this.readSync(res.dataId);
+ const inVals = this.readSync(x.dataId);
+ for (let i = 0; i < inVals.length; ++i) {
+ resVals[i] = Math.max(0, inVals[i]);
+ }
+ return res;
+ }
+ relu6(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'relu');
+ const res = dist["zeros"](x.shape, x.dtype);
+ const resVals = this.readSync(res.dataId);
+ const inVals = this.readSync(x.dataId);
+ for (let i = 0; i < inVals.length; ++i) {
+ resVals[i] = Math.min(Math.max(0, inVals[i]), 6);
+ }
+ return res;
+ }
+ prelu(x, a) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, a], 'prelu');
+ return this.broadcastedBinaryOp(x, a, x.dtype, (xValue, aValue) => xValue < 0 ? aValue * xValue : xValue);
+ }
+ elu(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'elu');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ const v = values[i];
+ if (v >= 0) {
+ resultValues[i] = v;
+ }
+ else {
+ resultValues[i] = (Math.exp(v) - 1);
+ }
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ eluDer(dy, y) {
+ Object(cpu_util["a" /* assertNotComplex */])([dy, y], 'eluDer');
+ const resultValues = new Float32Array(y.size);
+ const values = this.readSync(y.dataId);
+ const dyValues = this.readSync(dy.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ const v = values[i];
+ if (v >= 1) {
+ resultValues[i] = dyValues[i];
+ }
+ else {
+ resultValues[i] = dyValues[i] * (v + 1);
+ }
+ }
+ return this.makeOutput(resultValues, y.shape, 'float32');
+ }
+ selu(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'selu');
+ // Stable and Attracting Fixed Point (0, 1) for Normalized Weights.
+ // see: https://arxiv.org/abs/1706.02515
+ const scaleAlpha = dist["backend_util"].SELU_SCALEALPHA;
+ const scale = dist["backend_util"].SELU_SCALE;
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ const v = values[i];
+ if (v >= 0) {
+ resultValues[i] = scale * v;
+ }
+ else {
+ resultValues[i] = scaleAlpha * (Math.exp(v) - 1);
+ }
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ clip(x, min, max) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'clip');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ const v = values[i];
+ resultValues[i] = v > max ? max : (v < min ? min : v);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ abs(x) {
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.abs(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ complexAbs(x) {
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < x.size; ++i) {
+ const real = values[i * 2];
+ const imag = values[i * 2 + 1];
+ resultValues[i] = Math.hypot(real, imag);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ int(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'int');
+ const resultValues = new Int32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = values[i];
+ }
+ return this.makeOutput(resultValues, x.shape, 'int32');
+ }
+ sigmoid(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'sigmoid');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = 1 / (1 + Math.exp(-values[i]));
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ softplus(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'softplus');
+ // mirrors the implementation of tf.nn.softplus: https://goo.gl/vkcvwX
+ // epsilon is the difference between 1.0 and the next representable float.
+ // For a single precision 32 bit float this should be 2^-23, see:
+ // https://math.byu.edu/~schow/work/IEEEFloatingPoint.htm
+ const epsilon = 1.1920928955078125e-7;
+ const threshold = Math.log(epsilon) + 2.0;
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ // Value above which exp(x) may overflow, but softplus(x) == x
+ // is within machine epsilon.
+ const tooLarge = values[i] > -threshold;
+ // Value below which exp(x) may underflow, but softplus(x) == exp(x)
+ // is within machine epsilon.
+ const tooSmall = values[i] < threshold;
+ const expX = Math.exp(values[i]);
+ let result;
+ if (tooSmall) {
+ result = expX;
+ }
+ else if (tooLarge) {
+ result = values[i];
+ }
+ else {
+ result = Math.log(1.0 + expX);
+ }
+ resultValues[i] = result;
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ sin(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'sin');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.sin(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ cos(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'cos');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.cos(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ tan(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'tan');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.tan(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ asin(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'asin');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.asin(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ acos(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'acos');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.acos(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ atan(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'atan');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.atan(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ atan2(a, b) {
+ Object(cpu_util["a" /* assertNotComplex */])([a, b], 'atan2');
+ return this.broadcastedBinaryOp(a, b, a.dtype, (aValue, bValue) => Math.atan2(aValue, bValue));
+ }
+ sinh(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'sinh');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.sinh(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ cosh(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'cosh');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.cosh(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ tanh(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'tanh');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = dist["util"].tanh(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ asinh(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'asinh');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.asinh(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ acosh(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'acosh');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.acosh(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ atanh(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'atanh');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ resultValues[i] = Math.atanh(values[i]);
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ erf(x) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'erf');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ const p = dist["backend_util"].ERF_P;
+ const a1 = dist["backend_util"].ERF_A1;
+ const a2 = dist["backend_util"].ERF_A2;
+ const a3 = dist["backend_util"].ERF_A3;
+ const a4 = dist["backend_util"].ERF_A4;
+ const a5 = dist["backend_util"].ERF_A5;
+ for (let i = 0; i < values.length; ++i) {
+ const sign = Math.sign(values[i]);
+ const v = Math.abs(values[i]);
+ const t = 1.0 / (1.0 + p * v);
+ resultValues[i] = sign *
+ (1.0 -
+ (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t *
+ Math.exp(-v * v));
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ step(x, alpha = 0) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'step');
+ const resultValues = new Float32Array(x.size);
+ const values = this.readSync(x.dataId);
+ for (let i = 0; i < values.length; ++i) {
+ const value = values[i];
+ if (isNaN(value)) {
+ resultValues[i] = NaN;
+ }
+ else {
+ resultValues[i] = value > 0 ? 1 : alpha;
+ }
+ }
+ return this.makeOutput(resultValues, x.shape, 'float32');
+ }
+ fusedConv2d({ input, filter, convInfo, bias, activation, preluActivationWeights }) {
+ let result = this.conv2d(input, filter, convInfo);
+ if (bias) {
+ result = this.add(result, bias);
+ }
+ if (activation) {
+ result =
+ mapActivation(this, result, activation, preluActivationWeights);
+ }
+ return result;
+ }
+ conv2d(x, filter, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, filter], 'conv2d');
+ const filterHeight = convInfo.filterHeight;
+ const filterWidth = convInfo.filterWidth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const padLeft = convInfo.padInfo.left;
+ const padTop = convInfo.padInfo.top;
+ const isChannelsLast = convInfo.dataFormat === 'channelsLast';
+ const y = dist["buffer"](convInfo.outShape, x.dtype);
+ const xBatchStride = x.strides[0];
+ const xRowStride = isChannelsLast ? x.strides[1] : x.strides[2];
+ const xColStride = isChannelsLast ? x.strides[2] : 1;
+ const xChannelStride = isChannelsLast ? 1 : x.strides[1];
+ const yBatchStride = y.strides[0];
+ const yRowStride = isChannelsLast ? y.strides[1] : y.strides[2];
+ const yColStride = isChannelsLast ? y.strides[2] : 1;
+ const yChannelStride = isChannelsLast ? 1 : y.strides[1];
+ const xVals = this.readSync(x.dataId);
+ const wVals = this.readSync(filter.dataId);
+ const yVals = y.values;
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ const xOffset1 = b * xBatchStride;
+ const yOffset1 = b * yBatchStride;
+ for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+ const yOffset2 = yOffset1 + yR * yRowStride;
+ const xRCorner = yR * convInfo.strideHeight - padTop;
+ for (let wR = 0; wR < filterHeight; wR++) {
+ const xR = xRCorner + wR * dilationHeight;
+ if (xR < 0 || xR >= convInfo.inHeight) {
+ continue;
+ }
+ const wOffset1 = wR * filter.strides[0];
+ const xOffset2 = xOffset1 + xR * xRowStride;
+ for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+ const yOffset3 = yOffset2 + yC * yColStride;
+ const xCCorner = yC * convInfo.strideWidth - padLeft;
+ for (let wC = 0; wC < filterWidth; wC++) {
+ const xC = xCCorner + wC * dilationWidth;
+ if (xC < 0 || xC >= convInfo.inWidth) {
+ continue;
+ }
+ const wOffset2 = wOffset1 + wC * filter.strides[1];
+ const xOffset3 = xOffset2 + xC * xColStride;
+ let wOffset3 = wOffset2;
+ for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+ const xVal = xVals[xOffset3 + d1 * xChannelStride];
+ for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+ yVals[yOffset3 + d2 * yChannelStride] +=
+ xVal * wVals[wOffset3 + d2];
+ }
+ wOffset3 += convInfo.outChannels;
+ }
+ }
+ }
+ }
+ }
+ }
+ return y.toTensor();
+ }
+ conv3d(x, filter, convInfo) {
+ const filterDepth = convInfo.filterDepth;
+ const filterHeight = convInfo.filterHeight;
+ const filterWidth = convInfo.filterWidth;
+ const dilationDepth = convInfo.dilationDepth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const padFront = convInfo.padInfo.front;
+ const padLeft = convInfo.padInfo.left;
+ const padTop = convInfo.padInfo.top;
+ const y = dist["buffer"](convInfo.outShape, x.dtype);
+ const xVals = this.readSync(x.dataId);
+ const wVals = this.readSync(filter.dataId);
+ const yVals = y.values;
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ const xOffset1 = b * x.strides[0];
+ const yOffset1 = b * y.strides[0];
+ for (let yF = 0; yF < convInfo.outDepth; ++yF) {
+ const yOffset2 = yOffset1 + yF * y.strides[1];
+ const xFCorner = yF * convInfo.strideDepth - padFront;
+ for (let wF = 0; wF < filterDepth; wF++) {
+ const xF = xFCorner + wF * dilationDepth;
+ if (xF < 0 || xF >= convInfo.inDepth) {
+ continue;
+ }
+ const wOffset1 = wF * filter.strides[0];
+ const xOffset2 = xOffset1 + xF * x.strides[1];
+ for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+ const yOffset3 = yOffset2 + yR * y.strides[2];
+ const xRCorner = yR * convInfo.strideHeight - padTop;
+ for (let wR = 0; wR < filterHeight; wR++) {
+ const xR = xRCorner + wR * dilationHeight;
+ if (xR < 0 || xR >= convInfo.inHeight) {
+ continue;
+ }
+ const wOffset2 = wOffset1 + wR * filter.strides[1];
+ const xOffset3 = xOffset2 + xR * x.strides[2];
+ for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+ const yOffset4 = yOffset3 + yC * convInfo.outChannels;
+ const xCCorner = yC * convInfo.strideWidth - padLeft;
+ for (let wC = 0; wC < filterWidth; wC++) {
+ const xC = xCCorner + wC * dilationWidth;
+ if (xC < 0 || xC >= convInfo.inWidth) {
+ continue;
+ }
+ const wOffset3 = wOffset2 + wC * filter.strides[2];
+ const xOffset4 = xOffset3 + xC * convInfo.inChannels;
+ let wOffset4 = wOffset3;
+ for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+ const xVal = xVals[xOffset4 + d1];
+ for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+ yVals[yOffset4 + d2] += xVal * wVals[wOffset4 + d2];
+ }
+ wOffset4 += convInfo.outChannels;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return y.toTensor();
+ }
+ conv2dDerInput(dy, filter, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([dy, filter], 'conv2dDerInput');
+ const dx = dist["buffer"](convInfo.inShape, 'float32');
+ const dxValues = dx.values;
+ const dyValues = this.readSync(dy.dataId);
+ const fltValues = this.readSync(filter.dataId);
+ const [fltS0, fltS1, fltS2] = filter.strides;
+ const { batchSize, filterHeight, filterWidth, inChannels, inHeight, inWidth, outChannels, outHeight, outWidth, strideHeight, strideWidth, dataFormat } = convInfo;
+ const topPad = filterHeight - 1 - convInfo.padInfo.top;
+ const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+ const isChannelsLast = dataFormat === 'channelsLast';
+ const xBatchStride = dx.strides[0];
+ const xRowStride = isChannelsLast ? dx.strides[1] : dx.strides[2];
+ const xColStride = isChannelsLast ? dx.strides[2] : 1;
+ const xChannelStride = isChannelsLast ? 1 : dx.strides[1];
+ const yBatchStride = dy.strides[0];
+ const yRowStride = isChannelsLast ? dy.strides[1] : dy.strides[2];
+ const yColStride = isChannelsLast ? dy.strides[2] : 1;
+ const yChannelStride = isChannelsLast ? 1 : dy.strides[1];
+ for (let b = 0; b < batchSize; ++b) {
+ for (let d1 = 0; d1 < inChannels; ++d1) {
+ for (let xR = 0; xR < inHeight; ++xR) {
+ const xRCorner = xR - topPad;
+ const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+ const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+ for (let xC = 0; xC < inWidth; ++xC) {
+ const xCCorner = xC - leftPad;
+ const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+ const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+ let dotProd = 0;
+ for (let yR = xRMin; yR < yRMax; ++yR) {
+ const wR = yR * strideHeight - xRCorner;
+ for (let yC = xCMin; yC < yCMax; ++yC) {
+ const wC = yC * strideWidth - xCCorner;
+ const dyOffset = yBatchStride * b + yRowStride * yR + yColStride * yC;
+ const fltOffset = fltS0 * (filterHeight - 1 - wR) +
+ fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;
+ for (let d2 = 0; d2 < outChannels; ++d2) {
+ const pixel = dyValues[dyOffset + yChannelStride * d2];
+ const weight = fltValues[fltOffset + d2];
+ dotProd += pixel * weight;
+ }
+ }
+ }
+ const dxOffset = xBatchStride * b + xRowStride * xR +
+ xColStride * xC + xChannelStride * d1;
+ dxValues[dxOffset] = dotProd;
+ }
+ }
+ }
+ }
+ return dx.toTensor();
+ }
+ conv3dDerInput(dy, filter, convInfo) {
+ const dx = dist["buffer"](convInfo.inShape, 'float32');
+ const dxValues = dx.values;
+ const [dxS0, dxS1, dxS2, dxS3] = dx.strides;
+ const dyValues = this.readSync(dy.dataId);
+ const [dyS0, dyS1, dyS2, dyS3] = dy.strides;
+ const fltValues = this.readSync(filter.dataId);
+ const [fltS0, fltS1, fltS2, fltS3] = filter.strides;
+ const { batchSize, filterDepth, filterHeight, filterWidth, inChannels, inDepth, inHeight, inWidth, outChannels, outDepth, outHeight, outWidth, strideDepth, strideHeight, strideWidth } = convInfo;
+ const frontPad = filterDepth - 1 - convInfo.padInfo.front;
+ const topPad = filterHeight - 1 - convInfo.padInfo.top;
+ const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+ for (let b = 0; b < batchSize; ++b) {
+ for (let d1 = 0; d1 < inChannels; ++d1) {
+ // Frames of depth
+ for (let xF = 0; xF < inDepth; ++xF) {
+ const xFCorner = xF - frontPad;
+ const xFMin = Math.max(0, Math.ceil(xFCorner / strideDepth));
+ const yFMax = Math.min(outDepth, (filterDepth + xFCorner) / strideDepth);
+ // Rows as per standard 2d matrix notation
+ for (let xR = 0; xR < inHeight; ++xR) {
+ const xRCorner = xR - topPad;
+ const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+ const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+ // Columns as per standard 2d matrix notation
+ for (let xC = 0; xC < inWidth; ++xC) {
+ const xCCorner = xC - leftPad;
+ const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+ const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+ let dotProd = 0;
+ for (let yF = xFMin; yF < yFMax; ++yF) {
+ const wF = yF * strideDepth - xFCorner;
+ for (let yR = xRMin; yR < yRMax; ++yR) {
+ const wR = yR * strideHeight - xRCorner;
+ for (let yC = xCMin; yC < yCMax; ++yC) {
+ const wC = yC * strideWidth - xCCorner;
+ const dyOffset = dyS0 * b + dyS1 * yF + dyS2 * yR + dyS3 * yC;
+ const fltOffset = fltS0 * (filterDepth - 1 - wF) +
+ fltS1 * (filterHeight - 1 - wR) +
+ fltS2 * (filterWidth - 1 - wC) + fltS3 * d1;
+ for (let d2 = 0; d2 < outChannels; ++d2) {
+ const pixel = dyValues[dyOffset + d2];
+ const weight = fltValues[fltOffset + d2];
+ dotProd += pixel * weight;
+ }
+ }
+ }
+ }
+ dxValues[dxS0 * b + dxS1 * xF + dxS2 * xR + dxS3 * xC + d1] =
+ dotProd;
+ }
+ }
+ }
+ }
+ }
+ return dx.toTensor();
+ }
+ conv2dDerFilter(x, dy, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, dy], 'conv2dDerFilter');
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const filterHeight = convInfo.filterHeight;
+ const filterWidth = convInfo.filterWidth;
+ const isChannelsLast = convInfo.dataFormat === 'channelsLast';
+ const dW = dist["buffer"](convInfo.filterShape, 'float32');
+ const leftPad = convInfo.padInfo.left;
+ const topPad = convInfo.padInfo.top;
+ const xBuf = this.bufferSync(x);
+ const dyBuf = this.bufferSync(dy);
+ for (let wR = 0; wR < filterHeight; ++wR) {
+ const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+ const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+ for (let wC = 0; wC < filterWidth; ++wC) {
+ const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+ const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+ for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+ for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+ // Need to convolve.
+ let dotProd = 0;
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ for (let yR = yRMin; yR < yRMax; ++yR) {
+ const xR = wR + yR * strideHeight - topPad;
+ for (let yC = yCMin; yC < yCMax; ++yC) {
+ const xC = wC + yC * strideWidth - leftPad;
+ if (isChannelsLast) {
+ dotProd +=
+ xBuf.get(b, xR, xC, d1) * dyBuf.get(b, yR, yC, d2);
+ }
+ else {
+ dotProd +=
+ xBuf.get(b, d1, xR, xC) * dyBuf.get(b, d2, yR, yC);
+ }
+ }
+ }
+ }
+ dW.set(dotProd, wR, wC, d1, d2);
+ }
+ }
+ }
+ }
+ return dW.toTensor();
+ }
+ conv3dDerFilter(x, dy, convInfo) {
+ const strideDepth = convInfo.strideDepth;
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const filterDepth = convInfo.filterDepth;
+ const filterHeight = convInfo.filterHeight;
+ const filterWidth = convInfo.filterWidth;
+ const dw = dist["buffer"](convInfo.filterShape, 'float32');
+ const dwValues = dw.values;
+ const [dwS0, dwS1, dwS2, dwS3] = dw.strides;
+ const dyValues = this.readSync(dy.dataId);
+ const [dyS0, dyS1, dyS2, dyS3] = dy.strides;
+ const xValues = this.readSync(x.dataId);
+ const [xS0, xS1, xS2, xS3] = x.strides;
+ const frontPad = convInfo.padInfo.front;
+ const leftPad = convInfo.padInfo.left;
+ const topPad = convInfo.padInfo.top;
+ for (let wF = 0; wF < filterDepth; ++wF) {
+ const yFMin = Math.max(0, Math.ceil((frontPad - wF) / strideDepth));
+ const yFMax = Math.min(convInfo.outDepth, (convInfo.inDepth + frontPad - wF) / strideDepth);
+ const wOffset1 = wF * dwS0;
+ for (let wR = 0; wR < filterHeight; ++wR) {
+ const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+ const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+ const wOffset2 = wR * dwS1 + wOffset1;
+ for (let wC = 0; wC < filterWidth; ++wC) {
+ const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+ const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+ const wOffset3 = wC * dwS2 + wOffset2;
+ for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+ const wOffset4 = d1 * dwS3 + wOffset3;
+ for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+ let dotProd = 0;
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ const xOffset1 = b * xS0;
+ const yOffset1 = b * dyS0;
+ for (let yF = yFMin; yF < yFMax; ++yF) {
+ const xF = wF + yF * strideDepth - frontPad;
+ const xOffset2 = xF * xS1 + xOffset1;
+ const yOffset2 = yF * dyS1 + yOffset1;
+ for (let yR = yRMin; yR < yRMax; ++yR) {
+ const xR = wR + yR * strideHeight - topPad;
+ const xOffset3 = xR * xS2 + xOffset2;
+ const yOffset3 = yR * dyS2 + yOffset2;
+ for (let yC = yCMin; yC < yCMax; ++yC) {
+ const xC = wC + yC * strideWidth - leftPad;
+ const xOffset4 = xC * xS3 + xOffset3;
+ const yOffset4 = yC * dyS3 + yOffset3;
+ dotProd +=
+ xValues[xOffset4 + d1] * dyValues[yOffset4 + d2];
+ }
+ }
+ }
+ }
+ dwValues[wOffset4 + d2] = dotProd;
+ }
+ }
+ }
+ }
+ }
+ return dw.toTensor();
+ }
+ fusedDepthwiseConv2D({ input, filter, convInfo, bias, activation, preluActivationWeights }) {
+ let result = this.depthwiseConv2D(input, filter, convInfo);
+ if (bias) {
+ result = this.add(result, bias);
+ }
+ if (activation) {
+ result =
+ mapActivation(this, result, activation, preluActivationWeights);
+ }
+ return result;
+ }
+ depthwiseConv2D(x, filter, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, filter], 'depthwiseConv2D');
+ const filterHeight = convInfo.filterHeight;
+ const filterWidth = convInfo.filterWidth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const padLeft = convInfo.padInfo.left;
+ const padTop = convInfo.padInfo.top;
+ const chMul = convInfo.outChannels / convInfo.inChannels;
+ const y = dist["buffer"](convInfo.outShape, x.dtype);
+ const xVals = this.readSync(x.dataId);
+ const wVals = this.readSync(filter.dataId);
+ const yVals = y.values;
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ const xOffset1 = b * x.strides[0];
+ const yOffset1 = b * y.strides[0];
+ for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+ const yOffset2 = yOffset1 + yR * y.strides[1];
+ const xRCorner = yR * convInfo.strideHeight - padLeft;
+ for (let wR = 0; wR < filterHeight; ++wR) {
+ const xR = xRCorner + wR * dilationHeight;
+ if (xR < 0 || xR >= convInfo.inHeight) {
+ continue;
+ }
+ const wOffset1 = wR * filter.strides[0];
+ const xOffset2 = xOffset1 + xR * x.strides[1];
+ for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+ const yOffset3 = yOffset2 + yC * y.strides[2];
+ const xCCorner = yC * convInfo.strideWidth - padTop;
+ for (let wC = 0; wC < filterWidth; ++wC) {
+ const xC = xCCorner + wC * dilationWidth;
+ if (xC < 0 || xC >= convInfo.inWidth) {
+ continue;
+ }
+ const wOffset2 = wOffset1 + wC * filter.strides[1];
+ const xOffset3 = xOffset2 + xC * convInfo.inChannels;
+ let yOffset4 = yOffset3;
+ let wOffset3 = wOffset2;
+ for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+ const xVal = xVals[xOffset3 + d1];
+ for (let q = 0; q < chMul; ++q) {
+ yVals[yOffset4 + q] += xVal * wVals[wOffset3 + q];
+ }
+ yOffset4 += chMul;
+ wOffset3 += chMul;
+ }
+ }
+ }
+ }
+ }
+ }
+ return y.toTensor();
+ }
+ depthwiseConv2DDerInput(dy, filter, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([dy, filter], 'depthwiseConv2DDerInput');
+ const dx = dist["buffer"](convInfo.inShape, 'float32');
+ const dxValues = dx.values;
+ const [dxS0, dxS1, dxS2] = dx.strides;
+ const dyValues = this.readSync(dy.dataId);
+ const [dyS0, dyS1, dyS2] = dy.strides;
+ const fltValues = this.readSync(filter.dataId);
+ const [fltS0, fltS1, fltS2] = filter.strides;
+ const { batchSize, filterHeight, filterWidth, inChannels, inHeight, inWidth, outChannels, outHeight, outWidth, strideHeight, strideWidth } = convInfo;
+ const topPad = filterHeight - 1 - convInfo.padInfo.top;
+ const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+ const chMul = outChannels / inChannels;
+ for (let b = 0; b < batchSize; ++b) {
+ for (let d1 = 0; d1 < inChannels; ++d1) {
+ for (let xR = 0; xR < inHeight; ++xR) {
+ const xRCorner = xR - topPad;
+ const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+ const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+ for (let xC = 0; xC < inWidth; ++xC) {
+ const xCCorner = xC - leftPad;
+ const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+ const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+ let dotProd = 0;
+ for (let yR = xRMin; yR < yRMax; ++yR) {
+ const wR = yR * strideHeight - xRCorner;
+ for (let yC = xCMin; yC < yCMax; ++yC) {
+ const wC = yC * strideWidth - xCCorner;
+ const dyOffset = dyS0 * b + dyS1 * yR + dyS2 * yC;
+ const fltOffset = fltS0 * (filterHeight - 1 - wR) +
+ fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;
+ for (let dm = 0; dm < chMul; ++dm) {
+ const d2 = d1 * chMul + dm;
+ const pixel = dyValues[dyOffset + d2];
+ const weight = fltValues[fltOffset + dm];
+ dotProd += pixel * weight;
+ }
+ }
+ }
+ dxValues[dxS0 * b + dxS1 * xR + dxS2 * xC + d1] = dotProd;
+ }
+ }
+ }
+ }
+ return dx.toTensor();
+ }
+ depthwiseConv2DDerFilter(x, dy, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, dy], 'depthwiseConv2DDerFilter');
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const filterHeight = convInfo.filterHeight;
+ const filterWidth = convInfo.filterWidth;
+ const dW = dist["buffer"](convInfo.filterShape, 'float32');
+ const leftPad = convInfo.padInfo.left;
+ const topPad = convInfo.padInfo.top;
+ const chMul = convInfo.outChannels / convInfo.inChannels;
+ const xBuf = this.bufferSync(x);
+ const dyBuf = this.bufferSync(dy);
+ for (let wR = 0; wR < filterHeight; ++wR) {
+ const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+ const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+ for (let wC = 0; wC < filterWidth; ++wC) {
+ const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+ const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+ for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+ const d1 = Math.trunc(d2 / chMul);
+ const dm = d2 % chMul;
+ let dotProd = 0;
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ for (let yR = yRMin; yR < yRMax; ++yR) {
+ const xR = wR + yR * strideHeight - topPad;
+ for (let yC = yCMin; yC < yCMax; ++yC) {
+ const xC = wC + yC * strideWidth - leftPad;
+ dotProd += xBuf.get(b, xR, xC, d1) * dyBuf.get(b, yR, yC, d2);
+ }
+ }
+ }
+ dW.set(dotProd, wR, wC, d1, dm);
+ }
+ }
+ }
+ return dW.toTensor();
+ }
+ tile(x, reps) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'tile');
+ return tile(this.bufferSync(x), reps);
+ }
+ pad(x, paddings, constantValue) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'pad');
+ const outShape = paddings.map((p, i) => p[0] /* beforePad */ + x.shape[i] + p[1] /* afterPad */);
+ const start = paddings.map(p => p[0]);
+ const xBuffer = this.bufferSync(x);
+ const buffer = dist["buffer"](outShape, x.dtype);
+ if (constantValue !== 0) {
+ buffer.values.fill(constantValue);
+ }
+ for (let i = 0; i < x.size; i++) {
+ const coords = xBuffer.indexToLoc(i);
+ const outCoords = coords.map((c, i) => c + start[i]);
+ buffer.set(xBuffer.get(...coords), ...outCoords);
+ }
+ return buffer.toTensor();
+ }
+ gather(x, indices, axis) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, indices], 'gather');
+ const newShape = x.shape.slice();
+ const indicesValues = this.readSync(indices.dataId);
+ newShape[axis] = indicesValues.length;
+ const result = dist["buffer"](newShape, x.dtype);
+ const xBuf = this.bufferSync(x);
+ for (let i = 0; i < result.size; ++i) {
+ const newLoc = result.indexToLoc(i);
+ const originalLoc = newLoc.slice();
+ originalLoc[axis] = indicesValues[newLoc[axis]];
+ const originalIndex = xBuf.locToIndex(originalLoc);
+ result.values[i] = xBuf.values[originalIndex];
+ }
+ return result.toTensor();
+ }
+ batchToSpaceND(x, blockShape, crops) {
+ Object(cpu_util["a" /* assertNotComplex */])([x], 'batchToSpaceND');
+ const prod = blockShape.reduce((a, b) => a * b);
+ const reshaped = dist["backend_util"].getReshaped(x.shape, blockShape, prod);
+ const permuted = dist["backend_util"].getPermuted(reshaped.length, blockShape.length);
+ const reshapedPermuted = dist["backend_util"].getReshapedPermuted(x.shape, blockShape, prod);
+ const sliceBeginCoords = dist["backend_util"].getSliceBeginCoords(crops, blockShape.length);
+ const sliceSize = dist["backend_util"].getSliceSize(reshapedPermuted, crops, blockShape.length);
+ return dist["transpose"](x.reshape(reshaped), permuted)
+ .reshape(reshapedPermuted)
+ .slice(sliceBeginCoords, sliceSize);
+ }
+ spaceToBatchND(x, blockShape, paddings) {
+ Object(cpu_util["a" /* assertNotComplex */])([x], 'spaceToBatchND');
+ const prod = blockShape.reduce((a, b) => a * b);
+ const completePaddings = [[0, 0]];
+ completePaddings.push(...paddings);
+ for (let i = 1 + blockShape.length; i < x.shape.length; ++i) {
+ completePaddings.push([0, 0]);
+ }
+ const paddedX = x.pad(completePaddings);
+ const reshapedPaddedShape = dist["backend_util"].getReshaped(paddedX.shape, blockShape, prod, false);
+ const permutedReshapedPaddedPermutation = dist["backend_util"].getPermuted(reshapedPaddedShape.length, blockShape.length, false);
+ const flattenShape = dist["backend_util"].getReshapedPermuted(paddedX.shape, blockShape, prod, false);
+ return dist["transpose"](paddedX.reshape(reshapedPaddedShape), permutedReshapedPaddedPermutation)
+ .reshape(flattenShape);
+ }
+ maxPool(x, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'maxPool');
+ const xValues = this.readSync(x.dataId);
+ return Object(pool_utils["b" /* pool */])(xValues, x.shape, x.dtype, x.strides, convInfo, 'max')
+ .toTensor();
+ }
+ maxPoolBackprop(dy, x, y, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, y], 'maxPoolBackprop');
+ const xValues = this.readSync(x.dataId);
+ const maxPosBuf = Object(dist["buffer"])(convInfo.outShape, x.dtype, Object(pool_utils["a" /* maxPoolPositions */])(xValues, x.shape, x.dtype, convInfo).values);
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+ const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+ const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+ const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+ const dx = dist["buffer"](x.shape, 'float32');
+ const dyBuf = this.bufferSync(dy);
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ for (let d = 0; d < convInfo.inChannels; ++d) {
+ for (let dxR = 0; dxR < convInfo.inHeight; ++dxR) {
+ for (let dxC = 0; dxC < convInfo.inWidth; ++dxC) {
+ // Shader code begins.
+ const dyRCorner = dxR - padTop;
+ const dyCCorner = dxC - padLeft;
+ let dotProd = 0;
+ for (let wR = 0; wR < effectiveFilterHeight; wR += dilationHeight) {
+ const dyR = (dyRCorner + wR) / strideHeight;
+ if (dyR < 0 || dyR >= convInfo.outHeight ||
+ Math.floor(dyR) !== dyR) {
+ continue;
+ }
+ for (let wC = 0; wC < effectiveFilterWidth; wC += dilationWidth) {
+ const dyC = (dyCCorner + wC) / strideWidth;
+ if (dyC < 0 || dyC >= convInfo.outWidth ||
+ Math.floor(dyC) !== dyC) {
+ continue;
+ }
+ const maxPos = effectiveFilterHeight * effectiveFilterWidth -
+ 1 - maxPosBuf.get(b, dyR, dyC, d);
+ const curPos = wR * effectiveFilterWidth + wC;
+ const mask = maxPos === curPos ? 1 : 0;
+ if (mask === 0) {
+ continue;
+ }
+ const pixel = dyBuf.get(b, dyR, dyC, d);
+ dotProd += pixel * mask;
+ }
+ }
+ dx.set(dotProd, b, dxR, dxC, d);
+ }
+ }
+ }
+ }
+ return dx.toTensor();
+ }
+ avgPoolBackprop(dy, x, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([dy, x], 'avgPoolBackprop');
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const filterHeight = convInfo.filterHeight;
+ const filterWidth = convInfo.filterWidth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+ const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+ const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+ const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+ const dx = dist["buffer"](x.shape, 'float32');
+ const avgMultiplier = 1 / (filterHeight * filterWidth);
+ const dyBuf = this.bufferSync(dy);
+ for (let b = 0; b < convInfo.batchSize; ++b) {
+ for (let d = 0; d < convInfo.inChannels; ++d) {
+ for (let dxR = 0; dxR < convInfo.inHeight; ++dxR) {
+ for (let dxC = 0; dxC < convInfo.inWidth; ++dxC) {
+ // Shader code begins.
+ const dyRCorner = dxR - padTop;
+ const dyCCorner = dxC - padLeft;
+ let dotProd = 0;
+ for (let wR = 0; wR < effectiveFilterHeight; wR += dilationHeight) {
+ const dyR = (dyRCorner + wR) / strideHeight;
+ if (dyR < 0 || dyR >= convInfo.outHeight ||
+ Math.floor(dyR) !== dyR) {
+ continue;
+ }
+ for (let wC = 0; wC < effectiveFilterWidth; wC += dilationWidth) {
+ const dyC = (dyCCorner + wC) / strideWidth;
+ if (dyC < 0 || dyC >= convInfo.outWidth ||
+ Math.floor(dyC) !== dyC) {
+ continue;
+ }
+ const pixel = dyBuf.get(b, dyR, dyC, d);
+ dotProd += pixel;
+ }
+ }
+ dx.set(dotProd * avgMultiplier, b, dxR, dxC, d);
+ }
+ }
+ }
+ }
+ return dx.toTensor();
+ }
+ pool3d(x, convInfo, poolType) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'pool3d');
+ const strideDepth = convInfo.strideDepth;
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const dilationDepth = convInfo.dilationDepth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+ const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+ const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+ const padFront = convInfo.padInfo.front;
+ const padTop = convInfo.padInfo.top;
+ const padLeft = convInfo.padInfo.left;
+ const initialValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY :
+ Number.POSITIVE_INFINITY);
+ const xValues = this.readSync(x.dataId);
+ const output = dist["buffer"](convInfo.outShape, x.dtype);
+ const outputVals = output.values;
+ const outputBatchStrides = convInfo.outShape[1] * convInfo.outShape[2] *
+ convInfo.outShape[3] * convInfo.outShape[4];
+ const outputDepthStrides = convInfo.outShape[2] * convInfo.outShape[3] * convInfo.outShape[4];
+ const outputRowStrides = convInfo.outShape[3] * convInfo.outShape[4];
+ const outputColStrides = convInfo.outShape[4];
+ for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+ const outputBatchOffset = batch * outputBatchStrides;
+ const inputBatchOffset = batch * x.strides[0];
+ for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+ for (let yDepth = 0; yDepth < convInfo.outDepth; ++yDepth) {
+ const xDepthCorner = yDepth * strideDepth - padFront;
+ let xDepthMin = xDepthCorner;
+ while (xDepthMin < 0) {
+ xDepthMin += dilationDepth;
+ }
+ const xDepthMax = Math.min(convInfo.inDepth, effectiveFilterDepth + xDepthCorner);
+ const outputDepthOffset = outputBatchOffset + yDepth * outputDepthStrides;
+ for (let yRow = 0; yRow < convInfo.outHeight; ++yRow) {
+ const xRowCorner = yRow * strideHeight - padTop;
+ let xRowMin = xRowCorner;
+ while (xRowMin < 0) {
+ xRowMin += dilationHeight;
+ }
+ const xRowMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRowCorner);
+ const outputRowOffset = outputDepthOffset + yRow * outputRowStrides;
+ for (let yCol = 0; yCol < convInfo.outWidth; ++yCol) {
+ const xColCorner = yCol * strideWidth - padLeft;
+ let xColMin = xColCorner;
+ while (xColMin < 0) {
+ xColMin += dilationWidth;
+ }
+ const xColMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xColCorner);
+ // Shader code begins
+ const outputColOffset = outputRowOffset + yCol * outputColStrides;
+ let minMaxValue = initialValue;
+ let avgValue = 0;
+ let count = 0;
+ for (let xDepth = xDepthMin; xDepth < xDepthMax; xDepth += dilationDepth) {
+ const xDepthOffset = inputBatchOffset + xDepth * x.strides[1];
+ for (let xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
+ const xRowOffset = xDepthOffset + xRow * x.strides[2];
+ for (let xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
+ const xColOffset = xRowOffset + xCol * x.strides[3];
+ const pixel = xValues[xColOffset + channel];
+ if ((poolType === 'max' && pixel > minMaxValue)) {
+ minMaxValue = pixel;
+ }
+ else if (poolType === 'avg') {
+ avgValue += pixel;
+ count++;
+ }
+ if (isNaN(minMaxValue)) {
+ break;
+ }
+ }
+ if (isNaN(minMaxValue)) {
+ break;
+ }
+ }
+ if (isNaN(minMaxValue)) {
+ break;
+ }
+ }
+ const outputOffset = outputColOffset + channel;
+ outputVals[outputOffset] =
+ poolType === 'avg' ? avgValue / count : minMaxValue;
+ }
+ }
+ }
+ }
+ }
+ return output.toTensor();
+ }
+ avgPool3d(x, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'avgPool3d');
+ return this.pool3d(x, convInfo, 'avg').toFloat();
+ }
+ avgPool3dBackprop(dy, x, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([dy, x], 'avgPool3dBackprop');
+ const strideDepth = convInfo.strideDepth;
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const filterDepth = convInfo.filterDepth;
+ const filterHeight = convInfo.filterHeight;
+ const filterWidth = convInfo.filterWidth;
+ const dilationDepth = convInfo.dilationDepth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+ const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+ const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+ const padFront = effectiveFilterDepth - 1 - convInfo.padInfo.front;
+ const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+ const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+ const dx = dist["buffer"](x.shape, 'float32');
+ const avgMultiplier = 1 / (filterDepth * filterHeight * filterWidth);
+ const dyBuf = this.bufferSync(dy);
+ for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+ for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+ for (let dxDepth = 0; dxDepth < convInfo.inDepth; ++dxDepth) {
+ for (let dxRow = 0; dxRow < convInfo.inHeight; ++dxRow) {
+ for (let dxCol = 0; dxCol < convInfo.inWidth; ++dxCol) {
+ // Shader code begins.
+ const dyDepthCorner = dxDepth - padFront;
+ const dyRowCorner = dxRow - padTop;
+ const dyColCorner = dxCol - padLeft;
+ let dotProd = 0;
+ for (let wDepth = 0; wDepth < effectiveFilterDepth; wDepth += dilationDepth) {
+ const dyDepth = (dyDepthCorner + wDepth) / strideDepth;
+ if (dyDepth < 0 || dyDepth >= convInfo.outDepth ||
+ Math.floor(dyDepth) !== dyDepth) {
+ continue;
+ }
+ for (let wRow = 0; wRow < effectiveFilterHeight; wRow += dilationHeight) {
+ const dyRow = (dyRowCorner + wRow) / strideHeight;
+ if (dyRow < 0 || dyRow >= convInfo.outHeight ||
+ Math.floor(dyRow) !== dyRow) {
+ continue;
+ }
+ for (let wCol = 0; wCol < effectiveFilterWidth; wCol += dilationWidth) {
+ const dyCol = (dyColCorner + wCol) / strideWidth;
+ if (dyCol < 0 || dyCol >= convInfo.outWidth ||
+ Math.floor(dyCol) !== dyCol) {
+ continue;
+ }
+ const pixel = dyBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+ dotProd += pixel;
+ }
+ }
+ }
+ dx.set(dotProd * avgMultiplier, batch, dxDepth, dxRow, dxCol, channel);
+ }
+ }
+ }
+ }
+ }
+ return dx.toTensor();
+ }
+ maxPool3d(x, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'maxPool3d');
+ return this.pool3d(x, convInfo, 'max').toFloat();
+ }
+ maxPool3dPositions(x, convInfo) {
+ const maxPositions = dist["buffer"](convInfo.outShape, 'int32');
+ const strideDepth = convInfo.strideDepth;
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const dilationDepth = convInfo.dilationDepth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+ const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+ const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+ const padFront = convInfo.padInfo.front;
+ const padTop = convInfo.padInfo.top;
+ const padLeft = convInfo.padInfo.left;
+ const xBuf = this.bufferSync(x);
+ for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+ for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+ for (let yDepth = 0; yDepth < convInfo.outDepth; ++yDepth) {
+ const xDepthCorner = yDepth * strideDepth - padFront;
+ let xDepthMin = xDepthCorner;
+ while (xDepthMin < 0) {
+ xDepthMin += dilationDepth;
+ }
+ const xDepthMax = Math.min(convInfo.inDepth, effectiveFilterDepth + xDepthCorner);
+ for (let yRow = 0; yRow < convInfo.outHeight; ++yRow) {
+ const xRowCorner = yRow * strideHeight - padTop;
+ let xRowMin = xRowCorner;
+ while (xRowMin < 0) {
+ xRowMin += dilationHeight;
+ }
+ const xRowMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRowCorner);
+ for (let yCol = 0; yCol < convInfo.outWidth; ++yCol) {
+ const xColCorner = yCol * strideWidth - padLeft;
+ let xColMin = xColCorner;
+ while (xColMin < 0) {
+ xColMin += dilationWidth;
+ }
+ const xColMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xColCorner);
+ // Shader code begins
+ let maxValue = Number.NEGATIVE_INFINITY;
+ let maxPosition = -1;
+ for (let xDepth = xDepthMin; xDepth < xDepthMax; xDepth += dilationDepth) {
+ const wDepth = xDepth - xDepthCorner;
+ for (let xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
+ const wRow = xRow - xRowCorner;
+ for (let xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
+ const wCol = xCol - xColCorner;
+ const pixel = xBuf.get(batch, xDepth, xRow, xCol, channel);
+ if (pixel >= maxValue) {
+ maxValue = pixel;
+ maxPosition = wDepth * effectiveFilterHeight *
+ effectiveFilterWidth +
+ wRow * effectiveFilterHeight + wCol;
+ }
+ }
+ }
+ }
+ maxPositions.set(maxPosition, batch, yDepth, yRow, yCol, channel);
+ }
+ }
+ }
+ }
+ }
+ return maxPositions.toTensor();
+ }
+ maxPool3dBackprop(dy, x, y, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, y], 'maxPool3dBackprop');
+ const maxPositions = this.maxPool3dPositions(x, convInfo);
+ const strideDepth = convInfo.strideDepth;
+ const strideHeight = convInfo.strideHeight;
+ const strideWidth = convInfo.strideWidth;
+ const dilationDepth = convInfo.dilationDepth;
+ const dilationHeight = convInfo.dilationHeight;
+ const dilationWidth = convInfo.dilationWidth;
+ const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+ const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+ const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+ const padFront = effectiveFilterDepth - 1 - convInfo.padInfo.front;
+ const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+ const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+ const dx = dist["buffer"](x.shape, 'float32');
+ const maxPosBuf = this.bufferSync(maxPositions);
+ const dyBuf = this.bufferSync(dy);
+ for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+ for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+ for (let dxDepth = 0; dxDepth < convInfo.inDepth; ++dxDepth) {
+ for (let dxRow = 0; dxRow < convInfo.inHeight; ++dxRow) {
+ for (let dxCol = 0; dxCol < convInfo.inWidth; ++dxCol) {
+ // Shader code begins
+ const dyDepthCorner = dxDepth - padFront;
+ const dyRowCorner = dxRow - padTop;
+ const dyColCorner = dxCol - padLeft;
+ let dotProd = 0;
+ for (let wDepth = 0; wDepth < effectiveFilterDepth; wDepth += dilationDepth) {
+ const dyDepth = (dyDepthCorner + wDepth) / strideDepth;
+ if (dyDepth < 0 || dyDepth >= convInfo.outDepth ||
+ Math.floor(dyDepth) !== dyDepth) {
+ continue;
+ }
+ for (let wRow = 0; wRow < effectiveFilterHeight; wRow += dilationHeight) {
+ const dyRow = (dyRowCorner + wRow) / strideHeight;
+ if (dyRow < 0 || dyRow >= convInfo.outHeight ||
+ Math.floor(dyRow) !== dyRow) {
+ continue;
+ }
+ for (let wCol = 0; wCol < effectiveFilterWidth; wCol += dilationWidth) {
+ const dyCol = (dyColCorner + wCol) / strideWidth;
+ if (dyCol < 0 || dyCol >= convInfo.outWidth ||
+ Math.floor(dyCol) !== dyCol) {
+ continue;
+ }
+ const maxPos = effectiveFilterDepth *
+ effectiveFilterHeight * effectiveFilterWidth -
+ 1 -
+ maxPosBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+ const curPos = wDepth * effectiveFilterHeight * effectiveFilterWidth +
+ wRow * effectiveFilterWidth + wCol;
+ const mask = maxPos === curPos ? 1 : 0;
+ if (mask === 0) {
+ continue;
+ }
+ const pixel = dyBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+ dotProd += pixel * mask;
+ }
+ }
+ }
+ dx.set(dotProd, batch, dxDepth, dxRow, dxCol, channel);
+ }
+ }
+ }
+ }
+ }
+ return dx.toTensor();
+ }
+ cast(x, dtype) {
+ return dist["backend_util"].castTensor(x, dtype, this);
+ }
+ reshape(x, shape) {
+ return dist["backend_util"].reshapeTensor(x, shape);
+ }
+ avgPool(x, convInfo) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'avgPool');
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'maxPool');
+ const xValues = this.readSync(x.dataId);
+ return Object(pool_utils["b" /* pool */])(xValues, x.shape, x.dtype, x.strides, convInfo, 'avg')
+ .toTensor()
+ .toFloat();
+ }
+ resizeBilinear(x, newHeight, newWidth, alignCorners) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'resizeBilinear');
+ const [batch, oldHeight, oldWidth, numChannels] = x.shape;
+ const xValues = this.readSync(x.dataId);
+ const result = new Float32Array(dist["util"].sizeFromShape([batch, newHeight, newWidth, numChannels]));
+ const effectiveInputSize = [
+ (alignCorners && newHeight > 1) ? oldHeight - 1 : oldHeight,
+ (alignCorners && newWidth > 1) ? oldWidth - 1 : oldWidth
+ ];
+ const effectiveOutputSize = [
+ (alignCorners && newHeight > 1) ? newHeight - 1 : newHeight,
+ (alignCorners && newWidth > 1) ? newWidth - 1 : newWidth
+ ];
+ let outputIdx = 0;
+ const effectiveRowSizeRatio = effectiveInputSize[0] / effectiveOutputSize[0];
+ const effectiveColSizeRatio = effectiveInputSize[1] / effectiveOutputSize[1];
+ for (let b = 0; b < batch; b++) {
+ for (let r = 0; r < newHeight; r++) {
+ const sourceFracRow = effectiveRowSizeRatio * r;
+ const sourceRowFloor = Math.floor(sourceFracRow);
+ const rowFrac = sourceFracRow - sourceRowFloor;
+ const sourceRowCeil = Math.min(oldHeight - 1, Math.ceil(sourceFracRow));
+ const topRowOffset = b * x.strides[0] + sourceRowFloor * x.strides[1];
+ const botRowOffset = b * x.strides[0] + sourceRowCeil * x.strides[1];
+ for (let c = 0; c < newWidth; c++) {
+ const sourceFracCol = effectiveColSizeRatio * c;
+ const sourceColFloor = Math.floor(sourceFracCol);
+ const colFrac = sourceFracCol - sourceColFloor;
+ const sourceColCeil = Math.min(oldWidth - 1, Math.ceil(sourceFracCol));
+ const topLeftOffest = topRowOffset + sourceColFloor * x.strides[2];
+ const botLeftOffset = botRowOffset + sourceColFloor * x.strides[2];
+ const topRightOffset = topRowOffset + sourceColCeil * x.strides[2];
+ const botRightOffest = botRowOffset + sourceColCeil * x.strides[2];
+ for (let d = 0; d < numChannels; d++) {
+ // Begin shader.
+ // Compute the fractional index of the source.
+ const topLeft = xValues[topLeftOffest + d];
+ const bottomLeft = xValues[botLeftOffset + d];
+ const topRight = xValues[topRightOffset + d];
+ const bottomRight = xValues[botRightOffest + d];
+ const top = topLeft + (topRight - topLeft) * colFrac;
+ const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;
+ const newValue = top + (bottom - top) * rowFrac;
+ result[outputIdx++] = newValue;
+ }
+ }
+ }
+ }
+ return dist["tensor"](result, [batch, newHeight, newWidth, numChannels]);
+ }
+ resizeBilinearBackprop(dy, x, alignCorners) {
+ Object(cpu_util["a" /* assertNotComplex */])([dy, x], 'resizeBilinearBackprop');
+ const [batch, xHeight, xWidth, depth] = x.shape;
+ const [, yHeight, yWidth] = dy.shape;
+ const output = new Float32Array(batch * xHeight * xWidth * depth);
+ // In the backwards pass, we want to find the pixels that were generated
+ // for each pixel in the input image the forward pass and add the
+ // corresponding coefficient from dy to the gradient (with some
+ // interpolation).
+ const effectiveXSize = [
+ (alignCorners && yHeight > 1) ? xHeight - 1 : xHeight,
+ (alignCorners && yWidth > 1) ? xWidth - 1 : xWidth
+ ];
+ const effectiveYSize = [
+ (alignCorners && yHeight > 1) ? yHeight - 1 : yHeight,
+ (alignCorners && yWidth > 1) ? yWidth - 1 : yWidth
+ ];
+ const heightScale = effectiveXSize[0] / effectiveYSize[0];
+ const widthScale = effectiveXSize[1] / effectiveYSize[1];
+ // Reference implementation
+ // tslint:disable-next-line:max-line-length
+ // https://github.com/tensorflow/tensorflow/blob/3039375c86a5bbc9610c7725dcaa95d635f87ba2/tensorflow/core/kernels/resize_bilinear_op.cc#L275
+ const dyValues = this.readSync(dy.dataId);
+ let offset = 0;
+ for (let b = 0; b < batch; b++) {
+ const bOffset = b * x.strides[0];
+ for (let r = 0; r < yHeight; r++) {
+ const dxR = r * heightScale;
+ const topDxRIndex = Math.floor(dxR);
+ const bottomDxRIndex = Math.min(Math.ceil(dxR), xHeight - 1);
+ const topDxROffset = bOffset + topDxRIndex * x.strides[1];
+ const bottomDxROffset = bOffset + bottomDxRIndex * x.strides[1];
+ const dxRLerp = dxR - topDxRIndex;
+ const inverseDxRLerp = 1.0 - dxRLerp;
+ for (let c = 0; c < yWidth; c++) {
+ const dxC = c * widthScale;
+ const leftDxCIndex = Math.floor(dxC);
+ const rightDxCIndex = Math.min(Math.ceil(dxC), xWidth - 1);
+ const dxCLerp = dxC - leftDxCIndex;
+ const inverseDxCLerp = 1.0 - dxCLerp;
+ const topLeftRCOffset = topDxROffset + leftDxCIndex * x.strides[2];
+ const topRightRCOffset = topDxROffset + rightDxCIndex * x.strides[2];
+ const bottomLeftRCOffset = bottomDxROffset + leftDxCIndex * x.strides[2];
+ const bottomRightRCOffset = bottomDxROffset + rightDxCIndex * x.strides[2];
+ const inverseDxRLerpTimesInverseDxCLerp = inverseDxRLerp * inverseDxCLerp;
+ const inverseDxRLerpTimesDxCLerp = inverseDxRLerp * dxCLerp;
+ const dxRLerpTimesInverseDxCLerp = dxRLerp * inverseDxCLerp;
+ const dxRLerpTimesDxCLerp = dxRLerp * dxCLerp;
+ for (let d = 0; d < depth; d++) {
+ const dyVal = dyValues[offset++];
+ output[topLeftRCOffset + d] +=
+ dyVal * inverseDxRLerpTimesInverseDxCLerp;
+ output[topRightRCOffset + d] += dyVal * inverseDxRLerpTimesDxCLerp;
+ output[bottomLeftRCOffset + d] +=
+ dyVal * dxRLerpTimesInverseDxCLerp;
+ output[bottomRightRCOffset + d] += dyVal * dxRLerpTimesDxCLerp;
+ }
+ }
+ }
+ }
+ return dist["tensor4d"](output, [batch, xWidth, xHeight, depth], x.dtype);
+ }
+ resizeNearestNeighbor(x, newHeight, newWidth, alignCorners) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'resizeNearestNeighbor');
+ const [batch, oldHeight, oldWidth, numChannels] = x.shape;
+ const xValues = this.readSync(x.dataId);
+ const output = new Float32Array(batch * newHeight * newWidth * numChannels);
+ const effectiveInputSize = [
+ (alignCorners && newHeight > 1) ? oldHeight - 1 : oldHeight,
+ (alignCorners && newWidth > 1) ? oldWidth - 1 : oldWidth
+ ];
+ const effectiveOutputSize = [
+ (alignCorners && newHeight > 1) ? newHeight - 1 : newHeight,
+ (alignCorners && newWidth > 1) ? newWidth - 1 : newWidth
+ ];
+ const effectiveRowSizeRatio = effectiveInputSize[0] / effectiveOutputSize[0];
+ const effectiveColSizeRatio = effectiveInputSize[1] / effectiveOutputSize[1];
+ let outputOffset = 0;
+ for (let b = 0; b < batch; b++) {
+ const batchOffset = b * x.strides[0];
+ for (let r = 0; r < newHeight; r++) {
+ const sourceFracRow = effectiveRowSizeRatio * r;
+ const sourceNearestRow = Math.min(oldHeight - 1, alignCorners ? Math.round(sourceFracRow) :
+ Math.floor(sourceFracRow));
+ const rowOffset = batchOffset + sourceNearestRow * x.strides[1];
+ for (let c = 0; c < newWidth; c++) {
+ const sourceFracCol = effectiveColSizeRatio * c;
+ const sourceNearestCol = Math.min(oldWidth - 1, alignCorners ? Math.round(sourceFracCol) :
+ Math.floor(sourceFracCol));
+ const colOffset = rowOffset + sourceNearestCol * x.strides[2];
+ for (let d = 0; d < numChannels; d++) {
+ // Begin shader.
+ // Compute the fractional index of the source.
+ const newVal = xValues[colOffset + d];
+ output[outputOffset++] = newVal;
+ }
+ }
+ }
+ }
+ return dist["tensor"](output, [batch, newHeight, newWidth, numChannels], x.dtype);
+ }
+ resizeNearestNeighborBackprop(dy, x, alignCorners) {
+ Object(cpu_util["a" /* assertNotComplex */])([dy, x], 'resizeNearestNeighborBackprop');
+ const [batch, xHeight, xWidth, depth] = x.shape;
+ const [, yHeight, yWidth] = dy.shape;
+ const output = new Float32Array(batch * xHeight * xWidth * depth);
+ const dyValues = this.readSync(dy.dataId);
+ // In the backwards pass, we want to find the pixels that were generated
+ // for each pixel in the input image the forward pass
+ const effectiveXSize = [
+ (alignCorners && yHeight > 1) ? xHeight - 1 : xHeight,
+ (alignCorners && yWidth > 1) ? xWidth - 1 : xWidth
+ ];
+ const effectiveYSize = [
+ (alignCorners && yHeight > 1) ? yHeight - 1 : yHeight,
+ (alignCorners && yWidth > 1) ? yWidth - 1 : yWidth
+ ];
+ const heightScale = effectiveXSize[0] / effectiveYSize[0];
+ const widthScale = effectiveXSize[1] / effectiveYSize[1];
+ const invHeightScale = 1 / heightScale;
+ const invWidthScale = 1 / widthScale;
+ // This defines the size of the window of values around a particular
+ // index in dy that we want to search for contributions to dx.
+ const winHeight = (Math.ceil(invHeightScale) * 2) + 2;
+ const winWidth = (Math.ceil(invWidthScale) * 2) + 2;
+ // Loop over the output space.
+ for (let b = 0; b < batch; b++) {
+ const batchOffset = b * x.strides[0];
+ for (let r = 0; r < xHeight; r++) {
+ const rowOffset = batchOffset + r * x.strides[1];
+ // Compute bounds for where in dy we will look
+ const startRLerp = Math.floor(r * invHeightScale);
+ const startDyR = Math.floor(startRLerp - (winHeight / 2));
+ for (let c = 0; c < xWidth; c++) {
+ const colOffset = rowOffset + c * x.strides[2];
+ // Compute bounds for where in dy we will look
+ const startCLerp = Math.floor(c * invWidthScale);
+ const startDyC = Math.floor(startCLerp - (winWidth / 2));
+ for (let d = 0; d < depth; d++) {
+ let accum = 0;
+ // loop over dy
+ for (let dyRIndex = 0; dyRIndex < winHeight; dyRIndex++) {
+ const dyR = dyRIndex + startDyR;
+ // Guard against the window exceeding the bounds of dy
+ if (dyR < 0 || dyR >= yHeight) {
+ continue;
+ }
+ const dyROffset = batchOffset + dyR * dy.strides[1];
+ const sourceFracRow = dyR * heightScale;
+ const sourceNearestRow = Math.min(xHeight - 1, alignCorners ? Math.round(sourceFracRow) :
+ Math.floor(sourceFracRow));
+ if (r !== sourceNearestRow) {
+ continue;
+ }
+ for (let dyCIndex = 0; dyCIndex < winWidth; dyCIndex++) {
+ const dyC = dyCIndex + startDyC;
+ // Guard against the window exceeding the bounds of dy
+ if (dyC < 0 || dyC >= yWidth) {
+ continue;
+ }
+ const dyCOffset = dyROffset + dyC * dy.strides[2];
+ const sourceFracCol = dyC * widthScale;
+ const sourceNearestCol = Math.min(xWidth - 1, alignCorners ? Math.round(sourceFracCol) :
+ Math.floor(sourceFracCol));
+ if (c === sourceNearestCol) {
+ accum += dyValues[dyCOffset + d];
+ }
+ }
+ }
+ output[colOffset + d] = accum;
+ }
+ }
+ }
+ }
+ return dist["tensor4d"](output, x.shape, x.dtype);
+ }
+ batchNorm(x, mean, variance, offset, scale, varianceEpsilon) {
+ Object(cpu_util["a" /* assertNotComplex */])([x, mean, variance, scale, offset], 'batchNorm');
+ const xVals = this.readSync(x.dataId);
+ const mVals = this.readSync(mean.dataId);
+ const varVals = this.readSync(variance.dataId);
+ const sVals = scale ? this.readSync(scale.dataId) :
+ new Float32Array([1]);
+ const offVals = offset ? this.readSync(offset.dataId) :
+ new Float32Array([0]);
+ const outVals = new Float32Array(xVals.length);
+ const offValsLength = offVals.length;
+ const sValsLength = sVals.length;
+ const varValsLength = varVals.length;
+ const mValsLength = mVals.length;
+ let offi = 0;
+ let mi = 0;
+ let si = 0;
+ let vi = 0;
+ for (let i = 0; i < xVals.length; ++i) {
+ outVals[i] = offVals[offi++] +
+ (xVals[i] - mVals[mi++]) * sVals[si++] /
+ Math.sqrt(varVals[vi++] + varianceEpsilon);
+ if (offi >= offValsLength) {
+ offi = 0;
+ }
+ if (mi >= mValsLength) {
+ mi = 0;
+ }
+ if (si >= sValsLength) {
+ si = 0;
+ }
+ if (vi >= varValsLength) {
+ vi = 0;
+ }
+ }
+ return dist["tensor4d"](outVals, x.shape);
+ }
+ localResponseNormalization4D(x, depthRadius, bias, alpha, beta) {
+ Object(cpu_util["a" /* assertNotComplex */])(x, 'localResponseNormalization4D');
+ const channels = x.shape[3];
+ const maxD = channels - 1;
+ const xValues = this.readSync(x.dataId);
+ const size = x.size;
+ const result = new Float32Array(size);
+ function sumAcrossChannels(offset) {
+ const currentChannel = offset % channels;
+ let beginSumOffset = offset - currentChannel + Math.max(0, currentChannel - depthRadius);
+ const endSumOffset = offset - currentChannel +
+ Math.min(currentChannel + depthRadius, maxD);
+ let sum = 0.0;
+ for (; beginSumOffset <= endSumOffset; beginSumOffset++) {
+ const z = xValues[beginSumOffset];
+ sum += z * z;
+ }
+ return sum;
+ }
+ for (let offset = 0; offset < size; offset++) {
+ const sum = sumAcrossChannels(offset);
+ const val = xValues[offset] * Math.pow(bias + alpha * sum, -beta);
+ result[offset] = val;
+ }
+ return dist["tensor4d"](result, x.shape);
+ }
+ LRNGrad(dy, inputImage, outputImage, depthRadius, bias, alpha, beta) {
+ Object(cpu_util["a" /* assertNotComplex */])(dy, 'LRNGrad');
+ const channels = dy.shape[3];
+ const dyValues = this.readSync(dy.dataId);
+ const inputImageValues = this.readSync(inputImage.dataId);
+ const outputImageValues = this.readSync(outputImage.dataId);
+ const result = new Float32Array(dy.size);
+ const size = dy.size;
+ for (let offset = 0; offset < size; offset++) {
+ const currentChannel = offset % channels;
+ const depthBegin = (offset - currentChannel) + Math.max(0, currentChannel - depthRadius);
+ const depthEnd = (offset - currentChannel) +
+ Math.min(channels, currentChannel + depthRadius + 1);
+ let norm = 0;
+ for (let k = depthBegin; k < depthEnd; k++) {
+ norm += Math.pow(inputImageValues[k], 2);
+ }
+ norm = alpha * norm + bias;
+ for (let k = depthBegin; k < depthEnd; k++) {
+ let dyi = -2 * alpha * beta * inputImageValues[k] *
+ outputImageValues[offset] / norm;
+ if (offset === k) {
+ dyi += Math.pow(norm, -beta);
+ }
+ dyi *= dyValues[offset];
+ result[k] += dyi;
+ }
+ }
+ return dist["tensor4d"](result, dy.shape);
+ }
+ multinomial(logits, normalized, numSamples, seed) {
+ Object(cpu_util["a" /* assertNotComplex */])(logits, 'multinomial');
+ const probabilities = normalized ? logits : dist["softmax"](logits);
+ const batchSize = probabilities.shape[0];
+ const numEvents = probabilities.shape[1];
+ const res = dist["zeros"]([batchSize, numSamples], 'int32');
+ const resVals = this.readSync(res.dataId);
+ const probVals = this.readSync(probabilities.dataId);
+ for (let b = 0; b < batchSize; ++b) {
+ const offset = b * numEvents;
+ // The cdf won't include the last event. It will be implicit if no other
+ // event happened.
+ const cdf = new Float32Array(numEvents - 1);
+ cdf[0] = probVals[offset];
+ for (let event = 1; event < cdf.length; ++event) {
+ cdf[event] = cdf[event - 1] + probVals[offset + event];
+ }
+ const random = seedrandom["alea"](seed.toString());
+ const outOffset = b * numSamples;
+ for (let sampleId = 0; sampleId < numSamples; ++sampleId) {
+ const r = random();
+ // Assume last event happened by default.
+ resVals[outOffset + sampleId] = cdf.length;
+ for (let event = 0; event < cdf.length; event++) {
+ if (r < cdf[event]) {
+ resVals[outOffset + sampleId] = event;
+ break;
+ }
+ }
+ }
+ }
+ return res;
+ }
+ oneHot(indices, depth, onValue, offValue) {
+ Object(cpu_util["a" /* assertNotComplex */])(indices, 'oneHot');
+ const res = new Float32Array(indices.size * depth);
+ res.fill(offValue);
+ const indicesVal = this.readSync(indices.dataId);
+ for (let event = 0; event < indices.size; ++event) {
+ if (indicesVal[event] >= 0 && indicesVal[event] < depth) {
+ res[event * depth + indicesVal[event]] = onValue;
+ }
+ }
+ return dist["tensor2d"](res, [indices.size, depth], 'int32');
+ }
+ nonMaxSuppression(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
+ Object(cpu_util["a" /* assertNotComplex */])(boxes, 'nonMaxSuppression');
+ const boxesVals = this.readSync(boxes.dataId);
+ const scoresVals = this.readSync(scores.dataId);
+ return nonMaxSuppressionV3(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
+ }
+ fft(x) {
+ return this.fftBatch(x, false);
+ }
+ ifft(x) {
+ return this.fftBatch(x, true);
+ }
+ /**
+ * Calculate FFT of inner most elements of batch tensor.
+ */
+ fftBatch(x, inverse) {
+ const batch = x.shape[0];
+ const innerDim = x.shape[1];
+ // Collects real and imaginary values separately.
+ const realResult = dist["buffer"](x.shape, 'float32');
+ const imagResult = dist["buffer"](x.shape, 'float32');
+ const real = dist["real"](x).as2D(batch, innerDim);
+ const imag = dist["imag"](x).as2D(batch, innerDim);
+ for (let b = 0; b < batch; b++) {
+ // TODO: Support slice ops for complex type.
+ const r = real.slice([b, 0], [1, innerDim]);
+ const i = imag.slice([b, 0], [1, innerDim]);
+ const input = dist["complex"](r, i);
+ // Run FFT by batch element.
+ const res = this.readSync(this.fftImpl(input, inverse).dataId);
+ for (let d = 0; d < innerDim; d++) {
+ const c = dist["backend_util"].getComplexWithIndex(res, d);
+ realResult.values[b * innerDim + d] = c.real;
+ imagResult.values[b * innerDim + d] = c.imag;
+ }
+ }
+ const t = dist["complex"](realResult.toTensor(), imagResult.toTensor());
+ return t.as2D(batch, innerDim);
+ }
+ fftImpl(x, inverse) {
+ const x1D = x.as1D();
+ const n = x1D.size;
+ if (this.isExponentOf2(n)) {
+ let result = this.fftRadix2(x1D, n, inverse).as2D(x.shape[0], x.shape[1]);
+ if (inverse) {
+ result = dist["complex"](dist["real"](result).div(dist["scalar"](n)), dist["imag"](result).div(dist["scalar"](n)));
+ }
+ return result;
+ }
+ else {
+ const data = this.readSync(x.dataId);
+ const rawOutput = this.fourierTransformByMatmul(data, n, inverse);
+ const output = dist["backend_util"].splitRealAndImagArrays(rawOutput);
+ return dist["complex"](output.real, output.imag).as2D(x.shape[0], x.shape[1]);
+ }
+ }
+ isExponentOf2(size) {
+ return (size & size - 1) === 0;
+ }
+ // FFT using Cooley-Tukey algorithm on radix 2 dimensional input.
+ fftRadix2(input, size, inverse) {
+ if (size === 1) {
+ return input;
+ }
+ const data = this.readSync(input.dataId);
+ const half = size / 2;
+ const evenComplex = dist["backend_util"].complexWithEvenIndex(data);
+ let evenTensor = dist["complex"](evenComplex.real, evenComplex.imag).as1D();
+ const oddComplex = dist["backend_util"].complexWithOddIndex(data);
+ let oddTensor = dist["complex"](oddComplex.real, oddComplex.imag).as1D();
+ // Recursive call for half part of original input.
+ evenTensor = this.fftRadix2(evenTensor, half, inverse);
+ oddTensor = this.fftRadix2(oddTensor, half, inverse);
+ const e = dist["backend_util"].exponents(size, inverse);
+ const exponent = dist["complex"](e.real, e.imag).mul(oddTensor);
+ const addPart = evenTensor.add(exponent);
+ const subPart = evenTensor.sub(exponent);
+ const realTensor = dist["real"](addPart).concat(dist["real"](subPart));
+ const imagTensor = dist["imag"](addPart).concat(dist["imag"](subPart));
+ return dist["complex"](realTensor, imagTensor).as1D();
+ }
+ // Calculate fourier transform by multplying sinusoid matrix.
+ fourierTransformByMatmul(data, size, inverse) {
+ const ret = new Float32Array(size * 2);
+ // TODO: Use matmul instead once it supports complex64 type.
+ for (let r = 0; r < size; r++) {
+ let real = 0.0;
+ let imag = 0.0;
+ for (let c = 0; c < size; c++) {
+ const e = dist["backend_util"].exponent(r * c, size, inverse);
+ const term = dist["backend_util"].getComplexWithIndex(data, c);
+ real += term.real * e.real - term.imag * e.imag;
+ imag += term.real * e.imag + term.imag * e.real;
+ }
+ if (inverse) {
+ real /= size;
+ imag /= size;
+ }
+ dist["backend_util"].assignToTypedArray(ret, real, imag, r);
+ }
+ return ret;
+ }
+ depthToSpace(x, blockSize, dataFormat) {
+ dist["util"].assert(dataFormat === 'NHWC', () => `Only NHWC dataFormat supported on CPU for depthToSpace. Got ${dataFormat}`);
+ dist["util"].assert(blockSize > 1, () => `blockSize should be > 1 for depthToSpace, but was: ${blockSize}`);
+ const batchSize = x.shape[0];
+ const inputHeight = x.shape[1];
+ const inputWidth = x.shape[2];
+ const inputDepth = x.shape[3];
+ const outputHeight = inputHeight * blockSize;
+ const outputWidth = inputWidth * blockSize;
+ const outputDepth = inputDepth / (blockSize * blockSize);
+ const xValues = this.readSync(x.dataId);
+ const result = new Float32Array(batchSize * outputHeight * outputWidth * outputDepth);
+ let outputIdx = 0;
+ for (let b = 0; b < batchSize; ++b) {
+ for (let h = 0; h < outputHeight; ++h) {
+ const inH = Math.floor(h / blockSize);
+ const offsetH = (h % blockSize);
+ for (let w = 0; w < outputWidth; ++w) {
+ const inW = Math.floor(w / blockSize);
+ const offsetW = (w % blockSize);
+ const offsetD = (offsetH * blockSize + offsetW) * outputDepth;
+ for (let d = 0; d < outputDepth; ++d) {
+ const inD = d + offsetD;
+ const inputIdx = inD + inputDepth * (inW + inputWidth * (inH + inputHeight * b));
+ result[outputIdx++] = xValues[inputIdx];
+ }
+ }
+ }
+ }
+ return dist["tensor4d"](result, [batchSize, outputHeight, outputWidth, outputDepth]);
+ }
+ broadcastedBinaryOp(a, b, dtype, op) {
+ const newShape = dist["backend_util"].assertAndGetBroadcastShape(a.shape, b.shape);
+ const result = dist["buffer"](newShape, dtype);
+ const aVals = this.readSync(a.dataId);
+ const bVals = this.readSync(b.dataId);
+ const aBroadcastDims = dist["backend_util"].getBroadcastDims(a.shape, newShape);
+ const bBroadcastDims = dist["backend_util"].getBroadcastDims(b.shape, newShape);
+ const resVals = result.values;
+ if (aBroadcastDims.length + bBroadcastDims.length === 0) {
+ for (let i = 0; i < resVals.length; ++i) {
+ resVals[i] = op(aVals[i % aVals.length], bVals[i % bVals.length]);
+ }
+ }
+ else {
+ const aBuf = this.bufferSync(a);
+ const bBuf = this.bufferSync(b);
+ for (let i = 0; i < resVals.length; ++i) {
+ const loc = result.indexToLoc(i);
+ const aLoc = loc.slice(-a.rank);
+ aBroadcastDims.forEach(d => aLoc[d] = 0);
+ const aIndex = aBuf.locToIndex(aLoc);
+ const bLoc = loc.slice(-b.rank);
+ bBroadcastDims.forEach(d => bLoc[d] = 0);
+ const bIndex = bBuf.locToIndex(bLoc);
+ resVals[i] = op(aVals[aIndex], bVals[bIndex]);
+ }
+ }
+ return result.toTensor();
+ }
+ broadcastedBinaryComplexOp(a, b, op) {
+ const newShape = dist["backend_util"].assertAndGetBroadcastShape(a.shape, b.shape);
+ const realResult = dist["buffer"](newShape, 'float32');
+ const imagResult = dist["buffer"](newShape, 'float32');
+ const aVals = this.readSync(a.dataId);
+ const bVals = this.readSync(b.dataId);
+ const aBroadcastDims = dist["backend_util"].getBroadcastDims(a.shape, newShape);
+ const bBroadcastDims = dist["backend_util"].getBroadcastDims(b.shape, newShape);
+ const realVals = realResult.values;
+ const imagVals = imagResult.values;
+ if (aBroadcastDims.length + bBroadcastDims.length === 0) {
+ for (let i = 0; i < realVals.length; i++) {
+ const aIdx = i % aVals.length;
+ const bIdx = i % bVals.length;
+ const result = op(aVals[aIdx * 2], aVals[aIdx * 2 + 1], bVals[bIdx * 2], bVals[bIdx * 2 + 1]);
+ realVals[i] = result.real;
+ imagVals[i] = result.imag;
+ }
+ }
+ else {
+ const aRealBuf = this.bufferSync(this.data.get(a.dataId).complexTensors.real);
+ const bRealBuf = this.bufferSync(this.data.get(b.dataId).complexTensors.real);
+ for (let i = 0; i < realVals.length; i++) {
+ const loc = realResult.indexToLoc(i);
+ const aLoc = loc.slice(-a.rank);
+ aBroadcastDims.forEach(d => aLoc[d] = 0);
+ const aIndex = aRealBuf.locToIndex(aLoc);
+ const bLoc = loc.slice(-b.rank);
+ bBroadcastDims.forEach(d => bLoc[d] = 0);
+ const bIndex = bRealBuf.locToIndex(bLoc);
+ const opResult = op(aVals[aIndex * 2], aVals[aIndex * 2 + 1], bVals[bIndex * 2], bVals[bIndex * 2 + 1]);
+ realVals[i] = opResult.real;
+ imagVals[i] = opResult.imag;
+ }
+ }
+ return this.complex(realResult.toTensor(), imagResult.toTensor());
+ }
+ split(x, sizeSplits, axis) {
+ return split(x, sizeSplits, axis);
+ }
+ dispose() { }
+ floatPrecision() {
+ return 32;
+ }
+ /** Returns the smallest representable number. */
+ epsilon() {
+ return super.epsilon();
+ }
+ cropAndResize(images, boxes, boxIndex, cropSize, method, extrapolationValue) {
+ const [batch, imageHeight, imageWidth, numChannels] = images.shape;
+ const numBoxes = boxes.shape[0];
+ const [cropHeight, cropWidth] = cropSize;
+ const output = dist["buffer"]([numBoxes, cropHeight, cropWidth, numChannels], 'float32');
+ const boxVals = this.readSync(boxes.dataId);
+ const boxIndVals = this.readSync(boxIndex.dataId);
+ const imageVals = this.readSync(images.dataId);
+ const inStride = images.strides; // to calculate flat indexes into image
+ const outStride = output.strides; // to calculate flat indexes into output
+ // Reference implementation
+ // tslint:disable-next-line:max-line-length
+ // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/crop_and_resize_op.cc
+ for (let b = 0; b < numBoxes; b++) {
+ const startInd = b * 4;
+ const y1 = boxVals[startInd];
+ const x1 = boxVals[startInd + 1];
+ const y2 = boxVals[startInd + 2];
+ const x2 = boxVals[startInd + 3];
+ const bInd = boxIndVals[b];
+ if (bInd >= batch) {
+ continue;
+ }
+ const heightScale = (cropHeight > 1) ?
+ (y2 - y1) * (imageHeight - 1) / (cropHeight - 1) :
+ 0;
+ const widthScale = (cropWidth > 1) ? (x2 - x1) * (imageWidth - 1) / (cropWidth - 1) : 0;
+ for (let y = 0; y < cropHeight; y++) {
+ const yInd = (cropHeight > 1) ?
+ y1 * (imageHeight - 1) + y * (heightScale) :
+ 0.5 * (y1 + y2) * (imageHeight - 1);
+ if (yInd < 0 || yInd > imageHeight - 1) {
+ for (let x = 0; x < cropWidth; x++) {
+ for (let c = 0; c < numChannels; c++) {
+ const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+ output.values[ind] = extrapolationValue;
+ }
+ }
+ continue;
+ }
+ if (method === 'bilinear') {
+ const topInd = Math.floor(yInd);
+ const bottomInd = Math.ceil(yInd);
+ const yLerp = yInd - topInd;
+ for (let x = 0; x < cropWidth; x++) {
+ const xInd = (cropWidth > 1) ?
+ x1 * (imageWidth - 1) + x * widthScale :
+ 0.5 * (x1 + x2) * (imageWidth - 1);
+ if (xInd < 0 || xInd > imageWidth - 1) {
+ for (let c = 0; c < numChannels; c++) {
+ const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+ output.values[ind] = extrapolationValue;
+ }
+ continue;
+ }
+ const leftInd = Math.floor(xInd);
+ const rightInd = Math.ceil(xInd);
+ const xLerp = xInd - leftInd;
+ for (let c = 0; c < numChannels; c++) {
+ let ind = c + leftInd * inStride[2] + topInd * inStride[1] +
+ bInd * inStride[0];
+ const topLeft = imageVals[ind];
+ ind = c + rightInd * inStride[2] + topInd * inStride[1] +
+ bInd * inStride[0];
+ const topRight = imageVals[ind];
+ ind = c + leftInd * inStride[2] + bottomInd * inStride[1] +
+ bInd * inStride[0];
+ const bottomLeft = imageVals[ind];
+ ind = c + rightInd * inStride[2] + bottomInd * inStride[1] +
+ bInd * inStride[0];
+ const bottomRight = imageVals[ind];
+ const top = topLeft + (topRight - topLeft) * xLerp;
+ const bottom = bottomLeft + (bottomRight - bottomLeft) * xLerp;
+ ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+ output.values[ind] = top + ((bottom - top) * yLerp);
+ }
+ }
+ }
+ else { // method == "nearest"
+ for (let x = 0; x < cropWidth; ++x) {
+ const xInd = (cropWidth > 1) ?
+ x1 * (imageWidth - 1) + x * widthScale :
+ 0.5 * (x1 + x2) * (imageWidth - 1);
+ if (xInd < 0 || xInd > imageWidth - 1) {
+ for (let c = 0; c < numChannels; c++) {
+ const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+ output.values[ind] = extrapolationValue;
+ }
+ continue;
+ }
+ const closestX = Math.round(xInd);
+ const closestY = Math.round(yInd);
+ for (let c = 0; c < numChannels; c++) {
+ const inInd = c + closestX * inStride[2] +
+ closestY * inStride[1] + bInd * inStride[0];
+ const outInd = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+ output.values[outInd] = imageVals[inInd];
+ }
+ }
+ }
+ }
+ }
+ return output.toTensor();
+ }
+ sparseToDense(sparseIndices, sparseValues, outputShape, defaultValue) {
+ const { sliceRank, numUpdates, sliceSize, strides, outputSize } = dist["backend_util"].calculateShapes(sparseValues, sparseIndices, outputShape);
+ const sumDupeIndices = false;
+ return this.scatter(sparseIndices, sparseValues, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, defaultValue, sumDupeIndices);
+ }
+ gatherND(x, indices) {
+ const indicesShape = indices.shape;
+ const sliceRank = indicesShape[indicesShape.length - 1];
+ const [resultShape, numSlices, sliceSize, strides] = dist["backend_util"].prepareAndValidate(x, indices);
+ if (numSlices === 0) {
+ return dist["tensor"]([], resultShape, x.dtype);
+ }
+ const buffer = new dist["TensorBuffer"]([numSlices, sliceSize], x.dtype);
+ const indicesData = this.readSync(indices.dataId);
+ const xData = this.readSync(x.dataId);
+ for (let i = 0; i < numSlices; i++) {
+ const index = [];
+ let flattenIndex = 0;
+ for (let j = 0; j < sliceRank; j++) {
+ const dim = indicesData[i * sliceRank + j];
+ flattenIndex += dim * strides[j];
+ index.push(dim);
+ }
+ if (flattenIndex < 0 || flattenIndex >= x.size / sliceSize) {
+ throw new Error(`Invalid indices: ${index} does not index into ${x.shape}`);
+ }
+ for (let k = 0; k < sliceSize; k++) {
+ buffer.values[i * sliceSize + k] = xData[flattenIndex * sliceSize + k];
+ }
+ }
+ return buffer.toTensor().reshape(resultShape);
+ }
+ scatterND(indices, updates, shape) {
+ const { sliceRank, numUpdates, sliceSize, strides, outputSize } = dist["backend_util"].calculateShapes(updates, indices, shape);
+ const defaultValue = dist["scalar"](0);
+ const sumDupeIndices = true;
+ return this.scatter(indices, updates, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, defaultValue, sumDupeIndices);
+ }
+ fill(shape, value, dtype) {
+ dtype = dtype || dist["util"].inferDtype(value);
+ const values = dist["util"].getArrayFromDType(dtype, dist["util"].sizeFromShape(shape));
+ values.fill(value);
+ return Object(dist["engine"])().makeTensor(values, shape, dtype, this);
+ }
+ onesLike(x) {
+ if (x.dtype === 'string') {
+ throw new Error('onesLike is not supported for string tensors');
+ }
+ else {
+ return this.fill(x.shape, 1, x.dtype);
+ }
+ }
+ zerosLike(x) {
+ const values = dist["util"].getArrayFromDType(x.dtype, dist["util"].sizeFromShape(x.shape));
+ return this.makeOutput(values, x.shape, x.dtype);
+ }
+ linspace(start, stop, num) {
+ return dist["backend_util"].linspaceImpl(start, stop, num);
+ }
+ scatter(indices, updates, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, defaultValue, sumDupeIndices) {
+ const flattenShape = [outputSize / sliceSize, sliceSize];
+ const indicesData = this.readSync(indices.dataId);
+ const updatesData = this.readSync(updates.dataId);
+ if (outputSize === 0) {
+ return dist["tensor"]([], shape, updates.dtype);
+ }
+ const buffer = new dist["TensorBuffer"](flattenShape, updates.dtype);
+ buffer.values.fill(this.readSync(defaultValue.dataId)[0]);
+ for (let i = 0; i < numUpdates; i++) {
+ const index = [];
+ let flattenIndex = 0;
+ for (let j = 0; j < sliceRank; j++) {
+ const dim = indicesData[i * sliceRank + j];
+ index.push(dim);
+ flattenIndex += dim * strides[j];
+ }
+ if (flattenIndex < 0 || flattenIndex >= outputSize / sliceSize) {
+ throw new Error(`Invalid indices: ${index} does not index into ${shape}`);
+ }
+ for (let k = 0; k < sliceSize; k++) {
+ if (sumDupeIndices) {
+ buffer.values[flattenIndex * sliceSize + k] +=
+ updatesData[i * sliceSize + k];
+ }
+ else {
+ buffer.values[flattenIndex * sliceSize + k] = updates.rank === 0 ?
+ updatesData[0] :
+ updatesData[i * sliceSize + k];
+ }
+ }
+ }
+ return buffer.toTensor().reshape(shape);
+ }
+}
+//# sourceMappingURL=backend_cpu.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/version.js
+/** @license See the LICENSE file. */
+// This code is auto-generated, do not modify this file!
+const version = '2.0.1';
+
+//# sourceMappingURL=version.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-backend-cpu/dist/base.js
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/*
+ * base.ts contains all the exports from tfjs-backend-cpu
+ * that do not trigger side effects.
+ */
+
+
+
+
+//# sourceMappingURL=base.js.map
+
+/***/ }),
+/* 32 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global) {var require;var require;/*!
+ localForage -- Offline Storage, Improved
+ Version 1.7.3
+ https://localforage.github.io/localForage
+ (c) 2013-2017 Mozilla, Apache License 2.0
+*/
+(function(f){if(true){module.exports=f()}else { var g; }})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return require(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw (f.code="MODULE_NOT_FOUND", f)}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o element; its readystatechange event will be fired asynchronously once it is inserted
+ // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+ var scriptEl = global.document.createElement('script');
+ scriptEl.onreadystatechange = function () {
+ nextTick();
+
+ scriptEl.onreadystatechange = null;
+ scriptEl.parentNode.removeChild(scriptEl);
+ scriptEl = null;
+ };
+ global.document.documentElement.appendChild(scriptEl);
+ };
+ } else {
+ scheduleDrain = function () {
+ setTimeout(nextTick, 0);
+ };
+ }
+}
+
+var draining;
+var queue = [];
+//named nextTick for less confusing stack traces
+function nextTick() {
+ draining = true;
+ var i, oldQueue;
+ var len = queue.length;
+ while (len) {
+ oldQueue = queue;
+ queue = [];
+ i = -1;
+ while (++i < len) {
+ oldQueue[i]();
+ }
+ len = queue.length;
+ }
+ draining = false;
+}
+
+module.exports = immediate;
+function immediate(task) {
+ if (queue.push(task) === 1 && !draining) {
+ scheduleDrain();
+ }
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],2:[function(_dereq_,module,exports){
+'use strict';
+var immediate = _dereq_(1);
+
+/* istanbul ignore next */
+function INTERNAL() {}
+
+var handlers = {};
+
+var REJECTED = ['REJECTED'];
+var FULFILLED = ['FULFILLED'];
+var PENDING = ['PENDING'];
+
+module.exports = Promise;
+
+function Promise(resolver) {
+ if (typeof resolver !== 'function') {
+ throw new TypeError('resolver must be a function');
+ }
+ this.state = PENDING;
+ this.queue = [];
+ this.outcome = void 0;
+ if (resolver !== INTERNAL) {
+ safelyResolveThenable(this, resolver);
+ }
+}
+
+Promise.prototype["catch"] = function (onRejected) {
+ return this.then(null, onRejected);
+};
+Promise.prototype.then = function (onFulfilled, onRejected) {
+ if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
+ typeof onRejected !== 'function' && this.state === REJECTED) {
+ return this;
+ }
+ var promise = new this.constructor(INTERNAL);
+ if (this.state !== PENDING) {
+ var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
+ unwrap(promise, resolver, this.outcome);
+ } else {
+ this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+ }
+
+ return promise;
+};
+function QueueItem(promise, onFulfilled, onRejected) {
+ this.promise = promise;
+ if (typeof onFulfilled === 'function') {
+ this.onFulfilled = onFulfilled;
+ this.callFulfilled = this.otherCallFulfilled;
+ }
+ if (typeof onRejected === 'function') {
+ this.onRejected = onRejected;
+ this.callRejected = this.otherCallRejected;
+ }
+}
+QueueItem.prototype.callFulfilled = function (value) {
+ handlers.resolve(this.promise, value);
+};
+QueueItem.prototype.otherCallFulfilled = function (value) {
+ unwrap(this.promise, this.onFulfilled, value);
+};
+QueueItem.prototype.callRejected = function (value) {
+ handlers.reject(this.promise, value);
+};
+QueueItem.prototype.otherCallRejected = function (value) {
+ unwrap(this.promise, this.onRejected, value);
+};
+
+function unwrap(promise, func, value) {
+ immediate(function () {
+ var returnValue;
+ try {
+ returnValue = func(value);
+ } catch (e) {
+ return handlers.reject(promise, e);
+ }
+ if (returnValue === promise) {
+ handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+ } else {
+ handlers.resolve(promise, returnValue);
+ }
+ });
+}
+
+handlers.resolve = function (self, value) {
+ var result = tryCatch(getThen, value);
+ if (result.status === 'error') {
+ return handlers.reject(self, result.value);
+ }
+ var thenable = result.value;
+
+ if (thenable) {
+ safelyResolveThenable(self, thenable);
+ } else {
+ self.state = FULFILLED;
+ self.outcome = value;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callFulfilled(value);
+ }
+ }
+ return self;
+};
+handlers.reject = function (self, error) {
+ self.state = REJECTED;
+ self.outcome = error;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callRejected(error);
+ }
+ return self;
+};
+
+function getThen(obj) {
+ // Make sure we only access the accessor once as required by the spec
+ var then = obj && obj.then;
+ if (obj && (typeof obj === 'object' || typeof obj === 'function') && typeof then === 'function') {
+ return function appyThen() {
+ then.apply(obj, arguments);
+ };
+ }
+}
+
+function safelyResolveThenable(self, thenable) {
+ // Either fulfill, reject or reject with error
+ var called = false;
+ function onError(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.reject(self, value);
+ }
+
+ function onSuccess(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.resolve(self, value);
+ }
+
+ function tryToUnwrap() {
+ thenable(onSuccess, onError);
+ }
+
+ var result = tryCatch(tryToUnwrap);
+ if (result.status === 'error') {
+ onError(result.value);
+ }
+}
+
+function tryCatch(func, value) {
+ var out = {};
+ try {
+ out.value = func(value);
+ out.status = 'success';
+ } catch (e) {
+ out.status = 'error';
+ out.value = e;
+ }
+ return out;
+}
+
+Promise.resolve = resolve;
+function resolve(value) {
+ if (value instanceof this) {
+ return value;
+ }
+ return handlers.resolve(new this(INTERNAL), value);
+}
+
+Promise.reject = reject;
+function reject(reason) {
+ var promise = new this(INTERNAL);
+ return handlers.reject(promise, reason);
+}
+
+Promise.all = all;
+function all(iterable) {
+ var self = this;
+ if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+ return this.reject(new TypeError('must be an array'));
+ }
+
+ var len = iterable.length;
+ var called = false;
+ if (!len) {
+ return this.resolve([]);
+ }
+
+ var values = new Array(len);
+ var resolved = 0;
+ var i = -1;
+ var promise = new this(INTERNAL);
+
+ while (++i < len) {
+ allResolver(iterable[i], i);
+ }
+ return promise;
+ function allResolver(value, i) {
+ self.resolve(value).then(resolveFromAll, function (error) {
+ if (!called) {
+ called = true;
+ handlers.reject(promise, error);
+ }
+ });
+ function resolveFromAll(outValue) {
+ values[i] = outValue;
+ if (++resolved === len && !called) {
+ called = true;
+ handlers.resolve(promise, values);
+ }
+ }
+ }
+}
+
+Promise.race = race;
+function race(iterable) {
+ var self = this;
+ if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+ return this.reject(new TypeError('must be an array'));
+ }
+
+ var len = iterable.length;
+ var called = false;
+ if (!len) {
+ return this.resolve([]);
+ }
+
+ var i = -1;
+ var promise = new this(INTERNAL);
+
+ while (++i < len) {
+ resolver(iterable[i]);
+ }
+ return promise;
+ function resolver(value) {
+ self.resolve(value).then(function (response) {
+ if (!called) {
+ called = true;
+ handlers.resolve(promise, response);
+ }
+ }, function (error) {
+ if (!called) {
+ called = true;
+ handlers.reject(promise, error);
+ }
+ });
+ }
+}
+
+},{"1":1}],3:[function(_dereq_,module,exports){
+(function (global){
+'use strict';
+if (typeof global.Promise !== 'function') {
+ global.Promise = _dereq_(2);
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"2":2}],4:[function(_dereq_,module,exports){
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function getIDB() {
+ /* global indexedDB,webkitIndexedDB,mozIndexedDB,OIndexedDB,msIndexedDB */
+ try {
+ if (typeof indexedDB !== 'undefined') {
+ return indexedDB;
+ }
+ if (typeof webkitIndexedDB !== 'undefined') {
+ return webkitIndexedDB;
+ }
+ if (typeof mozIndexedDB !== 'undefined') {
+ return mozIndexedDB;
+ }
+ if (typeof OIndexedDB !== 'undefined') {
+ return OIndexedDB;
+ }
+ if (typeof msIndexedDB !== 'undefined') {
+ return msIndexedDB;
+ }
+ } catch (e) {
+ return;
+ }
+}
+
+var idb = getIDB();
+
+function isIndexedDBValid() {
+ try {
+ // Initialize IndexedDB; fall back to vendor-prefixed versions
+ // if needed.
+ if (!idb) {
+ return false;
+ }
+ // We mimic PouchDB here;
+ //
+ // We test for openDatabase because IE Mobile identifies itself
+ // as Safari. Oh the lulz...
+ var isSafari = typeof openDatabase !== 'undefined' && /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent) && !/BlackBerry/.test(navigator.platform);
+
+ var hasFetch = typeof fetch === 'function' && fetch.toString().indexOf('[native code') !== -1;
+
+ // Safari <10.1 does not meet our requirements for IDB support (#5572)
+ // since Safari 10.1 shipped with fetch, we can use that to detect it
+ return (!isSafari || hasFetch) && typeof indexedDB !== 'undefined' &&
+ // some outdated implementations of IDB that appear on Samsung
+ // and HTC Android devices <4.4 are missing IDBKeyRange
+ // See: https://github.com/mozilla/localForage/issues/128
+ // See: https://github.com/mozilla/localForage/issues/272
+ typeof IDBKeyRange !== 'undefined';
+ } catch (e) {
+ return false;
+ }
+}
+
+// Abstracts constructing a Blob object, so it also works in older
+// browsers that don't support the native Blob constructor. (i.e.
+// old QtWebKit versions, at least).
+// Abstracts constructing a Blob object, so it also works in older
+// browsers that don't support the native Blob constructor. (i.e.
+// old QtWebKit versions, at least).
+function createBlob(parts, properties) {
+ /* global BlobBuilder,MSBlobBuilder,MozBlobBuilder,WebKitBlobBuilder */
+ parts = parts || [];
+ properties = properties || {};
+ try {
+ return new Blob(parts, properties);
+ } catch (e) {
+ if (e.name !== 'TypeError') {
+ throw e;
+ }
+ var Builder = typeof BlobBuilder !== 'undefined' ? BlobBuilder : typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder : typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder : WebKitBlobBuilder;
+ var builder = new Builder();
+ for (var i = 0; i < parts.length; i += 1) {
+ builder.append(parts[i]);
+ }
+ return builder.getBlob(properties.type);
+ }
+}
+
+// This is CommonJS because lie is an external dependency, so Rollup
+// can just ignore it.
+if (typeof Promise === 'undefined') {
+ // In the "nopromises" build this will just throw if you don't have
+ // a global promise object, but it would throw anyway later.
+ _dereq_(3);
+}
+var Promise$1 = Promise;
+
+function executeCallback(promise, callback) {
+ if (callback) {
+ promise.then(function (result) {
+ callback(null, result);
+ }, function (error) {
+ callback(error);
+ });
+ }
+}
+
+function executeTwoCallbacks(promise, callback, errorCallback) {
+ if (typeof callback === 'function') {
+ promise.then(callback);
+ }
+
+ if (typeof errorCallback === 'function') {
+ promise["catch"](errorCallback);
+ }
+}
+
+function normalizeKey(key) {
+ // Cast the key to a string, as that's all we can set as a key.
+ if (typeof key !== 'string') {
+ console.warn(key + ' used as a key, but it is not a string.');
+ key = String(key);
+ }
+
+ return key;
+}
+
+function getCallback() {
+ if (arguments.length && typeof arguments[arguments.length - 1] === 'function') {
+ return arguments[arguments.length - 1];
+ }
+}
+
+// Some code originally from async_storage.js in
+// [Gaia](https://github.com/mozilla-b2g/gaia).
+
+var DETECT_BLOB_SUPPORT_STORE = 'local-forage-detect-blob-support';
+var supportsBlobs = void 0;
+var dbContexts = {};
+var toString = Object.prototype.toString;
+
+// Transaction Modes
+var READ_ONLY = 'readonly';
+var READ_WRITE = 'readwrite';
+
+// Transform a binary string to an array buffer, because otherwise
+// weird stuff happens when you try to work with the binary string directly.
+// It is known.
+// From http://stackoverflow.com/questions/14967647/ (continues on next line)
+// encode-decode-image-with-base64-breaks-image (2013-04-21)
+function _binStringToArrayBuffer(bin) {
+ var length = bin.length;
+ var buf = new ArrayBuffer(length);
+ var arr = new Uint8Array(buf);
+ for (var i = 0; i < length; i++) {
+ arr[i] = bin.charCodeAt(i);
+ }
+ return buf;
+}
+
+//
+// Blobs are not supported in all versions of IndexedDB, notably
+// Chrome <37 and Android <5. In those versions, storing a blob will throw.
+//
+// Various other blob bugs exist in Chrome v37-42 (inclusive).
+// Detecting them is expensive and confusing to users, and Chrome 37-42
+// is at very low usage worldwide, so we do a hacky userAgent check instead.
+//
+// content-type bug: https://code.google.com/p/chromium/issues/detail?id=408120
+// 404 bug: https://code.google.com/p/chromium/issues/detail?id=447916
+// FileReader bug: https://code.google.com/p/chromium/issues/detail?id=447836
+//
+// Code borrowed from PouchDB. See:
+// https://github.com/pouchdb/pouchdb/blob/master/packages/node_modules/pouchdb-adapter-idb/src/blobSupport.js
+//
+function _checkBlobSupportWithoutCaching(idb) {
+ return new Promise$1(function (resolve) {
+ var txn = idb.transaction(DETECT_BLOB_SUPPORT_STORE, READ_WRITE);
+ var blob = createBlob(['']);
+ txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, 'key');
+
+ txn.onabort = function (e) {
+ // If the transaction aborts now its due to not being able to
+ // write to the database, likely due to the disk being full
+ e.preventDefault();
+ e.stopPropagation();
+ resolve(false);
+ };
+
+ txn.oncomplete = function () {
+ var matchedChrome = navigator.userAgent.match(/Chrome\/(\d+)/);
+ var matchedEdge = navigator.userAgent.match(/Edge\//);
+ // MS Edge pretends to be Chrome 42:
+ // https://msdn.microsoft.com/en-us/library/hh869301%28v=vs.85%29.aspx
+ resolve(matchedEdge || !matchedChrome || parseInt(matchedChrome[1], 10) >= 43);
+ };
+ })["catch"](function () {
+ return false; // error, so assume unsupported
+ });
+}
+
+function _checkBlobSupport(idb) {
+ if (typeof supportsBlobs === 'boolean') {
+ return Promise$1.resolve(supportsBlobs);
+ }
+ return _checkBlobSupportWithoutCaching(idb).then(function (value) {
+ supportsBlobs = value;
+ return supportsBlobs;
+ });
+}
+
+function _deferReadiness(dbInfo) {
+ var dbContext = dbContexts[dbInfo.name];
+
+ // Create a deferred object representing the current database operation.
+ var deferredOperation = {};
+
+ deferredOperation.promise = new Promise$1(function (resolve, reject) {
+ deferredOperation.resolve = resolve;
+ deferredOperation.reject = reject;
+ });
+
+ // Enqueue the deferred operation.
+ dbContext.deferredOperations.push(deferredOperation);
+
+ // Chain its promise to the database readiness.
+ if (!dbContext.dbReady) {
+ dbContext.dbReady = deferredOperation.promise;
+ } else {
+ dbContext.dbReady = dbContext.dbReady.then(function () {
+ return deferredOperation.promise;
+ });
+ }
+}
+
+function _advanceReadiness(dbInfo) {
+ var dbContext = dbContexts[dbInfo.name];
+
+ // Dequeue a deferred operation.
+ var deferredOperation = dbContext.deferredOperations.pop();
+
+ // Resolve its promise (which is part of the database readiness
+ // chain of promises).
+ if (deferredOperation) {
+ deferredOperation.resolve();
+ return deferredOperation.promise;
+ }
+}
+
+function _rejectReadiness(dbInfo, err) {
+ var dbContext = dbContexts[dbInfo.name];
+
+ // Dequeue a deferred operation.
+ var deferredOperation = dbContext.deferredOperations.pop();
+
+ // Reject its promise (which is part of the database readiness
+ // chain of promises).
+ if (deferredOperation) {
+ deferredOperation.reject(err);
+ return deferredOperation.promise;
+ }
+}
+
+function _getConnection(dbInfo, upgradeNeeded) {
+ return new Promise$1(function (resolve, reject) {
+ dbContexts[dbInfo.name] = dbContexts[dbInfo.name] || createDbContext();
+
+ if (dbInfo.db) {
+ if (upgradeNeeded) {
+ _deferReadiness(dbInfo);
+ dbInfo.db.close();
+ } else {
+ return resolve(dbInfo.db);
+ }
+ }
+
+ var dbArgs = [dbInfo.name];
+
+ if (upgradeNeeded) {
+ dbArgs.push(dbInfo.version);
+ }
+
+ var openreq = idb.open.apply(idb, dbArgs);
+
+ if (upgradeNeeded) {
+ openreq.onupgradeneeded = function (e) {
+ var db = openreq.result;
+ try {
+ db.createObjectStore(dbInfo.storeName);
+ if (e.oldVersion <= 1) {
+ // Added when support for blob shims was added
+ db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);
+ }
+ } catch (ex) {
+ if (ex.name === 'ConstraintError') {
+ console.warn('The database "' + dbInfo.name + '"' + ' has been upgraded from version ' + e.oldVersion + ' to version ' + e.newVersion + ', but the storage "' + dbInfo.storeName + '" already exists.');
+ } else {
+ throw ex;
+ }
+ }
+ };
+ }
+
+ openreq.onerror = function (e) {
+ e.preventDefault();
+ reject(openreq.error);
+ };
+
+ openreq.onsuccess = function () {
+ resolve(openreq.result);
+ _advanceReadiness(dbInfo);
+ };
+ });
+}
+
+function _getOriginalConnection(dbInfo) {
+ return _getConnection(dbInfo, false);
+}
+
+function _getUpgradedConnection(dbInfo) {
+ return _getConnection(dbInfo, true);
+}
+
+function _isUpgradeNeeded(dbInfo, defaultVersion) {
+ if (!dbInfo.db) {
+ return true;
+ }
+
+ var isNewStore = !dbInfo.db.objectStoreNames.contains(dbInfo.storeName);
+ var isDowngrade = dbInfo.version < dbInfo.db.version;
+ var isUpgrade = dbInfo.version > dbInfo.db.version;
+
+ if (isDowngrade) {
+ // If the version is not the default one
+ // then warn for impossible downgrade.
+ if (dbInfo.version !== defaultVersion) {
+ console.warn('The database "' + dbInfo.name + '"' + " can't be downgraded from version " + dbInfo.db.version + ' to version ' + dbInfo.version + '.');
+ }
+ // Align the versions to prevent errors.
+ dbInfo.version = dbInfo.db.version;
+ }
+
+ if (isUpgrade || isNewStore) {
+ // If the store is new then increment the version (if needed).
+ // This will trigger an "upgradeneeded" event which is required
+ // for creating a store.
+ if (isNewStore) {
+ var incVersion = dbInfo.db.version + 1;
+ if (incVersion > dbInfo.version) {
+ dbInfo.version = incVersion;
+ }
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+// encode a blob for indexeddb engines that don't support blobs
+function _encodeBlob(blob) {
+ return new Promise$1(function (resolve, reject) {
+ var reader = new FileReader();
+ reader.onerror = reject;
+ reader.onloadend = function (e) {
+ var base64 = btoa(e.target.result || '');
+ resolve({
+ __local_forage_encoded_blob: true,
+ data: base64,
+ type: blob.type
+ });
+ };
+ reader.readAsBinaryString(blob);
+ });
+}
+
+// decode an encoded blob
+function _decodeBlob(encodedBlob) {
+ var arrayBuff = _binStringToArrayBuffer(atob(encodedBlob.data));
+ return createBlob([arrayBuff], { type: encodedBlob.type });
+}
+
+// is this one of our fancy encoded blobs?
+function _isEncodedBlob(value) {
+ return value && value.__local_forage_encoded_blob;
+}
+
+// Specialize the default `ready()` function by making it dependent
+// on the current database operations. Thus, the driver will be actually
+// ready when it's been initialized (default) *and* there are no pending
+// operations on the database (initiated by some other instances).
+function _fullyReady(callback) {
+ var self = this;
+
+ var promise = self._initReady().then(function () {
+ var dbContext = dbContexts[self._dbInfo.name];
+
+ if (dbContext && dbContext.dbReady) {
+ return dbContext.dbReady;
+ }
+ });
+
+ executeTwoCallbacks(promise, callback, callback);
+ return promise;
+}
+
+// Try to establish a new db connection to replace the
+// current one which is broken (i.e. experiencing
+// InvalidStateError while creating a transaction).
+function _tryReconnect(dbInfo) {
+ _deferReadiness(dbInfo);
+
+ var dbContext = dbContexts[dbInfo.name];
+ var forages = dbContext.forages;
+
+ for (var i = 0; i < forages.length; i++) {
+ var forage = forages[i];
+ if (forage._dbInfo.db) {
+ forage._dbInfo.db.close();
+ forage._dbInfo.db = null;
+ }
+ }
+ dbInfo.db = null;
+
+ return _getOriginalConnection(dbInfo).then(function (db) {
+ dbInfo.db = db;
+ if (_isUpgradeNeeded(dbInfo)) {
+ // Reopen the database for upgrading.
+ return _getUpgradedConnection(dbInfo);
+ }
+ return db;
+ }).then(function (db) {
+ // store the latest db reference
+ // in case the db was upgraded
+ dbInfo.db = dbContext.db = db;
+ for (var i = 0; i < forages.length; i++) {
+ forages[i]._dbInfo.db = db;
+ }
+ })["catch"](function (err) {
+ _rejectReadiness(dbInfo, err);
+ throw err;
+ });
+}
+
+// FF doesn't like Promises (micro-tasks) and IDDB store operations,
+// so we have to do it with callbacks
+function createTransaction(dbInfo, mode, callback, retries) {
+ if (retries === undefined) {
+ retries = 1;
+ }
+
+ try {
+ var tx = dbInfo.db.transaction(dbInfo.storeName, mode);
+ callback(null, tx);
+ } catch (err) {
+ if (retries > 0 && (!dbInfo.db || err.name === 'InvalidStateError' || err.name === 'NotFoundError')) {
+ return Promise$1.resolve().then(function () {
+ if (!dbInfo.db || err.name === 'NotFoundError' && !dbInfo.db.objectStoreNames.contains(dbInfo.storeName) && dbInfo.version <= dbInfo.db.version) {
+ // increase the db version, to create the new ObjectStore
+ if (dbInfo.db) {
+ dbInfo.version = dbInfo.db.version + 1;
+ }
+ // Reopen the database for upgrading.
+ return _getUpgradedConnection(dbInfo);
+ }
+ }).then(function () {
+ return _tryReconnect(dbInfo).then(function () {
+ createTransaction(dbInfo, mode, callback, retries - 1);
+ });
+ })["catch"](callback);
+ }
+
+ callback(err);
+ }
+}
+
+function createDbContext() {
+ return {
+ // Running localForages sharing a database.
+ forages: [],
+ // Shared database.
+ db: null,
+ // Database readiness (promise).
+ dbReady: null,
+ // Deferred operations on the database.
+ deferredOperations: []
+ };
+}
+
+// Open the IndexedDB database (automatically creates one if one didn't
+// previously exist), using any options set in the config.
+function _initStorage(options) {
+ var self = this;
+ var dbInfo = {
+ db: null
+ };
+
+ if (options) {
+ for (var i in options) {
+ dbInfo[i] = options[i];
+ }
+ }
+
+ // Get the current context of the database;
+ var dbContext = dbContexts[dbInfo.name];
+
+ // ...or create a new context.
+ if (!dbContext) {
+ dbContext = createDbContext();
+ // Register the new context in the global container.
+ dbContexts[dbInfo.name] = dbContext;
+ }
+
+ // Register itself as a running localForage in the current context.
+ dbContext.forages.push(self);
+
+ // Replace the default `ready()` function with the specialized one.
+ if (!self._initReady) {
+ self._initReady = self.ready;
+ self.ready = _fullyReady;
+ }
+
+ // Create an array of initialization states of the related localForages.
+ var initPromises = [];
+
+ function ignoreErrors() {
+ // Don't handle errors here,
+ // just makes sure related localForages aren't pending.
+ return Promise$1.resolve();
+ }
+
+ for (var j = 0; j < dbContext.forages.length; j++) {
+ var forage = dbContext.forages[j];
+ if (forage !== self) {
+ // Don't wait for itself...
+ initPromises.push(forage._initReady()["catch"](ignoreErrors));
+ }
+ }
+
+ // Take a snapshot of the related localForages.
+ var forages = dbContext.forages.slice(0);
+
+ // Initialize the connection process only when
+ // all the related localForages aren't pending.
+ return Promise$1.all(initPromises).then(function () {
+ dbInfo.db = dbContext.db;
+ // Get the connection or open a new one without upgrade.
+ return _getOriginalConnection(dbInfo);
+ }).then(function (db) {
+ dbInfo.db = db;
+ if (_isUpgradeNeeded(dbInfo, self._defaultConfig.version)) {
+ // Reopen the database for upgrading.
+ return _getUpgradedConnection(dbInfo);
+ }
+ return db;
+ }).then(function (db) {
+ dbInfo.db = dbContext.db = db;
+ self._dbInfo = dbInfo;
+ // Share the final connection amongst related localForages.
+ for (var k = 0; k < forages.length; k++) {
+ var forage = forages[k];
+ if (forage !== self) {
+ // Self is already up-to-date.
+ forage._dbInfo.db = dbInfo.db;
+ forage._dbInfo.version = dbInfo.version;
+ }
+ }
+ });
+}
+
+function getItem(key, callback) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+ if (err) {
+ return reject(err);
+ }
+
+ try {
+ var store = transaction.objectStore(self._dbInfo.storeName);
+ var req = store.get(key);
+
+ req.onsuccess = function () {
+ var value = req.result;
+ if (value === undefined) {
+ value = null;
+ }
+ if (_isEncodedBlob(value)) {
+ value = _decodeBlob(value);
+ }
+ resolve(value);
+ };
+
+ req.onerror = function () {
+ reject(req.error);
+ };
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Iterate over all items stored in database.
+function iterate(iterator, callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+ if (err) {
+ return reject(err);
+ }
+
+ try {
+ var store = transaction.objectStore(self._dbInfo.storeName);
+ var req = store.openCursor();
+ var iterationNumber = 1;
+
+ req.onsuccess = function () {
+ var cursor = req.result;
+
+ if (cursor) {
+ var value = cursor.value;
+ if (_isEncodedBlob(value)) {
+ value = _decodeBlob(value);
+ }
+ var result = iterator(value, cursor.key, iterationNumber++);
+
+ // when the iterator callback retuns any
+ // (non-`undefined`) value, then we stop
+ // the iteration immediately
+ if (result !== void 0) {
+ resolve(result);
+ } else {
+ cursor["continue"]();
+ }
+ } else {
+ resolve();
+ }
+ };
+
+ req.onerror = function () {
+ reject(req.error);
+ };
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+
+ return promise;
+}
+
+function setItem(key, value, callback) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = new Promise$1(function (resolve, reject) {
+ var dbInfo;
+ self.ready().then(function () {
+ dbInfo = self._dbInfo;
+ if (toString.call(value) === '[object Blob]') {
+ return _checkBlobSupport(dbInfo.db).then(function (blobSupport) {
+ if (blobSupport) {
+ return value;
+ }
+ return _encodeBlob(value);
+ });
+ }
+ return value;
+ }).then(function (value) {
+ createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
+ if (err) {
+ return reject(err);
+ }
+
+ try {
+ var store = transaction.objectStore(self._dbInfo.storeName);
+
+ // The reason we don't _save_ null is because IE 10 does
+ // not support saving the `null` type in IndexedDB. How
+ // ironic, given the bug below!
+ // See: https://github.com/mozilla/localForage/issues/161
+ if (value === null) {
+ value = undefined;
+ }
+
+ var req = store.put(value, key);
+
+ transaction.oncomplete = function () {
+ // Cast to undefined so the value passed to
+ // callback/promise is the same as what one would get out
+ // of `getItem()` later. This leads to some weirdness
+ // (setItem('foo', undefined) will return `null`), but
+ // it's not my fault localStorage is our baseline and that
+ // it's weird.
+ if (value === undefined) {
+ value = null;
+ }
+
+ resolve(value);
+ };
+ transaction.onabort = transaction.onerror = function () {
+ var err = req.error ? req.error : req.transaction.error;
+ reject(err);
+ };
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function removeItem(key, callback) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
+ if (err) {
+ return reject(err);
+ }
+
+ try {
+ var store = transaction.objectStore(self._dbInfo.storeName);
+ // We use a Grunt task to make this safe for IE and some
+ // versions of Android (including those used by Cordova).
+ // Normally IE won't like `.delete()` and will insist on
+ // using `['delete']()`, but we have a build step that
+ // fixes this for us now.
+ var req = store["delete"](key);
+ transaction.oncomplete = function () {
+ resolve();
+ };
+
+ transaction.onerror = function () {
+ reject(req.error);
+ };
+
+ // The request will be also be aborted if we've exceeded our storage
+ // space.
+ transaction.onabort = function () {
+ var err = req.error ? req.error : req.transaction.error;
+ reject(err);
+ };
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function clear(callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
+ if (err) {
+ return reject(err);
+ }
+
+ try {
+ var store = transaction.objectStore(self._dbInfo.storeName);
+ var req = store.clear();
+
+ transaction.oncomplete = function () {
+ resolve();
+ };
+
+ transaction.onabort = transaction.onerror = function () {
+ var err = req.error ? req.error : req.transaction.error;
+ reject(err);
+ };
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function length(callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+ if (err) {
+ return reject(err);
+ }
+
+ try {
+ var store = transaction.objectStore(self._dbInfo.storeName);
+ var req = store.count();
+
+ req.onsuccess = function () {
+ resolve(req.result);
+ };
+
+ req.onerror = function () {
+ reject(req.error);
+ };
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function key(n, callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ if (n < 0) {
+ resolve(null);
+
+ return;
+ }
+
+ self.ready().then(function () {
+ createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+ if (err) {
+ return reject(err);
+ }
+
+ try {
+ var store = transaction.objectStore(self._dbInfo.storeName);
+ var advanced = false;
+ var req = store.openCursor();
+
+ req.onsuccess = function () {
+ var cursor = req.result;
+ if (!cursor) {
+ // this means there weren't enough keys
+ resolve(null);
+
+ return;
+ }
+
+ if (n === 0) {
+ // We have the first key, return it if that's what they
+ // wanted.
+ resolve(cursor.key);
+ } else {
+ if (!advanced) {
+ // Otherwise, ask the cursor to skip ahead n
+ // records.
+ advanced = true;
+ cursor.advance(n);
+ } else {
+ // When we get here, we've got the nth key.
+ resolve(cursor.key);
+ }
+ }
+ };
+
+ req.onerror = function () {
+ reject(req.error);
+ };
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function keys(callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+ if (err) {
+ return reject(err);
+ }
+
+ try {
+ var store = transaction.objectStore(self._dbInfo.storeName);
+ var req = store.openCursor();
+ var keys = [];
+
+ req.onsuccess = function () {
+ var cursor = req.result;
+
+ if (!cursor) {
+ resolve(keys);
+ return;
+ }
+
+ keys.push(cursor.key);
+ cursor["continue"]();
+ };
+
+ req.onerror = function () {
+ reject(req.error);
+ };
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function dropInstance(options, callback) {
+ callback = getCallback.apply(this, arguments);
+
+ var currentConfig = this.config();
+ options = typeof options !== 'function' && options || {};
+ if (!options.name) {
+ options.name = options.name || currentConfig.name;
+ options.storeName = options.storeName || currentConfig.storeName;
+ }
+
+ var self = this;
+ var promise;
+ if (!options.name) {
+ promise = Promise$1.reject('Invalid arguments');
+ } else {
+ var isCurrentDb = options.name === currentConfig.name && self._dbInfo.db;
+
+ var dbPromise = isCurrentDb ? Promise$1.resolve(self._dbInfo.db) : _getOriginalConnection(options).then(function (db) {
+ var dbContext = dbContexts[options.name];
+ var forages = dbContext.forages;
+ dbContext.db = db;
+ for (var i = 0; i < forages.length; i++) {
+ forages[i]._dbInfo.db = db;
+ }
+ return db;
+ });
+
+ if (!options.storeName) {
+ promise = dbPromise.then(function (db) {
+ _deferReadiness(options);
+
+ var dbContext = dbContexts[options.name];
+ var forages = dbContext.forages;
+
+ db.close();
+ for (var i = 0; i < forages.length; i++) {
+ var forage = forages[i];
+ forage._dbInfo.db = null;
+ }
+
+ var dropDBPromise = new Promise$1(function (resolve, reject) {
+ var req = idb.deleteDatabase(options.name);
+
+ req.onerror = req.onblocked = function (err) {
+ var db = req.result;
+ if (db) {
+ db.close();
+ }
+ reject(err);
+ };
+
+ req.onsuccess = function () {
+ var db = req.result;
+ if (db) {
+ db.close();
+ }
+ resolve(db);
+ };
+ });
+
+ return dropDBPromise.then(function (db) {
+ dbContext.db = db;
+ for (var i = 0; i < forages.length; i++) {
+ var _forage = forages[i];
+ _advanceReadiness(_forage._dbInfo);
+ }
+ })["catch"](function (err) {
+ (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function () {});
+ throw err;
+ });
+ });
+ } else {
+ promise = dbPromise.then(function (db) {
+ if (!db.objectStoreNames.contains(options.storeName)) {
+ return;
+ }
+
+ var newVersion = db.version + 1;
+
+ _deferReadiness(options);
+
+ var dbContext = dbContexts[options.name];
+ var forages = dbContext.forages;
+
+ db.close();
+ for (var i = 0; i < forages.length; i++) {
+ var forage = forages[i];
+ forage._dbInfo.db = null;
+ forage._dbInfo.version = newVersion;
+ }
+
+ var dropObjectPromise = new Promise$1(function (resolve, reject) {
+ var req = idb.open(options.name, newVersion);
+
+ req.onerror = function (err) {
+ var db = req.result;
+ db.close();
+ reject(err);
+ };
+
+ req.onupgradeneeded = function () {
+ var db = req.result;
+ db.deleteObjectStore(options.storeName);
+ };
+
+ req.onsuccess = function () {
+ var db = req.result;
+ db.close();
+ resolve(db);
+ };
+ });
+
+ return dropObjectPromise.then(function (db) {
+ dbContext.db = db;
+ for (var j = 0; j < forages.length; j++) {
+ var _forage2 = forages[j];
+ _forage2._dbInfo.db = db;
+ _advanceReadiness(_forage2._dbInfo);
+ }
+ })["catch"](function (err) {
+ (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function () {});
+ throw err;
+ });
+ });
+ }
+ }
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+var asyncStorage = {
+ _driver: 'asyncStorage',
+ _initStorage: _initStorage,
+ _support: isIndexedDBValid(),
+ iterate: iterate,
+ getItem: getItem,
+ setItem: setItem,
+ removeItem: removeItem,
+ clear: clear,
+ length: length,
+ key: key,
+ keys: keys,
+ dropInstance: dropInstance
+};
+
+function isWebSQLValid() {
+ return typeof openDatabase === 'function';
+}
+
+// Sadly, the best way to save binary data in WebSQL/localStorage is serializing
+// it to Base64, so this is how we store it to prevent very strange errors with less
+// verbose ways of binary <-> string data storage.
+var BASE_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+var BLOB_TYPE_PREFIX = '~~local_forage_type~';
+var BLOB_TYPE_PREFIX_REGEX = /^~~local_forage_type~([^~]+)~/;
+
+var SERIALIZED_MARKER = '__lfsc__:';
+var SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER.length;
+
+// OMG the serializations!
+var TYPE_ARRAYBUFFER = 'arbf';
+var TYPE_BLOB = 'blob';
+var TYPE_INT8ARRAY = 'si08';
+var TYPE_UINT8ARRAY = 'ui08';
+var TYPE_UINT8CLAMPEDARRAY = 'uic8';
+var TYPE_INT16ARRAY = 'si16';
+var TYPE_INT32ARRAY = 'si32';
+var TYPE_UINT16ARRAY = 'ur16';
+var TYPE_UINT32ARRAY = 'ui32';
+var TYPE_FLOAT32ARRAY = 'fl32';
+var TYPE_FLOAT64ARRAY = 'fl64';
+var TYPE_SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER_LENGTH + TYPE_ARRAYBUFFER.length;
+
+var toString$1 = Object.prototype.toString;
+
+function stringToBuffer(serializedString) {
+ // Fill the string into a ArrayBuffer.
+ var bufferLength = serializedString.length * 0.75;
+ var len = serializedString.length;
+ var i;
+ var p = 0;
+ var encoded1, encoded2, encoded3, encoded4;
+
+ if (serializedString[serializedString.length - 1] === '=') {
+ bufferLength--;
+ if (serializedString[serializedString.length - 2] === '=') {
+ bufferLength--;
+ }
+ }
+
+ var buffer = new ArrayBuffer(bufferLength);
+ var bytes = new Uint8Array(buffer);
+
+ for (i = 0; i < len; i += 4) {
+ encoded1 = BASE_CHARS.indexOf(serializedString[i]);
+ encoded2 = BASE_CHARS.indexOf(serializedString[i + 1]);
+ encoded3 = BASE_CHARS.indexOf(serializedString[i + 2]);
+ encoded4 = BASE_CHARS.indexOf(serializedString[i + 3]);
+
+ /*jslint bitwise: true */
+ bytes[p++] = encoded1 << 2 | encoded2 >> 4;
+ bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
+ bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
+ }
+ return buffer;
+}
+
+// Converts a buffer to a string to store, serialized, in the backend
+// storage library.
+function bufferToString(buffer) {
+ // base64-arraybuffer
+ var bytes = new Uint8Array(buffer);
+ var base64String = '';
+ var i;
+
+ for (i = 0; i < bytes.length; i += 3) {
+ /*jslint bitwise: true */
+ base64String += BASE_CHARS[bytes[i] >> 2];
+ base64String += BASE_CHARS[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
+ base64String += BASE_CHARS[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
+ base64String += BASE_CHARS[bytes[i + 2] & 63];
+ }
+
+ if (bytes.length % 3 === 2) {
+ base64String = base64String.substring(0, base64String.length - 1) + '=';
+ } else if (bytes.length % 3 === 1) {
+ base64String = base64String.substring(0, base64String.length - 2) + '==';
+ }
+
+ return base64String;
+}
+
+// Serialize a value, afterwards executing a callback (which usually
+// instructs the `setItem()` callback/promise to be executed). This is how
+// we store binary data with localStorage.
+function serialize(value, callback) {
+ var valueType = '';
+ if (value) {
+ valueType = toString$1.call(value);
+ }
+
+ // Cannot use `value instanceof ArrayBuffer` or such here, as these
+ // checks fail when running the tests using casper.js...
+ //
+ // TODO: See why those tests fail and use a better solution.
+ if (value && (valueType === '[object ArrayBuffer]' || value.buffer && toString$1.call(value.buffer) === '[object ArrayBuffer]')) {
+ // Convert binary arrays to a string and prefix the string with
+ // a special marker.
+ var buffer;
+ var marker = SERIALIZED_MARKER;
+
+ if (value instanceof ArrayBuffer) {
+ buffer = value;
+ marker += TYPE_ARRAYBUFFER;
+ } else {
+ buffer = value.buffer;
+
+ if (valueType === '[object Int8Array]') {
+ marker += TYPE_INT8ARRAY;
+ } else if (valueType === '[object Uint8Array]') {
+ marker += TYPE_UINT8ARRAY;
+ } else if (valueType === '[object Uint8ClampedArray]') {
+ marker += TYPE_UINT8CLAMPEDARRAY;
+ } else if (valueType === '[object Int16Array]') {
+ marker += TYPE_INT16ARRAY;
+ } else if (valueType === '[object Uint16Array]') {
+ marker += TYPE_UINT16ARRAY;
+ } else if (valueType === '[object Int32Array]') {
+ marker += TYPE_INT32ARRAY;
+ } else if (valueType === '[object Uint32Array]') {
+ marker += TYPE_UINT32ARRAY;
+ } else if (valueType === '[object Float32Array]') {
+ marker += TYPE_FLOAT32ARRAY;
+ } else if (valueType === '[object Float64Array]') {
+ marker += TYPE_FLOAT64ARRAY;
+ } else {
+ callback(new Error('Failed to get type for BinaryArray'));
+ }
+ }
+
+ callback(marker + bufferToString(buffer));
+ } else if (valueType === '[object Blob]') {
+ // Conver the blob to a binaryArray and then to a string.
+ var fileReader = new FileReader();
+
+ fileReader.onload = function () {
+ // Backwards-compatible prefix for the blob type.
+ var str = BLOB_TYPE_PREFIX + value.type + '~' + bufferToString(this.result);
+
+ callback(SERIALIZED_MARKER + TYPE_BLOB + str);
+ };
+
+ fileReader.readAsArrayBuffer(value);
+ } else {
+ try {
+ callback(JSON.stringify(value));
+ } catch (e) {
+ console.error("Couldn't convert value into a JSON string: ", value);
+
+ callback(null, e);
+ }
+ }
+}
+
+// Deserialize data we've inserted into a value column/field. We place
+// special markers into our strings to mark them as encoded; this isn't
+// as nice as a meta field, but it's the only sane thing we can do whilst
+// keeping localStorage support intact.
+//
+// Oftentimes this will just deserialize JSON content, but if we have a
+// special marker (SERIALIZED_MARKER, defined above), we will extract
+// some kind of arraybuffer/binary data/typed array out of the string.
+function deserialize(value) {
+ // If we haven't marked this string as being specially serialized (i.e.
+ // something other than serialized JSON), we can just return it and be
+ // done with it.
+ if (value.substring(0, SERIALIZED_MARKER_LENGTH) !== SERIALIZED_MARKER) {
+ return JSON.parse(value);
+ }
+
+ // The following code deals with deserializing some kind of Blob or
+ // TypedArray. First we separate out the type of data we're dealing
+ // with from the data itself.
+ var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH);
+ var type = value.substring(SERIALIZED_MARKER_LENGTH, TYPE_SERIALIZED_MARKER_LENGTH);
+
+ var blobType;
+ // Backwards-compatible blob type serialization strategy.
+ // DBs created with older versions of localForage will simply not have the blob type.
+ if (type === TYPE_BLOB && BLOB_TYPE_PREFIX_REGEX.test(serializedString)) {
+ var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX);
+ blobType = matcher[1];
+ serializedString = serializedString.substring(matcher[0].length);
+ }
+ var buffer = stringToBuffer(serializedString);
+
+ // Return the right type based on the code/type set during
+ // serialization.
+ switch (type) {
+ case TYPE_ARRAYBUFFER:
+ return buffer;
+ case TYPE_BLOB:
+ return createBlob([buffer], { type: blobType });
+ case TYPE_INT8ARRAY:
+ return new Int8Array(buffer);
+ case TYPE_UINT8ARRAY:
+ return new Uint8Array(buffer);
+ case TYPE_UINT8CLAMPEDARRAY:
+ return new Uint8ClampedArray(buffer);
+ case TYPE_INT16ARRAY:
+ return new Int16Array(buffer);
+ case TYPE_UINT16ARRAY:
+ return new Uint16Array(buffer);
+ case TYPE_INT32ARRAY:
+ return new Int32Array(buffer);
+ case TYPE_UINT32ARRAY:
+ return new Uint32Array(buffer);
+ case TYPE_FLOAT32ARRAY:
+ return new Float32Array(buffer);
+ case TYPE_FLOAT64ARRAY:
+ return new Float64Array(buffer);
+ default:
+ throw new Error('Unkown type: ' + type);
+ }
+}
+
+var localforageSerializer = {
+ serialize: serialize,
+ deserialize: deserialize,
+ stringToBuffer: stringToBuffer,
+ bufferToString: bufferToString
+};
+
+/*
+ * Includes code from:
+ *
+ * base64-arraybuffer
+ * https://github.com/niklasvh/base64-arraybuffer
+ *
+ * Copyright (c) 2012 Niklas von Hertzen
+ * Licensed under the MIT license.
+ */
+
+function createDbTable(t, dbInfo, callback, errorCallback) {
+ t.executeSql('CREATE TABLE IF NOT EXISTS ' + dbInfo.storeName + ' ' + '(id INTEGER PRIMARY KEY, key unique, value)', [], callback, errorCallback);
+}
+
+// Open the WebSQL database (automatically creates one if one didn't
+// previously exist), using any options set in the config.
+function _initStorage$1(options) {
+ var self = this;
+ var dbInfo = {
+ db: null
+ };
+
+ if (options) {
+ for (var i in options) {
+ dbInfo[i] = typeof options[i] !== 'string' ? options[i].toString() : options[i];
+ }
+ }
+
+ var dbInfoPromise = new Promise$1(function (resolve, reject) {
+ // Open the database; the openDatabase API will automatically
+ // create it for us if it doesn't exist.
+ try {
+ dbInfo.db = openDatabase(dbInfo.name, String(dbInfo.version), dbInfo.description, dbInfo.size);
+ } catch (e) {
+ return reject(e);
+ }
+
+ // Create our key/value table if it doesn't exist.
+ dbInfo.db.transaction(function (t) {
+ createDbTable(t, dbInfo, function () {
+ self._dbInfo = dbInfo;
+ resolve();
+ }, function (t, error) {
+ reject(error);
+ });
+ }, reject);
+ });
+
+ dbInfo.serializer = localforageSerializer;
+ return dbInfoPromise;
+}
+
+function tryExecuteSql(t, dbInfo, sqlStatement, args, callback, errorCallback) {
+ t.executeSql(sqlStatement, args, callback, function (t, error) {
+ if (error.code === error.SYNTAX_ERR) {
+ t.executeSql('SELECT name FROM sqlite_master ' + "WHERE type='table' AND name = ?", [dbInfo.storeName], function (t, results) {
+ if (!results.rows.length) {
+ // if the table is missing (was deleted)
+ // re-create it table and retry
+ createDbTable(t, dbInfo, function () {
+ t.executeSql(sqlStatement, args, callback, errorCallback);
+ }, errorCallback);
+ } else {
+ errorCallback(t, error);
+ }
+ }, errorCallback);
+ } else {
+ errorCallback(t, error);
+ }
+ }, errorCallback);
+}
+
+function getItem$1(key, callback) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ dbInfo.db.transaction(function (t) {
+ tryExecuteSql(t, dbInfo, 'SELECT * FROM ' + dbInfo.storeName + ' WHERE key = ? LIMIT 1', [key], function (t, results) {
+ var result = results.rows.length ? results.rows.item(0).value : null;
+
+ // Check to see if this is serialized content we need to
+ // unpack.
+ if (result) {
+ result = dbInfo.serializer.deserialize(result);
+ }
+
+ resolve(result);
+ }, function (t, error) {
+ reject(error);
+ });
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function iterate$1(iterator, callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+
+ dbInfo.db.transaction(function (t) {
+ tryExecuteSql(t, dbInfo, 'SELECT * FROM ' + dbInfo.storeName, [], function (t, results) {
+ var rows = results.rows;
+ var length = rows.length;
+
+ for (var i = 0; i < length; i++) {
+ var item = rows.item(i);
+ var result = item.value;
+
+ // Check to see if this is serialized content
+ // we need to unpack.
+ if (result) {
+ result = dbInfo.serializer.deserialize(result);
+ }
+
+ result = iterator(result, item.key, i + 1);
+
+ // void(0) prevents problems with redefinition
+ // of `undefined`.
+ if (result !== void 0) {
+ resolve(result);
+ return;
+ }
+ }
+
+ resolve();
+ }, function (t, error) {
+ reject(error);
+ });
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function _setItem(key, value, callback, retriesLeft) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ // The localStorage API doesn't return undefined values in an
+ // "expected" way, so undefined is always cast to null in all
+ // drivers. See: https://github.com/mozilla/localForage/pull/42
+ if (value === undefined) {
+ value = null;
+ }
+
+ // Save the original value to pass to the callback.
+ var originalValue = value;
+
+ var dbInfo = self._dbInfo;
+ dbInfo.serializer.serialize(value, function (value, error) {
+ if (error) {
+ reject(error);
+ } else {
+ dbInfo.db.transaction(function (t) {
+ tryExecuteSql(t, dbInfo, 'INSERT OR REPLACE INTO ' + dbInfo.storeName + ' ' + '(key, value) VALUES (?, ?)', [key, value], function () {
+ resolve(originalValue);
+ }, function (t, error) {
+ reject(error);
+ });
+ }, function (sqlError) {
+ // The transaction failed; check
+ // to see if it's a quota error.
+ if (sqlError.code === sqlError.QUOTA_ERR) {
+ // We reject the callback outright for now, but
+ // it's worth trying to re-run the transaction.
+ // Even if the user accepts the prompt to use
+ // more storage on Safari, this error will
+ // be called.
+ //
+ // Try to re-run the transaction.
+ if (retriesLeft > 0) {
+ resolve(_setItem.apply(self, [key, originalValue, callback, retriesLeft - 1]));
+ return;
+ }
+ reject(sqlError);
+ }
+ });
+ }
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function setItem$1(key, value, callback) {
+ return _setItem.apply(this, [key, value, callback, 1]);
+}
+
+function removeItem$1(key, callback) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ dbInfo.db.transaction(function (t) {
+ tryExecuteSql(t, dbInfo, 'DELETE FROM ' + dbInfo.storeName + ' WHERE key = ?', [key], function () {
+ resolve();
+ }, function (t, error) {
+ reject(error);
+ });
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Deletes every item in the table.
+// TODO: Find out if this resets the AUTO_INCREMENT number.
+function clear$1(callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ dbInfo.db.transaction(function (t) {
+ tryExecuteSql(t, dbInfo, 'DELETE FROM ' + dbInfo.storeName, [], function () {
+ resolve();
+ }, function (t, error) {
+ reject(error);
+ });
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Does a simple `COUNT(key)` to get the number of items stored in
+// localForage.
+function length$1(callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ dbInfo.db.transaction(function (t) {
+ // Ahhh, SQL makes this one soooooo easy.
+ tryExecuteSql(t, dbInfo, 'SELECT COUNT(key) as c FROM ' + dbInfo.storeName, [], function (t, results) {
+ var result = results.rows.item(0).c;
+ resolve(result);
+ }, function (t, error) {
+ reject(error);
+ });
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Return the key located at key index X; essentially gets the key from a
+// `WHERE id = ?`. This is the most efficient way I can think to implement
+// this rarely-used (in my experience) part of the API, but it can seem
+// inconsistent, because we do `INSERT OR REPLACE INTO` on `setItem()`, so
+// the ID of each key will change every time it's updated. Perhaps a stored
+// procedure for the `setItem()` SQL would solve this problem?
+// TODO: Don't change ID on `setItem()`.
+function key$1(n, callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ dbInfo.db.transaction(function (t) {
+ tryExecuteSql(t, dbInfo, 'SELECT key FROM ' + dbInfo.storeName + ' WHERE id = ? LIMIT 1', [n + 1], function (t, results) {
+ var result = results.rows.length ? results.rows.item(0).key : null;
+ resolve(result);
+ }, function (t, error) {
+ reject(error);
+ });
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function keys$1(callback) {
+ var self = this;
+
+ var promise = new Promise$1(function (resolve, reject) {
+ self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ dbInfo.db.transaction(function (t) {
+ tryExecuteSql(t, dbInfo, 'SELECT key FROM ' + dbInfo.storeName, [], function (t, results) {
+ var keys = [];
+
+ for (var i = 0; i < results.rows.length; i++) {
+ keys.push(results.rows.item(i).key);
+ }
+
+ resolve(keys);
+ }, function (t, error) {
+ reject(error);
+ });
+ });
+ })["catch"](reject);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// https://www.w3.org/TR/webdatabase/#databases
+// > There is no way to enumerate or delete the databases available for an origin from this API.
+function getAllStoreNames(db) {
+ return new Promise$1(function (resolve, reject) {
+ db.transaction(function (t) {
+ t.executeSql('SELECT name FROM sqlite_master ' + "WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'", [], function (t, results) {
+ var storeNames = [];
+
+ for (var i = 0; i < results.rows.length; i++) {
+ storeNames.push(results.rows.item(i).name);
+ }
+
+ resolve({
+ db: db,
+ storeNames: storeNames
+ });
+ }, function (t, error) {
+ reject(error);
+ });
+ }, function (sqlError) {
+ reject(sqlError);
+ });
+ });
+}
+
+function dropInstance$1(options, callback) {
+ callback = getCallback.apply(this, arguments);
+
+ var currentConfig = this.config();
+ options = typeof options !== 'function' && options || {};
+ if (!options.name) {
+ options.name = options.name || currentConfig.name;
+ options.storeName = options.storeName || currentConfig.storeName;
+ }
+
+ var self = this;
+ var promise;
+ if (!options.name) {
+ promise = Promise$1.reject('Invalid arguments');
+ } else {
+ promise = new Promise$1(function (resolve) {
+ var db;
+ if (options.name === currentConfig.name) {
+ // use the db reference of the current instance
+ db = self._dbInfo.db;
+ } else {
+ db = openDatabase(options.name, '', '', 0);
+ }
+
+ if (!options.storeName) {
+ // drop all database tables
+ resolve(getAllStoreNames(db));
+ } else {
+ resolve({
+ db: db,
+ storeNames: [options.storeName]
+ });
+ }
+ }).then(function (operationInfo) {
+ return new Promise$1(function (resolve, reject) {
+ operationInfo.db.transaction(function (t) {
+ function dropTable(storeName) {
+ return new Promise$1(function (resolve, reject) {
+ t.executeSql('DROP TABLE IF EXISTS ' + storeName, [], function () {
+ resolve();
+ }, function (t, error) {
+ reject(error);
+ });
+ });
+ }
+
+ var operations = [];
+ for (var i = 0, len = operationInfo.storeNames.length; i < len; i++) {
+ operations.push(dropTable(operationInfo.storeNames[i]));
+ }
+
+ Promise$1.all(operations).then(function () {
+ resolve();
+ })["catch"](function (e) {
+ reject(e);
+ });
+ }, function (sqlError) {
+ reject(sqlError);
+ });
+ });
+ });
+ }
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+var webSQLStorage = {
+ _driver: 'webSQLStorage',
+ _initStorage: _initStorage$1,
+ _support: isWebSQLValid(),
+ iterate: iterate$1,
+ getItem: getItem$1,
+ setItem: setItem$1,
+ removeItem: removeItem$1,
+ clear: clear$1,
+ length: length$1,
+ key: key$1,
+ keys: keys$1,
+ dropInstance: dropInstance$1
+};
+
+function isLocalStorageValid() {
+ try {
+ return typeof localStorage !== 'undefined' && 'setItem' in localStorage &&
+ // in IE8 typeof localStorage.setItem === 'object'
+ !!localStorage.setItem;
+ } catch (e) {
+ return false;
+ }
+}
+
+function _getKeyPrefix(options, defaultConfig) {
+ var keyPrefix = options.name + '/';
+
+ if (options.storeName !== defaultConfig.storeName) {
+ keyPrefix += options.storeName + '/';
+ }
+ return keyPrefix;
+}
+
+// Check if localStorage throws when saving an item
+function checkIfLocalStorageThrows() {
+ var localStorageTestKey = '_localforage_support_test';
+
+ try {
+ localStorage.setItem(localStorageTestKey, true);
+ localStorage.removeItem(localStorageTestKey);
+
+ return false;
+ } catch (e) {
+ return true;
+ }
+}
+
+// Check if localStorage is usable and allows to save an item
+// This method checks if localStorage is usable in Safari Private Browsing
+// mode, or in any other case where the available quota for localStorage
+// is 0 and there wasn't any saved items yet.
+function _isLocalStorageUsable() {
+ return !checkIfLocalStorageThrows() || localStorage.length > 0;
+}
+
+// Config the localStorage backend, using options set in the config.
+function _initStorage$2(options) {
+ var self = this;
+ var dbInfo = {};
+ if (options) {
+ for (var i in options) {
+ dbInfo[i] = options[i];
+ }
+ }
+
+ dbInfo.keyPrefix = _getKeyPrefix(options, self._defaultConfig);
+
+ if (!_isLocalStorageUsable()) {
+ return Promise$1.reject();
+ }
+
+ self._dbInfo = dbInfo;
+ dbInfo.serializer = localforageSerializer;
+
+ return Promise$1.resolve();
+}
+
+// Remove all keys from the datastore, effectively destroying all data in
+// the app's key/value store!
+function clear$2(callback) {
+ var self = this;
+ var promise = self.ready().then(function () {
+ var keyPrefix = self._dbInfo.keyPrefix;
+
+ for (var i = localStorage.length - 1; i >= 0; i--) {
+ var key = localStorage.key(i);
+
+ if (key.indexOf(keyPrefix) === 0) {
+ localStorage.removeItem(key);
+ }
+ }
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Retrieve an item from the store. Unlike the original async_storage
+// library in Gaia, we don't modify return values at all. If a key's value
+// is `undefined`, we pass that value to the callback function.
+function getItem$2(key, callback) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ var result = localStorage.getItem(dbInfo.keyPrefix + key);
+
+ // If a result was found, parse it from the serialized
+ // string into a JS object. If result isn't truthy, the key
+ // is likely undefined and we'll pass it straight to the
+ // callback.
+ if (result) {
+ result = dbInfo.serializer.deserialize(result);
+ }
+
+ return result;
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Iterate over all items in the store.
+function iterate$2(iterator, callback) {
+ var self = this;
+
+ var promise = self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ var keyPrefix = dbInfo.keyPrefix;
+ var keyPrefixLength = keyPrefix.length;
+ var length = localStorage.length;
+
+ // We use a dedicated iterator instead of the `i` variable below
+ // so other keys we fetch in localStorage aren't counted in
+ // the `iterationNumber` argument passed to the `iterate()`
+ // callback.
+ //
+ // See: github.com/mozilla/localForage/pull/435#discussion_r38061530
+ var iterationNumber = 1;
+
+ for (var i = 0; i < length; i++) {
+ var key = localStorage.key(i);
+ if (key.indexOf(keyPrefix) !== 0) {
+ continue;
+ }
+ var value = localStorage.getItem(key);
+
+ // If a result was found, parse it from the serialized
+ // string into a JS object. If result isn't truthy, the
+ // key is likely undefined and we'll pass it straight
+ // to the iterator.
+ if (value) {
+ value = dbInfo.serializer.deserialize(value);
+ }
+
+ value = iterator(value, key.substring(keyPrefixLength), iterationNumber++);
+
+ if (value !== void 0) {
+ return value;
+ }
+ }
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Same as localStorage's key() method, except takes a callback.
+function key$2(n, callback) {
+ var self = this;
+ var promise = self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ var result;
+ try {
+ result = localStorage.key(n);
+ } catch (error) {
+ result = null;
+ }
+
+ // Remove the prefix from the key, if a key is found.
+ if (result) {
+ result = result.substring(dbInfo.keyPrefix.length);
+ }
+
+ return result;
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function keys$2(callback) {
+ var self = this;
+ var promise = self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ var length = localStorage.length;
+ var keys = [];
+
+ for (var i = 0; i < length; i++) {
+ var itemKey = localStorage.key(i);
+ if (itemKey.indexOf(dbInfo.keyPrefix) === 0) {
+ keys.push(itemKey.substring(dbInfo.keyPrefix.length));
+ }
+ }
+
+ return keys;
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Supply the number of keys in the datastore to the callback function.
+function length$2(callback) {
+ var self = this;
+ var promise = self.keys().then(function (keys) {
+ return keys.length;
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Remove an item from the store, nice and simple.
+function removeItem$2(key, callback) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = self.ready().then(function () {
+ var dbInfo = self._dbInfo;
+ localStorage.removeItem(dbInfo.keyPrefix + key);
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+// Set a key's value and run an optional callback once the value is set.
+// Unlike Gaia's implementation, the callback function is passed the value,
+// in case you want to operate on that value only after you're sure it
+// saved, or something like that.
+function setItem$2(key, value, callback) {
+ var self = this;
+
+ key = normalizeKey(key);
+
+ var promise = self.ready().then(function () {
+ // Convert undefined values to null.
+ // https://github.com/mozilla/localForage/pull/42
+ if (value === undefined) {
+ value = null;
+ }
+
+ // Save the original value to pass to the callback.
+ var originalValue = value;
+
+ return new Promise$1(function (resolve, reject) {
+ var dbInfo = self._dbInfo;
+ dbInfo.serializer.serialize(value, function (value, error) {
+ if (error) {
+ reject(error);
+ } else {
+ try {
+ localStorage.setItem(dbInfo.keyPrefix + key, value);
+ resolve(originalValue);
+ } catch (e) {
+ // localStorage capacity exceeded.
+ // TODO: Make this a specific error/event.
+ if (e.name === 'QuotaExceededError' || e.name === 'NS_ERROR_DOM_QUOTA_REACHED') {
+ reject(e);
+ }
+ reject(e);
+ }
+ }
+ });
+ });
+ });
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+function dropInstance$2(options, callback) {
+ callback = getCallback.apply(this, arguments);
+
+ options = typeof options !== 'function' && options || {};
+ if (!options.name) {
+ var currentConfig = this.config();
+ options.name = options.name || currentConfig.name;
+ options.storeName = options.storeName || currentConfig.storeName;
+ }
+
+ var self = this;
+ var promise;
+ if (!options.name) {
+ promise = Promise$1.reject('Invalid arguments');
+ } else {
+ promise = new Promise$1(function (resolve) {
+ if (!options.storeName) {
+ resolve(options.name + '/');
+ } else {
+ resolve(_getKeyPrefix(options, self._defaultConfig));
+ }
+ }).then(function (keyPrefix) {
+ for (var i = localStorage.length - 1; i >= 0; i--) {
+ var key = localStorage.key(i);
+
+ if (key.indexOf(keyPrefix) === 0) {
+ localStorage.removeItem(key);
+ }
+ }
+ });
+ }
+
+ executeCallback(promise, callback);
+ return promise;
+}
+
+var localStorageWrapper = {
+ _driver: 'localStorageWrapper',
+ _initStorage: _initStorage$2,
+ _support: isLocalStorageValid(),
+ iterate: iterate$2,
+ getItem: getItem$2,
+ setItem: setItem$2,
+ removeItem: removeItem$2,
+ clear: clear$2,
+ length: length$2,
+ key: key$2,
+ keys: keys$2,
+ dropInstance: dropInstance$2
+};
+
+var sameValue = function sameValue(x, y) {
+ return x === y || typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y);
+};
+
+var includes = function includes(array, searchElement) {
+ var len = array.length;
+ var i = 0;
+ while (i < len) {
+ if (sameValue(array[i], searchElement)) {
+ return true;
+ }
+ i++;
+ }
+
+ return false;
+};
+
+var isArray = Array.isArray || function (arg) {
+ return Object.prototype.toString.call(arg) === '[object Array]';
+};
+
+// Drivers are stored here when `defineDriver()` is called.
+// They are shared across all instances of localForage.
+var DefinedDrivers = {};
+
+var DriverSupport = {};
+
+var DefaultDrivers = {
+ INDEXEDDB: asyncStorage,
+ WEBSQL: webSQLStorage,
+ LOCALSTORAGE: localStorageWrapper
+};
+
+var DefaultDriverOrder = [DefaultDrivers.INDEXEDDB._driver, DefaultDrivers.WEBSQL._driver, DefaultDrivers.LOCALSTORAGE._driver];
+
+var OptionalDriverMethods = ['dropInstance'];
+
+var LibraryMethods = ['clear', 'getItem', 'iterate', 'key', 'keys', 'length', 'removeItem', 'setItem'].concat(OptionalDriverMethods);
+
+var DefaultConfig = {
+ description: '',
+ driver: DefaultDriverOrder.slice(),
+ name: 'localforage',
+ // Default DB size is _JUST UNDER_ 5MB, as it's the highest size
+ // we can use without a prompt.
+ size: 4980736,
+ storeName: 'keyvaluepairs',
+ version: 1.0
+};
+
+function callWhenReady(localForageInstance, libraryMethod) {
+ localForageInstance[libraryMethod] = function () {
+ var _args = arguments;
+ return localForageInstance.ready().then(function () {
+ return localForageInstance[libraryMethod].apply(localForageInstance, _args);
+ });
+ };
+}
+
+function extend() {
+ for (var i = 1; i < arguments.length; i++) {
+ var arg = arguments[i];
+
+ if (arg) {
+ for (var _key in arg) {
+ if (arg.hasOwnProperty(_key)) {
+ if (isArray(arg[_key])) {
+ arguments[0][_key] = arg[_key].slice();
+ } else {
+ arguments[0][_key] = arg[_key];
+ }
+ }
+ }
+ }
+ }
+
+ return arguments[0];
+}
+
+var LocalForage = function () {
+ function LocalForage(options) {
+ _classCallCheck(this, LocalForage);
+
+ for (var driverTypeKey in DefaultDrivers) {
+ if (DefaultDrivers.hasOwnProperty(driverTypeKey)) {
+ var driver = DefaultDrivers[driverTypeKey];
+ var driverName = driver._driver;
+ this[driverTypeKey] = driverName;
+
+ if (!DefinedDrivers[driverName]) {
+ // we don't need to wait for the promise,
+ // since the default drivers can be defined
+ // in a blocking manner
+ this.defineDriver(driver);
+ }
+ }
+ }
+
+ this._defaultConfig = extend({}, DefaultConfig);
+ this._config = extend({}, this._defaultConfig, options);
+ this._driverSet = null;
+ this._initDriver = null;
+ this._ready = false;
+ this._dbInfo = null;
+
+ this._wrapLibraryMethodsWithReady();
+ this.setDriver(this._config.driver)["catch"](function () {});
+ }
+
+ // Set any config values for localForage; can be called anytime before
+ // the first API call (e.g. `getItem`, `setItem`).
+ // We loop through options so we don't overwrite existing config
+ // values.
+
+
+ LocalForage.prototype.config = function config(options) {
+ // If the options argument is an object, we use it to set values.
+ // Otherwise, we return either a specified config value or all
+ // config values.
+ if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object') {
+ // If localforage is ready and fully initialized, we can't set
+ // any new configuration values. Instead, we return an error.
+ if (this._ready) {
+ return new Error("Can't call config() after localforage " + 'has been used.');
+ }
+
+ for (var i in options) {
+ if (i === 'storeName') {
+ options[i] = options[i].replace(/\W/g, '_');
+ }
+
+ if (i === 'version' && typeof options[i] !== 'number') {
+ return new Error('Database version must be a number.');
+ }
+
+ this._config[i] = options[i];
+ }
+
+ // after all config options are set and
+ // the driver option is used, try setting it
+ if ('driver' in options && options.driver) {
+ return this.setDriver(this._config.driver);
+ }
+
+ return true;
+ } else if (typeof options === 'string') {
+ return this._config[options];
+ } else {
+ return this._config;
+ }
+ };
+
+ // Used to define a custom driver, shared across all instances of
+ // localForage.
+
+
+ LocalForage.prototype.defineDriver = function defineDriver(driverObject, callback, errorCallback) {
+ var promise = new Promise$1(function (resolve, reject) {
+ try {
+ var driverName = driverObject._driver;
+ var complianceError = new Error('Custom driver not compliant; see ' + 'https://mozilla.github.io/localForage/#definedriver');
+
+ // A driver name should be defined and not overlap with the
+ // library-defined, default drivers.
+ if (!driverObject._driver) {
+ reject(complianceError);
+ return;
+ }
+
+ var driverMethods = LibraryMethods.concat('_initStorage');
+ for (var i = 0, len = driverMethods.length; i < len; i++) {
+ var driverMethodName = driverMethods[i];
+
+ // when the property is there,
+ // it should be a method even when optional
+ var isRequired = !includes(OptionalDriverMethods, driverMethodName);
+ if ((isRequired || driverObject[driverMethodName]) && typeof driverObject[driverMethodName] !== 'function') {
+ reject(complianceError);
+ return;
+ }
+ }
+
+ var configureMissingMethods = function configureMissingMethods() {
+ var methodNotImplementedFactory = function methodNotImplementedFactory(methodName) {
+ return function () {
+ var error = new Error('Method ' + methodName + ' is not implemented by the current driver');
+ var promise = Promise$1.reject(error);
+ executeCallback(promise, arguments[arguments.length - 1]);
+ return promise;
+ };
+ };
+
+ for (var _i = 0, _len = OptionalDriverMethods.length; _i < _len; _i++) {
+ var optionalDriverMethod = OptionalDriverMethods[_i];
+ if (!driverObject[optionalDriverMethod]) {
+ driverObject[optionalDriverMethod] = methodNotImplementedFactory(optionalDriverMethod);
+ }
+ }
+ };
+
+ configureMissingMethods();
+
+ var setDriverSupport = function setDriverSupport(support) {
+ if (DefinedDrivers[driverName]) {
+ console.info('Redefining LocalForage driver: ' + driverName);
+ }
+ DefinedDrivers[driverName] = driverObject;
+ DriverSupport[driverName] = support;
+ // don't use a then, so that we can define
+ // drivers that have simple _support methods
+ // in a blocking manner
+ resolve();
+ };
+
+ if ('_support' in driverObject) {
+ if (driverObject._support && typeof driverObject._support === 'function') {
+ driverObject._support().then(setDriverSupport, reject);
+ } else {
+ setDriverSupport(!!driverObject._support);
+ }
+ } else {
+ setDriverSupport(true);
+ }
+ } catch (e) {
+ reject(e);
+ }
+ });
+
+ executeTwoCallbacks(promise, callback, errorCallback);
+ return promise;
+ };
+
+ LocalForage.prototype.driver = function driver() {
+ return this._driver || null;
+ };
+
+ LocalForage.prototype.getDriver = function getDriver(driverName, callback, errorCallback) {
+ var getDriverPromise = DefinedDrivers[driverName] ? Promise$1.resolve(DefinedDrivers[driverName]) : Promise$1.reject(new Error('Driver not found.'));
+
+ executeTwoCallbacks(getDriverPromise, callback, errorCallback);
+ return getDriverPromise;
+ };
+
+ LocalForage.prototype.getSerializer = function getSerializer(callback) {
+ var serializerPromise = Promise$1.resolve(localforageSerializer);
+ executeTwoCallbacks(serializerPromise, callback);
+ return serializerPromise;
+ };
+
+ LocalForage.prototype.ready = function ready(callback) {
+ var self = this;
+
+ var promise = self._driverSet.then(function () {
+ if (self._ready === null) {
+ self._ready = self._initDriver();
+ }
+
+ return self._ready;
+ });
+
+ executeTwoCallbacks(promise, callback, callback);
+ return promise;
+ };
+
+ LocalForage.prototype.setDriver = function setDriver(drivers, callback, errorCallback) {
+ var self = this;
+
+ if (!isArray(drivers)) {
+ drivers = [drivers];
+ }
+
+ var supportedDrivers = this._getSupportedDrivers(drivers);
+
+ function setDriverToConfig() {
+ self._config.driver = self.driver();
+ }
+
+ function extendSelfWithDriver(driver) {
+ self._extend(driver);
+ setDriverToConfig();
+
+ self._ready = self._initStorage(self._config);
+ return self._ready;
+ }
+
+ function initDriver(supportedDrivers) {
+ return function () {
+ var currentDriverIndex = 0;
+
+ function driverPromiseLoop() {
+ while (currentDriverIndex < supportedDrivers.length) {
+ var driverName = supportedDrivers[currentDriverIndex];
+ currentDriverIndex++;
+
+ self._dbInfo = null;
+ self._ready = null;
+
+ return self.getDriver(driverName).then(extendSelfWithDriver)["catch"](driverPromiseLoop);
+ }
+
+ setDriverToConfig();
+ var error = new Error('No available storage method found.');
+ self._driverSet = Promise$1.reject(error);
+ return self._driverSet;
+ }
+
+ return driverPromiseLoop();
+ };
+ }
+
+ // There might be a driver initialization in progress
+ // so wait for it to finish in order to avoid a possible
+ // race condition to set _dbInfo
+ var oldDriverSetDone = this._driverSet !== null ? this._driverSet["catch"](function () {
+ return Promise$1.resolve();
+ }) : Promise$1.resolve();
+
+ this._driverSet = oldDriverSetDone.then(function () {
+ var driverName = supportedDrivers[0];
+ self._dbInfo = null;
+ self._ready = null;
+
+ return self.getDriver(driverName).then(function (driver) {
+ self._driver = driver._driver;
+ setDriverToConfig();
+ self._wrapLibraryMethodsWithReady();
+ self._initDriver = initDriver(supportedDrivers);
+ });
+ })["catch"](function () {
+ setDriverToConfig();
+ var error = new Error('No available storage method found.');
+ self._driverSet = Promise$1.reject(error);
+ return self._driverSet;
+ });
+
+ executeTwoCallbacks(this._driverSet, callback, errorCallback);
+ return this._driverSet;
+ };
+
+ LocalForage.prototype.supports = function supports(driverName) {
+ return !!DriverSupport[driverName];
+ };
+
+ LocalForage.prototype._extend = function _extend(libraryMethodsAndProperties) {
+ extend(this, libraryMethodsAndProperties);
+ };
+
+ LocalForage.prototype._getSupportedDrivers = function _getSupportedDrivers(drivers) {
+ var supportedDrivers = [];
+ for (var i = 0, len = drivers.length; i < len; i++) {
+ var driverName = drivers[i];
+ if (this.supports(driverName)) {
+ supportedDrivers.push(driverName);
+ }
+ }
+ return supportedDrivers;
+ };
+
+ LocalForage.prototype._wrapLibraryMethodsWithReady = function _wrapLibraryMethodsWithReady() {
+ // Add a stub for each driver API method that delays the call to the
+ // corresponding driver method until localForage is ready. These stubs
+ // will be replaced by the driver methods as soon as the driver is
+ // loaded, so there is no performance impact.
+ for (var i = 0, len = LibraryMethods.length; i < len; i++) {
+ callWhenReady(this, LibraryMethods[i]);
+ }
+ };
+
+ LocalForage.prototype.createInstance = function createInstance(options) {
+ return new LocalForage(options);
+ };
+
+ return LocalForage;
+}();
+
+// The actual localForage object that we expose as a module or via a
+// global. It's extended by pulling in one of our other libraries.
+
+
+var localforage_js = new LocalForage();
+
+module.exports = localforage_js;
+
+},{"3":3}]},{},[4])(4)
+});
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(27)))
+
+/***/ }),
+/* 33 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global, process) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getGlobalNamespace; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getGlobal; });
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// Note that the identifier globalNameSpace is scoped to this module, but will
+// always resolve to the same global object regardless of how the module is
+// resolved.
+// tslint:disable-next-line:no-any
+let globalNameSpace;
+// tslint:disable-next-line:no-any
+function getGlobalNamespace() {
+ if (globalNameSpace == null) {
+ // tslint:disable-next-line:no-any
+ let ns;
+ if (typeof (window) !== 'undefined') {
+ ns = window;
+ }
+ else if (typeof (global) !== 'undefined') {
+ ns = global;
+ }
+ else if (typeof (process) !== 'undefined') {
+ ns = process;
+ }
+ else if (typeof (self) !== 'undefined') {
+ ns = self;
+ }
+ else {
+ throw new Error('Could not find a global object');
+ }
+ globalNameSpace = ns;
+ }
+ return globalNameSpace;
+}
+// tslint:disable-next-line:no-any
+function getGlobalMap() {
+ const ns = getGlobalNamespace();
+ if (ns._tfGlobals == null) {
+ ns._tfGlobals = new Map();
+ }
+ return ns._tfGlobals;
+}
+/**
+ * Returns a globally accessible 'singleton' object.
+ *
+ * @param key the name of the object
+ * @param init a function to initialize to initialize this object
+ * the first time it is fetched.
+ */
+function getGlobal(key, init) {
+ const globalMap = getGlobalMap();
+ if (globalMap.has(key)) {
+ return globalMap.get(key);
+ }
+ else {
+ const singleton = init();
+ globalMap.set(key, singleton);
+ return globalMap.get(key);
+ }
+}
+//# sourceMappingURL=global_util.js.map
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(27), __webpack_require__(35)))
+
+/***/ }),
+/* 34 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DTYPE_VALUE_SIZE_MAP; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/* Type definitions for exporting and importing of models. */
+/**
+ * A map from Tensor dtype to number of bytes per element of the Tensor.
+ */
+const DTYPE_VALUE_SIZE_MAP = {
+ 'float32': 4,
+ 'float16': 2,
+ 'int32': 4,
+ 'uint16': 2,
+ 'uint8': 1,
+ 'bool': 1,
+ 'complex64': 8
+};
+//# sourceMappingURL=types.js.map
+
+/***/ }),
+/* 35 */
+/***/ (function(module, exports) {
+
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things. But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals. It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+ throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+ throw new Error('clearTimeout has not been defined');
+}
+(function () {
+ try {
+ if (typeof setTimeout === 'function') {
+ cachedSetTimeout = setTimeout;
+ } else {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ } catch (e) {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ try {
+ if (typeof clearTimeout === 'function') {
+ cachedClearTimeout = clearTimeout;
+ } else {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+ } catch (e) {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+} ())
+function runTimeout(fun) {
+ if (cachedSetTimeout === setTimeout) {
+ //normal enviroments in sane situations
+ return setTimeout(fun, 0);
+ }
+ // if setTimeout wasn't available but was latter defined
+ if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+ cachedSetTimeout = setTimeout;
+ return setTimeout(fun, 0);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedSetTimeout(fun, 0);
+ } catch(e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedSetTimeout.call(null, fun, 0);
+ } catch(e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+ return cachedSetTimeout.call(this, fun, 0);
+ }
+ }
+
+
+}
+function runClearTimeout(marker) {
+ if (cachedClearTimeout === clearTimeout) {
+ //normal enviroments in sane situations
+ return clearTimeout(marker);
+ }
+ // if clearTimeout wasn't available but was latter defined
+ if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+ cachedClearTimeout = clearTimeout;
+ return clearTimeout(marker);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedClearTimeout(marker);
+ } catch (e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedClearTimeout.call(null, marker);
+ } catch (e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+ // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+ return cachedClearTimeout.call(this, marker);
+ }
+ }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+ if (!draining || !currentQueue) {
+ return;
+ }
+ draining = false;
+ if (currentQueue.length) {
+ queue = currentQueue.concat(queue);
+ } else {
+ queueIndex = -1;
+ }
+ if (queue.length) {
+ drainQueue();
+ }
+}
+
+function drainQueue() {
+ if (draining) {
+ return;
+ }
+ var timeout = runTimeout(cleanUpNextTick);
+ draining = true;
+
+ var len = queue.length;
+ while(len) {
+ currentQueue = queue;
+ queue = [];
+ while (++queueIndex < len) {
+ if (currentQueue) {
+ currentQueue[queueIndex].run();
+ }
+ }
+ queueIndex = -1;
+ len = queue.length;
+ }
+ currentQueue = null;
+ draining = false;
+ runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+ var args = new Array(arguments.length - 1);
+ if (arguments.length > 1) {
+ for (var i = 1; i < arguments.length; i++) {
+ args[i - 1] = arguments[i];
+ }
+ }
+ queue.push(new Item(fun, args));
+ if (queue.length === 1 && !draining) {
+ runTimeout(drainQueue);
+ }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+ this.fun = fun;
+ this.array = array;
+}
+Item.prototype.run = function () {
+ this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+
+/***/ }),
+/* 36 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isMobile", function() { return isMobile; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isBrowser", function() { return isBrowser; });
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// tslint:disable-next-line:no-any
+function _isNavigatorDefined() {
+ return typeof navigator !== 'undefined' && navigator != null;
+}
+function isMobile() {
+ if (_isNavigatorDefined()) {
+ // tslint:disable-next-line:no-any
+ const a = navigator.userAgent || navigator.vendor || window.opera;
+ // tslint:disable-next-line:max-line-length
+ return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i
+ .test(a) ||
+ // tslint:disable-next-line:max-line-length
+ /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i
+ .test(a.substr(0, 4));
+ }
+ return false;
+}
+function isBrowser() {
+ return (typeof window !== 'undefined' && window.document != null) ||
+ //@ts-ignore
+ (typeof WorkerGlobalScope !== 'undefined');
+}
+//# sourceMappingURL=device_util.js.map
+
+/***/ }),
+/* 37 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return maxImpl; });
+/* harmony import */ var _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/**
+ * @license
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+function maxImpl(aVals, reduceSize, outShape, dtype) {
+ const vals = _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].getTypedArrayFromDType(dtype, _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["util"].sizeFromShape(outShape));
+ for (let i = 0; i < vals.length; ++i) {
+ const offset = i * reduceSize;
+ let max = aVals[offset];
+ for (let j = 0; j < reduceSize; ++j) {
+ const value = aVals[offset + j];
+ if (value > max) {
+ max = value;
+ }
+ }
+ vals[i] = max;
+ }
+ return vals;
+}
+//# sourceMappingURL=Max_impl.js.map
+
+/***/ }),
+/* 38 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, "GraphModel", function() { return /* reexport */ graph_model_GraphModel; });
+__webpack_require__.d(__webpack_exports__, "loadGraphModel", function() { return /* reexport */ loadGraphModel; });
+__webpack_require__.d(__webpack_exports__, "deregisterOp", function() { return /* reexport */ register["a" /* deregisterOp */]; });
+__webpack_require__.d(__webpack_exports__, "registerOp", function() { return /* reexport */ register["c" /* registerOp */]; });
+__webpack_require__.d(__webpack_exports__, "version_converter", function() { return /* reexport */ version; });
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-core/dist/index.js + 269 modules
+var dist = __webpack_require__(0);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/operation_mapper.js
+var operation_mapper = __webpack_require__(15);
+
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/utils.js
+var utils = __webpack_require__(2);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/custom_op/node_value_impl.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+/**
+ * Helper class for lookup inputs and params for nodes in the model graph.
+ */
+class node_value_impl_NodeValueImpl {
+ constructor(node, tensorMap, context) {
+ this.node = node;
+ this.tensorMap = tensorMap;
+ this.context = context;
+ this.inputs = [];
+ this.attrs = {};
+ this.inputs = node.inputNames.map(name => this.getInput(name));
+ if (node.rawAttrs != null) {
+ this.attrs = Object.keys(node.rawAttrs)
+ .reduce((attrs, key) => {
+ attrs[key] = this.getAttr(key);
+ return attrs;
+ }, {});
+ }
+ }
+ /**
+ * Return the value of the attribute or input param.
+ * @param name String: name of attribute or input param.
+ */
+ getInput(name) {
+ return Object(utils["c" /* getTensor */])(name, this.tensorMap, this.context);
+ }
+ /**
+ * Return the value of the attribute or input param.
+ * @param name String: name of attribute or input param.
+ */
+ getAttr(name, defaultValue) {
+ const value = this.node.rawAttrs[name];
+ if (value.tensor != null) {
+ return Object(utils["c" /* getTensor */])(name, this.tensorMap, this.context);
+ }
+ if (value.i != null || value.f != null) {
+ return Object(operation_mapper["f" /* getNumberParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.s != null) {
+ return Object(operation_mapper["i" /* getStringParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.b != null) {
+ return Object(operation_mapper["c" /* getBoolParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.shape != null) {
+ return Object(operation_mapper["k" /* getTensorShapeParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.type != null) {
+ return Object(operation_mapper["e" /* getDtypeParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.list != null) {
+ if (value.list.i != null || value.list.f != null) {
+ return Object(operation_mapper["g" /* getNumericArrayParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.list.s != null) {
+ return Object(operation_mapper["h" /* getStringArrayParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.list.shape != null) {
+ return Object(operation_mapper["j" /* getTensorShapeArrayParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.list.b != null) {
+ return Object(operation_mapper["b" /* getBoolArrayParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ if (value.list.type != null) {
+ return Object(operation_mapper["d" /* getDtypeArrayParam */])(this.node.rawAttrs, name, defaultValue);
+ }
+ }
+ return defaultValue;
+ }
+}
+//# sourceMappingURL=node_value_impl.js.map
+// EXTERNAL MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/custom_op/register.js
+var register = __webpack_require__(24);
+
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/arithmetic_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'BiasAdd':
+ case 'AddV2':
+ case 'Add': {
+ return [dist["add"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'AddN': {
+ return [dist["addN"](Object(utils["b" /* getParamValue */])('tensors', node, tensorMap, context))];
+ }
+ case 'FloorMod':
+ case 'Mod':
+ return [dist["mod"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ case 'Mul':
+ return [dist["mul"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ case 'RealDiv':
+ case 'Div': {
+ return [dist["div"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'DivNoNan': {
+ return [dist["divNoNan"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'FloorDiv': {
+ return [dist["floorDiv"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'Sub': {
+ return [dist["sub"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'Minimum': {
+ return [dist["minimum"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'Maximum': {
+ return [dist["maximum"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'Pow': {
+ return [dist["pow"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'SquaredDifference': {
+ return [dist["squaredDifference"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const CATEGORY = 'arithmetic';
+//# sourceMappingURL=arithmetic_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/basic_math_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const basic_math_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'Abs':
+ case 'ComplexAbs':
+ return [dist["abs"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Acos':
+ return [dist["acos"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Acosh':
+ return [dist["acosh"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Asin':
+ return [dist["asin"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Asinh':
+ return [dist["asinh"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Atan':
+ return [dist["atan"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Atan2':
+ return [dist["atan2"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('y', node, tensorMap, context))];
+ case 'Atanh':
+ return [dist["atanh"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Ceil':
+ return [dist["ceil"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Complex':
+ return [dist["complex"](Object(utils["b" /* getParamValue */])('real', node, tensorMap, context), Object(utils["b" /* getParamValue */])('imag', node, tensorMap, context))];
+ case 'Cos':
+ return [dist["cos"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Cosh':
+ return [dist["cosh"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Elu':
+ return [dist["elu"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Erf':
+ return [dist["erf"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Exp':
+ return [dist["exp"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Expm1': {
+ return [dist["expm1"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Floor':
+ return [dist["floor"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Log':
+ return [dist["log"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Log1p': {
+ return [dist["log1p"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Imag':
+ return [dist["imag"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Neg':
+ return [dist["neg"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Reciprocal': {
+ return [dist["reciprocal"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Real':
+ return [dist["real"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Relu':
+ return [dist["relu"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Round': {
+ return [dist["round"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Selu':
+ return [dist["selu"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Sigmoid':
+ return [dist["sigmoid"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Sin':
+ return [dist["sin"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Sign': {
+ return [dist["sign"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Sinh': {
+ return [dist["sinh"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Softplus': {
+ return [dist["softplus"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Sqrt': {
+ return [dist["sqrt"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Square': {
+ return [dist["square"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Tanh': {
+ return [dist["tanh"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'Tan':
+ return [dist["tan"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ case 'Relu6':
+ case 'ClipByValue':
+ return [dist["clipByValue"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('clipValueMin', node, tensorMap, context), Object(utils["b" /* getParamValue */])('clipValueMax', node, tensorMap, context))];
+ case 'Rsqrt':
+ return [dist["rsqrt"](Object(utils["c" /* getTensor */])(node.inputNames[0], tensorMap, context))];
+ case 'Prod':
+ return [dist["prod"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('axes', node, tensorMap, context))];
+ case 'LeakyRelu':
+ return [dist["leakyRelu"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('alpha', node, tensorMap, context))];
+ case 'Prelu':
+ return [dist["prelu"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('alpha', node, tensorMap, context))];
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const basic_math_executor_CATEGORY = 'basic_math';
+//# sourceMappingURL=basic_math_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/executor/tensor_utils.js
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * This differs from util.assertShapesMatch in that it allows values of
+ * negative one, an undefined size of a dimensinon, in a shape to match
+ * anything.
+ */
+
+function assertShapesMatchAllowUndefinedSize(shapeA, shapeB, errorMessagePrefix = '') {
+ dist["util"].assert(shapesEqualAllowUndefinedSize(shapeA, shapeB), () => errorMessagePrefix + ` Shapes ${shapeA} and ${shapeB} must match`);
+}
+function shapesEqualAllowUndefinedSize(n1, n2) {
+ if (n1.length !== n2.length) {
+ return false;
+ }
+ for (let i = 0; i < n1.length; i++) {
+ if (n1[i] !== -1 && n2[i] !== -1 && n1[i] !== n2[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+//# sourceMappingURL=tensor_utils.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/executor/tensor_array.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+/**
+ * The TensorArray object keeps an array of Tensors. It
+ * allows reading from the array and writing to the array.
+ */
+class tensor_array_TensorArray {
+ constructor(name, dtype, maxSize, elementShape, identicalElementShapes, dynamicSize, clearAfterRead) {
+ this.name = name;
+ this.dtype = dtype;
+ this.maxSize = maxSize;
+ this.elementShape = elementShape;
+ this.identicalElementShapes = identicalElementShapes;
+ this.dynamicSize = dynamicSize;
+ this.clearAfterRead = clearAfterRead;
+ this.tensors = [];
+ this.closed_ = false;
+ this.id = tensor_array_TensorArray.nextId++;
+ }
+ get closed() {
+ return this.closed_;
+ }
+ /**
+ * Close the current TensorArray.
+ */
+ clearAndClose() {
+ this.tensors.forEach(tensor => tensor.tensor.dispose());
+ this.tensors = [];
+ this.closed_ = true;
+ }
+ size() {
+ return this.tensors.length;
+ }
+ /**
+ * Read the value at location index in the TensorArray.
+ * @param index Number the index to read from.
+ */
+ read(index) {
+ if (this.closed_) {
+ throw new Error(`TensorArray ${this.name} has already been closed.`);
+ }
+ if (index < 0 || index >= this.size()) {
+ throw new Error(`Tried to read from index ${index}, but array size is: ${this.size()}`);
+ }
+ const tensorWithState = this.tensors[index];
+ if (tensorWithState.cleared) {
+ throw new Error(`TensorArray ${this.name}: Could not read index ${index} twice because it was cleared after a previous read ` +
+ `(perhaps try setting clear_after_read = false?).`);
+ }
+ if (this.clearAfterRead) {
+ tensorWithState.cleared = true;
+ }
+ tensorWithState.read = true;
+ return tensorWithState.tensor;
+ }
+ /**
+ * Helper method to read multiple tensors from the specified indices.
+ */
+ readMany(indices) {
+ return indices.map(index => this.read(index));
+ }
+ /**
+ * Write value into the index of the TensorArray.
+ * @param index number the index to write to.
+ * @param tensor
+ */
+ write(index, tensor) {
+ if (this.closed_) {
+ throw new Error(`TensorArray ${this.name} has already been closed.`);
+ }
+ if (index < 0 || !this.dynamicSize && index >= this.maxSize) {
+ throw new Error(`Tried to write to index ${index}, but array is not resizeable and size is: ${this.maxSize}`);
+ }
+ const t = this.tensors[index] || {};
+ if (tensor.dtype !== this.dtype) {
+ throw new Error(`TensorArray ${this.name}: Could not write to TensorArray index ${index},
+ because the value dtype is ${tensor.dtype}, but TensorArray dtype is ${this.dtype}.`);
+ }
+ // Set the shape for the first time write to unknow shape tensor array
+ if (this.size() === 0 &&
+ (this.elementShape == null || this.elementShape.length === 0)) {
+ this.elementShape = tensor.shape;
+ }
+ assertShapesMatchAllowUndefinedSize(this.elementShape, tensor.shape, `TensorArray ${this.name}: Could not write to TensorArray index ${index}.`);
+ if (t && t.read) {
+ throw new Error(`TensorArray ${this.name}: Could not write to TensorArray index ${index}, because it has already been read.`);
+ }
+ if (t && t.written) {
+ throw new Error(`TensorArray ${this.name}: Could not write to TensorArray index ${index}, because it has already been written.`);
+ }
+ t.tensor = tensor;
+ t.written = true;
+ this.tensors[index] = t;
+ }
+ /**
+ * Helper method to write multiple tensors to the specified indices.
+ */
+ writeMany(indices, tensors) {
+ if (indices.length !== tensors.length) {
+ throw new Error(`TensorArray ${this.name}: could not write multiple tensors,` +
+ `because the index size: ${indices.length} is not the same as tensors size: ${tensors.length}.`);
+ }
+ indices.forEach((i, index) => this.write(i, tensors[index]));
+ }
+ /**
+ * Return selected values in the TensorArray as a packed Tensor. All of
+ * selected values must have been written and their shapes must all match.
+ * @param [indices] number[] Optional. Taking values in [0, max_value). If the
+ * TensorArray is not dynamic, max_value=size(). If not specified returns
+ * all tensors in the original order.
+ * @param [dtype]
+ */
+ gather(indices, dtype) {
+ if (!!dtype && dtype !== this.dtype) {
+ throw new Error(`TensorArray dtype is ${this.dtype} but gather requested dtype ${dtype}`);
+ }
+ if (!indices) {
+ indices = [];
+ for (let i = 0; i < this.size(); i++) {
+ indices.push(i);
+ }
+ }
+ else {
+ indices = indices.slice(0, this.size());
+ }
+ if (indices.length === 0) {
+ return Object(dist["tensor"])([], [0].concat(this.elementShape));
+ }
+ // Read all the PersistentTensors into a vector to keep track of
+ // their memory.
+ const tensors = this.readMany(indices);
+ assertShapesMatchAllowUndefinedSize(this.elementShape, tensors[0].shape, 'TensorArray shape mismatch: ');
+ return Object(dist["stack"])(tensors, 0);
+ }
+ /**
+ * Return the values in the TensorArray as a concatenated Tensor.
+ */
+ concat(dtype) {
+ if (!!dtype && dtype !== this.dtype) {
+ throw new Error(`TensorArray dtype is ${this.dtype} but concat requested dtype ${dtype}`);
+ }
+ if (this.size() === 0) {
+ return Object(dist["tensor"])([], [0].concat(this.elementShape));
+ }
+ const indices = [];
+ for (let i = 0; i < this.size(); i++) {
+ indices.push(i);
+ }
+ // Collect all the tensors from the tensors array.
+ const tensors = this.readMany(indices);
+ assertShapesMatchAllowUndefinedSize(this.elementShape, tensors[0].shape, `TensorArray shape mismatch: tensor array shape (${this.elementShape}) vs first tensor shape (${tensors[0].shape})`);
+ return Object(dist["concat"])(tensors, 0);
+ }
+ /**
+ * Scatter the values of a Tensor in specific indices of a TensorArray.
+ * @param indices nummber[] values in [0, max_value). If the
+ * TensorArray is not dynamic, max_value=size().
+ * @param tensor Tensor input tensor.
+ */
+ scatter(indices, tensor) {
+ if (tensor.dtype !== this.dtype) {
+ throw new Error(`TensorArray dtype is ${this.dtype} but tensor has dtype ${tensor.dtype}`);
+ }
+ if (indices.length !== tensor.shape[0]) {
+ throw new Error(`Expected len(indices) == tensor.shape[0], but saw: ${indices.length} vs. ${tensor.shape[0]}`);
+ }
+ const maxIndex = Math.max(...indices);
+ if (!this.dynamicSize && maxIndex >= this.maxSize) {
+ throw new Error(`Max index must be < array size (${maxIndex} vs. ${this.maxSize})`);
+ }
+ this.writeMany(indices, Object(dist["unstack"])(tensor, 0));
+ }
+ /**
+ * Split the values of a Tensor into the TensorArray.
+ * @param length number[] with the lengths to use when splitting value along
+ * its first dimension.
+ * @param tensor Tensor, the tensor to split.
+ */
+ split(length, tensor) {
+ if (tensor.dtype !== this.dtype) {
+ throw new Error(`TensorArray dtype is ${this.dtype} but tensor has dtype ${tensor.dtype}`);
+ }
+ let totalLength = 0;
+ const cumulativeLengths = length.map(len => {
+ totalLength += len;
+ return totalLength;
+ });
+ if (totalLength !== tensor.shape[0]) {
+ throw new Error(`Expected sum of lengths to be equal to
+ tensor.shape[0], but sum of lengths is
+ ${totalLength}, and tensor's shape is: ${tensor.shape}`);
+ }
+ if (!this.dynamicSize && length.length !== this.maxSize) {
+ throw new Error(`TensorArray's size is not equal to the size of lengths (${this.maxSize} vs. ${length.length}), ` +
+ 'and the TensorArray is not marked as dynamically resizeable');
+ }
+ const elementPerRow = totalLength === 0 ? 0 : tensor.size / totalLength;
+ const tensors = [];
+ Object(dist["tidy"])(() => {
+ tensor = tensor.reshape([1, totalLength, elementPerRow]);
+ for (let i = 0; i < length.length; ++i) {
+ const previousLength = (i === 0) ? 0 : cumulativeLengths[i - 1];
+ const indices = [0, previousLength, 0];
+ const sizes = [1, length[i], elementPerRow];
+ tensors[i] = Object(dist["slice"])(tensor, indices, sizes).reshape(this.elementShape);
+ }
+ return tensors;
+ });
+ const indices = [];
+ for (let i = 0; i < length.length; i++) {
+ indices[i] = i;
+ }
+ this.writeMany(indices, tensors);
+ }
+}
+tensor_array_TensorArray.nextId = 0;
+//# sourceMappingURL=tensor_array.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/control_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+const control_executor_executeOp = async (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'If':
+ case 'StatelessIf': {
+ const thenFunc = Object(utils["b" /* getParamValue */])('thenBranch', node, tensorMap, context);
+ const elseFunc = Object(utils["b" /* getParamValue */])('elseBranch', node, tensorMap, context);
+ const cond = Object(utils["b" /* getParamValue */])('cond', node, tensorMap, context);
+ const args = Object(utils["b" /* getParamValue */])('args', node, tensorMap, context);
+ const condValue = await cond.data();
+ if (condValue[0]) {
+ return context.functionMap[thenFunc].executeFunctionAsync(args);
+ }
+ else {
+ return context.functionMap[elseFunc].executeFunctionAsync(args);
+ }
+ }
+ case 'While':
+ case 'StatelessWhile': {
+ const bodyFunc = Object(utils["b" /* getParamValue */])('body', node, tensorMap, context);
+ const condFunc = Object(utils["b" /* getParamValue */])('cond', node, tensorMap, context);
+ const args = Object(utils["b" /* getParamValue */])('args', node, tensorMap, context);
+ const condTensor = (await context.functionMap[condFunc].executeFunctionAsync(args))[0];
+ let condValue = await condTensor.data();
+ let result = args;
+ while (condValue[0]) {
+ result =
+ await context.functionMap[bodyFunc].executeFunctionAsync(result);
+ const condTensor = (await context.functionMap[condFunc].executeFunctionAsync(result))[0];
+ condValue = await condTensor.data();
+ }
+ return result;
+ }
+ case 'LoopCond':
+ return [
+ Object(utils["b" /* getParamValue */])('pred', node, tensorMap, context).clone()
+ ];
+ case 'Switch': {
+ const pred = Object(utils["b" /* getParamValue */])('pred', node, tensorMap, context);
+ const data = Object(utils["b" /* getParamValue */])('data', node, tensorMap, context);
+ // Outputs nodes :0 => false, :1 => true
+ return (await pred.data())[0] ? [undefined, data.clone()] :
+ [data.clone(), undefined];
+ }
+ case 'Merge':
+ const inputName = node.inputNames.find(name => Object(utils["c" /* getTensor */])(name, tensorMap, context) !== undefined);
+ return inputName ? [Object(utils["c" /* getTensor */])(inputName, tensorMap, context).clone()] :
+ undefined;
+ case 'Enter':
+ const frameId = Object(utils["b" /* getParamValue */])('frameName', node, tensorMap, context);
+ const data = Object(utils["b" /* getParamValue */])('tensor', node, tensorMap, context);
+ context.enterFrame(frameId);
+ return [data.clone()];
+ case 'Exit':
+ const tensor = Object(utils["b" /* getParamValue */])('tensor', node, tensorMap, context);
+ context.exitFrame();
+ return [tensor.clone()];
+ case 'NextIteration':
+ const input = Object(utils["b" /* getParamValue */])('tensor', node, tensorMap, context);
+ context.nextIteration();
+ return [input.clone()];
+ case 'TensorArrayV3':
+ const size = Object(utils["b" /* getParamValue */])('size', node, tensorMap, context);
+ const dtype = Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context);
+ const elementShape = Object(utils["b" /* getParamValue */])('elementShape', node, tensorMap, context);
+ const dynamicSize = Object(utils["b" /* getParamValue */])('dynamicSize', node, tensorMap, context);
+ const clearAfterRead = Object(utils["b" /* getParamValue */])('clearAfterRead', node, tensorMap, context);
+ const identicalElementShapes = Object(utils["b" /* getParamValue */])('identicalElementShapes', node, tensorMap, context);
+ const name = Object(utils["b" /* getParamValue */])('name', node, tensorMap, context);
+ const tensorArray = new tensor_array_TensorArray(name, dtype, size, elementShape, identicalElementShapes, dynamicSize, clearAfterRead);
+ context.addTensorArray(tensorArray);
+ return [Object(dist["scalar"])(tensorArray.id), Object(dist["scalar"])(1.0)];
+ case 'TensorArrayWriteV3':
+ const id = Object(utils["b" /* getParamValue */])('tensorArrayId', node, tensorMap, context);
+ const index = Object(utils["b" /* getParamValue */])('index', node, tensorMap, context);
+ const writeTensor = Object(utils["b" /* getParamValue */])('tensor', node, tensorMap, context);
+ const writeTensorArray = context.getTensorArray(id);
+ writeTensorArray.write(index, writeTensor);
+ return [Object(dist["scalar"])(1.0)];
+ case 'TensorArrayReadV3':
+ const readId = Object(utils["b" /* getParamValue */])('tensorArrayId', node, tensorMap, context);
+ const readIndex = Object(utils["b" /* getParamValue */])('index', node, tensorMap, context);
+ const readTensorArray = context.getTensorArray(readId);
+ return [readTensorArray.read(readIndex)];
+ case 'TensorArrayGatherV3':
+ const gatherId = Object(utils["b" /* getParamValue */])('tensorArrayId', node, tensorMap, context);
+ const gatherIndices = Object(utils["b" /* getParamValue */])('indices', node, tensorMap, context);
+ const gatherDtype = Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context);
+ const gatherTensorArray = context.getTensorArray(gatherId);
+ return [gatherTensorArray.gather(gatherIndices, gatherDtype)];
+ case 'TensorArrayScatterV3':
+ const scatterId = Object(utils["b" /* getParamValue */])('tensorArrayId', node, tensorMap, context);
+ const scatterIndices = Object(utils["b" /* getParamValue */])('indices', node, tensorMap, context);
+ const scatterTensor = Object(utils["b" /* getParamValue */])('tensor', node, tensorMap, context);
+ const scatterTensorArray = context.getTensorArray(scatterId);
+ scatterTensorArray.scatter(scatterIndices, scatterTensor);
+ return [Object(dist["scalar"])(1.0)];
+ case 'TensorArrayConcatV3':
+ const concatId = Object(utils["b" /* getParamValue */])('tensorArrayId', node, tensorMap, context);
+ const concatTensorArray = context.getTensorArray(concatId);
+ const concatDtype = Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context);
+ return [concatTensorArray.concat(concatDtype)];
+ case 'TensorArraySplitV3':
+ const splitId = Object(utils["b" /* getParamValue */])('tensorArrayId', node, tensorMap, context);
+ const splitTensor = Object(utils["b" /* getParamValue */])('tensor', node, tensorMap, context);
+ const lengths = Object(utils["b" /* getParamValue */])('lengths', node, tensorMap, context);
+ const splitTensorArray = context.getTensorArray(splitId);
+ splitTensorArray.split(lengths, splitTensor);
+ return [Object(dist["scalar"])(1.0)];
+ case 'TensorArraySizeV3':
+ const sizeId = Object(utils["b" /* getParamValue */])('tensorArrayId', node, tensorMap, context);
+ const sizeTensorArray = context.getTensorArray(sizeId);
+ return [Object(dist["scalar"])(sizeTensorArray.size(), 'int32')];
+ case 'TensorArrayCloseV3':
+ const closeId = Object(utils["b" /* getParamValue */])('tensorArrayId', node, tensorMap, context);
+ const closeTensorArray = context.getTensorArray(closeId);
+ closeTensorArray.clearAndClose();
+ return [Object(dist["scalar"])(0)];
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const control_executor_CATEGORY = 'control';
+//# sourceMappingURL=control_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/convolution_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const convolution_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'Conv1D': {
+ const stride = Object(utils["b" /* getParamValue */])('stride', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const dataFormat = Object(utils["b" /* getParamValue */])('dataFormat', node, tensorMap, context)
+ .toUpperCase();
+ const dilation = Object(utils["b" /* getParamValue */])('dilation', node, tensorMap, context);
+ return [dist["conv1d"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('filter', node, tensorMap, context), stride, pad, dataFormat, dilation)];
+ }
+ case 'Conv2D': {
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const dataFormat = Object(utils["b" /* getParamValue */])('dataFormat', node, tensorMap, context)
+ .toUpperCase();
+ const dilations = Object(utils["b" /* getParamValue */])('dilations', node, tensorMap, context);
+ return [dist["conv2d"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('filter', node, tensorMap, context), [stride[1], stride[2]], pad, dataFormat, [dilations[1], dilations[2]])];
+ }
+ case '_FusedConv2D':
+ case 'FusedDepthwiseConv2dNative': {
+ const [extraOp, activationFunc] = Object(utils["b" /* getParamValue */])('fusedOps', node, tensorMap, context);
+ const isBiasAdd = extraOp === 'biasadd';
+ const isPrelu = activationFunc === 'prelu';
+ const isBatchNorm = extraOp === 'fusedbatchnorm';
+ const numArgs = Object(utils["b" /* getParamValue */])('numArgs', node, tensorMap, context);
+ if (isBiasAdd) {
+ if (isPrelu && numArgs !== 2) {
+ throw new Error('FusedConv2d and DepthwiseConv2d with BiasAdd and Prelu ' +
+ 'must have two extra arguments: bias and alpha.');
+ }
+ if (!isPrelu && numArgs !== 1) {
+ throw new Error('FusedConv2d and DepthwiseConv2d with BiasAdd must have ' +
+ 'one extra argument: bias.');
+ }
+ }
+ if (isBatchNorm) {
+ throw new Error('FusedConv2d and DepthwiseConv2d with FusedBatchNorm is not supported.');
+ }
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const dataFormat = Object(utils["b" /* getParamValue */])('dataFormat', node, tensorMap, context)
+ .toUpperCase();
+ const dilations = Object(utils["b" /* getParamValue */])('dilations', node, tensorMap, context);
+ const [biasArg, preluArg] = Object(utils["b" /* getParamValue */])('args', node, tensorMap, context);
+ const kernelMethod = node.op === '_FusedConv2D' ?
+ dist["fused"].conv2d :
+ dist["fused"].depthwiseConv2d;
+ return [kernelMethod({
+ x: Object(utils["b" /* getParamValue */])('x', node, tensorMap, context),
+ filter: Object(utils["b" /* getParamValue */])('filter', node, tensorMap, context),
+ strides: [stride[1], stride[2]],
+ pad: pad,
+ dataFormat: dataFormat,
+ dilations: [dilations[1], dilations[2]],
+ bias: biasArg,
+ activation: activationFunc,
+ preluActivationWeights: preluArg
+ })];
+ }
+ case 'Conv2DBackpropInput':
+ case 'Conv2dTranspose': {
+ const shape = Object(utils["b" /* getParamValue */])('outputShape', node, tensorMap, context);
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ return [dist["conv2dTranspose"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('filter', node, tensorMap, context), shape, [stride[1], stride[2]], pad)];
+ }
+ case 'DepthwiseConv2dNative':
+ case 'DepthwiseConv2d': {
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const dilations = Object(utils["b" /* getParamValue */])('dilations', node, tensorMap, context);
+ const dataFormat = Object(utils["b" /* getParamValue */])('dataFormat', node, tensorMap, context)
+ .toUpperCase();
+ return [dist["depthwiseConv2d"](Object(utils["b" /* getParamValue */])('input', node, tensorMap, context), Object(utils["b" /* getParamValue */])('filter', node, tensorMap, context), [stride[1], stride[2]], pad, dataFormat, [dilations[1], dilations[2]])];
+ }
+ case 'Conv3D': {
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const dataFormat = Object(utils["b" /* getParamValue */])('dataFormat', node, tensorMap, context)
+ .toUpperCase();
+ const dilations = Object(utils["b" /* getParamValue */])('dilations', node, tensorMap, context);
+ return [dist["conv3d"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('filter', node, tensorMap, context), [stride[1], stride[2], stride[3]], pad, dataFormat, [dilations[1], dilations[2], dilations[3]])];
+ }
+ case 'AvgPool': {
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const kernelSize = Object(utils["b" /* getParamValue */])('kernelSize', node, tensorMap, context);
+ return [dist["avgPool"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), [kernelSize[1], kernelSize[2]], [stride[1], stride[2]], pad)];
+ }
+ case 'MaxPool': {
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const kernelSize = Object(utils["b" /* getParamValue */])('kernelSize', node, tensorMap, context);
+ return [dist["maxPool"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), [kernelSize[1], kernelSize[2]], [stride[1], stride[2]], pad)];
+ }
+ case 'MaxPoolWithArgmax': {
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const kernelSize = Object(utils["b" /* getParamValue */])('kernelSize', node, tensorMap, context);
+ const includeBatchInIndex = Object(utils["b" /* getParamValue */])('includeBatchInIndex', node, tensorMap, context);
+ const { result, indexes } = dist["maxPoolWithArgmax"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), [kernelSize[1], kernelSize[2]], [stride[1], stride[2]], pad, includeBatchInIndex);
+ return [result, indexes];
+ }
+ case 'AvgPool3D': {
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const kernelSize = Object(utils["b" /* getParamValue */])('kernelSize', node, tensorMap, context);
+ return [dist["avgPool3d"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), [kernelSize[1], kernelSize[2], kernelSize[3]], [stride[1], stride[2], stride[3]], pad)];
+ }
+ case 'MaxPool3D': {
+ const stride = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const pad = Object(utils["b" /* getParamValue */])('pad', node, tensorMap, context);
+ const kernelSize = Object(utils["b" /* getParamValue */])('kernelSize', node, tensorMap, context);
+ return [dist["maxPool3d"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), [kernelSize[1], kernelSize[2], kernelSize[3]], [stride[1], stride[2], stride[3]], pad)];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const convolution_executor_CATEGORY = 'convolution';
+//# sourceMappingURL=convolution_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/creation_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const creation_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'Fill': {
+ const shape = Object(utils["b" /* getParamValue */])('shape', node, tensorMap, context);
+ const dtype = Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context);
+ const value = Object(utils["b" /* getParamValue */])('value', node, tensorMap, context);
+ return [dist["fill"](shape, value, dtype)];
+ }
+ case 'LinSpace': {
+ const start = Object(utils["b" /* getParamValue */])('start', node, tensorMap, context);
+ const stop = Object(utils["b" /* getParamValue */])('stop', node, tensorMap, context);
+ const num = Object(utils["b" /* getParamValue */])('num', node, tensorMap, context);
+ return [dist["linspace"](start, stop, num)];
+ }
+ case 'Multinomial': {
+ const logits = Object(utils["b" /* getParamValue */])('logits', node, tensorMap, context);
+ const numSamples = Object(utils["b" /* getParamValue */])('numSamples', node, tensorMap, context);
+ const seed = Object(utils["b" /* getParamValue */])('seed', node, tensorMap, context);
+ return [dist["multinomial"](logits, numSamples, seed)];
+ }
+ case 'OneHot': {
+ const indices = Object(utils["b" /* getParamValue */])('indices', node, tensorMap, context);
+ const depth = Object(utils["b" /* getParamValue */])('depth', node, tensorMap, context);
+ const onValue = Object(utils["b" /* getParamValue */])('onValue', node, tensorMap, context);
+ const offValue = Object(utils["b" /* getParamValue */])('offValue', node, tensorMap, context);
+ return [dist["oneHot"](indices, depth, onValue, offValue)];
+ }
+ case 'Ones': {
+ return [dist["ones"](Object(utils["b" /* getParamValue */])('shape', node, tensorMap, context), Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context))];
+ }
+ case 'OnesLike': {
+ return [dist["onesLike"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'RandomUniform': {
+ return [dist["randomUniform"](
+ // tslint:disable-next-line:no-any
+ Object(utils["b" /* getParamValue */])('shape', node, tensorMap, context), Object(utils["b" /* getParamValue */])('minval', node, tensorMap, context), Object(utils["b" /* getParamValue */])('maxval', node, tensorMap, context), Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context))];
+ }
+ case 'Range': {
+ const start = Object(utils["b" /* getParamValue */])('start', node, tensorMap, context);
+ const stop = Object(utils["b" /* getParamValue */])('stop', node, tensorMap, context);
+ const step = Object(utils["b" /* getParamValue */])('step', node, tensorMap, context);
+ return [dist["range"](start, stop, step, Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context))];
+ }
+ case 'TruncatedNormal': {
+ const shape = Object(utils["b" /* getParamValue */])('shape', node, tensorMap, context);
+ const mean = Object(utils["b" /* getParamValue */])('mean', node, tensorMap, context);
+ const stdDev = Object(utils["b" /* getParamValue */])('stdDev', node, tensorMap, context);
+ const seed = Object(utils["b" /* getParamValue */])('seed', node, tensorMap, context);
+ return [dist["truncatedNormal"](shape, mean, stdDev, Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context), seed)];
+ }
+ case 'Zeros': {
+ return [dist["zeros"](Object(utils["b" /* getParamValue */])('shape', node, tensorMap, context), Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context))];
+ }
+ case 'ZerosLike': {
+ return [dist["zerosLike"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const creation_executor_CATEGORY = 'creation';
+//# sourceMappingURL=creation_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/dynamic_executor.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const dynamic_executor_executeOp = async (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'NonMaxSuppressionV5':
+ case 'NonMaxSuppressionV3':
+ case 'NonMaxSuppressionV2': {
+ const boxes = Object(utils["b" /* getParamValue */])('boxes', node, tensorMap, context);
+ const scores = Object(utils["b" /* getParamValue */])('scores', node, tensorMap, context);
+ const maxOutputSize = Object(utils["b" /* getParamValue */])('maxOutputSize', node, tensorMap, context);
+ const iouThreshold = Object(utils["b" /* getParamValue */])('iouThreshold', node, tensorMap, context);
+ const scoreThreshold = Object(utils["b" /* getParamValue */])('scoreThreshold', node, tensorMap, context);
+ if (node.op === 'NonMaxSuppressionV5') {
+ const softNmsSigma = Object(utils["b" /* getParamValue */])('softNmsSigma', node, tensorMap, context);
+ const result = await dist["image"].nonMaxSuppressionWithScoreAsync(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma);
+ return [result.selectedIndices, result.selectedScores];
+ }
+ return [await dist["image"].nonMaxSuppressionAsync(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold)];
+ }
+ case 'Where': {
+ const condition = Object(utils["b" /* getParamValue */])('condition', node, tensorMap, context)
+ .asType('bool');
+ const result = [await dist["whereAsync"](condition)];
+ condition.dispose();
+ return result;
+ }
+ case 'ListDiff': {
+ return dist["setdiff1dAsync"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('y', node, tensorMap, context));
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const dynamic_executor_CATEGORY = 'dynamic';
+//# sourceMappingURL=dynamic_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/evaluation_executor.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const evaluation_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'TopKV2': {
+ const x = Object(utils["b" /* getParamValue */])('x', node, tensorMap, context);
+ const k = Object(utils["b" /* getParamValue */])('k', node, tensorMap, context);
+ const sorted = Object(utils["b" /* getParamValue */])('sorted', node, tensorMap, context);
+ const result = dist["topk"](x, k, sorted);
+ return [result.values, result.indices];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const evaluation_executor_CATEGORY = 'evaluation';
+//# sourceMappingURL=evaluation_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/graph_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const graph_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'Const': {
+ return tensorMap[node.name];
+ }
+ case 'PlaceholderWithDefault':
+ const def = Object(utils["b" /* getParamValue */])('default', node, tensorMap, context);
+ return [Object(utils["c" /* getTensor */])(node.name, tensorMap, context) || def];
+ case 'Placeholder':
+ return [Object(utils["c" /* getTensor */])(node.name, tensorMap, context)];
+ case 'Identity':
+ case 'StopGradient':
+ case 'FakeQuantWithMinMaxVars': // This op is currently ignored.
+ return [
+ Object(utils["b" /* getParamValue */])('x', node, tensorMap, context).clone()
+ ];
+ case 'IdentityN':
+ return Object(utils["b" /* getParamValue */])('x', node, tensorMap, context)
+ .map((t) => t.clone());
+ case 'Snapshot':
+ const snapshot = Object(utils["b" /* getParamValue */])('x', node, tensorMap, context);
+ return [snapshot.clone()];
+ case 'Shape':
+ return [dist["tensor1d"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context).shape, 'int32')];
+ case 'ShapeN':
+ return Object(utils["b" /* getParamValue */])('x', node, tensorMap, context)
+ .map((t) => dist["tensor1d"](t.shape));
+ case 'Size':
+ return [dist["scalar"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context).size, 'int32')];
+ case 'Rank':
+ return [dist["scalar"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context).rank, 'int32')];
+ case 'NoOp':
+ return [dist["scalar"](1)];
+ case 'Print':
+ const input = Object(utils["b" /* getParamValue */])('x', node, tensorMap, context);
+ const data = Object(utils["b" /* getParamValue */])('data', node, tensorMap, context);
+ const message = Object(utils["b" /* getParamValue */])('message', node, tensorMap, context);
+ const summarize = Object(utils["b" /* getParamValue */])('summarize', node, tensorMap, context);
+ console.warn('The graph has a tf.print() operation,' +
+ 'usually used for debugging, which slows down performance.');
+ console.log(message);
+ for (let i = 0; i < data.length; i++) {
+ console.log(Array.prototype.slice.call(data[i].dataSync()).slice(0, summarize));
+ }
+ return [input];
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const graph_executor_CATEGORY = 'graph';
+//# sourceMappingURL=graph_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/image_executor.js
+/**
+ * @license
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const image_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'ResizeBilinear': {
+ const images = Object(utils["b" /* getParamValue */])('images', node, tensorMap, context);
+ const size = Object(utils["b" /* getParamValue */])('size', node, tensorMap, context);
+ const alignCorners = Object(utils["b" /* getParamValue */])('alignCorners', node, tensorMap, context);
+ return [dist["image"].resizeBilinear(images, [size[0], size[1]], alignCorners)];
+ }
+ case 'ResizeNearestNeighbor': {
+ const images = Object(utils["b" /* getParamValue */])('images', node, tensorMap, context);
+ const size = Object(utils["b" /* getParamValue */])('size', node, tensorMap, context);
+ const alignCorners = Object(utils["b" /* getParamValue */])('alignCorners', node, tensorMap, context);
+ return [dist["image"].resizeNearestNeighbor(images, [size[0], size[1]], alignCorners)];
+ }
+ case 'CropAndResize': {
+ const image = Object(utils["b" /* getParamValue */])('image', node, tensorMap, context);
+ const boxes = Object(utils["b" /* getParamValue */])('boxes', node, tensorMap, context);
+ const boxInd = Object(utils["b" /* getParamValue */])('boxInd', node, tensorMap, context);
+ const cropSize = Object(utils["b" /* getParamValue */])('cropSize', node, tensorMap, context);
+ const method = Object(utils["b" /* getParamValue */])('method', node, tensorMap, context);
+ const extrapolationValue = Object(utils["b" /* getParamValue */])('extrapolationValue', node, tensorMap, context);
+ return [dist["image"].cropAndResize(image, boxes, boxInd, cropSize, method, extrapolationValue)];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const image_executor_CATEGORY = 'image';
+//# sourceMappingURL=image_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/logical_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const logical_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'Equal': {
+ return [dist["equal"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'NotEqual': {
+ return [dist["notEqual"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'Greater': {
+ return [dist["greater"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'GreaterEqual': {
+ return [dist["greaterEqual"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'Less': {
+ return [dist["less"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'LessEqual': {
+ return [dist["lessEqual"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'LogicalAnd': {
+ return [dist["logicalAnd"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'LogicalNot': {
+ return [dist["logicalNot"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context))];
+ }
+ case 'LogicalOr': {
+ return [dist["logicalOr"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ case 'Select':
+ case 'SelectV2': {
+ return [dist["where"](Object(utils["b" /* getParamValue */])('condition', node, tensorMap, context), Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context))];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const logical_executor_CATEGORY = 'logical';
+//# sourceMappingURL=logical_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/matrices_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const matrices_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'BatchMatMul':
+ case 'BatchMatMulV2':
+ case 'MatMul':
+ return [dist["matMul"](Object(utils["b" /* getParamValue */])('a', node, tensorMap, context), Object(utils["b" /* getParamValue */])('b', node, tensorMap, context), Object(utils["b" /* getParamValue */])('transposeA', node, tensorMap, context), Object(utils["b" /* getParamValue */])('transposeB', node, tensorMap, context))];
+ case 'Transpose':
+ return [dist["transpose"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('perm', node, tensorMap, context))];
+ case '_FusedMatMul':
+ const [extraOp, activationFunc] = Object(utils["b" /* getParamValue */])('fusedOps', node, tensorMap, context);
+ const isBiasAdd = extraOp === 'biasadd';
+ const isPrelu = activationFunc === 'prelu';
+ const numArgs = Object(utils["b" /* getParamValue */])('numArgs', node, tensorMap, context);
+ if (isBiasAdd) {
+ if (isPrelu && numArgs !== 2) {
+ throw new Error('Fused MatMul with BiasAdd and Prelu must have two ' +
+ 'extra arguments: bias and alpha.');
+ }
+ if (!isPrelu && numArgs !== 1) {
+ throw new Error('Fused MatMul with BiasAdd must have one extra argument: bias.');
+ }
+ }
+ const [biasArg, preluArg] = Object(utils["b" /* getParamValue */])('args', node, tensorMap, context);
+ return [dist["fused"].matMul({
+ a: Object(utils["b" /* getParamValue */])('a', node, tensorMap, context),
+ b: Object(utils["b" /* getParamValue */])('b', node, tensorMap, context),
+ transposeA: Object(utils["b" /* getParamValue */])('transposeA', node, tensorMap, context),
+ transposeB: Object(utils["b" /* getParamValue */])('transposeB', node, tensorMap, context),
+ bias: biasArg,
+ activation: activationFunc,
+ preluActivationWeights: preluArg
+ })];
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const matrices_executor_CATEGORY = 'matrices';
+//# sourceMappingURL=matrices_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/normalization_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const normalization_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'FusedBatchNorm':
+ case 'FusedBatchNormV2': {
+ return [dist["batchNorm"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('mean', node, tensorMap, context), Object(utils["b" /* getParamValue */])('variance', node, tensorMap, context), Object(utils["b" /* getParamValue */])('offset', node, tensorMap, context), Object(utils["b" /* getParamValue */])('scale', node, tensorMap, context), Object(utils["b" /* getParamValue */])('epsilon', node, tensorMap, context))];
+ }
+ case 'FusedBatchNormV3': {
+ return [dist["batchNorm"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('mean', node, tensorMap, context), Object(utils["b" /* getParamValue */])('variance', node, tensorMap, context), Object(utils["b" /* getParamValue */])('offset', node, tensorMap, context), Object(utils["b" /* getParamValue */])('scale', node, tensorMap, context), Object(utils["b" /* getParamValue */])('epsilon', node, tensorMap, context))];
+ }
+ case 'LRN': {
+ return [dist["localResponseNormalization"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('radius', node, tensorMap, context), Object(utils["b" /* getParamValue */])('bias', node, tensorMap, context), Object(utils["b" /* getParamValue */])('alpha', node, tensorMap, context), Object(utils["b" /* getParamValue */])('beta', node, tensorMap, context))];
+ }
+ case 'Softmax': {
+ return [dist["softmax"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'LogSoftmax': {
+ return [dist["logSoftmax"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'SparseToDense': {
+ return [dist["sparseToDense"](Object(utils["b" /* getParamValue */])('sparseIndices', node, tensorMap, context), Object(utils["b" /* getParamValue */])('outputShape', node, tensorMap, context), Object(utils["b" /* getParamValue */])('sparseValues', node, tensorMap, context), Object(utils["b" /* getParamValue */])('defaultValue', node, tensorMap, context))];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const normalization_executor_CATEGORY = 'normalization';
+//# sourceMappingURL=normalization_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/reduction_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const reduction_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'Max': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const keepDims = Object(utils["b" /* getParamValue */])('keepDims', node, tensorMap, context);
+ return [dist["max"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis, keepDims)];
+ }
+ case 'Mean': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const keepDims = Object(utils["b" /* getParamValue */])('keepDims', node, tensorMap, context);
+ return [dist["mean"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis, keepDims)];
+ }
+ case 'Min': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const keepDims = Object(utils["b" /* getParamValue */])('keepDims', node, tensorMap, context);
+ return [dist["min"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis, keepDims)];
+ }
+ case 'Sum': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const keepDims = Object(utils["b" /* getParamValue */])('keepDims', node, tensorMap, context);
+ return [dist["sum"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis, keepDims)];
+ }
+ case 'All': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const keepDims = Object(utils["b" /* getParamValue */])('keepDims', node, tensorMap, context);
+ return [dist["all"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis, keepDims)];
+ }
+ case 'Any': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const keepDims = Object(utils["b" /* getParamValue */])('keepDims', node, tensorMap, context);
+ return [dist["any"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis, keepDims)];
+ }
+ case 'ArgMax': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ return [dist["argMax"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis)];
+ }
+ case 'ArgMin': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ return [dist["argMin"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis)];
+ }
+ case 'Prod': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const keepDims = Object(utils["b" /* getParamValue */])('keepDims', node, tensorMap, context);
+ return [dist["prod"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis, keepDims)];
+ }
+ case 'Cumsum': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const exclusive = Object(utils["b" /* getParamValue */])('exclusive', node, tensorMap, context);
+ const reverse = Object(utils["b" /* getParamValue */])('reverse', node, tensorMap, context);
+ return [dist["cumsum"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis, exclusive, reverse)];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const reduction_executor_CATEGORY = 'reduction';
+//# sourceMappingURL=reduction_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/slice_join_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const slice_join_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'ConcatV2':
+ case 'Concat': {
+ const n = Object(utils["b" /* getParamValue */])('n', node, tensorMap, context);
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ let inputs = Object(utils["b" /* getParamValue */])('tensors', node, tensorMap, context);
+ inputs = inputs.slice(0, n);
+ return [dist["concat"](inputs, axis)];
+ }
+ case 'GatherV2':
+ case 'Gather': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const input = Object(utils["b" /* getParamValue */])('x', node, tensorMap, context);
+ const indices = Object(utils["b" /* getParamValue */])('indices', node, tensorMap, context);
+ return [dist["gather"](input, indices.asType('int32'), axis)];
+ }
+ case 'ReverseV2':
+ case 'Reverse': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const input = Object(utils["b" /* getParamValue */])('x', node, tensorMap, context);
+ return [dist["reverse"](input, axis)];
+ }
+ case 'Slice': {
+ // tslint:disable-next-line:no-any
+ const begin = Object(utils["b" /* getParamValue */])('begin', node, tensorMap, context);
+ // tslint:disable-next-line:no-any
+ const size = Object(utils["b" /* getParamValue */])('size', node, tensorMap, context);
+ return [dist["slice"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), begin, size)];
+ }
+ case 'StridedSlice': {
+ const begin = Object(utils["b" /* getParamValue */])('begin', node, tensorMap, context);
+ const end = Object(utils["b" /* getParamValue */])('end', node, tensorMap, context);
+ const strides = Object(utils["b" /* getParamValue */])('strides', node, tensorMap, context);
+ const beginMask = Object(utils["b" /* getParamValue */])('beginMask', node, tensorMap, context);
+ const endMask = Object(utils["b" /* getParamValue */])('endMask', node, tensorMap, context);
+ const ellipsisMask = Object(utils["b" /* getParamValue */])('ellipsisMask', node, tensorMap, context);
+ const newAxisMask = Object(utils["b" /* getParamValue */])('newAxisMask', node, tensorMap, context);
+ const shrinkAxisMask = Object(utils["b" /* getParamValue */])('shrinkAxisMask', node, tensorMap, context);
+ const tensor = Object(utils["b" /* getParamValue */])('x', node, tensorMap, context);
+ if (begin.length === 1 && tensor.shape.length > 1) {
+ for (let i = 1; i < tensor.shape.length; i++) {
+ begin.push(0);
+ end.push(tensor.shape[i]);
+ strides.push(strides[0]);
+ }
+ }
+ return [dist["stridedSlice"](tensor, begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask)];
+ }
+ case 'Pack': {
+ return dist["tidy"](() => {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const tensors = Object(utils["b" /* getParamValue */])('tensors', node, tensorMap, context);
+ // Reshape the tensors to the first tensor's shape if they don't match.
+ const shape = tensors[0].shape;
+ const squeezedShape = tensors[0].squeeze().shape;
+ const mapped = tensors.map(tensor => {
+ const sameShape = dist["util"].arraysEqual(tensor.shape, shape);
+ if (!sameShape &&
+ !dist["util"].arraysEqual(tensor.squeeze().shape, squeezedShape)) {
+ throw new Error('the input tensors shape does not match');
+ }
+ return sameShape ? tensor : tensor.reshape(shape);
+ });
+ return [dist["stack"](mapped, axis)];
+ });
+ }
+ case 'Unpack': {
+ return dist["tidy"](() => {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const tensor = Object(utils["b" /* getParamValue */])('tensor', node, tensorMap, context);
+ return dist["unstack"](tensor, axis);
+ });
+ }
+ case 'Tile': {
+ const reps = Object(utils["b" /* getParamValue */])('reps', node, tensorMap, context);
+ return [dist["tile"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), reps)];
+ }
+ case 'Split':
+ case 'SplitV': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ const numOrSizeSplits = Object(utils["b" /* getParamValue */])('numOrSizeSplits', node, tensorMap, context);
+ return dist["split"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), numOrSizeSplits, axis);
+ }
+ case 'ScatterNd': {
+ const indices = Object(utils["b" /* getParamValue */])('indices', node, tensorMap, context);
+ const values = Object(utils["b" /* getParamValue */])('values', node, tensorMap, context);
+ const shape = Object(utils["b" /* getParamValue */])('shape', node, tensorMap, context);
+ return [dist["scatterND"](indices, values, shape)];
+ }
+ case 'GatherNd': {
+ const x = Object(utils["b" /* getParamValue */])('x', node, tensorMap, context);
+ const indices = Object(utils["b" /* getParamValue */])('indices', node, tensorMap, context);
+ return [dist["gatherND"](x, indices)];
+ }
+ case 'SparseToDense': {
+ const indices = Object(utils["b" /* getParamValue */])('sparseIndices', node, tensorMap, context);
+ const shape = Object(utils["b" /* getParamValue */])('outputShape', node, tensorMap, context);
+ const sparseValues = Object(utils["b" /* getParamValue */])('sparseValues', node, tensorMap, context);
+ const defaultValue = Object(utils["b" /* getParamValue */])('defaultValue', node, tensorMap, context);
+ return [dist["sparseToDense"](indices, sparseValues, shape, sparseValues.dtype === defaultValue.dtype ?
+ defaultValue :
+ defaultValue.asType(sparseValues.dtype))];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const slice_join_executor_CATEGORY = 'slice_join';
+//# sourceMappingURL=slice_join_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/spectral_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const spectral_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'FFT': {
+ return [dist["fft"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'IFFT': {
+ return [dist["ifft"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'RFFT': {
+ return [dist["rfft"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ case 'IRFFT': {
+ return [dist["irfft"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context))];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const spectral_executor_CATEGORY = 'spectral';
+//# sourceMappingURL=spectral_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/executors/transformation_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const transformation_executor_executeOp = (node, tensorMap, context) => {
+ switch (node.op) {
+ case 'Cast': {
+ return [dist["cast"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('dtype', node, tensorMap, context))];
+ }
+ case 'ExpandDims': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ return [dist["expandDims"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis)];
+ }
+ case 'Squeeze': {
+ const axis = Object(utils["b" /* getParamValue */])('axis', node, tensorMap, context);
+ return [dist["squeeze"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), axis)];
+ }
+ case 'Reshape': {
+ return [dist["reshape"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('shape', node, tensorMap, context))];
+ }
+ case 'PadV2':
+ case 'Pad': {
+ return [dist["pad"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["f" /* split */])(Object(utils["b" /* getParamValue */])('padding', node, tensorMap, context), 2), Object(utils["b" /* getParamValue */])('constantValue', node, tensorMap, context))];
+ }
+ case 'SpaceToBatchND': {
+ const blockShape = Object(utils["b" /* getParamValue */])('blockShape', node, tensorMap, context);
+ const paddings = Object(utils["f" /* split */])(Object(utils["b" /* getParamValue */])('paddings', node, tensorMap, context), 2);
+ return [dist["spaceToBatchND"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), blockShape, paddings)];
+ }
+ case 'BatchToSpaceND': {
+ const blockShape = Object(utils["b" /* getParamValue */])('blockShape', node, tensorMap, context);
+ const crops = Object(utils["f" /* split */])(Object(utils["b" /* getParamValue */])('crops', node, tensorMap, context), 2);
+ return [dist["batchToSpaceND"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), blockShape, crops)];
+ }
+ case 'DepthToSpace': {
+ const blockSize = Object(utils["b" /* getParamValue */])('blockSize', node, tensorMap, context);
+ const dataFormat = Object(utils["b" /* getParamValue */])('dataFormat', node, tensorMap, context).toUpperCase();
+ return [dist["depthToSpace"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), blockSize, dataFormat)];
+ }
+ case 'BroadcastTo': {
+ return [dist["broadcastTo"](Object(utils["b" /* getParamValue */])('x', node, tensorMap, context), Object(utils["b" /* getParamValue */])('shape', node, tensorMap, context))];
+ }
+ default:
+ throw TypeError(`Node type ${node.op} is not implemented`);
+ }
+};
+const transformation_executor_CATEGORY = 'transformation';
+//# sourceMappingURL=transformation_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/operations/operation_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Executes the op defined by the node object.
+ * @param node
+ * @param tensorMap contains tensors for executed nodes and weights
+ */
+function operation_executor_executeOp(node, tensorMap, context) {
+ const value = ((node, tensorMap, context) => {
+ switch (node.category) {
+ case 'arithmetic':
+ return dist["tidy"](() => executeOp(node, tensorMap, context));
+ case 'basic_math':
+ return dist["tidy"](() => basic_math_executor_executeOp(node, tensorMap, context));
+ case 'control':
+ return control_executor_executeOp(node, tensorMap, context);
+ case 'convolution':
+ return dist["tidy"](() => convolution_executor_executeOp(node, tensorMap, context));
+ case 'creation':
+ return dist["tidy"](() => creation_executor_executeOp(node, tensorMap, context));
+ case 'dynamic':
+ return dynamic_executor_executeOp(node, tensorMap, context);
+ case 'evaluation':
+ return dist["tidy"](() => evaluation_executor_executeOp(node, tensorMap, context));
+ case 'image':
+ return dist["tidy"](() => image_executor_executeOp(node, tensorMap, context));
+ case 'graph':
+ return dist["tidy"](() => graph_executor_executeOp(node, tensorMap, context));
+ case 'logical':
+ return dist["tidy"](() => logical_executor_executeOp(node, tensorMap, context));
+ case 'matrices':
+ return dist["tidy"](() => matrices_executor_executeOp(node, tensorMap, context));
+ case 'normalization':
+ return dist["tidy"](() => normalization_executor_executeOp(node, tensorMap, context));
+ case 'reduction':
+ return dist["tidy"](() => reduction_executor_executeOp(node, tensorMap, context));
+ case 'slice_join':
+ return dist["tidy"](() => slice_join_executor_executeOp(node, tensorMap, context));
+ case 'spectral':
+ return dist["tidy"](() => spectral_executor_executeOp(node, tensorMap, context));
+ case 'transformation':
+ return dist["tidy"](() => transformation_executor_executeOp(node, tensorMap, context));
+ case 'custom':
+ const opMapper = Object(register["b" /* getRegisteredOp */])(node.op);
+ if (opMapper && opMapper.customExecutor) {
+ return opMapper.customExecutor(new node_value_impl_NodeValueImpl(node, tensorMap, context));
+ }
+ else {
+ throw TypeError(`Custom op ${node.op} is not registered.`);
+ }
+ default:
+ throw TypeError(`Unknown op '${node.op}'. File an issue at ` +
+ `https://github.com/tensorflow/tfjs/issues so we can add it` +
+ `, or register a custom execution with tf.registerOp()`);
+ }
+ })(node, tensorMap, context);
+ if (value instanceof Promise) {
+ return value.then((data) => [].concat(data));
+ }
+ return [].concat(value);
+}
+//# sourceMappingURL=operation_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/executor/execution_context.js
+/**
+ * ExecutionContext captures the runtime environment of the node. It keeps
+ * track of the current frame and iteration for the control flow ops.
+ *
+ * For example, typical Dynamic RNN model may contain loops, for which
+ * TensorFlow will generate graphs with Enter/Exit nodes to control the
+ * current execution frame, and NextIteration Nodes for iteration id increment.
+ * For model with branch logic, TensorFLow will generate Switch/Merge ops.
+ */
+class ExecutionContext {
+ constructor(weightMap, tensorArrayMap, functionMap = {}) {
+ this.weightMap = weightMap;
+ this.tensorArrayMap = tensorArrayMap;
+ this.functionMap = functionMap;
+ this.rootContext = { id: 0, frameName: '', iterationId: 0 };
+ this.contexts = [this.rootContext];
+ this.lastId = 0;
+ this.generateCurrentContextIds();
+ }
+ newFrame(id, frameName) {
+ return { id, frameName, iterationId: 0 };
+ }
+ /**
+ * Set the current context
+ * @param contexts: ExecutionContextInfo[] the current path of execution
+ * frames
+ */
+ set currentContext(contexts) {
+ if (this.contexts !== contexts) {
+ this.contexts = contexts;
+ this.generateCurrentContextIds();
+ }
+ }
+ get currentContext() {
+ return this.contexts;
+ }
+ /**
+ * Returns the current context in string format.
+ */
+ get currentContextId() {
+ return this._currentContextIds[0];
+ }
+ /**
+ * Returns the current context and all parent contexts in string format.
+ * This allow access to the nodes in the current and parent frames.
+ */
+ get currentContextIds() {
+ return this._currentContextIds;
+ }
+ generateCurrentContextIds() {
+ const names = [];
+ for (let i = 0; i < this.contexts.length - 1; i++) {
+ const contexts = this.contexts.slice(0, this.contexts.length - i);
+ names.push(this.contextIdforContexts(contexts));
+ }
+ names.push('');
+ this._currentContextIds = names;
+ }
+ contextIdforContexts(contexts) {
+ return contexts ?
+ contexts
+ .map(context => (context.id === 0 && context.iterationId === 0) ?
+ '' :
+ `${context.frameName}-${context.iterationId}`)
+ .join('/') :
+ '';
+ }
+ /**
+ * Enter a new frame, a new context is pushed on the current context list.
+ * @param frameId new frame id
+ */
+ enterFrame(frameId) {
+ if (this.contexts) {
+ this.lastId++;
+ this.contexts = this.contexts.slice();
+ this.contexts.push(this.newFrame(this.lastId, frameId));
+ this._currentContextIds.unshift(this.contextIdforContexts(this.contexts));
+ }
+ }
+ /**
+ * Exit the current frame, the last context is removed from the current
+ * context list.
+ */
+ exitFrame() {
+ if (this.contexts && this.contexts.length > 1) {
+ this.contexts = this.contexts.slice();
+ this.contexts.splice(-1);
+ this.currentContextIds.shift();
+ }
+ else {
+ throw new Error('Cannot exit frame, the context is empty');
+ }
+ }
+ /**
+ * Enter the next iteration of a loop, the iteration id of last context is
+ * increased.
+ */
+ nextIteration() {
+ if (this.contexts && this.contexts.length > 0) {
+ this.contexts = this.contexts.slice();
+ this.lastId++;
+ const context = Object.assign({}, this.contexts[this.contexts.length - 1]);
+ context.iterationId += 1;
+ context.id = this.lastId;
+ this.contexts.splice(-1, 1, context);
+ this._currentContextIds.splice(0, 1, this.contextIdforContexts(this.contexts));
+ }
+ else {
+ throw new Error('Cannot increase frame iteration, the context is empty');
+ }
+ }
+ getWeight(name) {
+ return this.weightMap[name];
+ }
+ addTensorArray(tensorArray) {
+ this.tensorArrayMap[tensorArray.id] = tensorArray;
+ }
+ getTensorArray(id) {
+ return this.tensorArrayMap[id];
+ }
+}
+//# sourceMappingURL=execution_context.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/executor/model_analysis.js
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+/**
+ * Given graph inputs and desired outputs, find the minimal set of nodes
+ * to execute in order to compute the outputs. In addition return other useful
+ * info such:
+ * - Missing inputs needed to compute the output.
+ * - Whether the subgraph contains dynamic ops (control flow, dynamic shape).
+ * - Alternative inputs in order to avoid async (dynamic op) execution.
+ */
+function getExecutionSubgraph(inputs, outputs, weightMap) {
+ const usedNodes = new Set();
+ const missingInputs = [];
+ let dynamicNode = null;
+ let syncInputs = null;
+ // Start with the outputs, going backwards and find all the nodes that are
+ // needed to compute those outputs.
+ const seen = new Set();
+ const inputNodeNames = Object.keys(inputs).map(name => Object(utils["e" /* parseNodeName */])(name)[0]);
+ const frontier = [...outputs];
+ while (frontier.length > 0) {
+ const node = frontier.pop();
+ if (isControlFlow(node) || isDynamicShape(node)) {
+ if (dynamicNode == null) {
+ dynamicNode = node;
+ syncInputs = dynamicNode.children.map(child => child.name)
+ .filter(name => usedNodes.has(name));
+ }
+ }
+ usedNodes.add(node.name);
+ // Weights are dead end since we already have their values.
+ if (weightMap[node.name] != null) {
+ continue;
+ }
+ // This node is a dead end since it's one of the user-provided inputs.
+ if (inputNodeNames.indexOf(node.name) !== -1) {
+ continue;
+ }
+ if (node.inputs.length === 0) {
+ missingInputs.push(node.name);
+ continue;
+ }
+ node.inputs.forEach(input => {
+ // Don't add to the frontier if it is already there.
+ if (seen.has(input.name)) {
+ return;
+ }
+ seen.add(input.name);
+ frontier.push(input);
+ });
+ }
+ return { inputs, outputs, usedNodes, missingInputs, dynamicNode, syncInputs };
+}
+/**
+ * Given the execution info, return a list of nodes in topological order that
+ * need to be executed to compute the output.
+ */
+function getNodesInTopologicalOrder(graph, weightMap, executionInfo) {
+ const { usedNodes, inputs } = executionInfo;
+ const frontier = [];
+ const inputNodes = Object.keys(inputs)
+ .map(name => Object(utils["e" /* parseNodeName */])(name)[0])
+ .map(name => graph.nodes[name]);
+ inputNodes.forEach(input => {
+ if (usedNodes.has(input.name)) {
+ frontier.push(input);
+ }
+ });
+ graph.weights.forEach(weight => {
+ if (usedNodes.has(weight.name)) {
+ frontier.push(weight);
+ }
+ });
+ const seen = new Set();
+ const orderedNodes = [];
+ while (frontier.length > 0) {
+ const node = frontier.pop();
+ seen.add(node.name);
+ if (!weightMap[node.name]) {
+ orderedNodes.push(node);
+ }
+ node.children.forEach(child => {
+ if (!seen.has(child.name) && usedNodes.has(child.name) &&
+ child.inputs.every(input => seen.has(input.name))) {
+ frontier.push(child);
+ }
+ });
+ }
+ return orderedNodes;
+}
+const CONTROL_FLOW_OPS = [
+ 'Switch', 'Merge', 'Enter', 'Exit', 'NextIteration', 'StatelessIf',
+ 'StatelessWhile'
+];
+const DYNAMIC_SHAPE_OPS = [
+ 'NonMaxSuppressionV2', 'NonMaxSuppressionV3', 'NonMaxSuppressionV5', 'Where'
+];
+function isControlFlow(node) {
+ return CONTROL_FLOW_OPS.indexOf(node.op) >= 0;
+}
+function isDynamicShape(node) {
+ return DYNAMIC_SHAPE_OPS.indexOf(node.op) >= 0;
+}
+//# sourceMappingURL=model_analysis.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/executor/graph_executor.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+
+
+class graph_executor_GraphExecutor {
+ /**
+ *
+ * @param graph Graph the model or function graph to be executed.
+ * @param parent When building function exector you need to set the parent
+ * executor. Since the weights and function executor maps are set at parant
+ * level, that function executor can access the function maps and weight maps
+ * through the parent.
+ */
+ constructor(graph, parent) {
+ this.graph = graph;
+ this.parent = parent;
+ this.compiledMap = new Map();
+ this._weightMap = {};
+ this.SEPERATOR = ',';
+ this._functions = {};
+ this._functionExecutorMap = {};
+ this._outputs = graph.outputs;
+ this._inputs = graph.inputs;
+ this._signature = graph.signature;
+ this._functions = graph.functions;
+ // create sub-graph executors
+ if (graph.functions != null) {
+ Object.keys(graph.functions).forEach(name => {
+ this._functionExecutorMap[name] =
+ new graph_executor_GraphExecutor(graph.functions[name], this);
+ });
+ }
+ }
+ get weightIds() {
+ return this.parent ? this.parent.weightIds : this._weightIds;
+ }
+ get functionExecutorMap() {
+ return this.parent ? this.parent.functionExecutorMap :
+ this._functionExecutorMap;
+ }
+ get weightMap() {
+ return this.parent ? this.parent.weightMap : this._weightMap;
+ }
+ set weightMap(weightMap) {
+ const weightIds = Object.keys(weightMap).map(key => weightMap[key].map(tensor => tensor.id));
+ this._weightIds = [].concat(...weightIds);
+ this._weightMap = weightMap;
+ }
+ get inputs() {
+ return this._inputs.map(node => {
+ return {
+ name: node.name,
+ shape: node.attrParams['shape'] ?
+ node.attrParams['shape'].value :
+ undefined,
+ dtype: node.attrParams['dtype'] ?
+ node.attrParams['dtype'].value :
+ undefined
+ };
+ });
+ }
+ get outputs() {
+ return this._outputs.map(node => {
+ return {
+ name: node.name,
+ shape: node.attrParams['shape'] ?
+ node.attrParams['shape'].value :
+ undefined,
+ dtype: node.attrParams['dtype'] ?
+ node.attrParams['dtype'].value :
+ undefined
+ };
+ });
+ }
+ get inputNodes() {
+ return this._inputs.map(node => node.signatureKey || node.name);
+ }
+ get outputNodes() {
+ return this._outputs.map((node) => {
+ const name = node.signatureKey || node.name;
+ return node.defaultOutput ? (`${name}:${node.defaultOutput}`) : name;
+ });
+ }
+ get functions() {
+ return Object.keys(this._functions).reduce((map, key) => {
+ map[key] = this._functions[key].signature;
+ return map;
+ }, {});
+ }
+ getCompilationKey(inputs, outputs) {
+ const sortedInputs = inputs.map(node => node.name).sort();
+ const sortedOutputs = outputs.map(node => node.name).sort();
+ return sortedInputs.join(this.SEPERATOR) + '--' +
+ sortedOutputs.join(this.SEPERATOR);
+ }
+ /**
+ * Compiles the inference graph and returns the minimal set of nodes that are
+ * required for execution, in the correct execution order.
+ */
+ compile(inputs, outputs) {
+ const executionInfo = getExecutionSubgraph(inputs, outputs, this.weightMap);
+ const { missingInputs, dynamicNode, syncInputs } = executionInfo;
+ if (dynamicNode != null) {
+ throw new Error(`This execution contains the node '${dynamicNode.name}', which has ` +
+ `the dynamic op '${dynamicNode.op}'. Please use ` +
+ `model.executeAsync() instead. Alternatively, to avoid the ` +
+ `dynamic ops, specify the inputs [${syncInputs}]`);
+ }
+ if (missingInputs.length > 0) {
+ const outNames = outputs.map(n => n.name);
+ const inNames = Object.keys(inputs);
+ throw new Error(`Cannot compute the outputs [${outNames}] from the provided inputs ` +
+ `[${inNames}]. Missing the following inputs: [${missingInputs}]`);
+ }
+ return getNodesInTopologicalOrder(this.graph, this.weightMap, executionInfo);
+ }
+ /**
+ * Executes the inference for given input tensors.
+ * @param inputs Tensor map for the model inputs, keyed by the input node
+ * names.
+ * @param outputs output node name from the Tensorflow model, if no outputs
+ * are specified, the default outputs of the model would be used. You can
+ * inspect intermediate nodes of the model by adding them to the outputs
+ * array.
+ */
+ execute(inputs, outputs) {
+ inputs = this.mapInputs(inputs);
+ const names = Object.keys(inputs).sort();
+ this.checkInputs(inputs);
+ this.checkInputShapeAndType(inputs);
+ outputs = this.mapOutputs(outputs);
+ this.checkOutputs(outputs);
+ const inputNodes = names.map(name => this.graph.nodes[Object(utils["e" /* parseNodeName */])(name)[0]]);
+ const outputNodes = outputs.map(name => this.graph.nodes[Object(utils["e" /* parseNodeName */])(name)[0]]);
+ const compilationKey = this.getCompilationKey(inputNodes, outputNodes);
+ // Do nothing if the compiled graph cache contains the input.
+ let orderedNodes = this.compiledMap.get(compilationKey);
+ if (orderedNodes == null) {
+ orderedNodes = this.compile(inputs, outputNodes);
+ this.compiledMap.set(compilationKey, orderedNodes);
+ }
+ const tensorArrayMap = {};
+ return Object(dist["tidy"])(() => {
+ const context = new ExecutionContext(this.weightMap, tensorArrayMap, this.functionExecutorMap);
+ const tensorsMap = Object.assign({}, this.weightMap);
+ Object.keys(inputs).forEach(name => {
+ const [nodeName, index] = Object(utils["e" /* parseNodeName */])(name);
+ const tensors = [];
+ tensors[index] = inputs[name];
+ tensorsMap[nodeName] = tensors;
+ });
+ const tensorsToKeep = this.getFrozenTensorIds(tensorsMap);
+ const intermediateTensorConsumerCount = {};
+ for (let i = 0; i < orderedNodes.length; i++) {
+ const node = orderedNodes[i];
+ if (!tensorsMap[node.name]) {
+ const tensors = operation_executor_executeOp(node, tensorsMap, context);
+ if (tensors instanceof Promise) {
+ throw new Error(`The execution of the op '${node.op}' returned a promise. ` +
+ `Please use model.executeAsync() instead.`);
+ }
+ tensorsMap[node.name] = tensors;
+ this.checkTensorForDisposal(node.name, node, tensorsMap, context, tensorsToKeep, outputs, intermediateTensorConsumerCount);
+ }
+ }
+ return outputs.map(name => Object(utils["c" /* getTensor */])(name, tensorsMap, context));
+ });
+ }
+ getFrozenTensorIds(tensorMap) {
+ const ids = [].concat.apply([], Object.keys(tensorMap)
+ .map(key => tensorMap[key])
+ .map(tensors => tensors.map(tensor => tensor.id)));
+ return new Set(ids);
+ }
+ checkTensorForDisposal(nodeName, node, tensorMap, context, tensorsToKeep, outputNames, intermediateTensorConsumerCount) {
+ // Skip output nodes and any control flow nodes, since its dependency is
+ // tricky to track correctly.
+ if (node.category === 'control' || outputNames.indexOf(nodeName) !== -1) {
+ return;
+ }
+ tensorMap[nodeName].forEach(tensor => {
+ if (tensor != null) {
+ intermediateTensorConsumerCount[tensor.id] =
+ (intermediateTensorConsumerCount[tensor.id] || 0) +
+ node.children.length;
+ }
+ });
+ node.inputs.forEach(input => {
+ // Skip any control flow nodes, since its dependency is tricky to track
+ // correctly.
+ if (input.category !== 'control') {
+ const tensors = Object(utils["d" /* getTensorsForCurrentContenxt */])(input.name, tensorMap, context);
+ if (tensors != null) {
+ tensors.forEach(tensor => {
+ if (tensor && !tensorsToKeep.has(tensor.id)) {
+ const count = intermediateTensorConsumerCount[tensor.id];
+ if (count === 1) {
+ tensor.dispose();
+ delete intermediateTensorConsumerCount[tensor.id];
+ }
+ else if (count != null) {
+ // only intermediate nodes has count set, inputs and weights are
+ // not.
+ intermediateTensorConsumerCount[tensor.id]--;
+ }
+ }
+ });
+ }
+ }
+ });
+ }
+ /**
+ * Executes the inference for given input tensors in Async fashion.
+ * @param inputs Tensor map for the model inputs, keyed by the input node
+ * names.
+ * @param outputs output node name from the Tensorflow model, if no outputs
+ * are specified, the default outputs of the model would be used. You can
+ * inspect intermediate nodes of the model by adding them to the outputs
+ * array.
+ * @param disableWarning disable the no dynamic ops warning message, default
+ * to false
+ */
+ async executeAsync(inputs, outputs, disableWarning = false) {
+ inputs = this.mapInputs(inputs);
+ this.checkInputs(inputs);
+ this.checkInputShapeAndType(inputs);
+ outputs = this.mapOutputs(outputs);
+ this.checkOutputs(outputs);
+ const tensorArrayMap = {};
+ const context = new ExecutionContext(this.weightMap, tensorArrayMap, this.functionExecutorMap);
+ // Graph with control flow op requires runtime evaluation of the execution
+ // order, while without control flow the execution order is pre-determined
+ // in the compile method.
+ const tensorMap = await this.executeWithControlFlow(inputs, context, outputs, disableWarning);
+ const results = outputs.map(name => Object(utils["c" /* getTensor */])(name, tensorMap, context));
+ // dispose all the intermediate tensors
+ const outputIds = new Set(results.map(t => t.id));
+ const inputIds = new Set(Object.keys(inputs).map(name => inputs[name].id));
+ Object.keys(tensorMap).forEach(key => {
+ const tensorArray = tensorMap[key];
+ tensorArray.forEach(tensor => {
+ if (tensor && !tensor.isDisposed && !outputIds.has(tensor.id) &&
+ !inputIds.has(tensor.id) &&
+ this.weightIds.indexOf(tensor.id) === -1) {
+ tensor.dispose();
+ }
+ });
+ });
+ return results;
+ }
+ async executeFunctionAsync(inputs) {
+ const mappedInputs = inputs.reduce((map, tensor, index) => {
+ map[this.inputs[index].name] = tensor;
+ return map;
+ }, {});
+ return this.executeAsync(mappedInputs, this.outputNodes, true);
+ }
+ /**
+ * When there are control flow nodes in the graph, the graph execution use
+ * ExecutionContext to keep track of the frames and loop iterators.
+ * @param inputs placeholder tensors for the graph.
+ * @param context the execution context object for current execution.
+ * @param disableWarning disable no async op warning
+ */
+ async executeWithControlFlow(inputs, context, outputNames, disableWarning) {
+ const names = Object.keys(inputs);
+ const inputNodes = names.map(name => this.graph.nodes[Object(utils["e" /* parseNodeName */])(name)[0]]);
+ const outputNodes = outputNames.map(name => this.graph.nodes[Object(utils["e" /* parseNodeName */])(name)[0]]);
+ const { usedNodes, missingInputs, dynamicNode, syncInputs } = getExecutionSubgraph(inputs, outputNodes, this.weightMap);
+ const stack = [...inputNodes, ...this.graph.weights].map(node => {
+ return { node, contexts: context.currentContext };
+ });
+ const tensorsMap = Object.assign({}, this.weightMap);
+ Object.keys(inputs).forEach(name => {
+ const [nodeName, index] = Object(utils["e" /* parseNodeName */])(name);
+ const tensors = [];
+ tensors[index] = inputs[name];
+ tensorsMap[nodeName] = tensors;
+ });
+ const intermediateTensorConsumerCount = {};
+ const tensorsToKeep = this.getFrozenTensorIds(tensorsMap);
+ const added = {};
+ while (stack.length > 0) {
+ const promises = this.processStack(inputNodes, stack, context, tensorsMap, added, tensorsToKeep, outputNames, intermediateTensorConsumerCount, usedNodes);
+ await Promise.all(promises);
+ }
+ if (dynamicNode == null && !disableWarning) {
+ console.warn(`This model execution did not contain any nodes with control flow ` +
+ `or dynamic output shapes. You can use model.execute() instead.`);
+ }
+ const missingOutputs = outputNodes
+ .filter(node => !isControlFlow(node) &&
+ !Object(utils["c" /* getTensor */])(node.name, tensorsMap, context))
+ .map(node => node.name);
+ if (missingOutputs.length > 0) {
+ let alternativeMsg = '';
+ if (dynamicNode != null) {
+ alternativeMsg =
+ `Alternatively, to avoid the dynamic ops, use model.execute() ` +
+ `and specify the inputs [${syncInputs}]`;
+ }
+ throw new Error(`Cannot compute the outputs [${missingOutputs}] from the provided ` +
+ `inputs [${names}]. Consider providing the following inputs: ` +
+ `[${missingInputs}]. ${alternativeMsg}`);
+ }
+ return tensorsMap;
+ }
+ processStack(inputNodes, stack, context, tensorMap, added, tensorsToKeep, outputNames, intermediateTensorConsumerCount, usedNodes) {
+ const promises = [];
+ while (stack.length > 0) {
+ const item = stack.pop();
+ context.currentContext = item.contexts;
+ let nodeName = '';
+ // The tensor of the Enter op with isConstant set should be set
+ // in the parent scope, so it will be available as constant for the
+ // whole loop.
+ if (item.node.op === 'Enter' &&
+ Object(utils["b" /* getParamValue */])('isConstant', item.node, tensorMap, context)) {
+ [nodeName] = Object(utils["a" /* getNodeNameAndIndex */])(item.node.name, context);
+ }
+ // only process nodes that are not provided as input nodes.
+ if (inputNodes.indexOf(item.node) === -1) {
+ const tensors = operation_executor_executeOp(item.node, tensorMap, context);
+ if (!nodeName) {
+ [nodeName] = Object(utils["a" /* getNodeNameAndIndex */])(item.node.name, context);
+ }
+ const currentContext = context.currentContext;
+ if (tensors instanceof Promise) {
+ promises.push(tensors.then(t => {
+ tensorMap[nodeName] = t;
+ context.currentContext = currentContext;
+ this.checkTensorForDisposal(nodeName, item.node, tensorMap, context, tensorsToKeep, outputNames, intermediateTensorConsumerCount);
+ this.processChildNodes(item.node, stack, context, tensorMap, added, usedNodes);
+ return t;
+ }));
+ }
+ else {
+ tensorMap[nodeName] = tensors;
+ this.checkTensorForDisposal(nodeName, item.node, tensorMap, context, tensorsToKeep, outputNames, intermediateTensorConsumerCount);
+ this.processChildNodes(item.node, stack, context, tensorMap, added, usedNodes);
+ }
+ }
+ else {
+ this.processChildNodes(item.node, stack, context, tensorMap, added, usedNodes);
+ }
+ }
+ return promises;
+ }
+ processChildNodes(node, stack, context, tensorMap, added, usedNodes) {
+ node.children.forEach((childNode) => {
+ const [nodeName,] = Object(utils["a" /* getNodeNameAndIndex */])(childNode.name, context);
+ if (added[nodeName] || !usedNodes.has(childNode.name)) {
+ return;
+ }
+ // Merge op can be pushed if any of its inputs has value.
+ if (childNode.op === 'Merge') {
+ if (childNode.inputNames.some(name => {
+ return !!Object(utils["c" /* getTensor */])(name, tensorMap, context);
+ })) {
+ added[nodeName] = true;
+ stack.push({ contexts: context.currentContext, node: childNode });
+ }
+ }
+ else // Otherwise all inputs must to have value.
+ if (childNode.inputNames.every(name => {
+ return !!Object(utils["c" /* getTensor */])(name, tensorMap, context);
+ })) {
+ added[nodeName] = true;
+ stack.push({ contexts: context.currentContext, node: childNode });
+ }
+ });
+ }
+ /**
+ * Releases the memory used by the weight tensors.
+ */
+ dispose() {
+ Object.keys(this.weightMap)
+ .forEach(key => this.weightMap[key].forEach(tensor => tensor.dispose()));
+ }
+ checkInputShapeAndType(inputs) {
+ Object.keys(inputs).forEach(name => {
+ const input = inputs[name];
+ const [nodeName,] = Object(utils["e" /* parseNodeName */])(name);
+ const node = this.graph.nodes[nodeName];
+ if (node.attrParams['shape'] && node.attrParams['shape'].value) {
+ const shape = node.attrParams['shape'].value;
+ const match = shape.length === input.shape.length &&
+ input.shape.every((dim, index) => shape[index] === -1 || shape[index] === dim);
+ dist["util"].assert(match, () => `The shape of dict['${node.name}'] provided in ` +
+ `model.execute(dict) must be [${shape}], but was ` +
+ `[${input.shape}]`);
+ }
+ if (node.attrParams['dtype'] && node.attrParams['dtype'].value) {
+ dist["util"].assert(input.dtype === node.attrParams['dtype'].value, () => `The dtype of dict['${node.name}'] provided in ` +
+ `model.execute(dict) must be ` +
+ `${node.attrParams['dtype'].value}, but was ${input.dtype}`);
+ }
+ });
+ }
+ mapInputs(inputs) {
+ const result = {};
+ for (const inputName in inputs) {
+ if (this._signature != null && this._signature.inputs != null &&
+ this._signature.inputs[inputName] != null) {
+ const tensor = this._signature.inputs[inputName];
+ result[tensor.name] = inputs[inputName];
+ }
+ else {
+ result[inputName] = inputs[inputName];
+ }
+ }
+ return result;
+ }
+ checkInputs(inputs) {
+ const notInGraph = Object.keys(inputs).filter(name => {
+ const [nodeName] = Object(utils["e" /* parseNodeName */])(name);
+ return this.graph.nodes[nodeName] == null;
+ });
+ if (notInGraph.length > 0) {
+ throw new Error(`The dict provided in model.execute(dict) has ` +
+ `keys: [${notInGraph}] that are not part of graph`);
+ }
+ }
+ mapOutputs(outputs) {
+ return outputs.map(name => {
+ if (this._signature != null && this._signature.outputs != null &&
+ this._signature.outputs[name] != null) {
+ const tensor = this._signature.outputs[name];
+ return tensor.name;
+ }
+ return name;
+ }, {});
+ }
+ checkOutputs(outputs) {
+ outputs.forEach(name => {
+ const [normalizedName] = Object(utils["e" /* parseNodeName */])(name);
+ if (!this.graph.nodes[normalizedName]) {
+ throw new Error(`The output '${name}' is not found in the graph`);
+ }
+ });
+ }
+}
+//# sourceMappingURL=graph_executor.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/executor/graph_model.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+const TFHUB_SEARCH_PARAM = '?tfjs-format=file';
+const DEFAULT_MODEL_NAME = 'model.json';
+/**
+ * A `tf.GraphModel` is a directed, acyclic graph built from a
+ * SavedModel GraphDef and allows inference execution.
+ *
+ * A `tf.GraphModel` can only be created by loading from a model converted from
+ * a [TensorFlow SavedModel](https://www.tensorflow.org/guide/saved_model) using
+ * the command line converter tool and loaded via `tf.loadGraphModel`.
+ */
+/** @doc {heading: 'Models', subheading: 'Classes'} */
+class graph_model_GraphModel {
+ /**
+ * @param modelUrl url for the model, or an `io.IOHandler`.
+ * @param weightManifestUrl url for the weight file generated by
+ * scripts/convert.py script.
+ * @param requestOption options for Request, which allows to send credentials
+ * and custom headers.
+ * @param onProgress Optional, progress callback function, fired periodically
+ * before the load is completed.
+ */
+ constructor(modelUrl, loadOptions = {}) {
+ this.modelUrl = modelUrl;
+ this.loadOptions = loadOptions;
+ this.version = 'n/a';
+ if (loadOptions == null) {
+ this.loadOptions = {};
+ }
+ }
+ // Returns the version information for the tensorflow model GraphDef.
+ get modelVersion() {
+ return this.version;
+ }
+ get inputNodes() {
+ return this.executor.inputNodes;
+ }
+ get outputNodes() {
+ return this.executor.outputNodes;
+ }
+ get inputs() {
+ return this.executor.inputs;
+ }
+ get outputs() {
+ return this.executor.outputs;
+ }
+ get weights() {
+ return this.executor.weightMap;
+ }
+ findIOHandler() {
+ const path = this.modelUrl;
+ if (path.load != null) {
+ // Path is an IO Handler.
+ this.handler = path;
+ }
+ else if (this.loadOptions.requestInit != null) {
+ this.handler = dist["io"].browserHTTPRequest(path, this.loadOptions);
+ }
+ else {
+ const handlers = dist["io"].getLoadHandlers(path, this.loadOptions);
+ if (handlers.length === 0) {
+ // For backward compatibility: if no load handler can be found,
+ // assume it is a relative http path.
+ handlers.push(dist["io"].browserHTTPRequest(path, this.loadOptions));
+ }
+ else if (handlers.length > 1) {
+ throw new Error(`Found more than one (${handlers.length}) load handlers for ` +
+ `URL '${[path]}'`);
+ }
+ this.handler = handlers[0];
+ }
+ }
+ /**
+ * Loads the model and weight files, construct the in memory weight map and
+ * compile the inference graph.
+ */
+ async load() {
+ this.findIOHandler();
+ if (this.handler.load == null) {
+ throw new Error('Cannot proceed with model loading because the IOHandler provided ' +
+ 'does not have the `load` method implemented.');
+ }
+ const artifacts = await this.handler.load();
+ return this.loadSync(artifacts);
+ }
+ /**
+ * Synchronously construct the in memory weight map and
+ * compile the inference graph.
+ */
+ /** @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true} */
+ loadSync(artifacts) {
+ this.artifacts = artifacts;
+ const graph = this.artifacts.modelTopology;
+ let signature = {};
+ if (this.artifacts.userDefinedMetadata != null) {
+ signature = // tslint:disable-next-line:no-any
+ this.artifacts.userDefinedMetadata.signature;
+ }
+ this.version = `${graph.versions.producer}.${graph.versions.minConsumer}`;
+ const weightMap = dist["io"].decodeWeights(this.artifacts.weightData, this.artifacts.weightSpecs);
+ this.executor = new graph_executor_GraphExecutor(operation_mapper["a" /* OperationMapper */].Instance.transformGraph(graph, signature));
+ this.executor.weightMap = this.convertTensorMapToTensorsMap(weightMap);
+ return true;
+ }
+ /**
+ * Save the configuration and/or weights of the GraphModel.
+ *
+ * An `IOHandler` is an object that has a `save` method of the proper
+ * signature defined. The `save` method manages the storing or
+ * transmission of serialized data ("artifacts") that represent the
+ * model's topology and weights onto or via a specific medium, such as
+ * file downloads, local storage, IndexedDB in the web browser and HTTP
+ * requests to a server. TensorFlow.js provides `IOHandler`
+ * implementations for a number of frequently used saving mediums, such as
+ * `tf.io.browserDownloads` and `tf.io.browserLocalStorage`. See `tf.io`
+ * for more details.
+ *
+ * This method also allows you to refer to certain types of `IOHandler`s
+ * as URL-like string shortcuts, such as 'localstorage://' and
+ * 'indexeddb://'.
+ *
+ * Example 1: Save `model`'s topology and weights to browser [local
+ * storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage);
+ * then load it back.
+ *
+ * ```js
+ * const modelUrl =
+ * 'https://storage.googleapis.com/tfjs-models/savedmodel/mobilenet_v2_1.0_224/model.json';
+ * const model = await tf.loadGraphModel(modelUrl);
+ * const zeros = tf.zeros([1, 224, 224, 3]);
+ * model.predict(zeros).print();
+ *
+ * const saveResults = await model.save('localstorage://my-model-1');
+ *
+ * const loadedModel = await tf.loadGraphModel('localstorage://my-model-1');
+ * console.log('Prediction from loaded model:');
+ * model.predict(zeros).print();
+ * ```
+ *
+ * @param handlerOrURL An instance of `IOHandler` or a URL-like,
+ * scheme-based string shortcut for `IOHandler`.
+ * @param config Options for saving the model.
+ * @returns A `Promise` of `SaveResult`, which summarizes the result of
+ * the saving, such as byte sizes of the saved artifacts for the model's
+ * topology and weight values.
+ */
+ /**
+ * @doc {heading: 'Models', subheading: 'Classes', ignoreCI: true}
+ */
+ async save(handlerOrURL, config) {
+ if (typeof handlerOrURL === 'string') {
+ const handlers = dist["io"].getSaveHandlers(handlerOrURL);
+ if (handlers.length === 0) {
+ throw new Error(`Cannot find any save handlers for URL '${handlerOrURL}'`);
+ }
+ else if (handlers.length > 1) {
+ throw new Error(`Found more than one (${handlers.length}) save handlers for ` +
+ `URL '${handlerOrURL}'`);
+ }
+ handlerOrURL = handlers[0];
+ }
+ if (handlerOrURL.save == null) {
+ throw new Error('GraphModel.save() cannot proceed because the IOHandler ' +
+ 'provided does not have the `save` attribute defined.');
+ }
+ return handlerOrURL.save(this.artifacts);
+ }
+ /**
+ * Execute the inference for the input tensors.
+ *
+ * @param input The input tensors, when there is single input for the model,
+ * inputs param should be a `tf.Tensor`. For models with mutliple inputs,
+ * inputs params should be in either `tf.Tensor`[] if the input order is
+ * fixed, or otherwise NamedTensorMap format.
+ *
+ * For model with multiple inputs, we recommend you use NamedTensorMap as the
+ * input type, if you use `tf.Tensor`[], the order of the array needs to
+ * follow the
+ * order of inputNodes array. @see {@link GraphModel.inputNodes}
+ *
+ * You can also feed any intermediate nodes using the NamedTensorMap as the
+ * input type. For example, given the graph
+ * InputNode => Intermediate => OutputNode,
+ * you can execute the subgraph Intermediate => OutputNode by calling
+ * model.execute('IntermediateNode' : tf.tensor(...));
+ *
+ * This is useful for models that uses tf.dynamic_rnn, where the intermediate
+ * state needs to be fed manually.
+ *
+ * For batch inference execution, the tensors for each input need to be
+ * concatenated together. For example with mobilenet, the required input shape
+ * is [1, 244, 244, 3], which represents the [batch, height, width, channel].
+ * If we are provide a batched data of 100 images, the input tensor should be
+ * in the shape of [100, 244, 244, 3].
+ *
+ * @param config Prediction configuration for specifying the batch size and
+ * output node names. Currently the batch size option is ignored for graph
+ * model.
+ *
+ * @returns Inference result tensors. The output would be single `tf.Tensor`
+ * if model has single output node, otherwise Tensor[] or NamedTensorMap[]
+ * will be returned for model with multiple outputs.
+ */
+ /** @doc {heading: 'Models', subheading: 'Classes'} */
+ predict(inputs, config) {
+ return this.execute(inputs, this.outputNodes);
+ }
+ normalizeInputs(inputs) {
+ if (!(inputs instanceof dist["Tensor"]) && !Array.isArray(inputs)) {
+ // The input is already a NamedTensorMap.
+ return inputs;
+ }
+ inputs = Array.isArray(inputs) ? inputs : [inputs];
+ if (inputs.length !== this.inputNodes.length) {
+ throw new Error('Input tensor count mismatch,' +
+ `the graph model has ${this.inputNodes.length} placeholders, ` +
+ `while there are ${inputs.length} input tensors.`);
+ }
+ return this.inputNodes.reduce((map, inputName, i) => {
+ map[inputName] = inputs[i];
+ return map;
+ }, {});
+ }
+ normalizeOutputs(outputs) {
+ outputs = outputs || this.outputNodes;
+ return !Array.isArray(outputs) ? [outputs] : outputs;
+ }
+ /**
+ * Executes inference for the model for given input tensors.
+ * @param inputs tensor, tensor array or tensor map of the inputs for the
+ * model, keyed by the input node names.
+ * @param outputs output node name from the Tensorflow model, if no
+ * outputs are specified, the default outputs of the model would be used.
+ * You can inspect intermediate nodes of the model by adding them to the
+ * outputs array.
+ *
+ * @returns A single tensor if provided with a single output or no outputs
+ * are provided and there is only one default output, otherwise return a
+ * tensor array. The order of the tensor array is the same as the outputs
+ * if provided, otherwise the order of outputNodes attribute of the model.
+ */
+ /** @doc {heading: 'Models', subheading: 'Classes'} */
+ execute(inputs, outputs) {
+ inputs = this.normalizeInputs(inputs);
+ outputs = this.normalizeOutputs(outputs);
+ const result = this.executor.execute(inputs, outputs);
+ return result.length > 1 ? result : result[0];
+ }
+ /**
+ * Executes inference for the model for given input tensors in async
+ * fashion, use this method when your model contains control flow ops.
+ * @param inputs tensor, tensor array or tensor map of the inputs for the
+ * model, keyed by the input node names.
+ * @param outputs output node name from the Tensorflow model, if no outputs
+ * are specified, the default outputs of the model would be used. You can
+ * inspect intermediate nodes of the model by adding them to the outputs
+ * array.
+ *
+ * @returns A Promise of single tensor if provided with a single output or
+ * no outputs are provided and there is only one default output, otherwise
+ * return a tensor map.
+ */
+ /** @doc {heading: 'Models', subheading: 'Classes'} */
+ async executeAsync(inputs, outputs) {
+ inputs = this.normalizeInputs(inputs);
+ outputs = this.normalizeOutputs(outputs);
+ const result = await this.executor.executeAsync(inputs, outputs);
+ return result.length > 1 ? result : result[0];
+ }
+ convertTensorMapToTensorsMap(map) {
+ return Object.keys(map).reduce((newMap, key) => {
+ newMap[key] = [map[key]];
+ return newMap;
+ }, {});
+ }
+ /**
+ * Releases the memory used by the weight tensors.
+ */
+ /** @doc {heading: 'Models', subheading: 'Classes'} */
+ dispose() {
+ this.executor.dispose();
+ }
+}
+/**
+ * Load a graph model given a URL to the model definition.
+ *
+ * Example of loading MobileNetV2 from a URL and making a prediction with a
+ * zeros input:
+ *
+ * ```js
+ * const modelUrl =
+ * 'https://storage.googleapis.com/tfjs-models/savedmodel/mobilenet_v2_1.0_224/model.json';
+ * const model = await tf.loadGraphModel(modelUrl);
+ * const zeros = tf.zeros([1, 224, 224, 3]);
+ * model.predict(zeros).print();
+ * ```
+ *
+ * Example of loading MobileNetV2 from a TF Hub URL and making a prediction with
+ * a zeros input:
+ *
+ * ```js
+ * const modelUrl =
+ * 'https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/classification/2';
+ * const model = await tf.loadGraphModel(modelUrl, {fromTFHub: true});
+ * const zeros = tf.zeros([1, 224, 224, 3]);
+ * model.predict(zeros).print();
+ * ```
+ * @param modelUrl The url or an `io.IOHandler` that loads the model.
+ * @param options Options for the HTTP request, which allows to send credentials
+ * and custom headers.
+ */
+/** @doc {heading: 'Models', subheading: 'Loading'} */
+async function loadGraphModel(modelUrl, options = {}) {
+ if (modelUrl == null) {
+ throw new Error('modelUrl in loadGraphModel() cannot be null. Please provide a url ' +
+ 'or an IOHandler that loads the model');
+ }
+ if (options == null) {
+ options = {};
+ }
+ if (options.fromTFHub) {
+ if (modelUrl.load == null) {
+ if (!modelUrl.endsWith('/')) {
+ modelUrl = modelUrl + '/';
+ }
+ modelUrl = `${modelUrl}${DEFAULT_MODEL_NAME}${TFHUB_SEARCH_PARAM}`;
+ }
+ }
+ const model = new graph_model_GraphModel(modelUrl, options);
+ await model.load();
+ return model;
+}
+//# sourceMappingURL=graph_model.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/version.js
+/** @license See the LICENSE file. */
+// This code is auto-generated, do not modify this file!
+const version = '2.0.1';
+
+//# sourceMappingURL=version.js.map
+// CONCATENATED MODULE: ./node_modules/@tensorflow/tfjs-converter/dist/index.js
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+/* 39 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh
+ * @license MIT
+ */
+/* eslint-disable no-proto */
+
+
+
+var base64 = __webpack_require__(65)
+var ieee754 = __webpack_require__(66)
+var isArray = __webpack_require__(67)
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Use Object implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * Due to various browser bugs, sometimes the Object implementation will be used even
+ * when the browser supports typed arrays.
+ *
+ * Note:
+ *
+ * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
+ * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
+ *
+ * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
+ *
+ * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+ * incorrect length in some situations.
+
+ * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
+ * get the Object implementation, which is slower but behaves correctly.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
+ ? global.TYPED_ARRAY_SUPPORT
+ : typedArraySupport()
+
+/*
+ * Export kMaxLength after typed array support is determined.
+ */
+exports.kMaxLength = kMaxLength()
+
+function typedArraySupport () {
+ try {
+ var arr = new Uint8Array(1)
+ arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
+ return arr.foo() === 42 && // typed array instances can be augmented
+ typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
+ arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
+ } catch (e) {
+ return false
+ }
+}
+
+function kMaxLength () {
+ return Buffer.TYPED_ARRAY_SUPPORT
+ ? 0x7fffffff
+ : 0x3fffffff
+}
+
+function createBuffer (that, length) {
+ if (kMaxLength() < length) {
+ throw new RangeError('Invalid typed array length')
+ }
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ // Return an augmented `Uint8Array` instance, for best performance
+ that = new Uint8Array(length)
+ that.__proto__ = Buffer.prototype
+ } else {
+ // Fallback: Return an object instance of the Buffer class
+ if (that === null) {
+ that = new Buffer(length)
+ }
+ that.length = length
+ }
+
+ return that
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+ if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
+ return new Buffer(arg, encodingOrOffset, length)
+ }
+
+ // Common case.
+ if (typeof arg === 'number') {
+ if (typeof encodingOrOffset === 'string') {
+ throw new Error(
+ 'If encoding is specified then the first argument must be a string'
+ )
+ }
+ return allocUnsafe(this, arg)
+ }
+ return from(this, arg, encodingOrOffset, length)
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+// TODO: Legacy, not needed anymore. Remove in next major version.
+Buffer._augment = function (arr) {
+ arr.__proto__ = Buffer.prototype
+ return arr
+}
+
+function from (that, value, encodingOrOffset, length) {
+ if (typeof value === 'number') {
+ throw new TypeError('"value" argument must not be a number')
+ }
+
+ if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+ return fromArrayBuffer(that, value, encodingOrOffset, length)
+ }
+
+ if (typeof value === 'string') {
+ return fromString(that, value, encodingOrOffset)
+ }
+
+ return fromObject(that, value)
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+ return from(null, value, encodingOrOffset, length)
+}
+
+if (Buffer.TYPED_ARRAY_SUPPORT) {
+ Buffer.prototype.__proto__ = Uint8Array.prototype
+ Buffer.__proto__ = Uint8Array
+ if (typeof Symbol !== 'undefined' && Symbol.species &&
+ Buffer[Symbol.species] === Buffer) {
+ // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+ Object.defineProperty(Buffer, Symbol.species, {
+ value: null,
+ configurable: true
+ })
+ }
+}
+
+function assertSize (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('"size" argument must be a number')
+ } else if (size < 0) {
+ throw new RangeError('"size" argument must not be negative')
+ }
+}
+
+function alloc (that, size, fill, encoding) {
+ assertSize(size)
+ if (size <= 0) {
+ return createBuffer(that, size)
+ }
+ if (fill !== undefined) {
+ // Only pay attention to encoding if it's a string. This
+ // prevents accidentally sending in a number that would
+ // be interpretted as a start offset.
+ return typeof encoding === 'string'
+ ? createBuffer(that, size).fill(fill, encoding)
+ : createBuffer(that, size).fill(fill)
+ }
+ return createBuffer(that, size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+ return alloc(null, size, fill, encoding)
+}
+
+function allocUnsafe (that, size) {
+ assertSize(size)
+ that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) {
+ for (var i = 0; i < size; ++i) {
+ that[i] = 0
+ }
+ }
+ return that
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+ return allocUnsafe(null, size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+ return allocUnsafe(null, size)
+}
+
+function fromString (that, string, encoding) {
+ if (typeof encoding !== 'string' || encoding === '') {
+ encoding = 'utf8'
+ }
+
+ if (!Buffer.isEncoding(encoding)) {
+ throw new TypeError('"encoding" must be a valid string encoding')
+ }
+
+ var length = byteLength(string, encoding) | 0
+ that = createBuffer(that, length)
+
+ var actual = that.write(string, encoding)
+
+ if (actual !== length) {
+ // Writing a hex string, for example, that contains invalid characters will
+ // cause everything after the first invalid character to be ignored. (e.g.
+ // 'abxxcd' will be treated as 'ab')
+ that = that.slice(0, actual)
+ }
+
+ return that
+}
+
+function fromArrayLike (that, array) {
+ var length = array.length < 0 ? 0 : checked(array.length) | 0
+ that = createBuffer(that, length)
+ for (var i = 0; i < length; i += 1) {
+ that[i] = array[i] & 255
+ }
+ return that
+}
+
+function fromArrayBuffer (that, array, byteOffset, length) {
+ array.byteLength // this throws if `array` is not a valid ArrayBuffer
+
+ if (byteOffset < 0 || array.byteLength < byteOffset) {
+ throw new RangeError('\'offset\' is out of bounds')
+ }
+
+ if (array.byteLength < byteOffset + (length || 0)) {
+ throw new RangeError('\'length\' is out of bounds')
+ }
+
+ if (byteOffset === undefined && length === undefined) {
+ array = new Uint8Array(array)
+ } else if (length === undefined) {
+ array = new Uint8Array(array, byteOffset)
+ } else {
+ array = new Uint8Array(array, byteOffset, length)
+ }
+
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ // Return an augmented `Uint8Array` instance, for best performance
+ that = array
+ that.__proto__ = Buffer.prototype
+ } else {
+ // Fallback: Return an object instance of the Buffer class
+ that = fromArrayLike(that, array)
+ }
+ return that
+}
+
+function fromObject (that, obj) {
+ if (Buffer.isBuffer(obj)) {
+ var len = checked(obj.length) | 0
+ that = createBuffer(that, len)
+
+ if (that.length === 0) {
+ return that
+ }
+
+ obj.copy(that, 0, 0, len)
+ return that
+ }
+
+ if (obj) {
+ if ((typeof ArrayBuffer !== 'undefined' &&
+ obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
+ if (typeof obj.length !== 'number' || isnan(obj.length)) {
+ return createBuffer(that, 0)
+ }
+ return fromArrayLike(that, obj)
+ }
+
+ if (obj.type === 'Buffer' && isArray(obj.data)) {
+ return fromArrayLike(that, obj.data)
+ }
+ }
+
+ throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
+}
+
+function checked (length) {
+ // Note: cannot use `length < kMaxLength()` here because that fails when
+ // length is NaN (which is otherwise coerced to zero.)
+ if (length >= kMaxLength()) {
+ throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+ 'size: 0x' + kMaxLength().toString(16) + ' bytes')
+ }
+ return length | 0
+}
+
+function SlowBuffer (length) {
+ if (+length != length) { // eslint-disable-line eqeqeq
+ length = 0
+ }
+ return Buffer.alloc(+length)
+}
+
+Buffer.isBuffer = function isBuffer (b) {
+ return !!(b != null && b._isBuffer)
+}
+
+Buffer.compare = function compare (a, b) {
+ if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+ throw new TypeError('Arguments must be Buffers')
+ }
+
+ if (a === b) return 0
+
+ var x = a.length
+ var y = b.length
+
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i]
+ y = b[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+Buffer.isEncoding = function isEncoding (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ case 'base64':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.concat = function concat (list, length) {
+ if (!isArray(list)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+
+ if (list.length === 0) {
+ return Buffer.alloc(0)
+ }
+
+ var i
+ if (length === undefined) {
+ length = 0
+ for (i = 0; i < list.length; ++i) {
+ length += list[i].length
+ }
+ }
+
+ var buffer = Buffer.allocUnsafe(length)
+ var pos = 0
+ for (i = 0; i < list.length; ++i) {
+ var buf = list[i]
+ if (!Buffer.isBuffer(buf)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+ buf.copy(buffer, pos)
+ pos += buf.length
+ }
+ return buffer
+}
+
+function byteLength (string, encoding) {
+ if (Buffer.isBuffer(string)) {
+ return string.length
+ }
+ if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
+ (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
+ return string.byteLength
+ }
+ if (typeof string !== 'string') {
+ string = '' + string
+ }
+
+ var len = string.length
+ if (len === 0) return 0
+
+ // Use a for loop to avoid recursion
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ return len
+ case 'utf8':
+ case 'utf-8':
+ case undefined:
+ return utf8ToBytes(string).length
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return len * 2
+ case 'hex':
+ return len >>> 1
+ case 'base64':
+ return base64ToBytes(string).length
+ default:
+ if (loweredCase) return utf8ToBytes(string).length // assume utf8
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+Buffer.byteLength = byteLength
+
+function slowToString (encoding, start, end) {
+ var loweredCase = false
+
+ // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+ // property of a typed array.
+
+ // This behaves neither like String nor Uint8Array in that we set start/end
+ // to their upper/lower bounds if the value passed is out of range.
+ // undefined is handled specially as per ECMA-262 6th Edition,
+ // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+ if (start === undefined || start < 0) {
+ start = 0
+ }
+ // Return early if start > this.length. Done here to prevent potential uint32
+ // coercion fail below.
+ if (start > this.length) {
+ return ''
+ }
+
+ if (end === undefined || end > this.length) {
+ end = this.length
+ }
+
+ if (end <= 0) {
+ return ''
+ }
+
+ // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+ end >>>= 0
+ start >>>= 0
+
+ if (end <= start) {
+ return ''
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ while (true) {
+ switch (encoding) {
+ case 'hex':
+ return hexSlice(this, start, end)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Slice(this, start, end)
+
+ case 'ascii':
+ return asciiSlice(this, start, end)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Slice(this, start, end)
+
+ case 'base64':
+ return base64Slice(this, start, end)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return utf16leSlice(this, start, end)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = (encoding + '').toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
+// Buffer instances.
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+ var i = b[n]
+ b[n] = b[m]
+ b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+ var len = this.length
+ if (len % 2 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 16-bits')
+ }
+ for (var i = 0; i < len; i += 2) {
+ swap(this, i, i + 1)
+ }
+ return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+ var len = this.length
+ if (len % 4 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 32-bits')
+ }
+ for (var i = 0; i < len; i += 4) {
+ swap(this, i, i + 3)
+ swap(this, i + 1, i + 2)
+ }
+ return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+ var len = this.length
+ if (len % 8 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 64-bits')
+ }
+ for (var i = 0; i < len; i += 8) {
+ swap(this, i, i + 7)
+ swap(this, i + 1, i + 6)
+ swap(this, i + 2, i + 5)
+ swap(this, i + 3, i + 4)
+ }
+ return this
+}
+
+Buffer.prototype.toString = function toString () {
+ var length = this.length | 0
+ if (length === 0) return ''
+ if (arguments.length === 0) return utf8Slice(this, 0, length)
+ return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.equals = function equals (b) {
+ if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+ if (this === b) return true
+ return Buffer.compare(this, b) === 0
+}
+
+Buffer.prototype.inspect = function inspect () {
+ var str = ''
+ var max = exports.INSPECT_MAX_BYTES
+ if (this.length > 0) {
+ str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
+ if (this.length > max) str += ' ... '
+ }
+ return ''
+}
+
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+ if (!Buffer.isBuffer(target)) {
+ throw new TypeError('Argument must be a Buffer')
+ }
+
+ if (start === undefined) {
+ start = 0
+ }
+ if (end === undefined) {
+ end = target ? target.length : 0
+ }
+ if (thisStart === undefined) {
+ thisStart = 0
+ }
+ if (thisEnd === undefined) {
+ thisEnd = this.length
+ }
+
+ if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+ throw new RangeError('out of range index')
+ }
+
+ if (thisStart >= thisEnd && start >= end) {
+ return 0
+ }
+ if (thisStart >= thisEnd) {
+ return -1
+ }
+ if (start >= end) {
+ return 1
+ }
+
+ start >>>= 0
+ end >>>= 0
+ thisStart >>>= 0
+ thisEnd >>>= 0
+
+ if (this === target) return 0
+
+ var x = thisEnd - thisStart
+ var y = end - start
+ var len = Math.min(x, y)
+
+ var thisCopy = this.slice(thisStart, thisEnd)
+ var targetCopy = target.slice(start, end)
+
+ for (var i = 0; i < len; ++i) {
+ if (thisCopy[i] !== targetCopy[i]) {
+ x = thisCopy[i]
+ y = targetCopy[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+ // Empty buffer means no match
+ if (buffer.length === 0) return -1
+
+ // Normalize byteOffset
+ if (typeof byteOffset === 'string') {
+ encoding = byteOffset
+ byteOffset = 0
+ } else if (byteOffset > 0x7fffffff) {
+ byteOffset = 0x7fffffff
+ } else if (byteOffset < -0x80000000) {
+ byteOffset = -0x80000000
+ }
+ byteOffset = +byteOffset // Coerce to Number.
+ if (isNaN(byteOffset)) {
+ // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+ byteOffset = dir ? 0 : (buffer.length - 1)
+ }
+
+ // Normalize byteOffset: negative offsets start from the end of the buffer
+ if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+ if (byteOffset >= buffer.length) {
+ if (dir) return -1
+ else byteOffset = buffer.length - 1
+ } else if (byteOffset < 0) {
+ if (dir) byteOffset = 0
+ else return -1
+ }
+
+ // Normalize val
+ if (typeof val === 'string') {
+ val = Buffer.from(val, encoding)
+ }
+
+ // Finally, search either indexOf (if dir is true) or lastIndexOf
+ if (Buffer.isBuffer(val)) {
+ // Special case: looking for empty string/buffer always fails
+ if (val.length === 0) {
+ return -1
+ }
+ return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+ } else if (typeof val === 'number') {
+ val = val & 0xFF // Search for a byte value [0-255]
+ if (Buffer.TYPED_ARRAY_SUPPORT &&
+ typeof Uint8Array.prototype.indexOf === 'function') {
+ if (dir) {
+ return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+ } else {
+ return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+ }
+ }
+ return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+ }
+
+ throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+ var indexSize = 1
+ var arrLength = arr.length
+ var valLength = val.length
+
+ if (encoding !== undefined) {
+ encoding = String(encoding).toLowerCase()
+ if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+ encoding === 'utf16le' || encoding === 'utf-16le') {
+ if (arr.length < 2 || val.length < 2) {
+ return -1
+ }
+ indexSize = 2
+ arrLength /= 2
+ valLength /= 2
+ byteOffset /= 2
+ }
+ }
+
+ function read (buf, i) {
+ if (indexSize === 1) {
+ return buf[i]
+ } else {
+ return buf.readUInt16BE(i * indexSize)
+ }
+ }
+
+ var i
+ if (dir) {
+ var foundIndex = -1
+ for (i = byteOffset; i < arrLength; i++) {
+ if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+ if (foundIndex === -1) foundIndex = i
+ if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+ } else {
+ if (foundIndex !== -1) i -= i - foundIndex
+ foundIndex = -1
+ }
+ }
+ } else {
+ if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+ for (i = byteOffset; i >= 0; i--) {
+ var found = true
+ for (var j = 0; j < valLength; j++) {
+ if (read(arr, i + j) !== read(val, j)) {
+ found = false
+ break
+ }
+ }
+ if (found) return i
+ }
+ }
+
+ return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+ return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+function hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ // must be an even number of digits
+ var strLen = string.length
+ if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; ++i) {
+ var parsed = parseInt(string.substr(i * 2, 2), 16)
+ if (isNaN(parsed)) return i
+ buf[offset + i] = parsed
+ }
+ return i
+}
+
+function utf8Write (buf, string, offset, length) {
+ return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+function asciiWrite (buf, string, offset, length) {
+ return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
+
+function latin1Write (buf, string, offset, length) {
+ return asciiWrite(buf, string, offset, length)
+}
+
+function base64Write (buf, string, offset, length) {
+ return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
+
+function ucs2Write (buf, string, offset, length) {
+ return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+ // Buffer#write(string)
+ if (offset === undefined) {
+ encoding = 'utf8'
+ length = this.length
+ offset = 0
+ // Buffer#write(string, encoding)
+ } else if (length === undefined && typeof offset === 'string') {
+ encoding = offset
+ length = this.length
+ offset = 0
+ // Buffer#write(string, offset[, length][, encoding])
+ } else if (isFinite(offset)) {
+ offset = offset | 0
+ if (isFinite(length)) {
+ length = length | 0
+ if (encoding === undefined) encoding = 'utf8'
+ } else {
+ encoding = length
+ length = undefined
+ }
+ // legacy write(string, encoding, offset, length) - remove in v0.13
+ } else {
+ throw new Error(
+ 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+ )
+ }
+
+ var remaining = this.length - offset
+ if (length === undefined || length > remaining) length = remaining
+
+ if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+ throw new RangeError('Attempt to write outside buffer bounds')
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'hex':
+ return hexWrite(this, string, offset, length)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Write(this, string, offset, length)
+
+ case 'ascii':
+ return asciiWrite(this, string, offset, length)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Write(this, string, offset, length)
+
+ case 'base64':
+ // Warning: maxLength not taken into account in base64Write
+ return base64Write(this, string, offset, length)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return ucs2Write(this, string, offset, length)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+Buffer.prototype.toJSON = function toJSON () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+function base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function utf8Slice (buf, start, end) {
+ end = Math.min(buf.length, end)
+ var res = []
+
+ var i = start
+ while (i < end) {
+ var firstByte = buf[i]
+ var codePoint = null
+ var bytesPerSequence = (firstByte > 0xEF) ? 4
+ : (firstByte > 0xDF) ? 3
+ : (firstByte > 0xBF) ? 2
+ : 1
+
+ if (i + bytesPerSequence <= end) {
+ var secondByte, thirdByte, fourthByte, tempCodePoint
+
+ switch (bytesPerSequence) {
+ case 1:
+ if (firstByte < 0x80) {
+ codePoint = firstByte
+ }
+ break
+ case 2:
+ secondByte = buf[i + 1]
+ if ((secondByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+ if (tempCodePoint > 0x7F) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 3:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+ if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 4:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ fourthByte = buf[i + 3]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+ if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+ codePoint = tempCodePoint
+ }
+ }
+ }
+ }
+
+ if (codePoint === null) {
+ // we did not generate a valid codePoint so insert a
+ // replacement char (U+FFFD) and advance only 1 byte
+ codePoint = 0xFFFD
+ bytesPerSequence = 1
+ } else if (codePoint > 0xFFFF) {
+ // encode to utf16 (surrogate pair dance)
+ codePoint -= 0x10000
+ res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+ codePoint = 0xDC00 | codePoint & 0x3FF
+ }
+
+ res.push(codePoint)
+ i += bytesPerSequence
+ }
+
+ return decodeCodePointsArray(res)
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
+
+function decodeCodePointsArray (codePoints) {
+ var len = codePoints.length
+ if (len <= MAX_ARGUMENTS_LENGTH) {
+ return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+ }
+
+ // Decode in chunks to avoid "call stack size exceeded".
+ var res = ''
+ var i = 0
+ while (i < len) {
+ res += String.fromCharCode.apply(
+ String,
+ codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+ )
+ }
+ return res
+}
+
+function asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i] & 0x7F)
+ }
+ return ret
+}
+
+function latin1Slice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i])
+ }
+ return ret
+}
+
+function hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; ++i) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+function utf16leSlice (buf, start, end) {
+ var bytes = buf.slice(start, end)
+ var res = ''
+ for (var i = 0; i < bytes.length; i += 2) {
+ res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
+ }
+ return res
+}
+
+Buffer.prototype.slice = function slice (start, end) {
+ var len = this.length
+ start = ~~start
+ end = end === undefined ? len : ~~end
+
+ if (start < 0) {
+ start += len
+ if (start < 0) start = 0
+ } else if (start > len) {
+ start = len
+ }
+
+ if (end < 0) {
+ end += len
+ if (end < 0) end = 0
+ } else if (end > len) {
+ end = len
+ }
+
+ if (end < start) end = start
+
+ var newBuf
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ newBuf = this.subarray(start, end)
+ newBuf.__proto__ = Buffer.prototype
+ } else {
+ var sliceLen = end - start
+ newBuf = new Buffer(sliceLen, undefined)
+ for (var i = 0; i < sliceLen; ++i) {
+ newBuf[i] = this[i + start]
+ }
+ }
+
+ return newBuf
+}
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+ if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+ if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
+
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ checkOffset(offset, byteLength, this.length)
+ }
+
+ var val = this[offset + --byteLength]
+ var mul = 1
+ while (byteLength > 0 && (mul *= 0x100)) {
+ val += this[offset + --byteLength] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return ((this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16)) +
+ (this[offset + 3] * 0x1000000)
+}
+
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] * 0x1000000) +
+ ((this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ this[offset + 3])
+}
+
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var i = byteLength
+ var mul = 1
+ var val = this[offset + --i]
+ while (i > 0 && (mul *= 0x100)) {
+ val += this[offset + --i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ if (!(this[offset] & 0x80)) return (this[offset])
+ return ((0xff - this[offset] + 1) * -1)
+}
+
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset] | (this[offset + 1] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset + 1] | (this[offset] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16) |
+ (this[offset + 3] << 24)
+}
+
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] << 24) |
+ (this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ (this[offset + 3])
+}
+
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, false, 52, 8)
+}
+
+function checkInt (buf, value, offset, ext, max, min) {
+ if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+ if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
+
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var mul = 1
+ var i = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ byteLength = byteLength | 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+function objectWriteUInt16 (buf, value, offset, littleEndian) {
+ if (value < 0) value = 0xffff + value + 1
+ for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
+ buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+ (littleEndian ? i : 1 - i) * 8
+ }
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ } else {
+ objectWriteUInt16(this, value, offset, true)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ } else {
+ objectWriteUInt16(this, value, offset, false)
+ }
+ return offset + 2
+}
+
+function objectWriteUInt32 (buf, value, offset, littleEndian) {
+ if (value < 0) value = 0xffffffff + value + 1
+ for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
+ buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+ }
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset + 3] = (value >>> 24)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 1] = (value >>> 8)
+ this[offset] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, true)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, false)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) {
+ var limit = Math.pow(2, 8 * byteLength - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = 0
+ var mul = 1
+ var sub = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) {
+ var limit = Math.pow(2, 8 * byteLength - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ var sub = 0
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+ if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
+ if (value < 0) value = 0xff + value + 1
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ } else {
+ objectWriteUInt16(this, value, offset, true)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ } else {
+ objectWriteUInt16(this, value, offset, false)
+ }
+ return offset + 2
+}
+
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 3] = (value >>> 24)
+ } else {
+ objectWriteUInt32(this, value, offset, true)
+ }
+ return offset + 4
+}
+
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset | 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (value < 0) value = 0xffffffff + value + 1
+ if (Buffer.TYPED_ARRAY_SUPPORT) {
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ } else {
+ objectWriteUInt32(this, value, offset, false)
+ }
+ return offset + 4
+}
+
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+ if (offset < 0) throw new RangeError('Index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+ return offset + 4
+}
+
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, false, noAssert)
+}
+
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+ return offset + 8
+}
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, false, noAssert)
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (targetStart >= target.length) targetStart = target.length
+ if (!targetStart) targetStart = 0
+ if (end > 0 && end < start) end = start
+
+ // Copy 0 bytes; we're done
+ if (end === start) return 0
+ if (target.length === 0 || this.length === 0) return 0
+
+ // Fatal error conditions
+ if (targetStart < 0) {
+ throw new RangeError('targetStart out of bounds')
+ }
+ if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
+ if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+ // Are we oob?
+ if (end > this.length) end = this.length
+ if (target.length - targetStart < end - start) {
+ end = target.length - targetStart + start
+ }
+
+ var len = end - start
+ var i
+
+ if (this === target && start < targetStart && targetStart < end) {
+ // descending copy from end
+ for (i = len - 1; i >= 0; --i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
+ // ascending copy from start
+ for (i = 0; i < len; ++i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else {
+ Uint8Array.prototype.set.call(
+ target,
+ this.subarray(start, start + len),
+ targetStart
+ )
+ }
+
+ return len
+}
+
+// Usage:
+// buffer.fill(number[, offset[, end]])
+// buffer.fill(buffer[, offset[, end]])
+// buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+ // Handle string cases:
+ if (typeof val === 'string') {
+ if (typeof start === 'string') {
+ encoding = start
+ start = 0
+ end = this.length
+ } else if (typeof end === 'string') {
+ encoding = end
+ end = this.length
+ }
+ if (val.length === 1) {
+ var code = val.charCodeAt(0)
+ if (code < 256) {
+ val = code
+ }
+ }
+ if (encoding !== undefined && typeof encoding !== 'string') {
+ throw new TypeError('encoding must be a string')
+ }
+ if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
+ }
+ } else if (typeof val === 'number') {
+ val = val & 255
+ }
+
+ // Invalid ranges are not set to a default, so can range check early.
+ if (start < 0 || this.length < start || this.length < end) {
+ throw new RangeError('Out of range index')
+ }
+
+ if (end <= start) {
+ return this
+ }
+
+ start = start >>> 0
+ end = end === undefined ? this.length : end >>> 0
+
+ if (!val) val = 0
+
+ var i
+ if (typeof val === 'number') {
+ for (i = start; i < end; ++i) {
+ this[i] = val
+ }
+ } else {
+ var bytes = Buffer.isBuffer(val)
+ ? val
+ : utf8ToBytes(new Buffer(val, encoding).toString())
+ var len = bytes.length
+ for (i = 0; i < end - start; ++i) {
+ this[i + start] = bytes[i % len]
+ }
+ }
+
+ return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
+
+function base64clean (str) {
+ // Node strips out invalid characters like \n and \t from the string, base64-js does not
+ str = stringtrim(str).replace(INVALID_BASE64_RE, '')
+ // Node converts strings with length < 2 to ''
+ if (str.length < 2) return ''
+ // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+ while (str.length % 4 !== 0) {
+ str = str + '='
+ }
+ return str
+}
+
+function stringtrim (str) {
+ if (str.trim) return str.trim()
+ return str.replace(/^\s+|\s+$/g, '')
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (string, units) {
+ units = units || Infinity
+ var codePoint
+ var length = string.length
+ var leadSurrogate = null
+ var bytes = []
+
+ for (var i = 0; i < length; ++i) {
+ codePoint = string.charCodeAt(i)
+
+ // is surrogate component
+ if (codePoint > 0xD7FF && codePoint < 0xE000) {
+ // last char was a lead
+ if (!leadSurrogate) {
+ // no lead yet
+ if (codePoint > 0xDBFF) {
+ // unexpected trail
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ } else if (i + 1 === length) {
+ // unpaired lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ }
+
+ // valid lead
+ leadSurrogate = codePoint
+
+ continue
+ }
+
+ // 2 leads in a row
+ if (codePoint < 0xDC00) {
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ leadSurrogate = codePoint
+ continue
+ }
+
+ // valid surrogate pair
+ codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+ } else if (leadSurrogate) {
+ // valid bmp char, but last char was a lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ }
+
+ leadSurrogate = null
+
+ // encode utf8
+ if (codePoint < 0x80) {
+ if ((units -= 1) < 0) break
+ bytes.push(codePoint)
+ } else if (codePoint < 0x800) {
+ if ((units -= 2) < 0) break
+ bytes.push(
+ codePoint >> 0x6 | 0xC0,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x10000) {
+ if ((units -= 3) < 0) break
+ bytes.push(
+ codePoint >> 0xC | 0xE0,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x110000) {
+ if ((units -= 4) < 0) break
+ bytes.push(
+ codePoint >> 0x12 | 0xF0,
+ codePoint >> 0xC & 0x3F | 0x80,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else {
+ throw new Error('Invalid code point')
+ }
+ }
+
+ return bytes
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function utf16leToBytes (str, units) {
+ var c, hi, lo
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ if ((units -= 2) < 0) break
+
+ c = str.charCodeAt(i)
+ hi = c >> 8
+ lo = c % 256
+ byteArray.push(lo)
+ byteArray.push(hi)
+ }
+
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+ for (var i = 0; i < length; ++i) {
+ if ((i + offset >= dst.length) || (i >= src.length)) break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+function isnan (val) {
+ return val !== val // eslint-disable-line no-self-compare
+}
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(27)))
+
+/***/ }),
+/* 40 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(setImmediate) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return nextFrame; });
+/**
+ * @license
+ * Copyright 2017 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const delayCallback = (() => {
+ if (typeof requestAnimationFrame !== 'undefined') {
+ return requestAnimationFrame;
+ }
+ else if (typeof setImmediate !== 'undefined') {
+ return setImmediate;
+ }
+ return (f) => f(); // no delays
+})();
+/**
+ * Returns a promise that resolve when a requestAnimationFrame has completed.
+ *
+ * On Node.js this uses setImmediate instead of requestAnimationFrame.
+ *
+ * This is simply a sugar method so that users can do the following:
+ * `await tf.nextFrame();`
+ */
+/** @doc {heading: 'Performance', subheading: 'Timing'} */
+function nextFrame() {
+ return new Promise(resolve => delayCallback(() => resolve()));
+}
+
+//# sourceMappingURL=browser_util.js.map
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(76).setImmediate))
+
+/***/ }),
+/* 41 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'Add',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'AddV2',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'AddN',
+ 'category': 'arithmetic',
+ 'inputs': [{ 'start': 0, 'end': 0, 'name': 'tensors', 'type': 'tensors' }]
+ },
+ {
+ 'tfOpName': 'BiasAdd',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Sub',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'RealDiv',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Div',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'DivNoNan',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'FloorDiv',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Mul',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Maximum',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' }
+ ]
+ },
+ {
+ 'tfOpName': 'Minimum',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' }
+ ]
+ },
+ {
+ 'tfOpName': 'Pow',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'SquaredDifference',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Mod',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'FloorMod',
+ 'category': 'arithmetic',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ }
+];
+//# sourceMappingURL=arithmetic.js.map
+
+/***/ }),
+/* 42 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'Abs',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Acos',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Asin',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Atan',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Atan2',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'y', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Ceil',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'ClipByValue',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'clip_value_min', 'name': 'clipValueMin', 'type': 'number' },
+ { 'tfName': 'clip_value_max', 'name': 'clipValueMax', 'type': 'number' }
+ ]
+ },
+ {
+ 'tfOpName': 'Complex',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'real', 'type': 'tensor' },
+ { 'start': 1, 'name': 'imag', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'ComplexAbs',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Cos',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Cosh',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Elu',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Exp',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Floor',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Log',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Imag',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }, {
+ 'tfName': 'Tout',
+ 'name': 'outputType',
+ 'type': 'dtype',
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Neg',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Real',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }, {
+ 'tfName': 'Tout',
+ 'name': 'outputType',
+ 'type': 'dtype',
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Prelu',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'alpha', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Relu',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Relu6',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }, {
+ 'tfName': 'clipValueMin',
+ 'name': 'clipValueMin',
+ 'type': 'number',
+ 'defaultValue': 0
+ },
+ {
+ 'tfName': 'clipValueMax',
+ 'name': 'clipValueMax',
+ 'type': 'number',
+ 'defaultValue': 6
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Selu',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Sigmoid',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Sin',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Sinh',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Sqrt',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Rsqrt',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Square',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Tan',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Tanh',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Sign',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Round',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Expm1',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Log1p',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Reciprocal',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Softplus',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Asinh',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Acosh',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Atanh',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Erf',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Prod',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axes', 'type': 'number[]' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'keep_dims',
+ 'name': 'keepDims',
+ 'type': 'bool',
+ 'notSupported': true
+ },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'LeakyRelu',
+ 'category': 'basic_math',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'alpha',
+ 'name': 'alpha',
+ 'type': 'number',
+ 'defaultValue': 0.2
+ },
+ {
+ 'tfName': 'T',
+ 'name': 'dtype',
+ 'type': 'dtype',
+ 'notSupported': true
+ }
+ ]
+ }
+];
+//# sourceMappingURL=basic_math.js.map
+
+/***/ }),
+/* 43 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'LoopCond',
+ 'category': 'control',
+ 'inputs': [{ 'start': 0, 'name': 'pred', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'Switch',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'data', 'type': 'tensor' },
+ { 'start': 1, 'name': 'pred', 'type': 'tensor' }
+ ]
+ },
+ {
+ 'tfOpName': 'Merge',
+ 'category': 'control',
+ 'inputs': [{ 'start': 0, 'end': 0, 'name': 'tensors', 'type': 'tensors' }]
+ },
+ {
+ 'tfOpName': 'Enter',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensor', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true },
+ { 'tfName': 'frame_name', 'name': 'frameName', 'type': 'string' },
+ { 'tfName': 'is_constant', 'name': 'isConstant', 'type': 'bool' }
+ ]
+ },
+ {
+ 'tfOpName': 'Exit',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensor', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'NextIteration',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensor', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'TensorArrayV3',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'size', 'type': 'number' },
+ ],
+ 'attrs': [
+ { 'tfName': 'dtype', 'name': 'dtype', 'type': 'dtype' },
+ { 'tfName': 'element_shape', 'name': 'elementShape', 'type': 'shape' },
+ { 'tfName': 'dynamic_size', 'name': 'dynamicSize', 'type': 'bool' },
+ { 'tfName': 'clear_after_read', 'name': 'clearAfterRead', 'type': 'bool' },
+ {
+ 'tfName': 'identical_element_shapes',
+ 'name': 'identicalElementShapes',
+ 'type': 'bool'
+ },
+ { 'tfName': 'tensor_array_name', 'name': 'name', 'type': 'string' }
+ ]
+ },
+ {
+ 'tfOpName': 'TensorArrayWriteV3',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensorArrayId', 'type': 'number' },
+ { 'start': 1, 'name': 'index', 'type': 'number' },
+ { 'start': 2, 'name': 'tensor', 'type': 'tensor' },
+ { 'start': 3, 'name': 'flowIn', 'type': 'number' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'TensorArrayReadV3',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensorArrayId', 'type': 'number' },
+ { 'start': 1, 'name': 'index', 'type': 'number' },
+ { 'start': 2, 'name': 'flowIn', 'type': 'number' },
+ ],
+ 'attrs': [{
+ 'tfName': 'dtype',
+ 'name': 'dtype',
+ 'type': 'dtype',
+ 'notSupported': true
+ }]
+ },
+ {
+ 'tfOpName': 'TensorArrayGatherV3',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensorArrayId', 'type': 'number' },
+ { 'start': 1, 'name': 'indices', 'type': 'number[]' },
+ { 'start': 2, 'name': 'flowIn', 'type': 'number' },
+ ],
+ 'attrs': [
+ { 'tfName': 'dtype', 'name': 'dtype', 'type': 'dtype' },
+ { 'tfName': 'element_shape', 'name': 'elementShape', 'type': 'shape' }
+ ]
+ },
+ {
+ 'tfOpName': 'TensorArrayScatterV3',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensorArrayId', 'type': 'number' },
+ { 'start': 1, 'name': 'indices', 'type': 'number[]' },
+ { 'start': 2, 'name': 'tensor', 'type': 'tensor' },
+ { 'start': 3, 'name': 'flowIn', 'type': 'number' },
+ ],
+ 'attrs': [{ 'tfName': 'T', 'name': 'dtype', 'type': 'dtype' }]
+ },
+ {
+ 'tfOpName': 'TensorArrayConcatV3',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensorArrayId', 'type': 'number' },
+ { 'start': 1, 'name': 'flowIn', 'type': 'number' },
+ ],
+ 'attrs': [
+ { 'tfName': 'dtype', 'name': 'dtype', 'type': 'dtype' }, {
+ 'tfName': 'element_shape_except0',
+ 'name': 'elementShapeExcept0',
+ 'type': 'shape',
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'TensorArraySplitV3',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensorArrayId', 'type': 'number' },
+ { 'start': 1, 'name': 'tensor', 'type': 'tensor' },
+ { 'start': 2, 'name': 'lengths', 'type': 'number[]' },
+ { 'start': 3, 'name': 'flowIn', 'type': 'number' },
+ ],
+ 'attrs': [{ 'tfName': 'T', 'name': 'dtype', 'type': 'dtype' }]
+ },
+ {
+ 'tfOpName': 'TensorArraySizeV3',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensorArrayId', 'type': 'number' },
+ { 'start': 1, 'name': 'flowIn', 'type': 'number' }
+ ]
+ },
+ {
+ 'tfOpName': 'TensorArrayCloseV3',
+ 'category': 'control',
+ 'inputs': [{ 'start': 0, 'name': 'tensorArrayId', 'type': 'number' }]
+ },
+ {
+ 'tfOpName': 'StatelessIf',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'cond', 'type': 'tensor' },
+ { 'start': 1, 'end': 0, 'name': 'args', 'type': 'tensors' }
+ ],
+ 'attrs': [
+ { 'tfName': 'then_branch', 'name': 'thenBranch', 'type': 'func' },
+ { 'tfName': 'else_branch', 'name': 'elseBranch', 'type': 'func' }
+ ]
+ },
+ {
+ 'tfOpName': 'If',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'name': 'cond', 'type': 'tensor' },
+ { 'start': 1, 'end': 0, 'name': 'args', 'type': 'tensors' }
+ ],
+ 'attrs': [
+ { 'tfName': 'then_branch', 'name': 'thenBranch', 'type': 'func' },
+ { 'tfName': 'else_branch', 'name': 'elseBranch', 'type': 'func' }
+ ]
+ },
+ {
+ 'tfOpName': 'StatelessWhile',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'end': 0, 'name': 'args', 'type': 'tensors' },
+ ],
+ 'attrs': [
+ { 'tfName': 'cond', 'name': 'cond', 'type': 'func' },
+ { 'tfName': 'body', 'name': 'body', 'type': 'func' }
+ ]
+ },
+ {
+ 'tfOpName': 'While',
+ 'category': 'control',
+ 'inputs': [
+ { 'start': 0, 'end': 0, 'name': 'args', 'type': 'tensors' },
+ ],
+ 'attrs': [
+ { 'tfName': 'cond', 'name': 'cond', 'type': 'func' },
+ { 'tfName': 'body', 'name': 'body', 'type': 'func' }
+ ]
+ }
+];
+//# sourceMappingURL=control.js.map
+
+/***/ }),
+/* 44 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'AvgPool',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'notSupported': true
+ },
+ { 'tfName': 'ksize', 'name': 'kernelSize', 'type': 'number[]' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'MaxPool',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'notSupported': true
+ },
+ { 'tfName': 'ksize', 'name': 'kernelSize', 'type': 'number[]' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'MaxPoolWithArgmax',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' },
+ { 'tfName': 'ksize', 'name': 'kernelSize', 'type': 'number[]' }, {
+ 'tfName': 'include_batch_in_index',
+ 'name': 'includeBatchInIndex',
+ 'type': 'bool'
+ },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'AvgPool3D',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'notSupported': true
+ },
+ { 'tfName': 'ksize', 'name': 'kernelSize', 'type': 'number[]' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'MaxPool3D',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'notSupported': true
+ },
+ { 'tfName': 'ksize', 'name': 'kernelSize', 'type': 'number[]' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Conv1D',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'filter', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'stride', 'name': 'stride', 'type': 'number' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'defaultValue': 'NWC'
+ },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }, {
+ 'tfName': 'dilation',
+ 'name': 'dilation',
+ 'type': 'number',
+ 'defaultValue': 1
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Conv2D',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'filter', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true },
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' },
+ { 'tfName': 'useCudnnOnGpu', 'name': 'useCudnnOnGpu', 'type': 'bool' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'defaultValue': 'NHWC'
+ },
+ {
+ 'tfName': 'explicit_paddings',
+ 'name': 'explicitPaddings',
+ 'type': 'number[]',
+ 'defaultValue': []
+ },
+ { 'tfName': 'dilations', 'name': 'dilations', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': '_FusedConv2D',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'filter', 'type': 'tensor' },
+ { 'start': 2, end: 0, 'name': 'args', 'type': 'tensors' },
+ ],
+ 'attrs': [
+ { 'tfName': 'num_args', 'name': 'numArgs', 'type': 'number' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true },
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' },
+ {
+ 'tfName': 'explicit_paddings',
+ 'name': 'explicitPaddings',
+ 'type': 'number[]',
+ 'defaultValue': []
+ },
+ {
+ 'tfName': 'use_cudnn_on_gpu',
+ 'name': 'useCudnnOnGpu',
+ 'type': 'bool',
+ 'defaultValue': true
+ },
+ {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'defaultValue': 'NHWC'
+ },
+ {
+ 'tfName': 'dilations',
+ 'name': 'dilations',
+ 'type': 'number[]',
+ 'defaultValue': [1, 1, 1, 1]
+ },
+ {
+ 'tfName': 'fused_ops',
+ 'name': 'fusedOps',
+ 'type': 'string[]',
+ 'defaultValue': []
+ },
+ {
+ 'tfName': 'epsilon',
+ 'name': 'epsilon',
+ 'type': 'number',
+ 'defaultValue': 0.0001
+ },
+ ]
+ },
+ {
+ 'tfOpName': 'Conv2DBackpropInput',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 2, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'filter', 'type': 'tensor' },
+ { 'start': 0, 'name': 'outputShape', 'type': 'number[]' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' },
+ {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'notSupported': true
+ },
+ {
+ 'tfName': 'explicit_paddings',
+ 'name': 'explicitPaddings',
+ 'type': 'number[]',
+ 'defaultValue': []
+ },
+ ]
+ },
+ {
+ 'tfOpName': 'DepthwiseConv2d',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'input', 'type': 'tensor' },
+ { 'start': 1, 'name': 'filter', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'defaultValue': 'NHWC'
+ },
+ {
+ 'tfName': 'explicit_paddings',
+ 'name': 'explicitPaddings',
+ 'type': 'number[]',
+ 'defaultValue': []
+ },
+ { 'tfName': 'dilations', 'name': 'dilations', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'DepthwiseConv2dNative',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'input', 'type': 'tensor' },
+ { 'start': 1, 'name': 'filter', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'defaultValue': 'NHWC'
+ },
+ {
+ 'tfName': 'explicit_paddings',
+ 'name': 'explicitPaddings',
+ 'type': 'number[]',
+ 'defaultValue': []
+ },
+ { 'tfName': 'dilations', 'name': 'dilations', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'FusedDepthwiseConv2dNative',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'filter', 'type': 'tensor' },
+ { 'start': 2, end: 0, 'name': 'args', 'type': 'tensors' },
+ ],
+ 'attrs': [
+ { 'tfName': 'num_args', 'name': 'numArgs', 'type': 'number' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true },
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'defaultValue': 'NHWC'
+ },
+ {
+ 'tfName': 'dilations',
+ 'name': 'dilations',
+ 'type': 'number[]',
+ 'defaultValue': [1, 1, 1, 1]
+ },
+ {
+ 'tfName': 'fused_ops',
+ 'name': 'fusedOps',
+ 'type': 'string[]',
+ 'defaultValue': []
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Conv3D',
+ 'category': 'convolution',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'filter', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'strides', 'name': 'strides', 'type': 'number[]' },
+ { 'tfName': 'padding', 'name': 'pad', 'type': 'string' }, {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'defaultValue': 'NHWC'
+ },
+ { 'tfName': 'dilations', 'name': 'dilations', 'type': 'number[]' }
+ ],
+ }
+];
+//# sourceMappingURL=convolution.js.map
+
+/***/ }),
+/* 45 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'Fill',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'shape', 'type': 'number[]' },
+ { 'start': 1, 'name': 'value', 'type': 'number' },
+ ],
+ 'attrs': [{ 'tfName': 'T', 'name': 'dtype', 'type': 'dtype' }]
+ },
+ {
+ 'tfOpName': 'LinSpace',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'start', 'type': 'number' },
+ { 'start': 1, 'name': 'stop', 'type': 'number' },
+ { 'start': 2, 'name': 'num', 'type': 'number' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'OneHot',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'indices', 'type': 'tensor' },
+ { 'start': 1, 'name': 'depth', 'type': 'number' },
+ { 'start': 2, 'name': 'onValue', 'type': 'number', 'defaultValue': 1 },
+ { 'start': 3, 'name': 'offValue', 'type': 'number', 'defaultValue': 0 },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'axis',
+ 'name': 'axis',
+ 'type': 'number',
+ 'notSupported': true
+ },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Ones',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'shape', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'T', 'name': 'dtype', 'type': 'dtype' }]
+ },
+ {
+ 'tfOpName': 'OnesLike',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [{ 'tfName': 'dtype', 'name': 'dtype', 'type': 'dtype' }]
+ },
+ {
+ 'tfOpName': 'RandomUniform',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'shape', 'type': 'number[]' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'minval',
+ 'name': 'minval',
+ 'type': 'number',
+ 'defaultValue': 0
+ },
+ {
+ 'tfName': 'maxval',
+ 'name': 'maxval',
+ 'type': 'number',
+ 'defaultValue': 1
+ },
+ { 'tfName': 'dtype', 'name': 'dtype', 'type': 'dtype' },
+ { 'tfName': 'seed', 'name': 'seed', 'type': 'number', 'defaultValue': 0 }, {
+ 'tfName': 'seed2',
+ 'name': 'seed2',
+ 'type': 'number',
+ 'defaultValue': 0,
+ 'notSupported': true
+ },
+ { 'tfName': 'T', 'name': 'T', 'type': 'number', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Range',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'start', 'type': 'number' },
+ { 'start': 1, 'name': 'stop', 'type': 'number' },
+ { 'start': 2, 'name': 'step', 'type': 'number', 'defaultValue': 0 },
+ ],
+ 'attrs': [{ 'tfName': 'Tidx', 'name': 'dtype', 'type': 'dtype' }]
+ },
+ {
+ 'tfOpName': 'TruncatedNormal',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'shape', 'type': 'number[]' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'means',
+ 'name': 'mean',
+ 'type': 'number',
+ 'defaultValue': 0.0
+ },
+ {
+ 'tfName': 'stddev',
+ 'name': 'stdDev',
+ 'type': 'number',
+ 'defaultValue': 1.0
+ },
+ { 'tfName': 'seed', 'name': 'seed', 'type': 'number' }, {
+ 'tfName': 'seed2',
+ 'name': 'seed2',
+ 'type': 'number',
+ 'defaultValue': 0,
+ 'notSupported': true
+ },
+ { 'tfName': 'dtype', 'name': 'dtype', 'type': 'dtype' },
+ { 'tfName': 'T', 'name': 'T', 'type': 'number', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Zeros',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'shape', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'T', 'name': 'dtype', 'type': 'dtype' }]
+ },
+ {
+ 'tfOpName': 'ZerosLike',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [{ 'tfName': 'T', 'name': 'dtype', 'type': 'dtype' }]
+ },
+ {
+ 'tfOpName': 'Multinomial',
+ 'category': 'creation',
+ 'inputs': [
+ { 'start': 0, 'name': 'logits', 'type': 'tensor' },
+ { 'start': 1, 'name': 'numSamples', 'type': 'number' },
+ ],
+ 'attrs': [
+ { 'tfName': 'seed', 'name': 'seed', 'type': 'number' },
+ { 'tfName': 'seed2', 'name': 'seed2', 'type': 'number' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype' },
+ { 'tfName': 'output_dtype', 'name': 'output_dtype', 'type': 'dtype' }
+ ]
+ }
+];
+//# sourceMappingURL=creation.js.map
+
+/***/ }),
+/* 46 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'NonMaxSuppressionV2',
+ 'category': 'dynamic',
+ 'inputs': [
+ { 'start': 0, 'name': 'boxes', 'type': 'tensor' },
+ { 'start': 1, 'name': 'scores', 'type': 'tensor' },
+ { 'start': 2, 'name': 'maxOutputSize', 'type': 'number' },
+ { 'start': 3, 'name': 'iouThreshold', 'type': 'number' }
+ ]
+ },
+ {
+ 'tfOpName': 'NonMaxSuppressionV3',
+ 'category': 'dynamic',
+ 'inputs': [
+ { 'start': 0, 'name': 'boxes', 'type': 'tensor' },
+ { 'start': 1, 'name': 'scores', 'type': 'tensor' },
+ { 'start': 2, 'name': 'maxOutputSize', 'type': 'number' },
+ { 'start': 3, 'name': 'iouThreshold', 'type': 'number' },
+ { 'start': 4, 'name': 'scoreThreshold', 'type': 'number' }
+ ]
+ },
+ {
+ 'tfOpName': 'NonMaxSuppressionV5',
+ 'category': 'dynamic',
+ 'inputs': [
+ { 'start': 0, 'name': 'boxes', 'type': 'tensor' },
+ { 'start': 1, 'name': 'scores', 'type': 'tensor' },
+ { 'start': 2, 'name': 'maxOutputSize', 'type': 'number' },
+ { 'start': 3, 'name': 'iouThreshold', 'type': 'number' },
+ { 'start': 4, 'name': 'scoreThreshold', 'type': 'number' },
+ { 'start': 5, 'name': 'softNmsSigma', 'type': 'number' }
+ ]
+ },
+ {
+ 'tfOpName': 'Where',
+ 'category': 'dynamic',
+ 'inputs': [
+ { 'start': 0, 'name': 'condition', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'ListDiff',
+ 'category': 'dynamic',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'y', 'type': 'tensor' },
+ ],
+ 'attrs': [{
+ 'tfName': 'T',
+ 'name': 'dtype',
+ 'type': 'dtype',
+ 'notSupported': true
+ }]
+ }
+];
+//# sourceMappingURL=dynamic.js.map
+
+/***/ }),
+/* 47 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [{
+ 'tfOpName': 'TopKV2',
+ 'category': 'evaluation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'k', 'type': 'number' },
+ ],
+ 'attrs': [{ 'tfName': 'sorted', 'name': 'sorted', 'type': 'bool' }]
+ }];
+//# sourceMappingURL=evaluation.js.map
+
+/***/ }),
+/* 48 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'PlaceholderWithDefault',
+ 'category': 'graph',
+ 'inputs': [
+ { 'start': 0, 'name': 'default', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'shape', 'name': 'shape', 'type': 'shape' },
+ { 'tfName': 'dtype', 'name': 'dtype', 'type': 'dtype' }
+ ]
+ },
+ {
+ 'tfOpName': 'Placeholder',
+ 'category': 'graph',
+ 'attrs': [
+ { 'tfName': 'shape', 'name': 'shape', 'type': 'shape' },
+ { 'tfName': 'dtype', 'name': 'dtype', 'type': 'dtype' }
+ ]
+ },
+ { 'tfOpName': 'Const', 'category': 'graph' }, {
+ 'tfOpName': 'Identity',
+ 'category': 'graph',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'IdentityN',
+ 'category': 'graph',
+ 'inputs': [{ 'start': 0, 'end': 0, 'name': 'x', 'type': 'tensors' }]
+ },
+ {
+ 'tfOpName': 'Snapshot',
+ 'category': 'graph',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'Rank',
+ 'category': 'graph',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'Size',
+ 'category': 'graph',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'Shape',
+ 'category': 'graph',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'ShapeN',
+ 'category': 'graph',
+ 'inputs': [{ 'start': 0, 'end': 0, 'name': 'x', 'type': 'tensors' }]
+ },
+ {
+ 'tfOpName': 'Print',
+ 'category': 'graph',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'data', 'type': 'tensors' },
+ ],
+ 'attrs': [
+ { 'tfName': 'message', 'name': 'message', 'type': 'string' }, {
+ 'tfName': 'first_n',
+ 'name': 'firstN',
+ 'type': 'number',
+ 'notSupported': true
+ },
+ {
+ 'tfName': 'summarize',
+ 'name': 'summarize',
+ 'type': 'number',
+ 'defaultValue': 3
+ }
+ ]
+ },
+ { 'tfOpName': 'NoOp', 'category': 'graph', 'inputs': [] }, {
+ 'tfOpName': 'StopGradient',
+ 'category': 'graph',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'FakeQuantWithMinMaxVars',
+ 'category': 'graph',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'min', 'name': 'min', 'type': 'number' },
+ { 'tfName': 'max', 'name': 'max', 'type': 'number' }
+ ]
+ }
+];
+//# sourceMappingURL=graph.js.map
+
+/***/ }),
+/* 49 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'ResizeBilinear',
+ 'category': 'image',
+ 'inputs': [
+ { 'start': 0, 'name': 'images', 'type': 'tensor' },
+ { 'start': 1, 'name': 'size', 'type': 'number[]' },
+ ],
+ 'attrs': [
+ { 'tfName': 'align_corners', 'name': 'alignCorners', 'type': 'bool' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'ResizeNearestNeighbor',
+ 'category': 'image',
+ 'inputs': [
+ { 'start': 0, 'name': 'images', 'type': 'tensor' },
+ { 'start': 1, 'name': 'size', 'type': 'number[]' },
+ ],
+ 'attrs': [
+ { 'tfName': 'align_corners', 'name': 'alignCorners', 'type': 'bool' },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'CropAndResize',
+ 'category': 'image',
+ 'inputs': [
+ { 'start': 0, 'name': 'image', 'type': 'tensor' },
+ { 'start': 1, 'name': 'boxes', 'type': 'tensor' },
+ { 'start': 2, 'name': 'boxInd', 'type': 'tensor' },
+ { 'start': 3, 'name': 'cropSize', 'type': 'number[]' },
+ ],
+ 'attrs': [
+ { 'tfName': 'method', 'name': 'method', 'type': 'string' }, {
+ 'tfName': 'extrapolation_value',
+ 'name': 'extrapolationValue',
+ 'type': 'number'
+ }
+ ]
+ }
+];
+//# sourceMappingURL=image.js.map
+
+/***/ }),
+/* 50 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'Equal',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'NotEqual',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Greater',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'GreaterEqual',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Less',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'LessEqual',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'LogicalAnd',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'LogicalNot',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'LogicalOr',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Select',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'condition', 'type': 'tensor' },
+ { 'start': 1, 'name': 'a', 'type': 'tensor' },
+ { 'start': 2, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'SelectV2',
+ 'category': 'logical',
+ 'inputs': [
+ { 'start': 0, 'name': 'condition', 'type': 'tensor' },
+ { 'start': 1, 'name': 'a', 'type': 'tensor' },
+ { 'start': 2, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [{
+ 'tfName': 'T',
+ 'name': 'dtype',
+ 'type': 'dtype',
+ 'notSupported': true
+ }]
+ }
+];
+//# sourceMappingURL=logical.js.map
+
+/***/ }),
+/* 51 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': '_FusedMatMul',
+ 'category': 'matrices',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ { 'start': 2, end: 0, 'name': 'args', 'type': 'tensors' },
+ ],
+ 'attrs': [
+ { 'tfName': 'num_args', 'name': 'numArgs', 'type': 'number' }, {
+ 'tfName': 'fused_ops',
+ 'name': 'fusedOps',
+ 'type': 'string[]',
+ 'defaultValue': []
+ },
+ {
+ 'tfName': 'epsilon',
+ 'name': 'epsilon',
+ 'type': 'number',
+ 'defaultValue': 0.0001
+ },
+ {
+ 'tfName': 'transpose_a',
+ 'name': 'transposeA',
+ 'type': 'bool',
+ 'defaultValue': false
+ },
+ {
+ 'tfName': 'transpose_b',
+ 'name': 'transposeB',
+ 'type': 'bool',
+ 'defaultValue': false
+ },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'MatMul',
+ 'category': 'matrices',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'transpose_a',
+ 'name': 'transposeA',
+ 'type': 'bool',
+ 'defaultValue': false
+ },
+ {
+ 'tfName': 'transpose_b',
+ 'name': 'transposeB',
+ 'type': 'bool',
+ 'defaultValue': false
+ },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'BatchMatMul',
+ 'category': 'matrices',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'adj_x',
+ 'name': 'transposeA',
+ 'type': 'bool',
+ 'defaultValue': false
+ },
+ {
+ 'tfName': 'adj_y',
+ 'name': 'transposeB',
+ 'type': 'bool',
+ 'defaultValue': false
+ },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'BatchMatMulV2',
+ 'category': 'matrices',
+ 'inputs': [
+ { 'start': 0, 'name': 'a', 'type': 'tensor' },
+ { 'start': 1, 'name': 'b', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'adj_x',
+ 'name': 'transposeA',
+ 'type': 'bool',
+ 'defaultValue': false
+ },
+ {
+ 'tfName': 'adj_y',
+ 'name': 'transposeB',
+ 'type': 'bool',
+ 'defaultValue': false
+ },
+ { 'tfName': 'T', 'name': 'dtype', 'type': 'dtype', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'Transpose',
+ 'category': 'matrices',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'perm', 'type': 'number[]' },
+ ],
+ 'attrs': [{
+ 'tfName': 'T',
+ 'name': 'dtype',
+ 'type': 'dtype',
+ 'notSupported': true
+ }]
+ }
+];
+//# sourceMappingURL=matrices.js.map
+
+/***/ }),
+/* 52 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'FusedBatchNorm',
+ 'category': 'normalization',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'scale', 'type': 'tensor' },
+ { 'start': 2, 'name': 'offset', 'type': 'tensor' },
+ { 'start': 3, 'name': 'mean', 'type': 'tensor' },
+ { 'start': 4, 'name': 'variance', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'epsilon',
+ 'name': 'epsilon',
+ 'type': 'number',
+ 'defaultValue': 0.001
+ },
+ {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'FusedBatchNormV2',
+ 'category': 'normalization',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'scale', 'type': 'tensor' },
+ { 'start': 2, 'name': 'offset', 'type': 'tensor' },
+ { 'start': 3, 'name': 'mean', 'type': 'tensor' },
+ { 'start': 4, 'name': 'variance', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'epsilon',
+ 'name': 'epsilon',
+ 'type': 'number',
+ 'defaultValue': 0.001
+ },
+ {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'FusedBatchNormV3',
+ 'category': 'normalization',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'scale', 'type': 'tensor' },
+ { 'start': 2, 'name': 'offset', 'type': 'tensor' },
+ { 'start': 3, 'name': 'mean', 'type': 'tensor' },
+ { 'start': 4, 'name': 'variance', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'epsilon',
+ 'name': 'epsilon',
+ 'type': 'number',
+ 'defaultValue': 0.001
+ },
+ {
+ 'tfName': 'data_format',
+ 'name': 'dataFormat',
+ 'type': 'string',
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'LRN',
+ 'category': 'normalization',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'depth_radius',
+ 'name': 'radius',
+ 'type': 'number',
+ 'defaultValue': 5
+ },
+ { 'tfName': 'bias', 'name': 'bias', 'type': 'number', 'defaultValue': 1.0 },
+ {
+ 'tfName': 'alpha',
+ 'name': 'alpha',
+ 'type': 'number',
+ 'defaultValue': 1.0
+ },
+ {
+ 'tfName': 'beta',
+ 'name': 'beta',
+ 'type': 'number',
+ 'defaultValue': 0.5
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Softmax',
+ 'category': 'normalization',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'LogSoftmax',
+ 'category': 'normalization',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'SparseToDense',
+ 'category': 'normalization',
+ 'inputs': [
+ { 'start': 0, 'name': 'sparseIndices', 'type': 'tensor' },
+ { 'start': 1, 'name': 'outputShape', 'type': 'number[]' },
+ { 'start': 2, 'name': 'sparseValues', 'type': 'tensor' },
+ { 'start': 3, 'name': 'defaultValue', 'type': 'tensor' },
+ ],
+ 'attrs': [{
+ 'tfName': 'validate_indices',
+ 'name': 'validateIndices',
+ 'type': 'bool',
+ 'defaultValue': true,
+ 'notSupported': true
+ }]
+ }
+];
+//# sourceMappingURL=normalization.js.map
+
+/***/ }),
+/* 53 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'Max',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'keep_dims', 'name': 'keepDims', 'type': 'bool' }]
+ },
+ {
+ 'tfOpName': 'Mean',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'keep_dims', 'name': 'keepDims', 'type': 'bool' }]
+ },
+ {
+ 'tfOpName': 'Min',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'keep_dims', 'name': 'keepDims', 'type': 'bool' }]
+ },
+ {
+ 'tfOpName': 'Sum',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'keep_dims', 'name': 'keepDims', 'type': 'bool' }]
+ },
+ {
+ 'tfOpName': 'All',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'keep_dims', 'name': 'keepDims', 'type': 'bool' }]
+ },
+ {
+ 'tfOpName': 'Any',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'keep_dims', 'name': 'keepDims', 'type': 'bool' }]
+ },
+ {
+ 'tfOpName': 'ArgMax',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number' }
+ ]
+ },
+ {
+ 'tfOpName': 'ArgMin',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number' }
+ ]
+ },
+ {
+ 'tfOpName': 'Prod',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number[]' },
+ ],
+ 'attrs': [{ 'tfName': 'keep_dims', 'name': 'keepDims', 'type': 'bool' }]
+ },
+ {
+ 'tfOpName': 'Cumsum',
+ 'category': 'reduction',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number' },
+ ],
+ 'attrs': [
+ { 'tfName': 'exclusive', 'name': 'exclusive', 'type': 'bool' },
+ { 'tfName': 'reverse', 'name': 'reverse', 'type': 'bool' }
+ ]
+ }
+];
+//# sourceMappingURL=reduction.js.map
+
+/***/ }),
+/* 54 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'ConcatV2',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'end': -1, 'name': 'tensors', 'type': 'tensors' },
+ { 'start': -1, 'name': 'axis', 'type': 'number' }
+ ],
+ 'attrs': [{ 'tfName': 'N', 'name': 'n', 'type': 'number', 'defaultValue': 2 }]
+ },
+ {
+ 'tfOpName': 'Concat',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 1, 'end': 0, 'name': 'tensors', 'type': 'tensors' },
+ { 'start': 0, 'name': 'axis', 'type': 'number' }
+ ],
+ 'attrs': [{ 'tfName': 'N', 'name': 'n', 'type': 'number', 'defaultValue': 2 }]
+ },
+ {
+ 'tfOpName': 'GatherV2',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'indices', 'type': 'tensor' },
+ { 'start': 2, 'name': 'axis', 'type': 'number', 'defaultValue': 0 }
+ ]
+ },
+ {
+ 'tfOpName': 'Gather',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'indices', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'axis', 'name': 'axis', 'type': 'number', 'defaultValue': 0 }, {
+ 'tfName': 'validate_indices',
+ 'name': 'validateIndices',
+ 'type': 'bool',
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Reverse',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'dims', 'type': 'bool', 'notSupported': true }
+ ]
+ },
+ {
+ 'tfOpName': 'ReverseV2',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'Slice',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'begin', 'type': 'number[]' },
+ { 'start': 2, 'name': 'size', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'StridedSlice',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'begin', 'type': 'number[]' },
+ { 'start': 2, 'name': 'end', 'type': 'number[]' },
+ { 'start': 3, 'name': 'strides', 'type': 'number[]' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'begin_mask',
+ 'name': 'beginMask',
+ 'type': 'number',
+ 'defaultValue': 0
+ },
+ {
+ 'tfName': 'end_mask',
+ 'name': 'endMask',
+ 'type': 'number',
+ 'defaultValue': 0
+ },
+ {
+ 'tfName': 'new_axis_mask',
+ 'name': 'newAxisMask',
+ 'type': 'number',
+ 'defaultValue': 0
+ },
+ {
+ 'tfName': 'ellipsis_mask',
+ 'name': 'ellipsisMask',
+ 'type': 'number',
+ 'defaultValue': 0
+ },
+ {
+ 'tfName': 'shrink_axis_mask',
+ 'name': 'shrinkAxisMask',
+ 'type': 'number',
+ 'defaultValue': 0
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Pack',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'end': 0, 'name': 'tensors', 'type': 'tensors' },
+ ],
+ 'attrs': [
+ { 'tfName': 'axis', 'name': 'axis', 'type': 'number', 'defaultValue': 0 }
+ ]
+ },
+ {
+ 'tfOpName': 'Unpack',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'tensor', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'axis', 'name': 'axis', 'type': 'number', 'defaultValue': 0 }, {
+ 'tfName': 'num',
+ 'name': 'num',
+ 'type': 'number',
+ 'defaultValue': 0,
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Tile',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'reps', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'Split',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'axis', 'type': 'number', 'defaultValue': 0 },
+ { 'start': 1, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [{
+ 'tfName': 'num_split',
+ 'name': 'numOrSizeSplits',
+ 'type': 'number',
+ 'defaultValue': 1
+ }]
+ },
+ {
+ 'tfOpName': 'SplitV',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'numOrSizeSplits', 'type': 'number[]' },
+ { 'start': 2, 'name': 'axis', 'type': 'number', 'defaultValue': 0 }
+ ]
+ },
+ {
+ 'tfOpName': 'ScatterNd',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'indices', 'type': 'tensor' },
+ { 'start': 1, 'name': 'values', 'type': 'tensor' },
+ { 'start': 2, 'name': 'shape', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'GatherNd',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'indices', 'type': 'tensor' }
+ ]
+ },
+ {
+ 'tfOpName': 'SparseToDense',
+ 'category': 'slice_join',
+ 'inputs': [
+ { 'start': 0, 'name': 'sparseIndices', 'type': 'tensor' },
+ { 'start': 1, 'name': 'outputShape', 'type': 'number[]' },
+ { 'start': 2, 'name': 'sparseValues', 'type': 'tensor' },
+ { 'start': 3, 'name': 'defaultValue', 'type': 'tensor' },
+ ],
+ 'attrs': [{
+ 'tfName': 'validate_indices',
+ 'name': 'validateIndices',
+ 'type': 'bool',
+ 'defaultValue': false,
+ 'notSupported': true
+ }]
+ }
+];
+//# sourceMappingURL=slice_join.js.map
+
+/***/ }),
+/* 55 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'FFT',
+ 'category': 'spectral',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'IFFT',
+ 'category': 'spectral',
+ 'inputs': [{ 'start': 0, 'name': 'x', 'type': 'tensor' }]
+ },
+ {
+ 'tfOpName': 'RFFT',
+ 'category': 'spectral',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' }, {
+ 'start': 1,
+ 'name': 'fft_length',
+ 'type': 'number',
+ 'notSupported': true
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'IRFFT',
+ 'category': 'spectral',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' }, {
+ 'start': 1,
+ 'name': 'fft_length',
+ 'type': 'number',
+ 'notSupported': true
+ }
+ ]
+ }
+];
+//# sourceMappingURL=spectral.js.map
+
+/***/ }),
+/* 56 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "json", function() { return json; });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const json = [
+ {
+ 'tfOpName': 'Cast',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ {
+ 'tfName': 'SrcT',
+ 'name': 'sdtype',
+ 'type': 'dtype',
+ 'notSupported': true
+ },
+ { 'tfName': 'DstT', 'name': 'dtype', 'type': 'dtype' }
+ ]
+ },
+ {
+ 'tfOpName': 'ExpandDims',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'axis', 'type': 'number' }
+ ]
+ },
+ {
+ 'tfOpName': 'Pad',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'padding', 'type': 'number[]' },
+ ],
+ 'attrs': [{
+ 'tfName': 'constant_value',
+ 'name': 'constantValue',
+ 'type': 'number',
+ 'defaultValue': 0
+ }]
+ },
+ {
+ 'tfOpName': 'PadV2',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'padding', 'type': 'number[]' }, {
+ 'start': 2,
+ 'name': 'constantValue',
+ 'type': 'number',
+ 'defaultValue': 0
+ }
+ ]
+ },
+ {
+ 'tfOpName': 'Reshape',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'shape', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'Squeeze',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [{
+ 'tfName': 'axis',
+ 'tfDeprecatedName': 'squeeze_dims',
+ 'name': 'axis',
+ 'type': 'number[]'
+ }]
+ },
+ {
+ 'tfOpName': 'SpaceToBatchND',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'blockShape', 'type': 'number[]' },
+ { 'start': 2, 'name': 'paddings', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'BatchToSpaceND',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'blockShape', 'type': 'number[]' },
+ { 'start': 2, 'name': 'crops', 'type': 'number[]' }
+ ]
+ },
+ {
+ 'tfOpName': 'DepthToSpace',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ ],
+ 'attrs': [
+ { 'tfName': 'block_size', 'name': 'blockSize', 'type': 'number' },
+ { 'tfName': 'data_format', 'name': 'dataFormat', 'type': 'string' }
+ ]
+ },
+ {
+ 'tfOpName': 'BroadcastTo',
+ 'category': 'transformation',
+ 'inputs': [
+ { 'start': 0, 'name': 'x', 'type': 'tensor' },
+ { 'start': 1, 'name': 'shape', 'type': 'number[]' },
+ ],
+ 'attrs': []
+ }
+];
+//# sourceMappingURL=transformation.js.map
+
+/***/ }),
+/* 57 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(Buffer) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ByteChunkIterator; });
+/* harmony import */ var _tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
+/* harmony import */ var _lazy_iterator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(14);
+/* harmony import */ var _string_iterator__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(58);
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * =============================================================================
+ */
+
+
+
+class ByteChunkIterator extends _lazy_iterator__WEBPACK_IMPORTED_MODULE_1__[/* LazyIterator */ "a"] {
+ /**
+ * Decode a stream of UTF8-encoded byte arrays to a stream of strings.
+ *
+ * The byte arrays producetd from the ByteChunkIterator on which this is
+ * called will be interpreted as concatenated. No assumptions are made about
+ * the boundaries of the incoming chunks, so a multi-byte UTF8 encoding of a
+ * character may span the boundary between chunks. This naturally happens,
+ * for instance, when reading fixed-size byte arrays from a file.
+ */
+ decodeUTF8() {
+ return new Utf8Iterator(this);
+ }
+}
+// ============================================================================
+// The following private classes serve to implement the chainable methods
+// on ByteChunkIterator. Unfortunately they can't be placed in separate files,
+// due to resulting trouble with circular imports.
+// ============================================================================
+// We wanted multiple inheritance, e.g.
+// class Utf8Iterator extends QueueIterator, StringIterator
+// but the TypeScript mixin approach is a bit hacky, so we take this adapter
+// approach instead.
+class Utf8Iterator extends _string_iterator__WEBPACK_IMPORTED_MODULE_2__[/* StringIterator */ "a"] {
+ constructor(upstream) {
+ super();
+ this.upstream = upstream;
+ this.impl = new Utf8IteratorImpl(upstream);
+ }
+ summary() {
+ return this.impl.summary();
+ }
+ async next() {
+ return this.impl.next();
+ }
+}
+/**
+ * Decode a stream of UTF8-encoded byte arrays to a stream of strings.
+ *
+ * This is tricky because the incoming byte array boundaries may disrupt a
+ * multi-byte UTF8 character. Thus any incomplete character data at the end of
+ * a chunk must be carried over and prepended to the next chunk before
+ * decoding. Luckily with native decoder, TextDecoder in browser and
+ * string_decoder in node, byte array boundaries are handled automatically.
+ *
+ * In the context of an input pipeline for machine learning, UTF8 decoding is
+ * needed to parse text files containing training examples or prediction
+ * requests (e.g., formatted as CSV or JSON). We cannot use the built-in
+ * decoding provided by FileReader.readAsText() because here we are in a
+ * streaming context, which FileReader does not support.
+ *
+ * @param upstream A `LazyIterator` of `Uint8Arrays` containing UTF8-encoded
+ * text, which should be interpreted as concatenated. No assumptions are
+ * made about the boundaries of the incoming chunks, so a multi-byte UTF8
+ * encoding of a character may span the boundary between chunks. This
+ * naturally happens, for instance, when reading fixed-size byte arrays from a
+ * file.
+ */
+class Utf8IteratorImpl extends _lazy_iterator__WEBPACK_IMPORTED_MODULE_1__[/* OneToManyIterator */ "b"] {
+ constructor(upstream) {
+ super();
+ this.upstream = upstream;
+ if (Object(_tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["env"])().get('IS_BROWSER')) {
+ this.decoder = new TextDecoder('utf-8');
+ }
+ else {
+ // tslint:disable-next-line:no-require-imports
+ const { StringDecoder } = __webpack_require__(78);
+ this.decoder = new StringDecoder('utf8');
+ }
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Utf8`;
+ }
+ async pump() {
+ const chunkResult = await this.upstream.next();
+ let chunk;
+ if (chunkResult.done) {
+ return false;
+ }
+ else {
+ chunk = chunkResult.value;
+ }
+ let text;
+ if (Object(_tensorflow_tfjs_core__WEBPACK_IMPORTED_MODULE_0__["env"])().get('IS_BROWSER')) {
+ text = this.decoder.decode(chunk, { stream: true });
+ }
+ else {
+ text = this.decoder.write(Buffer.from(chunk.buffer));
+ }
+ this.outputQueue.push(text);
+ return true;
+ }
+}
+//# sourceMappingURL=byte_chunk_iterator.js.map
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(39).Buffer))
+
+/***/ }),
+/* 58 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return StringIterator; });
+/* harmony import */ var _lazy_iterator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14);
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * =============================================================================
+ */
+
+class StringIterator extends _lazy_iterator__WEBPACK_IMPORTED_MODULE_0__[/* LazyIterator */ "a"] {
+ /**
+ * Splits a string stream on a given separator.
+ *
+ * It is assumed that the incoming chunk boundaries have no semantic meaning,
+ * so conceptually the incoming stream is treated simply as the concatenation
+ * of its elements.
+ *
+ * The outgoing stream provides chunks corresponding to the results of the
+ * standard string split() operation (even if such a chunk spanned incoming
+ * chunks). The separators are not included.
+ *
+ * A typical usage is to split a text file (represented as a stream with
+ * arbitrary chunk boundaries) into lines.
+ *
+ * @param upstream A readable stream of strings that can be treated as
+ * concatenated.
+ * @param separator A character to split on.
+ */
+ split(separator) {
+ return new SplitIterator(this, separator);
+ }
+}
+// ============================================================================
+// The following private classes serve to implement the chainable methods
+// on StringIterator. Unfortunately they can't be placed in separate files, due
+// to resulting trouble with circular imports.
+// ============================================================================
+// We wanted multiple inheritance, e.g.
+// class SplitIterator extends QueueIterator, StringIterator
+// but the TypeScript mixin approach is a bit hacky, so we take this adapter
+// approach instead.
+class SplitIterator extends StringIterator {
+ constructor(upstream, separator) {
+ super();
+ this.upstream = upstream;
+ this.impl = new SplitIteratorImpl(upstream, separator);
+ }
+ summary() {
+ return this.impl.summary();
+ }
+ async next() {
+ return this.impl.next();
+ }
+}
+class SplitIteratorImpl extends _lazy_iterator__WEBPACK_IMPORTED_MODULE_0__[/* OneToManyIterator */ "b"] {
+ constructor(upstream, separator) {
+ super();
+ this.upstream = upstream;
+ this.separator = separator;
+ // A partial string at the end of an upstream chunk
+ this.carryover = '';
+ }
+ summary() {
+ return `${this.upstream.summary()} -> Split('${this.separator}')`;
+ }
+ async pump() {
+ const chunkResult = await this.upstream.next();
+ if (chunkResult.done) {
+ if (this.carryover === '') {
+ return false;
+ }
+ // Pretend that the pump succeeded in order to emit the small last batch.
+ // The next pump() call will actually fail.
+ this.outputQueue.push(this.carryover);
+ this.carryover = '';
+ return true;
+ }
+ const lines = chunkResult.value.split(this.separator);
+ // Note the behavior: " ab ".split(' ') === ['', 'ab', '']
+ // Thus the carryover may be '' if the separator falls on a chunk
+ // boundary; this produces the correct result.
+ lines[0] = this.carryover + lines[0];
+ for (const line of lines.slice(0, -1)) {
+ this.outputQueue.push(line);
+ }
+ this.carryover = lines[lines.length - 1];
+ return true;
+ }
+}
+//# sourceMappingURL=string_iterator.js.map
+
+/***/ }),
+/* 59 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const blazeface = __webpack_require__(81);
+const tfconv = __webpack_require__(38);
+const tf = __webpack_require__(0);
+const keypoints_1 = __webpack_require__(82);
+const pipeline_1 = __webpack_require__(83);
+const uv_coords_1 = __webpack_require__(85);
+const FACEMESH_GRAPHMODEL_PATH = 'https://tfhub.dev/mediapipe/tfjs-model/facemesh/1/default/1';
+const MESH_MODEL_INPUT_WIDTH = 192;
+const MESH_MODEL_INPUT_HEIGHT = 192;
+async function load({ maxContinuousChecks = 5, detectionConfidence = 0.9, maxFaces = 10, iouThreshold = 0.3, scoreThreshold = 0.75 } = {}) {
+ const [blazeFace, blazeMeshModel] = await Promise.all([
+ loadDetectorModel(maxFaces, iouThreshold, scoreThreshold), loadMeshModel()
+ ]);
+ const faceMesh = new FaceMesh(blazeFace, blazeMeshModel, maxContinuousChecks, detectionConfidence, maxFaces);
+ return faceMesh;
+}
+exports.load = load;
+async function loadDetectorModel(maxFaces, iouThreshold, scoreThreshold) {
+ return blazeface.load({ maxFaces, iouThreshold, scoreThreshold });
+}
+async function loadMeshModel() {
+ return tfconv.loadGraphModel(FACEMESH_GRAPHMODEL_PATH, { fromTFHub: true });
+}
+function getInputTensorDimensions(input) {
+ return input instanceof tf.Tensor ? [input.shape[0], input.shape[1]] :
+ [input.height, input.width];
+}
+function flipFaceHorizontal(face, imageWidth) {
+ if (face.mesh instanceof tf.Tensor) {
+ const [topLeft, bottomRight, mesh, scaledMesh] = tf.tidy(() => {
+ const subtractBasis = tf.tensor1d([imageWidth - 1, 0, 0]);
+ const multiplyBasis = tf.tensor1d([1, -1, 1]);
+ return tf.tidy(() => {
+ return [
+ tf.concat([
+ tf.sub(imageWidth - 1, face.boundingBox.topLeft.slice(0, 1)),
+ face.boundingBox.topLeft.slice(1, 1)
+ ]),
+ tf.concat([
+ tf.sub(imageWidth - 1, face.boundingBox.bottomRight.slice(0, 1)),
+ face.boundingBox.bottomRight.slice(1, 1)
+ ]),
+ tf.sub(subtractBasis, face.mesh).mul(multiplyBasis),
+ tf.sub(subtractBasis, face.scaledMesh).mul(multiplyBasis)
+ ];
+ });
+ });
+ return Object.assign({}, face, { boundingBox: { topLeft, bottomRight }, mesh, scaledMesh });
+ }
+ return Object.assign({}, face, {
+ boundingBox: {
+ topLeft: [
+ imageWidth - 1 - face.boundingBox.topLeft[0],
+ face.boundingBox.topLeft[1]
+ ],
+ bottomRight: [
+ imageWidth - 1 - face.boundingBox.bottomRight[0],
+ face.boundingBox.bottomRight[1]
+ ]
+ },
+ mesh: (face.mesh).map(coord => {
+ const flippedCoord = coord.slice(0);
+ flippedCoord[0] = imageWidth - 1 - coord[0];
+ return flippedCoord;
+ }),
+ scaledMesh: face.scaledMesh.map(coord => {
+ const flippedCoord = coord.slice(0);
+ flippedCoord[0] = imageWidth - 1 - coord[0];
+ return flippedCoord;
+ })
+ });
+}
+class FaceMesh {
+ constructor(blazeFace, blazeMeshModel, maxContinuousChecks, detectionConfidence, maxFaces) {
+ this.pipeline = new pipeline_1.Pipeline(blazeFace, blazeMeshModel, MESH_MODEL_INPUT_WIDTH, MESH_MODEL_INPUT_HEIGHT, maxContinuousChecks, maxFaces);
+ this.detectionConfidence = detectionConfidence;
+ }
+ static getAnnotations() {
+ return keypoints_1.MESH_ANNOTATIONS;
+ }
+ static getUVCoords() {
+ return uv_coords_1.UV_COORDS;
+ }
+ async estimateFaces(input, returnTensors = false, flipHorizontal = false) {
+ const [, width] = getInputTensorDimensions(input);
+ const image = tf.tidy(() => {
+ if (!(input instanceof tf.Tensor)) {
+ input = tf.browser.fromPixels(input);
+ }
+ return input.toFloat().expandDims(0);
+ });
+ const savedWebglPackDepthwiseConvFlag = tf.env().get('WEBGL_PACK_DEPTHWISECONV');
+ tf.env().set('WEBGL_PACK_DEPTHWISECONV', true);
+ const predictions = await this.pipeline.predict(image);
+ tf.env().set('WEBGL_PACK_DEPTHWISECONV', savedWebglPackDepthwiseConvFlag);
+ image.dispose();
+ if (predictions != null && predictions.length > 0) {
+ return Promise.all(predictions.map(async (prediction, i) => {
+ const { coords, scaledCoords, box, flag } = prediction;
+ let tensorsToRead = [flag];
+ if (!returnTensors) {
+ tensorsToRead = tensorsToRead.concat([coords, scaledCoords, box.startPoint, box.endPoint]);
+ }
+ const tensorValues = await Promise.all(tensorsToRead.map(async (d) => d.array()));
+ const flagValue = tensorValues[0];
+ flag.dispose();
+ if (flagValue < this.detectionConfidence) {
+ this.pipeline.clearRegionOfInterest(i);
+ }
+ if (returnTensors) {
+ const annotatedPrediction = {
+ faceInViewConfidence: flagValue,
+ mesh: coords,
+ scaledMesh: scaledCoords,
+ boundingBox: {
+ topLeft: box.startPoint.squeeze(),
+ bottomRight: box.endPoint.squeeze()
+ }
+ };
+ if (flipHorizontal) {
+ return flipFaceHorizontal(annotatedPrediction, width);
+ }
+ return annotatedPrediction;
+ }
+ const [coordsArr, coordsArrScaled, topLeft, bottomRight] = tensorValues.slice(1);
+ scaledCoords.dispose();
+ coords.dispose();
+ let annotatedPrediction = {
+ faceInViewConfidence: flagValue,
+ boundingBox: { topLeft, bottomRight },
+ mesh: coordsArr,
+ scaledMesh: coordsArrScaled
+ };
+ if (flipHorizontal) {
+ annotatedPrediction =
+ flipFaceHorizontal(annotatedPrediction, width);
+ }
+ const annotations = {};
+ for (const key in keypoints_1.MESH_ANNOTATIONS) {
+ annotations[key] = keypoints_1.MESH_ANNOTATIONS[key].map(index => annotatedPrediction.scaledMesh[index]);
+ }
+ annotatedPrediction['annotations'] = annotations;
+ return annotatedPrediction;
+ }));
+ }
+ return [];
+ }
+}
+exports.FaceMesh = FaceMesh;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+/* 60 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tfjsCore = __webpack_require__(0);
+var tfjsLayers = __webpack_require__(87);
+var tfjsConverter = __webpack_require__(38);
+var tfjsData = __webpack_require__(88);
+var tfjsBackendCpu = __webpack_require__(89);
+var tfjsBackendWebgl = __webpack_require__(86);
+
+/** @license See the LICENSE file. */
+// This code is auto-generated, do not modify this file!
+var version = '2.0.1';
+
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+var version$1 = {
+ 'tfjs-core': tfjsCore.version_core,
+ 'tfjs-backend-cpu': tfjsBackendCpu.version_cpu,
+ 'tfjs-backend-webgl': tfjsBackendWebgl.version_webgl,
+ 'tfjs-data': tfjsData.version_data,
+ 'tfjs-layers': tfjsLayers.version_layers,
+ 'tfjs-converter': tfjsConverter.version_converter,
+ 'tfjs': version
+};
+
+Object.keys(tfjsCore).forEach(function (k) {
+ if (k !== 'default') Object.defineProperty(exports, k, {
+ enumerable: true,
+ get: function () {
+ return tfjsCore[k];
+ }
+ });
+});
+Object.keys(tfjsLayers).forEach(function (k) {
+ if (k !== 'default') Object.defineProperty(exports, k, {
+ enumerable: true,
+ get: function () {
+ return tfjsLayers[k];
+ }
+ });
+});
+Object.keys(tfjsConverter).forEach(function (k) {
+ if (k !== 'default') Object.defineProperty(exports, k, {
+ enumerable: true,
+ get: function () {
+ return tfjsConverter[k];
+ }
+ });
+});
+exports.data = tfjsData;
+exports.version = version$1;
+//# sourceMappingURL=tf.node.js.map
+
+
+/***/ }),
+/* 61 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {/* harmony import */ var _device_util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36);
+/* harmony import */ var _environment__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
+/**
+ * @license
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+
+const ENV = Object(_environment__WEBPACK_IMPORTED_MODULE_1__[/* env */ "c"])();
+/**
+ * This file contains environment-related flag registrations.
+ */
+/** Whether to enable debug mode. */
+ENV.registerFlag('DEBUG', () => false, debugValue => {
+ if (debugValue) {
+ console.warn('Debugging mode is ON. The output of every math call will ' +
+ 'be downloaded to CPU and checked for NaNs. ' +
+ 'This significantly impacts performance.');
+ }
+});
+/** Whether we are in a browser (as versus, say, node.js) environment. */
+ENV.registerFlag('IS_BROWSER', () => _device_util__WEBPACK_IMPORTED_MODULE_0__["isBrowser"]());
+/** Whether we are in a browser (as versus, say, node.js) environment. */
+ENV.registerFlag('IS_NODE', () => (typeof process !== 'undefined') &&
+ (typeof process.versions !== 'undefined') &&
+ (typeof process.versions.node !== 'undefined'));
+/** Whether this browser is Chrome. */
+ENV.registerFlag('IS_CHROME', () => typeof navigator !== 'undefined' && navigator != null &&
+ navigator.userAgent != null && /Chrome/.test(navigator.userAgent) &&
+ /Google Inc/.test(navigator.vendor));
+/**
+ * True when the environment is "production" where we disable safety checks
+ * to gain performance.
+ */
+ENV.registerFlag('PROD', () => false);
+/**
+ * Whether to do sanity checks when inferring a shape from user-provided
+ * values, used when creating a new tensor.
+ */
+ENV.registerFlag('TENSORLIKE_CHECK_SHAPE_CONSISTENCY', () => ENV.getBool('DEBUG'));
+/** Whether deprecation warnings are enabled. */
+ENV.registerFlag('DEPRECATION_WARNINGS_ENABLED', () => true);
+/** True if running unit tests. */
+ENV.registerFlag('IS_TEST', () => false);
+//# sourceMappingURL=flags.js.map
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(35)))
+
+/***/ }),
+/* 62 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {/* unused harmony export getNodeFetch */
+/* unused harmony export resetSystemFetch */
+/* unused harmony export setSystemFetch */
+/* unused harmony export getSystemFetch */
+/* unused harmony export PlatformNode */
+/* harmony import */ var _environment__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+
+// We are wrapping this within an object so it can be stubbed by Jasmine.
+const getNodeFetch = {
+ // tslint:disable-next-line:no-require-imports
+ importFetch: () => __webpack_require__(63)
+};
+let systemFetch;
+// These getters and setters are for testing so we don't export a mutable
+// variable.
+function resetSystemFetch() {
+ systemFetch = null;
+}
+function setSystemFetch(fetchFn) {
+ systemFetch = fetchFn;
+}
+function getSystemFetch() {
+ return systemFetch;
+}
+class PlatformNode {
+ constructor() {
+ // tslint:disable-next-line:no-require-imports
+ this.util = __webpack_require__(64);
+ // According to the spec, the built-in encoder can do only UTF-8 encoding.
+ // https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder/TextEncoder
+ this.textEncoder = new this.util.TextEncoder();
+ }
+ fetch(path, requestInits) {
+ if (Object(_environment__WEBPACK_IMPORTED_MODULE_0__[/* env */ "c"])().global.fetch != null) {
+ return Object(_environment__WEBPACK_IMPORTED_MODULE_0__[/* env */ "c"])().global.fetch(path, requestInits);
+ }
+ if (systemFetch == null) {
+ systemFetch = getNodeFetch.importFetch();
+ }
+ return systemFetch(path, requestInits);
+ }
+ now() {
+ const time = process.hrtime();
+ return time[0] * 1000 + time[1] / 1000000;
+ }
+ encode(text, encoding) {
+ if (encoding !== 'utf-8' && encoding !== 'utf8') {
+ throw new Error(`Node built-in encoder only supports utf-8, but got ${encoding}`);
+ }
+ return this.textEncoder.encode(text);
+ }
+ decode(bytes, encoding) {
+ if (bytes.length === 0) {
+ return '';
+ }
+ return new this.util.TextDecoder(encoding).decode(bytes);
+ }
+}
+if (Object(_environment__WEBPACK_IMPORTED_MODULE_0__[/* env */ "c"])().get('IS_NODE')) {
+ Object(_environment__WEBPACK_IMPORTED_MODULE_0__[/* env */ "c"])().setPlatform('node', new PlatformNode());
+}
+//# sourceMappingURL=platform_node.js.map
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(35)))
+
+/***/ }),
+/* 63 */
+/***/ (function(module, exports) {
+
+/* (ignored) */
+
+/***/ }),
+/* 64 */
+/***/ (function(module, exports) {
+
+/* (ignored) */
+
+/***/ }),
+/* 65 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+ lookup[i] = code[i]
+ revLookup[code.charCodeAt(i)] = i
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
+
+function getLens (b64) {
+ var len = b64.length
+
+ if (len % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ // Trim off extra bytes after placeholder bytes are found
+ // See: https://github.com/beatgammit/base64-js/issues/42
+ var validLen = b64.indexOf('=')
+ if (validLen === -1) validLen = len
+
+ var placeHoldersLen = validLen === len
+ ? 0
+ : 4 - (validLen % 4)
+
+ return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength (b64, validLen, placeHoldersLen) {
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray (b64) {
+ var tmp
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+
+ var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+ var curByte = 0
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ var len = placeHoldersLen > 0
+ ? validLen - 4
+ : validLen
+
+ var i
+ for (i = 0; i < len; i += 4) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 18) |
+ (revLookup[b64.charCodeAt(i + 1)] << 12) |
+ (revLookup[b64.charCodeAt(i + 2)] << 6) |
+ revLookup[b64.charCodeAt(i + 3)]
+ arr[curByte++] = (tmp >> 16) & 0xFF
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 2) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 2) |
+ (revLookup[b64.charCodeAt(i + 1)] >> 4)
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 1) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 10) |
+ (revLookup[b64.charCodeAt(i + 1)] << 4) |
+ (revLookup[b64.charCodeAt(i + 2)] >> 2)
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ return arr
+}
+
+function tripletToBase64 (num) {
+ return lookup[num >> 18 & 0x3F] +
+ lookup[num >> 12 & 0x3F] +
+ lookup[num >> 6 & 0x3F] +
+ lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+ var tmp
+ var output = []
+ for (var i = start; i < end; i += 3) {
+ tmp =
+ ((uint8[i] << 16) & 0xFF0000) +
+ ((uint8[i + 1] << 8) & 0xFF00) +
+ (uint8[i + 2] & 0xFF)
+ output.push(tripletToBase64(tmp))
+ }
+ return output.join('')
+}
+
+function fromByteArray (uint8) {
+ var tmp
+ var len = uint8.length
+ var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+ var parts = []
+ var maxChunkLength = 16383 // must be multiple of 3
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+ parts.push(encodeChunk(
+ uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
+ ))
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ if (extraBytes === 1) {
+ tmp = uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 2] +
+ lookup[(tmp << 4) & 0x3F] +
+ '=='
+ )
+ } else if (extraBytes === 2) {
+ tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 10] +
+ lookup[(tmp >> 4) & 0x3F] +
+ lookup[(tmp << 2) & 0x3F] +
+ '='
+ )
+ }
+
+ return parts.join('')
+}
+
+
+/***/ }),
+/* 66 */
+/***/ (function(module, exports) {
+
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+ var e, m
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var nBits = -7
+ var i = isLE ? (nBytes - 1) : 0
+ var d = isLE ? -1 : 1
+ var s = buffer[offset + i]
+
+ i += d
+
+ e = s & ((1 << (-nBits)) - 1)
+ s >>= (-nBits)
+ nBits += eLen
+ for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+ m = e & ((1 << (-nBits)) - 1)
+ e >>= (-nBits)
+ nBits += mLen
+ for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+ if (e === 0) {
+ e = 1 - eBias
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity)
+ } else {
+ m = m + Math.pow(2, mLen)
+ e = e - eBias
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+}
+
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+ var i = isLE ? 0 : (nBytes - 1)
+ var d = isLE ? 1 : -1
+ var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+ value = Math.abs(value)
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0
+ e = eMax
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2)
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--
+ c *= 2
+ }
+ if (e + eBias >= 1) {
+ value += rt / c
+ } else {
+ value += rt * Math.pow(2, 1 - eBias)
+ }
+ if (value * c >= 2) {
+ e++
+ c /= 2
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0
+ e = eMax
+ } else if (e + eBias >= 1) {
+ m = ((value * c) - 1) * Math.pow(2, mLen)
+ e = e + eBias
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+ e = 0
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+ e = (e << mLen) | m
+ eLen += mLen
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+ buffer[offset + i - d] |= s * 128
+}
+
+
+/***/ }),
+/* 67 */
+/***/ (function(module, exports) {
+
+var toString = {}.toString;
+
+module.exports = Array.isArray || function (arr) {
+ return toString.call(arr) == '[object Array]';
+};
+
+
+/***/ }),
+/* 68 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_RESULT__;// A port of an algorithm by Johannes Baagøe , 2010
+// http://baagoe.com/en/RandomMusings/javascript/
+// https://github.com/nquinlan/better-random-numbers-for-javascript-mirror
+// Original work is under MIT license -
+
+// Copyright (C) 2010 by Johannes Baagøe
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+
+
+(function(global, module, define) {
+
+function Alea(seed) {
+ var me = this, mash = Mash();
+
+ me.next = function() {
+ var t = 2091639 * me.s0 + me.c * 2.3283064365386963e-10; // 2^-32
+ me.s0 = me.s1;
+ me.s1 = me.s2;
+ return me.s2 = t - (me.c = t | 0);
+ };
+
+ // Apply the seeding algorithm from Baagoe.
+ me.c = 1;
+ me.s0 = mash(' ');
+ me.s1 = mash(' ');
+ me.s2 = mash(' ');
+ me.s0 -= mash(seed);
+ if (me.s0 < 0) { me.s0 += 1; }
+ me.s1 -= mash(seed);
+ if (me.s1 < 0) { me.s1 += 1; }
+ me.s2 -= mash(seed);
+ if (me.s2 < 0) { me.s2 += 1; }
+ mash = null;
+}
+
+function copy(f, t) {
+ t.c = f.c;
+ t.s0 = f.s0;
+ t.s1 = f.s1;
+ t.s2 = f.s2;
+ return t;
+}
+
+function impl(seed, opts) {
+ var xg = new Alea(seed),
+ state = opts && opts.state,
+ prng = xg.next;
+ prng.int32 = function() { return (xg.next() * 0x100000000) | 0; }
+ prng.double = function() {
+ return prng() + (prng() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53
+ };
+ prng.quick = prng;
+ if (state) {
+ if (typeof(state) == 'object') copy(state, xg);
+ prng.state = function() { return copy(xg, {}); }
+ }
+ return prng;
+}
+
+function Mash() {
+ var n = 0xefc8249d;
+
+ var mash = function(data) {
+ data = data.toString();
+ for (var i = 0; i < data.length; i++) {
+ n += data.charCodeAt(i);
+ var h = 0.02519603282416938 * n;
+ n = h >>> 0;
+ h -= n;
+ h *= n;
+ n = h >>> 0;
+ h -= n;
+ n += h * 0x100000000; // 2^32
+ }
+ return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
+ };
+
+ return mash;
+}
+
+
+if (module && module.exports) {
+ module.exports = impl;
+} else if (__webpack_require__(16) && __webpack_require__(29)) {
+ !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return impl; }).call(exports, __webpack_require__, exports, module),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+} else {
+ this.alea = impl;
+}
+
+})(
+ this,
+ true && module, // present in node.js
+ __webpack_require__(16) // present with an AMD loader
+);
+
+
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)(module)))
+
+/***/ }),
+/* 69 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_RESULT__;// A Javascript implementaion of the "xor128" prng algorithm by
+// George Marsaglia. See http://www.jstatsoft.org/v08/i14/paper
+
+(function(global, module, define) {
+
+function XorGen(seed) {
+ var me = this, strseed = '';
+
+ me.x = 0;
+ me.y = 0;
+ me.z = 0;
+ me.w = 0;
+
+ // Set up generator function.
+ me.next = function() {
+ var t = me.x ^ (me.x << 11);
+ me.x = me.y;
+ me.y = me.z;
+ me.z = me.w;
+ return me.w ^= (me.w >>> 19) ^ t ^ (t >>> 8);
+ };
+
+ if (seed === (seed | 0)) {
+ // Integer seed.
+ me.x = seed;
+ } else {
+ // String seed.
+ strseed += seed;
+ }
+
+ // Mix in string seed, then discard an initial batch of 64 values.
+ for (var k = 0; k < strseed.length + 64; k++) {
+ me.x ^= strseed.charCodeAt(k) | 0;
+ me.next();
+ }
+}
+
+function copy(f, t) {
+ t.x = f.x;
+ t.y = f.y;
+ t.z = f.z;
+ t.w = f.w;
+ return t;
+}
+
+function impl(seed, opts) {
+ var xg = new XorGen(seed),
+ state = opts && opts.state,
+ prng = function() { return (xg.next() >>> 0) / 0x100000000; };
+ prng.double = function() {
+ do {
+ var top = xg.next() >>> 11,
+ bot = (xg.next() >>> 0) / 0x100000000,
+ result = (top + bot) / (1 << 21);
+ } while (result === 0);
+ return result;
+ };
+ prng.int32 = xg.next;
+ prng.quick = prng;
+ if (state) {
+ if (typeof(state) == 'object') copy(state, xg);
+ prng.state = function() { return copy(xg, {}); }
+ }
+ return prng;
+}
+
+if (module && module.exports) {
+ module.exports = impl;
+} else if (__webpack_require__(16) && __webpack_require__(29)) {
+ !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return impl; }).call(exports, __webpack_require__, exports, module),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+} else {
+ this.xor128 = impl;
+}
+
+})(
+ this,
+ true && module, // present in node.js
+ __webpack_require__(16) // present with an AMD loader
+);
+
+
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)(module)))
+
+/***/ }),
+/* 70 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_RESULT__;// A Javascript implementaion of the "xorwow" prng algorithm by
+// George Marsaglia. See http://www.jstatsoft.org/v08/i14/paper
+
+(function(global, module, define) {
+
+function XorGen(seed) {
+ var me = this, strseed = '';
+
+ // Set up generator function.
+ me.next = function() {
+ var t = (me.x ^ (me.x >>> 2));
+ me.x = me.y; me.y = me.z; me.z = me.w; me.w = me.v;
+ return (me.d = (me.d + 362437 | 0)) +
+ (me.v = (me.v ^ (me.v << 4)) ^ (t ^ (t << 1))) | 0;
+ };
+
+ me.x = 0;
+ me.y = 0;
+ me.z = 0;
+ me.w = 0;
+ me.v = 0;
+
+ if (seed === (seed | 0)) {
+ // Integer seed.
+ me.x = seed;
+ } else {
+ // String seed.
+ strseed += seed;
+ }
+
+ // Mix in string seed, then discard an initial batch of 64 values.
+ for (var k = 0; k < strseed.length + 64; k++) {
+ me.x ^= strseed.charCodeAt(k) | 0;
+ if (k == strseed.length) {
+ me.d = me.x << 10 ^ me.x >>> 4;
+ }
+ me.next();
+ }
+}
+
+function copy(f, t) {
+ t.x = f.x;
+ t.y = f.y;
+ t.z = f.z;
+ t.w = f.w;
+ t.v = f.v;
+ t.d = f.d;
+ return t;
+}
+
+function impl(seed, opts) {
+ var xg = new XorGen(seed),
+ state = opts && opts.state,
+ prng = function() { return (xg.next() >>> 0) / 0x100000000; };
+ prng.double = function() {
+ do {
+ var top = xg.next() >>> 11,
+ bot = (xg.next() >>> 0) / 0x100000000,
+ result = (top + bot) / (1 << 21);
+ } while (result === 0);
+ return result;
+ };
+ prng.int32 = xg.next;
+ prng.quick = prng;
+ if (state) {
+ if (typeof(state) == 'object') copy(state, xg);
+ prng.state = function() { return copy(xg, {}); }
+ }
+ return prng;
+}
+
+if (module && module.exports) {
+ module.exports = impl;
+} else if (__webpack_require__(16) && __webpack_require__(29)) {
+ !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return impl; }).call(exports, __webpack_require__, exports, module),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+} else {
+ this.xorwow = impl;
+}
+
+})(
+ this,
+ true && module, // present in node.js
+ __webpack_require__(16) // present with an AMD loader
+);
+
+
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)(module)))
+
+/***/ }),
+/* 71 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_RESULT__;// A Javascript implementaion of the "xorshift7" algorithm by
+// François Panneton and Pierre L'ecuyer:
+// "On the Xorgshift Random Number Generators"
+// http://saluc.engr.uconn.edu/refs/crypto/rng/panneton05onthexorshift.pdf
+
+(function(global, module, define) {
+
+function XorGen(seed) {
+ var me = this;
+
+ // Set up generator function.
+ me.next = function() {
+ // Update xor generator.
+ var X = me.x, i = me.i, t, v, w;
+ t = X[i]; t ^= (t >>> 7); v = t ^ (t << 24);
+ t = X[(i + 1) & 7]; v ^= t ^ (t >>> 10);
+ t = X[(i + 3) & 7]; v ^= t ^ (t >>> 3);
+ t = X[(i + 4) & 7]; v ^= t ^ (t << 7);
+ t = X[(i + 7) & 7]; t = t ^ (t << 13); v ^= t ^ (t << 9);
+ X[i] = v;
+ me.i = (i + 1) & 7;
+ return v;
+ };
+
+ function init(me, seed) {
+ var j, w, X = [];
+
+ if (seed === (seed | 0)) {
+ // Seed state array using a 32-bit integer.
+ w = X[0] = seed;
+ } else {
+ // Seed state using a string.
+ seed = '' + seed;
+ for (j = 0; j < seed.length; ++j) {
+ X[j & 7] = (X[j & 7] << 15) ^
+ (seed.charCodeAt(j) + X[(j + 1) & 7] << 13);
+ }
+ }
+ // Enforce an array length of 8, not all zeroes.
+ while (X.length < 8) X.push(0);
+ for (j = 0; j < 8 && X[j] === 0; ++j);
+ if (j == 8) w = X[7] = -1; else w = X[j];
+
+ me.x = X;
+ me.i = 0;
+
+ // Discard an initial 256 values.
+ for (j = 256; j > 0; --j) {
+ me.next();
+ }
+ }
+
+ init(me, seed);
+}
+
+function copy(f, t) {
+ t.x = f.x.slice();
+ t.i = f.i;
+ return t;
+}
+
+function impl(seed, opts) {
+ if (seed == null) seed = +(new Date);
+ var xg = new XorGen(seed),
+ state = opts && opts.state,
+ prng = function() { return (xg.next() >>> 0) / 0x100000000; };
+ prng.double = function() {
+ do {
+ var top = xg.next() >>> 11,
+ bot = (xg.next() >>> 0) / 0x100000000,
+ result = (top + bot) / (1 << 21);
+ } while (result === 0);
+ return result;
+ };
+ prng.int32 = xg.next;
+ prng.quick = prng;
+ if (state) {
+ if (state.x) copy(state, xg);
+ prng.state = function() { return copy(xg, {}); }
+ }
+ return prng;
+}
+
+if (module && module.exports) {
+ module.exports = impl;
+} else if (__webpack_require__(16) && __webpack_require__(29)) {
+ !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return impl; }).call(exports, __webpack_require__, exports, module),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+} else {
+ this.xorshift7 = impl;
+}
+
+})(
+ this,
+ true && module, // present in node.js
+ __webpack_require__(16) // present with an AMD loader
+);
+
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)(module)))
+
+/***/ }),
+/* 72 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_RESULT__;// A Javascript implementaion of Richard Brent's Xorgens xor4096 algorithm.
+//
+// This fast non-cryptographic random number generator is designed for
+// use in Monte-Carlo algorithms. It combines a long-period xorshift
+// generator with a Weyl generator, and it passes all common batteries
+// of stasticial tests for randomness while consuming only a few nanoseconds
+// for each prng generated. For background on the generator, see Brent's
+// paper: "Some long-period random number generators using shifts and xors."
+// http://arxiv.org/pdf/1004.3115v1.pdf
+//
+// Usage:
+//
+// var xor4096 = require('xor4096');
+// random = xor4096(1); // Seed with int32 or string.
+// assert.equal(random(), 0.1520436450538547); // (0, 1) range, 53 bits.
+// assert.equal(random.int32(), 1806534897); // signed int32, 32 bits.
+//
+// For nonzero numeric keys, this impelementation provides a sequence
+// identical to that by Brent's xorgens 3 implementaion in C. This
+// implementation also provides for initalizing the generator with
+// string seeds, or for saving and restoring the state of the generator.
+//
+// On Chrome, this prng benchmarks about 2.1 times slower than
+// Javascript's built-in Math.random().
+
+(function(global, module, define) {
+
+function XorGen(seed) {
+ var me = this;
+
+ // Set up generator function.
+ me.next = function() {
+ var w = me.w,
+ X = me.X, i = me.i, t, v;
+ // Update Weyl generator.
+ me.w = w = (w + 0x61c88647) | 0;
+ // Update xor generator.
+ v = X[(i + 34) & 127];
+ t = X[i = ((i + 1) & 127)];
+ v ^= v << 13;
+ t ^= t << 17;
+ v ^= v >>> 15;
+ t ^= t >>> 12;
+ // Update Xor generator array state.
+ v = X[i] = v ^ t;
+ me.i = i;
+ // Result is the combination.
+ return (v + (w ^ (w >>> 16))) | 0;
+ };
+
+ function init(me, seed) {
+ var t, v, i, j, w, X = [], limit = 128;
+ if (seed === (seed | 0)) {
+ // Numeric seeds initialize v, which is used to generates X.
+ v = seed;
+ seed = null;
+ } else {
+ // String seeds are mixed into v and X one character at a time.
+ seed = seed + '\0';
+ v = 0;
+ limit = Math.max(limit, seed.length);
+ }
+ // Initialize circular array and weyl value.
+ for (i = 0, j = -32; j < limit; ++j) {
+ // Put the unicode characters into the array, and shuffle them.
+ if (seed) v ^= seed.charCodeAt((j + 32) % seed.length);
+ // After 32 shuffles, take v as the starting w value.
+ if (j === 0) w = v;
+ v ^= v << 10;
+ v ^= v >>> 15;
+ v ^= v << 4;
+ v ^= v >>> 13;
+ if (j >= 0) {
+ w = (w + 0x61c88647) | 0; // Weyl.
+ t = (X[j & 127] ^= (v + w)); // Combine xor and weyl to init array.
+ i = (0 == t) ? i + 1 : 0; // Count zeroes.
+ }
+ }
+ // We have detected all zeroes; make the key nonzero.
+ if (i >= 128) {
+ X[(seed && seed.length || 0) & 127] = -1;
+ }
+ // Run the generator 512 times to further mix the state before using it.
+ // Factoring this as a function slows the main generator, so it is just
+ // unrolled here. The weyl generator is not advanced while warming up.
+ i = 127;
+ for (j = 4 * 128; j > 0; --j) {
+ v = X[(i + 34) & 127];
+ t = X[i = ((i + 1) & 127)];
+ v ^= v << 13;
+ t ^= t << 17;
+ v ^= v >>> 15;
+ t ^= t >>> 12;
+ X[i] = v ^ t;
+ }
+ // Storing state as object members is faster than using closure variables.
+ me.w = w;
+ me.X = X;
+ me.i = i;
+ }
+
+ init(me, seed);
+}
+
+function copy(f, t) {
+ t.i = f.i;
+ t.w = f.w;
+ t.X = f.X.slice();
+ return t;
+};
+
+function impl(seed, opts) {
+ if (seed == null) seed = +(new Date);
+ var xg = new XorGen(seed),
+ state = opts && opts.state,
+ prng = function() { return (xg.next() >>> 0) / 0x100000000; };
+ prng.double = function() {
+ do {
+ var top = xg.next() >>> 11,
+ bot = (xg.next() >>> 0) / 0x100000000,
+ result = (top + bot) / (1 << 21);
+ } while (result === 0);
+ return result;
+ };
+ prng.int32 = xg.next;
+ prng.quick = prng;
+ if (state) {
+ if (state.X) copy(state, xg);
+ prng.state = function() { return copy(xg, {}); }
+ }
+ return prng;
+}
+
+if (module && module.exports) {
+ module.exports = impl;
+} else if (__webpack_require__(16) && __webpack_require__(29)) {
+ !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return impl; }).call(exports, __webpack_require__, exports, module),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+} else {
+ this.xor4096 = impl;
+}
+
+})(
+ this, // window object or global
+ true && module, // present in node.js
+ __webpack_require__(16) // present with an AMD loader
+);
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)(module)))
+
+/***/ }),
+/* 73 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_RESULT__;// A Javascript implementaion of the "Tyche-i" prng algorithm by
+// Samuel Neves and Filipe Araujo.
+// See https://eden.dei.uc.pt/~sneves/pubs/2011-snfa2.pdf
+
+(function(global, module, define) {
+
+function XorGen(seed) {
+ var me = this, strseed = '';
+
+ // Set up generator function.
+ me.next = function() {
+ var b = me.b, c = me.c, d = me.d, a = me.a;
+ b = (b << 25) ^ (b >>> 7) ^ c;
+ c = (c - d) | 0;
+ d = (d << 24) ^ (d >>> 8) ^ a;
+ a = (a - b) | 0;
+ me.b = b = (b << 20) ^ (b >>> 12) ^ c;
+ me.c = c = (c - d) | 0;
+ me.d = (d << 16) ^ (c >>> 16) ^ a;
+ return me.a = (a - b) | 0;
+ };
+
+ /* The following is non-inverted tyche, which has better internal
+ * bit diffusion, but which is about 25% slower than tyche-i in JS.
+ me.next = function() {
+ var a = me.a, b = me.b, c = me.c, d = me.d;
+ a = (me.a + me.b | 0) >>> 0;
+ d = me.d ^ a; d = d << 16 ^ d >>> 16;
+ c = me.c + d | 0;
+ b = me.b ^ c; b = b << 12 ^ d >>> 20;
+ me.a = a = a + b | 0;
+ d = d ^ a; me.d = d = d << 8 ^ d >>> 24;
+ me.c = c = c + d | 0;
+ b = b ^ c;
+ return me.b = (b << 7 ^ b >>> 25);
+ }
+ */
+
+ me.a = 0;
+ me.b = 0;
+ me.c = 2654435769 | 0;
+ me.d = 1367130551;
+
+ if (seed === Math.floor(seed)) {
+ // Integer seed.
+ me.a = (seed / 0x100000000) | 0;
+ me.b = seed | 0;
+ } else {
+ // String seed.
+ strseed += seed;
+ }
+
+ // Mix in string seed, then discard an initial batch of 64 values.
+ for (var k = 0; k < strseed.length + 20; k++) {
+ me.b ^= strseed.charCodeAt(k) | 0;
+ me.next();
+ }
+}
+
+function copy(f, t) {
+ t.a = f.a;
+ t.b = f.b;
+ t.c = f.c;
+ t.d = f.d;
+ return t;
+};
+
+function impl(seed, opts) {
+ var xg = new XorGen(seed),
+ state = opts && opts.state,
+ prng = function() { return (xg.next() >>> 0) / 0x100000000; };
+ prng.double = function() {
+ do {
+ var top = xg.next() >>> 11,
+ bot = (xg.next() >>> 0) / 0x100000000,
+ result = (top + bot) / (1 << 21);
+ } while (result === 0);
+ return result;
+ };
+ prng.int32 = xg.next;
+ prng.quick = prng;
+ if (state) {
+ if (typeof(state) == 'object') copy(state, xg);
+ prng.state = function() { return copy(xg, {}); }
+ }
+ return prng;
+}
+
+if (module && module.exports) {
+ module.exports = impl;
+} else if (__webpack_require__(16) && __webpack_require__(29)) {
+ !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return impl; }).call(exports, __webpack_require__, exports, module),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+} else {
+ this.tychei = impl;
+}
+
+})(
+ this,
+ true && module, // present in node.js
+ __webpack_require__(16) // present with an AMD loader
+);
+
+
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)(module)))
+
+/***/ }),
+/* 74 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var __WEBPACK_AMD_DEFINE_RESULT__;/*
+Copyright 2014 David Bau.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+
+(function (pool, math) {
+//
+// The following constants are related to IEEE 754 limits.
+//
+var global = this,
+ width = 256, // each RC4 output is 0 <= x < 256
+ chunks = 6, // at least six RC4 outputs for each double
+ digits = 52, // there are 52 significant digits in a double
+ rngname = 'random', // rngname: name for Math.random and Math.seedrandom
+ startdenom = math.pow(width, chunks),
+ significance = math.pow(2, digits),
+ overflow = significance * 2,
+ mask = width - 1,
+ nodecrypto; // node.js crypto module, initialized at the bottom.
+
+//
+// seedrandom()
+// This is the seedrandom function described above.
+//
+function seedrandom(seed, options, callback) {
+ var key = [];
+ options = (options == true) ? { entropy: true } : (options || {});
+
+ // Flatten the seed string or build one from local entropy if needed.
+ var shortseed = mixkey(flatten(
+ options.entropy ? [seed, tostring(pool)] :
+ (seed == null) ? autoseed() : seed, 3), key);
+
+ // Use the seed to initialize an ARC4 generator.
+ var arc4 = new ARC4(key);
+
+ // This function returns a random double in [0, 1) that contains
+ // randomness in every bit of the mantissa of the IEEE 754 value.
+ var prng = function() {
+ var n = arc4.g(chunks), // Start with a numerator n < 2 ^ 48
+ d = startdenom, // and denominator d = 2 ^ 48.
+ x = 0; // and no 'extra last byte'.
+ while (n < significance) { // Fill up all significant digits by
+ n = (n + x) * width; // shifting numerator and
+ d *= width; // denominator and generating a
+ x = arc4.g(1); // new least-significant-byte.
+ }
+ while (n >= overflow) { // To avoid rounding up, before adding
+ n /= 2; // last byte, shift everything
+ d /= 2; // right using integer math until
+ x >>>= 1; // we have exactly the desired bits.
+ }
+ return (n + x) / d; // Form the number within [0, 1).
+ };
+
+ prng.int32 = function() { return arc4.g(4) | 0; }
+ prng.quick = function() { return arc4.g(4) / 0x100000000; }
+ prng.double = prng;
+
+ // Mix the randomness into accumulated entropy.
+ mixkey(tostring(arc4.S), pool);
+
+ // Calling convention: what to return as a function of prng, seed, is_math.
+ return (options.pass || callback ||
+ function(prng, seed, is_math_call, state) {
+ if (state) {
+ // Load the arc4 state from the given state if it has an S array.
+ if (state.S) { copy(state, arc4); }
+ // Only provide the .state method if requested via options.state.
+ prng.state = function() { return copy(arc4, {}); }
+ }
+
+ // If called as a method of Math (Math.seedrandom()), mutate
+ // Math.random because that is how seedrandom.js has worked since v1.0.
+ if (is_math_call) { math[rngname] = prng; return seed; }
+
+ // Otherwise, it is a newer calling convention, so return the
+ // prng directly.
+ else return prng;
+ })(
+ prng,
+ shortseed,
+ 'global' in options ? options.global : (this == math),
+ options.state);
+}
+math['seed' + rngname] = seedrandom;
+
+//
+// ARC4
+//
+// An ARC4 implementation. The constructor takes a key in the form of
+// an array of at most (width) integers that should be 0 <= x < (width).
+//
+// The g(count) method returns a pseudorandom integer that concatenates
+// the next (count) outputs from ARC4. Its return value is a number x
+// that is in the range 0 <= x < (width ^ count).
+//
+function ARC4(key) {
+ var t, keylen = key.length,
+ me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
+
+ // The empty key [] is treated as [0].
+ if (!keylen) { key = [keylen++]; }
+
+ // Set up S using the standard key scheduling algorithm.
+ while (i < width) {
+ s[i] = i++;
+ }
+ for (i = 0; i < width; i++) {
+ s[i] = s[j = mask & (j + key[i % keylen] + (t = s[i]))];
+ s[j] = t;
+ }
+
+ // The "g" method returns the next (count) outputs as one number.
+ (me.g = function(count) {
+ // Using instance members instead of closure state nearly doubles speed.
+ var t, r = 0,
+ i = me.i, j = me.j, s = me.S;
+ while (count--) {
+ t = s[i = mask & (i + 1)];
+ r = r * width + s[mask & ((s[i] = s[j = mask & (j + t)]) + (s[j] = t))];
+ }
+ me.i = i; me.j = j;
+ return r;
+ // For robust unpredictability, the function call below automatically
+ // discards an initial batch of values. This is called RC4-drop[256].
+ // See http://google.com/search?q=rsa+fluhrer+response&btnI
+ })(width);
+}
+
+//
+// copy()
+// Copies internal state of ARC4 to or from a plain object.
+//
+function copy(f, t) {
+ t.i = f.i;
+ t.j = f.j;
+ t.S = f.S.slice();
+ return t;
+};
+
+//
+// flatten()
+// Converts an object tree to nested arrays of strings.
+//
+function flatten(obj, depth) {
+ var result = [], typ = (typeof obj), prop;
+ if (depth && typ == 'object') {
+ for (prop in obj) {
+ try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
+ }
+ }
+ return (result.length ? result : typ == 'string' ? obj : obj + '\0');
+}
+
+//
+// mixkey()
+// Mixes a string seed into a key that is an array of integers, and
+// returns a shortened string seed that is equivalent to the result key.
+//
+function mixkey(seed, key) {
+ var stringseed = seed + '', smear, j = 0;
+ while (j < stringseed.length) {
+ key[mask & j] =
+ mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));
+ }
+ return tostring(key);
+}
+
+//
+// autoseed()
+// Returns an object for autoseeding, using window.crypto and Node crypto
+// module if available.
+//
+function autoseed() {
+ try {
+ var out;
+ if (nodecrypto && (out = nodecrypto.randomBytes)) {
+ // The use of 'out' to remember randomBytes makes tight minified code.
+ out = out(width);
+ } else {
+ out = new Uint8Array(width);
+ (global.crypto || global.msCrypto).getRandomValues(out);
+ }
+ return tostring(out);
+ } catch (e) {
+ var browser = global.navigator,
+ plugins = browser && browser.plugins;
+ return [+new Date, global, plugins, global.screen, tostring(pool)];
+ }
+}
+
+//
+// tostring()
+// Converts an array of charcodes to a string
+//
+function tostring(a) {
+ return String.fromCharCode.apply(0, a);
+}
+
+//
+// When seedrandom.js is loaded, we immediately mix a few bits
+// from the built-in RNG into the entropy pool. Because we do
+// not want to interfere with deterministic PRNG state later,
+// seedrandom will not call math.random on its own again after
+// initialization.
+//
+mixkey(math.random(), pool);
+
+//
+// Nodejs and AMD support: export the implementation as a module using
+// either convention.
+//
+if ( true && module.exports) {
+ module.exports = seedrandom;
+ // When in node.js, try using crypto package for autoseeding.
+ try {
+ nodecrypto = __webpack_require__(75);
+ } catch (ex) {}
+} else if (true) {
+ !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return seedrandom; }).call(exports, __webpack_require__, exports, module),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+}
+
+// End anonymous scope, and pass initial values.
+})(
+ [], // pool: entropy pool starts empty
+ Math // math: package containing random, pow, and seedrandom
+);
+
+
+/***/ }),
+/* 75 */
+/***/ (function(module, exports) {
+
+/* (ignored) */
+
+/***/ }),
+/* 76 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) ||
+ (typeof self !== "undefined" && self) ||
+ window;
+var apply = Function.prototype.apply;
+
+// DOM APIs, for completeness
+
+exports.setTimeout = function() {
+ return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
+};
+exports.setInterval = function() {
+ return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
+};
+exports.clearTimeout =
+exports.clearInterval = function(timeout) {
+ if (timeout) {
+ timeout.close();
+ }
+};
+
+function Timeout(id, clearFn) {
+ this._id = id;
+ this._clearFn = clearFn;
+}
+Timeout.prototype.unref = Timeout.prototype.ref = function() {};
+Timeout.prototype.close = function() {
+ this._clearFn.call(scope, this._id);
+};
+
+// Does not start the time, just sets up the members needed.
+exports.enroll = function(item, msecs) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = msecs;
+};
+
+exports.unenroll = function(item) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = -1;
+};
+
+exports._unrefActive = exports.active = function(item) {
+ clearTimeout(item._idleTimeoutId);
+
+ var msecs = item._idleTimeout;
+ if (msecs >= 0) {
+ item._idleTimeoutId = setTimeout(function onTimeout() {
+ if (item._onTimeout)
+ item._onTimeout();
+ }, msecs);
+ }
+};
+
+// setimmediate attaches itself to the global object
+__webpack_require__(77);
+// On some exotic environments, it's not clear which object `setimmediate` was
+// able to install onto. Search each possibility in the same order as the
+// `setimmediate` library.
+exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) ||
+ (typeof global !== "undefined" && global.setImmediate) ||
+ (this && this.setImmediate);
+exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) ||
+ (typeof global !== "undefined" && global.clearImmediate) ||
+ (this && this.clearImmediate);
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(27)))
+
+/***/ }),
+/* 77 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
+ "use strict";
+
+ if (global.setImmediate) {
+ return;
+ }
+
+ var nextHandle = 1; // Spec says greater than zero
+ var tasksByHandle = {};
+ var currentlyRunningATask = false;
+ var doc = global.document;
+ var registerImmediate;
+
+ function setImmediate(callback) {
+ // Callback can either be a function or a string
+ if (typeof callback !== "function") {
+ callback = new Function("" + callback);
+ }
+ // Copy function arguments
+ var args = new Array(arguments.length - 1);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i + 1];
+ }
+ // Store and register the task
+ var task = { callback: callback, args: args };
+ tasksByHandle[nextHandle] = task;
+ registerImmediate(nextHandle);
+ return nextHandle++;
+ }
+
+ function clearImmediate(handle) {
+ delete tasksByHandle[handle];
+ }
+
+ function run(task) {
+ var callback = task.callback;
+ var args = task.args;
+ switch (args.length) {
+ case 0:
+ callback();
+ break;
+ case 1:
+ callback(args[0]);
+ break;
+ case 2:
+ callback(args[0], args[1]);
+ break;
+ case 3:
+ callback(args[0], args[1], args[2]);
+ break;
+ default:
+ callback.apply(undefined, args);
+ break;
+ }
+ }
+
+ function runIfPresent(handle) {
+ // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
+ // So if we're currently running a task, we'll need to delay this invocation.
+ if (currentlyRunningATask) {
+ // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
+ // "too much recursion" error.
+ setTimeout(runIfPresent, 0, handle);
+ } else {
+ var task = tasksByHandle[handle];
+ if (task) {
+ currentlyRunningATask = true;
+ try {
+ run(task);
+ } finally {
+ clearImmediate(handle);
+ currentlyRunningATask = false;
+ }
+ }
+ }
+ }
+
+ function installNextTickImplementation() {
+ registerImmediate = function(handle) {
+ process.nextTick(function () { runIfPresent(handle); });
+ };
+ }
+
+ function canUsePostMessage() {
+ // The test against `importScripts` prevents this implementation from being installed inside a web worker,
+ // where `global.postMessage` means something completely different and can't be used for this purpose.
+ if (global.postMessage && !global.importScripts) {
+ var postMessageIsAsynchronous = true;
+ var oldOnMessage = global.onmessage;
+ global.onmessage = function() {
+ postMessageIsAsynchronous = false;
+ };
+ global.postMessage("", "*");
+ global.onmessage = oldOnMessage;
+ return postMessageIsAsynchronous;
+ }
+ }
+
+ function installPostMessageImplementation() {
+ // Installs an event handler on `global` for the `message` event: see
+ // * https://developer.mozilla.org/en/DOM/window.postMessage
+ // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
+
+ var messagePrefix = "setImmediate$" + Math.random() + "$";
+ var onGlobalMessage = function(event) {
+ if (event.source === global &&
+ typeof event.data === "string" &&
+ event.data.indexOf(messagePrefix) === 0) {
+ runIfPresent(+event.data.slice(messagePrefix.length));
+ }
+ };
+
+ if (global.addEventListener) {
+ global.addEventListener("message", onGlobalMessage, false);
+ } else {
+ global.attachEvent("onmessage", onGlobalMessage);
+ }
+
+ registerImmediate = function(handle) {
+ global.postMessage(messagePrefix + handle, "*");
+ };
+ }
+
+ function installMessageChannelImplementation() {
+ var channel = new MessageChannel();
+ channel.port1.onmessage = function(event) {
+ var handle = event.data;
+ runIfPresent(handle);
+ };
+
+ registerImmediate = function(handle) {
+ channel.port2.postMessage(handle);
+ };
+ }
+
+ function installReadyStateChangeImplementation() {
+ var html = doc.documentElement;
+ registerImmediate = function(handle) {
+ // Create a
+
+ 