() missing 1 required positional argument: 'x_'\"","def fConnectivityModel(RD,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha):\n#\n# 1. Initialisations:\n# \t-------------------\n\tFSwEnd = 0\n\tFSwInt = 0\n\tFSwMax = 200\n\tFSwErr = 0.0001\n\tSwOld = 1\n\tSwNew = 1\n\tSwInc = 0\n\tTiny=0.000000001\n\tBig=1000000000000\n\tTout=0 # Defines output of fRCrim\n#\n# 2. Calculate Observed Conductivity:\n#-----------------------------------\n\tif(RD<=0):\n\t\tCt=Big\n\telse:\n\t\tCt=1/RD\n#\n# 2. Interative Loop:\n#--------------------\t\t\n\tSwOld=0.50 # Initialises Effective Water Saturation\n\twhile(FSwEnd==0):\n\t\tCm=fRCrim(SwOld,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout)\n\t\tr=Ct-Cm\n\t\ts=(Cm-fRCrim((SwOld-Tiny),Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout))/Tiny # dCm/dSw\n\t\tif(s==0): \n\t\t\tFSwEnd=1\n\t\t\ts=Tiny\n\t\tSwInc=(r/s)\n\t\tSwNew=SwOld+SwInc\n\t\tFSwInt=FSwInt+1\n\t\tif(FSwInt>3):\t\n\t\t\tif (FSwInt>=FSwMax):\n\t\t\t\tFSwEnd=1\n\t\t\tif (abs(SwOld-SwNew)<FSwErr):\n\t\t\t\tFSwEnd=1\n\t\tSwOld=SwNew\n\t\tSwOld=ImposeLimits(SwOld,Tiny,1)\n\t#\t\t\n\treturn SwOld","def __init__(self, model):\n aaa\n self.model = model\n\n #: the list of CROD cards\n self._crod = []\n\n #: the list of CONROD cards\n self._conrod = []\n\n self._crod_comment = []\n self._conrod_comment = []\n\n self.crod = CROD(self.model)\n self.conrod = CONROD(self.model)","def load_CIFAR10(ROOT):\r\n xs = []\r\n ys = []\r\n for b in range(1,6):\r\n f = os.path.join(ROOT, 'data_batch_%d' % (b, ))\r\n X, Y = load_CIFAR_batch(f)\r\n xs.append(X)\r\n ys.append(Y)\r\n Xtr = np.concatenate(xs)\r\n Ytr = np.concatenate(ys)\r\n del X, Y\r\n Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))\r\n return Xtr, Ytr, Xte, Yte\r\n\r\n\tdef get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=10000):\r\n # Load the raw CIFAR-10 data\r\n \r\n cifar10_dir = 'Downloads/cifar-10-batches-py'\r\n \r\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\r\n\r\n # Subsample the data\r\n mask = range(num_training, num_training + num_validation)\r\n X_val = X_train[mask]\r\n y_val = y_train[mask]\r\n mask = range(num_training)\r\n X_train = X_train[mask]\r\n y_train = y_train[mask]\r\n mask = range(num_test)\r\n X_test = X_test[mask]\r\n y_test = y_test[mask]\r\n\r\n x_train = X_train.astype('float32') \r\n x_test = X_test.astype('float32')\r\n \r\n x_train = x_train.reshape(-1, 32, 32, 3)\r\n x_test = x_test.reshape(-1, 32, 32, 3)\r\n x_train /= 255\r\n x_test /= 255\r\n\r\n return x_train, y_train, X_val, y_val, x_test, y_test","def create_model(self, C : float =1):\n self.classifier = RandomForestClassifier(max_depth=5)","def GenerateModel(modelData, outputFilePath, objectName = 'SBMLmodel'):\n #The library mathFuncs serves to both only allow functions supported\n #functions in SBML/user defined functions, but also the python equivalent\n \n np.set_printoptions(threshold=sys.maxsize)\n \n \n \n outputFile = open(outputFilePath, \"w\")\n\n parameters = modelData.parameters\n compartments = modelData.compartments\n species = modelData.species\n reactions = modelData.reactions\n functions = modelData.functions\n \n assignmentRules = modelData.assignmentRules\n rateRules = modelData.rateRules\n initialAssignments = modelData.initialAssignments\n \n mathFuncs = {'abs' : 'abs',\n 'max' : 'max',\n 'min' : 'min',\n 'pow' : 'pow',\n 'exp' : 'math.exp',\n 'floor' : 'np.floor',\n 'ceiling' : 'math.ceil',\n 'exp' : 'math.exp',\n 'ln' : 'math.log',\n 'log' : 'math.log10',\n 'factorial' : 'math.factorial',\n 'sqrt' : 'math.sqrt',\n \n 'eq' : 'operator.eq',\n 'neq' : 'operator.ne',\n 'gt' : 'operator.gt',\n 'lt' : 'operator.lt',\n 'geq' : 'operator.ge',\n 'leq' : 'operator.le',\n \n 'and' : 'operator.and_',\n 'or' : 'operator.or_',\n 'xor' : 'operator.xor_',\n 'not' : 'operator.not_',\n \n 'sin' : 'np.sin',\n 'cos' : 'np.cos',\n 'tan' : 'np.tan',\n 'sec' : '1/np.cos',\n 'csc' : '1/np.sin',\n 'cot' : '1/np.tan',\n 'sinh' : 'np.sinh',\n 'cosh' : 'np.cosh',\n 'tanh' : 'np.tanh',\n 'sech' : '1/np.cosh',\n 'csch' : '1/np.sinh',\n 'coth' : '1/np.tanh',\n 'arcsin' : 'np.arcsin',\n 'arccos' : 'np.arccos',\n 'arctan' : 'np.arctan',\n 'arcsinh' : 'np.arcsinh',\n 'arccosh' : 'np.arccosh',\n 'arctanh' : 'np.arctanh',\n \n 'true' : 'True',\n 'false' : 'False',\n 'notanumber' : 'np.nan',\n 'pi' : 'np.pi',\n 'infinity' : 'np.inf',\n 'exponentiale' : 'np.e',\n 'piecewise' : 'Piecewise'\n } \n #Add in user defined functions\n# for function in functions:\n# mathFuncs[function] = \"self.\" + function\n\t\t\n #Set up stoichCoeffMat, a matrix of stoichiometric coefficients for solving the reactions\n reactantCounter = 0\n reactantIndex = {}\n reactionCounter = 0\n reactionIndex = {}\n \n rateRuleVars = []\n rateParams = 0\n for specie in species:\n reactantIndex[specie] = reactantCounter\n reactantCounter += 1\n for key, rateRule in rateRules.items():\n if rateRule.variable in parameters or rateRule.variable in compartments:\n rateParams += 1\n reactantIndex[rateRule.variable] = reactantCounter\n reactantCounter += 1\n rateRuleVars.append(rateRule.variable)\n elif rateRule.variable in species:\n pass\n else:\n raise Exception(\"Rate Rule adjusting something other than specie amount, parameter value, or compartment size.\")\n\n \t\t\n stoichCoeffMat = np.zeros([len(species) + rateParams, max(len(reactions),1)])\n \n for rxnId in reactions:\n reactionIndex[rxnId] = reactionCounter\n reactionCounter += 1\n reaction = reactions[rxnId]\n for reactant in reaction.reactants:\n if reactant[1] not in reactantIndex:\n reactantIndex[reactant[1]] = reactantCounter\n reactantCounter += 1\n if not (species[reactant[1]].isBoundarySpecies == \"True\"):\n stoichCoeffMat[reactantIndex[reactant[1]], reactionIndex[rxnId]] += reactant[0]\n\n \t\n # for reaction in reactions:\n # for reactant in reactions[reaction][0]:\n # if reactant[1] not in reactantIndex:\n # reactantIndex[reactant[1]] = reactantCounter\n # reactantCounter += 1\n # if not species[reactant[1]][4]:\n # stoichCoeffMat[reactantIndex[reactant[1]], reaction-1] += reactant[0]\n #print(rateParams)\n #print(stoichCoeffMat)\n \n outputFile.write(\"from sbmltopyode.SBMLModelClasses import *\\n\")\n outputFile.write(\"from scipy.integrate import odeint\\n\")\n outputFile.write(\"import numpy as np\\n\")\n outputFile.write(\"import operator\\n\")\n outputFile.write(\"import math\\n\\n\")\n \n outputFile.write(\"class \" + objectName +\":\\n\\n\")\n \n outputFile.write(\"\\tdef __init__(self):\\n\\n\")\n outputFile.write(\"\\t\\tself.p = {} #Dictionary of model parameters\\n\")\n for paramId in parameters:\n outputFile.write(\"\\t\\tself.p[\\'\" + paramId + \"\\'] = Parameter(\" + str(parameters[paramId].value)+ \", \\'\"+ paramId + \"\\', \" + str(parameters[paramId].isConstant) +\")\\n\")\n \n outputFile.write(\"\\n\\t\\tself.c = {} #Dictionary of compartments\\n\")\n for compartmentId in compartments:\n outputFile.write(\"\\t\\tself.c[\\'\" + compartmentId + \"\\'] = Compartment(\" + str(compartments[compartmentId].size) + \", \" + str(compartments[compartmentId].dimensionality)+ \", \" + str(compartments[compartmentId].isConstant) + \")\\n\")\n \n outputFile.write(\"\\n\\t\\tself.s = {} #Dictionary of chemical species\\n\")\n for speciesId in species:\n outputFile.write(\"\\t\\tspeciesMetadata = SBMLMetadata('\" + species[speciesId].name +\"')\\n\")\n outputFile.write(\"\\t\\tself.s[\\'\" + speciesId + \"\\'] = Species(\" + str(species[speciesId].value) + \", '\" + species[speciesId].valueType + \"', self.c['\" + species[speciesId].compartment + \"'], \" + str(species[speciesId].hasOnlySubstanceUnits) + \", constant = \" + str(species[speciesId].isConstant) + \")\\n\")\n for key, rule in assignmentRules.items():\n if rule.variable == speciesId:\n outputFile.write(\"\\t\\tself.s[\\'\" + speciesId + \"\\']._modifiedBy = \" + rule.Id + \"\\n\")\n for key, rule in rateRules.items():\n if rule.variable == speciesId:\n outputFile.write(\"\\t\\tself.s[\\'\" + speciesId + \"\\']._modifiedBy = \" + rule.Id + \"\\n\")\n \n \n outputFile.write(\"\\n\\t\\tself.r = {} #Dictionary of reactiions\\n\")\n for reactionId in reactions:\n outputFile.write(\"\\t\\tself.r[\\'\" + reactionId + \"\\'] = \" + reactionId + \"(self, SBMLMetadata('\" + reactions[reactionId].name + \"'))\\n\")\n \n outputFile.write(\"\\t\\tself.time = 0\\n\\n\")\n \n outputFile.write(\"\\t\\tself.reactionMetadata = {\")\n commaFlag = 0\n for reactionId in reactions:\n if commaFlag == 0:\n commaFlag = 1\n outputFile.write(\"\\n\\t\\t\")\n else:\n outputFile.write(\",\\n\\t\\t\")\n outputFile.write(\"self.Reaction\" + reactionId + \": SBMLMetadata('\" + reactions[reactionId].name + \"')\")\n outputFile.write(\"\\n\\t\\t}\\n\")\n \n outputFile.write('\\t\\tself.AssignmentRules()\\n\\n')\n \n outputFile.write(\"\\n\\n\")\n outputFile.write(\"\\tdef AssignmentRules(self):\\n\\n\")\n #These functions are defined here due to reading variables in the parent function's namespace\n #These are not intended to be used elsewhere\n def ParseLHS(rawLHS):\n returnLHS = ''\n if rawLHS in parameters:\n returnLHS = \"self.p[\\'\" + rawLHS + \"\\'].value = \"\n elif rawLHS in species:\n if not species[rawLHS].hasOnlySubstanceUnits: \n returnLHS = 'self.s[\\'' + rawLHS + '\\'].concentration = '\n else: \n returnLHS = 'self.s[\\'' + rawLHS + '\\'].amount = '\n elif rawLHS in compartments:\n returnLHS = 'self.c[\\'' + rawLHS + '\\'].size = '\n else:\n raise(Exception(\"New case: rule LHS not in p: \" + rawLHS))\n\n return returnLHS\n\t\n def ParseRHS(rawRHS, extendedParams = [], objectText = \"self\"):\n #objectText is not \"self\" when parsing reaction math\n \n #The main purpose of this function is to turn math strings given by libSBML into\n #code formated to properly call members of the resulting class\n #For example k_1*C_A may turn to\n \n \n rawRHS = rawRHS.replace(\"^\", \"**\") #Replaces carrot notation for exponentiation with ** operator\n variables = []\n for match in re.finditer(r'\\b[a-zA-Z_]\\w*', rawRHS): #look for variable names\n #ToDo: check for function calls\n variables.append([rawRHS[match.start():match.end()], match.span()])\n \n #rule[1] contains the right hand side\n returnRHS = ''\n oldSpan = None\n if variables != []:\n for variable in variables:\n if oldSpan == None and variable[1][0] != 0:\n returnRHS += rawRHS[0:variable[1][0]]\n elif oldSpan != None:\n returnRHS += rawRHS[oldSpan[1]:variable[1][0]]\n oldSpan = variable[1]\n if variable[0] in parameters:\n returnRHS += objectText + '.p[\\'' + variable[0] + '\\'].value'\n elif variable[0] in species:\n if not species[variable[0]].hasOnlySubstanceUnits == \"True\": \n returnRHS += objectText + '.s[\\'' + variable[0] + '\\'].concentration'\n else: \n returnRHS += objectText + '.s[\\'' + variable[0] + '\\'].amount'\n elif variable[0] in compartments:\n returnRHS += objectText + '.c[\\'' + variable[0] + '\\'].size'\n elif variable[0] in mathFuncs:\n returnRHS += mathFuncs[variable[0]]\n elif variable[0] in functions:\n returnRHS += objectText + '.' + variable[0]\n elif variable[0] in extendedParams:\n if objectText == \"self\":\n returnRHS += variable[0]\n else:\n returnRHS += \"self.p[\\'\" + variable[0] + \"\\'].value\"\n\n elif variable[0] == \"time\":\n returnRHS += objectText + '.time'\n elif variable[0] == \"pi\":\n returnRHS += \"np.pi\"\n else:\n raise(Exception('New case: unkown RHS variable: ' + variable[0]))\n returnRHS += rawRHS[variable[1][1]:len(rawRHS)]\n # print(rule[1][variable[1][1]])\n #print(rule[1][-1])\n else:\n returnRHS = rawRHS\n\t\t\n return returnRHS\n\n ruleDefinedVars = [rule.variable for rule in assignmentRules.values()]\n for key, assignment in initialAssignments.items():\n ruleDefinedVars.append(assignment.variable)\n \n for key, rule in assignmentRules.items():\n rule.dependents = []\n for match in re.finditer(r'\\b[a-zA-Z_]\\w*', rule.math): #look for variable names\n rule.dependents.append(rule.math[match.start():match.end()])\n originalLen = len(rule.dependents)\n for i in range(originalLen):\n if rule.dependents[originalLen - i -1] not in ruleDefinedVars:\n rule.dependents.pop(originalLen- i-1)\n \n for key, assignment in initialAssignments.items():\n assignment.dependents = []\n for match in re.finditer(r'\\b[a-zA-Z_]\\w*', assignment.math): #look for variable names\n assignment.dependents.append(assignment.math[match.start():match.end()])\n originalLen = len(assignment.dependents)\n for i in range(originalLen):\n if assignment.dependents[originalLen - i -1] not in ruleDefinedVars :\n assignment.dependents.pop(originalLen- i-1)\n \n# breakVar = False\n while True:\n continueVar = False\n breakVar = True\n varDefinedThisLoop = None\n for key, rule in assignmentRules.items():\n if rule.dependents == []:\n ruleLHS = ParseLHS(rule.variable)\n ruleRHS = ParseRHS(rule.math)\n outputFile.write(\"\\t\\t\" + ruleLHS + ruleRHS + '\\n\\n')\n varDefinedThisLoop = rule.variable\n rule.dependents = None\n continueVar = True\n breakVar = False\n break\n elif not rule.dependents == None:\n breakVar = False\n \n if not continueVar:\n for key, assignment in initialAssignments.items():\n if assignment.dependents == []:\n assignmentLHS = ParseLHS(assignment.variable)\n assignmentRHS = ParseRHS(assignment.math)\n outputFile.write(\"\\t\\tif self.time <= 0 :\\n\")\n if assignment.variable in parameters:\n outputFile.write(\"\\t\\t\\tisConstantValue = self.p['\" + assignment.variable + \"']._constant\\n\")\n outputFile.write(\"\\t\\t\\tself.p['\" + assignment.variable + \"']._constant = False\\n\")\n outputFile.write(\"\\t\\t\\t\" + assignmentLHS + assignmentRHS + '\\n')\n outputFile.write(\"\\t\\t\\tself.p['\" + assignment.variable + \"']._constant = isConstantValue\\n\\n\")\n elif assignment.variable in species:\n outputFile.write(\"\\t\\t\\tisConstantValue = self.s['\" + assignment.variable + \"']._constant\\n\")\n outputFile.write(\"\\t\\t\\tself.s['\" + assignment.variable + \"']._constant = False\\n\")\n outputFile.write(\"\\t\\t\\t\" + assignmentLHS + assignmentRHS + '\\n')\n outputFile.write(\"\\t\\t\\tself.s['\" + assignment.variable + \"']._constant = isConstantValue\\n\\n\")\n elif assignment.variable in compartment:\n outputFile.write(\"\\t\\t\\tisConstantValue = self.c['\" + assignment.variable + \"']._constant\\n\")\n outputFile.write(\"\\t\\t\\tself.c['\" + assignment.variable + \"']._constant = False\\n\")\n outputFile.write(\"\\t\\t\\t\" + assignmentLHS + assignmentRHS + '\\n')\n outputFile.write(\"\\t\\t\\tself.c['\" + assignment.variable + \"']._constant = isConstantValue\\n\\n\")\n \n varDefinedThisLoop = assignment.variable\n assignment.dependents = None\n continueVar = True\n breakVar = False\n break\n elif not rule.dependents == None:\n breakVar = False\n \n for rule in assignmentRules.values():\n if not rule.dependents == None:\n originalLen = len(rule.dependents)\n for i in range(originalLen):\n if rule.dependents[originalLen - i -1] == varDefinedThisLoop:\n rule.dependents.pop(originalLen - i -1)\n# print(rule.variable + ':' + str(rule.dependents))\n\n for assignment in initialAssignments.values():\n if not assignment.dependents == None:\n originalLen = len(assignment.dependents)\n for i in range(originalLen):\n if assignment.dependents[originalLen - i - 1] == varDefinedThisLoop:\n assignment.dependents.pop(originalLen - i - 1)\n# print(assignment.variable + ':' + str(assignment.dependents))\n \n if continueVar:\n continue\n elif breakVar:\n break\n else:\n raise Exception('Algebraic Loop in AssignmentRules')\n \n outputFile.write(\"\\t\\treturn\\n\\n\")\n \n for functionId in functions:\n arguments = functions[functionId].arguments\n argumentString = \"\"\n for i in range(len(arguments)):\n argumentString += arguments[i]\n if i != len(arguments) - 1:\n argumentString += \", \"\n \n outputFile.write(\"\\tdef \" + functionId + \"(self, \" + argumentString + \"):\\n\")\n outputFile.write(\"\\t\\treturn \" + functions[functionId].mathString.replace(\"^\", \"**\") + \"\\n\")\n \n for reactionId in reactions:\n outputFile.write(\"\\tdef Reaction\" + str(reactionId) + \"(self):\\n\\n\")\n\n rxnParameters = []\n for param in reactions[reactionId].rxnParameters:\n outputFile.write(\"\\t\\t\" + param[0] + \" = \" + str(param[1]) + \"\\n\")\n rxnParameters.append(param[0])\n\t\t\t\n rateLaw = ParseRHS(reactions[reactionId].rateLaw, rxnParameters)\n \n outputFile.write('\\t\\treturn ' + rateLaw + '\\n\\n')\n\n rateRuleLHSVars = []\n for key, rateRule in rateRules.items():\n rateRuleLHSVars.append(rateRule.variable)\n outputFile.write(\"\\tdef Rate\" + rateRule.variable + \"(self):\\n\\n\")\n rateLaw = ParseRHS(rateRule.math)\n outputFile.write('\\t\\treturn ' + rateLaw + '\\n\\n')\n \n yArray = ''\n i = 0\n yArrayVars = [0 for x in range(len(species) + rateParams)]\n for variable, index in reactantIndex.items():\n yArrayVars[index] = variable\n \n for index in range(len(yArrayVars)):\n # print(yArrayVars[index])\n if index != 0:\n yArray += ', '\n \n if yArrayVars[index] in species:\n yArray += 'self.s[\\'' + yArrayVars[index] + '\\'].amount'\n continue\n \n if yArrayVars[index] in parameters:\n yArray += 'self.p[\\'' + yArrayVars[index] + '\\'].value'\n continue\n \n if yArrayVars[index] in compartments:\n yArray += 'self.c\\'' + yArrayVars[index] + '\\'].size'\n continue\n \n\n \n outputFile.write('\\tdef _SolveReactions(self, y, t):\\n\\n')\n outputFile.write('\\t\\tself.time = t\\n')\n outputFile.write('\\t\\t' + yArray + ' = y\\n')\n outputFile.write('\\t\\tself.AssignmentRules()\\n\\n')\n# outputFile.write('\\t\\t[self.s[speciesId].UpdateCompartmentSizeMember() for speciesId in self.s]\\n')\n rateArray = '[ '\n i = 0\n rateArrayVars = [0 for x in range(len(species) + rateParams)]\n \n for variable, index in reactantIndex.items():\n if variable in rateRuleLHSVars:\n rateArrayVars[index] = variable\n \n\n \n for variable in rateArrayVars:\n if i != 0:\n rateArray += ', '\n i += 1\n if variable == 0:\n rateArray += '0'\n else:\n rateArray += 'self.Rate' + variable + '()'\n \n \n \n \n rateArray += ']'\n outputFile.write('\\t\\trateRuleVector = np.array(' + str(rateArray) + ', dtype = np.float64)\\n\\n') \n \n outputFile.write('\\t\\tstoichiometricMatrix = np.array(' + re.sub('\\n,', ',\\n\\t\\t\\t\\t\\t', re.sub('[^[] +', ',' ,str(stoichCoeffMat))) + ', dtype = np.float64)\\n\\n')\n outputFile.write('\\t\\treactionVelocities = np.array([')\n reactionElements = ''\n if reactions:\n for reactionId in reactions:\n if reactionElements == '':\n reactionElements += ('self.r[\\'' + str(reactionId) + '\\']()')\n else:\n reactionElements += (', self.r[\\'' + str(reactionId) + '\\']()')\n else:\n reactionElements = '0'\n outputFile.write(reactionElements + '], dtype = np.float64)\\n\\n')\n outputFile.write('\\t\\trateOfSpeciesChange = stoichiometricMatrix @ reactionVelocities + rateRuleVector\\n\\n')\n outputFile.write('\\t\\treturn rateOfSpeciesChange\\n\\n')\n \n outputFile.write('\\tdef RunSimulation(self, deltaT, absoluteTolerance = 1e-12, relativeTolerance = 1e-6):\\n\\n')\n \n outputFile.write('\\t\\tfinalTime = self.time + deltaT\\n')\n outputFile.write('\\t\\ty0 = np.array([' + yArray + '], dtype = np.float64)\\n')\n outputFile.write('\\t\\t' + yArray + ' = odeint(self._SolveReactions, y0, [self.time, finalTime], atol = absoluteTolerance, rtol = relativeTolerance, mxstep=5000000)[-1]\\n')\n outputFile.write('\\t\\tself.time = finalTime\\n')\n outputFile.write('\\t\\tself.AssignmentRules()\\n')\n# outputFile.write('\\t\\t[self.s[speciesId].UpdateCompartmentSizeMember() for speciesId in self.s]\\n')\n outputFile.write('\\n')\n \n for key in reactions.keys():\n outputFile.write('class ' + key + ':\\n\\n')\n outputFile.write('\\tdef __init__(self, parent, metadata = None):\\n\\n')\n outputFile.write('\\t\\tself.parent = parent\\n')\n outputFile.write('\\t\\tself.p = {}\\n')\n outputFile.write('\\t\\tself.metadata = metadata\\n\\n')\n for param in reactions[key].rxnParameters:\n outputFile.write(\"\\t\\tself.p[\\'\" + param[0] + \"\\'] = Parameter(\" + str(param[1]) + \", '\" + param[0] + \"')\\n\")\n #\"\\t\\tself.p[\\'\" + paramId + \"\\'] = Parameter(\" + str(parameters[paramId].value)+ \", \"+ paramId + \", \" + str(parameters[paramId].isConstant) +\")\\n\"\n \n outputFile.write('\\n\\tdef __call__(self):\\n')\n# print(key)\n# print(reactions[key].rxnParameters)\n rxnParamNames = [param[0] for param in reactions[key].rxnParameters]\n rateLaw = ParseRHS(reactions[key].rateLaw, rxnParamNames, \"self.parent\")\n outputFile.write('\\t\\treturn ' + rateLaw + '\\n\\n')\n\n \n for key in functions.keys():\n outputFile.write('class ' + key + ':\\n\\n')\n outputFile.write('\\tdef __init__(self, parent, metadata = None):\\n\\n')\n outputFile.write('\\t\\tself.parent = parent\\n')\n outputFile.write('\\t\\tself.metadata = metadata\\n\\n')\n\n arguments = functions[key].arguments\n argumentString = \"\"\n for i in range(len(arguments)):\n argumentString += arguments[i]\n if i != len(arguments) - 1:\n argumentString += \", \"\n \n outputFile.write('\\tdef __call__(self, ' + argumentString + '):\\n')\n outputFile.write(\"\\t\\treturn \" + functions[key].mathString.replace(\"^\", \"**\") + \"\\n\\n\")\n\n outputFile.close()","def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n # Load the raw CIFAR-10 data\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n\n # subsample the data\n mask = range(num_training, num_training + num_validation)\n X_val = X_train[mask]\n y_val = y_train[mask]\n mask = range(num_training)\n X_train = X_train[mask]\n y_train = y_train[mask]\n mask = range(num_test)\n X_test = X_test[mask]\n y_test = y_test[mask]\n mask = np.random.choice(num_training, num_dev, replace=False)\n X_dev = X_train[mask]\n y_dev = y_train[mask]\n\n # Preprocessing: reshape the image data into rows\n X_train = np.reshape(X_train, (X_train.shape[0], -1))\n X_val = np.reshape(X_val, (X_val.shape[0], -1))\n X_test = np.reshape(X_test, (X_test.shape[0], -1))\n X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n\n # Normalize the data: subtract the mean image\n mean_image = np.mean(X_train, axis=0)\n X_train -= mean_image\n X_val -= mean_image\n X_test -= mean_image\n X_dev -= mean_image\n\n # add bias dimension and transform into columns\n X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n\n return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev","def __init__(self, model=None):\n self.model = model\n self.model_f = None\n self.model_h = None\n self.cav = None\n self.sensitivity = None\n self.tcav_score = []\n self.y_labels = None","def load_cifar10_data(img_rows=48,\n\timg_cols=48):\n\n\t(X_train, Y_train), (X_valid, Y_valid) = cifar10.load_data()\n\n\tX_train = np.array([cv2.resize(img, (img_rows,img_cols)) for img in X_train[:,:,:,:]])\n\tX_valid = np.array([cv2.resize(img, (img_rows,img_cols)) for img in X_valid[:,:,:,:]])\n\n\tY_train = to_categorical(Y_train[:], num_classes)\n\tY_valid = to_categorical(Y_valid[:], num_classes)\n\n\treturn X_train, Y_train, X_valid, Y_valid","def _construct_model(self):\n self.model = AutoEncoderConvolutional(self.n_latent_features, self.reduced_size)\n self.model = self.model.to(self.device, non_blocking=True)","def build(self, hp):\n\n model = Sequential()\n model.add(Conv2D(filters=hp.Choice('num_filters_0', values=[8, 16, 32, 64]),\n kernel_size=hp.Choice('kernel_size_0', values=[3, 4, 5]),\n activation=hp.Choice('activation_0', values=['relu', 'tanh']),\n input_shape=self.input_shape))\n\n for i in range(hp.Int('num_layers', 1, 3)):\n model.add(Conv2D(filters=hp.Choice('num_filters_%d' % (i + 1), values=[8, 16, 32, 64]),\n kernel_size=hp.Choice('kernel_size_%d' % (i + 1), values=[3, 4, 5]),\n activation=hp.Choice('activation_%d' % (i + 1), values=['relu', 'tanh'])))\n model.add(Flatten())\n model.add(Dense(N_zern))\n model.summary()\n\n model.compile(optimizer=keras.optimizers.Adam(hp.Choice('learning_rate', values=[1e-3, 5e-4, 1e-4])),\n loss='mean_squared_error')\n return model","def __init__(self, input_dim, embed_dim, conv_layers, num_labels, batch_size, m=14):\n super(CRF, self).__init__()\n \n # crf param\n self.input_dim = input_dim\n self.embed_dim = embed_dim\n self.num_labels = num_labels\n self.batch_size = batch_size\n self.use_cuda = torch.cuda.is_available()\n self.m = m\n \n # conv layer params\n self.out_channels = 1 # output channel of conv layer\n self.conv_layers = conv_layers\n self.stride = (1,1)\n self.padding = True\n self.cout_shape = self.get_cout_dim() # output shape of conv layer\n self.cout_numel = self.cout_shape[0]*self.cout_shape[1]\n \n \n \n self.init_params()\n\n ### Use GPU if available\n if self.use_cuda:\n [m.cuda() for m in self.modules()]","def raw_model():\n model = cobra.Model(id_or_model=\"raw_model\", name=\"raw_model\")\n rxn_1 = cobra.Reaction(\"BIOMASS_TEST\")\n rxn_2 = cobra.Reaction(\"RXN2\")\n rxn_3 = cobra.Reaction(\"RXN3\")\n rxn_4 = cobra.Reaction(\"RXN4\")\n model.add_reactions([rxn_1, rxn_2, rxn_3, rxn_4])\n model.objective = rxn_3\n return model","def doParametersOfInterest(self):\n \n self.modelBuilder.doVar('expr::cosW(\"0.87681811112\",)')\n self.modelBuilder.doVar('expr::sinW(\"0.48082221247\",)')\n self.modelBuilder.doVar('expr::mZ(\"91.2\",)')\n self.modelBuilder.doVar('expr::Lambda1(\"100.0\",)')\n self.modelBuilder.doVar('expr::e2(\"0.0917\",)')\n self.modelBuilder.doVar('expr::gs2(\"1.533\",)')\n\n # EFT Higgs basis couplings\n\n self.modelBuilder.doVar('cZ[0,-1,1]') \n self.modelBuilder.doVar(\"cZZ[0,-2,2]\") \n self.modelBuilder.doVar(\"cZZt[0,-2,2]\") \n self.modelBuilder.doVar(\"cZB[0,-6,6]\") \n\n poi='cZ,cZZ,cZZt,cZB'\n\n # Amplitude couplings from EFT couplings \n\n self.modelBuilder.doVar('expr::a1(\"@0+1\",cZ)') # (\"2*(@0+1)\",cZ) in AN/Paper but a1 = 1 for signal model and width calculation\n self.modelBuilder.doVar('expr::a2(\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\",cZZ,e2,sinW,cosW)')\n self.modelBuilder.doVar('expr::a3(\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\",cZZt,e2,sinW,cosW)')\n self.modelBuilder.doVar('expr::k1(\"@0*(@1*pow(@2,2)/(pow(@3,2)*pow(@4,2)))\",cZB,e2,Lambda1,sinW,mZ)')\n self.modelBuilder.doVar('expr::k1L1(\"@0/pow(@1,2)\",k1,Lambda1)')\n\n ###### gamma_H ########\n\n # SMEFT relationships for VV couplings (Expressed using amplitude couplings)\n\n self.modelBuilder.doVar('expr::kappa(\"1.0\",)')\n self.modelBuilder.doVar('expr::kappa_tilde(\"0.0\",)') \n\n self.modelBuilder.doVar('expr::a1_WW(\"@0\",a1)')\n self.modelBuilder.doVar('expr::a2_WW(\"@0*@0*@1\",cosW,a2)')\n self.modelBuilder.doVar('expr::a3_WW(\"@0*@0*@1\",cosW,a3)')\n self.modelBuilder.doVar('expr::k1_WW(\"(@2 / (@0*@0 - @1*@1) - 2*@1*@1*@3*@4*@4 /(@5*@5*(@0*@0 - @1*@1)))\",cosW,sinW,k1,a2,Lambda1,mZ)')\n self.modelBuilder.doVar('expr::k2_k1(\"2*@0*@1*@2/(@0*@0 - @1*@1)\",cosW,sinW,k1)')\n self.modelBuilder.doVar('expr::k2_a2(\"-2*@0*@1*@3*@4*@4/((@2*@2)*(@0*@0 - @1*@1))\",cosW,sinW,mZ,a2,Lambda1)')\n self.modelBuilder.doVar('expr::k2(\"@0 + @1\",k2_k1,k2_a2)')\n\n # Determine gamma_H from VV couplings\n\n zz_expr = '\"4*(@0*@0/4. + 0.1695*@3*@3 + 0.09076*@1*@1 + 0.03809*@2*@2 + 0.8095*@0*@3/2. + 0.5046*@0*@1/2. + 0.2092*@1*@3 + 0.1023*@4*@4 + 0.1901*@0*@4/2. + 0.07429*@3*@4 + 0.04710*@1*@4) \",a1,a2,a3,k1,k2'\n ww_expr = '\"4*(@0*@0/4. + 0.1320*@3*@3 + 0.1944*@1*@1 + 0.08075*@2*@2 + 0.7204*@0*@3/2. + 0.7437*@0*@1/2. + 0.2774*@3*@1) \",a1_WW,a2_WW,a3_WW,k1_WW'\n zgamma_expr = '\"4*(1.118600*@0*@0/4. +0.0035*@1*@1 - 0.125010*@0*@1/2. + 0.000003*@1*@1 - 0.00018*@1*@1 + 0.003100*@0*@1/2. +0.00126*@2*@2 + 0.000005*@2*@2 -0.00047*@2*@2)\",a1_WW,kappa,kappa_tilde'\n gg_expr = '\"(1.1068*@0*@0 + 0.0082*@0*@0 - 0.1150*@0*@0 + 2.5717*@1*@1 + 0.0091*@1*@1 - 0.1982*@1*@1)\",kappa,kappa_tilde'\n bb_expr = '\"(@0*@0 + @1*@1)\",kappa,kappa_tilde'\n cc_expr = '\"(@0*@0 + @1*@1)\",kappa,kappa_tilde'\n tautau_expr = '\"(@0*@0 + @1*@1)\",kappa,kappa_tilde'\n mumu_expr = '\"(@0*@0 + @1*@1)\",kappa,kappa_tilde'\n gmgm_expr = '\"4*(1.6054*@0*@0/4. + 0.07312*@1*@1 - 0.6854*@0*@1/2. + 0.00002*@1*@1 - 0.0018*@1*@1 + 0.0085*@0*@1/2. + 0.1699*@2*@2 + 0.00002*@2*@2 - 0.0031*@2*@2)\",a1_WW,kappa,kappa_tilde'\n \n self.modelBuilder.doVar('expr::R_WW('+str(ww_expr)+')')\n self.modelBuilder.doVar('expr::R_ZZ('+str(zz_expr)+')')\n self.modelBuilder.doVar('expr::R_Zgamma('+str(zgamma_expr)+')')\n self.modelBuilder.doVar('expr::R_gg('+str(gg_expr)+')')\n self.modelBuilder.doVar('expr::R_bb('+str(bb_expr)+')')\n self.modelBuilder.doVar('expr::R_cc('+str(cc_expr)+')')\n self.modelBuilder.doVar('expr::R_tautau('+str(tautau_expr)+')')\n self.modelBuilder.doVar('expr::R_mumu('+str(mumu_expr)+')')\n self.modelBuilder.doVar('expr:R_gammagamma('+str(gmgm_expr)+')')\n\n self.modelBuilder.doVar('expr::gammaH(\"(0.5824*@0 + 0.2137*@1 + 0.08187*@2 + 0.06272*@3 + 0.02891*@4 + 0.02619*@5 + 0.002270*@6 + 0.001533*@7 + 0.0002176*@8 )/0.9998\",R_bb,R_WW,R_gg,R_tautau,R_cc,R_ZZ,R_gammagamma,R_Zgamma,R_mumu)') \n\n ###########################\n\n self.g1V = GetCoupTerms(1,1,1,-0.0001,\"1V\") # Compensate for scaling of k1 templates \n self.g2V = GetCoupTerms(1,1,1,-0.0001,\"2V\") \n \n self.modelBuilder.doVar(\"expr::g2V_1(\\\"\"+str(self.g2V[0])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T1(\\\"((pow(@0,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T1_Neg(\\\"-1*((pow(@0,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\") \n self.modelBuilder.doVar(\"expr::g2V_2(\\\"\"+str(self.g2V[1])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T2(\\\"((pow(@0,3)*@1)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T2_Neg(\\\"-1*((pow(@0,3)*@1)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\") \n self.modelBuilder.doVar(\"expr::g2V_3(\\\"\"+str(self.g2V[2])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T3(\\\"((pow(@0,2)*pow(@1,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T3_Neg(\\\"-1*((pow(@0,2)*pow(@1,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\") \n self.modelBuilder.doVar(\"expr::g2V_4(\\\"\"+str(self.g2V[3])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T4(\\\"((@0*pow(@1,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T4_Neg(\\\"-1*((@0*pow(@1,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\") \n self.modelBuilder.doVar(\"expr::g2V_5(\\\"\"+str(self.g2V[4])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T5(\\\"((pow(@1,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T5_Neg(\\\"-1*((pow(@1,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\") \n self.modelBuilder.doVar(\"expr::g2V_6(\\\"\"+str(self.g2V[5])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T6(\\\"((pow(@0,3)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T6_Neg(\\\"-1*((pow(@0,3)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\") \n self.modelBuilder.doVar(\"expr::g2V_7(\\\"\"+str(self.g2V[6])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T7(\\\"((pow(@0,2)*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T7_Neg(\\\"-1*((pow(@0,2)*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\") \n self.modelBuilder.doVar(\"expr::g2V_8(\\\"\"+str(self.g2V[7])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T8(\\\"((@0*pow(@2,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T8_Neg(\\\"-1*((@0*pow(@2,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\") \n self.modelBuilder.doVar(\"expr::g2V_9(\\\"\"+str(self.g2V[8])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T9(\\\"((pow(@2,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T9_Neg(\\\"-1*((pow(@2,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\") \n self.modelBuilder.doVar(\"expr::g2V_10(\\\"\"+str(self.g2V[9])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T10(\\\"((pow(@0,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T10_Neg(\\\"-1*((pow(@0,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\") \n self.modelBuilder.doVar(\"expr::g2V_11(\\\"\"+str(self.g2V[10])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T11(\\\"((pow(@0,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T11_Neg(\\\"-1*((pow(@0,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\") \n self.modelBuilder.doVar(\"expr::g2V_12(\\\"\"+str(self.g2V[11])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T12(\\\"((@0*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T12_Neg(\\\"-1*((@0*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\") \n self.modelBuilder.doVar(\"expr::g2V_13(\\\"\"+str(self.g2V[12])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T13(\\\"((pow(@3,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T13_Neg(\\\"-1*((pow(@3,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\") \n self.modelBuilder.doVar(\"expr::g2V_14(\\\"\"+str(self.g2V[13])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T14(\\\"((pow(@1,3)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T14_Neg(\\\"-1*((pow(@1,3)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\") \n self.modelBuilder.doVar(\"expr::g2V_15(\\\"\"+str(self.g2V[14])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T15(\\\"((pow(@1,2)*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T15_Neg(\\\"-1*((pow(@1,2)*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\") \n self.modelBuilder.doVar(\"expr::g2V_16(\\\"\"+str(self.g2V[15])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T16(\\\"((@1*pow(@2,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T16_Neg(\\\"-1*((@1*pow(@2,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\") \n self.modelBuilder.doVar(\"expr::g2V_17(\\\"\"+str(self.g2V[16])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T17(\\\"((pow(@1,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T17_Neg(\\\"-1*((pow(@1,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\") \n self.modelBuilder.doVar(\"expr::g2V_18(\\\"\"+str(self.g2V[17])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T18(\\\"((pow(@1,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T18_Neg(\\\"-1*((pow(@1,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\") \n self.modelBuilder.doVar(\"expr::g2V_19(\\\"\"+str(self.g2V[18])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T19(\\\"((@1*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T19_Neg(\\\"-1*((@1*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\") \n self.modelBuilder.doVar(\"expr::g2V_20(\\\"\"+str(self.g2V[19])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T20(\\\"((pow(@2,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T20_Neg(\\\"-1*((pow(@2,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\") \n self.modelBuilder.doVar(\"expr::g2V_21(\\\"\"+str(self.g2V[20])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T21(\\\"((pow(@2,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T21_Neg(\\\"-1*((pow(@2,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\") \n self.modelBuilder.doVar(\"expr::g2V_22(\\\"\"+str(self.g2V[21])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T22(\\\"((@2*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T22_Neg(\\\"-1*((@2*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\") \n self.modelBuilder.doVar(\"expr::g2V_23(\\\"\"+str(self.g2V[22])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T23(\\\"((@0*@1*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T23_Neg(\\\"-1*((@0*@1*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\") \n self.modelBuilder.doVar(\"expr::g2V_24(\\\"\"+str(self.g2V[23])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T24(\\\"((@0*pow(@1,2)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T24_Neg(\\\"-1*((@0*pow(@1,2)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\") \n self.modelBuilder.doVar(\"expr::g2V_25(\\\"\"+str(self.g2V[24])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T25(\\\"((pow(@0,2)*@1*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T25_Neg(\\\"-1*((pow(@0,2)*@1*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\") \n self.modelBuilder.doVar(\"expr::g2V_26(\\\"\"+str(self.g2V[25])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T26(\\\"((@0*@1*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T26_Neg(\\\"-1*((@0*@1*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\") \n self.modelBuilder.doVar(\"expr::g2V_27(\\\"\"+str(self.g2V[26])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T27(\\\"((@0*pow(@1,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T27_Neg(\\\"-1*((@0*pow(@1,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\") \n self.modelBuilder.doVar(\"expr::g2V_28(\\\"\"+str(self.g2V[27])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T28(\\\"((pow(@0,2)*@1*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T28_Neg(\\\"-1*((pow(@0,2)*@1*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\") \n self.modelBuilder.doVar(\"expr::g2V_29(\\\"\"+str(self.g2V[28])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T29(\\\"((@0*@2*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T29_Neg(\\\"-1*((@0*@2*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\") \n self.modelBuilder.doVar(\"expr::g2V_30(\\\"\"+str(self.g2V[29])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T30(\\\"((@0*pow(@2,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T30_Neg(\\\"-1*((@0*pow(@2,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\") \n self.modelBuilder.doVar(\"expr::g2V_31(\\\"\"+str(self.g2V[30])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T31(\\\"((pow(@0,2)*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T31_Neg(\\\"-1*((pow(@0,2)*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\") \n self.modelBuilder.doVar(\"expr::g2V_32(\\\"\"+str(self.g2V[31])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T32(\\\"((@1*@2*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T32_Neg(\\\"-1*((@1*@2*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\") \n self.modelBuilder.doVar(\"expr::g2V_33(\\\"\"+str(self.g2V[32])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T33(\\\"((@1*pow(@2,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T33_Neg(\\\"-1*((@1*pow(@2,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\") \n self.modelBuilder.doVar(\"expr::g2V_34(\\\"\"+str(self.g2V[33])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T34(\\\"((pow(@1,2)*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T34_Neg(\\\"-1*((pow(@1,2)*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\") \n self.modelBuilder.doVar(\"expr::g2V_35(\\\"\"+str(self.g2V[34])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T35(\\\"((@0*@1*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T35_Neg(\\\"-1*((@0*@1*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\") \n \n self.modelBuilder.doVar(\"expr::g1V_1(\\\"\"+str(self.g1V[0])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T1(\\\"((pow(@0,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T1_Neg(\\\"-1*((pow(@0,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\") \n self.modelBuilder.doVar(\"expr::g1V_2(\\\"\"+str(self.g1V[1])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T2(\\\"((@0*@1)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T2_Neg(\\\"-1*((@0*@1)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\") \n self.modelBuilder.doVar(\"expr::g1V_3(\\\"\"+str(self.g1V[2])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T3(\\\"((pow(@1,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T3_Neg(\\\"-1*((pow(@1,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\") \n self.modelBuilder.doVar(\"expr::g1V_4(\\\"\"+str(self.g1V[3])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T4(\\\"((@0*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T4_Neg(\\\"-1*((@0*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\") \n self.modelBuilder.doVar(\"expr::g1V_5(\\\"\"+str(self.g1V[4])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T5(\\\"((pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T5_Neg(\\\"-1*((pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\") \n self.modelBuilder.doVar(\"expr::g1V_6(\\\"\"+str(self.g1V[5])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T6(\\\"((@0*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T6_Neg(\\\"-1*((@0*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\") \n self.modelBuilder.doVar(\"expr::g1V_7(\\\"\"+str(self.g1V[6])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T7(\\\"((pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T7_Neg(\\\"-1*((pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\") \n self.modelBuilder.doVar(\"expr::g1V_8(\\\"\"+str(self.g1V[7])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T8(\\\"((@1*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T8_Neg(\\\"-1*((@1*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\") \n self.modelBuilder.doVar(\"expr::g1V_9(\\\"\"+str(self.g1V[8])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T9(\\\"((@1*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T9_Neg(\\\"-1*((@1*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\") \n self.modelBuilder.doVar(\"expr::g1V_10(\\\"\"+str(self.g1V[9])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T10(\\\"((@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T10_Neg(\\\"-1*((@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\") \n \n self.modelBuilder.doSet(\"POI\",poi)","def __init__(self):\n self.name = \"Osyczka\"\n objectives = [ob_os_1, ob_os_2]\n constraints = [con_os_1, con_os_2, con_os_3, con_os_4, con_os_5, con_os_6]\n decisions = [Decision(0, 10), Decision(0, 10), Decision(1, 5), Decision(0, 6), Decision(1, 5), Decision(0, 10)]\n Model.__init__(self, objectives, constraints, decisions)","def loadData(self):\n # Load the raw CIFAR-10 data\n num_training = 49000\n num_validation = 1000\n num_test = 1000\n subtract_mean = True\n\n cifar10_dir = '/home/parallels/PycharmProjects/Courses/232A/project2/stats232a/datasets/cifar-10-batches-py'\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n\n # Subsample the data\n mask = list(range(num_training, num_training + num_validation))\n X_val = X_train[mask]\n y_val = y_train[mask]\n mask = list(range(num_training))\n X_train = X_train[mask]\n y_train = y_train[mask]\n mask = list(range(num_test))\n X_test = X_test[mask]\n y_test = y_test[mask]\n\n # Normalize the data: subtract the mean image\n if subtract_mean:\n mean_image = np.mean(X_train, axis=0)\n X_train -= mean_image\n X_val -= mean_image\n X_test -= mean_image\n\n # Transpose so that channels come first\n X_train = X_train.transpose(0, 3, 1, 2)\n X_val = X_val.transpose(0, 3, 1, 2)\n X_test = X_test.transpose(0, 3, 1, 2)\n\n # Package data into a dictionary\n self.data = {\n 'X_train': X_train, 'y_train': y_train,\n 'X_val': X_val, 'y_val': y_val,\n 'X_test': X_test, 'y_test': y_test,\n }","def __init__(self,model,device):\n self.model = model\n self.device = device","def create_model(data, cont, cat, target): \n\n cont_features = '+'.join(cont)\n\n cat_features = '+'.join([f'C({x})' for x in cat])\n\n f = f'{target}~+{cont_features}+{cat_features}'\n\n print(f)\n\n model = smf.ols(formula=f, data=data).fit()\n \n diagnose_model(model)\n \n return model","def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n # Load the raw CIFAR-10 data\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n \n # Subsample the data\n mask = range(num_training, num_training + num_validation)\n X_val = X_train[mask]\n y_val = y_train[mask]\n mask = range(num_training)\n X_train = X_train[mask]\n y_train = y_train[mask]\n mask = range(num_test)\n X_test = X_test[mask]\n y_test = y_test[mask]\n\n # Normalize the data: subtract the mean image\n mean_image = np.mean(X_train, axis=0)\n X_train -= mean_image\n X_val -= mean_image\n X_test -= mean_image\n\n # Reshape data to rows\n X_train = X_train.reshape(num_training, -1)\n X_val = X_val.reshape(num_validation, -1)\n X_test = X_test.reshape(num_test, -1)\n\n pca = decomposition.PCA(n_components=None, whiten=False)\n X_train = pca.fit_transform(X_train)\n X_val = pca.transform(X_val)\n X_test = pca.transform(X_test)\n\n return X_train, y_train, X_val, y_val, X_test, y_test","def __init__(self, input_dim, conv_layers, num_labels, batch_size):\n super(CRF, self).__init__()\n\n self.input_dim = input_dim\n self.crf_input_dim = None # Calculated inside init_params() based on Conv layer I/O dims\n self.conv_layers = conv_layers\n self.num_labels = num_labels\n self.batch_size = batch_size\n\t\t#Uncomment below and remove self.use_cuda=False once all tensors are set to run on cuda\n #self.use_cuda = torch.cuda.is_available()\n self.use_cuda=False\n self.conv_objects = torch.nn.ModuleList() # Stores multiple Conv objects\n self.Ks = [] # Stores multiple Conv filters\n self.W = None # CRF parameter (node potential)\n self.T = None # CRF parameter (transition weights between node pairs)\n\n ### Use GPU if available\n if self.use_cuda:\n [m.cuda() for m in self.modules()]","def model(self) -> CameraModel:\n pass","def construct_model():\n # model = Sequential()\n # model.add(Dense(units=64, activation='relu', input_dim=100))\n # model.add(Dense(units=10, activation='softmax'))\n # model.compile(loss='categorical_crossentropy',\n # optimizer='sgd',\n # metrics=['accuracy'])\n # return model\n\n model = Sequential()\n # Input Layer\n model.add(Conv2D(64, 3, data_format='channels_last', activation='relu', padding='same',\n input_shape=(img_width, img_height, 3)))\n model.add(MaxPool2D(pool_size=2, strides=2))\n # Hidden Layer 1\n model.add(Conv2D(64, 3, activation='relu', padding='same'))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n # Hidden Layer 2\n model.add(Conv2D(128, 3, activation='relu', padding='same'))\n model.add(Conv2D(128, 3, activation='relu', padding='same', strides=2))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n # Hidden Layer 3\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\n model.add(Conv2D(256, 3, activation='relu', padding='same', strides=2))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n\n # Fully Connected Layer\n model.add(Flatten())\n # 512 Neuron Layer\n model.add(Dense(512, activation='relu'))\n model.add(Dropout(0.5))\n # Output Layer\n model.add(Dense(num_of_classes))\n model.add(Activation('softmax'))\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n return model","def genModel():\n inp = (160, 320, 3) # initial image size\n oup1 = (160, 320, 1) # gray image size\n oup2 = (80, 320, 1) # cropped image size\n\n model = Sequential()\n model.add(Lambda(color2gray, input_shape = inp, output_shape= oup1))\n # crop top 50 pixels, bottom 30 pixels, left/right 0 pixels\n model.add(Cropping2D(cropping=((50,30), (0,0))))\n # Preprocess incoming data, centered around zero with small standard deviation \n model.add(Lambda(lambda x: x/127.5 - 1., output_shape= oup2))\n model.add(Convolution2D(24,5,5,subsample=(1,2), activation=\"relu\"))\n model.add(Convolution2D(36,5,5,subsample=(2,2), activation=\"relu\"))\n model.add(Convolution2D(48,5,5,subsample=(2,2), activation=\"relu\"))\n model.add(Convolution2D(64,3,3, activation=\"relu\"))\n model.add(Convolution2D(64,3,3, activation=\"relu\"))\n model.add(Flatten())\n model.add(Dropout(0.3))\n model.add(Dense(180, activation=\"relu\"))\n model.add(Dense(60))\n model.add(Dense(10, activation=\"relu\"))\n model.add(Dense(1))\n # print layer size for each model layers\n for layer in model.layers:\n print(layer.get_output_at(0).get_shape().as_list())\n return model","def __train__(self):\n if (self.type_camf == 'CAMF_CI'):\n #users, items, context, ratings\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = ci.fit()\n elif (self.type_camf == 'CAMF_CU'):\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = cu.fit()\n elif (self.type_camf == 'CAMF_C'):\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = c.fit()\n\n dummy_pred = np.zeros((predictions.shape))\n for r, pred_array in enumerate(predictions):\n for c, pred in enumerate(pred_array):\n dummy_pred[r][c] = self.__check_ratings__(pred)\n predictions = dummy_pred\n #save a plot with a loss function\n plots = prs.PlotRSData()\n #print(losses)\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\"_loop\"+str(self.loop))\n pd.DataFrame(losses).to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ +\"losses_loop\"+str(self.loop)+\".csv\")\n print('Saving the feature matrix...')\n # set predictions back to the pivot table\n self.__utility_saved_training__(predictions) \n # save results\n self.utility_predictions.to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ + \"_SGD_predictions_loop\"+str(self.loop)+\".csv\")","def get_classification(self, image):\n # return TrafficLight.RED\n # TODO implement light color prediction\n # creating an image object \n img_np = np.array(image) \n\n # convert np array to tensor\n input_tensor = tf.convert_to_tensor(img_np)\n\n # The model expects a batch of images, so add an axis with `tf.newaxis`.\n input_tensor = input_tensor[tf.newaxis, ...]\n\n\n detections = self.loaded(input_tensor)\n\n num_detections = int(detections.pop('num_detections'))\n\n # detection_classes should be ints.\n detections_dict = {key: value[0, :num_detections].numpy() for key, value in detections.items()}\n\n\n # detection_classes should be ints.\n detections_dict['detection_classes'] = detections_dict['detection_classes'].astype(np.int64)\n\n label_id_offset = 1\n\n # DEBUG - can do it in a cleaner way :0\n tl_classes = {3: 'green', 2: 'red'}\n top_classes_prediction = list(detections_dict['detection_classes']+label_id_offset)[:5] \n #print(top_classes_prediction)\n for i in range(len(top_classes_prediction)):\n if top_classes_prediction[i] == 2:\n top_classes_prediction[i] = 'green'\n elif top_classes_prediction[i] == 3:\n top_classes_prediction[i] = 'red'\n\n\n #print(\"--------->\", image_path, \"<-----------\")\n #print( top_classes_prediction ) \n #print(detections_dict['detection_scores'][:5], '\\n' )\n\n # basic red tl logic\n if top_classes_prediction[0] == 'red' and detections_dict['detection_scores'][0] >= 0.60:\n #print(\"-------------> RED TRAFFIC LIGHT <----------------\\n\")\n self.current_light = TrafficLight.RED\n #rospy.logwarn( \"----------------- Taffic light is RED !!! -------------------- \" )\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\n else:\n #print(\"No red traffic is detected\\n\")\n self.current_light = TrafficLight.GREEN\n #rospy.logwarn( \"----------------- You're good to go !!! --------: {0} - {1} \".format(top_classes_prediction[0], detections_dict['detection_scores'][0]) )\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\n\n return self.current_light","def __init__(self,model,alpha=0,head_min=0,head_max=1,k=1,\r\n variables=[],priors=[]):\r\n \r\n import numpy as np\r\n \r\n # Append the base to the elementlist\r\n self.model = model\r\n model.elementlist.append(self)\r\n \r\n # Set orientation value\r\n self.alpha = alpha\r\n \r\n # Set potential scaling variables\r\n self.head_min = head_min\r\n self.head_max = head_max\r\n \r\n # Assign the hydraulic conductivity of the base model\r\n self.k = k\r\n \r\n # The model requires the base flow in terms of hydraulic potential (phi)\r\n # The function head_to_potential extracts the following variables:\r\n # phi_min hydraulic potential corresponding to head_min\r\n # phi_max hydraulic potential corresponding to head_max\r\n self.head_to_potential()\r\n \r\n # Check input for validity\r\n self.check_input()\r\n \r\n self.variables = variables\r\n self.priors = priors\r\n \r\n if len(self.variables) > 0:\r\n # There are some model variables specified\r\n for idx,var in enumerate(self.variables):\r\n self.model.num_params += 1\r\n exec(\"self.model.params += [self.%s]\" % var)\r\n self.model.variables += [var]\r\n self.model.priors += [self.priors[idx]]\r\n if 'name' in list(self.priors[idx].keys()):\r\n self.model.param_names += [self.priors[idx]['name']] \r\n else: \r\n self.model.param_names += ['unknown']","def get_model_data(self):\n sen_info=self._get_sensor_info()\n cam_info=lib.is_GetCameraInfo(self.hcam)\n dll_ver=lib.is_GetDLLVersion()\n dll_ver=\"{}.{}.{}\".format((dll_ver>>24),(dll_ver>>16)&0xFF,dll_ver&0xFFFF)\n return self.ModelData(py3.as_str(sen_info.strSensorName),py3.as_str(cam_info.ID),py3.as_str(cam_info.SerNo),py3.as_str(cam_info.Version),\n py3.as_str(cam_info.Date),dll_ver,cam_info.Type)","def bestModel(self, channel_type):","def get_model(summary=False):\n\timage_input=Input(shape=(220,220,5),name='image_input')\n\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\n\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\t\n\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\n\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\n\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\t\n\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\n\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\n\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\t\n\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\n\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\n\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\t\n\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\n\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\n\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\t\n\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\n\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\n\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\t\n\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\n\tbranch1_flat=Flatten()(branch6_pool1)\n\tdrop=Dropout(.3)(branch1_flat)\n\t# FC layers group\n\tdense1=Dense(512, activation='relu', name='fc1')(drop)\n\tdrop1=Dropout(.3)(dense1)\n\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\n\tdrop3=Dropout(.3)(dense2)\n\tout=Dense(2, activation='softmax', name='fc4')(drop3)\n\tmodel=Model(inputs=image_input,outputs=out)\n\treturn model","def build(self):\n input_shape_img = (None, None, 3)\n img_input = Input(shape=input_shape_img)\n roi_input = Input(shape=(None, 4))\n shared_layers = self.cnn_model.nn_base(img_input, trainable=True)\n num_anchors = len(self.C.anchor_scales) * len(self.C.anchor_ratios)\n \n output_region_proposal = self.region_proposal_net(shared_layers, num_anchors)\n output_classifier = self.classifier(shared_layers,\n self.cnn_model.classifier_layers, \n roi_input, self.C.num_roi, \n num_class=len(self.class_count), trainable=True)\n \n self.model_region_proposal = Model(img_input, output_region_proposal[:2])\n self.model_classifier = Model([img_input, roi_input], output_classifier)\n self.model_all = Model([img_input, roi_input], output_region_proposal[:2] + output_classifier)\n\n optimizer = Adam(lr=1e-5)\n self.model_region_proposal.compile(optimizer=optimizer, \n loss=[losses.rpn_loss_cls(num_anchors), \n losses.rpn_loss_regr(num_anchors)])\n self.model_classifier.compile(optimizer=optimizer, \n loss=[losses.class_loss_cls, \n losses.class_loss_regr(len(self.class_count)-1)], \n metrics={'dense_class_{}'.format(len(self.class_count)): 'accuracy'})\n self.model_all.compile(optimizer='sgd', loss='mae')\n\n # print(self.model_all.summary())\n plot_model(self.model_region_proposal, show_shapes=True, to_file='./frcnn/images/region_proposal.png')\n plot_model(self.model_classifier, show_shapes=True, to_file='./frcnn/images/classifier.png')\n plot_model(self.model_all, show_shapes=True, to_file='./frcnn/images/model_all.png')","def create_cloth_model(self, segment_dict):\r\n\r\n # List of color histograms\r\n model = []\r\n\r\n # Extract list of frames from dictionary\r\n frame_list = segment_dict[c.FRAMES_KEY]\r\n\r\n all_bboxes_in_frames = c.ALL_CLOTH_BBOXES_IN_FRAMES\r\n cl_pct_height = c.CLOTHES_BBOX_HEIGHT\r\n cl_pct_width = c.CLOTHES_BBOX_WIDTH\r\n hsv_channels = c.CLOTHING_REC_HSV_CHANNELS_NR\r\n min_size = c.MIN_CLOTH_MODEL_SIZE\r\n neck_pct_height = c.NECK_HEIGHT\r\n use_dom_color = c.CLOTHING_REC_USE_DOMINANT_COLOR\r\n use_mean_x = c.CLOTHING_REC_USE_MEAN_X_OF_FACES\r\n use_3_bboxes = c.CLOTHING_REC_USE_3_BBOXES\r\n kernel_size = c.HIST_SMOOTHING_KERNEL_SIZE\r\n\r\n if self.params is not None:\r\n if c.ALL_CLOTH_BBOXES_IN_FRAMES_KEY in self.params:\r\n all_bboxes_in_frames = self.params[\r\n c.ALL_CLOTH_BBOXES_IN_FRAMES_KEY]\r\n if c.CLOTHES_BBOX_HEIGHT_KEY in self.params:\r\n cl_pct_height = self.params[c.CLOTHES_BBOX_HEIGHT_KEY]\r\n if c.CLOTHES_BBOX_WIDTH_KEY in self.params:\r\n cl_pct_width = self.params[c.CLOTHES_BBOX_WIDTH_KEY]\r\n if c.CLOTHING_REC_HSV_CHANNELS_NR_KEY in self.params:\r\n hsv_channels = self.params[c.CLOTHING_REC_HSV_CHANNELS_NR_KEY]\r\n if c.MIN_CLOTH_MODEL_SIZE_KEY in self.params:\r\n min_size = self.params[c.MIN_CLOTH_MODEL_SIZE_KEY]\r\n if c.NECK_HEIGHT_KEY in self.params:\r\n neck_pct_height = self.params[c.NECK_HEIGHT_KEY]\r\n if c.CLOTHING_REC_USE_DOMINANT_COLOR_KEY in self.params:\r\n use_dom_color = self.params[\r\n c.CLOTHING_REC_USE_DOMINANT_COLOR_KEY]\r\n if c.CLOTHING_REC_USE_MEAN_X_OF_FACES_KEY in self.params:\r\n use_mean_x = self.params[c.CLOTHING_REC_USE_MEAN_X_OF_FACES_KEY]\r\n if c.CLOTHING_REC_USE_3_BBOXES_KEY in self.params:\r\n use_3_bboxes = self.params[c.CLOTHING_REC_USE_3_BBOXES_KEY]\r\n if c.HIST_SMOOTHING_KERNEL_SIZE_KEY in self.params:\r\n kernel_size = self.params[c.HIST_SMOOTHING_KERNEL_SIZE_KEY]\r\n\r\n min_x = sys.maxint\r\n max_x = 0\r\n mean_x = 0\r\n if use_mean_x:\r\n\r\n # Calculate mean position of face in x axis\r\n for frame_dict in frame_list:\r\n\r\n detected = frame_dict[c.DETECTED_KEY]\r\n\r\n if detected:\r\n\r\n face_bbox = frame_dict[c.DETECTION_BBOX_KEY]\r\n face_x = face_bbox[0]\r\n\r\n if face_x < min_x:\r\n min_x = face_x\r\n\r\n if face_x > max_x:\r\n max_x = face_x\r\n\r\n mean_x = int((max_x + min_x) / 2.0)\r\n\r\n for frame_dict in frame_list:\r\n\r\n detected = frame_dict[c.DETECTED_KEY]\r\n\r\n # Consider only detected faces\r\n if detected:\r\n\r\n frame_name = frame_dict[c.SAVED_FRAME_NAME_KEY]\r\n\r\n frame_path = os.path.join(self.frames_path, frame_name)\r\n\r\n face_bbox = frame_dict[c.DETECTION_BBOX_KEY]\r\n\r\n face_x = face_bbox[0]\r\n face_y = face_bbox[1]\r\n face_width = face_bbox[2]\r\n face_height = face_bbox[3]\r\n\r\n if use_3_bboxes:\r\n\r\n frame_hists = []\r\n\r\n im = cv2.imread(frame_path)\r\n\r\n # Width of whole bounding box\r\n clothes_whole_width = (face_width * cl_pct_width)\r\n\r\n # Width of single cell\r\n clothes_width = int(clothes_whole_width / 3.0)\r\n clothes_height = int(face_height * cl_pct_height)\r\n\r\n # Leftmost bounding box for clothes\r\n clothes_x0 = int(\r\n face_x + face_width / 2.0 - 1.5 * clothes_width)\r\n\r\n # Bounding box cannot start out of image\r\n if clothes_x0 < 0:\r\n if all_bboxes_in_frames:\r\n return None\r\n else:\r\n continue\r\n\r\n clothes_y0 = int(\r\n face_y + face_height + (\r\n face_height * neck_pct_height))\r\n\r\n clothes_y1 = clothes_y0 + clothes_height\r\n\r\n # Clothing bounding box must be\r\n # entirely contained by the frame\r\n height, width, depth = im.shape\r\n\r\n if ((clothes_y1 > height) or\r\n ((clothes_x0 + clothes_whole_width) > width)):\r\n if all_bboxes_in_frames:\r\n return None\r\n else:\r\n continue\r\n\r\n for i in range(0, 3):\r\n\r\n if i == 1:\r\n # Central bounding box for clothes\r\n clothes_x0 += clothes_width\r\n\r\n elif i == 2:\r\n # Rightmost bounding box for clothes\r\n clothes_x0 += clothes_width\r\n\r\n clothes_x1 = clothes_x0 + clothes_width\r\n\r\n # Get region of interest for clothes\r\n\r\n roi = im[clothes_y0:clothes_y1, clothes_x0:clothes_x1]\r\n\r\n roi_hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)\r\n\r\n hists = []\r\n\r\n mask = None\r\n\r\n if use_dom_color:\r\n\r\n mask = utils.get_dominant_color(\r\n roi_hsv, kernel_size)\r\n\r\n else:\r\n\r\n mask = cv2.inRange(roi_hsv,\r\n np.array((0., 60., 32.)),\r\n np.array((180., 255., 255.)))\r\n\r\n for ch in range(0, hsv_channels):\r\n hist = cv2.calcHist(\r\n [roi_hsv], [ch], mask, [256], [0, 255])\r\n\r\n cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)\r\n\r\n hists.append(hist)\r\n\r\n frame_hists.append(hists)\r\n\r\n model.append(frame_hists)\r\n\r\n del im\r\n\r\n else:\r\n\r\n # Get region of interest for clothes\r\n clothes_width = int(face_width * cl_pct_width)\r\n clothes_height = int(face_height * cl_pct_height)\r\n clothes_x0 = int(\r\n face_x + face_width / 2.0 - clothes_width / 2.0)\r\n\r\n if use_mean_x:\r\n # Bounding box for clothes\r\n # has fixed position in x axis\r\n clothes_x0 = int(\r\n mean_x + face_width / 2.0 - clothes_width / 2.0)\r\n\r\n clothes_y0 = int(\r\n face_y + face_height + (face_height * neck_pct_height))\r\n clothes_x1 = clothes_x0 + clothes_width\r\n clothes_y1 = clothes_y0 + clothes_height\r\n\r\n # Bounding box cannot start out of image\r\n if clothes_x0 < 0:\r\n if all_bboxes_in_frames:\r\n return None\r\n else:\r\n continue\r\n\r\n im = cv2.imread(frame_path)\r\n\r\n # Clothing bounding box must be\r\n # entirely contained by the frame\r\n height, width, depth = im.shape\r\n\r\n if (clothes_y1 > height) or (clothes_x1 > width):\r\n if all_bboxes_in_frames:\r\n return None\r\n else:\r\n continue\r\n\r\n roi = im[clothes_y0:clothes_y1, clothes_x0:clothes_x1]\r\n\r\n roi_hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)\r\n\r\n hists = []\r\n\r\n if use_dom_color:\r\n\r\n mask = utils.get_dominant_color(\r\n roi_hsv, kernel_size)\r\n\r\n else:\r\n\r\n mask = cv2.inRange(roi_hsv,\r\n np.array((0., 60., 32.)),\r\n np.array((180., 255., 255.)))\r\n\r\n for ch in range(0, hsv_channels):\r\n hist = cv2.calcHist(\r\n [roi_hsv], [ch], mask, [256], [0, 255])\r\n\r\n cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)\r\n\r\n hists.append(hist)\r\n\r\n model.append(hists)\r\n\r\n del im\r\n\r\n # Check model size\r\n model_size = len(model)\r\n\r\n if model_size >= min_size:\r\n return model\r\n else:\r\n return None","def __init__(self, model, X_lower, X_upper):\n self.model = model\n self.X_upper = X_upper\n self.X_lower = X_lower","def mgcNetArch(self, **kwargs):\n\n def_vals = {\"input_img_rows\" : self.input_img_rows,\n \"input_img_cols\" : self.input_img_cols,\n \"channels\" : self.channels,\n \"nb_classes\" : self.nb_classes,\n \"outLayer\" : 'gloAvg', \n \"l2_val\" : 0.00, \n \"net_architr\" : 'cnn_max', \n \"block_typex\" : 'basic', \n \"block_repeatx\" : [1, 1]\n }\n\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n _input_img_rows = kwargs['input_img_rows']\n _input_img_cols = kwargs['input_img_cols']\n _channels = kwargs['channels']\n _nb_classes = kwargs['nb_classes']\n _outLayer = kwargs['outLayer']\n _l2_val = kwargs['l2_val']\n _net_architr = kwargs['net_architr']\n _block_typex = kwargs['block_typex']\n _block_repeatx = kwargs['block_repeatx']\n \n \n params = {\"input_img_rows\" : _input_img_rows,\n \"input_img_cols\" : _input_img_cols,\n \"channels\" : _channels,\n \"nb_classes\" : _nb_classes\n }\n \n print(_net_architr)\n if _net_architr == 'cnn_max':\n model = mgcNetArchMax(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'cnn_stride':\n model = mgcNetArchStride2(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'cnn_stride_mini':\n model = mgcNetArchStride2Mini(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'common_cnn':\n model = mgcNetArchCommonCnn(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'net_in_net':\n model = mgcNetArchNin(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'resnet':\n model = mgcResnet(block_type = _block_typex, block_repeat = _block_repeatx, **params)\n \n elif _net_architr == 'resblock':\n model = mgcNetArchRes(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'skipconnect':\n model = mgcNetArchSkip(outLayer = _outLayer, l2_val = _l2_val, **params)\n elif _net_architr == 'skipconnect_mini':\n model = mgcNetArchSkipMini(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n self.model = model\n self.plot_model = SVG(model_to_dot(model, show_shapes = True).create(prog='dot', format='svg'))\n #self.model_summary = model.summary() \n \n return self","def generation_model(self, z, c): # P(x|z, c)\n z_c = torch.cat((z, c), dim=1)\n x_hat = self.decoder(z_c)\n return x_hat","def generation_model(self, z, c): # P(x|z, c)\n z_c = torch.cat((z, c), dim=1)\n x_hat = self.decoder(z_c)\n return x_hat","def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n # Load the raw CIFAR-10 data\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n\n # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n try:\n del X_train, y_train\n del X_test, y_test\n print('Clear previously loaded data.')\n except:\n pass\n\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n\n # Subsample the data\n mask = list(range(num_training, num_training + num_validation))\n X_val = X_train[mask]\n y_val = y_train[mask]\n mask = list(range(num_training))\n X_train = X_train[mask]\n y_train = y_train[mask]\n mask = list(range(num_test))\n X_test = X_test[mask]\n y_test = y_test[mask]\n\n # Normalize the data: subtract the mean image\n mean_image = np.mean(X_train, axis=0)\n X_train -= mean_image\n X_val -= mean_image\n X_test -= mean_image\n\n # Reshape data to rows\n X_train = X_train.reshape(num_training, -1)\n X_val = X_val.reshape(num_validation, -1)\n X_test = X_test.reshape(num_test, -1)\n\n return X_train, y_train, X_val, y_val, X_test, y_test","def create_model(self):\r\n model = self.model_fn(self.flags)\r\n print(model)\r\n return model","def predict_only(self):","def define(self, optimizer = Adam(lr=1e-5)): \n \n self.optimizer = optimizer\n\n model = Sequential()\n\n #Layer 1\n model.add(Conv2D( filters = 96, \n kernel_size = (11,11), \n strides = 4, \n padding = 'same', \n activation = 'relu', \n input_shape = (224, 224, 3), \n kernel_initializer = 'he_normal'))\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None)) # overlapping pooling\n #Layer 2\n model.add(Conv2D( filters = 256, \n kernel_size = (5,5), \n strides = 1, \n padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None)) \n #Layer 3\n model.add(Conv2D( filters = 384, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', kernel_initializer = 'he_normal'))\n #Layer 4\n model.add(Conv2D( filters = 384, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n #Layer 5\n model.add(Conv2D( filters = 256, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n #Layer 6\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None))\n \n #Layer 7\n model.add(Flatten())\n \n #Layer 8\n model.add(Dense( units = 4096, activation = 'relu'))\n model.add(Dense( units = 1024, activation = 'relu'))\n model.add(Dense( units = 512, activation = 'relu'))\n model.add(Dense( units = 256, activation = 'relu'))\n model.add(Dense( units = 128, activation = 'relu'))\n \n #Layer end\n model.add(Dense( units = 3, activation = 'softmax'))\n model.summary()\n \n self.model = model","def car(mnfr, model, **car_info):\n car_info[\"manufacturer\"] = mnfr\n car_info[\"model name\"] = model\n return car_info","def test_cifar(args):\n # type: () -> None\n\n # Build dataset and model\n dataset = CIFAR10(path=args.path)\n model = MEMCIFAR10(input_shape=dataset.shape, code_length=64, cpd_channels=100, mem_dim=500, shrink_thres=1.0 / 500).cuda().eval()\n\n # Set up result helper and perform test\n helper = MEMResultHelper(dataset, model, checkpoints_dir=args.checkpoints, output_file='mem_cifar.txt')\n helper.test_one_class_classification()","def resnet50_cifar10(pretrained=True, progress=True, use_data_parallel=False, **kwargs):\n return _model('resnet50_cifar10', resnet50, pretrained, progress, use_data_parallel, **kwargs)","def build(self) -> KM.Model:\n\n # For decoder number of features in opposite order of encoder\n decoder_features = self.encoder_features.copy()\n decoder_features.reverse()\n\n # build the encoder model\n self.encoder_model = self.encoder(\n features=self.encoder_features, name=\"encoder\"\n )\n\n # build the decoder model\n decoder = self.decoder(features=decoder_features, name=\"decoder\")\n\n input_tensor = KL.Input(\n shape=(32, 32, 3)\n ) # shape of images for cifar10 dataset\n\n # Encode the images\n encoded = self.encoder_model(input_tensor)\n # Decode the image\n decoded = decoder(encoded[-1])\n\n return KM.Model(inputs=input_tensor, outputs=decoded, name=\"AutoEncoder\")","def build_model(self):\n raise NotImplementedError","def test_forward(self):\r\n # CIFAR\r\n model = densenet.DenseNet(\r\n depth=40,\r\n Block=densenet.BasicBlock,\r\n growth_rate=12,\r\n mask=True,\r\n compression_rate=1.0,\r\n num_classes=100,\r\n )\r\n model.forward(torch.randn((1, 3, 32, 32)))","def rpy_process_r10(config_file, json_data):\n\n\trpy_module = importr('cocalculateur')\n\tloadjson_module = importr('jsonlite')\n\t\n\t#json_data = loadjson_module.fromJSON(txt = './input_f02.json',flatten=True)\n\tconfig_data = loadjson_module.fromJSON(txt = config_file ,flatten=True)\n\toutput_data = rpy_module.f_02(json_data,config_data)\n\n\treturn output_data","def model_fn(self, features, labels, mode, params, config):\n raise NotImplementedError()","def modelbuilder():\n model = Sequential()\n # Add a convolution layer with with a sigmoid activation function\n model.add(layers.Conv2D(1, (2, 2), strides=(1, 1), activation='sigmoid', padding='same', input_shape=(256, 256, 3)))\n model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n model.summary()\n return model","def __init__(self,*args,**kwargs):\n super(CompositeModel1D,self).__init__(*args,**kwargs)\n for m in self._models:\n if not isinstance(m,FunctionModel1D):\n raise ModelTypeError('Input model %s is not a 1D model'%m)\n self._filters = None","def __init__(self, meta_model, clust_cent, model_data):\r\n\r\n self.meta_model = meta_model\r\n\r\n MM.AbstractModel.__init__(self, meta_model.get_in_par_intervals(), meta_model.get_in_par_means(),\r\n meta_model.get_in_par_variances(), meta_model.get_out_par_intervals(),\r\n meta_model.get_out_par_means(), meta_model.get_out_par_variances())\r\n\r\n def check_additional_input():\r\n \"\"\" Checks the additional input\r\n\r\n :return: The additional input\r\n \"\"\"\r\n\r\n # Check if the cluster center input is correct\r\n RM.check_if_matrix(clust_cent, 'The cluster centers')\r\n RM.warn_if_bigger(clust_cent.shape[1], meta_model.get_in_par_means().shape[1],\r\n 'The number of input parameters in the cluster centers',\r\n 'the number of input parameters - 1')\r\n RM.check_if_bigger(clust_cent.shape[1], meta_model.get_in_par_means().shape[1] - 1,\r\n 'The number of input parameters',\r\n 'the number of input parameters in the cluster centers')\r\n\r\n bounds = meta_model.get_in_par_intervals()\r\n\r\n for j in range(clust_cent.shape[0]):\r\n for i in range(bounds.shape[0]):\r\n RM.check_if_in_interval(bounds[i], clust_cent[j, i], i, ' In cluster center %x, the value')\r\n\r\n def check_PLSR_input():\r\n \"\"\" Checks model data of PLSR\r\n\r\n :return: Checks model data of PLSR\r\n \"\"\"\r\n\r\n RM.check_if_ndim_array(model_data, 3, 'Model data')\r\n RM.check_if_bigger(model_data.shape[1], meta_model.get_in_par_means().shape[1],\r\n 'The number of input parameters in the solution matrix',\r\n 'the number of input parameters')\r\n RM.warn_if_bigger(model_data.shape[1], meta_model.get_in_par_means().shape[1] + 1,\r\n 'The number of input parameters',\r\n 'the number of input parameters in the solution matrix')\r\n RM.check_if_bigger(model_data.shape[2], meta_model.get_out_par_means().shape[1] - 1,\r\n 'The number of output parameters in the solution matrix',\r\n 'the number of output parameters')\r\n RM.warn_if_bigger(model_data.shape[2], meta_model.get_out_par_means().shape[1],\r\n 'The number of output parameters',\r\n 'the number of output parameters in the solution matrix')\r\n\r\n # Check if the additional data is correct\r\n\r\n if meta_model.get_type() == 'PLSR': # Additional check-up for PLSR\r\n check_PLSR_input()\r\n\r\n elif meta_model.get_type() == 'DLU': # Additional check-up for DLU\r\n raise TypeError('This part is not implemented yet')\r\n\r\n # if not isinstance(model_data, np.ndarray):\r\n # raise TypeError('The cluster input and output data is not stored in a multidimensional array')\r\n #\r\n # for clust_data in model_data:\r\n #\r\n # if not isinstance(clust_data[0], np.matrix) or not isinstance(clust_data[1], np.matrix):\r\n # raise TypeError('One of the input or output databases is not a matrix')\r\n #\r\n # if clust_data[0].shape[1] > meta_model.get_in_par_means().shape[1]:\r\n # warnings.warn('The number of input parameters for the input database of the clusters is bigger '\r\n # 'than the actual number of input parameters')\r\n #\r\n # elif clust_data[0].shape[1] < meta_model.get_in_par_means().shape[1]:\r\n # raise TypeError('The number of input parameters for the input database of the clusters is '\r\n # 'smaller than the actual numbers of input parameters')\r\n #\r\n # if clust_data[1].shape[1] > meta_model.get_out_par_means().shape[1]:\r\n # raise TypeError('The number of output parameters for the output database of the clusters is '\r\n # 'bigger than the actual number of output parameters')\r\n #\r\n # elif clust_data[1].shape[1] < meta_model.get_out_par_means().shape[1]:\r\n # raise TypeError('The number of output parameters for the output database of the clusters is '\r\n # 'smaller than the actual numbers of output parameters')\r\n #\r\n # if clust_data[0].shape[0] != clust_data[1].shape[0]:\r\n # raise TypeError('The number rows in the input and output database differ from each other')\r\n\r\n else: # No check-up is done when the meta-model is an unknown version\r\n warnings.warn('The additional cluster data can not be checked, for this kind of meta-model')\r\n\r\n RM.check_if_same_size(clust_cent.shape[0], model_data.shape[0],\r\n 'The number of clusters according to the cluster centers',\r\n 'The number of clusters according to the model_data')\r\n\r\n check_additional_input()\r\n\r\n self.__clust_cent = clust_cent\r\n self.__model_data = model_data","def Char_Gate(NV,res ,B_field=400):\n\n\n #data = np.loadtxt(\"NV_Sim_8.dat\") #Placeholder data to test the script\n #NV = np.vstack((data[:,3],data[:,4]))\n #physical constants\n gamma_c = 1.071e3 #g-factor for C13 in Hz/G\n #Model parameters\n omega_larmor = 2*np.pi*gamma_c*B_field\n tau_larmor = 2*np.pi/omega_larmor\n tau = res[0]\n n_pulses = int(res[1]*2) #So that we do a pi -pulse\n\n Ix = 0.5 * np.array([[0,1],[1,0]])\n Iz = 0.5* np.array([[1,0],[0,-1]])\n H0 = (omega_larmor)*Iz\n exH0 =linalg.expm(-1j*H0*tau)\n\n\n M = np.zeros(np.shape(NV)[0])\n for idC in range(np.shape(NV)[0]):\n A= 2*np.pi*NV[idC,0]\n B= 2*np.pi*NV[idC,1] #Converts to radial frequency in Hz/G\n H1 = (A+omega_larmor) *Iz +B*Ix\n exH1 = linalg.expm(-1j*H1*tau)\n V0 = exH0.dot(exH1.dot(exH1.dot(exH0)))\n V1 = exH1.dot(exH0.dot(exH0.dot(exH1)))\n n0 = Calc_axis(V0)\n n1 =Calc_axis(V1)\n phi = np.real(2*np.arccos(np.trace(V0)/2))\n M[idC] = 1 - (1-np.dot(n0,n1))*np.sin(n_pulses * phi /2 )**2\n\n Signal = -M.prod()\n F = (1-(Signal+1)/2)\n return F","def get_model():\n model = ecole.scip.Model.from_file(str(DATA_DIR / \"bppc8-02.mps\"))\n model.disable_cuts()\n model.disable_presolve()\n model.set_param(\"randomization/permuteconss\", True)\n model.set_param(\"randomization/permutevars\", True)\n model.set_param(\"randomization/permutationseed\", 784)\n model.set_param(\"randomization/randomseedshift\", 784)\n model.set_param(\"randomization/lpseed\", 784)\n return model","def classify(img, c_model):\n #global class_graph\n\n #img = load_img(im_path,target_size=(input_height, input_width))\n #img = img_to_array(img)\n im_size = 128\n # resize \n\n img = cv2.resize(img, (im_size,im_size))\n\n img = img.astype(\"float\") / 255.0\n img = np.expand_dims(img, axis=0)\n with class_graph.as_default():\n predictions = c_model.predict(img)[0]\n\n return predictions","def get_model_2(parameters):\n # Parameters\n BANDS = parameters['num_features']\n CLASSES = parameters['num_classes']\n \n # Sequential model\n model = keras.models.Sequential()\n \n # Add convolution (1)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, 9, BANDS, 1)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(9, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh',\n input_shape=(9, BANDS,1)))\n \n # Add convolution (2)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(1, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh'))\n \n # Add convolution (3)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 45, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(1, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh'))\n \n # Flatten before dense layer\n model.add(keras.layers.Flatten())\n \n # Add fully connected (4)\n # -----------------------\n # Intput_shape (batch, rows, cols, channels) = (-, (BANDS - 45) x 1 x 32)\n # Output_shape (batch, dim) = (-, 800)\n model.add(keras.layers.Dense(units=800,\n activation='tanh'))\n \n # Add fully connected (5)\n # -----------------------\n # Intput_shape (batch, dim) = (-, 800)\n # Output_shape (batch, dim) = (-, 800)\n model.add(keras.layers.Dense(units=800,\n activation='softmax'))\n \n # Add fully connected to reduce to number of categories\n # -----------------------------------------------------\n # Intput_shape (batch, dim) = (-, 800)\n # Output_shape (batch, dim) = (-, CLASSES)\n model.add(keras.layers.Dense(units=CLASSES,\n activation='softmax'))\n \n # Compile model\n model.compile(optimizer='adam',\n loss='categorical_crossentropy',\n metrics=['accuracy'])\n \n # Print the model summary to output file\n # To print to stdout: model.summary()\n with open(OUTPUT_FILE, 'a') as f:\n # Pass the file handle in as a lambda function to make it callable\n model.summary(print_fn=lambda x: f.write(x + '\\n'))\n \n # Return the model\n return model","def load_cifar(hparams):\n all_labels = []\n\n total_batches_to_load = 5\n assert hparams.train_size + hparams.validation_size <= 50000\n if hparams.eval_test:\n total_batches_to_load += 1\n # Determine how many images we have loaded\n total_dataset_size = 50000\n train_dataset_size = total_dataset_size\n if hparams.eval_test:\n total_dataset_size += 10000\n\n if hparams.dataset == 'cifar10':\n all_images = []\n elif hparams.dataset == 'cifar100':\n all_images = np.empty((1, 50000, 3072), dtype=np.uint8)\n if hparams.eval_test:\n test_data = np.empty((1, 10000, 3072), dtype=np.uint8)\n if hparams.dataset == 'cifar10':\n datafiles = [\n 'data_batch_1', 'data_batch_2', 'data_batch_3', 'data_batch_4',\n 'data_batch_5']\n\n if hparams.eval_test:\n datafiles.append('test_batch')\n num_classes = 10\n elif hparams.dataset == 'cifar100':\n datafiles = ['train']\n if hparams.eval_test:\n datafiles.append('test')\n num_classes = 100\n else:\n raise NotImplementedError('Unimplemented dataset: ', hparams.dataset)\n if hparams.dataset != 'test':\n for file_num, f in enumerate(datafiles):\n d = unpickle(os.path.join(hparams.data_path, f))\n if hparams.dataset == 'cifar10':\n labels = np.array(d['labels'])\n else:\n labels = np.array(d['fine_labels'])\n if f == 'test':\n test_data[0] = copy.deepcopy(d['data'])\n if hparams.dataset == 'cifar10':\n all_images.append(test_data)\n else:\n all_images = np.concatenate([all_images, test_data], axis=1)\n else:\n if hparams.dataset == 'cifar10':\n all_images.append(copy.deepcopy(d['data']))\n else:\n all_images[file_num] = copy.deepcopy(d['data'])\n nsamples = len(labels)\n for idx in range(nsamples):\n all_labels.append(labels[idx])\n if hparams.dataset == 'cifar10':\n all_images = np.concatenate(all_images, axis=0)\n all_images = all_images.reshape(-1, 3072)\n all_images = all_images.reshape(-1, 3, 32, 32) # pylint: disable=too-many-function-args\n all_images = all_images.transpose(0, 2, 3, 1).copy()\n all_images = all_images / 255.0\n mean = augmentation_transforms.MEANS\n std = augmentation_transforms.STDS\n tf.logging.info('mean:{} std: {}'.format(mean, std))\n all_images = (all_images - mean) / std\n all_labels = np.eye(num_classes)[np.array(all_labels, dtype=np.int32)]\n\n assert len(all_images) == len(all_labels)\n tf.logging.info(\n 'In CIFAR10 loader, number of images: {}'.format(len(all_images)))\n\n extra_test_images = None\n extra_test_labels = None\n if hparams.extra_dataset == 'cifar10_1':\n extra_test_ds = tfds.as_numpy(\n tfds.load('cifar10_1', split='test', batch_size=-1))\n extra_test_images = ((extra_test_ds['image'] / 255.0) - mean) / std\n extra_test_labels = np.eye(num_classes)[np.array(\n extra_test_ds['label'], dtype=np.int32)]\n\n # Break off test data\n if hparams.eval_test:\n test_images = all_images[train_dataset_size:]\n test_labels = all_labels[train_dataset_size:]\n else:\n test_images = []\n test_labels = []\n all_images = all_images[:train_dataset_size]\n all_labels = all_labels[:train_dataset_size]\n return all_images, all_labels, test_images, test_labels, extra_test_images, extra_test_labels","def first_model():\n model=Sequential()\n # model.add(Flatten(input_shape=(160,320,3)))\n model.add(Lambda(lambda x: (x-128.0)/128.0,input_shape=(160, 320, 3)))\n model.add(Cropping2D(cropping=((70,25), (0,0))))\n model.add(Convolution2D(32, 3, 3))\n model.add(MaxPooling2D((2, 2)))\n model.add(Dropout(0.5))\n model.add(Activation('relu'))\n model.add(Flatten())\n model.add(Dense(128))\n model.add(Activation('relu'))\n model.add(Dense(1))\n\n model.compile(loss=\"mse\",optimizer=\"adam\")\n return model","def COMBI(self):\n\n self.FB()\n self.LAT()\n self.ROT()","def build_model():\n\n if K.image_data_format() == 'channels_first':\n input_shape = (3, img_width, img_height)\n else:\n input_shape = (img_width, img_height, 3)\n\n model = Sequential()\n model.add(Conv2D(32, (3, 3), input_shape=input_shape))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n model.add(Conv2D(32, (3, 3)))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n model.add(Conv2D(64, (3, 3)))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n model.add(Flatten())\n\n # FC layer\n model.add(Dense(64))\n model.add(Activation('relu'))\n model.add(Dropout(0.5))\n model.add(Dense(1))\n model.add(Activation('sigmoid'))\n\n model.compile(loss='binary_crossentropy',\n optimizer='adadelta',\n metrics=['accuracy'])\n\n return model","def model_build(self):\n\n # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!\n X_input = Input(self.inputData[0].shape)\n\n '''\n # CONV -> BN -> RELU Block applied to X\n X = Conv2D(8, (8, 8), name='conv0')(X_input)\n X = BatchNormalization(name='bn0')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool0')(X)\n X = Dropout(0.1, name='dropout0')(X)\n\n X = Conv2D(16, (16, 16), name='conv1')(X)\n X = BatchNormalization(name='bn1')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool1')(X)\n X = Dropout(0.1, name='dropout1')(X)\n\n X = Conv2D(16, (32, 32), name='conv2')(X)\n X = BatchNormalization(name='bn2')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool2')(X)\n X = Dropout(0.1, name='dropout2')(X)\n' '''\n\n X = Dense(500, activation='relu', name='fc0')(X_input)\n X = Dropout(0.1, name='dropout1')(X)\n X = Dense(500, activation='relu', name='fc1')(X)\n X = Dropout(0.1, name='dropout2')(X)\n X = Dense(3, activation='softmax', name='fc2')(X)\n\n # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.\n self.model = Model(inputs=X_input, outputs=X, name='acouModel')","def makepredictions(self):\n data, sampling_rate = librosa.load(self.file)\n mfccs = np.mean(librosa.feature.mfcc(y=data, sr=sampling_rate, n_mfcc=40).T, axis=0)\n x = np.expand_dims(mfccs, axis=1)\n x = np.expand_dims(x, axis=0)\n predictions = self.loaded_model.predict_classes(x)\n predict = self.convertclasstoemotion(predictions)\n print(\"Prediction is\", \" \", self.convertclasstoemotion(predictions))\n return predict","def sweep_image_model():\n for c1 in [4, 8, 16]:\n for c2 in [2, 4]:\n for c3 in [2, 4]:\n for c4 in [1, 2]:\n flags = flag_reader.read_flag()\n print(c1)\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\n print('channel list = ', flags.channel_list)\n flags.last_dim = flags.channel_list[-1]\n flags.model_name = flags.data_set + '_channel_' + str(flags.channel_list).replace('[','').replace(']','').replace(' ','_') + \\\n '_dim_last_' + str(flags.last_dim) + '_ind_' + str(flags.comp_ind) + \\\n '_lr_{}_decay_{}_reg_{}_bs_{}'.format(flags.lr, flags.lr_decay_rate, flags.reg_scale, flags.batch_size)\n print(flags.model_name)\n training_from_flag(flags)","def openCif(self, filename):\r\n cf = CifFile.ReadCif(filename)\r\n \r\n #Assuming all data is in one outer block like NIST examples:\r\n data = cf[cf.keys()[0]]\r\n \r\n #Create a Crystollographic Unit Cell\r\n a = data['_cell_length_a']\r\n b = data['_cell_length_b']\r\n c = data['_cell_length_c']\r\n \r\n alpha = data['_cell_angle_alpha']\r\n gamma = data['_cell_angle_gamma']\r\n beta = data['_cell_angle_beta']\r\n \r\n spaceGroupInt = int(data['_symmetry_Int_Tables_number'])\r\n spaceGroup = SpaceGroups.GetSpaceGroup(spaceGroupInt)\r\n \r\n unitcell = Cell(spaceGroup, 0,0,0, a, b, c, alpha, gamma, beta)\r\n \r\n atomLabels = data['_atom_site_label']\r\n atomSymbol = data['_atom_site_type_symbol']\r\n xPositions = data['_atom_site_fract_x']\r\n yPositions = data['_atom_site_fract_y']\r\n zPositions = data['_atom_site_fract_z']\r\n \r\n atoms = [] #for the cell window\r\n for i in range(len(atomLabels)):\r\n #unitcell.generateAtoms((float(xPositions[i]), float(yPositions[i]), float(zPositions[i])), atomLabels[i])\n\r\n aData = [atomLabels[i], 0, float(xPositions[i]), float(yPositions[i]), float(zPositions[i])]\r\n #--Added to atomData: single ion anisotropy, spin magnitude, valence\r\n aData.append(0.0)#Dx\r\n aData.append(0.0)#Dy\r\n aData.append(0.0)#Dz\r\n aData.append(1)#Spin Magnitude\r\n aData.append('')#valence\r\n #-------------------------------------------------------------------\r\n atoms.append(aData)\r\n \r\n self.atomTable.SetValue(i, 0, atomLabels[i])\r\n self.atomTable.SetValue(i, 2, xPositions[i])\r\n self.atomTable.SetValue(i, 3, yPositions[i])\r\n self.atomTable.SetValue(i, 4, zPositions[i])\r\n \r\n #Create a Magnetic Cell\r\n self.MagCell = MagneticCell(unitcell, 1,1,1, spaceGroup)\r\n\r\n\r\n Na = 1 #Cif files only contain 1 unit cell\r\n Nb = 1\r\n Nc = 1\r\n \r\n #self.cellChange(spaceGroupInt, a, b, c, alpha, beta, gamma, magNa = Na, magNb = Nb, magNc = Nc, cutNa = Na, cutNb = Nb, cutNc = Nc, atomData = atoms)\n self.updateCell(spaceGroupInt, a, b, c, alpha, beta, gamma, magNa = Na, magNb = Nb, magNc = Nc, cutNa = Na, cutNb = Nb, cutNc = Nc, atomData = atoms)\n self.refreshGUI()\n \n \r\n #send signal to the cell window to show the info that has been loaded and to vtkWindow to draw it\r\n n = self.atomTable.GetNumberRows()\r\n for i in range(n):\r\n print self.atomTable.GetValue(i, 0)\r\n send(signal = \"File Load\", sender = \"Session\", spaceGroup = spaceGroupInt, a = a, b = b, c = c, alpha = alpha, beta = beta, gamma = gamma, magNa = Na, magNb = Nb, magNc = Nc, cutNa = Na, cutNb = Nb, cutNc = Nc)","def __init__(self):\n self.model = Sequential()\n self.model.add(AveragePooling2D(pool_size=(4, 4), input_shape=(224, 224, 3)))\n self.model.add(Conv2D(16, (9, 9)))\n self.model.add(Activation('relu'))\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\n self.model.add(Conv2D(16, (5, 5)))\n self.model.add(Activation('relu'))\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\n self.model.add(Flatten())\n self.model.add(Dropout(0.5))\n self.model.add(Dense(1, activation='sigmoid'))\n self.model.compile(loss=binary_crossentropy,\n optimizer=keras.optimizers.Adadelta(),\n metrics=['accuracy'])","def __init__(self, mode, path):\n\n\t\tmodel = load_model('data/model.h5') \n\n\t\tif mode == \"test\":\n\n\t\t\tX_test, Y_test = self._load_dataset(path)\n\t\t\tpreds = model.evaluate(X_test, Y_test)\n\t\t\tprint (\"Loss = \" + str(preds[0]))\n\t\t\tprint (\"Test Accuracy = \" + str(preds[1]))\n\n\n\t\telif mode == \"predict\":\t\t\t\n\t\t\t\n\t\t\tlabel_dict = {'airplane':0, 'automobile':1, 'bird':2, 'cat':3, 'deer':4,\n\t\t\t'dog':5, 'frog':6, 'horse':7, 'ship':8, 'truck':9}\n\n\t\t\timg = image.load_img(path, target_size=(64, 64))\n\t\t\tx = image.img_to_array(img)\n\t\t\tx = np.reshape(x, (1,64,64,3))\n\t\t\ttemp_pred = model.predict(x)\n\t\t\tidx = np.argmax(temp_pred)\n\t\t\t\n\t\t\tprint(\"The object detected in the picture is a(n) : \" + \n\t\t\t\tlist(label_dict.keys())[list(label_dict.values()).index(idx)])"],"string":"[\n \"def get_cifar10(self):\\n\\t\\t# Get the data.\\n\\t\\tself.x_train = self.x_train.reshape(self.nb_train, self.input_dim)\\n\\t\\tself.x_test = self.x_test.reshape(self.nb_test, self.input_dim)\\n\\t\\tself.x_train = self.x_train.astype('float32')\\n\\t\\tself.x_test = self.x_test.astype('float32')\\n\\t\\tself.x_train /= 255\\n\\t\\tself.x_test /= 255\\n\\n\\t\\t# convert class vectors to binary class matrices\\n\\t\\tself.y_train = np_utils.to_categorical(self.y_train, self.nb_classes)\\n\\t\\tself.y_test = np_utils.to_categorical(self.y_test, self.nb_classes)\",\n \"def get_cifar10():\\n\\n from keras.datasets import cifar10\\n\\n # input image dimensions\\n img_rows, img_cols = 32, 32\\n n_channels = 3\\n num_classes = 10\\n # the data, shuffled and split between train and test sets\\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\\n\\n if K.image_data_format() == 'channels_first':\\n print (\\\"Using Channels first\\\")\\n x_train = x_train.reshape(x_train.shape[0], n_channels, img_rows, img_cols)\\n x_test = x_test.reshape(x_test.shape[0], n_channels, img_rows, img_cols)\\n input_shape = (n_channels, img_rows, img_cols)\\n else:\\n print(\\\"Channels last\\\")\\n x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, n_channels)\\n x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, n_channels)\\n input_shape = (img_rows, img_cols, n_channels)\\n\\n return (x_train, y_train), (x_test, y_test)\",\n \"def get_cifar10_mlp():\\n # Set defaults.\\n nb_classes = 10 #dataset dependent \\n batch_size = 64\\n epochs = 4\\n input_shape = (3072,) #because it's RGB\\n\\n # Get the data.\\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\\n x_train = x_train.reshape(50000, 3072)\\n x_test = x_test.reshape(10000, 3072)\\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n x_train /= 255\\n x_test /= 255\\n\\n # convert class vectors to binary class matrices\\n y_train = to_categorical(y_train, nb_classes)\\n y_test = to_categorical(y_test, nb_classes)\\n\\n return (nb_classes, batch_size, input_shape, x_train, x_test, y_train, y_test, epochs)\",\n \"def _model(self):\\n common_scale = self.edp_par['common_scale'].value\\n model = self.F_trans() * self.F_cont()\\n # get F(h=1,k=0), which is used for normalization \\n # common_scale is a common scaling factor => F(h=1,k=0) = 100*common_scale\\n F_10 = model[(self.h==1)&(self.k==0)]\\n model = model / np.absolute(F_10) * 100 * common_scale\\n return model\",\n \"def cifar10(transform=transforms.ToTensor()):\\n\\n\\t# Directories\\n\\tscript_dir = os.path.dirname(os.path.realpath(__file__))\\n\\tdata_dir = os.path.join(script_dir, 'data', 'cifar10')\\n\\n\\t# Load training set, downloading if necessary\\n\\tdataset = datasets.CIFAR10(data_dir, train=True, transform=transform, download=True)\\n\\n\\t# Split into train, val, and test sets\\n\\n\\t# Add 'classes' list and 'class_to_idx' lookup dictionary to both sets\\n\\tclasses = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', \\n\\t\\t'horse', 'ship', 'truck']\\n\\tclass_to_idx = {classes[i]: i for i in range(len(classes))}\\n\\n\\tdataset.classes = classes\\n\\tdataset.class_to_idx = class_to_idx\\n\\n\\treturn dataset\",\n \"def get_cifar10_cnn():\\n # Set defaults.\\n nb_classes = 10 #dataset dependent \\n batch_size = 128\\n epochs = 4\\n \\n # the data, shuffled and split between train and test sets\\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\\n \\n # convert class vectors to binary class matrices\\n y_train = to_categorical(y_train, nb_classes)\\n y_test = to_categorical(y_test, nb_classes)\\n\\n #x._train shape: (50000, 32, 32, 3)\\n #input shape (32, 32, 3)\\n input_shape = x_train.shape[1:]\\n\\n #print('x_train shape:', x_train.shape)\\n #print(x_train.shape[0], 'train samples')\\n #print(x_test.shape[0], 'test samples')\\n #print('input shape', input_shape)\\n \\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n x_train /= 255\\n x_test /= 255\\n\\n return (nb_classes, batch_size, input_shape, x_train, x_test, y_train, y_test, epochs)\",\n \"def _compile_model(self):\\n\\n\\t\\t\\t### GC90 atmospheric model implementation\\n\\t\\t\\n\\t\\t\\ttheta_sun, beta, alpha, am, rh, pressure = T.scalars('theta_sun', 'beta', 'alpha', 'am', 'rh', 'pressure')\\n\\n\\t\\t\\twl = T.vector('wl')\\n\\t\\t\\n\\t\\t\\twl_a = 550\\n\\n\\t\\t\\ttheta_sun_ = theta_sun * np.pi / 180.\\n\\n\\t\\t\\tz3 = -0.1417 * alpha + 0.82\\n\\t\\t\\tz2 = ifelse(T.gt(alpha, 1.2), 0.65, z3)\\n\\t\\t\\tz1 = ifelse(T.lt(alpha, 0), 0.82, z2)\\n\\t\\t\\n\\t\\t\\ttheta_sun_mean = z1\\n\\n\\t\\t\\tB3 = T.log(1 - theta_sun_mean)\\n\\t\\t\\tB2 = B3 * (0.0783 + B3 * (-0.3824 - 0.5874 * B3))\\n\\t\\t\\tB1 = B3 * (1.459 + B3 * (0.1595 + 0.4129 * B3))\\n\\t\\t\\tFa = 1 - 0.5 * T.exp((B1 + B2 * T.cos(theta_sun_)) * T.cos(theta_sun_))\\n\\n\\t\\t\\tomega_a = (-0.0032 * am + 0.972) * T.exp(3.06 * 1e-4 * rh)\\n\\t\\t\\ttau_a = beta*(wl/wl_a)**(-alpha)\\n\\n\\t\\t\\t# fixed a bug in M, thanks Jaime! [brackets added]\\n\\t\\t\\tM = 1 / (T.cos(theta_sun_) + 0.50572 * (90 + 6.07995 - theta_sun)**(-1.6364)) \\n\\t\\t\\tM_ = M * pressure / 1013.25\\n\\n\\t\\t\\tTr = T.exp(- M_ / (115.6406 * (wl / 1000)**4 - 1.335 * (wl / 1000)**2)) \\n\\n\\t\\t\\tTas = T.exp(- omega_a * tau_a * M)\\n\\n\\t\\t\\tEdd = Tr * Tas \\n\\t\\t\\tEdsr = 0.5 * (1 - Tr**0.95)\\n\\t\\t\\tEdsa = Tr**1.5 * (1 - Tas) * Fa\\n\\t\\t\\n\\t\\t\\tEd = Edd + Edsr + Edsa\\n\\t\\t\\tEdd_Ed = Edd / Ed\\n\\t\\t\\tEdsr_Ed = Edsr / Ed\\n\\t\\t\\tEdsa_Ed = Edsa / Ed\\n\\t\\t\\tEds_Ed = Edsr_Ed + Edsa_Ed\\n\\n\\t\\t\\t### Albert and Mobley bio-optical model implementation\\n\\n\\t\\t\\ta_w, daw_dT, astar_ph, astar_y, Ls_Ed = T.vectors('a_w', 'daw_dT', 'astar_ph', 'astar_y', 'Ls_Ed') \\n\\t\\t\\n\\t\\t\\tC_chl, C_sm, C_mie, n_mie, C_y, S_y, T_w, theta_view, n_w, rho_s, rho_dd, rho_ds, delta= T.scalars('C_chl', 'C_sm', 'C_mie', 'n_mie', 'C_y', 'S_y', 'T_w', 'theta_view', 'n_w', 'rho_s', 'rho_dd', 'rho_ds', 'delta')\\n\\n\\t\\t\\t# calc_a_ph\\n\\t\\t\\ta_ph = C_chl * astar_ph\\n\\n\\t\\t\\t# calc_a_y\\n\\t\\t\\twl_ref_y = 440\\n\\t\\t\\ta_y = ifelse(T.eq(S_y, -1), C_y * astar_y, C_y * T.exp(- S_y * (wl - wl_ref_y)))\\n\\n\\t\\t\\t# calc_a\\n\\t\\t\\tT_w_ref = 20.\\n\\t\\t\\ta_w_corr = a_w + (T_w - T_w_ref) * daw_dT\\n\\t\\t\\n\\t\\t\\ta = a_w_corr + a_ph + a_y\\n\\n\\t\\t\\t# calc_bb_sm\\n\\t\\t\\tbbstar_sm = 0.0086\\n\\t\\t\\tbbstar_mie = 0.0042\\n\\t\\t\\twl_ref_mie = 500\\n\\t\\t\\n\\t\\t\\tbb_sm = C_sm * bbstar_sm + C_mie * bbstar_mie * (wl / wl_ref_mie)**n_mie\\n\\n\\t\\t\\t# calc_bb\\n\\t\\t\\tb1 = ifelse(T.eq(n_w, 1.34), 0.00144, 0.00111)\\n\\t\\t\\n\\t\\t\\twl_ref_water = 500\\n\\t\\t\\tS_water = -4.32\\n\\n\\t\\t\\tbb_water = b1 * (wl / wl_ref_water)**S_water\\n\\t\\t\\tbb = bb_water + bb_sm\\n\\n\\t\\t\\t# calc omega_b\\n\\t\\t\\tomega_b = bb / (bb + a)\\n\\n\\t\\t\\t# calc sun and viewing zenith angles under water\\n\\t\\t\\ttheta_sun_ = theta_sun * np.pi / 180.\\n\\t\\t\\ttheta_sun_ss = T.arcsin(T.sin(theta_sun_) / n_w)\\n\\t\\t\\ttheta_view_ = theta_view * np.pi / 180.\\n\\t\\t\\ttheta_view_ss = T.arcsin(T.sin(theta_view_) / n_w)\\n\\n\\t\\t\\tp_f = [0.1034, 1, 3.3586, -6.5358, 4.6638, 2.4121]\\n\\t\\t\\tp_frs = [0.0512, 1, 4.6659, -7.8387, 5.4571, 0.1098, 0.4021]\\n\\n\\t\\t\\t# calc subsurface reflectance \\n\\t\\t\\tf = p_f[0] * (p_f[1] + p_f[2] * omega_b + p_f[3] * omega_b**2 + p_f[4] * omega_b**3) * (1 + p_f[5] / T.cos(theta_sun_ss)) \\n\\n\\t\\t\\tR0minus = f * omega_b\\n\\n\\t\\t\\t# calc subsurface remote sensing reflectance \\n\\t\\t\\tfrs = p_frs[0] * (p_frs[1] + p_frs[2] * omega_b + p_frs[3] * omega_b**2 + p_frs[4] * omega_b**3) * (1 + p_frs[5] / T.cos(theta_sun_ss)) * (1 + p_frs[6] / T.cos(theta_view_ss))\\n\\n\\t\\t\\tRrs0minus = frs * omega_b\\n\\n\\t\\t\\t# calc water surface reflected reflectance \\n\\t\\t\\tRrs_refl = rho_s * Ls_Ed + rho_dd * Edd_Ed / np.pi + rho_ds * Eds_Ed / np.pi + delta\\n\\n\\t\\t\\t# calc_Rrs0plus (Lee1998, eq22), R=Q*Rrs\\n\\t\\t\\tgamma = 0.48\\n\\t\\t\\tzeta = 0.518\\n\\n\\t\\t\\tRrs = zeta * Rrs0minus / ( 1 - gamma * R0minus )\\n\\t\\t\\n\\t\\t\\tLu_Ed = Rrs + Rrs_refl\\n\\t\\t\\n\\t\\t\\tf = th.function([beta, alpha, am, rh, pressure, C_chl, C_sm, C_mie, n_mie, C_y, S_y, T_w, theta_sun, theta_view, n_w, rho_s, rho_dd, rho_ds, delta, wl, a_w, daw_dT, astar_ph, astar_y, Ls_Ed], [Rrs, Rrs_refl, Lu_Ed], on_unused_input='warn')\\n\\n\\t\\t\\treturn f\",\n \"def train_cifar10():\\r\\n # type: () -> None\\r\\n\\r\\n # Build dataset and model\\r\\n dataset = CIFAR10_TRAIN(path=Config.video_folder)\\r\\n model = LSACIFAR10(input_shape=dataset.shape, code_length=64,\\r\\n cpd_channels=100).to(device).train()\\r\\n\\r\\n # Set up result helper and perform test\\r\\n helper = OneClassResultHelper(dataset, model,\\r\\n checkpoints_dir=Config.model_ckpt,\\r\\n output_file='cifar10.txt')\\r\\n helper.train_one_class_classification()\",\n \"def fit_covid_function(self):\\r\\n return\",\n \"def __init__(self, **kwargs):\\n super(CIFAR10Classifier, self).__init__() #pylint: disable=super-with-arguments\\n self.model_conv = models.resnet50(pretrained=True)\\n for param in self.model_conv.parameters():\\n param.requires_grad = False\\n num_ftrs = self.model_conv.fc.in_features\\n num_classes = 10\\n self.model_conv.fc = nn.Linear(num_ftrs, num_classes)\\n\\n self.scheduler = None\\n self.optimizer = None\\n self.args = kwargs\\n\\n self.train_acc = Accuracy()\\n self.val_acc = Accuracy()\\n self.test_acc = Accuracy()\\n\\n self.preds = []\\n self.target = []\\n self.example_input_array = torch.rand((1, 3, 64, 64))\",\n \"def presenetCar():\",\n \"def build_model_fn(self):\",\n \"def cifar10_bin_model_fn(features, labels, mode, params):\\n\\n network = resnet_model.cifar10_resnet_v2_generator(\\n params['resnet_size'], _NUM_CLASSES, params['data_format']\\n )\\n\\n inputs = tf.reshape(features, [-1, _HEIGHT, _WIDTH, _DEPTH])\\n clabels = labels[:, :_NUM_CLASSES]\\n \\n # logits = network(inputs, mode == tf.estimator.ModeKeys.TRAIN)\\n logits = network(inputs, mode == tf.estimator.ModeKeys.TRAIN, name=\\\"main\\\")\\n probs = tf.sigmoid(logits)\\n\\n # slabels, smask = smooth_neg_labels(clabels, params[\\\"cutoff_weight\\\"], params[\\\"pen_prob\\\"])\\n # slabels, smask = smooth_neg_labels(clabels, 1*1/_NUM_CLASSES, 0.45)\\n bt_loss = tf.reduce_mean(per_class_bin_loss(probs, clabels, params[\\\"milden\\\"]), axis=1)\\n\\n loss = tf.reduce_mean(bt_loss, axis=0)\\n loss = tf.identity(loss, name=\\\"loss_vec\\\")\\n loss_sum = tf.summary.scalar(\\\"loss\\\", loss)\\n\\n probs_cal = tf.sigmoid(logits/params[\\\"temp\\\"])\\n rate = tf.reduce_max(probs_cal, axis=1)\\n\\n # loss = tf.Print(loss, [smask], summarize=100, message=\\\"smask: \\\")\\n # loss = tf.Print(loss, [tf.reduce_mean(probs)], summarize=100, message=\\\"mean: \\\")\\n # loss = tf.Print(loss, [rate], summarize=100, message=\\\"rate: \\\")\\n # loss = tf.Print(loss, [clabels, slabels], summarize=100, message=\\\"slabels: \\\")\\n\\n classes = tf.argmax(logits, axis=1)\\n accuracy_m = tf.metrics.accuracy( tf.argmax(clabels, axis=1), classes, name=\\\"accuracy_metric\\\")\\n accuracy = tf.identity(accuracy_m[1], name=\\\"accuracy_vec\\\")\\n accuracy_sum = tf.summary.scalar(\\\"accuracy\\\", accuracy)\\n\\n if mode == tf.estimator.ModeKeys.EVAL or params[\\\"predict\\\"]:\\n\\n # print # note this is labels not clabels\\n print_labels = tf.argmax(labels, axis=1)\\n print_rate = rate\\n print_probs = probs\\n print_logits = logits\\n\\n hooks = []\\n eval_metric_ops = { \\\"accuracy\\\": accuracy_m }\\n\\n # # printing stuff if predict\\n if params[\\\"predict\\\"]:\\n loss = tf.Print(loss, [print_labels], summarize=1000000, message='Targets')\\n loss = tf.Print(loss, [print_rate], summarize=1000000, message='Rate')\\n loss = tf.Print(loss, [print_probs], summarize=1000000, message='Probs')\\n loss = tf.Print(loss, [print_logits], summarize=1000000, message='Logits')\\n hooks = []\\n eval_metric_ops = {}\\n\\n return tf.estimator.EstimatorSpec(\\n mode=mode,\\n loss=loss,\\n eval_metric_ops = eval_metric_ops,\\n # evaluation_hooks=hooks,\\n )\\n\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n # Scale the learning rate linearly with the batch size. When the batch size\\n # is 128, the learning rate should be 0.1.\\n initial_learning_rate = 0.1 * params['batch_size'] / 128\\n batches_per_epoch = _NUM_IMAGES['train'] / params['batch_size']\\n global_step = tf.train.get_or_create_global_step()\\n\\n # Multiply the learning rate by 0.1 at 100, 150, and 200 epochs.\\n boundaries = [int(batches_per_epoch * epoch) for epoch in [100, 150, 200]]\\n values = [initial_learning_rate * decay for decay in [1, 0.1, 0.01, 0.001]]\\n learning_rate = tf.train.piecewise_constant(\\n tf.cast(global_step, tf.int32), boundaries, values, name=\\\"learning_rate_vec\\\")\\n\\n learning_rate_sum = tf.summary.scalar(\\\"learning_rate\\\", learning_rate)\\n\\n optimizer = tf.train.MomentumOptimizer(\\n learning_rate=learning_rate,\\n momentum=_MOMENTUM\\n )\\n\\n # Batch norm requires update ops to be added as a dependency to the train_op\\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n with tf.control_dependencies(update_ops):\\n train_op = optimizer.minimize(loss, global_step)\\n\\n hook = tf.train.SummarySaverHook(\\n summary_op=tf.summary.merge([accuracy_sum, learning_rate_sum]),\\n save_steps=1,\\n )\\n return tf.estimator.EstimatorSpec(\\n mode=mode,\\n loss=loss,\\n train_op=train_op,\\n training_hooks=[hook],\\n )\",\n \"def get_cifar_data(num_classes=10):\\n\\n (x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()\\n x_train = x_train.astype(np.float32) / 255.\\n x_test = x_test.astype(np.float32) / 255.\\n\\n y_train_cat = to_categorical(y_train, num_classes=num_classes).astype(np.float32)\\n y_test_cat = to_categorical(y_test, num_classes=num_classes).astype(np.float32)\\n\\n return x_train, y_train, x_test, y_test, y_train_cat, y_test_cat\",\n \"def __init__(self, C, num_classes):\\n super(AuxiliaryHeadCIFAR, self).__init__()\\n self.features = nn.Sequential(nn.ReLU(inplace=True), nn.AvgPool2d(5, stride=3, padding=0, count_include_pad=False), nn.Conv2d(C, 128, 1, bias=False), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 768, 2, bias=False), nn.BatchNorm2d(768), nn.ReLU(inplace=True))\\n self.classifier = nn.Linear(768, num_classes)\",\n \"def get_model_code():\\n\\n return \\\"\\\"\\\"\\n functions {\\n matrix cov_matrix_ard(int N, int D, vector[] x, vector ls, real alpha_sq, int cov_id) {\\n matrix[N,N] S;\\n real dist_sum;\\n real sqrt3;\\n real sqrt5;\\n sqrt3=sqrt(3.0);\\n sqrt5=sqrt(5.0);\\n\\n // For RBF ARD kernel\\n if (cov_id == 1) {\\n for(i in 1:(N-1)) {\\n for(j in (i+1):N) {\\n dist_sum = 0;\\n for(d in 1:D) {\\n dist_sum = dist_sum + square(x[i][d] - x[j][d]) / square(ls[d]);\\n }\\n S[i,j] = alpha_sq * exp( -0.5 * dist_sum);\\n }\\n }\\n }\\n\\n // Fill upper triangle\\n for(i in 1:(N-1)) {\\n for(j in (i+1):N) {\\n S[j,i] = S[i,j];\\n }\\n }\\n\\n // Create diagonal\\n for(i in 1:N) {\\n S[i,i] = alpha_sq;\\n }\\n\\n return S;\\n }\\n\\n matrix distance_matrix_on_vectors(int N, vector[] x) {\\n matrix[N, N] distmat;\\n for(i in 1:(N-1)) {\\n for(j in (i+1):N) {\\n distmat[i, j] = square(distance(x[i], x[j]));\\n }\\n }\\n return distmat;\\n }\\n\\n matrix cov_matrix_matern(int N, matrix dist, real ls, real alpha_sq, int cov_id) {\\n matrix[N,N] S;\\n real dist_ls;\\n real sqrt3;\\n real sqrt5;\\n sqrt3=sqrt(3.0);\\n sqrt5=sqrt(5.0);\\n\\n // For Matern kernel with parameter nu=1/2 (i.e. absolute exponential kernel)\\n if (cov_id == 2) {\\n for(i in 1:(N-1)) {\\n for(j in (i+1):N) {\\n dist_ls = fabs(dist[i,j])/square(ls);\\n S[i,j] = alpha_sq * exp(-1 * dist_ls);\\n }\\n }\\n }\\n\\n // For Matern kernel with parameter nu=3/2\\n else if (cov_id == 3) {\\n for(i in 1:(N-1)) {\\n for(j in (i+1):N) {\\n dist_ls = fabs(dist[i,j])/ls;\\n S[i,j] = alpha_sq * (1 + sqrt3 * dist_ls) * exp(-sqrt3 * dist_ls);\\n }\\n }\\n }\\n\\n // For Matern kernel with parameter nu=5/2\\n else if (cov_id == 4) {\\n for(i in 1:(N-1)) {\\n for(j in (i+1):N) {\\n dist_ls = fabs(dist[i,j])/ls;\\n S[i,j] = alpha_sq * (1 + sqrt5 * dist_ls + 5 * pow(dist_ls,2)/3) * exp(-sqrt5 * dist_ls);\\n }\\n }\\n }\\n\\n // For Matern kernel with parameter nu tending to infinity (i.e. RBF kernel)\\n else if (cov_id == 1) {\\n for(i in 1:(N-1)) {\\n for(j in (i+1):N) {\\n dist_ls = fabs(dist[i,j])/ls;\\n S[i,j] = alpha_sq * exp( -0.5 * pow(dist_ls, 2) );\\n }\\n }\\n }\\n\\n // Fill upper triangle\\n for(i in 1:(N-1)) {\\n for(j in (i+1):N) {\\n S[j,i] = S[i,j];\\n }\\n }\\n\\n // Create diagonal\\n for(i in 1:N) {\\n S[i,i] = alpha_sq;\\n }\\n\\n return S;\\n }\\n\\n }\\n\\n data {\\n int<lower=1> D;\\n int<lower=1> N;\\n vector[D] x[N];\\n vector[N] y;\\n real<lower=0> ig1;\\n real<lower=0> ig2;\\n real<lower=0> n1;\\n real<lower=0> n2;\\n real<lower=0> sigma;\\n int kernel_id;\\n }\\n\\n parameters {\\n real<lower=0> rho;\\n vector<lower=0>[D] rhovec;\\n real<lower=0> alpha;\\n }\\n\\n model {\\n int cov_id;\\n matrix[N, N] cov;\\n matrix[N, N] L_cov;\\n matrix[N, N] distmat;\\n\\n // RBF kernel single lengthscale\\n if (kernel_id == 1) {\\n cov = cov_exp_quad(x, alpha, rho) + diag_matrix(rep_vector(square(sigma), N));\\n L_cov = cholesky_decompose(cov);\\n rho ~ inv_gamma(ig1, ig2);\\n alpha ~ normal(n1, n2);\\n y ~ multi_normal_cholesky(rep_vector(0, N), L_cov);\\n }\\n\\n // Matern kernel single lengthscale\\n else if (kernel_id >= 2 && kernel_id <= 4) {\\n if (kernel_id == 2) { cov_id = 2; }\\n if (kernel_id == 3) { cov_id = 3; }\\n if (kernel_id == 4) { cov_id = 4; }\\n\\n distmat = distance_matrix_on_vectors(N, x);\\n cov = cov_matrix_matern(N, distmat, rho, square(alpha), cov_id) + diag_matrix(rep_vector(square(sigma), N));\\n L_cov = cholesky_decompose(cov);\\n rho ~ inv_gamma(ig1, ig2);\\n alpha ~ normal(n1, n2);\\n y ~ multi_normal_cholesky(rep_vector(0, N), L_cov);\\n }\\n\\n // RBF kernel with ARD (D-dimensional) lengthscale\\n else if (kernel_id == 5) {\\n cov_id = 1;\\n cov = cov_matrix_ard(N, D, x, rhovec, square(alpha), cov_id) + diag_matrix(rep_vector(square(sigma), N));\\n L_cov = cholesky_decompose(cov);\\n for(d in 1:D) {\\n rhovec[d] ~ inv_gamma(ig1, ig2);\\n }\\n alpha ~ normal(n1, n2);\\n y ~ multi_normal_cholesky(rep_vector(0, N), L_cov);\\n }\\n\\n }\\n \\\"\\\"\\\"\",\n \"def __init__(self, S, f, num_t_sens, num_t_insens):\\n # Number of states \\n self.S = S \\n self.f = f\\n self.t_sens = num_t_sens\\n self.t_insens = num_t_insens\\n \\n self.name = 'CRF'\",\n \"def __init__(self, C, num_classes):\\n super(AuxiliaryHeadCIFAR, self).__init__()\\n self.features = nn.Sequential(\\n nn.ReLU(inplace=True),\\n nn.AvgPool2d(5, stride=3, padding=0, count_include_pad=False), # image size = 2 x 2\\n nn.Conv2d(C, 128, 1, bias=False),\\n nn.BatchNorm2d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(128, 768, 2, bias=False),\\n nn.BatchNorm2d(768),\\n nn.ReLU(inplace=True)\\n )\\n self.classifier = nn.Linear(768, num_classes)\",\n \"def __init__(self, model):\\n self.model = model\\n self.n = 0\\n\\n self.ctetra4 = model.ctetra4\\n self.cpyram5 = model.cpyram5\\n self.cpenta6 = model.cpenta6\\n self.chexa8 = model.chexa8\\n\\n self.ctetra10 = model.ctetra10\\n self.cpyram13 = model.cpyram13\\n self.cpenta15 = model.cpenta15\\n self.chexa20 = model.chexa20\\n self.element_id = array([], dtype='int32')\",\n \"def recognition_model(self, x, c):\\n x = self.encoder(x)\\n c = self.conditional(c)\\n temp = self.recog_head(x + c)\\n mu = self.mu(temp)\\n logvar = self.logvar(temp)\\n return mu, logvar\",\n \"def recognition_model(self, x, c):\\n x = self.encoder(x)\\n c = self.conditional(c)\\n temp = self.recog_head(x + c)\\n mu = self.mu(temp)\\n logvar = self.logvar(temp)\\n return mu, logvar\",\n \"def build_model():\",\n \"def get_CIFAR10_data():\\n # Load the raw CIFAR-10 data\\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\\n X_train, _, X_test, _ = load_CIFAR10(cifar10_dir)\\n X = np.concatenate((X_train, X_test), axis =0)\\n return X\",\n \"def __init__(self, model):\\n if model == \\\"biblis\\\" :\\n data = [1.3200e+00, 2.7720e-01, 2.6562e-03, \\\\\\n 7.1596e-02, 0.00000000, 0.00000000, \\\\\\n 2.3106e-02] \\n else :\\n raise Exception(\\\"Reflector model not available\\\")\\n self.model = model\\n # Default group data.\\n self.D1 = data[0]\\n self.D2 = data[1]\\n self.A1 = data[2]\\n self.A2 = data[3] \\n self.F1 = data[4]\\n self.F2 = data[5] \\n self.S12 = data[6] \\n self.R1 = self.A1 + self.S12\",\n \"def construct_model():\\n import lbann\\n\\n # Layer graph\\n input = lbann.Input(target_mode='N/A', name='inp_data')\\n # data is 64*64*4 images + 15 scalar + 5 param\\n #inp_slice = lbann.Slice(input, axis=0, slice_points=\\\"0 16399 16404\\\",name='inp_slice')\\n inp_slice = lbann.Slice(input, axis=0, slice_points=str_list([0,args.ydim,args.ydim+5]),name='inp_slice')\\n gt_y = lbann.Identity(inp_slice,name='gt_y')\\n gt_x = lbann.Identity(inp_slice, name='gt_x') #param not used\\n\\n zero = lbann.Constant(value=0.0,num_neurons='1',name='zero')\\n one = lbann.Constant(value=1.0,num_neurons='1',name='one')\\n\\n z_dim = 20 #Latent space dim\\n\\n z = lbann.Gaussian(mean=0.0,stdev=1.0, neuron_dims=\\\"20\\\")\\n model = macc_models.MACCWAE(args.zdim,args.ydim,cf=args.mcf,use_CNN=args.useCNN)\\n d1_real, d1_fake, d_adv, pred_y = model(z,gt_y)\\n\\n d1_real_bce = lbann.SigmoidBinaryCrossEntropy([d1_real,one],name='d1_real_bce')\\n d1_fake_bce = lbann.SigmoidBinaryCrossEntropy([d1_fake,zero],name='d1_fake_bce')\\n d_adv_bce = lbann.SigmoidBinaryCrossEntropy([d_adv,one],name='d_adv_bce')\\n img_loss = lbann.MeanSquaredError([pred_y,gt_y])\\n rec_error = lbann.L2Norm2(lbann.WeightedSum([pred_y,gt_y], scaling_factors=\\\"1 -1\\\"))\\n\\n layers = list(lbann.traverse_layer_graph(input))\\n # Setup objective function\\n weights = set()\\n src_layers = []\\n dst_layers = []\\n for l in layers:\\n if(l.weights and \\\"disc0\\\" in l.name and \\\"instance1\\\" in l.name):\\n src_layers.append(l.name)\\n #freeze weights in disc2\\n if(l.weights and \\\"disc1\\\" in l.name):\\n dst_layers.append(l.name)\\n for idx in range(len(l.weights)):\\n l.weights[idx].optimizer = lbann.NoOptimizer()\\n weights.update(l.weights)\\n l2_reg = lbann.L2WeightRegularization(weights=weights, scale=1e-4)\\n d_adv_bce = lbann.LayerTerm(d_adv_bce,scale=0.01)\\n obj = lbann.ObjectiveFunction([d1_real_bce,d1_fake_bce,d_adv_bce,img_loss,rec_error,l2_reg])\\n # Initialize check metric callback\\n metrics = [lbann.Metric(img_loss, name='recon_error')]\\n #pred_y = macc_models.MACCWAE.pred_y_name\\n callbacks = [lbann.CallbackPrint(),\\n lbann.CallbackTimer(),\\n lbann.CallbackSaveModel(dir=args.dump_models),\\n lbann.CallbackReplaceWeights(source_layers=list2str(src_layers),\\n destination_layers=list2str(dst_layers),\\n batch_interval=2)]\\n\\n if(args.ltfb_batch_interval > 0) :\\n callbacks.append(lbann.CallbackLTFB(batch_interval=args.ltfb_batch_interval,metric='recon_error',\\n low_score_wins=True,\\n exchange_hyperparameters=True))\\n\\n # Construct model\\n return lbann.Model(args.num_epochs,\\n serialize_io=True,\\n weights=weights,\\n layers=layers,\\n metrics=metrics,\\n objective_function=obj,\\n callbacks=callbacks)\",\n \"def model_4_parameters(num_features, num_classes, image_info):\\n parameters = {}\\n parameters['num_features'] = num_features\\n parameters['num_classes'] = num_classes\\n if image_info['key'][:5] == \\\"pavia\\\":\\n parameters['C'] = 1.0\\n else:\\n parameters['C'] = 40.0\\n \\n return parameters\",\n \"def modelAVOAkiRichards3(interface):\\n interface[:,6]=0.5*(interface[:,0]/interface[:,3]+ \\\\\\n interface[:,2]/interface[:,5])\\n interface[:,7]=(interface[:,0]/(2*interface[:,3]))- \\\\\\n 4*((interface[:,4]**2/interface[:,3]**2)* \\\\\\n (interface[:,1]/interface[:,4]))- \\\\\\n 2*(interface[:,4]**2/interface[:,3]**2)* \\\\\\n (interface[:,2]/interface[:,5])\",\n \"def dynamic_model(self, input_val: float) -> float:\\n pass\",\n \"def load_cifar10_data(img_rows, img_cols):\\n\\n # Load cifar10 training and validation sets\\n (X_train, Y_train), (X_valid, Y_valid) = cifar10.load_data()\\n\\n # Resize training images\\n X_train = np.array([cv2.resize(img, (img_rows, \\\\\\n img_cols)) for img in X_train[:, :, :, :]])\\n\\n X_valid = np.array([cv2.resize(img, (img_rows, \\\\\\n img_cols)) for img in X_valid[:, :, :, :]])\\n\\n # Check the data type of X_train or X_valid\\n for each in X_train:\\n print(type(each))\\n\\n # Transform targets to keras compatible format\\n Y_train = np_utils.to_categorical(Y_train, num_classes)\\n Y_valid = np_utils.to_categorical(Y_valid, num_classes)\\n\\n X_train = X_train.astype('float32')\\n X_valid = X_valid.astype('float32')\\n\\n # Data normalization\\n X_train = X_train / 255.0\\n X_valid = X_valid / 255.0\\n\\n return X_train, Y_train, X_valid, Y_valid\",\n \"def model(self):\",\n \"def model(self):\",\n \"def model(self):\",\n \"def model(self):\",\n \"def model(self):\",\n \"def main():\\n nn = CarsClassifierModel()\\n train_x, train_y, test_x, test_y = nn.load_data_preprocess()\\n history = nn.run(train_x,train_y)\\n nn.evaluate(test_x, test_y)\\n nn.save(\\\"keras_nn_5\\\")\\n #nn.plots(history)\\n #print(train_x.shape)\\n #plt.imshow(train_x[52])\\n #plt.title(\\\"Car\\\")\\n #plt.show()\\n #print(train_y[52])\",\n \"def get_model_with_properties():\\n \\n m = ConcreteModel()\\n\\n # ------------------------------------------------------------------\\n # Data\\n # ------------------------------------------------------------------\\n\\n m.np = 25 # Number of possible tays\\n m.c = 4 # Number of components\\n m.lc = 1 # Light component\\n m.hc = 4 # Heavy component\\n\\n #### Constant parameters\\n m.Rgas = 8.314 # Ideal gas constant in J/mol K\\n m.Tref = 298.15 # Reference temperature in K\\n\\n #### Product specifications\\n m.xspec_lc = 0.99 # Final liquid composition for methanol (1)\\n m.xspec_hc = 0.99 # Fnal liquid composition for butanol (4)\\n m.xspec_inter2 = 0.99 # Final liquid composition for ethanol (2)\\n m.xspec_inter3 = 0.99 # Final liquid composition for propanol (3)\\n m.Ddes = 50 # Final flowrate in distillate in mol/s\\n m.Bdes = 50 # Final flowrate in bottoms in mol/s\\n m.Sdes = 50 # Final flowrate in side product streams in mol/s\\n\\n # #### Known initial values\\n m.Fi = m.Ddes + m.Bdes + 2 * m.Sdes # Side feed flowrate in mol/s\\n m.Vi = 400 # Initial value for vapor flowrate in mol/s\\n m.Li = 400 # Initial value for liquid flowrate in mol/s\\n\\n m.Tf = 358 # Side feed temperature in K\\n\\n m.Preb = 1.2 # Reboiler pressure in bar\\n m.Pbot = 1.12 # Bottom-most tray pressure in bar\\n m.Ptop = 1.08 # Top-most tray pressure in bar\\n m.Pcon = 1.05 # Condenser pressure in bar\\n m.Pf = 1.02\\n\\n m.rr0 = 0.893 # Internal reflux ratio initial value\\n m.bu0 = 0.871 # Internal reflux ratio initial value\\n\\n\\n #### Scaling factors\\n m.Hscale = 1e3 \\n m.Qscale = 1e-3 \\n\\n \\n #### Constants for the calculation of liquid heat capacity\\n m.cpc = {} # Constant 1 for liquid heat capacity \\n m.cpc2 = {} # Constant 2 for liquid heat capacity \\n m.cpc[1] = m.Rgas \\n m.cpc[2] = 1\\n m.cpc2['A', 1] = 1 / 100\\n m.cpc2['B', 1] = 1 / 1e4\\n m.cpc2['A', 2] = 1\\n m.cpc2['B', 2] = 1\\n\\n\\n # ------------------------------------------------------------------\\n # Physical Properties\\n #\\n # Notation:\\n # MW ........................ molecular weight in g/gmol\\n # TB ........................ boiling point temperature in K\\n # TC ........................ critical temperature in K\\n # PC ........................ critical pressure in bar\\n # w ........................ acentric factor\\n # lden ...................... liquid density g/m3,\\n # dHvap ..................... heat of vaporization in J/mol.\\n # vpA, vpB, vpC, and vpD .... vapor pressure constants\\n # cpA, cpB, cpC, and cpD .... heat capacity constants J/mol:\\n # 1 for liq and 2 for vapor phase\\n #\\n # Reference A: R.C. Reid, J.M. Prausnitz and B.E. Poling,\\n # \\\"The Properties of gases and liquids\\\", 1987 and 2004 Eds.\\n #\\n # ------------------------------------------------------------------\\n\\n m.prop = {} # Properties of components:\\n cpL = {} # Ruczika-D method for liquid heat capacity calculation\\n # (Reference A, page 6.20)\\n sumA = {}\\n sumB = {}\\n sumC = {}\\n cpL['a', 'C(H3)(C)'] = 4.19845\\n cpL['b', 'C(H3)(C)'] = -0.312709\\n cpL['c', 'C(H3)(C)'] = 0.178609\\n cpL['a', 'C(H2)(C2)'] = 2.7345\\n cpL['b', 'C(H2)(C2)'] = 0.122732\\n cpL['c', 'C(H2)(C2)'] = -0.123482\\n cpL['a', 'C(H2)(C)(O)'] = 0.517007\\n cpL['b', 'C(H2)(C)(O)'] = 1.26631\\n cpL['c', 'C(H2)(C)(O)'] = -0.0939713\\n cpL['a', 'O(H)(C)'] = 16.1555\\n cpL['b', 'O(H)(C)'] = -11.938\\n cpL['c', 'O(H)(C)'] = 2.85117\\n cpL['a', 'C(H3)(O)'] = 3.70344\\n cpL['b', 'C(H3)(O)'] = -1.12884\\n cpL['c', 'C(H3)(O)'] = 0.51239\\n sumA[1] = (cpL['a', 'C(H3)(O)']\\n + cpL['a', 'O(H)(C)']) \\n sumB[1] = (cpL['b', 'C(H3)(O)']\\n + cpL['b', 'O(H)(C)'])\\n sumC[1] = (cpL['c', 'C(H3)(O)']\\n + cpL['c', 'O(H)(C)'])\\n sumA[2] = (cpL['a', 'C(H3)(C)']\\n + cpL['a', 'C(H2)(C)(O)']\\n + cpL['a', 'O(H)(C)'])\\n sumB[2] = (cpL['b', 'C(H3)(C)']\\n + cpL['b', 'C(H2)(C)(O)']\\n + cpL['b', 'O(H)(C)'])\\n sumC[2] = (cpL['c', 'C(H3)(C)']\\n + cpL['c', 'C(H2)(C)(O)']\\n + cpL['c', 'O(H)(C)'])\\n sumA[3] = (cpL['a', 'C(H3)(C)']\\n + cpL['a', 'C(H2)(C2)']\\n + cpL['a', 'C(H2)(C)(O)']\\n + cpL['a', 'O(H)(C)'])\\n sumB[3] = (cpL['b', 'C(H3)(C)']\\n + cpL['b', 'C(H2)(C2)']\\n + cpL['b', 'C(H2)(C)(O)']\\n + cpL['b', 'O(H)(C)'])\\n sumC[3] = (cpL['c', 'C(H3)(C)']\\n + cpL['c', 'C(H2)(C2)']\\n + cpL['c', 'C(H2)(C)(O)']\\n + cpL['c', 'O(H)(C)'])\\n sumA[4] = (cpL['a', 'C(H3)(C)']\\n + 2 * cpL['a', 'C(H2)(C2)']\\n + cpL['a', 'C(H2)(C)(O)']\\n + cpL['a', 'O(H)(C)'])\\n sumB[4] = (cpL['b', 'C(H3)(C)']\\n + 2 * cpL['b', 'C(H2)(C2)']\\n + cpL['b', 'C(H2)(C)(O)']\\n + cpL['b', 'O(H)(C)'])\\n sumC[4] = (cpL['c', 'C(H3)(C)']\\n + 2 * cpL['c', 'C(H2)(C2)']\\n + cpL['c', 'C(H2)(C)(O)']\\n + cpL['c', 'O(H)(C)'])\\n\\n ## Methanol: component 1\\n m.prop[1, 'MW'] = 32.042\\n m.prop[1, 'TB'] = 337.7\\n m.prop[1, 'TC'] = 512.6\\n m.prop[1, 'PC'] = 80.9\\n m.prop[1, 'w'] = 0.556\\n m.prop[1, 'lden'] = 792e3\\n m.prop[1, 'dHvap'] = 38.376e3\\n m.prop[1, 'vpA'] = -8.54796\\n m.prop[1, 'vpB'] = 0.76982\\n m.prop[1, 'vpC'] = -3.10850\\n m.prop[1, 'vpD'] = 1.54481\\n m.prop[1, 'cpA', 1] = sumA[1]\\n m.prop[1, 'cpB', 1] = sumB[1]\\n m.prop[1, 'cpC', 1] = sumC[1]\\n m.prop[1, 'cpD', 1] = 0\\n m.prop[1, 'cpA', 2] = 2.115e1\\n m.prop[1, 'cpB', 2] = 7.092e-2\\n m.prop[1, 'cpC', 2] = 2.587e-5\\n m.prop[1, 'cpD', 2] = -2.852e-8\\n\\n\\n ## Ethanol: component 2\\n m.prop[2, 'MW'] = 46.069\\n m.prop[2, 'TB'] = 351.4\\n m.prop[2, 'TC'] = 513.9\\n m.prop[2, 'PC'] = 61.4\\n m.prop[2, 'w'] = 0.644\\n m.prop[2, 'lden'] = 789.3e3\\n m.prop[2, 'dHvap'] = 42.698e3\\n m.prop[2, 'vpA'] = -8.51838\\n m.prop[2, 'vpB'] = 0.34163\\n m.prop[2, 'vpC'] = -5.73683\\n m.prop[2, 'vpD'] = 8.32581\\n m.prop[2, 'cpA', 1] = sumA[2]\\n m.prop[2, 'cpB', 1] = sumB[2]\\n m.prop[2, 'cpC', 1] = sumC[2]\\n m.prop[2, 'cpD', 1] = 0\\n m.prop[2, 'cpA', 2] = 9.014\\n m.prop[2, 'cpB', 2] = 2.141e-1\\n m.prop[2, 'cpC', 2] = -8.390e-5\\n m.prop[2, 'cpD', 2] = 1.373e-9\\n\\n\\n ## Propanol: component 3\\n m.prop[3, 'MW'] = 60.096\\n m.prop[3, 'TB'] = 370.3\\n m.prop[3, 'TC'] = 536.8\\n m.prop[3, 'PC'] = 51.7\\n m.prop[3, 'w'] = 0.623\\n m.prop[3, 'lden'] = 804e3\\n m.prop[3, 'dHvap'] = 47.763e3\\n m.prop[3, 'vpA'] = -8.05594\\n m.prop[3, 'vpB'] = 4.25183e-2\\n m.prop[3, 'vpC'] = -7.51296\\n m.prop[3, 'vpD'] = 6.89004\\n m.prop[3, 'cpA', 1] = sumA[3]\\n m.prop[3, 'cpB', 1] = sumB[3]\\n m.prop[3, 'cpC', 1] = sumC[3]\\n m.prop[3, 'cpD', 1] = 0\\n m.prop[3, 'cpA', 2] = 2.47\\n m.prop[3, 'cpB', 2] = 3.325e-1\\n m.prop[3, 'cpC', 2] = -1.855e-4\\n m.prop[3, 'cpD', 2] = 4.296e-8\\n\\n\\n ## Butanol: component 4\\n m.prop[4, 'MW'] = 74.123\\n m.prop[4, 'TB'] = 390.9\\n m.prop[4, 'TC'] = 563.1\\n m.prop[4, 'PC'] = 44.2\\n m.prop[4, 'w'] = 0.593\\n m.prop[4, 'lden'] = 810e3\\n m.prop[4, 'dHvap'] = 52.607e3\\n m.prop[4, 'vpA'] = -8.00756\\n m.prop[4, 'vpB'] = 0.53783\\n m.prop[4, 'vpC'] = -9.34240\\n m.prop[4, 'vpD'] = 6.68692\\n m.prop[4, 'cpA', 1] = sumA[4]\\n m.prop[4, 'cpB', 1] = sumB[4]\\n m.prop[4, 'cpC', 1] = sumC[4]\\n m.prop[4, 'cpD', 1] = 0\\n m.prop[4, 'cpA', 2] = 3.266\\n m.prop[4, 'cpB', 2] = 4.18e-1\\n m.prop[4, 'cpC', 2] = -2.242e-4\\n m.prop[4, 'cpD', 2] = 4.685e-8\\n\\n\\n return m\",\n \"def test_construct_f_(self):\\n model = roi._core._ContinuousROM('')\\n\\n # Check that the constructed f takes the right number of arguments.\\n model.modelform = \\\"cA\\\"\\n model.c_, model.A_ = 1, 1\\n model.Hc_, model.Gc_, model.B_ = None, None, None\\n model._construct_f_()\\n with pytest.raises(TypeError) as ex:\\n model.f_(1)\\n assert ex.value.args[0] == \\\\\\n \\\"<lambda>() missing 1 required positional argument: 'x_'\\\"\",\n \"def fConnectivityModel(RD,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha):\\n#\\n# 1. Initialisations:\\n# \\t-------------------\\n\\tFSwEnd = 0\\n\\tFSwInt = 0\\n\\tFSwMax = 200\\n\\tFSwErr = 0.0001\\n\\tSwOld = 1\\n\\tSwNew = 1\\n\\tSwInc = 0\\n\\tTiny=0.000000001\\n\\tBig=1000000000000\\n\\tTout=0 # Defines output of fRCrim\\n#\\n# 2. Calculate Observed Conductivity:\\n#-----------------------------------\\n\\tif(RD<=0):\\n\\t\\tCt=Big\\n\\telse:\\n\\t\\tCt=1/RD\\n#\\n# 2. Interative Loop:\\n#--------------------\\t\\t\\n\\tSwOld=0.50 # Initialises Effective Water Saturation\\n\\twhile(FSwEnd==0):\\n\\t\\tCm=fRCrim(SwOld,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout)\\n\\t\\tr=Ct-Cm\\n\\t\\ts=(Cm-fRCrim((SwOld-Tiny),Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout))/Tiny # dCm/dSw\\n\\t\\tif(s==0): \\n\\t\\t\\tFSwEnd=1\\n\\t\\t\\ts=Tiny\\n\\t\\tSwInc=(r/s)\\n\\t\\tSwNew=SwOld+SwInc\\n\\t\\tFSwInt=FSwInt+1\\n\\t\\tif(FSwInt>3):\\t\\n\\t\\t\\tif (FSwInt>=FSwMax):\\n\\t\\t\\t\\tFSwEnd=1\\n\\t\\t\\tif (abs(SwOld-SwNew)<FSwErr):\\n\\t\\t\\t\\tFSwEnd=1\\n\\t\\tSwOld=SwNew\\n\\t\\tSwOld=ImposeLimits(SwOld,Tiny,1)\\n\\t#\\t\\t\\n\\treturn SwOld\",\n \"def __init__(self, model):\\n aaa\\n self.model = model\\n\\n #: the list of CROD cards\\n self._crod = []\\n\\n #: the list of CONROD cards\\n self._conrod = []\\n\\n self._crod_comment = []\\n self._conrod_comment = []\\n\\n self.crod = CROD(self.model)\\n self.conrod = CONROD(self.model)\",\n \"def load_CIFAR10(ROOT):\\r\\n xs = []\\r\\n ys = []\\r\\n for b in range(1,6):\\r\\n f = os.path.join(ROOT, 'data_batch_%d' % (b, ))\\r\\n X, Y = load_CIFAR_batch(f)\\r\\n xs.append(X)\\r\\n ys.append(Y)\\r\\n Xtr = np.concatenate(xs)\\r\\n Ytr = np.concatenate(ys)\\r\\n del X, Y\\r\\n Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))\\r\\n return Xtr, Ytr, Xte, Yte\\r\\n\\r\\n\\tdef get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=10000):\\r\\n # Load the raw CIFAR-10 data\\r\\n \\r\\n cifar10_dir = 'Downloads/cifar-10-batches-py'\\r\\n \\r\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\r\\n\\r\\n # Subsample the data\\r\\n mask = range(num_training, num_training + num_validation)\\r\\n X_val = X_train[mask]\\r\\n y_val = y_train[mask]\\r\\n mask = range(num_training)\\r\\n X_train = X_train[mask]\\r\\n y_train = y_train[mask]\\r\\n mask = range(num_test)\\r\\n X_test = X_test[mask]\\r\\n y_test = y_test[mask]\\r\\n\\r\\n x_train = X_train.astype('float32') \\r\\n x_test = X_test.astype('float32')\\r\\n \\r\\n x_train = x_train.reshape(-1, 32, 32, 3)\\r\\n x_test = x_test.reshape(-1, 32, 32, 3)\\r\\n x_train /= 255\\r\\n x_test /= 255\\r\\n\\r\\n return x_train, y_train, X_val, y_val, x_test, y_test\",\n \"def create_model(self, C : float =1):\\n self.classifier = RandomForestClassifier(max_depth=5)\",\n \"def GenerateModel(modelData, outputFilePath, objectName = 'SBMLmodel'):\\n #The library mathFuncs serves to both only allow functions supported\\n #functions in SBML/user defined functions, but also the python equivalent\\n \\n np.set_printoptions(threshold=sys.maxsize)\\n \\n \\n \\n outputFile = open(outputFilePath, \\\"w\\\")\\n\\n parameters = modelData.parameters\\n compartments = modelData.compartments\\n species = modelData.species\\n reactions = modelData.reactions\\n functions = modelData.functions\\n \\n assignmentRules = modelData.assignmentRules\\n rateRules = modelData.rateRules\\n initialAssignments = modelData.initialAssignments\\n \\n mathFuncs = {'abs' : 'abs',\\n 'max' : 'max',\\n 'min' : 'min',\\n 'pow' : 'pow',\\n 'exp' : 'math.exp',\\n 'floor' : 'np.floor',\\n 'ceiling' : 'math.ceil',\\n 'exp' : 'math.exp',\\n 'ln' : 'math.log',\\n 'log' : 'math.log10',\\n 'factorial' : 'math.factorial',\\n 'sqrt' : 'math.sqrt',\\n \\n 'eq' : 'operator.eq',\\n 'neq' : 'operator.ne',\\n 'gt' : 'operator.gt',\\n 'lt' : 'operator.lt',\\n 'geq' : 'operator.ge',\\n 'leq' : 'operator.le',\\n \\n 'and' : 'operator.and_',\\n 'or' : 'operator.or_',\\n 'xor' : 'operator.xor_',\\n 'not' : 'operator.not_',\\n \\n 'sin' : 'np.sin',\\n 'cos' : 'np.cos',\\n 'tan' : 'np.tan',\\n 'sec' : '1/np.cos',\\n 'csc' : '1/np.sin',\\n 'cot' : '1/np.tan',\\n 'sinh' : 'np.sinh',\\n 'cosh' : 'np.cosh',\\n 'tanh' : 'np.tanh',\\n 'sech' : '1/np.cosh',\\n 'csch' : '1/np.sinh',\\n 'coth' : '1/np.tanh',\\n 'arcsin' : 'np.arcsin',\\n 'arccos' : 'np.arccos',\\n 'arctan' : 'np.arctan',\\n 'arcsinh' : 'np.arcsinh',\\n 'arccosh' : 'np.arccosh',\\n 'arctanh' : 'np.arctanh',\\n \\n 'true' : 'True',\\n 'false' : 'False',\\n 'notanumber' : 'np.nan',\\n 'pi' : 'np.pi',\\n 'infinity' : 'np.inf',\\n 'exponentiale' : 'np.e',\\n 'piecewise' : 'Piecewise'\\n } \\n #Add in user defined functions\\n# for function in functions:\\n# mathFuncs[function] = \\\"self.\\\" + function\\n\\t\\t\\n #Set up stoichCoeffMat, a matrix of stoichiometric coefficients for solving the reactions\\n reactantCounter = 0\\n reactantIndex = {}\\n reactionCounter = 0\\n reactionIndex = {}\\n \\n rateRuleVars = []\\n rateParams = 0\\n for specie in species:\\n reactantIndex[specie] = reactantCounter\\n reactantCounter += 1\\n for key, rateRule in rateRules.items():\\n if rateRule.variable in parameters or rateRule.variable in compartments:\\n rateParams += 1\\n reactantIndex[rateRule.variable] = reactantCounter\\n reactantCounter += 1\\n rateRuleVars.append(rateRule.variable)\\n elif rateRule.variable in species:\\n pass\\n else:\\n raise Exception(\\\"Rate Rule adjusting something other than specie amount, parameter value, or compartment size.\\\")\\n\\n \\t\\t\\n stoichCoeffMat = np.zeros([len(species) + rateParams, max(len(reactions),1)])\\n \\n for rxnId in reactions:\\n reactionIndex[rxnId] = reactionCounter\\n reactionCounter += 1\\n reaction = reactions[rxnId]\\n for reactant in reaction.reactants:\\n if reactant[1] not in reactantIndex:\\n reactantIndex[reactant[1]] = reactantCounter\\n reactantCounter += 1\\n if not (species[reactant[1]].isBoundarySpecies == \\\"True\\\"):\\n stoichCoeffMat[reactantIndex[reactant[1]], reactionIndex[rxnId]] += reactant[0]\\n\\n \\t\\n # for reaction in reactions:\\n # for reactant in reactions[reaction][0]:\\n # if reactant[1] not in reactantIndex:\\n # reactantIndex[reactant[1]] = reactantCounter\\n # reactantCounter += 1\\n # if not species[reactant[1]][4]:\\n # stoichCoeffMat[reactantIndex[reactant[1]], reaction-1] += reactant[0]\\n #print(rateParams)\\n #print(stoichCoeffMat)\\n \\n outputFile.write(\\\"from sbmltopyode.SBMLModelClasses import *\\\\n\\\")\\n outputFile.write(\\\"from scipy.integrate import odeint\\\\n\\\")\\n outputFile.write(\\\"import numpy as np\\\\n\\\")\\n outputFile.write(\\\"import operator\\\\n\\\")\\n outputFile.write(\\\"import math\\\\n\\\\n\\\")\\n \\n outputFile.write(\\\"class \\\" + objectName +\\\":\\\\n\\\\n\\\")\\n \\n outputFile.write(\\\"\\\\tdef __init__(self):\\\\n\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\tself.p = {} #Dictionary of model parameters\\\\n\\\")\\n for paramId in parameters:\\n outputFile.write(\\\"\\\\t\\\\tself.p[\\\\'\\\" + paramId + \\\"\\\\'] = Parameter(\\\" + str(parameters[paramId].value)+ \\\", \\\\'\\\"+ paramId + \\\"\\\\', \\\" + str(parameters[paramId].isConstant) +\\\")\\\\n\\\")\\n \\n outputFile.write(\\\"\\\\n\\\\t\\\\tself.c = {} #Dictionary of compartments\\\\n\\\")\\n for compartmentId in compartments:\\n outputFile.write(\\\"\\\\t\\\\tself.c[\\\\'\\\" + compartmentId + \\\"\\\\'] = Compartment(\\\" + str(compartments[compartmentId].size) + \\\", \\\" + str(compartments[compartmentId].dimensionality)+ \\\", \\\" + str(compartments[compartmentId].isConstant) + \\\")\\\\n\\\")\\n \\n outputFile.write(\\\"\\\\n\\\\t\\\\tself.s = {} #Dictionary of chemical species\\\\n\\\")\\n for speciesId in species:\\n outputFile.write(\\\"\\\\t\\\\tspeciesMetadata = SBMLMetadata('\\\" + species[speciesId].name +\\\"')\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\tself.s[\\\\'\\\" + speciesId + \\\"\\\\'] = Species(\\\" + str(species[speciesId].value) + \\\", '\\\" + species[speciesId].valueType + \\\"', self.c['\\\" + species[speciesId].compartment + \\\"'], \\\" + str(species[speciesId].hasOnlySubstanceUnits) + \\\", constant = \\\" + str(species[speciesId].isConstant) + \\\")\\\\n\\\")\\n for key, rule in assignmentRules.items():\\n if rule.variable == speciesId:\\n outputFile.write(\\\"\\\\t\\\\tself.s[\\\\'\\\" + speciesId + \\\"\\\\']._modifiedBy = \\\" + rule.Id + \\\"\\\\n\\\")\\n for key, rule in rateRules.items():\\n if rule.variable == speciesId:\\n outputFile.write(\\\"\\\\t\\\\tself.s[\\\\'\\\" + speciesId + \\\"\\\\']._modifiedBy = \\\" + rule.Id + \\\"\\\\n\\\")\\n \\n \\n outputFile.write(\\\"\\\\n\\\\t\\\\tself.r = {} #Dictionary of reactiions\\\\n\\\")\\n for reactionId in reactions:\\n outputFile.write(\\\"\\\\t\\\\tself.r[\\\\'\\\" + reactionId + \\\"\\\\'] = \\\" + reactionId + \\\"(self, SBMLMetadata('\\\" + reactions[reactionId].name + \\\"'))\\\\n\\\")\\n \\n outputFile.write(\\\"\\\\t\\\\tself.time = 0\\\\n\\\\n\\\")\\n \\n outputFile.write(\\\"\\\\t\\\\tself.reactionMetadata = {\\\")\\n commaFlag = 0\\n for reactionId in reactions:\\n if commaFlag == 0:\\n commaFlag = 1\\n outputFile.write(\\\"\\\\n\\\\t\\\\t\\\")\\n else:\\n outputFile.write(\\\",\\\\n\\\\t\\\\t\\\")\\n outputFile.write(\\\"self.Reaction\\\" + reactionId + \\\": SBMLMetadata('\\\" + reactions[reactionId].name + \\\"')\\\")\\n outputFile.write(\\\"\\\\n\\\\t\\\\t}\\\\n\\\")\\n \\n outputFile.write('\\\\t\\\\tself.AssignmentRules()\\\\n\\\\n')\\n \\n outputFile.write(\\\"\\\\n\\\\n\\\")\\n outputFile.write(\\\"\\\\tdef AssignmentRules(self):\\\\n\\\\n\\\")\\n #These functions are defined here due to reading variables in the parent function's namespace\\n #These are not intended to be used elsewhere\\n def ParseLHS(rawLHS):\\n returnLHS = ''\\n if rawLHS in parameters:\\n returnLHS = \\\"self.p[\\\\'\\\" + rawLHS + \\\"\\\\'].value = \\\"\\n elif rawLHS in species:\\n if not species[rawLHS].hasOnlySubstanceUnits: \\n returnLHS = 'self.s[\\\\'' + rawLHS + '\\\\'].concentration = '\\n else: \\n returnLHS = 'self.s[\\\\'' + rawLHS + '\\\\'].amount = '\\n elif rawLHS in compartments:\\n returnLHS = 'self.c[\\\\'' + rawLHS + '\\\\'].size = '\\n else:\\n raise(Exception(\\\"New case: rule LHS not in p: \\\" + rawLHS))\\n\\n return returnLHS\\n\\t\\n def ParseRHS(rawRHS, extendedParams = [], objectText = \\\"self\\\"):\\n #objectText is not \\\"self\\\" when parsing reaction math\\n \\n #The main purpose of this function is to turn math strings given by libSBML into\\n #code formated to properly call members of the resulting class\\n #For example k_1*C_A may turn to\\n \\n \\n rawRHS = rawRHS.replace(\\\"^\\\", \\\"**\\\") #Replaces carrot notation for exponentiation with ** operator\\n variables = []\\n for match in re.finditer(r'\\\\b[a-zA-Z_]\\\\w*', rawRHS): #look for variable names\\n #ToDo: check for function calls\\n variables.append([rawRHS[match.start():match.end()], match.span()])\\n \\n #rule[1] contains the right hand side\\n returnRHS = ''\\n oldSpan = None\\n if variables != []:\\n for variable in variables:\\n if oldSpan == None and variable[1][0] != 0:\\n returnRHS += rawRHS[0:variable[1][0]]\\n elif oldSpan != None:\\n returnRHS += rawRHS[oldSpan[1]:variable[1][0]]\\n oldSpan = variable[1]\\n if variable[0] in parameters:\\n returnRHS += objectText + '.p[\\\\'' + variable[0] + '\\\\'].value'\\n elif variable[0] in species:\\n if not species[variable[0]].hasOnlySubstanceUnits == \\\"True\\\": \\n returnRHS += objectText + '.s[\\\\'' + variable[0] + '\\\\'].concentration'\\n else: \\n returnRHS += objectText + '.s[\\\\'' + variable[0] + '\\\\'].amount'\\n elif variable[0] in compartments:\\n returnRHS += objectText + '.c[\\\\'' + variable[0] + '\\\\'].size'\\n elif variable[0] in mathFuncs:\\n returnRHS += mathFuncs[variable[0]]\\n elif variable[0] in functions:\\n returnRHS += objectText + '.' + variable[0]\\n elif variable[0] in extendedParams:\\n if objectText == \\\"self\\\":\\n returnRHS += variable[0]\\n else:\\n returnRHS += \\\"self.p[\\\\'\\\" + variable[0] + \\\"\\\\'].value\\\"\\n\\n elif variable[0] == \\\"time\\\":\\n returnRHS += objectText + '.time'\\n elif variable[0] == \\\"pi\\\":\\n returnRHS += \\\"np.pi\\\"\\n else:\\n raise(Exception('New case: unkown RHS variable: ' + variable[0]))\\n returnRHS += rawRHS[variable[1][1]:len(rawRHS)]\\n # print(rule[1][variable[1][1]])\\n #print(rule[1][-1])\\n else:\\n returnRHS = rawRHS\\n\\t\\t\\n return returnRHS\\n\\n ruleDefinedVars = [rule.variable for rule in assignmentRules.values()]\\n for key, assignment in initialAssignments.items():\\n ruleDefinedVars.append(assignment.variable)\\n \\n for key, rule in assignmentRules.items():\\n rule.dependents = []\\n for match in re.finditer(r'\\\\b[a-zA-Z_]\\\\w*', rule.math): #look for variable names\\n rule.dependents.append(rule.math[match.start():match.end()])\\n originalLen = len(rule.dependents)\\n for i in range(originalLen):\\n if rule.dependents[originalLen - i -1] not in ruleDefinedVars:\\n rule.dependents.pop(originalLen- i-1)\\n \\n for key, assignment in initialAssignments.items():\\n assignment.dependents = []\\n for match in re.finditer(r'\\\\b[a-zA-Z_]\\\\w*', assignment.math): #look for variable names\\n assignment.dependents.append(assignment.math[match.start():match.end()])\\n originalLen = len(assignment.dependents)\\n for i in range(originalLen):\\n if assignment.dependents[originalLen - i -1] not in ruleDefinedVars :\\n assignment.dependents.pop(originalLen- i-1)\\n \\n# breakVar = False\\n while True:\\n continueVar = False\\n breakVar = True\\n varDefinedThisLoop = None\\n for key, rule in assignmentRules.items():\\n if rule.dependents == []:\\n ruleLHS = ParseLHS(rule.variable)\\n ruleRHS = ParseRHS(rule.math)\\n outputFile.write(\\\"\\\\t\\\\t\\\" + ruleLHS + ruleRHS + '\\\\n\\\\n')\\n varDefinedThisLoop = rule.variable\\n rule.dependents = None\\n continueVar = True\\n breakVar = False\\n break\\n elif not rule.dependents == None:\\n breakVar = False\\n \\n if not continueVar:\\n for key, assignment in initialAssignments.items():\\n if assignment.dependents == []:\\n assignmentLHS = ParseLHS(assignment.variable)\\n assignmentRHS = ParseRHS(assignment.math)\\n outputFile.write(\\\"\\\\t\\\\tif self.time <= 0 :\\\\n\\\")\\n if assignment.variable in parameters:\\n outputFile.write(\\\"\\\\t\\\\t\\\\tisConstantValue = self.p['\\\" + assignment.variable + \\\"']._constant\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\t\\\\tself.p['\\\" + assignment.variable + \\\"']._constant = False\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\t\\\\t\\\" + assignmentLHS + assignmentRHS + '\\\\n')\\n outputFile.write(\\\"\\\\t\\\\t\\\\tself.p['\\\" + assignment.variable + \\\"']._constant = isConstantValue\\\\n\\\\n\\\")\\n elif assignment.variable in species:\\n outputFile.write(\\\"\\\\t\\\\t\\\\tisConstantValue = self.s['\\\" + assignment.variable + \\\"']._constant\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\t\\\\tself.s['\\\" + assignment.variable + \\\"']._constant = False\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\t\\\\t\\\" + assignmentLHS + assignmentRHS + '\\\\n')\\n outputFile.write(\\\"\\\\t\\\\t\\\\tself.s['\\\" + assignment.variable + \\\"']._constant = isConstantValue\\\\n\\\\n\\\")\\n elif assignment.variable in compartment:\\n outputFile.write(\\\"\\\\t\\\\t\\\\tisConstantValue = self.c['\\\" + assignment.variable + \\\"']._constant\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\t\\\\tself.c['\\\" + assignment.variable + \\\"']._constant = False\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\t\\\\t\\\" + assignmentLHS + assignmentRHS + '\\\\n')\\n outputFile.write(\\\"\\\\t\\\\t\\\\tself.c['\\\" + assignment.variable + \\\"']._constant = isConstantValue\\\\n\\\\n\\\")\\n \\n varDefinedThisLoop = assignment.variable\\n assignment.dependents = None\\n continueVar = True\\n breakVar = False\\n break\\n elif not rule.dependents == None:\\n breakVar = False\\n \\n for rule in assignmentRules.values():\\n if not rule.dependents == None:\\n originalLen = len(rule.dependents)\\n for i in range(originalLen):\\n if rule.dependents[originalLen - i -1] == varDefinedThisLoop:\\n rule.dependents.pop(originalLen - i -1)\\n# print(rule.variable + ':' + str(rule.dependents))\\n\\n for assignment in initialAssignments.values():\\n if not assignment.dependents == None:\\n originalLen = len(assignment.dependents)\\n for i in range(originalLen):\\n if assignment.dependents[originalLen - i - 1] == varDefinedThisLoop:\\n assignment.dependents.pop(originalLen - i - 1)\\n# print(assignment.variable + ':' + str(assignment.dependents))\\n \\n if continueVar:\\n continue\\n elif breakVar:\\n break\\n else:\\n raise Exception('Algebraic Loop in AssignmentRules')\\n \\n outputFile.write(\\\"\\\\t\\\\treturn\\\\n\\\\n\\\")\\n \\n for functionId in functions:\\n arguments = functions[functionId].arguments\\n argumentString = \\\"\\\"\\n for i in range(len(arguments)):\\n argumentString += arguments[i]\\n if i != len(arguments) - 1:\\n argumentString += \\\", \\\"\\n \\n outputFile.write(\\\"\\\\tdef \\\" + functionId + \\\"(self, \\\" + argumentString + \\\"):\\\\n\\\")\\n outputFile.write(\\\"\\\\t\\\\treturn \\\" + functions[functionId].mathString.replace(\\\"^\\\", \\\"**\\\") + \\\"\\\\n\\\")\\n \\n for reactionId in reactions:\\n outputFile.write(\\\"\\\\tdef Reaction\\\" + str(reactionId) + \\\"(self):\\\\n\\\\n\\\")\\n\\n rxnParameters = []\\n for param in reactions[reactionId].rxnParameters:\\n outputFile.write(\\\"\\\\t\\\\t\\\" + param[0] + \\\" = \\\" + str(param[1]) + \\\"\\\\n\\\")\\n rxnParameters.append(param[0])\\n\\t\\t\\t\\n rateLaw = ParseRHS(reactions[reactionId].rateLaw, rxnParameters)\\n \\n outputFile.write('\\\\t\\\\treturn ' + rateLaw + '\\\\n\\\\n')\\n\\n rateRuleLHSVars = []\\n for key, rateRule in rateRules.items():\\n rateRuleLHSVars.append(rateRule.variable)\\n outputFile.write(\\\"\\\\tdef Rate\\\" + rateRule.variable + \\\"(self):\\\\n\\\\n\\\")\\n rateLaw = ParseRHS(rateRule.math)\\n outputFile.write('\\\\t\\\\treturn ' + rateLaw + '\\\\n\\\\n')\\n \\n yArray = ''\\n i = 0\\n yArrayVars = [0 for x in range(len(species) + rateParams)]\\n for variable, index in reactantIndex.items():\\n yArrayVars[index] = variable\\n \\n for index in range(len(yArrayVars)):\\n # print(yArrayVars[index])\\n if index != 0:\\n yArray += ', '\\n \\n if yArrayVars[index] in species:\\n yArray += 'self.s[\\\\'' + yArrayVars[index] + '\\\\'].amount'\\n continue\\n \\n if yArrayVars[index] in parameters:\\n yArray += 'self.p[\\\\'' + yArrayVars[index] + '\\\\'].value'\\n continue\\n \\n if yArrayVars[index] in compartments:\\n yArray += 'self.c\\\\'' + yArrayVars[index] + '\\\\'].size'\\n continue\\n \\n\\n \\n outputFile.write('\\\\tdef _SolveReactions(self, y, t):\\\\n\\\\n')\\n outputFile.write('\\\\t\\\\tself.time = t\\\\n')\\n outputFile.write('\\\\t\\\\t' + yArray + ' = y\\\\n')\\n outputFile.write('\\\\t\\\\tself.AssignmentRules()\\\\n\\\\n')\\n# outputFile.write('\\\\t\\\\t[self.s[speciesId].UpdateCompartmentSizeMember() for speciesId in self.s]\\\\n')\\n rateArray = '[ '\\n i = 0\\n rateArrayVars = [0 for x in range(len(species) + rateParams)]\\n \\n for variable, index in reactantIndex.items():\\n if variable in rateRuleLHSVars:\\n rateArrayVars[index] = variable\\n \\n\\n \\n for variable in rateArrayVars:\\n if i != 0:\\n rateArray += ', '\\n i += 1\\n if variable == 0:\\n rateArray += '0'\\n else:\\n rateArray += 'self.Rate' + variable + '()'\\n \\n \\n \\n \\n rateArray += ']'\\n outputFile.write('\\\\t\\\\trateRuleVector = np.array(' + str(rateArray) + ', dtype = np.float64)\\\\n\\\\n') \\n \\n outputFile.write('\\\\t\\\\tstoichiometricMatrix = np.array(' + re.sub('\\\\n,', ',\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t', re.sub('[^[] +', ',' ,str(stoichCoeffMat))) + ', dtype = np.float64)\\\\n\\\\n')\\n outputFile.write('\\\\t\\\\treactionVelocities = np.array([')\\n reactionElements = ''\\n if reactions:\\n for reactionId in reactions:\\n if reactionElements == '':\\n reactionElements += ('self.r[\\\\'' + str(reactionId) + '\\\\']()')\\n else:\\n reactionElements += (', self.r[\\\\'' + str(reactionId) + '\\\\']()')\\n else:\\n reactionElements = '0'\\n outputFile.write(reactionElements + '], dtype = np.float64)\\\\n\\\\n')\\n outputFile.write('\\\\t\\\\trateOfSpeciesChange = stoichiometricMatrix @ reactionVelocities + rateRuleVector\\\\n\\\\n')\\n outputFile.write('\\\\t\\\\treturn rateOfSpeciesChange\\\\n\\\\n')\\n \\n outputFile.write('\\\\tdef RunSimulation(self, deltaT, absoluteTolerance = 1e-12, relativeTolerance = 1e-6):\\\\n\\\\n')\\n \\n outputFile.write('\\\\t\\\\tfinalTime = self.time + deltaT\\\\n')\\n outputFile.write('\\\\t\\\\ty0 = np.array([' + yArray + '], dtype = np.float64)\\\\n')\\n outputFile.write('\\\\t\\\\t' + yArray + ' = odeint(self._SolveReactions, y0, [self.time, finalTime], atol = absoluteTolerance, rtol = relativeTolerance, mxstep=5000000)[-1]\\\\n')\\n outputFile.write('\\\\t\\\\tself.time = finalTime\\\\n')\\n outputFile.write('\\\\t\\\\tself.AssignmentRules()\\\\n')\\n# outputFile.write('\\\\t\\\\t[self.s[speciesId].UpdateCompartmentSizeMember() for speciesId in self.s]\\\\n')\\n outputFile.write('\\\\n')\\n \\n for key in reactions.keys():\\n outputFile.write('class ' + key + ':\\\\n\\\\n')\\n outputFile.write('\\\\tdef __init__(self, parent, metadata = None):\\\\n\\\\n')\\n outputFile.write('\\\\t\\\\tself.parent = parent\\\\n')\\n outputFile.write('\\\\t\\\\tself.p = {}\\\\n')\\n outputFile.write('\\\\t\\\\tself.metadata = metadata\\\\n\\\\n')\\n for param in reactions[key].rxnParameters:\\n outputFile.write(\\\"\\\\t\\\\tself.p[\\\\'\\\" + param[0] + \\\"\\\\'] = Parameter(\\\" + str(param[1]) + \\\", '\\\" + param[0] + \\\"')\\\\n\\\")\\n #\\\"\\\\t\\\\tself.p[\\\\'\\\" + paramId + \\\"\\\\'] = Parameter(\\\" + str(parameters[paramId].value)+ \\\", \\\"+ paramId + \\\", \\\" + str(parameters[paramId].isConstant) +\\\")\\\\n\\\"\\n \\n outputFile.write('\\\\n\\\\tdef __call__(self):\\\\n')\\n# print(key)\\n# print(reactions[key].rxnParameters)\\n rxnParamNames = [param[0] for param in reactions[key].rxnParameters]\\n rateLaw = ParseRHS(reactions[key].rateLaw, rxnParamNames, \\\"self.parent\\\")\\n outputFile.write('\\\\t\\\\treturn ' + rateLaw + '\\\\n\\\\n')\\n\\n \\n for key in functions.keys():\\n outputFile.write('class ' + key + ':\\\\n\\\\n')\\n outputFile.write('\\\\tdef __init__(self, parent, metadata = None):\\\\n\\\\n')\\n outputFile.write('\\\\t\\\\tself.parent = parent\\\\n')\\n outputFile.write('\\\\t\\\\tself.metadata = metadata\\\\n\\\\n')\\n\\n arguments = functions[key].arguments\\n argumentString = \\\"\\\"\\n for i in range(len(arguments)):\\n argumentString += arguments[i]\\n if i != len(arguments) - 1:\\n argumentString += \\\", \\\"\\n \\n outputFile.write('\\\\tdef __call__(self, ' + argumentString + '):\\\\n')\\n outputFile.write(\\\"\\\\t\\\\treturn \\\" + functions[key].mathString.replace(\\\"^\\\", \\\"**\\\") + \\\"\\\\n\\\\n\\\")\\n\\n outputFile.close()\",\n \"def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\\n # Load the raw CIFAR-10 data\\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\n\\n # subsample the data\\n mask = range(num_training, num_training + num_validation)\\n X_val = X_train[mask]\\n y_val = y_train[mask]\\n mask = range(num_training)\\n X_train = X_train[mask]\\n y_train = y_train[mask]\\n mask = range(num_test)\\n X_test = X_test[mask]\\n y_test = y_test[mask]\\n mask = np.random.choice(num_training, num_dev, replace=False)\\n X_dev = X_train[mask]\\n y_dev = y_train[mask]\\n\\n # Preprocessing: reshape the image data into rows\\n X_train = np.reshape(X_train, (X_train.shape[0], -1))\\n X_val = np.reshape(X_val, (X_val.shape[0], -1))\\n X_test = np.reshape(X_test, (X_test.shape[0], -1))\\n X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\\n\\n # Normalize the data: subtract the mean image\\n mean_image = np.mean(X_train, axis=0)\\n X_train -= mean_image\\n X_val -= mean_image\\n X_test -= mean_image\\n X_dev -= mean_image\\n\\n # add bias dimension and transform into columns\\n X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\\n X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\\n X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\\n X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\\n\\n return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\",\n \"def __init__(self, model=None):\\n self.model = model\\n self.model_f = None\\n self.model_h = None\\n self.cav = None\\n self.sensitivity = None\\n self.tcav_score = []\\n self.y_labels = None\",\n \"def load_cifar10_data(img_rows=48,\\n\\timg_cols=48):\\n\\n\\t(X_train, Y_train), (X_valid, Y_valid) = cifar10.load_data()\\n\\n\\tX_train = np.array([cv2.resize(img, (img_rows,img_cols)) for img in X_train[:,:,:,:]])\\n\\tX_valid = np.array([cv2.resize(img, (img_rows,img_cols)) for img in X_valid[:,:,:,:]])\\n\\n\\tY_train = to_categorical(Y_train[:], num_classes)\\n\\tY_valid = to_categorical(Y_valid[:], num_classes)\\n\\n\\treturn X_train, Y_train, X_valid, Y_valid\",\n \"def _construct_model(self):\\n self.model = AutoEncoderConvolutional(self.n_latent_features, self.reduced_size)\\n self.model = self.model.to(self.device, non_blocking=True)\",\n \"def build(self, hp):\\n\\n model = Sequential()\\n model.add(Conv2D(filters=hp.Choice('num_filters_0', values=[8, 16, 32, 64]),\\n kernel_size=hp.Choice('kernel_size_0', values=[3, 4, 5]),\\n activation=hp.Choice('activation_0', values=['relu', 'tanh']),\\n input_shape=self.input_shape))\\n\\n for i in range(hp.Int('num_layers', 1, 3)):\\n model.add(Conv2D(filters=hp.Choice('num_filters_%d' % (i + 1), values=[8, 16, 32, 64]),\\n kernel_size=hp.Choice('kernel_size_%d' % (i + 1), values=[3, 4, 5]),\\n activation=hp.Choice('activation_%d' % (i + 1), values=['relu', 'tanh'])))\\n model.add(Flatten())\\n model.add(Dense(N_zern))\\n model.summary()\\n\\n model.compile(optimizer=keras.optimizers.Adam(hp.Choice('learning_rate', values=[1e-3, 5e-4, 1e-4])),\\n loss='mean_squared_error')\\n return model\",\n \"def __init__(self, input_dim, embed_dim, conv_layers, num_labels, batch_size, m=14):\\n super(CRF, self).__init__()\\n \\n # crf param\\n self.input_dim = input_dim\\n self.embed_dim = embed_dim\\n self.num_labels = num_labels\\n self.batch_size = batch_size\\n self.use_cuda = torch.cuda.is_available()\\n self.m = m\\n \\n # conv layer params\\n self.out_channels = 1 # output channel of conv layer\\n self.conv_layers = conv_layers\\n self.stride = (1,1)\\n self.padding = True\\n self.cout_shape = self.get_cout_dim() # output shape of conv layer\\n self.cout_numel = self.cout_shape[0]*self.cout_shape[1]\\n \\n \\n \\n self.init_params()\\n\\n ### Use GPU if available\\n if self.use_cuda:\\n [m.cuda() for m in self.modules()]\",\n \"def raw_model():\\n model = cobra.Model(id_or_model=\\\"raw_model\\\", name=\\\"raw_model\\\")\\n rxn_1 = cobra.Reaction(\\\"BIOMASS_TEST\\\")\\n rxn_2 = cobra.Reaction(\\\"RXN2\\\")\\n rxn_3 = cobra.Reaction(\\\"RXN3\\\")\\n rxn_4 = cobra.Reaction(\\\"RXN4\\\")\\n model.add_reactions([rxn_1, rxn_2, rxn_3, rxn_4])\\n model.objective = rxn_3\\n return model\",\n \"def doParametersOfInterest(self):\\n \\n self.modelBuilder.doVar('expr::cosW(\\\"0.87681811112\\\",)')\\n self.modelBuilder.doVar('expr::sinW(\\\"0.48082221247\\\",)')\\n self.modelBuilder.doVar('expr::mZ(\\\"91.2\\\",)')\\n self.modelBuilder.doVar('expr::Lambda1(\\\"100.0\\\",)')\\n self.modelBuilder.doVar('expr::e2(\\\"0.0917\\\",)')\\n self.modelBuilder.doVar('expr::gs2(\\\"1.533\\\",)')\\n\\n # EFT Higgs basis couplings\\n\\n self.modelBuilder.doVar('cZ[0,-1,1]') \\n self.modelBuilder.doVar(\\\"cZZ[0,-2,2]\\\") \\n self.modelBuilder.doVar(\\\"cZZt[0,-2,2]\\\") \\n self.modelBuilder.doVar(\\\"cZB[0,-6,6]\\\") \\n\\n poi='cZ,cZZ,cZZt,cZB'\\n\\n # Amplitude couplings from EFT couplings \\n\\n self.modelBuilder.doVar('expr::a1(\\\"@0+1\\\",cZ)') # (\\\"2*(@0+1)\\\",cZ) in AN/Paper but a1 = 1 for signal model and width calculation\\n self.modelBuilder.doVar('expr::a2(\\\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\\\",cZZ,e2,sinW,cosW)')\\n self.modelBuilder.doVar('expr::a3(\\\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\\\",cZZt,e2,sinW,cosW)')\\n self.modelBuilder.doVar('expr::k1(\\\"@0*(@1*pow(@2,2)/(pow(@3,2)*pow(@4,2)))\\\",cZB,e2,Lambda1,sinW,mZ)')\\n self.modelBuilder.doVar('expr::k1L1(\\\"@0/pow(@1,2)\\\",k1,Lambda1)')\\n\\n ###### gamma_H ########\\n\\n # SMEFT relationships for VV couplings (Expressed using amplitude couplings)\\n\\n self.modelBuilder.doVar('expr::kappa(\\\"1.0\\\",)')\\n self.modelBuilder.doVar('expr::kappa_tilde(\\\"0.0\\\",)') \\n\\n self.modelBuilder.doVar('expr::a1_WW(\\\"@0\\\",a1)')\\n self.modelBuilder.doVar('expr::a2_WW(\\\"@0*@0*@1\\\",cosW,a2)')\\n self.modelBuilder.doVar('expr::a3_WW(\\\"@0*@0*@1\\\",cosW,a3)')\\n self.modelBuilder.doVar('expr::k1_WW(\\\"(@2 / (@0*@0 - @1*@1) - 2*@1*@1*@3*@4*@4 /(@5*@5*(@0*@0 - @1*@1)))\\\",cosW,sinW,k1,a2,Lambda1,mZ)')\\n self.modelBuilder.doVar('expr::k2_k1(\\\"2*@0*@1*@2/(@0*@0 - @1*@1)\\\",cosW,sinW,k1)')\\n self.modelBuilder.doVar('expr::k2_a2(\\\"-2*@0*@1*@3*@4*@4/((@2*@2)*(@0*@0 - @1*@1))\\\",cosW,sinW,mZ,a2,Lambda1)')\\n self.modelBuilder.doVar('expr::k2(\\\"@0 + @1\\\",k2_k1,k2_a2)')\\n\\n # Determine gamma_H from VV couplings\\n\\n zz_expr = '\\\"4*(@0*@0/4. + 0.1695*@3*@3 + 0.09076*@1*@1 + 0.03809*@2*@2 + 0.8095*@0*@3/2. + 0.5046*@0*@1/2. + 0.2092*@1*@3 + 0.1023*@4*@4 + 0.1901*@0*@4/2. + 0.07429*@3*@4 + 0.04710*@1*@4) \\\",a1,a2,a3,k1,k2'\\n ww_expr = '\\\"4*(@0*@0/4. + 0.1320*@3*@3 + 0.1944*@1*@1 + 0.08075*@2*@2 + 0.7204*@0*@3/2. + 0.7437*@0*@1/2. + 0.2774*@3*@1) \\\",a1_WW,a2_WW,a3_WW,k1_WW'\\n zgamma_expr = '\\\"4*(1.118600*@0*@0/4. +0.0035*@1*@1 - 0.125010*@0*@1/2. + 0.000003*@1*@1 - 0.00018*@1*@1 + 0.003100*@0*@1/2. +0.00126*@2*@2 + 0.000005*@2*@2 -0.00047*@2*@2)\\\",a1_WW,kappa,kappa_tilde'\\n gg_expr = '\\\"(1.1068*@0*@0 + 0.0082*@0*@0 - 0.1150*@0*@0 + 2.5717*@1*@1 + 0.0091*@1*@1 - 0.1982*@1*@1)\\\",kappa,kappa_tilde'\\n bb_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n cc_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n tautau_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n mumu_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n gmgm_expr = '\\\"4*(1.6054*@0*@0/4. + 0.07312*@1*@1 - 0.6854*@0*@1/2. + 0.00002*@1*@1 - 0.0018*@1*@1 + 0.0085*@0*@1/2. + 0.1699*@2*@2 + 0.00002*@2*@2 - 0.0031*@2*@2)\\\",a1_WW,kappa,kappa_tilde'\\n \\n self.modelBuilder.doVar('expr::R_WW('+str(ww_expr)+')')\\n self.modelBuilder.doVar('expr::R_ZZ('+str(zz_expr)+')')\\n self.modelBuilder.doVar('expr::R_Zgamma('+str(zgamma_expr)+')')\\n self.modelBuilder.doVar('expr::R_gg('+str(gg_expr)+')')\\n self.modelBuilder.doVar('expr::R_bb('+str(bb_expr)+')')\\n self.modelBuilder.doVar('expr::R_cc('+str(cc_expr)+')')\\n self.modelBuilder.doVar('expr::R_tautau('+str(tautau_expr)+')')\\n self.modelBuilder.doVar('expr::R_mumu('+str(mumu_expr)+')')\\n self.modelBuilder.doVar('expr:R_gammagamma('+str(gmgm_expr)+')')\\n\\n self.modelBuilder.doVar('expr::gammaH(\\\"(0.5824*@0 + 0.2137*@1 + 0.08187*@2 + 0.06272*@3 + 0.02891*@4 + 0.02619*@5 + 0.002270*@6 + 0.001533*@7 + 0.0002176*@8 )/0.9998\\\",R_bb,R_WW,R_gg,R_tautau,R_cc,R_ZZ,R_gammagamma,R_Zgamma,R_mumu)') \\n\\n ###########################\\n\\n self.g1V = GetCoupTerms(1,1,1,-0.0001,\\\"1V\\\") # Compensate for scaling of k1 templates \\n self.g2V = GetCoupTerms(1,1,1,-0.0001,\\\"2V\\\") \\n \\n self.modelBuilder.doVar(\\\"expr::g2V_1(\\\\\\\"\\\"+str(self.g2V[0])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T1(\\\\\\\"((pow(@0,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T1_Neg(\\\\\\\"-1*((pow(@0,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_2(\\\\\\\"\\\"+str(self.g2V[1])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T2(\\\\\\\"((pow(@0,3)*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T2_Neg(\\\\\\\"-1*((pow(@0,3)*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_3(\\\\\\\"\\\"+str(self.g2V[2])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T3(\\\\\\\"((pow(@0,2)*pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T3_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_4(\\\\\\\"\\\"+str(self.g2V[3])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T4(\\\\\\\"((@0*pow(@1,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T4_Neg(\\\\\\\"-1*((@0*pow(@1,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_5(\\\\\\\"\\\"+str(self.g2V[4])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T5(\\\\\\\"((pow(@1,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T5_Neg(\\\\\\\"-1*((pow(@1,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_6(\\\\\\\"\\\"+str(self.g2V[5])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T6(\\\\\\\"((pow(@0,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T6_Neg(\\\\\\\"-1*((pow(@0,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_7(\\\\\\\"\\\"+str(self.g2V[6])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T7(\\\\\\\"((pow(@0,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T7_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_8(\\\\\\\"\\\"+str(self.g2V[7])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T8(\\\\\\\"((@0*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T8_Neg(\\\\\\\"-1*((@0*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_9(\\\\\\\"\\\"+str(self.g2V[8])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T9(\\\\\\\"((pow(@2,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T9_Neg(\\\\\\\"-1*((pow(@2,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_10(\\\\\\\"\\\"+str(self.g2V[9])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T10(\\\\\\\"((pow(@0,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T10_Neg(\\\\\\\"-1*((pow(@0,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_11(\\\\\\\"\\\"+str(self.g2V[10])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T11(\\\\\\\"((pow(@0,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T11_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_12(\\\\\\\"\\\"+str(self.g2V[11])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T12(\\\\\\\"((@0*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T12_Neg(\\\\\\\"-1*((@0*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_13(\\\\\\\"\\\"+str(self.g2V[12])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T13(\\\\\\\"((pow(@3,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T13_Neg(\\\\\\\"-1*((pow(@3,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_14(\\\\\\\"\\\"+str(self.g2V[13])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T14(\\\\\\\"((pow(@1,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T14_Neg(\\\\\\\"-1*((pow(@1,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_15(\\\\\\\"\\\"+str(self.g2V[14])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T15(\\\\\\\"((pow(@1,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T15_Neg(\\\\\\\"-1*((pow(@1,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_16(\\\\\\\"\\\"+str(self.g2V[15])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T16(\\\\\\\"((@1*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T16_Neg(\\\\\\\"-1*((@1*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_17(\\\\\\\"\\\"+str(self.g2V[16])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T17(\\\\\\\"((pow(@1,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T17_Neg(\\\\\\\"-1*((pow(@1,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_18(\\\\\\\"\\\"+str(self.g2V[17])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T18(\\\\\\\"((pow(@1,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T18_Neg(\\\\\\\"-1*((pow(@1,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_19(\\\\\\\"\\\"+str(self.g2V[18])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T19(\\\\\\\"((@1*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T19_Neg(\\\\\\\"-1*((@1*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_20(\\\\\\\"\\\"+str(self.g2V[19])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T20(\\\\\\\"((pow(@2,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T20_Neg(\\\\\\\"-1*((pow(@2,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_21(\\\\\\\"\\\"+str(self.g2V[20])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T21(\\\\\\\"((pow(@2,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T21_Neg(\\\\\\\"-1*((pow(@2,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_22(\\\\\\\"\\\"+str(self.g2V[21])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T22(\\\\\\\"((@2*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T22_Neg(\\\\\\\"-1*((@2*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_23(\\\\\\\"\\\"+str(self.g2V[22])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T23(\\\\\\\"((@0*@1*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T23_Neg(\\\\\\\"-1*((@0*@1*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_24(\\\\\\\"\\\"+str(self.g2V[23])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T24(\\\\\\\"((@0*pow(@1,2)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T24_Neg(\\\\\\\"-1*((@0*pow(@1,2)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_25(\\\\\\\"\\\"+str(self.g2V[24])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T25(\\\\\\\"((pow(@0,2)*@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T25_Neg(\\\\\\\"-1*((pow(@0,2)*@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_26(\\\\\\\"\\\"+str(self.g2V[25])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T26(\\\\\\\"((@0*@1*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T26_Neg(\\\\\\\"-1*((@0*@1*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_27(\\\\\\\"\\\"+str(self.g2V[26])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T27(\\\\\\\"((@0*pow(@1,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T27_Neg(\\\\\\\"-1*((@0*pow(@1,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_28(\\\\\\\"\\\"+str(self.g2V[27])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T28(\\\\\\\"((pow(@0,2)*@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T28_Neg(\\\\\\\"-1*((pow(@0,2)*@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_29(\\\\\\\"\\\"+str(self.g2V[28])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T29(\\\\\\\"((@0*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T29_Neg(\\\\\\\"-1*((@0*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_30(\\\\\\\"\\\"+str(self.g2V[29])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T30(\\\\\\\"((@0*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T30_Neg(\\\\\\\"-1*((@0*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_31(\\\\\\\"\\\"+str(self.g2V[30])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T31(\\\\\\\"((pow(@0,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T31_Neg(\\\\\\\"-1*((pow(@0,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_32(\\\\\\\"\\\"+str(self.g2V[31])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T32(\\\\\\\"((@1*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T32_Neg(\\\\\\\"-1*((@1*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_33(\\\\\\\"\\\"+str(self.g2V[32])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T33(\\\\\\\"((@1*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T33_Neg(\\\\\\\"-1*((@1*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_34(\\\\\\\"\\\"+str(self.g2V[33])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T34(\\\\\\\"((pow(@1,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T34_Neg(\\\\\\\"-1*((pow(@1,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_35(\\\\\\\"\\\"+str(self.g2V[34])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T35(\\\\\\\"((@0*@1*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T35_Neg(\\\\\\\"-1*((@0*@1*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\\\") \\n \\n self.modelBuilder.doVar(\\\"expr::g1V_1(\\\\\\\"\\\"+str(self.g1V[0])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T1(\\\\\\\"((pow(@0,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T1_Neg(\\\\\\\"-1*((pow(@0,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_2(\\\\\\\"\\\"+str(self.g1V[1])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T2(\\\\\\\"((@0*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T2_Neg(\\\\\\\"-1*((@0*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_3(\\\\\\\"\\\"+str(self.g1V[2])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T3(\\\\\\\"((pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T3_Neg(\\\\\\\"-1*((pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_4(\\\\\\\"\\\"+str(self.g1V[3])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T4(\\\\\\\"((@0*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T4_Neg(\\\\\\\"-1*((@0*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_5(\\\\\\\"\\\"+str(self.g1V[4])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T5(\\\\\\\"((pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T5_Neg(\\\\\\\"-1*((pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_6(\\\\\\\"\\\"+str(self.g1V[5])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T6(\\\\\\\"((@0*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T6_Neg(\\\\\\\"-1*((@0*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_7(\\\\\\\"\\\"+str(self.g1V[6])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T7(\\\\\\\"((pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T7_Neg(\\\\\\\"-1*((pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_8(\\\\\\\"\\\"+str(self.g1V[7])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T8(\\\\\\\"((@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T8_Neg(\\\\\\\"-1*((@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_9(\\\\\\\"\\\"+str(self.g1V[8])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T9(\\\\\\\"((@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T9_Neg(\\\\\\\"-1*((@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_10(\\\\\\\"\\\"+str(self.g1V[9])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T10(\\\\\\\"((@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T10_Neg(\\\\\\\"-1*((@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\\\") \\n \\n self.modelBuilder.doSet(\\\"POI\\\",poi)\",\n \"def __init__(self):\\n self.name = \\\"Osyczka\\\"\\n objectives = [ob_os_1, ob_os_2]\\n constraints = [con_os_1, con_os_2, con_os_3, con_os_4, con_os_5, con_os_6]\\n decisions = [Decision(0, 10), Decision(0, 10), Decision(1, 5), Decision(0, 6), Decision(1, 5), Decision(0, 10)]\\n Model.__init__(self, objectives, constraints, decisions)\",\n \"def loadData(self):\\n # Load the raw CIFAR-10 data\\n num_training = 49000\\n num_validation = 1000\\n num_test = 1000\\n subtract_mean = True\\n\\n cifar10_dir = '/home/parallels/PycharmProjects/Courses/232A/project2/stats232a/datasets/cifar-10-batches-py'\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\n\\n # Subsample the data\\n mask = list(range(num_training, num_training + num_validation))\\n X_val = X_train[mask]\\n y_val = y_train[mask]\\n mask = list(range(num_training))\\n X_train = X_train[mask]\\n y_train = y_train[mask]\\n mask = list(range(num_test))\\n X_test = X_test[mask]\\n y_test = y_test[mask]\\n\\n # Normalize the data: subtract the mean image\\n if subtract_mean:\\n mean_image = np.mean(X_train, axis=0)\\n X_train -= mean_image\\n X_val -= mean_image\\n X_test -= mean_image\\n\\n # Transpose so that channels come first\\n X_train = X_train.transpose(0, 3, 1, 2)\\n X_val = X_val.transpose(0, 3, 1, 2)\\n X_test = X_test.transpose(0, 3, 1, 2)\\n\\n # Package data into a dictionary\\n self.data = {\\n 'X_train': X_train, 'y_train': y_train,\\n 'X_val': X_val, 'y_val': y_val,\\n 'X_test': X_test, 'y_test': y_test,\\n }\",\n \"def __init__(self,model,device):\\n self.model = model\\n self.device = device\",\n \"def create_model(data, cont, cat, target): \\n\\n cont_features = '+'.join(cont)\\n\\n cat_features = '+'.join([f'C({x})' for x in cat])\\n\\n f = f'{target}~+{cont_features}+{cat_features}'\\n\\n print(f)\\n\\n model = smf.ols(formula=f, data=data).fit()\\n \\n diagnose_model(model)\\n \\n return model\",\n \"def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\\n # Load the raw CIFAR-10 data\\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\n \\n # Subsample the data\\n mask = range(num_training, num_training + num_validation)\\n X_val = X_train[mask]\\n y_val = y_train[mask]\\n mask = range(num_training)\\n X_train = X_train[mask]\\n y_train = y_train[mask]\\n mask = range(num_test)\\n X_test = X_test[mask]\\n y_test = y_test[mask]\\n\\n # Normalize the data: subtract the mean image\\n mean_image = np.mean(X_train, axis=0)\\n X_train -= mean_image\\n X_val -= mean_image\\n X_test -= mean_image\\n\\n # Reshape data to rows\\n X_train = X_train.reshape(num_training, -1)\\n X_val = X_val.reshape(num_validation, -1)\\n X_test = X_test.reshape(num_test, -1)\\n\\n pca = decomposition.PCA(n_components=None, whiten=False)\\n X_train = pca.fit_transform(X_train)\\n X_val = pca.transform(X_val)\\n X_test = pca.transform(X_test)\\n\\n return X_train, y_train, X_val, y_val, X_test, y_test\",\n \"def __init__(self, input_dim, conv_layers, num_labels, batch_size):\\n super(CRF, self).__init__()\\n\\n self.input_dim = input_dim\\n self.crf_input_dim = None # Calculated inside init_params() based on Conv layer I/O dims\\n self.conv_layers = conv_layers\\n self.num_labels = num_labels\\n self.batch_size = batch_size\\n\\t\\t#Uncomment below and remove self.use_cuda=False once all tensors are set to run on cuda\\n #self.use_cuda = torch.cuda.is_available()\\n self.use_cuda=False\\n self.conv_objects = torch.nn.ModuleList() # Stores multiple Conv objects\\n self.Ks = [] # Stores multiple Conv filters\\n self.W = None # CRF parameter (node potential)\\n self.T = None # CRF parameter (transition weights between node pairs)\\n\\n ### Use GPU if available\\n if self.use_cuda:\\n [m.cuda() for m in self.modules()]\",\n \"def model(self) -> CameraModel:\\n pass\",\n \"def construct_model():\\n # model = Sequential()\\n # model.add(Dense(units=64, activation='relu', input_dim=100))\\n # model.add(Dense(units=10, activation='softmax'))\\n # model.compile(loss='categorical_crossentropy',\\n # optimizer='sgd',\\n # metrics=['accuracy'])\\n # return model\\n\\n model = Sequential()\\n # Input Layer\\n model.add(Conv2D(64, 3, data_format='channels_last', activation='relu', padding='same',\\n input_shape=(img_width, img_height, 3)))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n # Hidden Layer 1\\n model.add(Conv2D(64, 3, activation='relu', padding='same'))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n # Hidden Layer 2\\n model.add(Conv2D(128, 3, activation='relu', padding='same'))\\n model.add(Conv2D(128, 3, activation='relu', padding='same', strides=2))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n # Hidden Layer 3\\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\\n model.add(Conv2D(256, 3, activation='relu', padding='same', strides=2))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n\\n # Fully Connected Layer\\n model.add(Flatten())\\n # 512 Neuron Layer\\n model.add(Dense(512, activation='relu'))\\n model.add(Dropout(0.5))\\n # Output Layer\\n model.add(Dense(num_of_classes))\\n model.add(Activation('softmax'))\\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n return model\",\n \"def genModel():\\n inp = (160, 320, 3) # initial image size\\n oup1 = (160, 320, 1) # gray image size\\n oup2 = (80, 320, 1) # cropped image size\\n\\n model = Sequential()\\n model.add(Lambda(color2gray, input_shape = inp, output_shape= oup1))\\n # crop top 50 pixels, bottom 30 pixels, left/right 0 pixels\\n model.add(Cropping2D(cropping=((50,30), (0,0))))\\n # Preprocess incoming data, centered around zero with small standard deviation \\n model.add(Lambda(lambda x: x/127.5 - 1., output_shape= oup2))\\n model.add(Convolution2D(24,5,5,subsample=(1,2), activation=\\\"relu\\\"))\\n model.add(Convolution2D(36,5,5,subsample=(2,2), activation=\\\"relu\\\"))\\n model.add(Convolution2D(48,5,5,subsample=(2,2), activation=\\\"relu\\\"))\\n model.add(Convolution2D(64,3,3, activation=\\\"relu\\\"))\\n model.add(Convolution2D(64,3,3, activation=\\\"relu\\\"))\\n model.add(Flatten())\\n model.add(Dropout(0.3))\\n model.add(Dense(180, activation=\\\"relu\\\"))\\n model.add(Dense(60))\\n model.add(Dense(10, activation=\\\"relu\\\"))\\n model.add(Dense(1))\\n # print layer size for each model layers\\n for layer in model.layers:\\n print(layer.get_output_at(0).get_shape().as_list())\\n return model\",\n \"def __train__(self):\\n if (self.type_camf == 'CAMF_CI'):\\n #users, items, context, ratings\\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = ci.fit()\\n elif (self.type_camf == 'CAMF_CU'):\\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = cu.fit()\\n elif (self.type_camf == 'CAMF_C'):\\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = c.fit()\\n\\n dummy_pred = np.zeros((predictions.shape))\\n for r, pred_array in enumerate(predictions):\\n for c, pred in enumerate(pred_array):\\n dummy_pred[r][c] = self.__check_ratings__(pred)\\n predictions = dummy_pred\\n #save a plot with a loss function\\n plots = prs.PlotRSData()\\n #print(losses)\\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\\\"_loop\\\"+str(self.loop))\\n pd.DataFrame(losses).to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ +\\\"losses_loop\\\"+str(self.loop)+\\\".csv\\\")\\n print('Saving the feature matrix...')\\n # set predictions back to the pivot table\\n self.__utility_saved_training__(predictions) \\n # save results\\n self.utility_predictions.to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ + \\\"_SGD_predictions_loop\\\"+str(self.loop)+\\\".csv\\\")\",\n \"def get_classification(self, image):\\n # return TrafficLight.RED\\n # TODO implement light color prediction\\n # creating an image object \\n img_np = np.array(image) \\n\\n # convert np array to tensor\\n input_tensor = tf.convert_to_tensor(img_np)\\n\\n # The model expects a batch of images, so add an axis with `tf.newaxis`.\\n input_tensor = input_tensor[tf.newaxis, ...]\\n\\n\\n detections = self.loaded(input_tensor)\\n\\n num_detections = int(detections.pop('num_detections'))\\n\\n # detection_classes should be ints.\\n detections_dict = {key: value[0, :num_detections].numpy() for key, value in detections.items()}\\n\\n\\n # detection_classes should be ints.\\n detections_dict['detection_classes'] = detections_dict['detection_classes'].astype(np.int64)\\n\\n label_id_offset = 1\\n\\n # DEBUG - can do it in a cleaner way :0\\n tl_classes = {3: 'green', 2: 'red'}\\n top_classes_prediction = list(detections_dict['detection_classes']+label_id_offset)[:5] \\n #print(top_classes_prediction)\\n for i in range(len(top_classes_prediction)):\\n if top_classes_prediction[i] == 2:\\n top_classes_prediction[i] = 'green'\\n elif top_classes_prediction[i] == 3:\\n top_classes_prediction[i] = 'red'\\n\\n\\n #print(\\\"--------->\\\", image_path, \\\"<-----------\\\")\\n #print( top_classes_prediction ) \\n #print(detections_dict['detection_scores'][:5], '\\\\n' )\\n\\n # basic red tl logic\\n if top_classes_prediction[0] == 'red' and detections_dict['detection_scores'][0] >= 0.60:\\n #print(\\\"-------------> RED TRAFFIC LIGHT <----------------\\\\n\\\")\\n self.current_light = TrafficLight.RED\\n #rospy.logwarn( \\\"----------------- Taffic light is RED !!! -------------------- \\\" )\\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\\n else:\\n #print(\\\"No red traffic is detected\\\\n\\\")\\n self.current_light = TrafficLight.GREEN\\n #rospy.logwarn( \\\"----------------- You're good to go !!! --------: {0} - {1} \\\".format(top_classes_prediction[0], detections_dict['detection_scores'][0]) )\\n self.display_predictions_scores( top_classes_prediction, detections_dict['detection_scores'] )\\n\\n return self.current_light\",\n \"def __init__(self,model,alpha=0,head_min=0,head_max=1,k=1,\\r\\n variables=[],priors=[]):\\r\\n \\r\\n import numpy as np\\r\\n \\r\\n # Append the base to the elementlist\\r\\n self.model = model\\r\\n model.elementlist.append(self)\\r\\n \\r\\n # Set orientation value\\r\\n self.alpha = alpha\\r\\n \\r\\n # Set potential scaling variables\\r\\n self.head_min = head_min\\r\\n self.head_max = head_max\\r\\n \\r\\n # Assign the hydraulic conductivity of the base model\\r\\n self.k = k\\r\\n \\r\\n # The model requires the base flow in terms of hydraulic potential (phi)\\r\\n # The function head_to_potential extracts the following variables:\\r\\n # phi_min hydraulic potential corresponding to head_min\\r\\n # phi_max hydraulic potential corresponding to head_max\\r\\n self.head_to_potential()\\r\\n \\r\\n # Check input for validity\\r\\n self.check_input()\\r\\n \\r\\n self.variables = variables\\r\\n self.priors = priors\\r\\n \\r\\n if len(self.variables) > 0:\\r\\n # There are some model variables specified\\r\\n for idx,var in enumerate(self.variables):\\r\\n self.model.num_params += 1\\r\\n exec(\\\"self.model.params += [self.%s]\\\" % var)\\r\\n self.model.variables += [var]\\r\\n self.model.priors += [self.priors[idx]]\\r\\n if 'name' in list(self.priors[idx].keys()):\\r\\n self.model.param_names += [self.priors[idx]['name']] \\r\\n else: \\r\\n self.model.param_names += ['unknown']\",\n \"def get_model_data(self):\\n sen_info=self._get_sensor_info()\\n cam_info=lib.is_GetCameraInfo(self.hcam)\\n dll_ver=lib.is_GetDLLVersion()\\n dll_ver=\\\"{}.{}.{}\\\".format((dll_ver>>24),(dll_ver>>16)&0xFF,dll_ver&0xFFFF)\\n return self.ModelData(py3.as_str(sen_info.strSensorName),py3.as_str(cam_info.ID),py3.as_str(cam_info.SerNo),py3.as_str(cam_info.Version),\\n py3.as_str(cam_info.Date),dll_ver,cam_info.Type)\",\n \"def bestModel(self, channel_type):\",\n \"def get_model(summary=False):\\n\\timage_input=Input(shape=(220,220,5),name='image_input')\\n\\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\\n\\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\\t\\n\\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\\n\\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\\n\\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\\t\\n\\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\\n\\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\\n\\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\\t\\n\\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\\n\\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\\n\\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\\t\\n\\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\\n\\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\\n\\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\\t\\n\\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\\n\\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\\n\\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\\t\\n\\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\\n\\tbranch1_flat=Flatten()(branch6_pool1)\\n\\tdrop=Dropout(.3)(branch1_flat)\\n\\t# FC layers group\\n\\tdense1=Dense(512, activation='relu', name='fc1')(drop)\\n\\tdrop1=Dropout(.3)(dense1)\\n\\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\\n\\tdrop3=Dropout(.3)(dense2)\\n\\tout=Dense(2, activation='softmax', name='fc4')(drop3)\\n\\tmodel=Model(inputs=image_input,outputs=out)\\n\\treturn model\",\n \"def build(self):\\n input_shape_img = (None, None, 3)\\n img_input = Input(shape=input_shape_img)\\n roi_input = Input(shape=(None, 4))\\n shared_layers = self.cnn_model.nn_base(img_input, trainable=True)\\n num_anchors = len(self.C.anchor_scales) * len(self.C.anchor_ratios)\\n \\n output_region_proposal = self.region_proposal_net(shared_layers, num_anchors)\\n output_classifier = self.classifier(shared_layers,\\n self.cnn_model.classifier_layers, \\n roi_input, self.C.num_roi, \\n num_class=len(self.class_count), trainable=True)\\n \\n self.model_region_proposal = Model(img_input, output_region_proposal[:2])\\n self.model_classifier = Model([img_input, roi_input], output_classifier)\\n self.model_all = Model([img_input, roi_input], output_region_proposal[:2] + output_classifier)\\n\\n optimizer = Adam(lr=1e-5)\\n self.model_region_proposal.compile(optimizer=optimizer, \\n loss=[losses.rpn_loss_cls(num_anchors), \\n losses.rpn_loss_regr(num_anchors)])\\n self.model_classifier.compile(optimizer=optimizer, \\n loss=[losses.class_loss_cls, \\n losses.class_loss_regr(len(self.class_count)-1)], \\n metrics={'dense_class_{}'.format(len(self.class_count)): 'accuracy'})\\n self.model_all.compile(optimizer='sgd', loss='mae')\\n\\n # print(self.model_all.summary())\\n plot_model(self.model_region_proposal, show_shapes=True, to_file='./frcnn/images/region_proposal.png')\\n plot_model(self.model_classifier, show_shapes=True, to_file='./frcnn/images/classifier.png')\\n plot_model(self.model_all, show_shapes=True, to_file='./frcnn/images/model_all.png')\",\n \"def create_cloth_model(self, segment_dict):\\r\\n\\r\\n # List of color histograms\\r\\n model = []\\r\\n\\r\\n # Extract list of frames from dictionary\\r\\n frame_list = segment_dict[c.FRAMES_KEY]\\r\\n\\r\\n all_bboxes_in_frames = c.ALL_CLOTH_BBOXES_IN_FRAMES\\r\\n cl_pct_height = c.CLOTHES_BBOX_HEIGHT\\r\\n cl_pct_width = c.CLOTHES_BBOX_WIDTH\\r\\n hsv_channels = c.CLOTHING_REC_HSV_CHANNELS_NR\\r\\n min_size = c.MIN_CLOTH_MODEL_SIZE\\r\\n neck_pct_height = c.NECK_HEIGHT\\r\\n use_dom_color = c.CLOTHING_REC_USE_DOMINANT_COLOR\\r\\n use_mean_x = c.CLOTHING_REC_USE_MEAN_X_OF_FACES\\r\\n use_3_bboxes = c.CLOTHING_REC_USE_3_BBOXES\\r\\n kernel_size = c.HIST_SMOOTHING_KERNEL_SIZE\\r\\n\\r\\n if self.params is not None:\\r\\n if c.ALL_CLOTH_BBOXES_IN_FRAMES_KEY in self.params:\\r\\n all_bboxes_in_frames = self.params[\\r\\n c.ALL_CLOTH_BBOXES_IN_FRAMES_KEY]\\r\\n if c.CLOTHES_BBOX_HEIGHT_KEY in self.params:\\r\\n cl_pct_height = self.params[c.CLOTHES_BBOX_HEIGHT_KEY]\\r\\n if c.CLOTHES_BBOX_WIDTH_KEY in self.params:\\r\\n cl_pct_width = self.params[c.CLOTHES_BBOX_WIDTH_KEY]\\r\\n if c.CLOTHING_REC_HSV_CHANNELS_NR_KEY in self.params:\\r\\n hsv_channels = self.params[c.CLOTHING_REC_HSV_CHANNELS_NR_KEY]\\r\\n if c.MIN_CLOTH_MODEL_SIZE_KEY in self.params:\\r\\n min_size = self.params[c.MIN_CLOTH_MODEL_SIZE_KEY]\\r\\n if c.NECK_HEIGHT_KEY in self.params:\\r\\n neck_pct_height = self.params[c.NECK_HEIGHT_KEY]\\r\\n if c.CLOTHING_REC_USE_DOMINANT_COLOR_KEY in self.params:\\r\\n use_dom_color = self.params[\\r\\n c.CLOTHING_REC_USE_DOMINANT_COLOR_KEY]\\r\\n if c.CLOTHING_REC_USE_MEAN_X_OF_FACES_KEY in self.params:\\r\\n use_mean_x = self.params[c.CLOTHING_REC_USE_MEAN_X_OF_FACES_KEY]\\r\\n if c.CLOTHING_REC_USE_3_BBOXES_KEY in self.params:\\r\\n use_3_bboxes = self.params[c.CLOTHING_REC_USE_3_BBOXES_KEY]\\r\\n if c.HIST_SMOOTHING_KERNEL_SIZE_KEY in self.params:\\r\\n kernel_size = self.params[c.HIST_SMOOTHING_KERNEL_SIZE_KEY]\\r\\n\\r\\n min_x = sys.maxint\\r\\n max_x = 0\\r\\n mean_x = 0\\r\\n if use_mean_x:\\r\\n\\r\\n # Calculate mean position of face in x axis\\r\\n for frame_dict in frame_list:\\r\\n\\r\\n detected = frame_dict[c.DETECTED_KEY]\\r\\n\\r\\n if detected:\\r\\n\\r\\n face_bbox = frame_dict[c.DETECTION_BBOX_KEY]\\r\\n face_x = face_bbox[0]\\r\\n\\r\\n if face_x < min_x:\\r\\n min_x = face_x\\r\\n\\r\\n if face_x > max_x:\\r\\n max_x = face_x\\r\\n\\r\\n mean_x = int((max_x + min_x) / 2.0)\\r\\n\\r\\n for frame_dict in frame_list:\\r\\n\\r\\n detected = frame_dict[c.DETECTED_KEY]\\r\\n\\r\\n # Consider only detected faces\\r\\n if detected:\\r\\n\\r\\n frame_name = frame_dict[c.SAVED_FRAME_NAME_KEY]\\r\\n\\r\\n frame_path = os.path.join(self.frames_path, frame_name)\\r\\n\\r\\n face_bbox = frame_dict[c.DETECTION_BBOX_KEY]\\r\\n\\r\\n face_x = face_bbox[0]\\r\\n face_y = face_bbox[1]\\r\\n face_width = face_bbox[2]\\r\\n face_height = face_bbox[3]\\r\\n\\r\\n if use_3_bboxes:\\r\\n\\r\\n frame_hists = []\\r\\n\\r\\n im = cv2.imread(frame_path)\\r\\n\\r\\n # Width of whole bounding box\\r\\n clothes_whole_width = (face_width * cl_pct_width)\\r\\n\\r\\n # Width of single cell\\r\\n clothes_width = int(clothes_whole_width / 3.0)\\r\\n clothes_height = int(face_height * cl_pct_height)\\r\\n\\r\\n # Leftmost bounding box for clothes\\r\\n clothes_x0 = int(\\r\\n face_x + face_width / 2.0 - 1.5 * clothes_width)\\r\\n\\r\\n # Bounding box cannot start out of image\\r\\n if clothes_x0 < 0:\\r\\n if all_bboxes_in_frames:\\r\\n return None\\r\\n else:\\r\\n continue\\r\\n\\r\\n clothes_y0 = int(\\r\\n face_y + face_height + (\\r\\n face_height * neck_pct_height))\\r\\n\\r\\n clothes_y1 = clothes_y0 + clothes_height\\r\\n\\r\\n # Clothing bounding box must be\\r\\n # entirely contained by the frame\\r\\n height, width, depth = im.shape\\r\\n\\r\\n if ((clothes_y1 > height) or\\r\\n ((clothes_x0 + clothes_whole_width) > width)):\\r\\n if all_bboxes_in_frames:\\r\\n return None\\r\\n else:\\r\\n continue\\r\\n\\r\\n for i in range(0, 3):\\r\\n\\r\\n if i == 1:\\r\\n # Central bounding box for clothes\\r\\n clothes_x0 += clothes_width\\r\\n\\r\\n elif i == 2:\\r\\n # Rightmost bounding box for clothes\\r\\n clothes_x0 += clothes_width\\r\\n\\r\\n clothes_x1 = clothes_x0 + clothes_width\\r\\n\\r\\n # Get region of interest for clothes\\r\\n\\r\\n roi = im[clothes_y0:clothes_y1, clothes_x0:clothes_x1]\\r\\n\\r\\n roi_hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)\\r\\n\\r\\n hists = []\\r\\n\\r\\n mask = None\\r\\n\\r\\n if use_dom_color:\\r\\n\\r\\n mask = utils.get_dominant_color(\\r\\n roi_hsv, kernel_size)\\r\\n\\r\\n else:\\r\\n\\r\\n mask = cv2.inRange(roi_hsv,\\r\\n np.array((0., 60., 32.)),\\r\\n np.array((180., 255., 255.)))\\r\\n\\r\\n for ch in range(0, hsv_channels):\\r\\n hist = cv2.calcHist(\\r\\n [roi_hsv], [ch], mask, [256], [0, 255])\\r\\n\\r\\n cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)\\r\\n\\r\\n hists.append(hist)\\r\\n\\r\\n frame_hists.append(hists)\\r\\n\\r\\n model.append(frame_hists)\\r\\n\\r\\n del im\\r\\n\\r\\n else:\\r\\n\\r\\n # Get region of interest for clothes\\r\\n clothes_width = int(face_width * cl_pct_width)\\r\\n clothes_height = int(face_height * cl_pct_height)\\r\\n clothes_x0 = int(\\r\\n face_x + face_width / 2.0 - clothes_width / 2.0)\\r\\n\\r\\n if use_mean_x:\\r\\n # Bounding box for clothes\\r\\n # has fixed position in x axis\\r\\n clothes_x0 = int(\\r\\n mean_x + face_width / 2.0 - clothes_width / 2.0)\\r\\n\\r\\n clothes_y0 = int(\\r\\n face_y + face_height + (face_height * neck_pct_height))\\r\\n clothes_x1 = clothes_x0 + clothes_width\\r\\n clothes_y1 = clothes_y0 + clothes_height\\r\\n\\r\\n # Bounding box cannot start out of image\\r\\n if clothes_x0 < 0:\\r\\n if all_bboxes_in_frames:\\r\\n return None\\r\\n else:\\r\\n continue\\r\\n\\r\\n im = cv2.imread(frame_path)\\r\\n\\r\\n # Clothing bounding box must be\\r\\n # entirely contained by the frame\\r\\n height, width, depth = im.shape\\r\\n\\r\\n if (clothes_y1 > height) or (clothes_x1 > width):\\r\\n if all_bboxes_in_frames:\\r\\n return None\\r\\n else:\\r\\n continue\\r\\n\\r\\n roi = im[clothes_y0:clothes_y1, clothes_x0:clothes_x1]\\r\\n\\r\\n roi_hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)\\r\\n\\r\\n hists = []\\r\\n\\r\\n if use_dom_color:\\r\\n\\r\\n mask = utils.get_dominant_color(\\r\\n roi_hsv, kernel_size)\\r\\n\\r\\n else:\\r\\n\\r\\n mask = cv2.inRange(roi_hsv,\\r\\n np.array((0., 60., 32.)),\\r\\n np.array((180., 255., 255.)))\\r\\n\\r\\n for ch in range(0, hsv_channels):\\r\\n hist = cv2.calcHist(\\r\\n [roi_hsv], [ch], mask, [256], [0, 255])\\r\\n\\r\\n cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)\\r\\n\\r\\n hists.append(hist)\\r\\n\\r\\n model.append(hists)\\r\\n\\r\\n del im\\r\\n\\r\\n # Check model size\\r\\n model_size = len(model)\\r\\n\\r\\n if model_size >= min_size:\\r\\n return model\\r\\n else:\\r\\n return None\",\n \"def __init__(self, model, X_lower, X_upper):\\n self.model = model\\n self.X_upper = X_upper\\n self.X_lower = X_lower\",\n \"def mgcNetArch(self, **kwargs):\\n\\n def_vals = {\\\"input_img_rows\\\" : self.input_img_rows,\\n \\\"input_img_cols\\\" : self.input_img_cols,\\n \\\"channels\\\" : self.channels,\\n \\\"nb_classes\\\" : self.nb_classes,\\n \\\"outLayer\\\" : 'gloAvg', \\n \\\"l2_val\\\" : 0.00, \\n \\\"net_architr\\\" : 'cnn_max', \\n \\\"block_typex\\\" : 'basic', \\n \\\"block_repeatx\\\" : [1, 1]\\n }\\n\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n _input_img_rows = kwargs['input_img_rows']\\n _input_img_cols = kwargs['input_img_cols']\\n _channels = kwargs['channels']\\n _nb_classes = kwargs['nb_classes']\\n _outLayer = kwargs['outLayer']\\n _l2_val = kwargs['l2_val']\\n _net_architr = kwargs['net_architr']\\n _block_typex = kwargs['block_typex']\\n _block_repeatx = kwargs['block_repeatx']\\n \\n \\n params = {\\\"input_img_rows\\\" : _input_img_rows,\\n \\\"input_img_cols\\\" : _input_img_cols,\\n \\\"channels\\\" : _channels,\\n \\\"nb_classes\\\" : _nb_classes\\n }\\n \\n print(_net_architr)\\n if _net_architr == 'cnn_max':\\n model = mgcNetArchMax(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'cnn_stride':\\n model = mgcNetArchStride2(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'cnn_stride_mini':\\n model = mgcNetArchStride2Mini(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'common_cnn':\\n model = mgcNetArchCommonCnn(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'net_in_net':\\n model = mgcNetArchNin(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'resnet':\\n model = mgcResnet(block_type = _block_typex, block_repeat = _block_repeatx, **params)\\n \\n elif _net_architr == 'resblock':\\n model = mgcNetArchRes(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'skipconnect':\\n model = mgcNetArchSkip(outLayer = _outLayer, l2_val = _l2_val, **params)\\n elif _net_architr == 'skipconnect_mini':\\n model = mgcNetArchSkipMini(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n self.model = model\\n self.plot_model = SVG(model_to_dot(model, show_shapes = True).create(prog='dot', format='svg'))\\n #self.model_summary = model.summary() \\n \\n return self\",\n \"def generation_model(self, z, c): # P(x|z, c)\\n z_c = torch.cat((z, c), dim=1)\\n x_hat = self.decoder(z_c)\\n return x_hat\",\n \"def generation_model(self, z, c): # P(x|z, c)\\n z_c = torch.cat((z, c), dim=1)\\n x_hat = self.decoder(z_c)\\n return x_hat\",\n \"def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\\n # Load the raw CIFAR-10 data\\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\\n\\n # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\\n try:\\n del X_train, y_train\\n del X_test, y_test\\n print('Clear previously loaded data.')\\n except:\\n pass\\n\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\n\\n # Subsample the data\\n mask = list(range(num_training, num_training + num_validation))\\n X_val = X_train[mask]\\n y_val = y_train[mask]\\n mask = list(range(num_training))\\n X_train = X_train[mask]\\n y_train = y_train[mask]\\n mask = list(range(num_test))\\n X_test = X_test[mask]\\n y_test = y_test[mask]\\n\\n # Normalize the data: subtract the mean image\\n mean_image = np.mean(X_train, axis=0)\\n X_train -= mean_image\\n X_val -= mean_image\\n X_test -= mean_image\\n\\n # Reshape data to rows\\n X_train = X_train.reshape(num_training, -1)\\n X_val = X_val.reshape(num_validation, -1)\\n X_test = X_test.reshape(num_test, -1)\\n\\n return X_train, y_train, X_val, y_val, X_test, y_test\",\n \"def create_model(self):\\r\\n model = self.model_fn(self.flags)\\r\\n print(model)\\r\\n return model\",\n \"def predict_only(self):\",\n \"def define(self, optimizer = Adam(lr=1e-5)): \\n \\n self.optimizer = optimizer\\n\\n model = Sequential()\\n\\n #Layer 1\\n model.add(Conv2D( filters = 96, \\n kernel_size = (11,11), \\n strides = 4, \\n padding = 'same', \\n activation = 'relu', \\n input_shape = (224, 224, 3), \\n kernel_initializer = 'he_normal'))\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None)) # overlapping pooling\\n #Layer 2\\n model.add(Conv2D( filters = 256, \\n kernel_size = (5,5), \\n strides = 1, \\n padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None)) \\n #Layer 3\\n model.add(Conv2D( filters = 384, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', kernel_initializer = 'he_normal'))\\n #Layer 4\\n model.add(Conv2D( filters = 384, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n #Layer 5\\n model.add(Conv2D( filters = 256, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n #Layer 6\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None))\\n \\n #Layer 7\\n model.add(Flatten())\\n \\n #Layer 8\\n model.add(Dense( units = 4096, activation = 'relu'))\\n model.add(Dense( units = 1024, activation = 'relu'))\\n model.add(Dense( units = 512, activation = 'relu'))\\n model.add(Dense( units = 256, activation = 'relu'))\\n model.add(Dense( units = 128, activation = 'relu'))\\n \\n #Layer end\\n model.add(Dense( units = 3, activation = 'softmax'))\\n model.summary()\\n \\n self.model = model\",\n \"def car(mnfr, model, **car_info):\\n car_info[\\\"manufacturer\\\"] = mnfr\\n car_info[\\\"model name\\\"] = model\\n return car_info\",\n \"def test_cifar(args):\\n # type: () -> None\\n\\n # Build dataset and model\\n dataset = CIFAR10(path=args.path)\\n model = MEMCIFAR10(input_shape=dataset.shape, code_length=64, cpd_channels=100, mem_dim=500, shrink_thres=1.0 / 500).cuda().eval()\\n\\n # Set up result helper and perform test\\n helper = MEMResultHelper(dataset, model, checkpoints_dir=args.checkpoints, output_file='mem_cifar.txt')\\n helper.test_one_class_classification()\",\n \"def resnet50_cifar10(pretrained=True, progress=True, use_data_parallel=False, **kwargs):\\n return _model('resnet50_cifar10', resnet50, pretrained, progress, use_data_parallel, **kwargs)\",\n \"def build(self) -> KM.Model:\\n\\n # For decoder number of features in opposite order of encoder\\n decoder_features = self.encoder_features.copy()\\n decoder_features.reverse()\\n\\n # build the encoder model\\n self.encoder_model = self.encoder(\\n features=self.encoder_features, name=\\\"encoder\\\"\\n )\\n\\n # build the decoder model\\n decoder = self.decoder(features=decoder_features, name=\\\"decoder\\\")\\n\\n input_tensor = KL.Input(\\n shape=(32, 32, 3)\\n ) # shape of images for cifar10 dataset\\n\\n # Encode the images\\n encoded = self.encoder_model(input_tensor)\\n # Decode the image\\n decoded = decoder(encoded[-1])\\n\\n return KM.Model(inputs=input_tensor, outputs=decoded, name=\\\"AutoEncoder\\\")\",\n \"def build_model(self):\\n raise NotImplementedError\",\n \"def test_forward(self):\\r\\n # CIFAR\\r\\n model = densenet.DenseNet(\\r\\n depth=40,\\r\\n Block=densenet.BasicBlock,\\r\\n growth_rate=12,\\r\\n mask=True,\\r\\n compression_rate=1.0,\\r\\n num_classes=100,\\r\\n )\\r\\n model.forward(torch.randn((1, 3, 32, 32)))\",\n \"def rpy_process_r10(config_file, json_data):\\n\\n\\trpy_module = importr('cocalculateur')\\n\\tloadjson_module = importr('jsonlite')\\n\\t\\n\\t#json_data = loadjson_module.fromJSON(txt = './input_f02.json',flatten=True)\\n\\tconfig_data = loadjson_module.fromJSON(txt = config_file ,flatten=True)\\n\\toutput_data = rpy_module.f_02(json_data,config_data)\\n\\n\\treturn output_data\",\n \"def model_fn(self, features, labels, mode, params, config):\\n raise NotImplementedError()\",\n \"def modelbuilder():\\n model = Sequential()\\n # Add a convolution layer with with a sigmoid activation function\\n model.add(layers.Conv2D(1, (2, 2), strides=(1, 1), activation='sigmoid', padding='same', input_shape=(256, 256, 3)))\\n model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\\n model.summary()\\n return model\",\n \"def __init__(self,*args,**kwargs):\\n super(CompositeModel1D,self).__init__(*args,**kwargs)\\n for m in self._models:\\n if not isinstance(m,FunctionModel1D):\\n raise ModelTypeError('Input model %s is not a 1D model'%m)\\n self._filters = None\",\n \"def __init__(self, meta_model, clust_cent, model_data):\\r\\n\\r\\n self.meta_model = meta_model\\r\\n\\r\\n MM.AbstractModel.__init__(self, meta_model.get_in_par_intervals(), meta_model.get_in_par_means(),\\r\\n meta_model.get_in_par_variances(), meta_model.get_out_par_intervals(),\\r\\n meta_model.get_out_par_means(), meta_model.get_out_par_variances())\\r\\n\\r\\n def check_additional_input():\\r\\n \\\"\\\"\\\" Checks the additional input\\r\\n\\r\\n :return: The additional input\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n # Check if the cluster center input is correct\\r\\n RM.check_if_matrix(clust_cent, 'The cluster centers')\\r\\n RM.warn_if_bigger(clust_cent.shape[1], meta_model.get_in_par_means().shape[1],\\r\\n 'The number of input parameters in the cluster centers',\\r\\n 'the number of input parameters - 1')\\r\\n RM.check_if_bigger(clust_cent.shape[1], meta_model.get_in_par_means().shape[1] - 1,\\r\\n 'The number of input parameters',\\r\\n 'the number of input parameters in the cluster centers')\\r\\n\\r\\n bounds = meta_model.get_in_par_intervals()\\r\\n\\r\\n for j in range(clust_cent.shape[0]):\\r\\n for i in range(bounds.shape[0]):\\r\\n RM.check_if_in_interval(bounds[i], clust_cent[j, i], i, ' In cluster center %x, the value')\\r\\n\\r\\n def check_PLSR_input():\\r\\n \\\"\\\"\\\" Checks model data of PLSR\\r\\n\\r\\n :return: Checks model data of PLSR\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n RM.check_if_ndim_array(model_data, 3, 'Model data')\\r\\n RM.check_if_bigger(model_data.shape[1], meta_model.get_in_par_means().shape[1],\\r\\n 'The number of input parameters in the solution matrix',\\r\\n 'the number of input parameters')\\r\\n RM.warn_if_bigger(model_data.shape[1], meta_model.get_in_par_means().shape[1] + 1,\\r\\n 'The number of input parameters',\\r\\n 'the number of input parameters in the solution matrix')\\r\\n RM.check_if_bigger(model_data.shape[2], meta_model.get_out_par_means().shape[1] - 1,\\r\\n 'The number of output parameters in the solution matrix',\\r\\n 'the number of output parameters')\\r\\n RM.warn_if_bigger(model_data.shape[2], meta_model.get_out_par_means().shape[1],\\r\\n 'The number of output parameters',\\r\\n 'the number of output parameters in the solution matrix')\\r\\n\\r\\n # Check if the additional data is correct\\r\\n\\r\\n if meta_model.get_type() == 'PLSR': # Additional check-up for PLSR\\r\\n check_PLSR_input()\\r\\n\\r\\n elif meta_model.get_type() == 'DLU': # Additional check-up for DLU\\r\\n raise TypeError('This part is not implemented yet')\\r\\n\\r\\n # if not isinstance(model_data, np.ndarray):\\r\\n # raise TypeError('The cluster input and output data is not stored in a multidimensional array')\\r\\n #\\r\\n # for clust_data in model_data:\\r\\n #\\r\\n # if not isinstance(clust_data[0], np.matrix) or not isinstance(clust_data[1], np.matrix):\\r\\n # raise TypeError('One of the input or output databases is not a matrix')\\r\\n #\\r\\n # if clust_data[0].shape[1] > meta_model.get_in_par_means().shape[1]:\\r\\n # warnings.warn('The number of input parameters for the input database of the clusters is bigger '\\r\\n # 'than the actual number of input parameters')\\r\\n #\\r\\n # elif clust_data[0].shape[1] < meta_model.get_in_par_means().shape[1]:\\r\\n # raise TypeError('The number of input parameters for the input database of the clusters is '\\r\\n # 'smaller than the actual numbers of input parameters')\\r\\n #\\r\\n # if clust_data[1].shape[1] > meta_model.get_out_par_means().shape[1]:\\r\\n # raise TypeError('The number of output parameters for the output database of the clusters is '\\r\\n # 'bigger than the actual number of output parameters')\\r\\n #\\r\\n # elif clust_data[1].shape[1] < meta_model.get_out_par_means().shape[1]:\\r\\n # raise TypeError('The number of output parameters for the output database of the clusters is '\\r\\n # 'smaller than the actual numbers of output parameters')\\r\\n #\\r\\n # if clust_data[0].shape[0] != clust_data[1].shape[0]:\\r\\n # raise TypeError('The number rows in the input and output database differ from each other')\\r\\n\\r\\n else: # No check-up is done when the meta-model is an unknown version\\r\\n warnings.warn('The additional cluster data can not be checked, for this kind of meta-model')\\r\\n\\r\\n RM.check_if_same_size(clust_cent.shape[0], model_data.shape[0],\\r\\n 'The number of clusters according to the cluster centers',\\r\\n 'The number of clusters according to the model_data')\\r\\n\\r\\n check_additional_input()\\r\\n\\r\\n self.__clust_cent = clust_cent\\r\\n self.__model_data = model_data\",\n \"def Char_Gate(NV,res ,B_field=400):\\n\\n\\n #data = np.loadtxt(\\\"NV_Sim_8.dat\\\") #Placeholder data to test the script\\n #NV = np.vstack((data[:,3],data[:,4]))\\n #physical constants\\n gamma_c = 1.071e3 #g-factor for C13 in Hz/G\\n #Model parameters\\n omega_larmor = 2*np.pi*gamma_c*B_field\\n tau_larmor = 2*np.pi/omega_larmor\\n tau = res[0]\\n n_pulses = int(res[1]*2) #So that we do a pi -pulse\\n\\n Ix = 0.5 * np.array([[0,1],[1,0]])\\n Iz = 0.5* np.array([[1,0],[0,-1]])\\n H0 = (omega_larmor)*Iz\\n exH0 =linalg.expm(-1j*H0*tau)\\n\\n\\n M = np.zeros(np.shape(NV)[0])\\n for idC in range(np.shape(NV)[0]):\\n A= 2*np.pi*NV[idC,0]\\n B= 2*np.pi*NV[idC,1] #Converts to radial frequency in Hz/G\\n H1 = (A+omega_larmor) *Iz +B*Ix\\n exH1 = linalg.expm(-1j*H1*tau)\\n V0 = exH0.dot(exH1.dot(exH1.dot(exH0)))\\n V1 = exH1.dot(exH0.dot(exH0.dot(exH1)))\\n n0 = Calc_axis(V0)\\n n1 =Calc_axis(V1)\\n phi = np.real(2*np.arccos(np.trace(V0)/2))\\n M[idC] = 1 - (1-np.dot(n0,n1))*np.sin(n_pulses * phi /2 )**2\\n\\n Signal = -M.prod()\\n F = (1-(Signal+1)/2)\\n return F\",\n \"def get_model():\\n model = ecole.scip.Model.from_file(str(DATA_DIR / \\\"bppc8-02.mps\\\"))\\n model.disable_cuts()\\n model.disable_presolve()\\n model.set_param(\\\"randomization/permuteconss\\\", True)\\n model.set_param(\\\"randomization/permutevars\\\", True)\\n model.set_param(\\\"randomization/permutationseed\\\", 784)\\n model.set_param(\\\"randomization/randomseedshift\\\", 784)\\n model.set_param(\\\"randomization/lpseed\\\", 784)\\n return model\",\n \"def classify(img, c_model):\\n #global class_graph\\n\\n #img = load_img(im_path,target_size=(input_height, input_width))\\n #img = img_to_array(img)\\n im_size = 128\\n # resize \\n\\n img = cv2.resize(img, (im_size,im_size))\\n\\n img = img.astype(\\\"float\\\") / 255.0\\n img = np.expand_dims(img, axis=0)\\n with class_graph.as_default():\\n predictions = c_model.predict(img)[0]\\n\\n return predictions\",\n \"def get_model_2(parameters):\\n # Parameters\\n BANDS = parameters['num_features']\\n CLASSES = parameters['num_classes']\\n \\n # Sequential model\\n model = keras.models.Sequential()\\n \\n # Add convolution (1)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, 9, BANDS, 1)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(9, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh',\\n input_shape=(9, BANDS,1)))\\n \\n # Add convolution (2)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(1, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh'))\\n \\n # Add convolution (3)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 45, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(1, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh'))\\n \\n # Flatten before dense layer\\n model.add(keras.layers.Flatten())\\n \\n # Add fully connected (4)\\n # -----------------------\\n # Intput_shape (batch, rows, cols, channels) = (-, (BANDS - 45) x 1 x 32)\\n # Output_shape (batch, dim) = (-, 800)\\n model.add(keras.layers.Dense(units=800,\\n activation='tanh'))\\n \\n # Add fully connected (5)\\n # -----------------------\\n # Intput_shape (batch, dim) = (-, 800)\\n # Output_shape (batch, dim) = (-, 800)\\n model.add(keras.layers.Dense(units=800,\\n activation='softmax'))\\n \\n # Add fully connected to reduce to number of categories\\n # -----------------------------------------------------\\n # Intput_shape (batch, dim) = (-, 800)\\n # Output_shape (batch, dim) = (-, CLASSES)\\n model.add(keras.layers.Dense(units=CLASSES,\\n activation='softmax'))\\n \\n # Compile model\\n model.compile(optimizer='adam',\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n \\n # Print the model summary to output file\\n # To print to stdout: model.summary()\\n with open(OUTPUT_FILE, 'a') as f:\\n # Pass the file handle in as a lambda function to make it callable\\n model.summary(print_fn=lambda x: f.write(x + '\\\\n'))\\n \\n # Return the model\\n return model\",\n \"def load_cifar(hparams):\\n all_labels = []\\n\\n total_batches_to_load = 5\\n assert hparams.train_size + hparams.validation_size <= 50000\\n if hparams.eval_test:\\n total_batches_to_load += 1\\n # Determine how many images we have loaded\\n total_dataset_size = 50000\\n train_dataset_size = total_dataset_size\\n if hparams.eval_test:\\n total_dataset_size += 10000\\n\\n if hparams.dataset == 'cifar10':\\n all_images = []\\n elif hparams.dataset == 'cifar100':\\n all_images = np.empty((1, 50000, 3072), dtype=np.uint8)\\n if hparams.eval_test:\\n test_data = np.empty((1, 10000, 3072), dtype=np.uint8)\\n if hparams.dataset == 'cifar10':\\n datafiles = [\\n 'data_batch_1', 'data_batch_2', 'data_batch_3', 'data_batch_4',\\n 'data_batch_5']\\n\\n if hparams.eval_test:\\n datafiles.append('test_batch')\\n num_classes = 10\\n elif hparams.dataset == 'cifar100':\\n datafiles = ['train']\\n if hparams.eval_test:\\n datafiles.append('test')\\n num_classes = 100\\n else:\\n raise NotImplementedError('Unimplemented dataset: ', hparams.dataset)\\n if hparams.dataset != 'test':\\n for file_num, f in enumerate(datafiles):\\n d = unpickle(os.path.join(hparams.data_path, f))\\n if hparams.dataset == 'cifar10':\\n labels = np.array(d['labels'])\\n else:\\n labels = np.array(d['fine_labels'])\\n if f == 'test':\\n test_data[0] = copy.deepcopy(d['data'])\\n if hparams.dataset == 'cifar10':\\n all_images.append(test_data)\\n else:\\n all_images = np.concatenate([all_images, test_data], axis=1)\\n else:\\n if hparams.dataset == 'cifar10':\\n all_images.append(copy.deepcopy(d['data']))\\n else:\\n all_images[file_num] = copy.deepcopy(d['data'])\\n nsamples = len(labels)\\n for idx in range(nsamples):\\n all_labels.append(labels[idx])\\n if hparams.dataset == 'cifar10':\\n all_images = np.concatenate(all_images, axis=0)\\n all_images = all_images.reshape(-1, 3072)\\n all_images = all_images.reshape(-1, 3, 32, 32) # pylint: disable=too-many-function-args\\n all_images = all_images.transpose(0, 2, 3, 1).copy()\\n all_images = all_images / 255.0\\n mean = augmentation_transforms.MEANS\\n std = augmentation_transforms.STDS\\n tf.logging.info('mean:{} std: {}'.format(mean, std))\\n all_images = (all_images - mean) / std\\n all_labels = np.eye(num_classes)[np.array(all_labels, dtype=np.int32)]\\n\\n assert len(all_images) == len(all_labels)\\n tf.logging.info(\\n 'In CIFAR10 loader, number of images: {}'.format(len(all_images)))\\n\\n extra_test_images = None\\n extra_test_labels = None\\n if hparams.extra_dataset == 'cifar10_1':\\n extra_test_ds = tfds.as_numpy(\\n tfds.load('cifar10_1', split='test', batch_size=-1))\\n extra_test_images = ((extra_test_ds['image'] / 255.0) - mean) / std\\n extra_test_labels = np.eye(num_classes)[np.array(\\n extra_test_ds['label'], dtype=np.int32)]\\n\\n # Break off test data\\n if hparams.eval_test:\\n test_images = all_images[train_dataset_size:]\\n test_labels = all_labels[train_dataset_size:]\\n else:\\n test_images = []\\n test_labels = []\\n all_images = all_images[:train_dataset_size]\\n all_labels = all_labels[:train_dataset_size]\\n return all_images, all_labels, test_images, test_labels, extra_test_images, extra_test_labels\",\n \"def first_model():\\n model=Sequential()\\n # model.add(Flatten(input_shape=(160,320,3)))\\n model.add(Lambda(lambda x: (x-128.0)/128.0,input_shape=(160, 320, 3)))\\n model.add(Cropping2D(cropping=((70,25), (0,0))))\\n model.add(Convolution2D(32, 3, 3))\\n model.add(MaxPooling2D((2, 2)))\\n model.add(Dropout(0.5))\\n model.add(Activation('relu'))\\n model.add(Flatten())\\n model.add(Dense(128))\\n model.add(Activation('relu'))\\n model.add(Dense(1))\\n\\n model.compile(loss=\\\"mse\\\",optimizer=\\\"adam\\\")\\n return model\",\n \"def COMBI(self):\\n\\n self.FB()\\n self.LAT()\\n self.ROT()\",\n \"def build_model():\\n\\n if K.image_data_format() == 'channels_first':\\n input_shape = (3, img_width, img_height)\\n else:\\n input_shape = (img_width, img_height, 3)\\n\\n model = Sequential()\\n model.add(Conv2D(32, (3, 3), input_shape=input_shape))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n\\n model.add(Conv2D(32, (3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n\\n model.add(Conv2D(64, (3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n\\n model.add(Flatten())\\n\\n # FC layer\\n model.add(Dense(64))\\n model.add(Activation('relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(1))\\n model.add(Activation('sigmoid'))\\n\\n model.compile(loss='binary_crossentropy',\\n optimizer='adadelta',\\n metrics=['accuracy'])\\n\\n return model\",\n \"def model_build(self):\\n\\n # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!\\n X_input = Input(self.inputData[0].shape)\\n\\n '''\\n # CONV -> BN -> RELU Block applied to X\\n X = Conv2D(8, (8, 8), name='conv0')(X_input)\\n X = BatchNormalization(name='bn0')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool0')(X)\\n X = Dropout(0.1, name='dropout0')(X)\\n\\n X = Conv2D(16, (16, 16), name='conv1')(X)\\n X = BatchNormalization(name='bn1')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool1')(X)\\n X = Dropout(0.1, name='dropout1')(X)\\n\\n X = Conv2D(16, (32, 32), name='conv2')(X)\\n X = BatchNormalization(name='bn2')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool2')(X)\\n X = Dropout(0.1, name='dropout2')(X)\\n' '''\\n\\n X = Dense(500, activation='relu', name='fc0')(X_input)\\n X = Dropout(0.1, name='dropout1')(X)\\n X = Dense(500, activation='relu', name='fc1')(X)\\n X = Dropout(0.1, name='dropout2')(X)\\n X = Dense(3, activation='softmax', name='fc2')(X)\\n\\n # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.\\n self.model = Model(inputs=X_input, outputs=X, name='acouModel')\",\n \"def makepredictions(self):\\n data, sampling_rate = librosa.load(self.file)\\n mfccs = np.mean(librosa.feature.mfcc(y=data, sr=sampling_rate, n_mfcc=40).T, axis=0)\\n x = np.expand_dims(mfccs, axis=1)\\n x = np.expand_dims(x, axis=0)\\n predictions = self.loaded_model.predict_classes(x)\\n predict = self.convertclasstoemotion(predictions)\\n print(\\\"Prediction is\\\", \\\" \\\", self.convertclasstoemotion(predictions))\\n return predict\",\n \"def sweep_image_model():\\n for c1 in [4, 8, 16]:\\n for c2 in [2, 4]:\\n for c3 in [2, 4]:\\n for c4 in [1, 2]:\\n flags = flag_reader.read_flag()\\n print(c1)\\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\\n print('channel list = ', flags.channel_list)\\n flags.last_dim = flags.channel_list[-1]\\n flags.model_name = flags.data_set + '_channel_' + str(flags.channel_list).replace('[','').replace(']','').replace(' ','_') + \\\\\\n '_dim_last_' + str(flags.last_dim) + '_ind_' + str(flags.comp_ind) + \\\\\\n '_lr_{}_decay_{}_reg_{}_bs_{}'.format(flags.lr, flags.lr_decay_rate, flags.reg_scale, flags.batch_size)\\n print(flags.model_name)\\n training_from_flag(flags)\",\n \"def openCif(self, filename):\\r\\n cf = CifFile.ReadCif(filename)\\r\\n \\r\\n #Assuming all data is in one outer block like NIST examples:\\r\\n data = cf[cf.keys()[0]]\\r\\n \\r\\n #Create a Crystollographic Unit Cell\\r\\n a = data['_cell_length_a']\\r\\n b = data['_cell_length_b']\\r\\n c = data['_cell_length_c']\\r\\n \\r\\n alpha = data['_cell_angle_alpha']\\r\\n gamma = data['_cell_angle_gamma']\\r\\n beta = data['_cell_angle_beta']\\r\\n \\r\\n spaceGroupInt = int(data['_symmetry_Int_Tables_number'])\\r\\n spaceGroup = SpaceGroups.GetSpaceGroup(spaceGroupInt)\\r\\n \\r\\n unitcell = Cell(spaceGroup, 0,0,0, a, b, c, alpha, gamma, beta)\\r\\n \\r\\n atomLabels = data['_atom_site_label']\\r\\n atomSymbol = data['_atom_site_type_symbol']\\r\\n xPositions = data['_atom_site_fract_x']\\r\\n yPositions = data['_atom_site_fract_y']\\r\\n zPositions = data['_atom_site_fract_z']\\r\\n \\r\\n atoms = [] #for the cell window\\r\\n for i in range(len(atomLabels)):\\r\\n #unitcell.generateAtoms((float(xPositions[i]), float(yPositions[i]), float(zPositions[i])), atomLabels[i])\\n\\r\\n aData = [atomLabels[i], 0, float(xPositions[i]), float(yPositions[i]), float(zPositions[i])]\\r\\n #--Added to atomData: single ion anisotropy, spin magnitude, valence\\r\\n aData.append(0.0)#Dx\\r\\n aData.append(0.0)#Dy\\r\\n aData.append(0.0)#Dz\\r\\n aData.append(1)#Spin Magnitude\\r\\n aData.append('')#valence\\r\\n #-------------------------------------------------------------------\\r\\n atoms.append(aData)\\r\\n \\r\\n self.atomTable.SetValue(i, 0, atomLabels[i])\\r\\n self.atomTable.SetValue(i, 2, xPositions[i])\\r\\n self.atomTable.SetValue(i, 3, yPositions[i])\\r\\n self.atomTable.SetValue(i, 4, zPositions[i])\\r\\n \\r\\n #Create a Magnetic Cell\\r\\n self.MagCell = MagneticCell(unitcell, 1,1,1, spaceGroup)\\r\\n\\r\\n\\r\\n Na = 1 #Cif files only contain 1 unit cell\\r\\n Nb = 1\\r\\n Nc = 1\\r\\n \\r\\n #self.cellChange(spaceGroupInt, a, b, c, alpha, beta, gamma, magNa = Na, magNb = Nb, magNc = Nc, cutNa = Na, cutNb = Nb, cutNc = Nc, atomData = atoms)\\n self.updateCell(spaceGroupInt, a, b, c, alpha, beta, gamma, magNa = Na, magNb = Nb, magNc = Nc, cutNa = Na, cutNb = Nb, cutNc = Nc, atomData = atoms)\\n self.refreshGUI()\\n \\n \\r\\n #send signal to the cell window to show the info that has been loaded and to vtkWindow to draw it\\r\\n n = self.atomTable.GetNumberRows()\\r\\n for i in range(n):\\r\\n print self.atomTable.GetValue(i, 0)\\r\\n send(signal = \\\"File Load\\\", sender = \\\"Session\\\", spaceGroup = spaceGroupInt, a = a, b = b, c = c, alpha = alpha, beta = beta, gamma = gamma, magNa = Na, magNb = Nb, magNc = Nc, cutNa = Na, cutNb = Nb, cutNc = Nc)\",\n \"def __init__(self):\\n self.model = Sequential()\\n self.model.add(AveragePooling2D(pool_size=(4, 4), input_shape=(224, 224, 3)))\\n self.model.add(Conv2D(16, (9, 9)))\\n self.model.add(Activation('relu'))\\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\\n self.model.add(Conv2D(16, (5, 5)))\\n self.model.add(Activation('relu'))\\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\\n self.model.add(Flatten())\\n self.model.add(Dropout(0.5))\\n self.model.add(Dense(1, activation='sigmoid'))\\n self.model.compile(loss=binary_crossentropy,\\n optimizer=keras.optimizers.Adadelta(),\\n metrics=['accuracy'])\",\n \"def __init__(self, mode, path):\\n\\n\\t\\tmodel = load_model('data/model.h5') \\n\\n\\t\\tif mode == \\\"test\\\":\\n\\n\\t\\t\\tX_test, Y_test = self._load_dataset(path)\\n\\t\\t\\tpreds = model.evaluate(X_test, Y_test)\\n\\t\\t\\tprint (\\\"Loss = \\\" + str(preds[0]))\\n\\t\\t\\tprint (\\\"Test Accuracy = \\\" + str(preds[1]))\\n\\n\\n\\t\\telif mode == \\\"predict\\\":\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tlabel_dict = {'airplane':0, 'automobile':1, 'bird':2, 'cat':3, 'deer':4,\\n\\t\\t\\t'dog':5, 'frog':6, 'horse':7, 'ship':8, 'truck':9}\\n\\n\\t\\t\\timg = image.load_img(path, target_size=(64, 64))\\n\\t\\t\\tx = image.img_to_array(img)\\n\\t\\t\\tx = np.reshape(x, (1,64,64,3))\\n\\t\\t\\ttemp_pred = model.predict(x)\\n\\t\\t\\tidx = np.argmax(temp_pred)\\n\\t\\t\\t\\n\\t\\t\\tprint(\\\"The object detected in the picture is a(n) : \\\" + \\n\\t\\t\\t\\tlist(label_dict.keys())[list(label_dict.values()).index(idx)])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6843386","0.650111","0.609306","0.60163224","0.5996454","0.59331244","0.588775","0.58561015","0.5830527","0.57808924","0.57354146","0.5720595","0.5690742","0.56661737","0.5664544","0.5653322","0.56082076","0.55979353","0.5551245","0.5541251","0.5541251","0.5531916","0.55178267","0.54801166","0.546483","0.54569495","0.5417938","0.5394017","0.53901184","0.53713876","0.53713876","0.53713876","0.53713876","0.53713876","0.5352903","0.5347471","0.53273267","0.53039294","0.52912396","0.52771544","0.5274009","0.52732104","0.5258769","0.5245436","0.52434677","0.52337366","0.5227893","0.5224607","0.5215319","0.5214747","0.52085435","0.5177377","0.51769465","0.5166435","0.5165537","0.516175","0.5160214","0.5159154","0.5155019","0.51526093","0.5150227","0.5144099","0.51440376","0.51433885","0.51400644","0.51400083","0.51258534","0.5120224","0.5118796","0.51175827","0.51175827","0.51069653","0.5103944","0.5102525","0.5096105","0.5090307","0.5088969","0.5085928","0.5072016","0.50702167","0.50565916","0.50558954","0.50551677","0.5049026","0.5048407","0.5033567","0.50334984","0.5030412","0.5029075","0.50211227","0.501904","0.50147766","0.50133276","0.50115687","0.50071275","0.50068605","0.5002529","0.50011975","0.49938342","0.49827304"],"string":"[\n \"0.6843386\",\n \"0.650111\",\n \"0.609306\",\n \"0.60163224\",\n \"0.5996454\",\n \"0.59331244\",\n \"0.588775\",\n \"0.58561015\",\n \"0.5830527\",\n \"0.57808924\",\n \"0.57354146\",\n \"0.5720595\",\n \"0.5690742\",\n \"0.56661737\",\n \"0.5664544\",\n \"0.5653322\",\n \"0.56082076\",\n \"0.55979353\",\n \"0.5551245\",\n \"0.5541251\",\n \"0.5541251\",\n \"0.5531916\",\n \"0.55178267\",\n \"0.54801166\",\n \"0.546483\",\n \"0.54569495\",\n \"0.5417938\",\n \"0.5394017\",\n \"0.53901184\",\n \"0.53713876\",\n \"0.53713876\",\n \"0.53713876\",\n \"0.53713876\",\n \"0.53713876\",\n \"0.5352903\",\n \"0.5347471\",\n \"0.53273267\",\n \"0.53039294\",\n \"0.52912396\",\n \"0.52771544\",\n \"0.5274009\",\n \"0.52732104\",\n \"0.5258769\",\n \"0.5245436\",\n \"0.52434677\",\n \"0.52337366\",\n \"0.5227893\",\n \"0.5224607\",\n \"0.5215319\",\n \"0.5214747\",\n \"0.52085435\",\n \"0.5177377\",\n \"0.51769465\",\n \"0.5166435\",\n \"0.5165537\",\n \"0.516175\",\n \"0.5160214\",\n \"0.5159154\",\n \"0.5155019\",\n \"0.51526093\",\n \"0.5150227\",\n \"0.5144099\",\n \"0.51440376\",\n \"0.51433885\",\n \"0.51400644\",\n \"0.51400083\",\n \"0.51258534\",\n \"0.5120224\",\n \"0.5118796\",\n \"0.51175827\",\n \"0.51175827\",\n \"0.51069653\",\n \"0.5103944\",\n \"0.5102525\",\n \"0.5096105\",\n \"0.5090307\",\n \"0.5088969\",\n \"0.5085928\",\n \"0.5072016\",\n \"0.50702167\",\n \"0.50565916\",\n \"0.50558954\",\n \"0.50551677\",\n \"0.5049026\",\n \"0.5048407\",\n \"0.5033567\",\n \"0.50334984\",\n \"0.5030412\",\n \"0.5029075\",\n \"0.50211227\",\n \"0.501904\",\n \"0.50147766\",\n \"0.50133276\",\n \"0.50115687\",\n \"0.50071275\",\n \"0.50068605\",\n \"0.5002529\",\n \"0.50011975\",\n \"0.49938342\",\n \"0.49827304\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6535784"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":23393,"cells":{"query":{"kind":"string","value":"Run ResNet CIFAR10 training and eval loop."},"document":{"kind":"string","value":"def run_flower(flags_obj):\n input_function = input_fn\n resnet_run_loop.resnet_main(\n flags_obj,\n cifar10_model_fn,\n input_function,\n DATASET_NAME,\n shape=[_IMAGE_SIZE, _IMAGE_SIZE, _NUM_CHANNELS])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def cifar10_model_fn(features, labels, mode, params):\n features = tf.reshape(features, [-1, _IMAGE_SIZE, _IMAGE_SIZE, _NUM_CHANNELS])\n\n learning_rate_fn = resnet_run_loop.learning_rate_with_decay(\n batch_size=params['batch_size'], batch_denom=128,\n num_images=_NUM_IMAGES['train'], boundary_epochs=[10, 20, 30],\n decay_rates=[1, 0.1, 0.01, 0.001])\n\n # We use a weight decay of 0.0002, which performs better\n # than the 0.0001 that was originally suggested.\n weight_decay = 2e-4\n\n # Empirical testing showed that including batch_normalization variables\n # in the calculation of regularized loss helped validation accuracy\n # for the CIFAR-10 dataset, perhaps because the regularization prevents\n # overfitting on the small data set. We therefore include all vars when\n # regularizing and computing loss during training.\n def loss_filter_fn(_):\n return True\n\n return resnet_run_loop.resnet_model_fn(\n features=features,\n labels=labels,\n mode=mode,\n model_class=Model,\n resnet_size=params['resnet_size'],\n weight_decay=weight_decay,\n learning_rate_fn=learning_rate_fn,\n momentum=0.9,\n data_format=params['data_format'],\n resnet_version=params['resnet_version'],\n loss_scale=params['loss_scale'],\n loss_filter_fn=loss_filter_fn,\n dtype=params['dtype'],\n fine_tune=params['fine_tune']\n )","def train_cifar10():\r\n # type: () -> None\r\n\r\n # Build dataset and model\r\n dataset = CIFAR10_TRAIN(path=Config.video_folder)\r\n model = LSACIFAR10(input_shape=dataset.shape, code_length=64,\r\n cpd_channels=100).to(device).train()\r\n\r\n # Set up result helper and perform test\r\n helper = OneClassResultHelper(dataset, model,\r\n checkpoints_dir=Config.model_ckpt,\r\n output_file='cifar10.txt')\r\n helper.train_one_class_classification()","def evaluate():\n with tf.Graph().as_default() as g:\n # Get images and labels for CIFAR-10.\n # eval_data = FLAGS.eval_data\n # images, labels = model.inputs(eval_data=eval_data, batch_size=FLAGS.eval_batch_size)\n data_obj = model.inputs()\n values = data_obj.value\n data = tf.concat(values,0)\n # print(data)\n\n data = tf.reshape(data, [data_obj.height,data_obj.width])\n # print(data)\n # Build a Graph that computes the logits predictions from the\n # inference model.\n representation, reconstruct = model.inference_fconn(data)\n # print(representation)\n # print(reconstruct)\n # print(data)\n # Calculate predictions.\n # representation_reshape = tf.reshape(representation, [FLAGS.eval_batch_size, -1])\n\n # Restore the moving average version of the learned variables for eval.\n variable_averages = tf.train.ExponentialMovingAverage(\n model.MOVING_AVERAGE_DECAY)\n variables_to_restore = variable_averages.variables_to_restore()\n saver = tf.train.Saver(variables_to_restore)\n\n # images_reconstruct = tf.concat([data, tf.transpose(reconstruct)],1)\n # print(images_reconstruct)\n # tf.summary.image('original_reconstruct', images_reconstruct)\n # tf.image_summary('original', images, max_images=20)\n # tf.image_summary('reconstruct', reconstruct, max_images=20)\n\n # Build the summary operation based on the TF collection of Summaries.\n summary_op = tf.summary.merge_all()\n\n summary_writer = tf.summary.FileWriter(eval_dir, g)\n\n\n while True:\n eval_once(saver, summary_writer, representation, summary_op, reconstruct, data)\n if FLAGS.run_once:\n break\n time.sleep(FLAGS.eval_interval_secs)","def train(self, network_parameters=network_model, eval_steps=100):\n #model_dir=TFFLAGS.train_dir\n #self.model_dir=model_dir\n network_parameters=buildNetwork()\n model_path='models/central/'\n save_path=\"models/cifar/clients\"\n cifar_train_file=\"data/clients/cifar\"\n cifar_test_file=\"data/clients/cifar\"\n \n batch_size = TFFLAGS.batch_size\n\n params = {\"accountant_type\": TFFLAGS.accountant_type,\n \"task_id\": 0,\n \"batch_size\": TFFLAGS.batch_size,\n \"default_gradient_l2norm_bound\":\n network_parameters.default_gradient_l2norm_bound,\n \"num_hidden_layers\": TFFLAGS.num_hidden_layers,\n \"hidden_layer_num_units\": TFFLAGS.hidden_layer_num_units,\n \"num_examples\": self.num_training_images,\n \"learning_rate\": TFFLAGS.lr,\n \"end_learning_rate\": TFFLAGS.end_lr,\n \"learning_rate_saturate_epochs\": TFFLAGS.lr_saturate_epochs\n }\n\n params.update({\"sigma\": TFFLAGS.sigma})\n #saver = tf.train.Saver()\n\n with tf.Graph().as_default(), tf.Session() as sess, tf.device('/cpu:0'):\n # Create the basic Cifar model.\n # TODO: GET INPUT FOR CLIENT\n #images, labels = CifarInput(cifar_train_file, batch_size, TFFLAGS.randomize)\n images, labels = cifar10_input.distorted_inputs(\"data/clients/cifar\", self.index, TFFLAGS.batch_size)\n \n\n logits, projection, training_params = utils.BuildNetwork(\n images, network_parameters)\n \n \n cost = tf.nn.softmax_cross_entropy_with_logits(\n logits=logits, labels=tf.one_hot(labels, 10))\n\n # The actual cost is the average across the examples.\n cost = tf.reduce_sum(cost, [0]) / batch_size\n\n priv_accountant = accountant.GaussianMomentsAccountant(self.num_training_images)\n sigma = TFFLAGS.sigma\n with_privacy = TFFLAGS.sigma > 0\n with_privacy = False\n # Note: Here and below, we scale down the l2norm_bound by\n # batch_size. This is because per_example_gradients computes the\n # gradient of the minibatch loss with respect to each individual\n # example, and the minibatch loss (for our model) is the *average*\n # loss over examples in the minibatch. Hence, the scale of the\n # per-example gradients goes like 1 / batch_size.\n gaussian_sanitizer = sanitizer.AmortizedGaussianSanitizer(\n priv_accountant, \n [network_parameters.default_gradient_l2norm_bound / batch_size, True])\n\n for var in training_params:\n if \"gradient_l2norm_bound\" in training_params[var]:\n l2bound = training_params[var][\"gradient_l2norm_bound\"] / batch_size\n gaussian_sanitizer.set_option(var,\n sanitizer.ClipOption(l2bound, True))\n lr = tf.placeholder(tf.float32)\n eps = tf.placeholder(tf.float32)\n delta = tf.placeholder(tf.float32)\n\n init_ops = []\n\n # Add global_step\n global_step = tf.Variable(0, dtype=tf.int32, trainable=False,\n name=\"global_step\")\n\n if with_privacy:\n gd_op = dp_optimizer.DPGradientDescentOptimizer(\n lr,\n [eps, delta],\n gaussian_sanitizer,\n sigma=sigma,\n batches_per_lot=TFFLAGS.batches_per_lot).minimize(\n cost, global_step=global_step)\n else:\n gd_op = tf.train.GradientDescentOptimizer(lr).minimize(cost)\n\n saver = tf.train.Saver()\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n # We need to maintain the intialization sequence.\n #for v in tf.trainable_variables():\n # sess.run(tf.variables_initializer([v]))\n #sess.run(tf.global_variables_initializer())\n \n ##### NEED DIS TO LOAD MODEL PLS.\n saver.restore(sess, tf.train.latest_checkpoint(save_path))\n\n sess.run(init_ops)\n\n start_time = time.time()\n prev_time = start_time\n filename = \"client-\" + str(self.index) + \"-results-0.json\"\n log_path = os.path.join(save_path, filename)\n print(log_path)\n target_eps = [float(s) for s in TFFLAGS.target_eps.split(\",\")]\n max_target_eps = max(target_eps)\n\n lot_size = TFFLAGS.batches_per_lot * TFFLAGS.batch_size\n lots_per_epoch = self.num_training_images / lot_size\n for step in range(TFFLAGS.num_training_steps):\n epoch = step / lots_per_epoch\n curr_lr = utils.VaryRate(TFFLAGS.lr, TFFLAGS.end_lr,\n TFFLAGS.lr_saturate_epochs, epoch)\n curr_eps = utils.VaryRate(TFFLAGS.eps, TFFLAGS.end_eps,\n TFFLAGS.eps_saturate_epochs, epoch)\n for _ in range(TFFLAGS.batches_per_lot):\n _ = sess.run(\n [gd_op], feed_dict={lr: curr_lr, eps: curr_eps, delta: TFFLAGS.delta})\n sys.stderr.write(\"step: %d\\n\" % step)\n\n # See if we should stop training due to exceeded privacy budget:\n should_terminate = False\n terminate_spent_eps_delta = None\n if with_privacy and TFFLAGS.terminate_based_on_privacy:\n terminate_spent_eps_delta = priv_accountant.get_privacy_spent(\n sess, target_eps=[max_target_eps])[0]\n # For the Moments accountant, we should always have\n # spent_eps == max_target_eps.\n if (terminate_spent_eps_delta.spent_delta > TFFLAGS.target_delta or\n terminate_spent_eps_delta.spent_eps > max_target_eps):\n should_terminate = True\n\n if (eval_steps > 0 and (step + 1) % eval_steps == 0) or should_terminate:\n if with_privacy:\n spent_eps_deltas = priv_accountant.get_privacy_spent(\n sess, target_eps=target_eps)\n else:\n spent_eps_deltas = [accountant.EpsDelta(0, 0)]\n for spent_eps, spent_delta in spent_eps_deltas:\n sys.stderr.write(\"spent privacy: eps %.4f delta %.5g\\n\" % (\n spent_eps, spent_delta))\n path = save_path + \"/model%s.ckpt\"%self.client\n saver.save(sess, save_path=path)\n train_accuracy, _ = self.Eval(cifar_train_file, network_parameters,\n num_testing_images=self.num_testing_images,\n randomize=True, load_path=TFFLAGS.save_path)\n sys.stderr.write(\"train_accuracy: %.2f\\n\" % train_accuracy)\n \n curr_time = time.time()\n elapsed_time = curr_time - prev_time\n prev_time = curr_time\n \n self.results.append({\"step\": step+1, # Number of lots trained so far.\n \"elapsed_secs\": elapsed_time,\n \"spent_eps_deltas\": spent_eps_deltas,\n \"train_accuracy\": train_accuracy})\n loginfo = {\"elapsed_secs\": curr_time-start_time,\n \"spent_eps_deltas\": spent_eps_deltas,\n \"train_accuracy\": train_accuracy,\n \"num_training_steps\": step+1, # Steps so far.\n \"result_series\": self.results}\n loginfo.update(params)\n if log_path:\n with tf.gfile.Open(log_path, \"w\") as f:\n json.dump(loginfo, f, indent=2)\n f.write(\"\\n\")\n f.close()\n if should_terminate:\n for t in tf.trainable_variables():\n weights.append(t.eval(session=sess))\n break\n for t in tf.trainable_variables():\n weights.append(t.eval(session=sess))\n \n coord.request_stop()\n coord.join(threads)","def run_crnet(model, epoch=100):\n criterion = CRLoss()\n\n optimizer_ft = optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-5)\n exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=50, gamma=0.1)\n\n print('start loading SCUTFBP5500 dataset...')\n train_loader, test_loader = data_loader.load_scutfbp5500_data()\n train_model_with_crloss(model=model, train_dataloader=train_loader, test_dataloader=test_loader,\n criterion=criterion, optimizer=optimizer_ft, scheduler=exp_lr_scheduler, num_epochs=epoch,\n inference=False)","def resnet50_cifar10(pretrained=True, progress=True, use_data_parallel=False, **kwargs):\n return _model('resnet50_cifar10', resnet50, pretrained, progress, use_data_parallel, **kwargs)","def train(self):\n # Track initial loss/accuracy\n self.validation_epoch()\n for epoch in range(self.epochs):\n # Perform a full pass through all the training samples\n for batch_it, (X_batch, Y_batch) in enumerate(self.dataloader_train):\n # X_batch is the CIFAR10 images. Shape: [batch_size, 3, 32, 32]\n # Y_batch is the CIFAR10 image label. Shape: [batch_size]\n # Transfer images / labels to GPU VRAM, if possible\n X_batch = to_cuda(X_batch)\n Y_batch = to_cuda(Y_batch)\n\n # Perform the forward pass\n predictions = self.model(X_batch)\n # Compute the cross entropy loss for the batch\n loss = self.loss_criterion(predictions, Y_batch)\n\n # Backpropagation\n loss.backward()\n\n # Gradient descent step\n self.optimizer.step()\n \n # Reset all computed gradients to 0\n self.optimizer.zero_grad()\n # Compute loss/accuracy for all three datasets.\n if batch_it % self.validation_check == 0:\n self.validation_epoch()\n # Check early stopping criteria.\n if self.should_early_stop():\n print(\"Early stopping.\")\n return","def train():\n\n ### DO NOT CHANGE SEEDS!\n # Set the random seeds for reproducibility\n np.random.seed(42)\n epoch_num = 3\n ########################\n # PUT YOUR CODE HERE #\n #######################\n model = ConvNet(3, 10)\n\n #Obtain Dataset\n train_dataset = cifar10_utils.get_cifar10()['train']\n val_dataset = cifar10_utils.get_cifar10()['validation']\n test_dataset = cifar10_utils.get_cifar10()['test']\n\n train_loader = torch.utils.data.DataLoader(\n train_dataset,\n batch_size = BATCH_SIZE_DEFAULT,\n drop_last = True)\n\n criterion = nn.CrossEntropyLoss()\n optimizer = torch.optim.Adam(model.parameters())\n for epoch in range(epoch_num):\n model.train()\n losses = []\n accs = []\n for i_iter in range(int(train_dataset.num_examples/BATCH_SIZE_DEFAULT)):\n images, labels = train_dataset.next_batch(BATCH_SIZE_DEFAULT)\n images, labels = torch.tensor(images), torch.tensor(labels, dtype = torch.long)\n pred = model(images)\n labels = torch.argmax(labels, dim=1)\n loss = criterion(pred, labels)\n pred_result = torch.argmax(pred, dim=1)\n acc = accuracy(pred_result, labels)\n accs.append(acc)\n model.zero_grad()\n loss.backward()\n optimizer.step()\n losses.append(loss)\n if i_iter % 100 ==0:\n msg = 'Epoch:[{}/{}] Iter: [{}/{}], Loss: {: .6f}, ACC:[{: .6f}]'.format(epoch, epoch_num, i_iter, int(train_dataset.num_examples/BATCH_SIZE_DEFAULT), sum(losses)/len(losses), sum(accs)/len(accs))\n print(msg)\n with open('./log.txt', 'a') as f:\n f.write(msg)\n f.write('\\n')\n msg_epoch = '--------Epoch: [{}/{}], Loss: {: .6f}, ACC:[{: .6f}]-------'.format(epoch, epoch_num, sum(losses)/len(losses), sum(accs)/len(accs))\n print(msg_epoch)\n with open('./log.txt', 'a') as f:\n f.write(msg)\n f.write('\\n')\n #raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################","def run(self):\n params = self.params\n\n # load data\n self.data = self.load_data()\n # check if loaded classification data set is using the same dict as pretrained model\n if not self.data['dico'] == self._embedder.dico:\n self.compare_dict(self.data['dico'], self._embedder.dico)\n raise Exception((\"Dictionary in evaluation data (%i words) seems different than the one \" +\n \"in the pretrained model (%i words). Please verify you used the same dictionary, \" +\n \"and the same values for max_vocab and min_count.\") % (len(self.data['dico']),\n len(self._embedder.dico)))\n\n # embedder\n self.encoder = copy.deepcopy(self._embedder)\n self.encoder.cuda()\n\n # projection layer: CHANGE 3 to your number of classes output\n self.proj = nn.Sequential(*[\n nn.Dropout(params.dropout),\n nn.Linear(self.encoder.out_dim, params.clf_output_dim)\n ]).cuda()\n\n # optimizers: use different optimizers to tune embedding layer and projection layer\n self.optimizer_e = get_optimizer(list(self.encoder.get_parameters(params.finetune_layers)), params.optimizer_e)\n self.optimizer_p = get_optimizer(self.proj.parameters(), params.optimizer_p)\n best_acc = 0\n eval_metric = \"CLF_valid_en_acc\"\n # train and evaluate the model\n for epoch in range(params.n_epochs):\n # update epoch\n self.epoch = epoch\n\n # training\n logger.info(\"CLF - Training epoch %i ...\" % epoch)\n self.train()\n\n # evaluation\n logger.info(\"CLF - Evaluating epoch %i ...\" % epoch)\n with torch.no_grad():\n scores = self.eval()\n if scores[eval_metric] > best_acc:\n logger.info('New best score for %s: %.6f' % (eval_metric, scores[eval_metric]))\n self.save_checkpoint('best-%s' % eval_metric)\n self.decrease_counts = 0\n best_acc = scores[eval_metric]\n else:\n logger.info(\"Not a better validation score (%i / %i).\"\n % (self.decrease_counts, self.decrease_counts_max))\n self.decrease_counts += 1\n if self.decrease_counts > self.decrease_counts_max:\n logger.info(\"Stopping criterion has been below its best value for more \"\n \"than %i epochs. Ending the experiment...\" % self.decrease_counts_max)\n exit()\n self.scores.update(scores)","def train_resnet():\n\n # load data\n training_sets = load_augmented_dataset()\n\n # build models\n model_resnet = build_resnetv2()\n\n baseWeights_t = model_resnet.get_weights()\n\n for training_set in training_sets:\n print(\" Starting training for set {}\".format(str(training_set)))\n model_resnet.set_weights(baseWeights_t) # Resets model\n train_x = np.load(os.path.join(\"./model_cache/train_data\", training_sets[training_set][0]))\n train_y = np.load(os.path.join(\"./model_cache/train_data\", training_sets[training_set][1]))\n\n early_stopping_monitor = EarlyStopping(patience=3)\n history = model_resnet.fit(train_x, train_y, batch_size=32, epochs=40, verbose=1, validation_split=0.2,\n shuffle=True,\n callbacks=[early_stopping_monitor])\n\n mpu.plot_accuracy_loss(history,\n \"./model_cache/train_data/{}_resnet_plots.png\".format(str(training_set)))\n\n upload_blob(BUCKET_NAME, \"./model_cache/train_data/{}_resnet_plots.png\".format(str(training_set)),\n \"model_charts/{}_resnet_plots.png\".format(str(training_set)))\n\n model_resnet.save(\"./model_cache/train_data/{}_resnet.h5\".format(str(training_set)))\n\n upload_blob(BUCKET_NAME, \"./model_cache/train_data/{}_resnet.h5\".format(str(training_set)),\n \"saved_models/{}_resnet.h5\".format(str(training_set)))","def train(self):\n best_loss = math.inf\n for _ in range(self.epoch, self.end_epoch):\n self.summary_writer.add_scalar('epoch', self.epoch, self.total_steps)\n epoch_loss, _ = self.run_epoch(self.dataloader)\n if epoch_loss < best_loss:\n best_loss = epoch_loss\n # save best module as onnx format\n dummy_input = torch.randn((10, 3, self.image_dim, self.image_dim))\n module_path = os.path.join(self.models_dir, 'resnet.onnx')\n self.save_module(\n self.resnet.module, module_path, save_onnx=True, dummy_input=dummy_input)\n self.save_checkpoint('resnet_e{}_state.pth'.format(self.epoch))\n\n # validate step\n val_loss, _ = self.validate()\n\n # update learning rates\n self.lr_scheduler.step(val_loss)\n self.save_learning_rate(self.summary_writer, self.optimizer, self.total_steps)\n self.epoch += 1\n self.test()","def load_CIFAR10(ROOT):\r\n xs = []\r\n ys = []\r\n for b in range(1,6):\r\n f = os.path.join(ROOT, 'data_batch_%d' % (b, ))\r\n X, Y = load_CIFAR_batch(f)\r\n xs.append(X)\r\n ys.append(Y)\r\n Xtr = np.concatenate(xs)\r\n Ytr = np.concatenate(ys)\r\n del X, Y\r\n Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))\r\n return Xtr, Ytr, Xte, Yte\r\n\r\n\tdef get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=10000):\r\n # Load the raw CIFAR-10 data\r\n \r\n cifar10_dir = 'Downloads/cifar-10-batches-py'\r\n \r\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\r\n\r\n # Subsample the data\r\n mask = range(num_training, num_training + num_validation)\r\n X_val = X_train[mask]\r\n y_val = y_train[mask]\r\n mask = range(num_training)\r\n X_train = X_train[mask]\r\n y_train = y_train[mask]\r\n mask = range(num_test)\r\n X_test = X_test[mask]\r\n y_test = y_test[mask]\r\n\r\n x_train = X_train.astype('float32') \r\n x_test = X_test.astype('float32')\r\n \r\n x_train = x_train.reshape(-1, 32, 32, 3)\r\n x_test = x_test.reshape(-1, 32, 32, 3)\r\n x_train /= 255\r\n x_test /= 255\r\n\r\n return x_train, y_train, X_val, y_val, x_test, y_test","def __init__(self, **kwargs):\n super(CIFAR10Classifier, self).__init__() #pylint: disable=super-with-arguments\n self.model_conv = models.resnet50(pretrained=True)\n for param in self.model_conv.parameters():\n param.requires_grad = False\n num_ftrs = self.model_conv.fc.in_features\n num_classes = 10\n self.model_conv.fc = nn.Linear(num_ftrs, num_classes)\n\n self.scheduler = None\n self.optimizer = None\n self.args = kwargs\n\n self.train_acc = Accuracy()\n self.val_acc = Accuracy()\n self.test_acc = Accuracy()\n\n self.preds = []\n self.target = []\n self.example_input_array = torch.rand((1, 3, 64, 64))","def eval(self):\n self.train(mode=False)","def train_crf(threads=3, hyperparameter_crf='1.5', cut_off='5', alg='CRF-L2'):\n\n print '\\n\\ttrain crf'\n os.system('crf_learn -p ' + threads +\n ' -c ' + hyperparameter_crf +\n ' -f ' + cut_off +\n ' -a ' + alg +\n ' ' + template_file + ' ' + train_file_crf + ' ' + model_file)\n print '\\t--done\\n'","def train():\r\n with tf.Graph().as_default():\r\n global_step = tf.train.get_or_create_global_step()\r\n # Get images and labels for CIFAR-10.\r\n # Force input pipeline to CPU:0 to avoid operations sometimes ending up on\r\n # GPU and resulting in a slow down.\r\n with tf.device('/cpu:0'):\r\n signals, labels = cnnHAR.distorted_inputs()\r\n print('<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>')\r\n \r\n # Build a Graph that computes the logits predictions from the\r\n # inference model.\r\n #training = tf.placeholder(tf.bool)\r\n \r\n pool11=cnnHAR.inference_cov11(signals,'_01')\r\n reshape1=cnnHAR.inference_cov21(pool11,'_01')\r\n local21=cnnHAR.inference_local21(reshape1,'_01')\r\n local31=cnnHAR.inference_local31(local21,'_01')\r\n local41=cnnHAR.inference_local41(local31,'_01')\r\n logits1=cnnHAR.inference_output1(local41,'_01')\r\n \r\n \r\n pool12=cnnHAR.inference_cov11(signals,'_02')\r\n reshape2=cnnHAR.inference_cov21(pool12,'_02')\r\n local22=cnnHAR.inference_local21(reshape2,'_02')\r\n local32=cnnHAR.inference_local31(local22,'_02')\r\n local42=cnnHAR.inference_local41(local32,'_02')\r\n logits2=cnnHAR.inference_output1(local42,'_02')\r\n \r\n \r\n pool13=cnnHAR.inference_cov11(signals,'_03')\r\n reshape3=cnnHAR.inference_cov21(pool13,'_03')\r\n local23=cnnHAR.inference_local21(reshape3,'_03')\r\n local33=cnnHAR.inference_local31(local23,'_03')\r\n local43=cnnHAR.inference_local41(local33,'_03')\r\n logits3=cnnHAR.inference_output1(local43,'_03')\r\n \r\n \r\n pool14=cnnHAR.inference_cov11(signals,'_04')\r\n reshape4=cnnHAR.inference_cov21(pool14,'_04')\r\n local24=cnnHAR.inference_local21(reshape4,'_04')\r\n local34=cnnHAR.inference_local31(local24,'_04')\r\n local44=cnnHAR.inference_local41(local34,'_04')\r\n logits4=cnnHAR.inference_output1(local44,'_04')\r\n\r\n \r\n pool15=cnnHAR.inference_cov11(signals,'_05')\r\n reshape5=cnnHAR.inference_cov21(pool15,'_05')\r\n local25=cnnHAR.inference_local21(reshape5,'_05')\r\n local35=cnnHAR.inference_local31(local25,'_05')\r\n local45=cnnHAR.inference_local41(local35,'_05')\r\n logits5=cnnHAR.inference_output1(local45,'_05')\r\n\r\n pool16=cnnHAR.inference_cov11(signals,'_06')\r\n reshape6=cnnHAR.inference_cov21(pool16,'_06')\r\n local26=cnnHAR.inference_local21(reshape6,'_06')\r\n local36=cnnHAR.inference_local31(local26,'_06')\r\n local46=cnnHAR.inference_local41(local36,'_06')\r\n logits6=cnnHAR.inference_output1(local46,'_06')\r\n \r\n\r\n loss1=cnnHAR.loss(logits1, labels,'_01')\r\n loss2=cnnHAR.loss(logits2, labels,'_02')\r\n loss3=cnnHAR.loss(logits3, labels,'_03')\r\n loss4=cnnHAR.loss(logits4, labels,'_04')\r\n loss5=cnnHAR.loss(logits5, labels,'_05')\r\n loss6=cnnHAR.loss(logits6, labels,'_06')\r\n \r\n train_op1 = cnnHAR.train(loss1, global_step,'_01')\r\n train_op2 = cnnHAR.train(loss2, global_step,'_02')\r\n train_op3 = cnnHAR.train(loss3, global_step,'_03')\r\n train_op4 = cnnHAR.train(loss4, global_step,'_04')\r\n train_op5 = cnnHAR.train(loss5, global_step,'_05')\r\n train_op6 = cnnHAR.train(loss6, global_step,'_06')\r\n \r\n \r\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\r\n class _LoggerHook(tf.train.SessionRunHook):\r\n \"\"\"Logs loss and runtime.\"\"\"\r\n\r\n def begin(self):\r\n self._step = -1\r\n self._start_time = time.time()\r\n\r\n def before_run(self, run_context):\r\n self._step += 1\r\n #print('~~~~~~~~~~~~~~~~before run1~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\r\n #tmp = tf.concat([labels,signals],1)\r\n \r\n index=int(self._step%(num*7)/7)\r\n if index==0:\r\n return tf.train.SessionRunArgs(loss1)\r\n elif index==1:\r\n return tf.train.SessionRunArgs(loss2)\r\n elif index==2:\r\n return tf.train.SessionRunArgs(loss3)\r\n elif index==3:\r\n return tf.train.SessionRunArgs(loss4)\r\n elif index==4:\r\n return tf.train.SessionRunArgs(loss5)\r\n elif index==5:\r\n return tf.train.SessionRunArgs(loss6)\r\n \r\n # Asks for loss value.\r\n\r\n def after_run(self, run_context, run_values):\r\n# if self._step == 1000:\r\n# #tf.Session().run(tf.global_variables_initializer())\r\n# ndar = np.array(run_values.results)\r\n# np.savetxt(\"logits.csv\", ndar.reshape(128,256), delimiter=\",\")\r\n \r\n if int((self._step-1) / log_frequency)%10==0 and (self._step%(num*7)+1)%7==0 and int(self._step%(num*7)/7)==0:#(self._step-1) % (log_frequency)== 0:\r\n #print('~~~~~~~~~~~~~~~~after run1~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\r\n '''\r\n current_time = time.time()\r\n duration = current_time - self._start_time\r\n self._start_time = current_time\r\n \r\n loss_value = run_values.results\r\n examples_per_sec = log_frequency * batch_size / duration\r\n sec_per_batch = float(duration / log_frequency)\r\n format_str = ('%s: step %d, loss = %.8f (%.1f examples/sec; %.3f '\r\n 'sec/batch)')\r\n '''\r\n format_str = ('%s: step %d loss%d=%0.8f')\r\n print(format_str % (datetime.now(), self._step+1, int(self._step%(num*7)/7)+1,run_values.results))\r\n \r\n class _LoggerHook2(tf.train.SessionRunHook):\r\n \"\"\"Logs signals.\"\"\"\r\n\r\n def begin(self):\r\n self._step = -1\r\n\r\n def before_run(self, run_context):\r\n self._step += 1\r\n #print('~~~~~~~~~~~~~~~~before run2~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\r\n return tf.train.SessionRunArgs(logits) # Asks for logits.\r\n\r\n def after_run(self, run_context, run_values):\r\n if self._step == max_steps-1:#:\r\n print('~~~~~~~~~~~~~~~~after run2~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\r\n ndar = np.array(run_values.results)\r\n np.savetxt(\"logits\"+str(self._step)+\".csv\", ndar.reshape(batch_size,NUM_CLASSES), delimiter=\",\")\r\n\r\n class _LoggerHook3(tf.train.SessionRunHook):\r\n \"\"\"Logs labels.\"\"\"\r\n\r\n def begin(self):\r\n self._step = -1\r\n\r\n def before_run(self, run_context):\r\n self._step += 1\r\n return tf.train.SessionRunArgs(labels) # Asks for labels.\r\n\r\n def after_run(self, run_context, run_values):\r\n if self._step == max_steps-1:\r\n ndar = np.array(run_values.results)\r\n np.savetxt(\"labels\"+str(self._step)+\".csv\", ndar.reshape(batch_size,NUM_CLASSES), delimiter=\",\")\r\n\r\n class _LoggerHook4(tf.train.SessionRunHook):\r\n \"\"\"Logs signals.\"\"\"\r\n\r\n def begin(self):\r\n self._step = -1\r\n\r\n def before_run(self, run_context):\r\n self._step += 1\r\n #print('~~~~~~~~~~~~~~~~before run4~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\r\n #return tf.train.SessionRunArgs(signals) # Asks for signals.\r\n\r\n def after_run(self, run_context, run_values):\r\n if (self._step+1)% (50*log_frequency) == 0:\r\n #if self._step == max_steps-1:#:\r\n #print('~~~~~~~~~~~~~~~~after run4~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\r\n cnnHAR_eval.main()\r\n\r\n with tf.train.MonitoredTrainingSession(\r\n checkpoint_dir=train_dir,\r\n hooks=[tf.train.StopAtStepHook(last_step=max_steps),\r\n #tf.train.NanTensorHook(loss),\r\n _LoggerHook(),\r\n #_LoggerHook2(),\r\n _LoggerHook4()],#,save_checkpoint_steps=5000\r\n config=tf.ConfigProto(\r\n log_device_placement=log_device_placement),save_checkpoint_steps=50*log_frequency) as mon_sess:\r\n ''',save_checkpoint_steps=10*log_frequency'''\r\n i=0\r\n while not mon_sess.should_stop():\r\n# mon_sess = tfdbg.LocalCLIDebugWrapperSession(mon_sess)\r\n #mon_sess.run([train_op1,extra_update_ops])\r\n #print('~~~~~~~~~~~~~~~~%d step:'%i)\r\n \r\n index=int(i%(num*7)/7)\r\n if index==0:\r\n #print('~~~~~~~~~~~~~~~~train_op1')\r\n mon_sess.run([train_op1,extra_update_ops])\r\n elif index==1:\r\n #print('~~~~~~~~~~~~~~~~train_op2')\r\n mon_sess.run([train_op2,extra_update_ops])\r\n elif index==2:\r\n #print('~~~~~~~~~~~~~~~~train_op3')\r\n mon_sess.run([train_op3,extra_update_ops])\r\n elif index==3:\r\n #print('~~~~~~~~~~~~~~~~train_op4')\r\n mon_sess.run([train_op4,extra_update_ops])\r\n elif index==4:\r\n #print('~~~~~~~~~~~~~~~~train_op5')\r\n mon_sess.run([train_op5,extra_update_ops])\r\n elif index==5:\r\n #print('~~~~~~~~~~~~~~~~train_op6')\r\n mon_sess.run([train_op6,extra_update_ops])\r\n '''\r\n elif index==6:\r\n #print('~~~~~~~~~~~~~~~~train_op1')\r\n mon_sess.run([train_op7,extra_update_ops])\r\n elif index==7:\r\n #print('~~~~~~~~~~~~~~~~train_op2')\r\n mon_sess.run([train_op8,extra_update_ops])\r\n elif index==8:\r\n #print('~~~~~~~~~~~~~~~~train_op3')\r\n mon_sess.run([train_op9,extra_update_ops])\r\n elif index==9:\r\n #print('~~~~~~~~~~~~~~~~train_op4')\r\n mon_sess.run([train_op10,extra_update_ops])\r\n elif index==10:\r\n #print('~~~~~~~~~~~~~~~~train_op5')\r\n mon_sess.run([train_op11,extra_update_ops])\r\n elif index==11:\r\n #print('~~~~~~~~~~~~~~~~train_op6')\r\n mon_sess.run([train_op12,extra_update_ops])\r\n '''\r\n i=i+1\r\n \r\n #print('~~~~~~~~~~~~~~~~one session ends~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\r","def run(self):\n for _ in range(self.epoch, conf.FX_MAX_EPOCHS):\n self.train()\n\n with torch.no_grad():\n self.test()\n\n self.epoch += 1\n self.save_ck()\n\n self.show_completion_msg()","def main():\r\n # assert tf.__version__[0] == \"2\"\r\n\r\n \"\"\" Load Config \"\"\"\r\n with open('./config/config_origin.json', 'r') as f:\r\n CONFIG = json.load(f)\r\n BATCH_SIZE = CONFIG[\"BATCH_SIZE\"]\r\n ROOT_PATH = CONFIG[\"ROOT_PATH\"]\r\n TRAIN_DATA_DIR = CONFIG[\"TRAIN_DATA_DIR\"]\r\n TEST_DATA_DIR = CONFIG[\"TEST_DATA_DIR\"]\r\n TRAIN_DATA_DIR = os.path.join(ROOT_PATH, TRAIN_DATA_DIR)\r\n TEST_DATA_DIR = os.path.join(ROOT_PATH, TEST_DATA_DIR)\r\n MODEL_CKPT = CONFIG[\"MODEL_CKPT\"]\r\n\r\n \"\"\" Prepare Model \"\"\"\r\n n = 6 # order of ResNetv2\r\n version = 2\r\n depth = model_depth(n, version)\r\n MODEL_TYPE = 'ResNet%dv%d' % (depth, version)\r\n SAVES_DIR = \"models-%s/\" % MODEL_TYPE\r\n SAVES_DIR = os.path.join(ROOT_PATH, SAVES_DIR)\r\n MODEL_CKPT = os.path.join(SAVES_DIR, MODEL_CKPT)\r\n\r\n # Features directory\r\n FEATURE_DIR = os.path.join(ROOT_PATH, \"features\")\r\n FEATURE_DIR = os.path.join(FEATURE_DIR, \"models-%s/\" % MODEL_TYPE)\r\n if not os.path.exists(FEATURE_DIR):\r\n os.mkdir(FEATURE_DIR)\r\n\r\n if not os.path.exists(SAVES_DIR):\r\n os.mkdir(SAVES_DIR)\r\n model = resnet_v2(input_shape=INPUT_SHAPE, depth=depth, num_classes=2)\r\n model.compile(loss='categorical_crossentropy',\r\n optimizer=Adam(learning_rate=lr_schedule(TRAINING_EPOCHS)),\r\n metrics=METRICS)\r\n # model.summary()\r\n print(MODEL_TYPE)\r\n\r\n \"\"\" Load Weights \"\"\"\r\n model_ckpt_file = os.path.join(SAVES_DIR, MODEL_CKPT)\r\n if os.path.exists(model_ckpt_file):\r\n print(\"Model ckpt found! Loading...:%s\" % model_ckpt_file)\r\n model.load_weights(model_ckpt_file)\r\n\r\n \"\"\" Extract Testing Data \"\"\"\r\n _train_filenames = os.listdir(os.path.join(TRAIN_DATA_DIR, \"bad_1\"))\r\n train_bad_df = pd.DataFrame({\r\n 'filename': _train_filenames\r\n })\r\n n_bad_samples = train_bad_df.shape[0]\r\n train_bad_df.to_csv(os.path.join(\r\n FEATURE_DIR, \"bad_samples_list.csv\"), index=False)\r\n\r\n \"\"\" Extract good samples \"\"\"\r\n _train_filenames = os.listdir(os.path.join(TRAIN_DATA_DIR, \"good_0\"))\r\n train_good_df = pd.DataFrame({\r\n 'filename': _train_filenames\r\n })\r\n n_good_samples = train_good_df.shape[0]\r\n train_good_df.to_csv(os.path.join(\r\n FEATURE_DIR, \"good_samples_list.csv\"), index=False)\r\n\r\n \"\"\" Create bad sample validation generator \"\"\"\r\n train_bad_datagen = ImageDataGenerator(rescale=1./255)\r\n train_bad_generator = train_bad_datagen.flow_from_dataframe(\r\n train_bad_df,\r\n os.path.join(TRAIN_DATA_DIR, \"bad_1\"),\r\n x_col='filename',\r\n y_col=None,\r\n class_mode=None,\r\n target_size=IMAGE_SIZE,\r\n color_mode=\"grayscale\",\r\n batch_size=BATCH_SIZE,\r\n shuffle=False\r\n )\r\n\r\n \"\"\" Create bad sample validation generator \"\"\"\r\n train_good_datagen = ImageDataGenerator(rescale=1./255)\r\n train_good_generator = train_good_datagen.flow_from_dataframe(\r\n train_good_df,\r\n os.path.join(TRAIN_DATA_DIR, \"good_0\"),\r\n x_col='filename',\r\n y_col=None,\r\n class_mode=None,\r\n target_size=IMAGE_SIZE,\r\n color_mode=\"grayscale\",\r\n batch_size=BATCH_SIZE,\r\n shuffle=False\r\n )\r\n\r\n \"\"\" Extractor \"\"\"\r\n extractor = Model(\r\n model.inputs, model.layers[-2].output) # flatten_2 (Flatten) (None, 12544)\r\n # features = extractor.predict(data)\r\n\r\n \"\"\" Extract train set 的特征 \"\"\"\r\n import time\r\n # bad samples\r\n start = time.perf_counter()\r\n print(\"Start extracting bad samples...\")\r\n features = extractor.predict_generator(\r\n train_bad_generator, steps=np.ceil(n_bad_samples / BATCH_SIZE),\r\n workers=4, verbose=1)\r\n print(\"features.shape:\", features.shape) # (16/32/etc, 12544)\r\n np.save(os.path.join(FEATURE_DIR, \"features_train_bad.npy\"), features)\r\n\r\n elapsed = (time.perf_counter() - start)\r\n print(\"Prediction time used:\", elapsed)\r\n # TODO 用 pandas 存储\r\n # good samples\r\n start = time.perf_counter()\r\n print(\"Start extracting good samples...\")\r\n features = extractor.predict_generator(\r\n train_good_generator, steps=np.ceil(n_good_samples / BATCH_SIZE),\r\n workers=4, verbose=1)\r\n print(\"features.shape:\", features.shape) # (16/32/etc, 12544)\r\n np.save(os.path.join(FEATURE_DIR, \"features_train_good.npy\"), features)\r\n\r\n elapsed = (time.perf_counter() - start)\r\n print(\"Prediction time used:\", elapsed)","def get_cifar10_cnn():\n # Set defaults.\n nb_classes = 10 #dataset dependent \n batch_size = 128\n epochs = 4\n \n # the data, shuffled and split between train and test sets\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\n \n # convert class vectors to binary class matrices\n y_train = to_categorical(y_train, nb_classes)\n y_test = to_categorical(y_test, nb_classes)\n\n #x._train shape: (50000, 32, 32, 3)\n #input shape (32, 32, 3)\n input_shape = x_train.shape[1:]\n\n #print('x_train shape:', x_train.shape)\n #print(x_train.shape[0], 'train samples')\n #print(x_test.shape[0], 'test samples')\n #print('input shape', input_shape)\n \n x_train = x_train.astype('float32')\n x_test = x_test.astype('float32')\n x_train /= 255\n x_test /= 255\n\n return (nb_classes, batch_size, input_shape, x_train, x_test, y_train, y_test, epochs)","def train():\n\n ### DO NOT CHANGE SEEDS!\n # Set the random seeds for reproducibility\n np.random.seed(42)\n\n ## Prepare all functions\n # Get number of units in each hidden layer specified in the string such as 100,100\n if FLAGS.dnn_hidden_units:\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\",\")\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\n else:\n dnn_hidden_units = []\n\n # Get negative slope parameter for LeakyReLU\n neg_slope = FLAGS.neg_slope\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n import matplotlib.pyplot as plt\n\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\n train = data['train']\n test = data['test']\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\n\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\n loss_module = CrossEntropyModule()\n\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n\n images_test = test.images\n labels_test = test.labels\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\n\n for i in range(0, FLAGS.max_steps):\n if PRINTS:\n print('iter', i+1, end='\\r')\n images, labels = train.next_batch(FLAGS.batch_size) \n images = np.reshape(images, (images.shape[0], dim_x))\n\n pred = mlp.forward(images)\n loss = loss_module.forward(pred, labels)\n loss_grad = loss_module.backward(pred, labels)\n mlp.backward(loss_grad)\n\n for module in reversed(mlp.modules):\n if isinstance(module, LinearModule):\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\n if (i+1) % FLAGS.eval_freq == 0:\n pred_test = mlp.forward(images_test)\n loss_train[i // FLAGS.eval_freq] = loss\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\n if PRINTS:\n print()\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\n\n if PLOTS:\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\n fig.suptitle('Training curves for Numpy MLP\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\n\n ax[0].set_title('Loss')\n ax[0].set_ylabel('Loss value')\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[0].plot(loss_train, label='Train')\n ax[0].plot(loss_test, label='Test')\n ax[0].legend()\n\n ax[1].set_title('Accuracy')\n ax[1].set_ylabel('Accuracy value')\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[1].plot(accuracy_test, label='Test')\n ax[1].legend()\n plt.show()\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def train_and_eval_eccv(train, test):\n train_vec = list()\n train_label = list()\n test_vec = list()\n test_label = list()\n\n for k, v in train.items():\n feature = np.concatenate((extract_feature(k, layer_name=\"conv5_2\"), extract_feature(k, layer_name=\"conv5_3\")),\n axis=0)\n train_vec.append(feature)\n train_label.append(v)\n\n for k, v in test.items():\n feature = np.concatenate((extract_feature(k, layer_name=\"conv5_2\"), extract_feature(k, layer_name=\"conv5_3\")),\n axis=0)\n test_vec.append(feature)\n test_label.append(v)\n\n reg = linear_model.BayesianRidge()\n reg.fit(np.array(train_vec), np.array(train_label))\n mkdirs_if_not_exist('./model')\n joblib.dump(reg, config['eccv_fbp_reg_model'])\n\n predicted_label = reg.predict(np.array(test_vec))\n mae_lr = round(mean_absolute_error(np.array(test_label), predicted_label), 4)\n rmse_lr = round(math.sqrt(mean_squared_error(np.array(test_label), predicted_label)), 4)\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\n\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\n\n csv_tag = time.time()\n\n mkdirs_if_not_exist('./result')\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\n df.to_csv('./result/performance_%s.csv' % csv_tag, index=False)\n\n out_result(list(test.keys()), predicted_label.flatten().tolist(), test_label, None,\n path='./result/detail_%s.csv' % csv_tag)","def train():\n ### DO NOT CHANGE SEEDS!\n # Set the random seeds for reproducibility\n np.random.seed(42)\n\n ## Prepare all functions\n # Get number of units in each hidden layer specified in the string such as 100,100\n if FLAGS.dnn_hidden_units:\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\",\")\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\n else:\n dnn_hidden_units = []\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n model = MLP(n_hidden=dnn_hidden_units,n_classes=10,batch_size=FLAGS.batch_size, input_dim=32*32*3, \n weight_decay=FLAGS.weight_reg_strength, weight_scale=FLAGS.weight_init_scale)\n\n Datasets = utils.get_cifar10(data_dir = DATA_DIR_DEFAULT, one_hot = True, validation_size = 0)\n \n for i in range(1500): #(FLAGS.max_steps):\n train_batch = Datasets.train.next_batch(batch_size = FLAGS.batch_size)\n #Get the model output\n logits = model.inference(x=train_batch[0].reshape([FLAGS.batch_size,32*32*3]))\n #Get the loss and let the model set the loss derivative.\n loss = model.loss(logits=logits, labels=train_batch[1])\n #Perform training step\n model.train_step(loss=loss, flags=FLAGS)\n\n #Every 100th iteratin print accuracy on the whole test set.\n if i % 100 == 0:\n # for layer in model.layers:\n test_batch = Datasets.test.next_batch(batch_size = 200) #Datasets.test.num_examples\n logits = model.inference(x=test_batch[0].reshape([200,32*32*3]))\n print('-- Step: ', i, \" accuracy: \",model.accuracy(logits=logits,labels=test_batch[1]),'loss', loss )\n\n ########################\n # END OF YOUR CODE #\n #######################","def catlin_run(workdir, cycles, cyclesize, gpuid = 0, max_testimages = 100000000000):\n\n # load val-data for evaluation\n pyparams = pload(osp.join(workdir, 'valpyparams.pkl'))\n imlist = [line.rstrip() for line in open(osp.join(workdir, 'vallist.txt'))][:max_testimages]\n with open(osp.join(workdir, 'valdict.json')) as f:\n imdict = json.load(f)\n\n # run\n for i in range(cycles):\n bct.run(workdir, gpuid = gpuid, nbr_iters = cyclesize)\n _ = bct.classify_from_patchlist_wrapper(imlist, imdict, pyparams, workdir, gpuid = gpuid, save = True, net_prototxt = 'valnet.prototxt')\n\n # find and load optimal model\n bestiter, _ = find_best_iter(workdir)\n caffemodel = 'snapshot_iter_{}.caffemodel'.format(bestiter)\n net = bct.load_model(workdir, caffemodel, gpuid = gpuid, net_prototxt = 'testnet.prototxt')\n\n # load test-data\n pyparams = pload(osp.join(workdir, 'testpyparams.pkl'))\n imlist = [line.rstrip() for line in open(osp.join(workdir, 'testlist.txt'))][:max_testimages]\n with open(osp.join(workdir, 'testdict.json')) as f:\n imdict = json.load(f)\n\n # run on test-data\n (gtlist, estlist, scorelist) = bct.classify_from_patchlist(imlist, imdict, pyparams, net)\n psave((gtlist, estlist, scorelist), osp.join(workdir, 'predictions_on_test.p'))","def load_cifar(hparams):\n all_labels = []\n\n total_batches_to_load = 5\n assert hparams.train_size + hparams.validation_size <= 50000\n if hparams.eval_test:\n total_batches_to_load += 1\n # Determine how many images we have loaded\n total_dataset_size = 50000\n train_dataset_size = total_dataset_size\n if hparams.eval_test:\n total_dataset_size += 10000\n\n if hparams.dataset == 'cifar10':\n all_images = []\n elif hparams.dataset == 'cifar100':\n all_images = np.empty((1, 50000, 3072), dtype=np.uint8)\n if hparams.eval_test:\n test_data = np.empty((1, 10000, 3072), dtype=np.uint8)\n if hparams.dataset == 'cifar10':\n datafiles = [\n 'data_batch_1', 'data_batch_2', 'data_batch_3', 'data_batch_4',\n 'data_batch_5']\n\n if hparams.eval_test:\n datafiles.append('test_batch')\n num_classes = 10\n elif hparams.dataset == 'cifar100':\n datafiles = ['train']\n if hparams.eval_test:\n datafiles.append('test')\n num_classes = 100\n else:\n raise NotImplementedError('Unimplemented dataset: ', hparams.dataset)\n if hparams.dataset != 'test':\n for file_num, f in enumerate(datafiles):\n d = unpickle(os.path.join(hparams.data_path, f))\n if hparams.dataset == 'cifar10':\n labels = np.array(d['labels'])\n else:\n labels = np.array(d['fine_labels'])\n if f == 'test':\n test_data[0] = copy.deepcopy(d['data'])\n if hparams.dataset == 'cifar10':\n all_images.append(test_data)\n else:\n all_images = np.concatenate([all_images, test_data], axis=1)\n else:\n if hparams.dataset == 'cifar10':\n all_images.append(copy.deepcopy(d['data']))\n else:\n all_images[file_num] = copy.deepcopy(d['data'])\n nsamples = len(labels)\n for idx in range(nsamples):\n all_labels.append(labels[idx])\n if hparams.dataset == 'cifar10':\n all_images = np.concatenate(all_images, axis=0)\n all_images = all_images.reshape(-1, 3072)\n all_images = all_images.reshape(-1, 3, 32, 32) # pylint: disable=too-many-function-args\n all_images = all_images.transpose(0, 2, 3, 1).copy()\n all_images = all_images / 255.0\n mean = augmentation_transforms.MEANS\n std = augmentation_transforms.STDS\n tf.logging.info('mean:{} std: {}'.format(mean, std))\n all_images = (all_images - mean) / std\n all_labels = np.eye(num_classes)[np.array(all_labels, dtype=np.int32)]\n\n assert len(all_images) == len(all_labels)\n tf.logging.info(\n 'In CIFAR10 loader, number of images: {}'.format(len(all_images)))\n\n extra_test_images = None\n extra_test_labels = None\n if hparams.extra_dataset == 'cifar10_1':\n extra_test_ds = tfds.as_numpy(\n tfds.load('cifar10_1', split='test', batch_size=-1))\n extra_test_images = ((extra_test_ds['image'] / 255.0) - mean) / std\n extra_test_labels = np.eye(num_classes)[np.array(\n extra_test_ds['label'], dtype=np.int32)]\n\n # Break off test data\n if hparams.eval_test:\n test_images = all_images[train_dataset_size:]\n test_labels = all_labels[train_dataset_size:]\n else:\n test_images = []\n test_labels = []\n all_images = all_images[:train_dataset_size]\n all_labels = all_labels[:train_dataset_size]\n return all_images, all_labels, test_images, test_labels, extra_test_images, extra_test_labels","def train_and_evaluate(self) -> None:\n with tf.Session() as self.sess:\n # Initialize computation graph.\n self.create_model()\n\n # Initialize variables.\n tf.global_variables_initializer().run()\n\n # Initialize summary writer.\n self.writer = tf.summary.FileWriter(logdir='conv_vis')\n\n for epoch_no in range(self.nb_epochs):\n # Train model on next batch\n batch_x, batch_y = self.mnist.train.next_batch(self.mb_size)\n results = self.train_on_batch(batch_x, batch_y, global_step=epoch_no)\n\n if epoch_no > 0 and epoch_no % self.lr_decay_time == 0:\n # Test on all samples.\n self.test_on_all()\n # Perform learning rate decay.\n self.learning_rate /= 2\n if epoch_no % 100 == 0:\n self.logger.info(\"Epoch {0}: Loss: {1[0]}, accuracy: {1[1]}\".format(epoch_no, results))\n batch_x_t, batch_y_t = self.mnist.test.next_batch(self.mb_size)\n test_results = self.test_on_batch(batch_x_t, batch_y_t)\n self.logger.info(\"(Test(batch): Loss: {0[0]}, accuracy: {0[1]}\".format(test_results))\n self.test_on_all()\n\n # Save the trained model with all valuable variables.\n saver = tf.train.Saver()\n saver.save(sess=self.sess, save_path='./saved_model', global_step=epoch_no)","def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n # Load the raw CIFAR-10 data\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n\n # subsample the data\n mask = range(num_training, num_training + num_validation)\n X_val = X_train[mask]\n y_val = y_train[mask]\n mask = range(num_training)\n X_train = X_train[mask]\n y_train = y_train[mask]\n mask = range(num_test)\n X_test = X_test[mask]\n y_test = y_test[mask]\n mask = np.random.choice(num_training, num_dev, replace=False)\n X_dev = X_train[mask]\n y_dev = y_train[mask]\n\n # Preprocessing: reshape the image data into rows\n X_train = np.reshape(X_train, (X_train.shape[0], -1))\n X_val = np.reshape(X_val, (X_val.shape[0], -1))\n X_test = np.reshape(X_test, (X_test.shape[0], -1))\n X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n\n # Normalize the data: subtract the mean image\n mean_image = np.mean(X_train, axis=0)\n X_train -= mean_image\n X_val -= mean_image\n X_test -= mean_image\n X_dev -= mean_image\n\n # add bias dimension and transform into columns\n X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n\n return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev","def build_resnet50(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\n conv1_feats = nonlinear(conv1_feats, 'relu')\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\n\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\n \n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128)\n res3b_feats = self.basic_block2(res3a_feats, 'res3b', 'bn3b', is_train, use_batch_norm, 128)\n res3c_feats = self.basic_block2(res3b_feats, 'res3c', 'bn3c', is_train, use_batch_norm, 128)\n res3d_feats = self.basic_block2(res3c_feats, 'res3d', 'bn3d', is_train, use_batch_norm, 128)\n\n res4a_feats = self.basic_block(res3d_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\n res4b_feats = self.basic_block2(res4a_feats, 'res4b', 'bn4b', is_train, use_batch_norm, 256)\n res4c_feats = self.basic_block2(res4b_feats, 'res4c', 'bn4c', is_train, use_batch_norm, 256)\n res4d_feats = self.basic_block2(res4c_feats, 'res4d', 'bn4d', is_train, use_batch_norm, 256)\n res4e_feats = self.basic_block2(res4d_feats, 'res4e', 'bn4e', is_train, use_batch_norm, 256)\n res4f_feats = self.basic_block2(res4e_feats, 'res4f', 'bn4f', is_train, use_batch_norm, 256)\n\n res5a_feats = self.basic_block(res4f_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\n\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\n self.conv_feats = res5c_feats_flat\n self.conv_feat_shape = [49, 2048]\n self.num_ctx = 49 \n self.dim_ctx = 2048\n\n self.imgs = imgs\n self.is_train = is_train","def train_model_with_crloss(model, train_dataloader, test_dataloader, criterion, optimizer, scheduler, num_epochs=25,\n inference=False):\n model = model.float()\n device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n\n if torch.cuda.device_count() > 1:\n print(\"Let's use\", torch.cuda.device_count(), \"GPUs!\")\n model = nn.DataParallel(model)\n model = model.to(device)\n\n if not inference:\n model.train()\n print('Start training CRNet...')\n for epoch in range(num_epochs):\n scheduler.step()\n\n running_loss = 0.0\n for i, data in enumerate(train_dataloader, 0):\n inputs, scores, classes = data['image'], data['label'], data['class']\n\n inputs = inputs.to(device)\n scores = scores.to(device)\n classes = classes.to(device)\n\n optimizer.zero_grad()\n\n inputs = inputs.float()\n # scores = scores.float().view(cfg['batch_size'], -1)\n # classes = classes.int().view(cfg['batch_size'], 3)\n\n reg_out, cls_out = model(inputs)\n loss = criterion(cls_out, classes, reg_out, scores.float().unsqueeze(-1))\n loss.backward()\n optimizer.step()\n\n # print statistics\n running_loss += loss.item()\n if i % 10 == 9: # print every 10 mini-batches\n print('[%d, %5d] loss: %.3f' %\n (epoch + 1, i + 1, running_loss / 10))\n running_loss = 0.0\n\n if epoch % 10 == 9:\n model.eval()\n with torch.no_grad():\n tmp_y_pred = []\n tmp_y_true = []\n tmp_filenames = []\n\n for data in test_dataloader:\n images, labels, classes, filename = data['image'], data['label'], data['class'], data[\n 'filename']\n\n images = images.to(device)\n labels = labels.to(device)\n\n reg_outputs, cls_outputs = model(images)\n # _, predicted = torch.max(outputs.data, 1)\n\n tmp_y_true += labels.to(\"cpu\").detach().numpy().tolist()\n tmp_y_pred += reg_outputs.to(\"cpu\").detach().numpy().tolist()\n tmp_filenames += filename\n\n model_path_dir = './model'\n mkdirs_if_not_exist(model_path_dir)\n if torch.cuda.device_count() > 1:\n torch.save(model.module.state_dict(),\n os.path.join(model_path_dir, model.__class__.__name__ + '-epoch-%d.pth' % (epoch + 1)))\n else:\n torch.save(model.state_dict(),\n os.path.join(model_path_dir, model.__class__.__name__ + '-epoch-%d.pth' % (epoch + 1)))\n\n rmse_lr = round(np.math.sqrt(mean_squared_error(np.array(tmp_y_true), np.array(tmp_y_pred).ravel())), 4)\n mae_lr = round(mean_absolute_error(np.array(tmp_y_true), np.array(tmp_y_pred).ravel()), 4)\n pc = round(np.corrcoef(np.array(tmp_y_true), np.array(tmp_y_pred).ravel())[0, 1], 4)\n print('RMSE of {0} on test set: {1} '.format(model.__class__.__name__, rmse_lr))\n print('MAE of {0} on test set: {1} '.format(model.__class__.__name__, mae_lr))\n print('PC of {0} on test set: {1} '.format(model.__class__.__name__, pc))\n\n model.train()\n\n print('Finished training CRNet...\\n')\n print('Saving trained model...')\n model_path_dir = './model'\n mkdirs_if_not_exist(model_path_dir)\n if torch.cuda.device_count() > 1:\n torch.save(model.module.state_dict(), os.path.join(model_path_dir, '%s.pth' % model.__class__.__name__))\n else:\n torch.save(model.state_dict(), os.path.join(model_path_dir, '%s.pth' % model.__class__.__name__))\n\n print('CRNet has been saved successfully~')\n\n else:\n print('Loading pre-trained model...')\n model.load_state_dict(torch.load(os.path.join('./model/%s.pth' % model.__class__.__name__)))\n\n model.eval()\n\n print('Start testing CRNet...')\n predicted_labels = []\n gt_labels = []\n filenames = []\n for data in test_dataloader:\n images, scores, classes, filename = data['image'], data['label'], data['class'], data['filename']\n images = images.to(device)\n\n reg_out, cls_out = model.forward(images)\n\n # bat_list = []\n # for out in F.softmax(cls_out).to(\"cpu\"):\n # tmp = 0\n # for i in range(0, 3, 1):\n # tmp += out[i] * (i - 1)\n # bat_list.append(float(tmp.detach().numpy()))\n\n # predicted_labels += (0.6 * reg_out.to(\"cpu\").detach().numpy() + 0.4 * np.array(bat_list)).tolist()\n\n predicted_labels += reg_out.to(\"cpu\").detach().numpy().tolist()\n gt_labels += scores.to(\"cpu\").detach().numpy().tolist()\n filenames += filename\n\n mae_lr = round(mean_absolute_error(np.array(gt_labels), np.array(predicted_labels).ravel()), 4)\n rmse_lr = round(np.math.sqrt(mean_squared_error(np.array(gt_labels), np.array(predicted_labels).ravel())), 4)\n pc = round(np.corrcoef(np.array(gt_labels), np.array(predicted_labels).ravel())[0, 1], 4)\n\n print('===============The Mean Absolute Error of CRNet is {0}===================='.format(mae_lr))\n print('===============The Root Mean Square Error of CRNet is {0}===================='.format(rmse_lr))\n print('===============The Pearson Correlation of CRNet is {0}===================='.format(pc))\n\n col = ['filename', 'gt', 'pred']\n df = pd.DataFrame([[filenames[i], gt_labels[i], predicted_labels[i][0]] for i in range(len(gt_labels))],\n columns=col)\n df.to_excel(\"./output.xlsx\", sheet_name='Output', index=False)\n print('Output Excel has been generated~')","def run_net(self,\n pre_trained_chckpnt_dir ='' #for resuming training, load the model from this directory\n ):\n\n _rd = _read_data(data=self.data)\n\n self.alpha_coeff=1\n\n #read path of the images for train, test, and validation\n train_CTs, train_GTVs, train_Torso, train_penalize, train_surface,\\\n validation_CTs, validation_GTVs, validation_Torso, validation_penalize, validation_surface,\\\n test_CTs, test_GTVs, test_Torso, test_penalize,test_surface=_rd.read_data_path(fold=self.fold)\n self.img_width = self.img_width\n self.img_height = self.img_height\n # ======================================\n #validation instances\n bunch_of_images_no=20\n _image_class_vl = image_class(validation_CTs, validation_GTVs, validation_Torso,validation_penalize,validation_surface\n , bunch_of_images_no=bunch_of_images_no, is_training=0,\n patch_window=self.patch_window)\n _patch_extractor_thread_vl = _patch_extractor_thread(_image_class=_image_class_vl,\n sample_no=self.sample_no, patch_window=self.patch_window,\n GTV_patchs_size=self.GTV_patchs_size,\n tumor_percent=self.tumor_percent,\n img_no=bunch_of_images_no,\n mutex=settings.mutex,is_training=0,vl_sample_no=self.validation_samples\n )\n _fill_thread_vl = fill_thread(validation_CTs,\n validation_GTVs,\n validation_Torso,\n validation_penalize,\n validation_surface,\n _image_class_vl,\n sample_no=self.sample_no,\n total_sample_no=self.validation_samples,\n patch_window=self.patch_window,\n GTV_patchs_size=self.GTV_patchs_size,\n img_width=self.img_width, img_height=self.img_height,\n mutex=settings.mutex,\n tumor_percent=self.tumor_percent,\n is_training=0,\n patch_extractor=_patch_extractor_thread_vl,\n fold=self.fold)\n\n\n _fill_thread_vl.start()\n _patch_extractor_thread_vl.start()\n _read_thread_vl = read_thread(_fill_thread_vl, mutex=settings.mutex,\n validation_sample_no=self.validation_samples, is_training=0)\n _read_thread_vl.start()\n # ======================================\n #training instances\n bunch_of_images_no = 24\n _image_class = image_class(train_CTs, train_GTVs, train_Torso,train_penalize,train_surface\n , bunch_of_images_no=bunch_of_images_no,is_training=1,patch_window=self.patch_window\n )\n patch_extractor_thread = _patch_extractor_thread(_image_class=_image_class,\n sample_no=240, patch_window=self.patch_window,\n GTV_patchs_size=self.GTV_patchs_size,\n tumor_percent=self.tumor_percent,\n img_no=bunch_of_images_no,\n mutex=settings.mutex,is_training=1)\n _fill_thread = fill_thread(train_CTs, train_GTVs, train_Torso,train_penalize,train_surface,\n _image_class,\n sample_no=self.sample_no,total_sample_no=self.sample_no,\n patch_window=self.patch_window,\n GTV_patchs_size=self.GTV_patchs_size,\n img_width=self.img_width,\n img_height=self.img_height,mutex=settings.mutex,\n tumor_percent=self.tumor_percent,\n is_training=1,\n patch_extractor=patch_extractor_thread,\n fold=self.fold)\n\n _fill_thread.start()\n patch_extractor_thread.start()\n\n _read_thread = read_thread(_fill_thread,mutex=settings.mutex,is_training=1)\n _read_thread.start()\n # ======================================\n\n image = tf.placeholder(tf.float32, shape=[None, None, None, None, 1])\n label = tf.placeholder(tf.float32, shape=[None, None, None, None, 2])\n penalize = tf.placeholder(tf.float32, shape=[None, None, None, None,1])\n surf_map = tf.placeholder(tf.float32, shape=[None, None, None, None,1])\n loss_coef = tf.placeholder(tf.float32, shape=[None, 2]) # shape: batchno * 2 values for each class\n alpha = tf.placeholder(tf.float32, name='alpha') # background coeff\n beta = tf.placeholder(tf.float32, name='beta') # tumor coeff\n\n ave_vali_acc=tf.placeholder(tf.float32)\n ave_loss_vali=tf.placeholder(tf.float32)\n ave_dsc_vali=tf.placeholder(tf.float32)\n\n dropout=tf.placeholder(tf.float32,name='dropout')\n is_training = tf.placeholder(tf.bool, name='is_training')\n is_training_bn = tf.placeholder(tf.bool, name='is_training_bn')\n dense_net_dim = tf.placeholder(tf.int32, name='dense_net_dim')\n\n _dn = _densenet_unet(self.densnet_unet_config,self.compression_coefficient,self.growth_rate) #create object\n y=_dn.dens_net(image=image,is_training=is_training,dropout_rate1=0,dropout_rate2=0,dim=dense_net_dim,is_training_bn=is_training_bn)\n # y = _dn.vgg(image)\n\n y_dirX = ((y[:, int(self.GTV_patchs_size / 2), :, :, 0, np.newaxis]))\n label_dirX = (label[:, int(self.GTV_patchs_size / 2), :, :, 0, np.newaxis])\n penalize_dirX = (penalize[:,16,:,:,0,np.newaxis])\n surf_map_dirX = (surf_map[:,16,:,:,0,np.newaxis])\n image_dirX = ((image[:, int(self.patch_window / 2), :, :, 0, np.newaxis]))\n\n show_img=tf.nn.softmax(y)[:, int(self.GTV_patchs_size / 2) , :, :, 0, np.newaxis]\n tf.summary.image('outprunut',show_img , 3)\n tf.summary.image('output without softmax',y_dirX ,3)\n tf.summary.image('groundtruth', label_dirX,3)\n tf.summary.image('penalize', penalize_dirX,3)\n tf.summary.image('surf_map', surf_map_dirX,3)\n tf.summary.image('image',image_dirX ,3)\n\n print('*****************************************')\n print('*****************************************')\n print('*****************************************')\n sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))\n devices = sess.list_devices()\n print(devices)\n\n print(device_lib.list_local_devices())\n print('*****************************************')\n print('*****************************************')\n print('*****************************************')\n\n train_writer = tf.summary.FileWriter(self.LOGDIR + '/train' ,graph=tf.get_default_graph())\n validation_writer = tf.summary.FileWriter(self.LOGDIR + '/validation' , graph=sess.graph)\n\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n saver=tf.train.Saver(tf.global_variables(), max_to_keep=1000)\n\n\n\n #define the loss function\n with tf.name_scope('cost'):\n penalize_weight=0\n [ penalized_loss,\n soft_dice_coef,logt,lbl]=self.loss_instance.dice_plus_distance_penalize(logits=y, labels=label,penalize=penalize)\n surface_loss= self.loss_instance.surface_loss(logits=y, labels=label, surf_map=surf_map)\n cost = tf.reduce_mean((1.0 - soft_dice_coef[1])+penalize_weight*penalized_loss+surface_loss, name=\"cost\")\n\n #Setup the Tensorboard plots\n tf.summary.scalar(\"cost\", cost)\n f1_measure = self.loss_instance.f1_measure(logits=y, labels=label)\n tf.summary.scalar(\"dice_bakground\", f1_measure[0])\n tf.summary.scalar(\"dice_tumor\", f1_measure[1])\n\n pwc = self.loss_instance.PWC(y, label)\n tf.summary.scalar(\"pwc_bakground\", pwc[0])\n tf.summary.scalar(\"pwc_tumor\", pwc[1])\n\n recall = self.loss_instance.Recall(y, label)\n tf.summary.scalar(\"recall_bakground\", recall[0])\n tf.summary.scalar(\"recall_tumor\", recall[1])\n\n precision = self.loss_instance.Precision(y, label)\n tf.summary.scalar(\"precision_bakground\", precision[0])\n tf.summary.scalar(\"precision_tumor\", precision[1])\n\n fpr = self.loss_instance.FPR(y, label)\n tf.summary.scalar(\"FPR_bakground\", fpr[0])\n tf.summary.scalar(\"FPR_tumor\", fpr[1])\n\n fnr = self.loss_instance.FNR(y, label)\n tf.summary.scalar(\"FNR_bakground\", fnr[0])\n tf.summary.scalar(\"FNR_tumor\", fnr[1])\n\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n with tf.control_dependencies(extra_update_ops):\n optimizer_tmp = tf.train.AdamOptimizer(self.learning_rate,epsilon=0.001)\n optimizer = optimizer_tmp.minimize(cost)\n\n with tf.name_scope('validation'):\n average_validation_accuracy=ave_vali_acc\n average_validation_loss=ave_loss_vali\n average_dsc_loss=ave_dsc_vali\n tf.summary.scalar(\"average_validation_accuracy\",average_validation_accuracy)\n tf.summary.scalar(\"average_validation_loss\",average_validation_loss)\n tf.summary.scalar(\"average_dsc_loss\",average_dsc_loss)\n\n with tf.name_scope('accuracy'):\n accuracy=self.loss_instance.accuracy_fn(y, label)\n\n tf.summary.scalar(\"accuracy\", accuracy)\n\n sess.run(tf.global_variables_initializer())\n logging.debug('total number of variables %s' % (\n np.sum([np.prod(v.get_shape().as_list()) for v in tf.trainable_variables()])))\n summ=tf.summary.merge_all()\n\n point = 0 # starting point, starts from a value > 0 if training is resumed\n itr1 = 0 # number of iterations\n if len(pre_trained_chckpnt_dir):\n ckpt = tf.train.get_checkpoint_state(pre_trained_chckpnt_dir)\n saver.restore(sess, ckpt.model_checkpoint_path)\n point=int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\n itr1=point\n\n\n # patch_radius = 49\n '''loop for epochs'''\n\n for epoch in range(self.total_epochs):\n while self.no_sample_per_each_itr*int(point/self.no_sample_per_each_itr)<self.sample_no:\n print('0')\n print(\"epoch #: %d\" %(epoch))\n startTime = time.time()\n step = 0\n self.beta_coeff=1+1 * np.exp(-point/2000)\n # =============start validation================\n if itr1 % self.display_validation_step ==0:\n '''Validation: '''\n loss_validation = 0\n acc_validation = 0\n validation_step = 0\n dsc_validation=0\n while (validation_step * self.batch_no_validation <settings.validation_totalimg_patch):\n [validation_CT_image, validation_GTV_image,validation_Penalize_patch,validation_Surface_patch] = _image_class_vl.return_patches_validation( validation_step * self.batch_no_validation, (validation_step + 1) *self.batch_no_validation)\n if (len(validation_CT_image)<self.batch_no_validation) | (len(validation_GTV_image)<self.batch_no_validation) | (len(validation_Penalize_patch)<self.batch_no_validation) | (len(validation_Surface_patch)<self.batch_no_validation) :\n _read_thread_vl.resume()\n time.sleep(0.5)\n continue\n\n validation_CT_image_patchs = validation_CT_image\n validation_GTV_label = validation_GTV_image\n tic=time.time()\n\n [acc_vali, loss_vali,dsc_vali,surface_loss1] = sess.run([accuracy, cost,f1_measure,surface_loss],\n feed_dict={image: validation_CT_image_patchs,\n label: validation_GTV_label,\n penalize: validation_Penalize_patch,\n dropout: 1,\n is_training: False,\n ave_vali_acc: -1,\n ave_loss_vali: -1,\n ave_dsc_vali:-1,\n dense_net_dim: self.patch_window,\n is_training_bn:False,\n alpha:1,\n beta:1,\n surf_map:validation_Surface_patch,\n })\n elapsed=time.time()-tic\n\n acc_validation += acc_vali\n loss_validation += loss_vali\n dsc_validation+=dsc_vali[1]\n validation_step += 1\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\n print('nan problem')\n process = psutil.Process(os.getpid())\n\n print(\n '%d - > %d: elapsed_time:%d acc_validation: %f, loss_validation: %f, memory_percent: %4s' % (\n validation_step,validation_step * self.batch_no_validation\n , elapsed, acc_vali, loss_vali, str(process.memory_percent()),\n ))\n\n settings.queue_isready_vl = False\n acc_validation = acc_validation / (validation_step)\n loss_validation = loss_validation / (validation_step)\n dsc_validation = dsc_validation / (validation_step)\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\n print('nan problem')\n _fill_thread_vl.kill_thread()\n print('******Validation, step: %d , accuracy: %.4f, loss: %f*******' % (\n itr1, acc_validation, loss_validation))\n\n [sum_validation] = sess.run([summ],\n feed_dict={image: validation_CT_image_patchs,\n label: validation_GTV_label,\n penalize: validation_Penalize_patch,\n dropout: 1,\n is_training: False,\n ave_vali_acc: acc_validation,\n ave_loss_vali: loss_validation,\n ave_dsc_vali:dsc_validation,\n dense_net_dim: self.patch_window,\n is_training_bn: False,\n alpha: 1,\n beta: 1,\n surf_map: validation_Surface_patch,\n\n })\n validation_writer.add_summary(sum_validation, point)\n print('end of validation---------%d' % (point))\n\n #loop for training batches\n while(step*self.batch_no<self.no_sample_per_each_itr):\n [train_CT_image_patchs, train_GTV_label, train_Penalize_patch,loss_coef_weights,train_Surface_patch] = _image_class.return_patches( self.batch_no)\n\n if (len(train_CT_image_patchs)<self.batch_no)|(len(train_GTV_label)<self.batch_no)\\\n |(len(train_Penalize_patch)<self.batch_no)|(len(train_Surface_patch)<self.batch_no):\n time.sleep(0.5)\n _read_thread.resume()\n continue\n\n tic=time.time()\n [acc_train1, loss_train1, optimizing,out,dsc_train11] = sess.run([accuracy, cost, optimizer,y,f1_measure],\n feed_dict={image: train_CT_image_patchs,\n label: train_GTV_label,\n penalize: train_Penalize_patch,\n # loss_coef: loss_coef_weights,\n dropout: self.dropout_keep,\n is_training: True,\n ave_vali_acc: -1,\n ave_loss_vali: -1,\n ave_dsc_vali: -1,\n dense_net_dim: self.patch_window,\n is_training_bn: True,\n alpha: self.alpha_coeff,\n beta: self.beta_coeff,\n surf_map: train_Surface_patch,\n\n })\n elapsed=time.time()-tic\n dsc_train1=dsc_train11[1]\n\n self.x_hist=self.x_hist+1\n # np.hstack((self.x_hist, [np.ceil(\n\n [sum_train] = sess.run([summ],\n feed_dict={image: train_CT_image_patchs,\n label: train_GTV_label,\n penalize: train_Penalize_patch,\n dropout: self.dropout_keep, is_training: True,\n ave_vali_acc: acc_train1,\n ave_loss_vali: loss_train1,\n ave_dsc_vali: dsc_train1,\n dense_net_dim: self.patch_window,\n is_training_bn: True,\n alpha: self.alpha_coeff,\n beta: self.beta_coeff,\n surf_map: train_Surface_patch,\n\n })\n train_writer.add_summary(sum_train,point)\n step = step + 1\n\n process = psutil.Process(os.getpid())\n\n print(\n 'point: %d, elapsed_time:%d step*self.batch_no:%f , LR: %.15f, acc_train1:%f, loss_train1:%f,memory_percent: %4s' % (\n int((point)),elapsed,\n step * self.batch_no, self.learning_rate, acc_train1, loss_train1,\n str(process.memory_percent())))\n\n\n point=int((point))\n if point%100==0:\n '''saveing model inter epoch'''\n chckpnt_path = os.path.join(self.chckpnt_dir,\n ('densenet_unet_inter_epoch%d_point%d.ckpt' % (epoch, point)))\n saver.save(sess, chckpnt_path, global_step=point)\n itr1 = itr1 + 1\n point=point+1\n endTime = time.time()\n\n #==============\n '''saveing model after each epoch'''\n chckpnt_path = os.path.join(self.chckpnt_dir, 'densenet_unet.ckpt')\n saver.save(sess, chckpnt_path, global_step=epoch)\n print(\"End of epoch----> %d, elapsed time: %d\" % (epoch, endTime - startTime))","def run_cifar_gan(sess, G_train_step, G_loss, D_train_step, D_loss, G_extra_step, D_extra_step, show_every=250, print_every=50, batch_size=128, num_epoch=10):\n # compute the number of iterations we need\n max_iter = int(X.shape[0]*num_epoch/batch_size)\n for it in range(max_iter):\n # every show often, show a sample result\n if it % show_every == 0:\n samples = sess.run(G_sample)\n fig = show_images_cifar(samples[:16],it/show_every)\n plt.show()\n # run a batch of data through the network\n minibatch = X[np.random.randint(0,X.shape[0],batch_size)]\n _, D_loss_curr = sess.run([D_train_step, D_loss], feed_dict={x: minibatch})\n _, G_loss_curr = sess.run([G_train_step, G_loss])\n\n # print loss every so often.\n # We want to make sure D_loss doesn't go to 0\n #if it % print_every == 0:\n print('Iter: {}, D: {:.4}, G:{:.4}'.format(it,D_loss_curr,G_loss_curr))\n print('Final images')\n samples = sess.run(G_sample)\n\n fig = show_images_cifar(samples[:16],it/show_every)\n plt.show()","def build_resnet101(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\n conv1_feats = nonlinear(conv1_feats, 'relu')\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\n\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\n \n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \n temp = res3a_feats\n for i in range(1, 4):\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\n res3b3_feats = temp\n \n res4a_feats = self.basic_block(res3b3_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\n temp = res4a_feats\n for i in range(1, 23):\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\n res4b22_feats = temp\n\n res5a_feats = self.basic_block(res4b22_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\n\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\n self.conv_feats = res5c_feats_flat\n self.conv_feat_shape = [49, 2048]\n self.num_ctx = 49 \n self.dim_ctx = 2048\n\n self.imgs = imgs\n self.is_train = is_train","def setup(args):\n cfg = get_cfg()\n\n cfg.merge_from_file(model_zoo.get_config_file(\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\"))\n cfg.merge_from_list(args.opts)\n\n # configs for training\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\n cfg.DATASETS.TRAIN = (\"vidor_small_train\",)\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\n cfg.DATASETS.TRAIN = (\"vidor_small_10imgs_train\",)\n else:\n cfg.DATASETS.TRAIN = (\"vidor_large_train\",)\n # cfg.DATALOADER.NUM_WORKERS = 2\n if not args.eval_only:\n cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\") # Let training initialize from model zoo\n factor = 4\n cfg.SOLVER.IMS_PER_BATCH = 16 * factor\n cfg.SOLVER.BASE_LR = 0.0001 * factor # finetune using 10x smaller base_lr\n cfg.SOLVER.MAX_ITER = 270000 // factor \n cfg.SOLVER.STEPS = [210000 // factor, 250000 // factor]\n # cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # default: 512\n cfg.MODEL.ROI_HEADS.NUM_CLASSES = 78\n\n # configs for testing\n # cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, \"model_final.pth\")\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\n cfg.DATASETS.TEST = (\"vidor_small_val\",)\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\n cfg.DATASETS.TEST = (\"vidor_small_10imgs_val\",)\n else:\n cfg.DATASETS.TEST = (\"vidor_large_val\",)\n # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5\n\n # cfg.OUTPUT_DIR = './output/train_vidor_with_pseudo_labels'\n \n \n if not args.eval_only:\n os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)\n cfg.freeze()\n default_setup(cfg, args)\n return cfg","def plscorr_eval(train_fmri_ts, train_feat_ts, val_fmri_ts, val_feat_ts,\n out_dir, mask_file):\n train_feat_ts = train_feat_ts.reshape(-1, train_feat_ts.shape[3]).T\n val_feat_ts = val_feat_ts.reshape(-1, val_feat_ts.shape[3]).T\n train_fmri_ts = train_fmri_ts.T\n val_fmri_ts = val_fmri_ts.T\n\n # Iteration loop for different component number\n #for n in range(5, 19):\n # print '--- Components number %s ---' %(n)\n # plsca = PLSCanonical(n_components=n)\n # plsca.fit(train_feat_ts, train_fmri_ts)\n # pred_feat_c, pred_fmri_c = plsca.transform(val_feat_ts, val_fmri_ts)\n # pred_fmri_ts = plsca.predict(val_feat_ts) \n # # calculate correlation coefficient between truth and prediction\n # r = corr2_coef(val_fmri_ts.T, pred_fmri_ts.T, mode='pair')\n # # get top 20% corrcoef for model evaluation\n # vsample = int(np.rint(0.2*len(r)))\n # print 'Sample size for evaluation : %s' % (vsample)\n # r.sort()\n # meanr = np.mean(r[-1*vsample:])\n # print 'Mean prediction corrcoef : %s' %(meanr)\n \n # model generation based on optimized CC number\n cc_num = 10\n plsca = PLSCanonical(n_components=cc_num)\n plsca.fit(train_feat_ts, train_fmri_ts)\n from sklearn.externals import joblib\n joblib.dump(plsca, os.path.join(out_dir, 'plsca_model.pkl'))\n plsca = joblib.load(os.path.join(out_dir, 'plsca_model.pkl'))\n\n # calculate correlation coefficient between truth and prediction\n pred_fmri_ts = plsca.predict(val_feat_ts)\n fmri_pred_r = corr2_coef(val_fmri_ts.T, pred_fmri_ts.T, mode='pair')\n mask = vutil.data_swap(mask_file)\n vxl_idx = np.nonzero(mask.flatten()==1)[0]\n tmp = np.zeros_like(mask.flatten(), dtype=np.float64)\n tmp[vxl_idx] = fmri_pred_r\n tmp = tmp.reshape(mask.shape)\n vutil.save2nifti(tmp, os.path.join(out_dir, 'pred_fmri_r.nii.gz'))\n pred_feat_ts = pls_y_pred_x(plsca, val_fmri_ts)\n pred_feat_ts = pred_feat_ts.T.reshape(96, 14, 14, 540)\n np.save(os.path.join(out_dir, 'pred_feat.npy'), pred_feat_ts)\n\n # get PLS-CCA weights\n feat_cc, fmri_cc = plsca.transform(train_feat_ts, train_fmri_ts)\n np.save(os.path.join(out_dir, 'feat_cc.npy'), feat_cc)\n np.save(os.path.join(out_dir, 'fmri_cc.npy'), fmri_cc)\n feat_weight = plsca.x_weights_.reshape(96, 14, 14, cc_num)\n #feat_weight = plsca.x_weights_.reshape(96, 11, 11, cc_num)\n fmri_weight = plsca.y_weights_\n np.save(os.path.join(out_dir, 'feat_weights.npy'), feat_weight)\n np.save(os.path.join(out_dir, 'fmri_weights.npy'), fmri_weight)\n fmri_orig_ccs = get_pls_components(plsca.y_scores_, plsca.y_loadings_)\n np.save(os.path.join(out_dir, 'fmri_orig_ccs.npy'), fmri_orig_ccs)","def train_and_eval(config, babas_data):\n\n if config.resume_from_checkpoint is not None:\n try:\n if config.augment_background == 'background':\n bg = config.augment_background\n else:\n bg = None\n rfc = config.resume_from_checkpoint\n ic = config.include_validation\n print 'Loading saved config: %s' % config.saved_config\n config = np.load(config.saved_config).item()\n config.resume_from_checkpoint = rfc\n config.include_validation = ic\n if not hasattr(config, 'augment_background'):\n config.augment_background = 'constant'\n if not hasattr(config, 'background_folder'):\n config.background_folder = 'backgrounds'\n if bg is not None:\n print 'Overriding saved config to add kinect backgrounds to training.'\n config.augment_background = bg\n results_dir = rfc\n except:\n print 'Relying on default config file.'\n\n if babas_data: # Shitty naive training method\n config.tfrecord_dir = '/media/data_cifs/monkey_tracking/data_for_babas/tfrecords_from_babas'\n config.babas_tfrecord_dir = config.tfrecord_dir\n config.steps_before_validation = 20\n config.epochs = 2000\n config.convert_labels_to_pixel_space = False\n config.augment_background = 'constant'\n\n # Import your model\n print 'Model directory: %s' % config.model_output\n print 'Running model: %s' % config.model_type\n model_file = import_cnn(config.model_type)\n\n # Prepare model training\n dt_stamp = re.split(\n '\\.', str(datetime.now()))[0].\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\n dt_dataset = '%s_%s' % (config.model_type, dt_stamp)\n if config.selected_joints is not None:\n dt_dataset = '_%s' % (config.selected_joints) + dt_dataset\n config.train_checkpoint = os.path.join(\n config.model_output, dt_dataset) # timestamp this run\n config.summary_dir = os.path.join(\n config.train_summaries, dt_dataset)\n results_dir = os.path.join(config.npy_dir, dt_dataset)\n print 'Saving Dmurphy\\'s online updates to: %s' % results_dir\n dir_list = [config.train_checkpoint, config.summary_dir, results_dir]\n [tf_fun.make_dir(d) for d in dir_list]\n\n # Prepare model inputs\n train_data = os.path.join(config.tfrecord_dir, config.train_tfrecords)\n if config.babas_tfrecord_dir is not None:\n train_babas_tfrecord_dir = os.path.join(\n config.babas_tfrecord_dir,\n config.train_tfrecords)\n if config.include_validation or config.include_validation is None:\n val_babas_tfrecord_dir = os.path.join(\n config.babas_tfrecord_dir,\n config.val_tfrecords)\n else:\n train_babas_tfrecord_dir = None\n val_babas_tfrecord_dir = None\n\n if isinstance(config.include_validation, basestring):\n validation_data = config.include_validation\n elif config.include_validation == True:\n validation_data = os.path.join(\n config.tfrecord_dir,\n config.val_tfrecords)\n else:\n validation_data = None\n\n print 'Using training set: %s' % train_data\n print 'Using validation set: %s' % validation_data\n\n # Prepare data on CPU\n with tf.device('/cpu:0'):\n train_data_dict = inputs(\n tfrecord_file=train_data,\n batch_size=config.train_batch,\n im_size=config.resize,\n target_size=config.image_target_size,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n label_shape=config.num_classes,\n num_epochs=config.epochs,\n image_target_size=config.image_target_size,\n image_input_size=config.image_input_size,\n maya_conversion=config.maya_conversion,\n max_value=config.max_depth,\n normalize_labels=config.normalize_labels,\n aux_losses=config.aux_losses,\n selected_joints=config.selected_joints,\n joint_names=config.joint_order,\n num_dims=config.num_dims,\n keep_dims=config.keep_dims,\n mask_occluded_joints=config.mask_occluded_joints,\n background_multiplier=config.background_multiplier,\n augment_background=config.augment_background,\n background_folder=config.background_folder,\n randomize_background=config.randomize_background,\n maya_joint_labels=config.labels,\n babas_tfrecord_dir=train_babas_tfrecord_dir,\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\n image_target_size_is_flipped=config.image_target_size_is_flipped)\n train_data_dict['deconv_label_size'] = len(config.labels)\n\n val_data_dict = inputs(\n tfrecord_file=validation_data,\n batch_size=config.validation_batch,\n im_size=config.resize,\n target_size=config.image_target_size,\n model_input_shape=config.resize,\n train=config.data_augmentations,\n label_shape=config.num_classes,\n num_epochs=config.epochs,\n image_target_size=config.image_target_size,\n image_input_size=config.image_input_size,\n maya_conversion=config.maya_conversion,\n max_value=config.max_depth,\n normalize_labels=config.normalize_labels,\n aux_losses=config.aux_losses,\n selected_joints=config.selected_joints,\n joint_names=config.joint_order,\n num_dims=config.num_dims,\n keep_dims=config.keep_dims,\n mask_occluded_joints=config.mask_occluded_joints,\n background_multiplier=config.background_multiplier,\n augment_background='none',\n background_folder=config.background_folder,\n randomize_background=None,\n maya_joint_labels=config.labels,\n babas_tfrecord_dir=val_babas_tfrecord_dir,\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\n image_target_size_is_flipped=config.image_target_size_is_flipped)\n val_data_dict['deconv_label_size'] = len(config.labels)\n\n # Check output_shape\n if config.selected_joints is not None:\n print 'Targeting joint: %s' % config.selected_joints\n joint_shape = len(config.selected_joints) * config.keep_dims\n if (config.num_classes // config.keep_dims) > (joint_shape):\n print 'New target size: %s' % joint_shape\n config.num_classes = joint_shape\n\n with tf.device('/gpu:0'):\n with tf.variable_scope('cnn') as scope:\n print 'Creating training graph:'\n model = model_file.model_struct(\n weight_npy_path=config.weight_npy_path)\n train_mode = tf.get_variable(name='training', initializer=True)\n model.build(\n rgb=train_data_dict['image'],\n target_variables=train_data_dict,\n train_mode=train_mode,\n batchnorm=config.batch_norm)\n train_mu, train_var = tf.nn.moments(train_data_dict['image'], axes=[1, 2, 3])\n tf.summary.histogram(\"train image mean\", train_mu)\n tf.summary.histogram(\"train image std\", tf.sqrt(train_var))\n if 'deconv_image' in config.aux_losses:\n tf.summary.image('Deconv train', model.deconv)\n if 'deconv_label' in config.aux_losses:\n tf.summary.image(\n 'Deconv label train',\n tf.expand_dims(\n tf.cast(\n tf.argmax(model.deconv, axis=3), tf.float32), 3))\n\n # Setup validation op\n if validation_data is not False:\n scope.reuse_variables()\n print 'Creating validation graph:'\n val_model = model_file.model_struct()\n val_model.build(\n rgb=val_data_dict['image'],\n target_variables=val_data_dict)\n\n # Calculate validation accuracy\n val_mu, val_var = tf.nn.moments(val_data_dict['image'], axes=[1, 2, 3])\n tf.summary.histogram(\"validation image mean\", val_mu)\n tf.summary.histogram(\"validation image std\", tf.sqrt(val_var))\n if 'label' in val_data_dict.keys():\n # val_score = tf.reduce_mean(\n # tf_fun.l2_loss(\n # val_model.output, val_data_dict['label']))\n if config.keep_dims == 3:\n z_mask = tf.expand_dims(tf.tile([1, 1, 0], [int(val_data_dict['label'].get_shape()[-1]) // 3]), axis=0)\n z_mask = tf.cast(z_mask, tf.float32)\n val_model.output = val_model.output * z_mask\n val_data_dict['label'] = val_data_dict['label'] * z_mask \n val_score = tf.reduce_mean(tf.nn.l2_loss(val_model.output - val_data_dict['label']))\n tf.summary.scalar(\"validation mse\", val_score)\n if 'fc' in config.aux_losses:\n tf.summary.image('FC val activations', val_model.final_fc)\n if 'deconv_image' in config.aux_losses:\n tf.summary.image('Deconv val', val_model.deconv)\n if 'deconv_label' in config.aux_losses:\n tf.summary.image(\n 'Deconv label train',\n tf.expand_dims(\n tf.cast(\n tf.argmax(val_model.deconv, axis=3),\n tf.float32), 3))\n tf.summary.image(\n 'validation images',\n tf.cast(val_data_dict['image'], tf.float32))\n\n # Prepare the loss functions:::\n loss_list, loss_label = [], []\n if 'label' in train_data_dict.keys():\n # 1. Joint localization loss\n if config.calculate_per_joint_loss == 'thomas':\n label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n elif config.calculate_per_joint_loss == 'skeleton':\n label_loss = tf_fun.skeleton_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n elif config.calculate_per_joint_loss == 'skeleton and joint':\n label_loss = tf_fun.skeleton_loss(\n model=model,\n train_data_dict=train_data_dict,\n config=config,\n y_key='label',\n yhat_key='output')\n loss_list += [label_loss]\n loss_label += ['skeleton loss']\n delta = model['output'] - train_data_dict['label']\n proc_weights = np.asarray(\n config.dim_weight)[None,:].repeat(\n len(config.joint_names), axis=0).reshape(1, -1)\n delta *= proc_weights\n # label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\n # model=model,\n # train_data_dict=train_data_dict,\n # config=config,\n # y_key='label',\n # yhat_key='output')\n # loss_list += [label_loss]\n loss_list += [tf.nn.l2_loss(\n model['output'] - train_data_dict['label'])]\n else:\n loss_list += [tf.nn.l2_loss(\n model['output'] - train_data_dict['label'])]\n loss_label += ['combined head']\n for al in loss_helper.potential_aux_losses():\n loss_list, loss_label = loss_helper.get_aux_losses(\n loss_list=loss_list,\n loss_label=loss_label,\n train_data_dict=train_data_dict,\n model=model,\n aux_loss_dict=al,\n domain_adaptation=train_babas_tfrecord_dir)\n loss = tf.add_n(loss_list)\n\n # Add wd if necessary\n if config.wd_penalty is not None:\n _, l2_wd_layers = tf_fun.fine_tune_prepare_layers(\n tf.trainable_variables(), config.wd_layers)\n l2_wd_layers = [\n x for x in l2_wd_layers if 'biases' not in x.name]\n if config.wd_type == 'l1':\n loss += (config.wd_penalty * tf.add_n(\n [tf.reduce_sum(tf.abs(x)) for x in l2_wd_layers]))\n elif config.wd_type == 'l2':\n loss += (config.wd_penalty * tf.add_n(\n [tf.nn.l2_loss(x) for x in l2_wd_layers]))\n\n optimizer = loss_helper.return_optimizer(config.optimizer)\n optimizer = optimizer(config.lr)\n\n if hasattr(config, 'fine_tune_layers') and config.fine_tune_layers is not None:\n print 'Finetuning learning for: %s' % config.fine_tune_layers\n train_op, grads = tf_fun.finetune_learning(\n loss,\n trainables=tf.trainable_variables(),\n fine_tune_layers=config.fine_tune_layers,\n config=config\n )\n else:\n # Op to calculate every variable gradient\n grads = optimizer.compute_gradients(\n loss, tf.trainable_variables())\n # Op to update all variables according to their gradient\n train_op = optimizer.apply_gradients(\n grads_and_vars=grads)\n\n # Summarize all gradients and weights\n [tf.summary.histogram(\n var.name + '/gradient', grad)\n for grad, var in grads if grad is not None]\n # train_op = optimizer.minimize(loss)\n\n # Summarize losses\n [tf.summary.scalar(lab, il) for lab, il in zip(\n loss_label, loss_list)]\n\n # Summarize images and l1 weights\n tf.summary.image(\n 'train images',\n tf.cast(train_data_dict['image'], tf.float32))\n tf_fun.add_filter_summary(\n trainables=tf.trainable_variables(),\n target_layer='conv1_1_filters')\n\n # Set up summaries and saver\n saver = tf.train.Saver(\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\n summary_op = tf.summary.merge_all()\n tf.add_to_collection('output', model.output)\n\n # Initialize the graph\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n\n # Need to initialize both of these if supplying num_epochs to inputs\n sess.run(tf.group(tf.global_variables_initializer(),\n tf.local_variables_initializer()))\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\n\n # Set up exemplar threading\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n # Create list of variables to run through training model\n train_session_vars = {\n 'train_op': train_op,\n 'loss_value': loss,\n 'im': train_data_dict['image'],\n 'yhat': model.output,\n 'ytrue': train_data_dict['label']\n }\n if hasattr(model, 'deconv'):\n train_session_vars['deconv'] = model.deconv\n if hasattr(model, 'final_fc'):\n train_session_vars['fc'] = model.final_fc\n\n # Create list of variables to run through validation model\n val_session_vars = {\n 'val_acc': val_score,\n 'val_pred': val_model.output,\n 'val_ims': val_data_dict['image'],\n 'val_true': val_data_dict['label'],\n }\n\n # Create list of variables to save to numpys\n save_training_vars = [\n 'im',\n 'yhat',\n 'ytrue',\n 'yhat'\n ]\n\n for al in loss_helper.potential_aux_losses():\n if al.keys()[0] in train_data_dict.keys():\n y_key = '%s' % al.keys()[0]\n train_session_vars[y_key] = train_data_dict[al.values()[0]['y_name']]\n save_training_vars += [y_key]\n\n yhat_key = '%s_hat' % al.keys()[0]\n train_session_vars[yhat_key] = model[al.values()[0]['model_name']]\n save_training_vars += [yhat_key]\n\n # Start training loop\n np.save(config.train_checkpoint, config)\n step, losses = 0, []\n num_joints = int(\n train_data_dict['label'].get_shape()[-1]) // config.keep_dims\n normalize_vec = tf_fun.get_normalization_vec(config, num_joints)\n if config.resume_from_checkpoint is not None:\n if '.ckpt' in config.resume_from_checkpoint:\n ckpt = config.resume_from_checkpoint\n 'Restoring specified checkpoint: %s' % config.resume_from_checkpoint\n else:\n ckpt = tf.train.latest_checkpoint(config.resume_from_checkpoint)\n print 'Evaluating checkpoint: %s' % ckpt\n saver.restore(sess, ckpt)\n try:\n while not coord.should_stop():\n start_time = time.time()\n train_out_dict = sess.run(train_session_vars.values())\n train_out_dict = {k: v for k, v in zip(\n train_session_vars.keys(), train_out_dict)}\n losses.append(train_out_dict['loss_value'])\n duration = time.time() - start_time\n assert not np.isnan(\n train_out_dict['loss_value']), 'Model diverged with loss = NaN'\n if step % config.steps_before_validation == 0:\n if validation_data is not False:\n val_out_dict = sess.run(\n val_session_vars.values())\n val_out_dict = {k: v for k, v in zip(\n val_session_vars.keys(), val_out_dict)}\n # if config.normalize_labels:\n # val_out_dict['val_pred'] *= normalize_vec\n # val_out_dict['val_true'] *= normalize_vec\n np.savez(\n os.path.join(\n results_dir, '%s_val_coors' % step),\n val_pred=val_out_dict['val_pred'],\n val_ims=val_out_dict['val_ims'],\n val_true=val_out_dict['val_true'],\n normalize_vec=normalize_vec)\n with open(\n os.path.join(\n results_dir, '%s_config.p' % step), 'wb') as fp:\n pickle.dump(config, fp)\n\n # Summaries\n summary_str = sess.run(summary_op)\n summary_writer.add_summary(summary_str, step)\n\n # Training status and validation accuracy attach 9177\n format_str = (\n '%s: step %d, loss = %.8f (%.1f examples/sec; '\n '%.3f sec/batch) | '\n 'Validation l2 loss = %s | logdir = %s')\n print (format_str % (\n datetime.now(), step, train_out_dict['loss_value'],\n config.train_batch / duration, float(duration),\n val_out_dict['val_acc'],\n config.summary_dir))\n\n # Save the model checkpoint if it's the best yet\n if config.normalize_labels:\n train_out_dict['yhat'] *= normalize_vec\n train_out_dict['ytrue'] *= normalize_vec\n [save_training_data(\n output_dir=results_dir,\n data=train_out_dict[k],\n name='%s_%s' % (k, step)) for k in save_training_vars]\n saver.save(\n sess, os.path.join(\n config.train_checkpoint,\n 'model_' + str(step) + '.ckpt'), global_step=step)\n\n else:\n # Training status\n format_str = ('%s: step %d, loss = %.8f (%.1f examples/sec; '\n '%.3f sec/batch)')\n print (format_str % (\n datetime.now(),\n step,\n train_out_dict['loss_value'],\n config.train_batch / duration,\n float(duration)))\n # End iteration\n step += 1\n\n except tf.errors.OutOfRangeError:\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\n finally:\n coord.request_stop()\n dt_stamp = get_dt() # date-time stamp\n np.save(\n os.path.join(\n config.tfrecord_dir, '%s_training_loss' % dt_stamp), losses)\n coord.join(threads)\n sess.close()","def train():\n args = arguments()\n\n # Create output directories\n create_output_dir(args.outputDir)\n\n # Start Log File\n log_path = os.path.join(args.outputDir, LOG_DIR, time.strftime('%Y-%m-%d_%H-%M-%S.log'))\n log_file = Logger(log_path)\n\n # Log arguments\n arg_str = ''\n for arg in vars(args):\n arg_str += \"\\n\" + \"{:30} {}\".format(str(arg), getattr(args, arg))\n log_file.log_line(\"Arguments\", arg_str)\n log_file.newline()\n\n # Load Params\n configuration = config_cvppp.TrainConfig()\n\n # Log params\n log_file.log_line(\"Config Parameters\\n\", configuration.to_string())\n log_file.newline()\n\n ## Load dataset API (Already logged in the args log step)\n train_dataset, crossVal_dataset = load_datasets(args)\n\n # Init the model\n checkpoint_path = os.path.join(args.outputDir, CHECKPOINT_DIR)\n training_model = model.MaskRCNN('training', configuration, checkpoint_path)\n\n # Load weights\n if args.init == 'last':\n weights_path = training_model.find_last()\n log_file.log_line(\"Initialised with \", weights_path)\n training_model.load_weights(weights_path, by_name=True)\n\n elif args.init == 'rand':\n log_file.log_line(\"Initialised with \", \"random weights\")\n pass\n\n else:\n if not os.path.exists(args.init):\n raise OSError('No weights at: ' + args.init)\n \n log_file.log_line(\"Initialised with \", args.init)\n training_model.load_weights(args.init, by_name=True)\n\n # Train the model\n augmentation = get_augmentation_sequence()\n\n custom_callbacks = None\n\n training_model.train(train_dataset, crossVal_dataset, \n learning_rate=configuration.LEARNING_RATE, \n epochs=args.numEpochs,\n augmentation=augmentation,\n layers='all',\n custom_callbacks=custom_callbacks) # Train all layers\n\n # Close the log file\n log_file.close()","def main_train(lr, bs, cuda_id, not_distrib, fp16, loss_scale):\r\n torch.backends.cudnn.benchmark = True\r\n if fp16: assert torch.backends.cudnn.enabled, \"missing cudnn\"\r\n stats = (np.array([ 0.4914 , 0.48216, 0.44653]), np.array([ 0.24703, 0.24349, 0.26159]))\r\n sz=32\r\n PATH = Path(\"../../data/cifar10/\")\r\n tfms = tfms_from_stats(stats, sz, aug_tfms=[RandomCrop(sz), RandomFlip()], pad=sz//8)\r\n data1 = ImageClassifierData.from_paths(PATH, val_name='test', tfms=tfms, bs=bs)\r\n m = wrn_22().cuda()\r\n if not not_distrib: m = nn.parallel.DistributedDataParallel(m, device_ids=[cuda_id], output_device=cuda_id)\r\n learn = ConvLearner.from_model_data(m, data1)\r\n learn.crit = nn.CrossEntropyLoss()\r\n learn.metrics = [accuracy]\r\n trn_tfms = CustomTfm(0.5, 4, 32, 1)\r\n val_tfms = None\r\n data = DataBunch.from_files(PATH, trn_tfms, val_tfms, stats, torch.device('cuda', cuda_id), distrib=not not_distrib, val_name='test', bs=bs)\r\n learn.data.trn_dl, learn.data.val_dl = data.trn_dl, data.val_dl\r\n if fp16: learn.half()\r\n x,y = next(iter(data.trn_dl))\r\n opt_fn = get_opt_fn('Adam', 0.95, 0.99, False)\r\n learn.opt_fn = opt_fn\r\n cyc_len, pct = 30, 0.075\r\n nbs = [cyc_len * (1-pct) / 2, cyc_len * (1-pct) / 2, cyc_len * pct]\r\n phases = get_phases(lr, (0.95,0.85), opt_fn, 10, nbs, 0.1, True, False)\r\n #print_lr = PrintLR(learn)\r\n learn.fit_opt_sched(phases, loss_scale=loss_scale)","def load_cifar10(data_path=\".\", test_size=0.2, random_state=1337):\n test_path = os.path.join(data_path, \"cifar-10-batches-py/test_batch\")\n train_paths = [os.path.join(data_path, \"cifar-10-batches-py/data_batch_%i\" % i) for i in range(1, 6)]\n\n if not os.path.exists(test_path) or not all(list(map(os.path.exists, train_paths))):\n print (\"Dataset not found. Downloading...\")\n download_cifar(data_path,\n url='https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz',\n tarname='cifar-10-python.tar.gz')\n\n train_batches = list(map(unpickle, train_paths))\n test_batch = unpickle(test_path)\n\n X = np.concatenate([batch[\"data\"] for batch in train_batches]).reshape([-1, 3, 32, 32]).astype('float32') / 255\n y = np.concatenate([batch[\"labels\"] for batch in train_batches]).astype('int32')\n X_train, X_val, y_train, y_val = train_test_split(X, y,\n test_size=test_size,\n random_state=random_state)\n\n X_test = test_batch[\"data\"].reshape([-1, 3, 32, 32]).astype('float32') / 255\n y_test = np.array(test_batch[\"labels\"]).astype('int32')\n\n return X_train, y_train, X_val, y_val, X_test, y_test","def train():\r\n with tf.Graph().as_default():\r\n global_step = tf.Variable(0, trainable=False)\r\n\r\n # Get images and labels for CIFAR-10.\r\n images=tf.placeholder(\"float\",shape=[None,256,320,3])\r\n labels=tf.placeholder(\"float\",shape=[None])\r\n local6=tf.placeholder(\"float\",shape=[None])\r\n images, labels = inputs()\r\n logits = inference(images)\r\n loss = compute_loss(logits, labels)\r\n lr=0.001\r\n tf.summary.scalar('learning_rate', lr)\r\n opt = tf.train.GradientDescentOptimizer(lr)\r\n grads = opt.compute_gradients(loss)\r\n apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)\r\n train_op=apply_gradient_op\r\n\r\n # Create a saver.\r\n saver = tf.train.Saver(tf.global_variables())\r\n\r\n # Build the summary operation based on the TF collection of Summaries.\r\n summary_op = tf.summary.merge_all()\r\n\r\n # Build an initialization operation to run below.\r\n init = tf.global_variables_initializer()\r\n\r\n # Start running operations on the Graph.\r\n sess = tf.Session(config=tf.ConfigProto(\r\n log_device_placement=False))\r\n sess.run(init)\r\n\r\n # Start the queue runners.\r\n tf.train.start_queue_runners(sess=sess)\r\n\r\n summary_writer = tf.summary.FileWriter('/home/fzyue/Desktop/caffeendtoend/1', sess.graph)\r\n\r\n for step in xrange(500000):\r\n start_time = time.time()\r\n _, loss_value = sess.run([train_op, loss])\r\n duration = time.time() - start_time\r\n\r\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\r\n\r\n if step % 10 == 0:\r\n num_examples_per_step = 64\r\n examples_per_sec = num_examples_per_step / duration\r\n sec_per_batch = float(duration)\r\n\r\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '\r\n 'sec/batch)')\r\n print (format_str % (datetime.now(), step, loss_value,\r\n examples_per_sec, sec_per_batch))\r\n #print(labels)\r\n #print (sess.run(logits))\r\n\r\n if step % 100 == 0:\r\n summary_str = sess.run(summary_op)\r\n summary_writer.add_summary(summary_str, step)\r\n\r\n # Save the model checkpoint periodically.\r\n if step % 1000 == 0 or (step + 1) == 500000:\r\n checkpoint_path = os.path.join('/home/fzyue/Desktop/caffeendtoend/1', 'model.ckpt')\r\n saver.save(sess, checkpoint_path, global_step=step)","def executeCNN(args, files, var_targets, nn_arch, batchsize, epoch, mode, n_gpu=(1, 'avolkov'), shuffle=(False, None), tb_logger=False):\n\n print '\\nEpoch Interval:\\t', epoch[0], ' - ', epoch[1], '\\n'\n\n if epoch[0] == 0:\n if nn_arch == 'DCNN':\n if args.wires in ['U', 'V']: model = create_shared_dcnn_network_2()\n elif args.wires in ['UV', 'U+V']: model = create_shared_dcnn_network_4()\n else: raise ValueError('passed wire specifier need to be U/V/UV')\n elif nn_arch == 'ResNet':\n raise ValueError('Currently, this is not implemented')\n elif nn_arch == 'Inception':\n if args.wires in ['U', 'V']: model = create_shared_inception_network_2()\n elif args.wires in ['UV', 'U+V']: model = create_shared_inception_network_4()\n else: raise ValueError('passed wire specifier need to be U/V/UV')\n elif nn_arch == 'Conv_LSTM':\n raise ValueError('Currently, this is not implemented')\n else:\n raise ValueError('Currently, only DCNN and Inception are available as nn_arch')\n else:\n model = load_trained_model(args)\n\n if mode == 'train':\n model.summary()\n try: # plot model, install missing packages with conda install if it throws a module error\n raise OSError\n ks.utils.plot_model(model, to_file=args.folderOUT + '/plot_model.png',\n show_shapes=True, show_layer_names=False)\n except OSError:\n save_plot_model_script(folderOUT=args.folderOUT)\n print 'could not produce plot_model.png ---- run generate_model_plot on CPU'\n\n # exit()\n\n adam = ks.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0) # Default: epsi: None, Deep NN: epsi=0.1/1.0\n optimizer = adam # Choose optimizer, only used if epoch == 0\n\n # model, batchsize = parallelize_model_to_n_gpus(model, n_gpu, batchsize) # TODO compile after restart????\n # if n_gpu[0] > 1: model.compile(loss=loss_opt[0], optimizer=optimizer, metrics=[loss_opt[1]]) # TODO check\n\n if epoch[0] == 0:\n print 'Compiling Keras model\\n'\n model.compile(\n loss='categorical_crossentropy',\n optimizer=optimizer,\n metrics=['accuracy'])\n # TODO Add Precision/Recall to metric, see:\n # TODO https://stackoverflow.com/questions/43076609/how-to-calculate-precision-and-recall-in-keras\n\n print 'optimizer epsilon:', model.optimizer.epsilon\n\n print \"\\nTraining begins in Epoch:\\t\", epoch\n\n model.save(args.folderOUT + \"models/model-000.hdf5\")\n model.save_weights(args.folderOUT + \"models/weights-000.hdf5\")\n model = fit_model(args, model, files, batchsize, var_targets, epoch, shuffle, n_events=None, tb_logger=tb_logger)\n model.save_weights(args.folderOUT + \"models/weights_final.hdf5\")\n model.save(args.folderOUT + \"models/model_final.hdf5\")\n elif mode in ['valid']: #validation\n # model.summary()\n print 'Validate events'\n print model\n print model.get_layer(index=3)\n exit()\n\n args.sources = \"\".join(sorted(args.sources))\n args.position = \"\".join(sorted(args.position))\n args.folderOUT += \"0validation/\" + args.sources + \"-\" + mode + \"-\" + args.position + \"-\" + str(args.num_weights) + \"-\" + args.wires + \"/\"\n os.system(\"mkdir -p -m 770 %s \" % (args.folderOUT))\n\n EVENT_INFO = get_events(args=args, files=files, model=model,\n fOUT=(args.folderOUT + \"events_\" + str(args.num_weights) + \"_\" + args.sources + \"-\" + mode + \"-\" + args.position + \"-\" + args.wires + \".hdf5\"))\n\n # EVENT_INFO['DNNPredClass'] = EVENT_INFO['DNNPred'].argmax(axis=-1)\n # EVENT_INFO['DNNTrueClass'] = EVENT_INFO['DNNTrue'].argmax(axis=-1)\n # EVENT_INFO['DNNPredTrueClass'] = EVENT_INFO['DNNPred'][:, 1]\n\n validation_mc_plots(args=args, folderOUT=args.folderOUT, data=EVENT_INFO)\n else:\n raise ValueError('chosen mode (%s) not available. Choose between train/mc/data'%(mode))","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--dataset_path',\n type=str,\n default='../Datasets2/cifar100Dataset.npy',\n help='location of the dataset in numpy format', )\n parser.add_argument('--train_steps',\n type=int,\n default=150000,\n help='training steps', )\n parser.add_argument('--measuring_step_size',\n type=float,\n default=0.1,\n help='step size to where a second loss is determined to approximate the loss function '\n 'in the direction of the gradient by a parabola', )\n parser.add_argument('--momentum',\n type=float,\n default=0.4,\n help='momentum term', )\n parser.add_argument('--batch_size',\n type=int,\n default=128,\n help='batch_size', )\n parser.add_argument('--experiment_name',\n type=str,\n default=\"testmodel\",\n help='the name of the experiment', )\n parser.add_argument('--loose_approximation_factor',\n type=float,\n default=1.0,\n help='intentionally approximate the function with less or more curvature. = 1/ step size adaptation '\n 'less curvature <1 more curvature >1', )\n parser.add_argument('--train_data_size',\n type=int,\n default=45000,\n help='train data size,remaining elements define the evaluation_Res_Net set', )\n parser.add_argument('--random_seed',\n type=int,\n default=1,\n help='random number seed for numpy and tensorflow to get same results for multiple runs', )\n parser.add_argument('--max_stepsize',\n type=float,\n default=3.6,\n help='max stepsize in direction of the gradient', )\n parser.add_argument('--decay',\n type=float,\n default=1,\n help='max stepsize and measurment stepsize decay rate', )\n parser.add_argument('--additional',\n type=float,\n default=100,\n help='additional parameter', )\n parser.add_argument('--num_gpus',\n type=int,\n default=1,\n help='num gpus to train on', )\n parser.add_argument('--optimizer',\n type=str,\n default=\"SLS\",\n help='the optimizer to use', )\n\n FLAGS, unparsed = parser.parse_known_args()\n for k, v in vars(FLAGS).items():\n k, v = str(k), str(v)\n print('%s: %s' % (k, v))\n FLAGS.dataset_path = os.path.expanduser(FLAGS.dataset_path)\n print(\"DatasetPath: \" + str(FLAGS.dataset_path))\n\n workpath = os.path.dirname(os.path.dirname(sys.argv[0])) + '/' # double dir name to get parent\n\n print(\"workpath: \" + workpath)\n\n # check gpus\n local_device_protos = device_lib.list_local_devices()\n num_available_gpus = len([x.name for x in local_device_protos if x.device_type == 'GPU'])\n assert num_available_gpus >= FLAGS.num_gpus\n print(\"GPUs available: {1:d} \\t GPUs used: {1:d}\".format(num_available_gpus, FLAGS.num_gpus))\n\n learning_rate_pf = lambda global_step, learning_rate: tf.train.piecewise_constant(global_step,\n [75000.0, 112500.0],\n [float(learning_rate),\n float(learning_rate / 10),\n float(learning_rate / 100),\n ])\n\n if FLAGS.optimizer == \"PAL\":\n optimizer = PAL(None, FLAGS.measuring_step_size, FLAGS.momentum, FLAGS.loose_approximation_factor,\n FLAGS.max_stepsize, False)\n elif FLAGS.optimizer == \"SLS\":\n optimizer = SLS(n_batches_per_epoch=FLAGS.train_data_size // FLAGS.batch_size,\n init_step_size=FLAGS.measuring_step_size, c=FLAGS.momentum,\n beta_b=FLAGS.loose_approximation_factor, gamma=FLAGS.max_stepsize)\n elif FLAGS.optimizer == \"OL\":\n #optimizer = OptimalLineSearch(initial_search_step=FLAGS.measuring_step_size,\n # max_num_of_steps=FLAGS.max_stepsize, momentum=FLAGS.momentum)\n optimizer = OptimalLineSearch(initial_search_step=1.0,\n max_num_of_steps=20.0, momentum=0.0)\n\n elif FLAGS.optimizer == \"RMSP\":\n optimizer = TfOptimizer(tf.train.RMSPropOptimizer, learning_rate_pf,\n {\"learning_rate\": FLAGS.measuring_step_size, \"decay\": FLAGS.momentum,\n \"epsilon\": FLAGS.loose_approximation_factor})\n elif FLAGS.optimizer == \"ADAM\":\n optimizer = TfOptimizer(tf.train.AdamOptimizer, learning_rate_pf,\n {\"learning_rate\": FLAGS.measuring_step_size, \"beta1\": FLAGS.momentum,\n \"beta2\": FLAGS.loose_approximation_factor, \"epsilon\": FLAGS.max_stepsize})\n elif FLAGS.optimizer == \"SGD\":\n optimizer = TfOptimizer(tf.train.MomentumOptimizer, learning_rate_pf,\n {\"learning_rate\": FLAGS.measuring_step_size, \"momentum\": FLAGS.momentum,\n \"use_nesterov\": True})\n elif FLAGS.optimizer == \"SGDHD\":\n optimizer = TfOptimizer(SGDHD, None,\n {\"learning_rate\": FLAGS.measuring_step_size, \"hyper_gradient_learning_rate\": FLAGS.momentum})\n elif FLAGS.optimizer == \"ALIG\":\n optimizer = TfOptimizer(AliGwithMomentum, None,\n {\"max_lr\": FLAGS.measuring_step_size, \"momentum\": FLAGS.momentum})\n elif FLAGS.optimizer == \"COCOB\":\n optimizer = TfOptimizer(COCOB, None,\n {\"alpha\": FLAGS.measuring_step_size})\n\n else:\n raise ValueError(\"unknown optimizer flag:\" + FLAGS.optimizer)\n\n # Uncomment the network and dataset to use!\n\n # net_type= tolstoi_rnn.TolstoiRNN\n\n # net_type= simple_mnist_net.SimpleMnistNet\n\n # net_type=efficient_net_cifar10.EfficientNet\n # net_type=mobile_net_v2_cifar10.MobileNetV2\n net_type = resnet_32_cifar10.ResNet\n # net_type=dense_net_cifar10.DenseNet\n # net_type=resnet_34_IN_style_cifar.ResNet\n\n # net_type=efficient_net_cifar100.EfficientNet\n # net_type=mobile_net_v2_cifar100.MobileNetV2\n # net_type=resnet_32_cifar100.ResNet\n # net_type=dense_net_cifar100.DenseNet\n\n # net_type=efficient_net_IM.EfficientNet\n # net_type=mobile_net_v2_IM.MobileNetV2\n # net_type=resnet_101_IM.ResNet\n # net_type=resnet_50_IM.ResNet\n # net_type=dense_net_IM.DenseNet\n\n # data_set_loader = ImageNetLoader\n #data_set_loader = Cifar10Loader # also uncomment is_augment\n #data_set_loader.is_augment = True\n data_set_loader = Cifar100Loader\n # data_set_loader = TolstoiLoader\n # data_set_loader= MNISTLoader\n\n sys.stdout.flush()\n\n if FLAGS.optimizer == \"OL\":\n net = net_frame_ol.NetFrame(net_type, data_set_loader, optimizer, FLAGS.num_gpus, FLAGS.random_seed,\n FLAGS.train_data_size,\n FLAGS.batch_size, FLAGS.dataset_path, workpath, FLAGS.experiment_name,\n is_calc_angle=False)\n else:\n net = net_frame.NetFrame(net_type, data_set_loader, optimizer, FLAGS.num_gpus, FLAGS.random_seed,\n FLAGS.train_data_size,\n FLAGS.batch_size, FLAGS.dataset_path, workpath, FLAGS.experiment_name,\n is_calc_angle=False) # 100. 0.001 # problem 1,1 or 20,1 -> very steep descent!\n\n is_failed = False\n try:\n mean_train_losses_per_interval, evaluation_accuracies, train_losses_for_each_step, step_sizes_for_each_step, \\\n angles_for_each_step, grad_norms_for_each_step, train_time_for_each_step, tran_acc_per_interval, \\\n eval_losses, avg_test_acc, avg_test_loss, all_first_derivatives, all_second_derivatives \\\n = net.train(FLAGS.train_steps)\n except Exception as e:\n print(e.__doc__)\n is_failed = True\n print(\"FAILED\")\n\n if is_failed:\n eval_data_wrapper = fu.EvalDataWrapper(FLAGS.experiment_name, FLAGS.random_seed, FLAGS.optimizer,\n FLAGS.train_data_size,\n FLAGS.train_steps, FLAGS.batch_size, FLAGS.measuring_step_size,\n FLAGS.momentum,\n FLAGS.loose_approximation_factor, FLAGS.max_stepsize, FLAGS.decay,\n FLAGS.additional, [], [], [], [], None, None, is_failed)\n else:\n eval_data_wrapper = fu.EvalDataWrapper(FLAGS.experiment_name, FLAGS.random_seed, FLAGS.optimizer,\n FLAGS.train_data_size,\n FLAGS.train_steps, FLAGS.batch_size, FLAGS.measuring_step_size,\n FLAGS.momentum,\n FLAGS.loose_approximation_factor, FLAGS.max_stepsize, FLAGS.decay,\n FLAGS.additional, mean_train_losses_per_interval, tran_acc_per_interval,\n evaluation_accuracies, eval_losses, avg_test_acc, avg_test_loss, is_failed,\n angles_for_each_step, step_sizes_for_each_step, grad_norms_for_each_step,\n all_first_derivatives, all_second_derivatives\n )\n\n fu.save_eval_data_wrapper(eval_data_wrapper, net.model_dir)","def run_test(filepath):\n num_class = 120 # dogbreeds class\n model = Resnet50MO(num_class, checkpoint_path=None)\n\n # image settings\n crop_size = model.input_size\n scale_size = model.input_size\n input_size = model.input_size\n input_mean = model.input_mean\n input_std = model.input_std\n\n # hyperparams settings\n epochs = 1\n batch_size = 32 # mini-batch-size\n learning_rate = 0.01\n momentum = 0.5\n decay_factor = 10\n eval_freq = 5 # in epochs\n\n # data generator settings: dataset and dataloader\n train_dataset = DogImageset(filepath, input_size,\n input_mean=input_mean, input_std=input_std)\n val_dataset = DogImageset(filepath, input_size,\n input_mean=input_mean, input_std=input_std)\n \n train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n val_loader = DataLoader(dataset=val_dataset, batch_size=batch_size, shuffle=False)\n\n # Loss and backprop settings\n model.cuda()\n criterion = torch.nn.CrossEntropyLoss()\n optimizer = torch.optim.SGD(\n model.parameters(),\n lr=learning_rate,\n momentum=momentum\n )\n\n run_model_train_test(model, train_loader, criterion, optimizer)","def loadData(self):\n # Load the raw CIFAR-10 data\n num_training = 49000\n num_validation = 1000\n num_test = 1000\n subtract_mean = True\n\n cifar10_dir = '/home/parallels/PycharmProjects/Courses/232A/project2/stats232a/datasets/cifar-10-batches-py'\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n\n # Subsample the data\n mask = list(range(num_training, num_training + num_validation))\n X_val = X_train[mask]\n y_val = y_train[mask]\n mask = list(range(num_training))\n X_train = X_train[mask]\n y_train = y_train[mask]\n mask = list(range(num_test))\n X_test = X_test[mask]\n y_test = y_test[mask]\n\n # Normalize the data: subtract the mean image\n if subtract_mean:\n mean_image = np.mean(X_train, axis=0)\n X_train -= mean_image\n X_val -= mean_image\n X_test -= mean_image\n\n # Transpose so that channels come first\n X_train = X_train.transpose(0, 3, 1, 2)\n X_val = X_val.transpose(0, 3, 1, 2)\n X_test = X_test.transpose(0, 3, 1, 2)\n\n # Package data into a dictionary\n self.data = {\n 'X_train': X_train, 'y_train': y_train,\n 'X_val': X_val, 'y_val': y_val,\n 'X_test': X_test, 'y_test': y_test,\n }","def main():\n args = get_arguments()\n \n # Create queue coordinator.\n coord = tf.train.Coordinator()\n \n # Load reader.\n with tf.name_scope(\"create_inputs\"):\n reader = ImageReader_MultiClass_Loss(\n args.data_dir,\n args.data_list,\n None, # No defined input size.\n RANDOM_SEED,\n False, # No random scale.\n False, # No random mirror.\n coord)\n image, l2_catg, binary_catg, hinge_catg = reader.image, reader.l2_catg, reader.binary_catg, reader.hinge_catg\n image_batch = tf.expand_dims(image, dim=0)\n binary_catg_batch = tf.expand_dims(binary_catg, dim=0)\n\n # Create network.\n net = DeepLabResNetModel({'data': image_batch}, is_training=False)\n\n # Which variables to load.\n restore_var = tf.global_variables()\n \n # Predictions.\n raw_output = net.layers['fc1_voc12']\n\n # Do the global average pooling\n raw_output_bcgd_rmvd = raw_output[:,:,:,1:]\n g_avg_pool = tf.reduce_mean(tf.reduce_mean(raw_output_bcgd_rmvd, axis=1, keep_dims=True),\\\n axis=2, keep_dims=True) # Avg across the width and height dimension -> [Bx21]\n g_avg_pool_sqzd = tf.squeeze(g_avg_pool, axis=[1, 2])\n pred = tf.nn.softmax(g_avg_pool_sqzd)\n\n # Get the class activation map\n raw_output_up = tf.image.resize_bilinear(raw_output_bcgd_rmvd, tf.shape(image_batch)[1:3,])\n raw_output_up = raw_output_up - tf.reduce_min(tf.reduce_min(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True) + EPSILON\n raw_output_up = raw_output_up / tf.reduce_max(tf.reduce_max(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True)\n cam_m_1 = tf.argmax(raw_output_up, dimension=3) + 1\n raw_output_catgs_rmvd = raw_output_up * tf.expand_dims(tf.expand_dims(binary_catg_batch, 1), 2)\n cam_m_2 = tf.argmax(raw_output_catgs_rmvd, dimension=3) + 1\n cam = tf.cast(tf.equal(cam_m_1, cam_m_2), tf.int64) * cam_m_1\n\n cam_batch = tf.expand_dims(cam, dim=3)\n\n # Set up tf session and initialize variables. \n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n init = tf.global_variables_initializer()\n \n sess.run(init)\n sess.run(tf.local_variables_initializer())\n \n # Load weights.\n loader = tf.train.Saver(var_list=restore_var)\n if args.restore_from is not None:\n load(loader, sess, args.restore_from)\n \n # Start queue threads.\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\n \n # Iterate over training steps.\n for step in range(args.num_steps):\n preds, images, cams, bin_catg = sess.run([pred, image_batch, cam_batch, binary_catg])\n \"\"\"\n print(bin_catg)\n print(np.unique(np.unique(cams)))\n \"\"\"\n img = inv_preprocess(images)\n attMap = decode_labels(cams)\n output_dir = './output_maps_binary_without_norm/'\n img_name = output_dir + str(step) + '.jpg'\n map_name = output_dir + str(step) + '.png'\n misc.imsave(img_name, img[0,:,:,:])\n misc.imsave(map_name, attMap[0,:,:,:])\n coord.request_stop()\n coord.join(threads)","def train():\n\t# 1、make dataloader\n\ttrain_loader, val_loader, num_query, num_class = make_data_loader(cfg)\n\t#print(\"num_query:{},num_class:{}\".format(num_query,num_class))\n\n\t# 2、make model\n\tmodel = build_model(cfg, num_class)\n\n\t# model.eval()\n\t# x = model(img_tensor)\n\t# print(x.shape)\n\t# 3、 make optimizer\n\toptimizer = make_optimizer(cfg, model)\n\n\t# 4、 make lr_scheduler\n\tscheduler = make_lr_scheduler(cfg, optimizer)\n\n\t# 5、 make loss_func\n\tif cfg.MODEL.PCB_NECK:\n\t\t# make loss specificially for pcb \n\t\tloss_func = get_softmax_triplet_loss_fn(cfg, num_class)\n\telse:\n\t\tloss_func = make_loss(cfg, num_class)\n\n\t# get paramters\n\tlog_period = cfg.OUTPUT.LOG_PERIOD \n\tckpt_period =cfg.OUTPUT.CHECKPOINT_PERIOD\n\teval_period = cfg.OUTPUT.EVAL_PERIOD\n\toutput_dir = cfg.OUTPUT.ROOT_DIR\n\tdevice = cfg.MODEL.DEVICE\n\tepochs = cfg.SOLVER.MAX_EPOCHS\n\tuse_gpu = device == \"cuda\"\n\tuse_neck = cfg.MODEL.NECK or cfg.MODEL.LEARN_REGION \n\t# how many batch for each log\n\tbatch_size = cfg.SOLVER.IMGS_PER_BATCH\n\tbatch_num = len(train_loader) \n\t\n\tlog_iters = batch_num // log_period\n\tpretrained = cfg.MODEL.PRETRAIN_PATH != ''\n\tparallel = cfg.MODEL.PARALLEL \t\n\tgrad_clip = cfg.DARTS.GRAD_CLIP \n\n\tfeat_norm = cfg.TEST.FEAT_NORM \n\tckpt_save_path = cfg.OUTPUT.ROOT_DIR + cfg.OUTPUT.CKPT_DIR\n\tif not os.path.exists(ckpt_save_path):\n\t\tos.makedirs(ckpt_save_path)\n\n\n\t# create *_result.xlsx\n\t# save the result for analyze\n\tname = (cfg.OUTPUT.LOG_NAME).split(\".\")[0] + \".xlsx\"\n\tresult_path = cfg.OUTPUT.ROOT_DIR + name\n\n\twb = xl.Workbook()\n\tsheet = wb.worksheets[0]\n\ttitles = ['size/M','speed/ms','final_planes', 'acc', 'mAP', 'r1', 'r5', 'r10', 'loss',\n\t\t\t 'acc', 'mAP', 'r1', 'r5', 'r10', 'loss','acc', 'mAP', 'r1', 'r5', 'r10', 'loss']\n\tsheet.append(titles)\n\tcheck_epochs = [40, 80, 120, 160, 200, 240, 280, 320, 360, epochs]\n\tvalues = []\n\n\tlogger = logging.getLogger('MobileNetReID.train')\n\t\n\t# count parameter\n\tsize = count_parameters(model)\n\tlogger.info(\"the param number of the model is {:.2f} M\".format(size))\n\t\n\tvalues.append(format(size, '.2f'))\n\tvalues.append(model.final_planes)\n\n\tlogger.info(\"Start training\")\n\t\n\t#count = 183, x, y = batch -> 11712 for train\n\tif pretrained:\n\t\tstart_epoch = model.start_epoch\n\n\tif parallel:\n\t\tmodel = nn.DataParallel(model)\n\n\tif use_gpu:\n\t\t# model = nn.DataParallel(model)\n\t\tmodel.to(device)\n\t\n\t# save the best model\n\tbest_mAP, best_r1 = 0., 0.\n\tis_best = False\n\t# batch : img, pid, camid, img_path\n\tavg_loss, avg_acc = RunningAverageMeter(), RunningAverageMeter()\n\tavg_time, global_avg_time = AverageMeter(), AverageMeter()\n\tglobal_avg_time.reset()\n\tfor epoch in range(epochs):\n\t\tscheduler.step()\n\n\t\tif pretrained and epoch < start_epoch - 1:\n\t\t\tcontinue\n\t\n\t\tmodel.train()\n\t\t# sum_loss, sum_acc = 0., 0.\n\t\tavg_loss.reset()\n\t\tavg_acc.reset()\n\t\tavg_time.reset()\n\t\tfor i, batch in enumerate(train_loader):\n\n\t\t\tt0 = time.time()\n\t\t\timgs,labels = batch\n\n\t\t\tif use_gpu:\n\t\t\t\timgs = imgs.to(device)\n\t\t\t\tlabels = labels.to(device)\n\n\t\t\tres = model(imgs)\n\t\t\t# score, feat = model(imgs)\n\t\t\t# loss = loss_func(score, feat, labels)\n\t\t\tloss, acc = compute_loss_acc(use_neck, res, labels, loss_func)\n\t\t\t\n\t\t\tloss.backward()\n\t\t\tif grad_clip != 0:\n\t\t\t\tnn.utils.clip_grad_norm(model.parameters(), grad_clip)\n\n\t\t\toptimizer.step()\n\n\t\t\toptimizer.zero_grad()\n\n\t\t\t# acc = (score.max(1)[1] == labels).float().mean()\n\n\t\t\t# sum_loss += loss\n\t\t\t# sum_acc += acc \n\t\t\tt1 = time.time()\n\t\t\tavg_time.update((t1 - t0) / batch_size)\n\t\t\tavg_loss.update(loss)\n\t\t\tavg_acc.update(acc)\n\n\t\t\t#log the info \n\t\t\tif (i+1) % log_iters == 0:\n\n\t\t\t\tlogger.info(\"epoch {}: {}/{} with loss is {:.5f} and acc is {:.3f}\".format(\n\t\t\t\t\t epoch+1, i+1, batch_num, avg_loss.avg, avg_acc.avg))\n\n\t\tlr = optimizer.state_dict()['param_groups'][0]['lr']\n\t\tlogger.info(\"end epochs {}/{} with lr: {:.5f} and avg_time is {:.3f} ms\".format(epoch+1, epochs, lr, avg_time.avg * 1000))\n\t\tglobal_avg_time.update(avg_time.avg)\n\t\t# change the lr \n\n\t\t# eval the model \n\t\tif (epoch+1) % eval_period == 0 or (epoch + 1) == epochs :\n\t\t\t\n\t\t\tmodel.eval()\n\t\t\tmetrics = R1_mAP(num_query, use_gpu = use_gpu, feat_norm = feat_norm)\n\n\t\t\twith torch.no_grad():\n\n\t\t\t\tfor vi, batch in enumerate(val_loader):\n\t\t\t\t\t\n\t\t\t\t\timgs, labels, camids = batch\n\n\t\t\t\t\tif use_gpu:\n\t\t\t\t\t\timgs = imgs.to(device)\n\n\t\t\t\t\tfeats = model(imgs)\n\t\t\t\t\tmetrics.update((feats,labels, camids))\n\n\t\t\t\t#compute cmc and mAP\n\t\t\t\tcmc, mAP = metrics.compute()\n\t\t\t\tlogger.info(\"validation results at epoch:{}\".format(epoch + 1))\n\t\t\t\tlogger.info(\"mAP:{:.2%}\".format(mAP))\n\t\t\t\tfor r in [1,5,10]:\n\t\t\t\t\tlogger.info(\"CMC curve, Rank-{:<3}:{:.2%}\".format(r,cmc[r-1]))\t\n\n\t\t\t\t# determine whether cur model is the best \n\t\t\t\tif mAP > best_mAP:\n\t\t\t\t\tis_best = True\n\t\t\t\t\tbest_mAP = mAP\n\t\t\t\t\tlogger.info(\"Get a new best mAP\")\n\t\t\t\tif cmc[0] > best_r1:\n\t\t\t\t\tis_best = True\n\t\t\t\t\tbest_r1 = cmc[0]\n\t\t\t\t\tlogger.info(\"Get a new best r1\")\n\n\t\t\t\t# add the result to sheet\n\t\t\t\tif (epoch + 1) in check_epochs:\n\t\t\t\t\tval = [avg_acc.avg, mAP, cmc[0], cmc[4], cmc[9]]\n\t\t\t\t\tchange = [format(v * 100, '.2f') for v in val]\n\t\t\t\t\tchange.append(format(avg_loss.avg, '.3f'))\n\t\t\t\t\tvalues.extend(change)\n\n\n\t\t# we hope that eval_period == ckpt_period or eval_period == k* ckpt_period where k is int\t\t\t\n\t\t# whether to save the model\n\t\tif (epoch+1) % ckpt_period == 0 or is_best:\n\n\t\t\tif parallel:\n\t\t\t\ttorch.save(model.module.state_dict(), ckpt_save_path + \"checkpoint_{}.pth\".format(epoch + 1 ))\n\t\t\telse:\n\t\t\t\ttorch.save(model.state_dict(), ckpt_save_path + \"checkpoint_{}.pth\".format(epoch + 1 ))\n\n\t\t\tlogger.info(\"checkpoint {} saved !\".format(epoch + 1))\n\n\t\t\tif is_best:\n\t\t\t\tif parallel:\n\t\t\t\t\ttorch.save(model.module.state_dict(), ckpt_save_path + \"best_ckpt.pth\")\n\t\t\t\telse:\n\t\t\t\t\ttorch.save(model.state_dict(), ckpt_save_path + \"best_ckpt.pth\")\n\t\t\t\tlogger.info(\"best checkpoint was saved\")\n\t\t\t\tis_best = False\n\t\n\tvalues.insert(1, format(global_avg_time.avg * 1000, '.2f'))\n\tsheet.append(values)\n\twb.save(result_path)\n\n\tlogger.info(\"training is end, time for per imgs is {} ms\".format(global_avg_time.avg *1000))","def train_cavia(args, config, path_model, device):\n global DATA, PATH_BASE, PATH_DATA, N_CLS, NAME_DATA, NAME_BACKBONE\n\n if path_model is None:\n masks_dict = None\n learner = None\n else:\n print('Load net from', path_model)\n save_dict = torch.load(path_model)\n state_dict = save_dict['state_dict']\n masks_dict = save_dict.get('masks_dict', None)\n\n learner = Learner(config, args.num_context_params, args.context_in)\n learner.load_state_dict(state_dict)\n\n if masks_dict is None:\n print('masks_dict is None!')\n cr = 1.\n else:\n cr = get_cr(learner, masks_dict)\n\n cavia = Meta(args, config, learner).to(device)\n\n # save path\n if path_model is None:\n path_save = '%s/model/cavia_lobs/%s_%s/%d-way_%d-shot' % (\n PATH_BASE, NAME_DATA, NAME_BACKBONE, args.n_way, args.k_spt)\n else:\n path_save = '/'.join(path_model.split('/')[:-1])\n if not os.path.exists(path_save):\n os.makedirs(path_save)\n\n # meta train\n meta_train(cavia, args, masks_dict, device,\n output=args.log_print,\n save=args.save_each_epoch,\n save_threshold=args.save_threshold,\n test_each_epoch=args.test_each_epoch,\n path_save=path_save,\n cr=cr,\n break_threshold=args.break_threshold)\n\n if not args.save_each_epoch:\n # meta test\n acc_avg, accs = meta_test(cavia, args, masks_dict, device)\n\n path_model = '%s/net_cr-1_acc-%.4f.pkl' % (path_save, acc_avg)\n print('Save as %s' % path_model)\n torch.save(\n {\n 'state_dict': cavia.net.state_dict(),\n 'accs': accs,\n 'config': config,\n 'args': args\n },\n path_model\n )","def load_cifar10_data(img_rows, img_cols):\n\n # Load cifar10 training and validation sets\n (X_train, Y_train), (X_valid, Y_valid) = cifar10.load_data()\n\n # Resize training images\n X_train = np.array([cv2.resize(img, (img_rows, \\\n img_cols)) for img in X_train[:, :, :, :]])\n\n X_valid = np.array([cv2.resize(img, (img_rows, \\\n img_cols)) for img in X_valid[:, :, :, :]])\n\n # Check the data type of X_train or X_valid\n for each in X_train:\n print(type(each))\n\n # Transform targets to keras compatible format\n Y_train = np_utils.to_categorical(Y_train, num_classes)\n Y_valid = np_utils.to_categorical(Y_valid, num_classes)\n\n X_train = X_train.astype('float32')\n X_valid = X_valid.astype('float32')\n\n # Data normalization\n X_train = X_train / 255.0\n X_valid = X_valid / 255.0\n\n return X_train, Y_train, X_valid, Y_valid","def main():\n nn = CarsClassifierModel()\n train_x, train_y, test_x, test_y = nn.load_data_preprocess()\n history = nn.run(train_x,train_y)\n nn.evaluate(test_x, test_y)\n nn.save(\"keras_nn_5\")\n #nn.plots(history)\n #print(train_x.shape)\n #plt.imshow(train_x[52])\n #plt.title(\"Car\")\n #plt.show()\n #print(train_y[52])","def train():\n init_distributed_mode(args)\n save_dir = TRAIN_CFG['save_dir']\n if not os.path.exists(save_dir) and torch.distributed.get_rank() == 0:\n os.mkdir(save_dir)\n kwargs = {}\n # If augmenting data, disable Pytorch's own augmentataion\n # This has to be done manually as augmentation is embedded\n # refer : https://github.com/pytorch/vision/issues/2263\n base_path = DATASET_CFG['base_path']\n train_set = DATASET_CFG['train']\n valid_set = DATASET_CFG['valid']\n dset_mean_std = DATASET_CFG['mean_std']\n if dset_mean_std is not None:\n dataset_mean = [i/255. for i in dset_mean_std[0]]\n dataset_std = [i/255. for i in dset_mean_std[1]]\n else:\n dataset_mean, dataset_std = compute_mean_std(base_path, train_set)\n kwargs['image_mean'] = dataset_mean\n kwargs['image_std'] = dataset_std\n kwargs['min_size'] = DATASET_CFG['min_size']\n kwargs['max_size'] = DATASET_CFG['max_size']\n kwargs['box_detections_per_img'] = 300 # increase max det to max val in our benchmark\n\n # Set benchmark related parameters\n if benchmark == 'ScutHead':\n combined_cfg = {**cfg, **sh_anchors}\n elif benchmark == 'CrowdHuman':\n combined_cfg = {**cfg, **ch_anchors}\n elif benchmark == 'Combined':\n combined_cfg = {**cfg, **combined_anchors}\n else:\n raise ValueError(\"New dataset has to be registered\")\n\n # Create Model\n default_filter = False\n model = customRCNN(cfg=combined_cfg,\n use_deform=NET_CFG['use_deform'],\n ohem=NET_CFG['ohem'],\n context=NET_CFG['context'],\n custom_sampling=NET_CFG['custom_sampling'],\n default_filter=default_filter,\n soft_nms=NET_CFG['soft_nms'],\n upscale_rpn=NET_CFG['upscale_rpn'],\n median_anchors=NET_CFG['median_anchors'],\n **kwargs).cuda() \n model_without_ddp = model\n if args.distributed:\n model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu],\n find_unused_parameters=True)\n model_without_ddp = model.module\n\n # Create Optimizer\n params = [p for p in model.parameters() if p.requires_grad]\n optimizer = torch.optim.SGD(params, lr=HYP_CFG['learning_rate'],\n momentum=HYP_CFG['learning_rate'],\n weight_decay=HYP_CFG['weight_decay'])\n\n scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,\n milestones=TRAIN_CFG['milestones'],\n gamma=HYP_CFG['gamma'])\n # Restore from checkpoint\n pt_model = TRAIN_CFG['pretrained_model']\n if pt_model:\n model_without_ddp = restore_network(model_without_ddp, pt_model,\n only_backbone=TRAIN_CFG['only_backbone'])\n \n # Create training and vaid dataset\n dataset_param = {'mean': dataset_mean, 'std':dataset_std,\n 'shape':(kwargs['min_size'], kwargs['max_size'])}\n batch_size = HYP_CFG['batch_size']\n train_dataset = HeadDataset(train_set,\n base_path,\n dataset_param,\n train=True)\n val_dataset = HeadDataset(valid_set,\n base_path,\n dataset_param,\n train=False)\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)\n train_batch_sampler = torch.utils.data.BatchSampler(train_sampler,\n batch_size,\n drop_last=True)\n train_data_loader = torch.utils.data.DataLoader(train_dataset,\n batch_sampler=train_batch_sampler,\n num_workers=args.num_workers,\n collate_fn=collate_fn)\n\n val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset)\n val_batch_sampler = torch.utils.data.BatchSampler(val_sampler,\n batch_size,\n drop_last=True)\n val_data_loader = torch.utils.data.DataLoader(val_dataset,\n batch_sampler=val_batch_sampler,\n num_workers=args.num_workers,\n collate_fn=collate_fn)\n # Fastforward the LR decayer\n start_epoch = TRAIN_CFG['start_epoch']\n max_epoch = TRAIN_CFG['max_epoch']\n for _ in range(0, -1):\n scheduler.step()\n\n # Start training\n print(\"======= Training for \" + str(max_epoch) + \"===========\")\n for epoch in range(start_epoch, int(max_epoch) + 1):\n if epoch % TRAIN_CFG['eval_every'] == 0:\n print(\"========= Evaluating Model ==========\")\n result_dict = evaluate(model, val_data_loader, benchmark=benchmark)\n if torch.distributed.get_rank() == 0:\n logging.info('Eval score at {0} epoch is {1}'.format(str(epoch),\n result_dict))\n \n train_one_epoch(model, optimizer, train_data_loader,\n device, epoch, print_freq=1000)\n scheduler.step()\n if torch.distributed.get_rank() == 0:\n print(\"Saving model\")\n torch.save(model.state_dict(), osp.join(save_dir,\n TRAIN_CFG['exp_name'] + '_epoch_' + str(epoch) + '.pth'))","def load_cifar10_data(self, data_path='data/cifar-10-batches-py',\n n_train_samples=50000, n_test_samples=10000):\n train_data = None\n train_labels = []\n\n for i in range(1, 6):\n data_dic = unpickle(data_path + '/data_batch_{}'.format(i))\n if i == 1:\n train_data = data_dic['data']\n else:\n train_data = np.vstack((train_data, data_dic['data']))\n\n train_labels += data_dic['labels']\n\n test_data_dic = unpickle(data_path + '/test_batch')\n test_data = test_data_dic['data']\n test_labels = test_data_dic['labels']\n\n train_data = train_data.reshape((len(train_data),\n self.LOADED_IMG_DEPTH,\n self.LOADED_IMG_HEIGHT,\n self.LOADED_IMG_HEIGHT))\n\n train_data = np.rollaxis(train_data, 1, 4)\n train_labels = np.array(train_labels)\n\n test_data = test_data.reshape((len(test_data),\n self.LOADED_IMG_DEPTH,\n self.LOADED_IMG_HEIGHT,\n self.LOADED_IMG_HEIGHT))\n\n test_data = np.rollaxis(test_data, 1, 4)\n test_labels = np.array(test_labels)\n\n self.train_dataset = {'data': train_data[0:n_train_samples],\n 'labels': train_labels[0:n_train_samples],\n 'cls': [np.zeros(10)\n for i in range(n_train_samples)]}\n\n for i in range(0, n_train_samples):\n self.train_dataset['cls'][i][self.train_dataset['labels'][i]] = 1.\n\n self.test_dataset = {'data': test_data[0:n_test_samples],\n 'labels': test_labels[0:n_test_samples],\n 'cls': [np.zeros(10)\n for i in range(n_train_samples)]}\n\n for i in range(0, n_test_samples):\n self.test_dataset['cls'][i][self.test_dataset['labels'][i]] = 1.\n\n self.train_dataset['data_array'] = np.array(\n [item.flatten() for item in self.train_dataset['data']])\n\n self.train_dataset['labels_array'] = np.array(\n [item.flatten() for item in self.train_dataset['labels']])\n\n self.train_dataset['cls_array'] = np.array(\n [item.flatten() for item in self.train_dataset['cls']])\n\n self.test_dataset['data_array'] = np.array(\n [item.flatten() for item in self.test_dataset['data']])\n\n self.test_dataset['labels_array'] = np.array(\n [item.flatten() for item in self.test_dataset['labels']])\n\n self.test_dataset['cls_array'] = np.array(\n [item.flatten() for item in self.test_dataset['cls']])\n\n return None","def main():\r\n # Read dataset.\r\n reader = DatasetReader\r\n train_filename = sys.argv[1]\r\n test_filename = train_filename.replace('_train_', '_dev_')\r\n term_index, tag_index, train_data, test_data = reader.ReadData(train_filename, test_filename)\r\n (train_terms, train_tags, train_lengths) = train_data\r\n (test_terms, test_tags, test_lengths) = test_data\r\n\r\n model = SequenceModel(train_tags.shape[1], len(term_index), len(tag_index))\r\n model.build_inference()\r\n model.build_training()\r\n for j in range(5):\r\n model.train_epoch(train_terms,train_tags, train_lengths)\r\n print('Finished epoch %i. Evaluating ...' % (j+1))\r\n model.evaluate(test_terms, test_tags, test_lengths)","def train(nepochs, model): \n if model == 'cnn':\n return gennet.train_cnn(nepochs, 'Resnet50')\n elif model == 'logreg':\n return gennet.train_logreg('Resnet50')","def resume_routine_resnet_multibranch(config, verbose=(2,2),\n weights_path='',\n nb_epoch_finetune=0, nb_epoch_after=50,\n stiefel_observed=None, stiefel_lr=0.01,\n by_name=False):\n image_gen = ImageDataGeneratorAdvanced(TARGET_SIZE, RESCALE_SMALL, True,\n horizontal_flip=True,\n )\n resume_model_with_config(ResNet50_o2_multibranch, config,\n weights_path=weights_path,\n title='mit_indoor_resnet_MB',\n verbose=verbose, image_gen=image_gen,\n nb_epoch_after=nb_epoch_after, nb_epoch_finetune=nb_epoch_finetune,\n stiefel_lr=stiefel_lr, stiefel_observed=stiefel_observed,\n by_name=by_name)","def test_cifar(args):\n # type: () -> None\n\n # Build dataset and model\n dataset = CIFAR10(path=args.path)\n model = MEMCIFAR10(input_shape=dataset.shape, code_length=64, cpd_channels=100, mem_dim=500, shrink_thres=1.0 / 500).cuda().eval()\n\n # Set up result helper and perform test\n helper = MEMResultHelper(dataset, model, checkpoints_dir=args.checkpoints, output_file='mem_cifar.txt')\n helper.test_one_class_classification()","def __train__(self):\n if (self.type_camf == 'CAMF_CI'):\n #users, items, context, ratings\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = ci.fit()\n elif (self.type_camf == 'CAMF_CU'):\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = cu.fit()\n elif (self.type_camf == 'CAMF_C'):\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = c.fit()\n\n dummy_pred = np.zeros((predictions.shape))\n for r, pred_array in enumerate(predictions):\n for c, pred in enumerate(pred_array):\n dummy_pred[r][c] = self.__check_ratings__(pred)\n predictions = dummy_pred\n #save a plot with a loss function\n plots = prs.PlotRSData()\n #print(losses)\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\"_loop\"+str(self.loop))\n pd.DataFrame(losses).to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ +\"losses_loop\"+str(self.loop)+\".csv\")\n print('Saving the feature matrix...')\n # set predictions back to the pivot table\n self.__utility_saved_training__(predictions) \n # save results\n self.utility_predictions.to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ + \"_SGD_predictions_loop\"+str(self.loop)+\".csv\")","def cifar10(transform=transforms.ToTensor()):\n\n\t# Directories\n\tscript_dir = os.path.dirname(os.path.realpath(__file__))\n\tdata_dir = os.path.join(script_dir, 'data', 'cifar10')\n\n\t# Load training set, downloading if necessary\n\tdataset = datasets.CIFAR10(data_dir, train=True, transform=transform, download=True)\n\n\t# Split into train, val, and test sets\n\n\t# Add 'classes' list and 'class_to_idx' lookup dictionary to both sets\n\tclasses = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', \n\t\t'horse', 'ship', 'truck']\n\tclass_to_idx = {classes[i]: i for i in range(len(classes))}\n\n\tdataset.classes = classes\n\tdataset.class_to_idx = class_to_idx\n\n\treturn dataset","def create_dataset_cifar10(data_path, batch_size=32, num_parallel_workers=8, do_train=True):\r\n # define dataset\r\n data_path = os.path.join(data_path, \"cifar-10-batches-bin\" if do_train else \"cifar-10-verify-bin\")\r\n\r\n cifar_ds = ds.Cifar10Dataset(data_path, num_parallel_workers=num_parallel_workers, shuffle=do_train)\r\n\r\n # define map operations\r\n resize_height, resize_width = 32, 32\r\n rescale = 1.0 / 255.0\r\n shift = 0.0\r\n random_crop_op = CV.RandomCrop([32, 32], [4, 4, 4, 4])\r\n random_horizontal_op = CV.RandomHorizontalFlip(prob=0.5)\r\n resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\r\n rescale_op = CV.Rescale(rescale, shift)\r\n normalize_op = CV.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\r\n hwc2chw_op = CV.HWC2CHW()\r\n type_cast_op = C.TypeCast(mstype.int32)\r\n\r\n if do_train:\r\n compose_op = [random_crop_op, random_horizontal_op, resize_op, rescale_op, normalize_op, hwc2chw_op]\r\n else:\r\n compose_op = [resize_op, rescale_op, normalize_op, hwc2chw_op]\r\n cifar_ds = cifar_ds.map(input_columns=\"image\", operations=compose_op, num_parallel_workers=num_parallel_workers)\r\n cifar_ds = cifar_ds.map(input_columns=\"label\", operations=type_cast_op, num_parallel_workers=num_parallel_workers)\r\n cifar_ds = cifar_ds.batch(batch_size, drop_remainder=True)\r\n\r\n return cifar_ds","def execute(self):\n for csnn_config in self.__config[\"csnnConfigs\"]:\n csnn_name = csnn_config[\"modelName\"]\n\n try:\n for dataset_config in self.__config[\"datasetConfigs\"]:\n provider = getDatasetProvider(dataset_config)\n if not dataset_config[\"nameOfDataset\"] in csnn_config[\"batchSizes\"].keys():\n continue\n for i in range(0, csnn_config[\"xFoldCrossValidation\"]):\n model_dir = \"/\" + csnn_name + \"/\" + dataset_config[\"nameOfDataset\"] + \"/xFoldCrossVal\" + str(i)\n self.__logger.info(\"Starting to train: \" + model_dir, \"CsnnVisualizationExperiment:execute\")\n\n if csnn_config[\"xFoldCrossValidation\"] <= 1:\n xseed = None\n else:\n xseed = 42 + i\n\n dataset, dataset_generator = prepareDataset(provider, dataset_config, xfold_seed=xseed,\n augment_data=csnn_config[\"augmentData\"])\n\n dataset_max_div, _ = prepareDataset(provider, dataset_config, xfold_seed=xseed,\n augment_data=csnn_config[\"augmentData\"],\n normalize_data=\"maxDiv\")\n\n self.__logger.info(\"Starting to create dataset encoding with: \" + model_dir,\n \"CsnnVisualizationExperiment:execute\")\n encoding_provider, encoding = prepareEncoding(csnn_config, dataset_generator, dataset,\n dataset_config, csnn_name, self.__num_gpus,\n model_dir + \"/Csnn\", zero_mean_unit_variance=\n csnn_config[\"zeroMeanUnitVarianceEncoding\"],\n return_with_encoding=dataset_max_div)\n\n self.__logger.info(\"Finished to create dataset encoding with: \" + model_dir,\n \"CsnnVisualizationExperiment:execute\")\n\n self.__logger.info(\"Starting to create mean activities for: \" + model_dir,\n \"CsnnVisualizationExperiment:execute\")\n enc_for_label = {}\n for i in range(0, len(encoding[\"y_test\"])):\n enc_for_label.setdefault(np.argmax(encoding[\"y_test\"][i]), []).append(encoding[\"x_test\"][i])\n\n mean_ecs_for_label = []\n for key, value in sorted(enc_for_label.items()):\n mean_ec_for_label = np.mean(np.mean(np.mean(value, axis=0), axis=0), axis=0)\n grid = csnn_config[\"layers\"][-1][\"somGrid\"]\n mean_ec_for_label = np.reshape(mean_ec_for_label, [grid[0], grid[1], grid[2]])\n mean_ecs_for_label.append(mean_ec_for_label)\n\n # Dir to save and reload model.\n save_path = os.path.dirname(\n sys.modules['__main__'].__file__) + \"/experimentResults\" + model_dir\n if not os.path.exists(save_path):\n os.makedirs(save_path)\n np.save(save_path + \"/test_mean_acts\", np.array(mean_ecs_for_label))\n self.__logger.info(\"Finised to create mean activities for: \" + model_dir,\n \"CsnnVisualizationExperiment:execute\")\n\n self.__logger.info(\"Starting to create mean sub activities for: \" + model_dir,\n \"CsnnVisualizationExperiment:execute\")\n sub_encs = []\n for enc in mean_ecs_for_label:\n sub_encs_for_label = []\n for kenc2 in mean_ecs_for_label:\n sub_enc = enc - kenc2\n sub_encs_for_label.append(sub_enc)\n sub_encs.append(sub_encs_for_label)\n\n np.save(save_path + \"/test_sub_mean_acts\", np.array(sub_encs))\n self.__logger.info(\"Finished to create mean sub activities for: \" + model_dir,\n \"CsnnVisualizationExperiment:execute\")\n\n except Exception:\n print(traceback.format_exc())","def main(Args):\n norm = [1.9844158727667542, 413.83759806375525,\n 51.2789974336363, 1038.4760551905683]\n input_pull = False\n input_model_mapping = False\n max_number = 2\n count = 40000\n catalog_name = os.path.join(DATA_PATH, 'OneDegSq.fits')\n # Define parameters for mrcnn model with btk here\n resid_model = btk_utils.Resid_btk_model(\n Args.model_name, Args.model_path, MODEL_DIR, training=True,\n images_per_gpu=4, validation_for_training=True)\n # Load parameters for dataset and load model\n resid_model.config.WEIGHT_DECAY = 0.001\n resid_model.config.STEPS_PER_EPOCH = 1000\n resid_model.config.VALIDATION_STEPS = 20\n sampling_function = None\n layers = 'all'\n if Args.model_name == 'model1':\n resid_model.config.BACKBONE = 'resnet41'\n elif Args.model_name == 'model2':\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n elif Args.model_name == 'model3':\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n elif Args.model_name == 'model4':\n resid_model.config.TRAIN_BN = None\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n elif Args.model_name == 'model5':\n resid_model.config.TRAIN_BN = None\n resid_model.config.BACKBONE = 'resnet35'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n elif Args.model_name == 'model4_large':\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = '4+' # '3+'\n elif Args.model_name == 'model6':\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0, 1, 51.2789974336363, 1038.4760551905683]\n input_pull = True\n elif Args.model_name == 'model7':\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model8': # stretch = 0.1, Q = 3\n resid_model.config.TRAIN_BN = None\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model9': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = None\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model10': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = None\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1., 0, 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model10_again': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = None\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model10_again2': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = None\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model10_again3': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model10_2': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1.45, 0., 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model11': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1., 0., 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model11_2': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1., 0., 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n elif Args.model_name == 'model12': # stretch = 2000, Q = 0.5\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n max_number = 6\n elif Args.model_name == 'model12_again': # stretch = 2000, Q = 0.5 # larger learning rate\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n max_number = 10 # changed from 6 to 10 for run 4\n elif Args.model_name == 'model12_again2': # stretch = 2000, Q = 0.5 # larger learning rate val set reduced to 10\n resid_model.config.TRAIN_BN = False\n resid_model.config.BACKBONE = 'resnet41'\n resid_model.config.SKIP_P2_RPN = True\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\n sampling_function = btk_utils.resid_general_sampling_function_large\n layers = 'all'\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\n input_pull = True\n input_model_mapping = True\n max_number = 6\n resid_model.config.VALIDATION_STEPS = 10\n else:\n raise AttributeError(\"model not found\", Args.model_name)\n print(\"Train in model:\", Args.model_name)\n resid_model.config.display()\n resid_model.make_resid_model(catalog_name, count=count,\n max_number=max_number, augmentation=True,\n norm_val=norm, input_pull=input_pull,\n sampling_function=sampling_function,\n input_model_mapping=input_model_mapping)\n learning_rate = resid_model.config.LEARNING_RATE/10.\n np.random.seed(Args.epochs)\n history = resid_model.model.train(resid_model.dataset,\n resid_model.dataset_val,\n learning_rate=learning_rate,\n epochs=Args.epochs,\n layers=layers)\n name = Args.model_name + '_run2'\n with open(name + \".dill\", 'wb') as handle:\n dill.dump(history.history, handle)\n learning_rate = resid_model.config.LEARNING_RATE/10.\n np.random.seed(Args.epochs + 10)\n history = resid_model.model.train(resid_model.dataset,\n resid_model.dataset_val,\n learning_rate=learning_rate,\n epochs=Args.epochs+10,\n layers=layers)\n name = Args.model_name + '_run3'\n with open(name + \".dill\", 'wb') as handle:\n dill.dump(history.history, handle)","def train_keras():\n epochs = 2\n strategy = tf.distribute.MirroredStrategy()\n global_batch_size = strategy.num_replicas_in_sync * 32\n train_dataset = create_dataset(global_batch_size)\n\n with strategy.scope():\n model = ResNet50(input_shape=(224, 224, 3), num_classes=1000)\n model.compile(loss=tf.keras.losses.CategoricalCrossentropy(),\n optimizer=tf.keras.optimizers.Adam(),\n metrics=['accuracy'])\n model.fit(train_dataset, epochs=epochs)","def configure_training_centralized(\n task_spec: training_specs.TaskSpecCentralized,\n *, # Caller passes below args by name.\n resnet_layers: int = 18,\n num_classes: int = 100,\n l2_weight_decay: float = 1e-4,\n) -> training_specs.RunnerSpecCentralized:\n\n return _Cifar100ImageTask(\n task_spec,\n resnet_layers=resnet_layers,\n num_classes=num_classes,\n l2_weight_decay=l2_weight_decay).build_centralized_runner_spec()","def load_dataset_cifar10():\n dirname = 'cifar-10-batches-py'\n origin = 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'\n path = get_file(dirname, origin=origin, untar=True)\n\n num_train_samples = 50000\n\n x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')\n y_train = np.empty((num_train_samples,), dtype='uint8')\n\n for i in range(1, 6):\n fpath = os.path.join(path, 'data_batch_' + str(i))\n (x_train[(i - 1) * 10000: i * 10000, :, :, :],\n y_train[(i - 1) * 10000: i * 10000]) = load_batch(fpath)\n\n fpath = os.path.join(path, 'test_batch')\n x_test, y_test = load_batch(fpath)\n\n y_train = np.reshape(y_train, (len(y_train), 1))\n y_test = np.reshape(y_test, (len(y_test), 1))\n\n return (x_train, y_train), (x_test, y_test)","def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n # Load the raw CIFAR-10 data\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n\n # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n try:\n del X_train, y_train\n del X_test, y_test\n print('Clear previously loaded data.')\n except:\n pass\n\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n\n # Subsample the data\n mask = list(range(num_training, num_training + num_validation))\n X_val = X_train[mask]\n y_val = y_train[mask]\n mask = list(range(num_training))\n X_train = X_train[mask]\n y_train = y_train[mask]\n mask = list(range(num_test))\n X_test = X_test[mask]\n y_test = y_test[mask]\n\n # Normalize the data: subtract the mean image\n mean_image = np.mean(X_train, axis=0)\n X_train -= mean_image\n X_val -= mean_image\n X_test -= mean_image\n\n # Reshape data to rows\n X_train = X_train.reshape(num_training, -1)\n X_val = X_val.reshape(num_validation, -1)\n X_test = X_test.reshape(num_test, -1)\n\n return X_train, y_train, X_val, y_val, X_test, y_test","def train(self):\n if not os.path.isdir(self.C.log_path):\n os.mkdir(self.C.log_path)\n \n callback = TensorBoard(self.C.log_path, write_graph=True, write_images=True)\n callback.set_model(self.model_all)\n\n epoch_length = self.C.epoch_length\n epochs = self.C.epochs\n iter_num = 0\n train_step = 0\n\n losses = np.zeros((epoch_length, 5))\n rpn_accuracy_monitor = []\n rpn_accuracy_epoch = []\n best_loss = np.Inf\n start_time = time.time()\n\n for epoch in range(epochs):\n progbar = generic_utils.Progbar(epoch_length)\n print('Epoch {}/{}'.format(epoch + 1, epochs))\n\n while True:\n if len(rpn_accuracy_monitor) == epoch_length and self.C.verbose:\n mean_overlapping_bboxes = float(sum(rpn_accuracy_monitor)) / len(rpn_accuracy_monitor)\n rpn_accuracy_monitor = []\n print('Average number of overlapping bounding boxes from RPN = {} for {} previous iterations'.format(mean_overlapping_bboxes, epoch_length))\n if mean_overlapping_bboxes == 0:\n print('RPN is not producing bounding boxes that overlap the ground truth boxes. Check RPN settings or keep training.')\n\n # data generator\n X, Y, img_data = next(self.data_gen_train)\n\n loss_rpn = self.model_region_proposal.train_on_batch(X, Y)\n self._write_log(callback, ['rpn_cls_loss', 'rpn_reg_loss'], loss_rpn, train_step)\n\n P_rpn = self.model_region_proposal.predict_on_batch(X)\n\n R = roi_helpers.rpn_to_roi(P_rpn[0], P_rpn[1], self.C, K.image_data_format(), use_regr=True, overlap_thresh=0.7, max_boxes=300)\n # note: calc_iou converts from (x1,y1,x2,y2) to (x,y,w,h) format\n X2, Y1, Y2, IouS = roi_helpers.calc_iou(R, img_data, self.C, self.class_mapping)\n\n if X2 is None:\n rpn_accuracy_monitor.append(0)\n rpn_accuracy_epoch.append(0)\n continue\n \n # sampling positive/negative samples\n neg_samples = np.where(Y1[0, :, -1] == 1)\n pos_samples = np.where(Y1[0, :, -1] == 0)\n\n if len(neg_samples) > 0:\n neg_samples = neg_samples[0]\n else:\n neg_samples = []\n\n if len(pos_samples) > 0:\n pos_samples = pos_samples[0]\n else:\n pos_samples = []\n\n rpn_accuracy_monitor.append(len(pos_samples))\n rpn_accuracy_epoch.append((len(pos_samples)))\n\n if self.C.num_roi > 1:\n if len(pos_samples) < self.C.num_roi//2:\n selected_pos_samples = pos_samples.tolist()\n else:\n selected_pos_samples = np.random.choice(pos_samples, \n self.C.num_roi//2, \n replace=False).tolist()\n try:\n selected_neg_samples = np.random.choice(neg_samples, \n self.C.num_roi-len(selected_pos_samples), \n replace=False).tolist()\n except:\n selected_neg_samples = np.random.choice(neg_samples, \n self.C.num_roi-len(selected_pos_samples), \n replace=True).tolist()\n sel_samples = selected_pos_samples + selected_neg_samples\n \n else:\n # in the extreme case where num_roi = 1, we pick a random pos or neg sample\n selected_pos_samples = pos_samples.tolist()\n selected_neg_samples = neg_samples.tolist()\n if np.random.randint(0, 2):\n sel_samples = random.choice(neg_samples)\n else:\n sel_samples = random.choice(pos_samples)\n\n loss_class = self.model_classifier.train_on_batch([X, X2[:, sel_samples, :]], \n [Y1[:, sel_samples, :], \n Y2[:, sel_samples, :]])\n self._write_log(callback, \n ['detection_cls_loss', 'detection_reg_loss', 'detection_acc'], \n loss_class, train_step)\n train_step += 1\n\n losses[iter_num, 0] = loss_rpn[1]\n losses[iter_num, 1] = loss_rpn[2]\n losses[iter_num, 2] = loss_class[1]\n losses[iter_num, 3] = loss_class[2]\n losses[iter_num, 4] = loss_class[3]\n\n iter_num += 1\n\n progbar.update(iter_num, \n [('rpn_cls', np.mean(losses[:iter_num, 0])), \n ('rpn_regr', np.mean(losses[:iter_num, 1])),\n ('det_cls', np.mean(losses[:iter_num, 2])), \n ('det_regr', np.mean(losses[:iter_num, 3]))])\n\n if iter_num == epoch_length:\n loss_rpn_cls = np.mean(losses[:, 0])\n loss_rpn_regr = np.mean(losses[:, 1])\n loss_class_cls = np.mean(losses[:, 2])\n loss_class_regr = np.mean(losses[:, 3])\n class_acc = np.mean(losses[:, 4])\n\n mean_overlapping_bboxes = float(sum(rpn_accuracy_epoch)) / len(rpn_accuracy_epoch)\n rpn_accuracy_epoch = []\n\n if self.C.verbose:\n print('Mean number of bounding boxes from RPN overlapping ground truth boxes: {}'.format(mean_overlapping_bboxes))\n print('Classifier accuracy for bounding boxes from RPN: {}'.format(class_acc))\n print('Loss RPN classifier: {}'.format(loss_rpn_cls))\n print('Loss RPN regression: {}'.format(loss_rpn_regr))\n print('Loss Detector classifier: {}'.format(loss_class_cls))\n print('Loss Detector regression: {}'.format(loss_class_regr))\n print('Elapsed time: {}'.format(time.time() - start_time))\n\n curr_loss = loss_rpn_cls + loss_rpn_regr + loss_class_cls + loss_class_regr\n iter_num = 0\n start_time = time.time()\n\n self._write_log(callback,\n ['Elapsed_time', 'mean_overlapping_bboxes', 'mean_rpn_cls_loss', \n 'mean_rpn_reg_loss', 'mean_detection_cls_loss', 'mean_detection_reg_loss', \n 'mean_detection_acc', 'total_loss'],\n [time.time() - start_time, mean_overlapping_bboxes, loss_rpn_cls, \n loss_rpn_regr, loss_class_cls, loss_class_regr, class_acc, curr_loss],\n epoch)\n\n if curr_loss < best_loss:\n if self.C.verbose:\n print('Total loss decreased from {} to {}, saving weights'.format(best_loss,curr_loss))\n best_loss = curr_loss\n self.model_all.save_weights(self.C.model_path)\n break\n \n print(\"traing completed.\")","def _train(args): \n\n #device = 'cuda' if torch.cuda.is_available() else 'cpu'\n device = 'cpu'\n logger.info(\"Device Type: {}\".format(device))\n\n logger.info(\"Loading SUN360 dataset\")\n transform = transforms.Compose(\n [transforms.Resize((224,224)),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n target_transform = transforms.Compose([transforms.Resize((224,224)),\n transforms.ToTensor()]) \n\n trainset = SUN360Dataset(\"imagedata.json\",transform = transform, target_transform = target_transform)\n train_loader = DataLoader(trainset, batch_size=args.batch_size,\n shuffle=True, num_workers=args.workers)\n \"\"\"\n testset = torchvision.datasets.CIFAR10(root=args.data_dir, train=False,\n download=False, transform=transform)\n test_loader = DataLoader(testset, batch_size=args.batch_size,\n shuffle=False, num_workers=args.workers)\n \"\"\" \n\n logger.info(\"Model loaded\")\n model = EfficientNet.from_name('efficientnet-b0',conv_type='Equi')\n\n if torch.cuda.device_count() > 1:\n logger.info(\"Gpu count: {}\".format(torch.cuda.device_count()))\n model = nn.DataParallel(model)\n\n model = model.to(device)\n\n criterion = CELoss().to(device)\n optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)\n\n for epoch in range(0, args.epochs):\n running_loss = 0.0\n for i, data in enumerate(train_loader):\n # get the inputs\n inputs, EM , CM = data\n inputs, EM, CM = inputs.to(device), EM.to(device), CM.to(device)\n\n # zero the parameter gradients\n optimizer.zero_grad()\n\n # forward + backward + optimize\n outputs = model(inputs)\n EMLoss, CMLoss = map_loss(outputs,EM,CM,criterion)\n loss = EMLoss + CMLoss\n loss.backward()\n optimizer.step()\n\n # print statistics\n running_loss += loss.item()\n if i % 2000 == 1999: # print every 2000 mini-batches\n print('[%d, %5d] loss: %.3f' %\n (epoch + 1, i + 1, running_loss / 2000))\n running_loss = 0.0\n print('Finished Training')\n return _save_model(model, args.model_dir)","def train_one_epoch(self):\n print('Training......')\n\n # set mode train\n self.network.train()\n\n # prepare data\n train_loss = 0\n transform = transforms.Compose([Rescale(params.rescale_size),\n RandomCrop(params.image_size),\n RandomHorizontalFlip(),\n ToTensor()\n ])\n\n\n\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\n\n train_loader = DataLoader(dataset,\n batch_size=params.train_batch,\n shuffle=params.shuffle,\n num_workers=params.dataloader_workers)\n \n train_size = 1896\n if train_size % self.params.train_batch != 0:\n total_batch = train_size // self.params.train_batch + 1\n else:\n total_batch = train_size // self.params.train_batch\n recal = 0\n precision = 0\n F_one = 0\n IOU = 0\n accuracy_new = 0 \n # train through dataset\n for batch_idx, batch in enumerate(train_loader):\n self.pb.click(batch_idx, total_batch)\n image, label = batch['image'], batch['label']\n image_cuda, label_cuda = image.cuda(), label.cuda()\n\n # checkpoint split\n if self.params.should_split:\n image_cuda.requires_grad_()\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\n else:\n out = self.network(image_cuda)\n\n\n loss = self.loss_fn(out, label_cuda)\n \n #display_image(out, label_cuda)\n TP, FP, TN, FN = confusion(out, label_cuda)\n recal = recal+TP\n precision = precision+FP\n F_one = F_one + TN\n IOU = IOU+ FN \n accuracy_final = accuracy(out, label_cuda)\n accuracy_new = accuracy_new + accuracy_final\n\n # optimize\n self.opt.zero_grad()\n loss.backward()\n self.opt.step()\n\n # accumulate\n train_loss += loss.item()\n\n # record first loss\n if self.train_loss == []:\n self.train_loss.append(train_loss)\n self.summary_writer.add_scalar('loss/train_loss', train_loss, 0)\n \n print(\"\\t\")\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\n print(accuracy_new/total_batch)\n \n self.pb.close()\n train_loss /= total_batch\n self.train_loss.append(train_loss)\n\n # add to summary\n self.summary_writer.add_scalar('loss/train_loss', train_loss, self.epoch)","def run_rfc():\n num_folds = 5\n with pd.HDFStore('./OT_clr_train_LGG_grade.h5') as store:\n X = store['expression'].values\n Y = store['labels'].values\n\n # standardize expression\n mu = np.mean(X,axis=0)\n std = np.std(X, axis=0)\n X = (X-mu)/std\n\n # define Predictor object to manage nested CV\n rf_predictor = Predictor(\n CVmodel(RandomForestClassifier_skl,[4,8,16,32,64,128], 'max_depth',\n n_estimators=100, n_jobs=-1),\n scorers.accuracy_scorer)\n # cross validate\n rf_cross_validation_scores = \\\n rf_predictor.cross_validate(X, Y,\n outer_folds=num_folds, inner_folds=num_folds)\n logger.info('Random Forest cross-validation = {0:.3f}'.format(\n np.mean(rf_cross_validation_scores)))","def train():\r\n print('Loading and compiling models...')\r\n model_systole = get_model()\r\n model_diastole = get_model()\r\n\r\n # load the preprocessed data with the heart cut-out\r\n print('Loading data...')\r\n X_train, scaling_train, ids_train, y_train = load_train_data()\r\n X_test, scaling_test, ids_test, y_test = load_test_data()\r\n\r\n nb_iter = 200 # a higher number seems to give rise to overfitting\r\n epochs_per_iter = 3 # reduces overfitting\r\n batch_size = 32 # not tuned - potential improvement\r\n calc_crps = 2 # calculate CRPS every n-th iteration (set to 0 if CRPS estimation is not needed)\r\n\r\n # remember min val. losses (best iterations), used as sigmas for submission\r\n min_val_loss_systole = sys.float_info.max\r\n min_val_loss_diastole = sys.float_info.max\r\n\r\n print('-'*50)\r\n print('Training...')\r\n print('-'*50)\r\n\r\n for i in range(nb_iter):\r\n print('-'*50)\r\n print('Iteration {0}/{1}'.format(i + 1, nb_iter))\r\n print('-'*50)\r\n\r\n # augment data to make up for low number of samples\r\n print('Augmenting images - rotations')\r\n X_train_aug = rotation_augmentation(X_train, 15)\r\n print('Augmenting images - shifts')\r\n X_train_aug = shift_augmentation(X_train_aug, 0.1, 0.1)\r\n\r\n print('Fitting systole model...')\r\n hist_systole = model_systole.fit([X_train_aug, scaling_train], y_train[:, 0], shuffle=True, nb_epoch=epochs_per_iter,\r\n batch_size=batch_size, validation_data=([X_test, scaling_test], y_test[:, 0]))\r\n\r\n print('Fitting diastole model...')\r\n hist_diastole = model_diastole.fit([X_train_aug, scaling_train], y_train[:, 1], shuffle=True, nb_epoch=epochs_per_iter,\r\n batch_size=batch_size, validation_data=([X_test, scaling_test], y_test[:, 1]))\r\n\r\n # sigmas for predicted data, actually loss function values (RMSE)\r\n loss_systole = hist_systole.history['loss'][-1]\r\n loss_diastole = hist_diastole.history['loss'][-1]\r\n val_loss_systole = hist_systole.history['val_loss'][-1]\r\n val_loss_diastole = hist_diastole.history['val_loss'][-1]\r\n\r\n if calc_crps > 0 and i % calc_crps == 0:\r\n print('Evaluating CRPS...')\r\n pred_systole = model_systole.predict([X_train, scaling_train], batch_size=batch_size, verbose=1)\r\n pred_diastole = model_diastole.predict([X_train, scaling_train], batch_size=batch_size, verbose=1)\r\n val_pred_systole = model_systole.predict([X_test, scaling_test], batch_size=batch_size, verbose=1)\r\n val_pred_diastole = model_diastole.predict([X_test, scaling_test], batch_size=batch_size, verbose=1)\r\n\r\n # CDF for train and test data (actually a step function)\r\n cdf_train = real_to_cdf(np.concatenate((y_train[:, 0], y_train[:, 1])))\r\n cdf_test = real_to_cdf(np.concatenate((y_test[:, 0], y_test[:, 1])))\r\n\r\n # CDF for predicted data\r\n cdf_pred_systole = real_to_cdf(pred_systole, loss_systole)\r\n cdf_pred_diastole = real_to_cdf(pred_diastole, loss_diastole)\r\n cdf_val_pred_systole = real_to_cdf(val_pred_systole, val_loss_systole)\r\n cdf_val_pred_diastole = real_to_cdf(val_pred_diastole, val_loss_diastole)\r\n\r\n # evaluate CRPS on training data\r\n crps_train = crps(cdf_train, np.concatenate((cdf_pred_systole, cdf_pred_diastole)))\r\n print('CRPS(train) = {0}'.format(crps_train))\r\n\r\n # evaluate CRPS on test data\r\n crps_test = crps(cdf_test, np.concatenate((cdf_val_pred_systole, cdf_val_pred_diastole)))\r\n print('CRPS(test) = {0}'.format(crps_test))\r\n\r\n print('Saving weights...')\r\n # save weights so they can be loaded later\r\n model_systole.save_weights('weights_systole.hdf5', overwrite=True)\r\n model_diastole.save_weights('weights_diastole.hdf5', overwrite=True)\r\n\r\n # for best (lowest) val losses, save weights\r\n if val_loss_systole < min_val_loss_systole:\r\n min_val_loss_systole = val_loss_systole\r\n model_systole.save_weights('weights_systole_best.hdf5', overwrite=True)\r\n\r\n if val_loss_diastole < min_val_loss_diastole:\r\n min_val_loss_diastole = val_loss_diastole\r\n model_diastole.save_weights('weights_diastole_best.hdf5', overwrite=True)\r\n\r\n # save best (lowest) val losses in file (to be later used for generating submission)\r\n with open('val_loss.txt', mode='w+') as f:\r\n f.write(str(min_val_loss_systole))\r\n f.write('\\n')\r\n f.write(str(min_val_loss_diastole))","def build_resnet152(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\n conv1_feats = nonlinear(conv1_feats, 'relu')\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\n\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\n \n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \n temp = res3a_feats\n for i in range(1, 8):\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\n res3b7_feats = temp\n \n res4a_feats = self.basic_block(res3b7_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\n temp = res4a_feats\n for i in range(1, 36):\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\n res4b35_feats = temp\n\n res5a_feats = self.basic_block(res4b35_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\n\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\n self.conv_feats = res5c_feats_flat\n self.conv_feat_shape = [49, 2048]\n self.num_ctx = 49 \n self.dim_ctx = 2048\n\n self.imgs = imgs\n self.is_train = is_train","def ffc_resnet101(pretrained=False, **kwargs):\n model = FFCResNet(Bottleneck, [3, 4, 23, 3], **kwargs)\n return model","def cifar10_bin_model_fn(features, labels, mode, params):\n\n network = resnet_model.cifar10_resnet_v2_generator(\n params['resnet_size'], _NUM_CLASSES, params['data_format']\n )\n\n inputs = tf.reshape(features, [-1, _HEIGHT, _WIDTH, _DEPTH])\n clabels = labels[:, :_NUM_CLASSES]\n \n # logits = network(inputs, mode == tf.estimator.ModeKeys.TRAIN)\n logits = network(inputs, mode == tf.estimator.ModeKeys.TRAIN, name=\"main\")\n probs = tf.sigmoid(logits)\n\n # slabels, smask = smooth_neg_labels(clabels, params[\"cutoff_weight\"], params[\"pen_prob\"])\n # slabels, smask = smooth_neg_labels(clabels, 1*1/_NUM_CLASSES, 0.45)\n bt_loss = tf.reduce_mean(per_class_bin_loss(probs, clabels, params[\"milden\"]), axis=1)\n\n loss = tf.reduce_mean(bt_loss, axis=0)\n loss = tf.identity(loss, name=\"loss_vec\")\n loss_sum = tf.summary.scalar(\"loss\", loss)\n\n probs_cal = tf.sigmoid(logits/params[\"temp\"])\n rate = tf.reduce_max(probs_cal, axis=1)\n\n # loss = tf.Print(loss, [smask], summarize=100, message=\"smask: \")\n # loss = tf.Print(loss, [tf.reduce_mean(probs)], summarize=100, message=\"mean: \")\n # loss = tf.Print(loss, [rate], summarize=100, message=\"rate: \")\n # loss = tf.Print(loss, [clabels, slabels], summarize=100, message=\"slabels: \")\n\n classes = tf.argmax(logits, axis=1)\n accuracy_m = tf.metrics.accuracy( tf.argmax(clabels, axis=1), classes, name=\"accuracy_metric\")\n accuracy = tf.identity(accuracy_m[1], name=\"accuracy_vec\")\n accuracy_sum = tf.summary.scalar(\"accuracy\", accuracy)\n\n if mode == tf.estimator.ModeKeys.EVAL or params[\"predict\"]:\n\n # print # note this is labels not clabels\n print_labels = tf.argmax(labels, axis=1)\n print_rate = rate\n print_probs = probs\n print_logits = logits\n\n hooks = []\n eval_metric_ops = { \"accuracy\": accuracy_m }\n\n # # printing stuff if predict\n if params[\"predict\"]:\n loss = tf.Print(loss, [print_labels], summarize=1000000, message='Targets')\n loss = tf.Print(loss, [print_rate], summarize=1000000, message='Rate')\n loss = tf.Print(loss, [print_probs], summarize=1000000, message='Probs')\n loss = tf.Print(loss, [print_logits], summarize=1000000, message='Logits')\n hooks = []\n eval_metric_ops = {}\n\n return tf.estimator.EstimatorSpec(\n mode=mode,\n loss=loss,\n eval_metric_ops = eval_metric_ops,\n # evaluation_hooks=hooks,\n )\n\n if mode == tf.estimator.ModeKeys.TRAIN:\n # Scale the learning rate linearly with the batch size. When the batch size\n # is 128, the learning rate should be 0.1.\n initial_learning_rate = 0.1 * params['batch_size'] / 128\n batches_per_epoch = _NUM_IMAGES['train'] / params['batch_size']\n global_step = tf.train.get_or_create_global_step()\n\n # Multiply the learning rate by 0.1 at 100, 150, and 200 epochs.\n boundaries = [int(batches_per_epoch * epoch) for epoch in [100, 150, 200]]\n values = [initial_learning_rate * decay for decay in [1, 0.1, 0.01, 0.001]]\n learning_rate = tf.train.piecewise_constant(\n tf.cast(global_step, tf.int32), boundaries, values, name=\"learning_rate_vec\")\n\n learning_rate_sum = tf.summary.scalar(\"learning_rate\", learning_rate)\n\n optimizer = tf.train.MomentumOptimizer(\n learning_rate=learning_rate,\n momentum=_MOMENTUM\n )\n\n # Batch norm requires update ops to be added as a dependency to the train_op\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n with tf.control_dependencies(update_ops):\n train_op = optimizer.minimize(loss, global_step)\n\n hook = tf.train.SummarySaverHook(\n summary_op=tf.summary.merge([accuracy_sum, learning_rate_sum]),\n save_steps=1,\n )\n return tf.estimator.EstimatorSpec(\n mode=mode,\n loss=loss,\n train_op=train_op,\n training_hooks=[hook],\n )","def grid_search(train_labels: str, \n test_labels: str, \n output:str, \n res:tuple=(120, 160), \n lazy:bool=True, \n batch_size:int=16, \n epochs:int=20):\n\n # Data\n print(\"=> Loading data.\")\n train = FLIRDataset(train_labels, res=res, batch_size=batch_size)\n test = FLIRDataset(test_labels, res=res, batch_size=batch_size)\n\n # In eager loading mode, train on everything.\n if not lazy:\n X_train, y_train = train.get_all()\n X_test, y_test = test.get_all()\n X_train = np.concatenate([X_train, X_test], axis=0)\n y_train = np.concatenate([y_train, y_test], axis=0)\n\n\n def net(x, num_classes=1):\n x = K.applications.resnet_v2.ResNet50V2(include_top=False, weights=None, input_shape=x.shape[1:])(x)\n x = K.layers.Flatten()(x)\n x = K.layers.Dense(num_classes, activation=\"softmax\")(x)\n return x\n\n print(\"\\n=> Training model.\")\n input_tensor = K.layers.Input((160, 120, 1))\n output_tensor = net(input_tensor, num_classes=train.num_classes())\n model = K.Model(input_tensor, output_tensor)\n\n model.compile(optimizer=\"sgd\",\n loss=\"categorical_crossentropy\",\n metrics=[\"accuracy\"])\n\n # Train model\n if lazy:\n model.fit(x=train, \n epochs=epochs, \n validation_data=train, \n verbose=2)\n else:\n model.fit(x=X_train, \n y=y_train, \n epochs=epochs, \n batch_size=batch_size, \n verbose=2)\n\n # Save weights\n model.save_weights(os.path.join(output, \"flir_pretrained_weights.h5\"))","def main():\n logger.info(\"=> creating model ...\")\n logger.info(\"Classes: %s\", cfg.classes)\n\n value_scale = 255\n mean = [0.485, 0.456, 0.406]\n mean = [item * value_scale for item in mean]\n std = [0.229, 0.224, 0.225]\n std = [item * value_scale for item in std]\n gray_folder = os.path.join(cfg.result_path, 'gray')\n color_folder = os.path.join(cfg.result_path, 'color')\n\n test_transform = pt_transform.Compose([pt_transform.Normalize(mean=mean, std=std, is_train=False)])\n\n if cfg.data_root[-1] == \"/\":\n val_list = cfg.data_root + cfg.val_list\n else:\n val_list = cfg.data_root + '/' + cfg.val_list\n\n test_data = pt_dataset.SemData(\n split='val', data_root=cfg.data_root,\n data_list=val_list,\n transform=test_transform)\n\n test_loader = ds.GeneratorDataset(test_data, column_names=[\"data\", \"label\"],\n shuffle=False)\n test_loader.batch(1)\n colors = numpy.loadtxt(cfg.color_txt).astype('uint8')\n\n from src.model import cpnet\n\n CPNet = cpnet.CPNet(\n prior_channels=256,\n proir__size=60,\n am_kernel_size=11,\n pretrained=True,\n pretrained_path=cfg.pretrain_path,\n deep_base=True\n )\n\n ms_checkpoint = load_checkpoint(cfg.ckpt)\n load_param_into_net(CPNet, ms_checkpoint, strict_load=True)\n CPNet.set_train(False)\n test(test_loader, test_data.data_list, CPNet, cfg.classes, mean, std, cfg.base_size, cfg.test_h,\n cfg.test_w, cfg.scales, gray_folder, color_folder, colors)\n if cfg.split != 'test':\n cal_acc(test_data.data_list, gray_folder, cfg.classes)","def main(configuration_path, mode):\n config = toml.load(configuration_path)\n train_conf = read_config(config)\n\n click.echo(\"\\n Train config:\")\n print(train_conf, \"\\n\")\n\n # create databunch\n data = create_databunch(\n data_path=train_conf[\"data_path\"],\n fourier=train_conf[\"fourier\"],\n batch_size=train_conf[\"batch_size\"],\n )\n\n # get image size\n train_conf[\"image_size\"] = data.train_ds[0][0][0].shape[1]\n\n # define architecture\n arch = define_arch(\n arch_name=train_conf[\"arch_name\"], img_size=train_conf[\"image_size\"]\n )\n\n if mode == \"train\":\n if train_conf[\"normalize\"] == \"mean\":\n train_conf[\"norm_factors\"] = get_normalisation_factors(data)\n # check out path and look for existing model files\n check_outpath(train_conf[\"model_path\"], train_conf)\n\n click.echo(\"Start training of the model.\\n\")\n\n # define_learner\n learn = define_learner(data, arch, train_conf)\n\n # load pretrained model\n if train_conf[\"pre_model\"] != \"none\":\n learn.create_opt()\n load_pre_model(learn, train_conf[\"pre_model\"])\n\n # Train the model, except interrupt\n # train_conf[\"comet_ml\"] = True\n try:\n if train_conf[\"comet_ml\"]:\n learn.comet.experiment.log_parameters(train_conf)\n with learn.comet.experiment.train():\n learn.fit(train_conf[\"num_epochs\"])\n else:\n learn.fit(train_conf[\"num_epochs\"])\n except KeyboardInterrupt:\n pop_interrupt(learn, train_conf)\n\n end_training(learn, train_conf)\n\n if train_conf[\"inspection\"]:\n after_training_plots(train_conf, rand=True)\n\n if mode == \"fine_tune\":\n click.echo(\"Start fine tuning of the model.\\n\")\n\n # define_learner\n learn = define_learner(\n data,\n arch,\n train_conf,\n )\n\n # load pretrained model\n if train_conf[\"pre_model\"] == \"none\":\n click.echo(\"Need a pre-trained modle for fine tuning!\")\n return\n\n learn.create_opt()\n load_pre_model(learn, train_conf[\"pre_model\"])\n\n # Train the model, except interrupt\n try:\n learn.fine_tune(train_conf[\"num_epochs\"])\n except KeyboardInterrupt:\n pop_interrupt(learn, train_conf)\n\n end_training(learn, train_conf)\n if train_conf[\"inspection\"]:\n after_training_plots(train_conf, rand=True)\n\n if mode == \"lr_find\":\n click.echo(\"Start lr_find.\\n\")\n if train_conf[\"normalize\"] == \"mean\":\n train_conf[\"norm_factors\"] = get_normalisation_factors(data)\n\n # define_learner\n learn = define_learner(data, arch, train_conf, lr_find=True)\n\n # load pretrained model\n if train_conf[\"pre_model\"] != \"none\":\n learn.create_opt()\n load_pre_model(learn, train_conf[\"pre_model\"])\n\n learn.lr_find()\n\n # save loss plot\n plot_lr_loss(\n learn,\n train_conf[\"arch_name\"],\n Path(train_conf[\"model_path\"]).parent,\n skip_last=5,\n output_format=train_conf[\"format\"],\n )\n\n if mode == \"plot_loss\":\n click.echo(\"Start plotting loss.\\n\")\n\n # define_learner\n learn = define_learner(data, arch, train_conf, plot_loss=True)\n # load pretrained model\n if Path(train_conf[\"model_path\"]).exists:\n load_pre_model(learn, train_conf[\"model_path\"], plot_loss=True)\n else:\n click.echo(\"Selected model does not exist.\")\n click.echo(\"Exiting.\\n\")\n sys.exit()\n\n plot_lr(\n learn, Path(train_conf[\"model_path\"]), output_format=train_conf[\"format\"]\n )\n plot_loss(\n learn, Path(train_conf[\"model_path\"]), output_format=train_conf[\"format\"]\n )","def train():\n with tf.Graph().as_default():\n #global_step = tf.contrib.framework.get_or_create_global_step()\n scope_1, scope_2 = \"parameters_1\", \"parameters_2\"\n\n with tf.variable_scope(scope_1):\n #images_1, labels_1 = cifar10.inputs(False)\n images_1 = tf.placeholder(tf.float32, shape=(None, cifar10.IMAGE_SIZE, cifar10.IMAGE_SIZE, 3))\n labels_1 = tf.placeholder(tf.int32, shape=(None,))\n logits_1 = cifar10.inference(images_1)\n loss_1 = cifar10.loss(logits_1, labels_1, scope_1)\n train_op_1 = cifar10.train(loss_1, scope_1)\n top_k_op_1 = tf.nn.in_top_k(logits_1, labels_1, 1)\n\n with tf.variable_scope(scope_2):\n #images_2, labels_2 = cifar10.inputs(False)\n images_2 = tf.placeholder(tf.float32, shape=(None, cifar10.IMAGE_SIZE, cifar10.IMAGE_SIZE, 3))\n labels_2 = tf.placeholder(tf.int32, shape=(None,))\n logits_2 = cifar10.inference(images_2)\n loss_2 = cifar10.loss(logits_2, labels_2, scope_2)\n train_op_2 = cifar10.train(loss_2, scope_2)\n top_k_op_2 = tf.nn.in_top_k(logits_2, labels_2, 1)\n\n variables_1 = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=\"parameters_1\")\n variables_2 = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=\"parameters_2\")\n assert(len(variables_1) == len(variables_2))\n\n images_raw, labels_raw, images_test_raw, labels_test_raw = load_cifar_data_raw()\n assert(images_raw.shape[0] == cifar10.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN)\n assert(images_test_raw.shape[0] == cifar10.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL)\n\n with tf.Session() as mon_sess:\n\n tf.initialize_all_variables().run()\n tf.train.start_queue_runners(sess=mon_sess)\n\n # First we make sure the parameters of the two models are the same.\n print(\"Making sure models have the same initial value...\")\n for i in range(len(variables_1)):\n v1 = variables_1[i]\n v2 = variables_2[i]\n shape1 = v1.get_shape().as_list()\n shape2 = v2.get_shape().as_list()\n if shape1 != shape2:\n print(\"Error shapes are not the same: \", shape1, shape2)\n assert(shape1 == shape2)\n\n images_fake = np.zeros((FLAGS.batch_size, cifar10.IMAGE_SIZE, cifar10.IMAGE_SIZE, 3))\n labels_fake = np.zeros((FLAGS.batch_size,))\n fd_fake = {images_1 : images_fake,\n labels_1 : labels_fake,\n images_2 : images_fake,\n labels_2 : labels_fake}\n v1, v2 = mon_sess.run([v1, v2], feed_dict=fd_fake)\n v1, v2 = v1.flatten(), v2.flatten()\n if np.linalg.norm(v1) != 0:\n v1 = v1 / np.linalg.norm(v1)\n if np.linalg.norm(v2) != 0:\n v2 = v2 / np.linalg.norm(v2)\n diff = np.linalg.norm(v1-v2)\n print(\"Difference between variable weights: %f\" % diff)\n assert(diff < 1e-7)\n print(\"Done\")\n\n epoch = 0\n n_perfect = 0\n\n # Exclude index refers to the index of the example to exclude.\n # Swap index refers to the index of the example to swap with the example excluded.\n exclude_index, swap_index = 0, 1\n\n while True:\n\n # Reshuffle data\n perm = np.random.permutation(len(images_raw))\n images_raw = images_raw[perm]\n labels_raw = labels_raw[perm]\n\n # Aggregate all parameters\n model_1_agg_variables = {}\n model_2_agg_variables = {}\n all_variables = {}\n for i in range(len(variables_1)):\n images_fake = np.zeros((FLAGS.batch_size, cifar10.IMAGE_SIZE, cifar10.IMAGE_SIZE, 3))\n labels_fake = np.zeros((FLAGS.batch_size,))\n fd_fake = {images_1 : images_fake,\n labels_1 : labels_fake,\n images_2 : images_fake,\n labels_2 : labels_fake}\n v1, v2 = variables_1[i], variables_2[i]\n name_v1, name_v2 = v1.name, v2.name\n v1, v2 = mon_sess.run([v1, v2], feed_dict=fd_fake)\n\n # Save all parameter weights\n all_variables[\"model1/\" + name_v1] = v1\n all_variables[\"model2/\" + name_v2] = v2\n\n v1, v2 = v1.flatten(), v2.flatten()\n\n if \"conv\" in variables_1[i].name:\n agg_name = variables_1[i].name.split(\"/\")[-2]\n if \"all\" not in model_1_agg_variables:\n model_1_agg_variables[\"all\"] = np.array([])\n if \"all\" not in model_2_agg_variables:\n model_2_agg_variables[\"all\"] = np.array([])\n if agg_name not in model_1_agg_variables:\n model_1_agg_variables[agg_name] = np.array([])\n if agg_name not in model_2_agg_variables:\n model_2_agg_variables[agg_name] = np.array([])\n model_1_agg_variables[agg_name] = np.hstack([model_1_agg_variables[agg_name], v1])\n model_2_agg_variables[agg_name] = np.hstack([model_2_agg_variables[agg_name], v2])\n model_1_agg_variables[\"all\"] = np.hstack([model_1_agg_variables[agg_name], v1])\n model_2_agg_variables[\"all\"] = np.hstack([model_2_agg_variables[agg_name], v2])\n\n # Save all variables\n output_file_name = \"%s/parameter_difference_batchsize_%d_epoch_%d_save\" % (save_directory, FLAGS.batch_size, epoch)\n output_file = open(output_file_name, \"wb\")\n cPickle.dump(all_variables, output_file)\n output_file.close()\n\n # Test the saved values\n if FLAGS.test_load_dumped_data_files:\n input_file = open(output_file_name, \"rb\")\n print(\"Testing whether loaded variables succeeded...\")\n all_variables_loaded = cPickle.load(input_file)\n input_file.close()\n for k,v in all_variables_loaded.items():\n assert(k in all_variables)\n assert(np.all(np.equal(all_variables[k].flatten(), all_variables_loaded[k].flatten())))\n print(\"Success!\")\n\n # Find parameter differences\n layer_diffs = []\n for layer_name, layer in model_1_agg_variables.items():\n v1, v2 = model_1_agg_variables[layer_name], model_2_agg_variables[layer_name]\n #if np.linalg.norm(v1) != 0:\n # v1 = np.linalg.norm(v1)\n #if np.linalg.norm(v2) != 0:\n # v2 = np.linalg.norm(v2)\n diff = np.linalg.norm(v1-v2)\n layer_diffs.append((layer_name, diff))\n print(\"Layer differences: \", (epoch, layer_diffs))\n\n # Evaluate on test data\n print(\"Evaluating on test...\")\n true_count_1, true_count_2 = 0, 0\n cur_index = 0\n for i in range(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL//FLAGS.eval_batchsize):\n #print(\"%d of %d\" % (i, cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL//FLAGS.eval_batchsize))\n\n images_eval_real, labels_eval_real, cur_index = next_batch(FLAGS.eval_batchsize, images_test_raw, labels_test_raw, cur_index)\n fd = {images_1 : images_eval_real,\n labels_1 : labels_eval_real,\n images_2 : images_eval_real,\n labels_2 : labels_eval_real}\n p1, p2 = mon_sess.run([top_k_op_1, top_k_op_2], feed_dict=fd)\n true_count_1 += np.sum(p1)\n true_count_2 += np.sum(p2)\n\n precision_test_1 = true_count_1 / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL)\n precision_test_2 = true_count_2 / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL)\n print(\"Done\")\n\n # Evaluate on train data\n print(\"Evaluating on train...\")\n true_count_1, true_count_2 = 0, 0\n cur_index = 0\n for i in range(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN//FLAGS.eval_batchsize):\n #print(\"%d of %d\" % (i, cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN//FLAGS.eval_batchsize))\n images_eval_real, labels_eval_real, cur_index = next_batch(FLAGS.eval_batchsize, images_raw, labels_raw, cur_index)\n fd = {images_1 : images_eval_real,\n labels_1 : labels_eval_real,\n images_2 : images_eval_real,\n labels_2 : labels_eval_real}\n p1, p2 = mon_sess.run([top_k_op_1, top_k_op_2], feed_dict=fd)\n true_count_1 += np.sum(p1)\n true_count_2 += np.sum(p2)\n\n precision_train_1 = true_count_1 / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN)\n precision_train_2 = true_count_2 / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN)\n\n output_file_name = \"%s/parameter_difference_batchsize_%d_epoch_%d_train_test_error\" % (save_directory, FLAGS.batch_size, epoch)\n output_file = open(output_file_name, \"w\")\n cPickle.dump([precision_train_1, precision_train_2, precision_test_1, precision_test_2], output_file)\n output_file.close()\n\n if precision_train_1 >= .999 or precision_train_2 >= .999:\n n_perfect += 1\n if n_perfect >= 10:\n break\n print(\"Done\")\n\n # Print all the data related to figures 3 and 4 of https://arxiv.org/pdf/1509.01240.pdf\n print(\"Layer distances: \", layer_diffs)\n print(\"Epoch: %f TrainError1: %f TrainError2: %f TestError1: %f TestError2: %f\" % (epoch, 1-precision_train_1, 1-precision_train_2, 1-precision_test_1, 1-precision_test_2))\n\n # Optimize\n cur_index = 0\n for i in range(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN // FLAGS.batch_size + 1):\n images_real_1, labels_real_1, next_index = next_batch(FLAGS.batch_size, images_raw,\n labels_raw, cur_index,\n exclude_index=exclude_index)\n images_real_2, labels_real_2, next_index = next_batch(FLAGS.batch_size, images_raw,\n labels_raw, cur_index,\n exclude_index=exclude_index,\n swap_index=swap_index)\n\n cur_index = next_index\n\n fd = {images_1 : images_real_1,\n labels_1 : labels_real_1,\n images_2 : images_real_2,\n labels_2 : labels_real_2}\n\n mon_sess.run([train_op_1, train_op_2], feed_dict=fd)\n l1, l2 = mon_sess.run([loss_1, loss_2], feed_dict=fd)\n\n if i % 100 == 0:\n epoch_cur = epoch + i * FLAGS.batch_size / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN)\n print(\"Epoch: %f Losses: %f %f\" % (epoch_cur, l1, l2))\n\n epoch += 1","def resnet10(**kwargs):\n model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)\n return model","def load_cifar10(directory):\n train_data = []\n train_labels = []\n for b in range(1, 6):\n f = os.path.join(directory, 'data_batch_%d' % (b,))\n X, Y = load_cifar10_batch(f)\n train_data.append(X)\n train_labels.append(Y)\n train_data = np.concatenate(train_data)\n train_labels = np.concatenate(train_labels)\n del X, Y\n test_data, test_labels = load_cifar10_batch(os.path.join(directory, 'test_batch'))\n return train_data, train_labels, test_data, test_labels","def trainNetwork():\n plot_data = {}\n plot_data['train_loss'] = []\n plot_data['valid_loss'] = []\n plot_data['train_acc'] = []\n plot_data['valid_acc'] = []\n plot_data['lr'] = []\n SAVE_DIR = 'C:/Users/Dario/Desktop/Projekt/Drugi labos/lab2_torch/figures'\n device = torch.device('cuda')\n\n net = ConvolutionalModel(3, 16, 128, 10).to(device=device)\n\n lossFunc = nn.CrossEntropyLoss()\n optimizer = optim.Adam(net.parameters(), lr=0.001)\n scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95)\n\n epoch = 10\n \n\n for e in range(epoch):\n \n accLoss = 0.0\n\n for i, data in enumerate(data_load.trainloader, 0):\n inputs, labels = data\n inputs = inputs.to(device=device)\n labels = labels.to(device=device)\n\n optimizer.zero_grad()\n\n outputs = net.forward(inputs)\n loss = lossFunc(outputs, labels)\n loss.backward()\n optimizer.step()\n\n accLoss += loss.item()\n\n if i % 100 == 0:\n print(\"Epoch: %d, Iteration: %5d, Loss: %.3f\" % ((e + 1), (i), (accLoss / (i + 1))))\n \n train_loss, train_acc = evaluate.evaluate(net, False)\n val_loss, val_acc = evaluate.evaluate(net, True)\n\n plot_data['train_loss'] += [train_loss]\n plot_data['valid_loss'] += [val_loss]\n plot_data['train_acc'] += [train_acc]\n plot_data['valid_acc'] += [val_acc]\n plot_data['lr'] += [scheduler.get_lr()]\n\n scheduler.step()\n\n plot.plot_training_progress(SAVE_DIR, plot_data)\n PATH = './CIFAR_10/cifar_netAdam.pth'\n torch.save(net.state_dict(), PATH)","def train_classifier(data, n_iters=3, batch_size=100):\n tqdm.write(f'Training a dilated CNN classifier for {n_iters} iterations.')\n (trainx, trainy), (valx, valy), (testx, testy) = data\n train_size, val_size, test_size = trainx.shape[0], valx.shape[0], testx.shape[0]\n train_batches = (train_size - 1) // batch_size + 1\n val_batches = (val_size - 1) // batch_size + 1\n test_batches = (test_size - 1) // batch_size + 1\n\n model = Network()\n model.add_layer(ConvLayer(10, (3, 3), (1, 1), 2)) \\\n .add_layer(ReluLayer()) \\\n .add_layer(Pad2DLayer((2, 2))) \\\n .add_layer(ConvLayer(10, (3, 3), (1, 1), 2)) \\\n .add_layer(ReluLayer()) \\\n .add_layer(Pool2DLayer((2, 2))) \\\n .add_layer(ConvLayer(10, (3, 3), (1, 1), 2)) \\\n .add_layer(ReluLayer()) \\\n .add_layer(Pool2DLayer((2, 2))) \\\n .add_layer(FlattenLayer()) \\\n .add_layer(FCLayer(32)) \\\n .add_layer(ReluLayer()) \\\n .add_layer(FCLayer(10)) \\\n .add_layer(SoftmaxCELayer())\n for i in range(1, n_iters + 1):\n train_order = np.random.permutation(train_size)\n bar = trange(train_batches, file=sys.stdout)\n for j in bar:\n cost = model.forward(trainx[train_order[j * batch_size: (j + 1) * batch_size]],\n trainy[train_order[j * batch_size: (j + 1) * batch_size]])\n bar.set_description(f'Curr loss: {cost}')\n model.backward()\n model.adam_trainstep()\n correct = []\n for j in range(val_batches):\n res = model.run(valx[j * batch_size:(j + 1) * batch_size])\n correct.append(np.argmax(res, axis=1) == valy[j * batch_size:(j + 1) * batch_size])\n tqdm.write(f'Validation accuracy: {np.mean(correct)}')\n tqdm.write('-------------------------------------------------------')\n\n correct = []\n for i in range(test_batches):\n res = model.run(testx[i * batch_size:(i + 1) * batch_size])\n correct.append(np.argmax(res, axis=1) == testy[i * batch_size:(i + 1) * batch_size])\n tqdm.write(f'Test accuracy: {np.mean(correct)}')\n tqdm.write('-------------------------------------------------------')","def main():\n\tmodel = load_model(args.model)\n\tif not args.retrain:\n\t\twhile True:\n\t\t\tvideos = glob.glob(args.input + '/*.mov')\n\t\t\tif len(videos) > 0:\n\t\t\t\tlabel(videos, model)\n\t\t\telse:\n\t\t\t\tsleep(10)\n\telif args.retrain:\n\t\t\tpath, file = os.path.split(args.model)\n\t\t\tmodel.save(path + '/old_' + file)\n\n\t\t\tX, Y = process_train_data(args.train)\n\t\t\tX_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state = 24)\n\n\t\t\tes_cb = EarlyStopping(monitor='val_loss', patience=2, mode='auto', restore_best_weights=True)\n\t\t\thistory = model.fit(X_train, y_train, batch_size=32, epochs=50, callbacks=[es_cb], validation_data=(X_test, y_test), verbose=int(args.debug))\n\t\t\tmodel.save(args.model)\n\n\t\t\tmaintain(args.train, 600)","def resnet_model(images,\n is_training,\n num_classes,\n resnet_size=50,\n weight_decay=None,\n kernel_size=7,\n num_filters=64,\n return_intermediate_values=False,\n film_generator_fn=None,\n film_generator_input=None,\n pretrain_checkpoint=None):\n # For bigger models, we want to use \"bottleneck\" layers\n if resnet_size < 50:\n bottleneck = False\n else:\n bottleneck = True\n model = resnet_lib.Model(\n resnet_size=resnet_size,\n bottleneck=bottleneck,\n num_classes=num_classes,\n num_filters=num_filters,\n kernel_size=kernel_size,\n conv_stride=2,\n first_pool_size=3,\n first_pool_stride=2,\n block_sizes=_get_block_sizes(resnet_size),\n block_strides=[1, 2, 2, 2],\n resnet_version=resnet_lib.DEFAULT_VERSION,\n data_format='channels_last',\n weight_decay=weight_decay,\n dtype=resnet_lib.DEFAULT_DTYPE\n )\n final_dense = model(images, is_training,\n film_generator_fn, film_generator_input)\n if pretrain_checkpoint:\n # Initialize variables in ResNet, excluding the final dense layer and any\n # optimization-specific variables (e.g. Momentum, Adam Beta).\n # When initializing on TPUs, use AbstractT2RModel.init_from_checkpoint_fn.\n resnet_init_from_checkpoint_fn(pretrain_checkpoint)\n if return_intermediate_values:\n return resnet_endpoints(model)\n else:\n return final_dense","def pretrain_nc_net(self, n_epochs=300):\n optimizer = torch.optim.Adam(self.model.nc_net.parameters(), lr=self.lr, weight_decay=self.weight_decay)\n best_val_auc = 0.\n best_test_auc = 0.\n best_res = None\n self.model.nc_net.to(self.device)\n user_features = self.user_features.to(self.device)\n item_features = self.item_features.to(self.device)\n self.labels = self.labels.to(self.device)\n\n cnt_wait = 0\n patience = 50\n for epoch in range(n_epochs):\n self.model.nc_net.train()\n self.model.nc_net.zero_grad()\n input_adj = self.adj.clone()\n input_adj = input_adj.to(self.device)\n loss, nc_logits, _ = self.model.nc_net(input_adj, user_features, item_features)\n loss.backward()\n optimizer.step()\n optimizer.zero_grad()\n # Detach from computation graph\n self.adj = self.adj.detach()\n # Validation\n self.model.nc_net.eval()\n with torch.no_grad():\n input_adj = self.adj.clone()\n input_adj = input_adj.to(self.device)\n _, nc_logits_eval, _ = self.model.nc_net(input_adj, user_features, item_features)\n res_training = self.eval_node_cls(nc_logits[self.train_nid].detach(), self.labels[self.train_nid], self.n_classes)\n res = self.eval_node_cls(nc_logits_eval[self.val_nid], self.labels[self.val_nid], self.n_classes)\n\n if res['auc'] > best_val_auc:\n cnt_wait = 0\n best_val_auc = res['auc']\n test_auc = self.eval_node_cls(nc_logits_eval[self.test_nid], self.labels[self.test_nid], self.n_classes)['auc']\n if test_auc > best_test_auc:\n best_test_auc = test_auc\n best_res = self.eval_node_cls(nc_logits_eval[self.test_nid], self.labels[self.test_nid], self.n_classes)\n self.logger.info('NCNet pretrain, Epoch [{} / {}]: loss {:.4f}, train_auc {:.4f}, val_auc {:.4f}, test_auc {:.4f}, test_ap {:.4f}'\n .format(epoch+1, n_epochs, loss.item(), res_training['auc'], res['auc'], test_auc, best_res['ap']))\n else:\n cnt_wait += 1\n self.logger.info('NCNet pretrain, Epoch [{} / {}]: loss {:.4f}, train_auc {:.4f}, val_auc: {:.4f}'\n .format(epoch+1, n_epochs, loss.item(), res_training['auc'], res['auc']))\n\n if cnt_wait >= patience:\n self.logger.info('Early stop!')\n break\n\n self.logger.info('Best Test Results: auc {:.4f}, ap {:.4f}'.format(best_res['auc'], best_res['ap']))\n return best_res['auc'], best_res['ap']","def eval_net(net, loader, device, n_val, cfg):\n net.eval()\n tot = 0\n bce_loss = 0\n dice_coef = 0\n with tqdm(total=n_val, desc='Validation round', unit='img', leave=False) as pbar:\n for imgs, true_masks in loader:\n # for batch in loader:\n # imgs = batch['image']\n # true_masks = batch['mask']\n\n imgs = imgs.to(device=device, dtype=torch.float32)\n mask_type = torch.float32 #if cfg.n_classes == 1 else torch.long\n true_masks = true_masks.to(device=device, dtype=mask_type)\n criterion_1 = BCE = F.binary_cross_entropy #(inputs, targets, reduction='mean')#StableBCELoss()#binary_xloss\n criterion_2 = DiceLoss()\n # compute loss\n if cfg.deepsupervision:\n masks_preds = net(imgs)\n for masks_pred in masks_preds:\n tot_ = 0\n tot_bce = 0\n tot_dice = 0\n for true_mask, pred in zip(true_masks, masks_pred):\n pred = (pred > cfg.out_threshold).float()\n if cfg.n_classes > 1:\n bce = criterion_1(F.sigmoid(pred), true_mask) \n dice = criterion_2(pred, true_mask.float())\n # sub_cross_entropy = F.cross_entropy(pred, true_mask).item()\n # sub_cross_entropy = F.cross_entropy(pred.unsqueeze(dim=0), true_mask.unsqueeze(dim=0).squeeze(1)).item()\n else:\n sub_cross_entropy = dice_coeff(pred, true_mask.squeeze(dim=1)).item()\n tot_bce += bce\n tot_dice += dice\n tot_bce = tot_bce / len(masks_preds)\n tot_dice = tot_dice / len(masks_preds)\n bce_loss += tot_bce\n dice_coef += tot_dice\n tot_ += tot_bce\n tot_ += tot_dice\n tot += tot_\n else:\n masks_pred = net(imgs)\n for true_mask, pred in zip(true_masks, masks_pred):\n pred = (pred > cfg.out_threshold).float()\n if cfg.n_classes > 1:\n tot += F.cross_entropy(pred.unsqueeze(dim=0), true_mask.unsqueeze(dim=0).squeeze(1)).item()\n else:\n tot += dice_coeff(pred, true_mask.squeeze(dim=1)).item()\n\n pbar.update(imgs.shape[0])\n\n return tot / n_val, bce_loss / n_val, dice_coef / n_val,","def modified_resnet10(self) -> torch.nn.Module:\n # initialize a Resnet-10 instance\n net = torchvision.models.resnet._resnet(arch=\"resnet10\", block=torchvision.models.resnet.BasicBlock, layers=[1, 1, 1, 1], pretrained=False, progress=False)\n\n # the first layer will be a lazy convolutional layer with any input channels\n net.conv1 = torch.nn.LazyConv2d(\n out_channels=64,\n kernel_size=(7, 7),\n stride=(2, 2),\n padding=(3, 3),\n bias=not self.bn_affine\n )\n\n # modify batch-norm layer to have momentum 1 and no tracking statistics\n net.bn1 = torch.nn.BatchNorm2d(64, momentum=1, track_running_stats=False, affine=self.bn_affine)\n\n net.layer1[0].bn1 = torch.nn.BatchNorm2d(64, momentum=1, track_running_stats=False, affine=self.bn_affine)\n net.layer1[0].bn2 = torch.nn.BatchNorm2d(64, momentum=1, track_running_stats=False, affine=self.bn_affine)\n\n net.layer2[0].bn1 = torch.nn.BatchNorm2d(128, momentum=1, track_running_stats=False, affine=self.bn_affine)\n net.layer2[0].bn2 = torch.nn.BatchNorm2d(128, momentum=1, track_running_stats=False, affine=self.bn_affine)\n net.layer2[0].downsample[1] = torch.nn.BatchNorm2d(128, momentum=1, track_running_stats=False, affine=self.bn_affine)\n\n net.layer3[0].bn1 = torch.nn.BatchNorm2d(256, momentum=1, track_running_stats=False, affine=self.bn_affine)\n net.layer3[0].bn2 = torch.nn.BatchNorm2d(256, momentum=1, track_running_stats=False, affine=self.bn_affine)\n net.layer3[0].downsample[1] = torch.nn.BatchNorm2d(256, momentum=1, track_running_stats=False, affine=self.bn_affine)\n\n net.layer4[0].bn1 = torch.nn.BatchNorm2d(512, momentum=1, track_running_stats=False, affine=self.bn_affine)\n net.layer4[0].bn2 = torch.nn.BatchNorm2d(512, momentum=1, track_running_stats=False, affine=self.bn_affine)\n net.layer4[0].downsample[1] = torch.nn.BatchNorm2d(512, momentum=1, track_running_stats=False, affine=self.bn_affine)\n\n # last layer\n if self.dim_output is not None:\n net.fc = torch.nn.LazyLinear(out_features=self.dim_output)\n else:\n net.fc = torch.nn.Identity()\n\n # add dropout-2d after layers 1, 2, and 3\n net.maxpool.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n\n net.layer1[0].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n # net.layer1[1].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n net.layer1.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n\n net.layer2[0].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n # net.layer2[1].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n net.layer2.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n\n net.layer3[0].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n # net.layer3[1].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n net.layer3.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n\n net.layer4[0].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n # net.layer4[1].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n net.layer4.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\n\n return net","def run_eval(gt_anno, pred_anno):\n coco = COCO(gt_anno)\n coco_dets = coco.loadRes(pred_anno)\n coco_eval = COCOeval(coco, coco_dets, \"keypoints\")\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()\n coco_eval = COCOeval(coco, coco_dets, \"bbox\")\n coco_eval.evaluate()\n coco_eval.accumulate()\n coco_eval.summarize()","def train(self, mode=True):\n super(ResNet, self).train(mode)\n self._freeze_stages()\n if mode and self.norm_eval:\n for m in self.modules():\n # trick: eval have effect on BatchNorm only\n if isinstance(m, _BatchNorm):\n m.eval()","def run_epoch(model, data, optimizer, epoch):\n traindata, valdata = data\n\n model.train()\n train_bpd = epoch_iter(model, traindata, optimizer, epoch)\n\n model.eval()\n val_bpd = epoch_iter(model, valdata, optimizer, epoch)\n\n return train_bpd, val_bpd","def main():\n args = get_arguments()\n \n # Create queue coordinator.\n coord = tf.train.Coordinator()\n\n # Load reader.\n with tf.name_scope(\"create_inputs\"):\n reader = ImageReader(\n args.data_dir,\n args.data_list,\n None, # No defined input size.\n False, # No random scale.\n False, # No random mirror.\n args.ignore_label,\n IMG_MEAN,\n coord)\n image, label = reader.image, reader.label\n image_batch, label_batch = tf.expand_dims(image, dim=0), tf.expand_dims(label, dim=0) # Add one batch dimension.\n\n # Create network.\n net = DeepLabResNetModel({'data': image_batch}, is_training=False, num_classes=args.num_classes)\n\n # Which variables to load.\n restore_var = tf.global_variables()\n\n # Predictions.\n raw_output = net.layers['fc1_voc12']\n raw_output = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\n #raw_output = tf.argmax(raw_output, dimension=3)\n #pred = tf.expand_dims(raw_output, dim=3) # Create 4-d tensor.\n pred = raw_output\n\n # Set up TF session and initialize variables.\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n init = tf.global_variables_initializer()\n\n sess.run(init)\n sess.run(tf.local_variables_initializer())\n\n # Load weights.\n loader = tf.train.Saver(var_list=restore_var)\n if args.restore_from is not None:\n load(loader, sess, args.restore_from)\n\n # Start queue threads.\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\n\n with open(args.data_list) as f:\n content = f.readlines()\n\n content = [x.strip() for x in content]\n\n\n \n for index, value in enumerate(content):\n print(\"outputting \"+str(index))\n \timg = tf.image.decode_png(tf.read_file(value.split()[0]), channels=3)\n raw_img = misc.imread(value.split()[0])\n print(type(raw_img))\n \t# Convert RGB to BGR.\n \timg_r, img_g, img_b = tf.split(axis=2, num_or_size_splits=3, value=img)\n \timg = tf.cast(tf.concat(axis=2, values=[img_b, img_g, img_r]), dtype=tf.float32)\n \t# Extract mean.\n \timg -= IMG_MEAN \n \t# Predictions.\n \traw_output = net.layers['fc1_voc12']\n\n \traw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(img)[0:2,])\n \t#pred = raw_output_up\n probabilities = tf.nn.softmax(raw_output_up)\n pred = tf.argmax(raw_output_up, dimension=3)\n \tpred = tf.expand_dims(pred, dim=3)\n \t# Perform inference.\n \tpreds, probs = sess.run([pred, probabilities])\n print(preds.shape)\n print(probs.shape)\n print(\"probs\")\n print(probs)\n softmax = probs[0, :, :, :]\n print(\"softmax\")\n print(softmax)\n print(softmax.shape)\n print(type(softmax))\n processed_probabilities = softmax.transpose((2, 0, 1))\n print(processed_probabilities.shape)\n print(type(processed_probabilities))\n crf_processed = performCRF(processed_probabilities, raw_img)\n\n im_preds = Image.fromarray(np.uint8(preds[0, :, :, 0]))\n\n print(\"preds shape\", preds.shape)\n \tmsk = decode_labels(preds, num_classes=args.num_classes)\n \tim = Image.fromarray(msk[0])\n\n print(\"crf_processed shape\", crf_processed.shape)\n crf_processed = crf_processed.reshape(1, crf_processed.shape[0], crf_processed.shape[1], 1)\n msk_crf = decode_labels(crf_processed, num_classes=args.num_classes)\n im_crf = Image.fromarray(msk_crf[0])\n\n \tif not os.path.exists(args.save_dir):\n os.makedirs(args.save_dir)\n #im_preds.save(args.save_dir +str(index).zfill(8) +'_predlabels_'+args.train_set+'.png')\n \tim.save(args.save_dir +str(index).zfill(8) +'_pred_'+args.train_set+'.png')\n im_crf.save(args.save_dir +str(index).zfill(8) +'_predcrf_'+args.train_set+'.png')","def run(self, data, training=False):\n # Set mode\n if training:\n self._model.train()\n else:\n self._model.eval()\n # Compute\n return self._model(data)","def run_training_loop():\n logging.info(\"Starting the training loop.\")\n\n trainer = trainer_class(\n output_dir=output_dir,\n train_env=train_env,\n eval_env=eval_env,\n trajectory_dump_dir=trajectory_dump_dir,\n )\n trainer.training_loop(n_epochs=n_epochs)","def load_cifar():\n print('==> Preparing data..')\n transform_train = transforms.Compose([\n transforms.RandomCrop(32, padding=4),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n ])\n\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n ])\n\n trainset = torchvision.datasets.CIFAR10(\n root='./data', train=True, download=True, transform=transform_train)\n trainloader = torch.utils.data.DataLoader(\n trainset, batch_size=1024, shuffle=True, num_workers=8)\n\n testset = torchvision.datasets.CIFAR10(\n root='./data', train=False, download=True, transform=transform_test)\n testloader = torch.utils.data.DataLoader(\n testset, batch_size=128, shuffle=False, num_workers=8)\n return trainloader, testloader","def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n # Load the raw CIFAR-10 data\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n \n # Subsample the data\n mask = range(num_training, num_training + num_validation)\n X_val = X_train[mask]\n y_val = y_train[mask]\n mask = range(num_training)\n X_train = X_train[mask]\n y_train = y_train[mask]\n mask = range(num_test)\n X_test = X_test[mask]\n y_test = y_test[mask]\n\n # Normalize the data: subtract the mean image\n mean_image = np.mean(X_train, axis=0)\n X_train -= mean_image\n X_val -= mean_image\n X_test -= mean_image\n\n # Reshape data to rows\n X_train = X_train.reshape(num_training, -1)\n X_val = X_val.reshape(num_validation, -1)\n X_test = X_test.reshape(num_test, -1)\n\n pca = decomposition.PCA(n_components=None, whiten=False)\n X_train = pca.fit_transform(X_train)\n X_val = pca.transform(X_val)\n X_test = pca.transform(X_test)\n\n return X_train, y_train, X_val, y_val, X_test, y_test","def train(self):\n self.ae_train(self.net0, self.ae0_optimizer, self.train0_loader, self.val_loader, name='Net0')\n self.ae_train(self.net1, self.ae1_optimizer, self.train1_loader, self.val_loader, name='Net1')\n self.ae_train(self.net2, self.ae2_optimizer, self.train2_loader, self.val_loader, name='Net2')\n\n self.classifier_train(self.net0, self.optimizer0, self.train0_loader, self.val_loader, name='Net0')\n self.classifier_train(self.net1, self.optimizer1, self.train1_loader, self.val_loader, name='Net1')\n self.classifier_train(self.net2, self.optimizer2, self.train2_loader, self.val_loader, name='Net2')","def eval(test_snrs, model, model_name, test_samples, test_labels, tag, classes, batch_size):\n # Import Packages\n import os\n import numpy as np\n \n # Function to plot the confusion matrices\n import confusion_matrix\n\n # Compute Acuracy and plot confusion matrices by SNR\n acc = np.zeros(len(test_snrs))\n for s in range(len(test_snrs)):\n\n # extract classes @ SNR\n test_X_i = test_samples[s]\n test_Y_i = test_labels[s]\n # estimate classes\n test_Y_i_hat = model.predict(test_X_i)\n conf = np.zeros([len(classes),len(classes)])\n confnorm = np.zeros([len(classes),len(classes)])\n for i in range(test_X_i.shape[0]):\n j = list(test_Y_i[i,:]).index(1)\n k = int(np.argmax(test_Y_i_hat[i,:]))\n conf[j,k] = conf[j,k] + 1\n for i in range(len(classes)):\n confnorm[i,:] = conf[i,:] / np.sum(conf[i,:])\n # Confusion matrix @ all SNRs in the test set\n if s == 0 or s == len(test_snrs)-1:\n filename = os.getcwd()+'/'+tag+'/Figures/'+ model_name + '_SNR_' + str(test_snrs[s]) + '_Confusion_Matrix.png'\n confusion_matrix.plot(confnorm, tag, model_name, filename, labels=classes)\n \n cor = np.sum(np.diag(conf))\n ncor = np.sum(conf) - cor\n acc[s] = 1.0*cor/(cor+ncor)\n # Save results\n np.save(os.getcwd()+'/'+tag+'/Computed_Values/' + model_name + '_SNR_Accuracy', acc.astype('float32'))\n print(model_name + ' Accuracy:\\n' + str(acc))","def resnet101_classifier(num_rois, num_classes, base_model = None, weight_regularizer=None, bias_regularizer=None):\n roi_input = Input(shape=(None, 4), name='roi_input')\n\n pooling_input = base_model.output if base_model else Input(shape=(None, None, FINAL_CONV_FILTERS))\n model_input = base_model.input if base_model else pooling_input\n resize_out = RoiResizeConv(POOLING_REGIONS, num_rois)([pooling_input, roi_input])\n\n out = td_conv_block(resize_out, 3, [512, 512, 2048], stage=5, block='a', strides=(1,1),\n weight_regularizer=weight_regularizer, bias_regularizer=bias_regularizer,\n td_input_shape=(num_rois, POOLING_REGIONS, POOLING_REGIONS, 1024),\n use_conv_bias=False, separate_scale=True)\n out = td_identity_block(out, 3, [512, 512, 2048], stage=5, block='b',\n weight_regularizer=weight_regularizer, bias_regularizer=bias_regularizer,\n use_conv_bias=False, separate_scale=True)\n out = td_identity_block(out, 3, [512, 512, 2048], stage=5, block='c',\n weight_regularizer=weight_regularizer, bias_regularizer=bias_regularizer,\n use_conv_bias=False, separate_scale=True)\n out = TimeDistributed(AveragePooling2D((7, 7)), name='avg_pool')(out)\n\n out = TimeDistributed(Flatten(name='flatten'))(out)\n\n gaussian_initializer_cls = TruncatedNormal(stddev=0.01)\n gaussian_initializer_bbreg = TruncatedNormal(stddev=0.001)\n\n out_class = TimeDistributed(Dense(num_classes, activation='softmax',\n kernel_initializer=gaussian_initializer_cls,\n kernel_regularizer=weight_regularizer,\n bias_regularizer=bias_regularizer\n ),\n name='dense_class_{}'.format(num_classes))(out)\n out_reg = TimeDistributed(Dense(4 * (num_classes - 1), activation='linear',\n kernel_initializer=gaussian_initializer_bbreg,\n kernel_regularizer=weight_regularizer,\n bias_regularizer=bias_regularizer\n ),\n name='dense_reg_{}'.format(num_classes))(out)\n\n cls_model = Model(inputs=[model_input, roi_input], outputs=[out_class, out_reg])\n\n this_dir = os.path.dirname(__file__)\n weights_path = os.path.join(this_dir, '../models/resnet101_weights_tf.h5')\n cls_model.load_weights(weights_path, by_name=True)\n\n return cls_model","def loop(self, epochs, train_loader, val_loader, test_loader):\n\n self.all_epoch = epochs\n self._resume()\n\n for ep in range(self.cur_epoch, epochs + 1):\n self.cur_epoch = ep\n\n # conduct training, validation and test\n self.train_loss = self.train(train_loader)\n if ep % self.val_freq == 0:\n self.val_loss = self.val(val_loader)\n\n if ep % self.test_freq == 0:\n self.test_loss, rho, nmse = self.test(test_loader)\n else:\n rho, nmse = None, None\n\n # conduct saving, visualization and log printing\n self._loop_postprocessing(rho, nmse)","def load_CIFAR10(ROOT):\n xs = []\n ys = []\n for b in range(1, 6):\n f = os.path.join(ROOT, 'data_batch_%d' % (b,))\n X, Y = load_CIFAR_batch(f)\n xs.append(X)\n ys.append(Y)\n Xtr = np.concatenate(xs)\n Ytr = np.concatenate(ys)\n del X, Y\n Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))\n return Xtr, Ytr, Xte, Yte","def make_NN(n_hidden, n_epoch, labelsdict, lr, device, model_name, trainloader, validloader, train_data, pretrain, finetune_whole, custom_model):\n if custom_model == 2:\n # Use custom two-layer convolution model\n print(\"Using Two-Layer CNN\")\n model = TwoLayerConvNet()\n elif custom_model == 5:\n print(\"Using Five-Layer CNN\")\n # Use custom five-layer convolution model\n model = FiveLayerConvNet()\n else:\n # Import NN model (either pretrained or not)\n model = getattr(models, model_name)(pretrained=pretrain)\n \"\"\" ===================================================================================== \"\"\"\"\n \n \"\"\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER FREEZE THE PARAMETERS OR NOT (WILBERT ARISTO) \"\"\"\n # If we do not need to finetune whole model, freeze parameters that we don't need to re-train\n if not finetune_whole:\n for param in model.parameters():\n param.requires_grad = False\n \"\"\" ===================================================================================== \"\"\"\"\n\n n_out = len(labelsdict)\n\n \"\"\" CHANGED LAST LAYER TO model.fc IF WE ARE USING RESNET MODEL (WILBERT ARISTO) \"\"\"\n if \"resnet\" in model_name:\n # Make classifier\n n_in = next(model.fc.modules()).in_features\n model.fc = NN_Classifier(input_size=n_in, output_size=n_out, hidden_layers=n_hidden)\n \n \"\"\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER OPTIMIZE ALL PARAMETERS OR JUST THE LAST LAYER'S PARAMS (WILBERT ARISTO) \"\"\"\n # Define optimizer\n if finetune_whole:\n optimizer = optim.Adam(model.parameters(), lr = lr)\n else:\n optimizer = optim.Adam(model.fc.parameters(), lr = lr)\n \"\"\" ============================================================================================================================ \"\"\"\"\n else:\n # Make classifier\n n_in = next(model.classifier.modules()).in_features\n model.classifier = NN_Classifier(input_size=n_in, output_size=n_out, hidden_layers=n_hidden)\n \n \"\"\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER OPTIMIZE ALL PARAMETERS OR JUST THE LAST LAYER'S PARAMS (WILBERT ARISTO) \"\"\"\n # Define optimizer\n if finetune_whole:\n optimizer = optim.Adam(model.parameters(), lr = lr)\n else:\n optimizer = optim.Adam(model.classifier.parameters(), lr = lr)\n \"\"\" ============================================================================================================================ \"\"\"\"\n \"\"\" ============================================================================================================================ \"\"\"\"\n\n # Define criterion\n criterion = nn.NLLLoss() \n\n model.to(device)\n start = time.time()\n\n epochs = n_epoch\n steps = 0 \n running_loss = 0\n print_every = 40\n for e in range(epochs):\n model.train()\n for images, labels in trainloader:\n images, labels = images.to(device), labels.to(device)\n\n steps += 1\n\n optimizer.zero_grad()\n\n output = model.forward(images)\n loss = criterion(output, labels)\n loss.backward()\n optimizer.step()\n\n running_loss += loss.item()\n\n if steps % print_every == 0:\n # Eval mode for predictions\n model.eval()\n\n # Turn off gradients for validation\n with torch.no_grad():\n test_loss, accuracy = validation(model, validloader, criterion, device)\n\n print(\"Epoch: {}/{} - \".format(e+1, epochs),\n \"Training Loss: {:.3f} - \".format(running_loss/print_every),\n \"Validation Loss: {:.3f} - \".format(test_loss/len(validloader)),\n \"Validation Accuracy: {:.3f}\".format(accuracy/len(validloader)))\n\n running_loss = 0\n\n # Make sure training is back on\n model.train()\n \n \"\"\" CHANGED LAST LAYER TO model.fc IF WE ARE USING RESNET MODEL (WILBERT ARISTO) \"\"\"\n if \"resnet\" in model_name:\n # Add model info \n model.fc.n_in = n_in\n model.fc.n_hidden = n_hidden\n model.fc.n_out = n_out\n model.fc.labelsdict = labelsdict\n model.fc.lr = lr\n model.fc.optimizer_state_dict = optimizer.state_dict\n model.fc.model_name = model_name\n model.fc.class_to_idx = train_data.class_to_idx\n else:\n # Add model info \n model.classifier.n_in = n_in\n model.classifier.n_hidden = n_hidden\n model.classifier.n_out = n_out\n model.classifier.labelsdict = labelsdict\n model.classifier.lr = lr\n model.classifier.optimizer_state_dict = optimizer.state_dict\n model.classifier.model_name = model_name\n model.classifier.class_to_idx = train_data.class_to_idx\n \"\"\" ============================================================================================================================ \"\"\"\"\n\n print('model:', model_name, '- hidden layers:', n_hidden, '- epochs:', n_epoch, '- lr:', lr)\n print(f\"Run time: {(time.time() - start)/60:.3f} min\")\n return model\n\n# Define function to save checkpoint\ndef save_checkpoint(model, path):\n checkpoint = {'c_input': model.classifier.n_in,\n 'c_hidden': model.classifier.n_hidden,\n 'c_out': model.classifier.n_out,\n 'labelsdict': model.classifier.labelsdict,\n 'c_lr': model.classifier.lr,\n 'state_dict': model.state_dict(),\n 'c_state_dict': model.classifier.state_dict(),\n 'opti_state_dict': model.classifier.optimizer_state_dict,\n 'model_name': model.classifier.model_name,\n 'class_to_idx': model.classifier.class_to_idx\n }\n torch.save(checkpoint, path)\n \n# Define function to load model\ndef load_model(path):\n cp = torch.load(path)\n \n # Import pre-trained NN model \n model = getattr(models, cp['model_name'])(pretrained=True)\n \n # Freeze parameters that we don't need to re-train \n for param in model.parameters():\n param.requires_grad = False\n \n # Make classifier\n model.classifier = NN_Classifier(input_size=cp['c_input'], output_size=cp['c_out'], \\\n hidden_layers=cp['c_hidden'])\n \n # Add model info \n model.classifier.n_in = cp['c_input']\n model.classifier.n_hidden = cp['c_hidden']\n model.classifier.n_out = cp['c_out']\n model.classifier.labelsdict = cp['labelsdict']\n model.classifier.lr = cp['c_lr']\n model.classifier.optimizer_state_dict = cp['opti_state_dict']\n model.classifier.model_name = cp['model_name']\n model.classifier.class_to_idx = cp['class_to_idx']\n model.load_state_dict(cp['state_dict'])\n \n return model","def load_CIFAR10(ROOT):\n xs = []\n ys = []\n for b in range(1,6):\n f = os.path.join(ROOT, 'data_batch_%d' % (b, ))\n X, Y = load_CIFAR_batch(f)\n xs.append(X)\n ys.append(Y)\n Xtr = np.concatenate(xs)\n Ytr = np.concatenate(ys)\n del X, Y\n Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))\n return Xtr, Ytr, Xte, Yte","def train_epoch(args, loss_func, pbar, train_loader, model, optimizer,\n train_bpd, train_recon_error , train_perplexity):\n model.train()\n # Loop data in epoch\n for x, _ in train_loader:\n\n # This break used for debugging\n if args.max_iterations is not None:\n if args.global_it > args.max_iterations:\n break\n\n x = x.to(args.device)\n\n # Get reconstruction and vector quantization loss\n # `x_prime`: reconstruction of `input`\n # `vq_loss`: MSE(encoded embeddings, nearest emb in codebooks)\n x_prime, vq_loss, perplexity = model(x)\n\n loss, log_pxz, bpd = loss_func(args, x_prime, x, vq_loss, model)\n\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n\n train_bpd.append((-1)*bpd.item())\n train_recon_error.append((-1)*log_pxz.item())\n train_perplexity.append(perplexity.item())\n\n # Print Average every 100 steps\n if (args.global_it+1) % 100 == 0:\n av_bpd = np.mean(train_bpd[-100:])\n av_rec_err = np.mean(train_recon_error[-100:])\n av_ppl = np.mean(train_perplexity[-100:])\n if args.model == 'vqvae':\n pbar.print_train(bpd=float(av_bpd), rec_err=float(av_rec_err),\n increment=100)\n elif args.model == 'diffvqvae':\n pbar.print_train(bpd=float(av_bpd), temp=float(model.temp),\n increment=100)\n args.global_it += 1","def run(self) -> None:\n self.model = self.trainer.train_model(self.model, self.data)"],"string":"[\n \"def cifar10_model_fn(features, labels, mode, params):\\n features = tf.reshape(features, [-1, _IMAGE_SIZE, _IMAGE_SIZE, _NUM_CHANNELS])\\n\\n learning_rate_fn = resnet_run_loop.learning_rate_with_decay(\\n batch_size=params['batch_size'], batch_denom=128,\\n num_images=_NUM_IMAGES['train'], boundary_epochs=[10, 20, 30],\\n decay_rates=[1, 0.1, 0.01, 0.001])\\n\\n # We use a weight decay of 0.0002, which performs better\\n # than the 0.0001 that was originally suggested.\\n weight_decay = 2e-4\\n\\n # Empirical testing showed that including batch_normalization variables\\n # in the calculation of regularized loss helped validation accuracy\\n # for the CIFAR-10 dataset, perhaps because the regularization prevents\\n # overfitting on the small data set. We therefore include all vars when\\n # regularizing and computing loss during training.\\n def loss_filter_fn(_):\\n return True\\n\\n return resnet_run_loop.resnet_model_fn(\\n features=features,\\n labels=labels,\\n mode=mode,\\n model_class=Model,\\n resnet_size=params['resnet_size'],\\n weight_decay=weight_decay,\\n learning_rate_fn=learning_rate_fn,\\n momentum=0.9,\\n data_format=params['data_format'],\\n resnet_version=params['resnet_version'],\\n loss_scale=params['loss_scale'],\\n loss_filter_fn=loss_filter_fn,\\n dtype=params['dtype'],\\n fine_tune=params['fine_tune']\\n )\",\n \"def train_cifar10():\\r\\n # type: () -> None\\r\\n\\r\\n # Build dataset and model\\r\\n dataset = CIFAR10_TRAIN(path=Config.video_folder)\\r\\n model = LSACIFAR10(input_shape=dataset.shape, code_length=64,\\r\\n cpd_channels=100).to(device).train()\\r\\n\\r\\n # Set up result helper and perform test\\r\\n helper = OneClassResultHelper(dataset, model,\\r\\n checkpoints_dir=Config.model_ckpt,\\r\\n output_file='cifar10.txt')\\r\\n helper.train_one_class_classification()\",\n \"def evaluate():\\n with tf.Graph().as_default() as g:\\n # Get images and labels for CIFAR-10.\\n # eval_data = FLAGS.eval_data\\n # images, labels = model.inputs(eval_data=eval_data, batch_size=FLAGS.eval_batch_size)\\n data_obj = model.inputs()\\n values = data_obj.value\\n data = tf.concat(values,0)\\n # print(data)\\n\\n data = tf.reshape(data, [data_obj.height,data_obj.width])\\n # print(data)\\n # Build a Graph that computes the logits predictions from the\\n # inference model.\\n representation, reconstruct = model.inference_fconn(data)\\n # print(representation)\\n # print(reconstruct)\\n # print(data)\\n # Calculate predictions.\\n # representation_reshape = tf.reshape(representation, [FLAGS.eval_batch_size, -1])\\n\\n # Restore the moving average version of the learned variables for eval.\\n variable_averages = tf.train.ExponentialMovingAverage(\\n model.MOVING_AVERAGE_DECAY)\\n variables_to_restore = variable_averages.variables_to_restore()\\n saver = tf.train.Saver(variables_to_restore)\\n\\n # images_reconstruct = tf.concat([data, tf.transpose(reconstruct)],1)\\n # print(images_reconstruct)\\n # tf.summary.image('original_reconstruct', images_reconstruct)\\n # tf.image_summary('original', images, max_images=20)\\n # tf.image_summary('reconstruct', reconstruct, max_images=20)\\n\\n # Build the summary operation based on the TF collection of Summaries.\\n summary_op = tf.summary.merge_all()\\n\\n summary_writer = tf.summary.FileWriter(eval_dir, g)\\n\\n\\n while True:\\n eval_once(saver, summary_writer, representation, summary_op, reconstruct, data)\\n if FLAGS.run_once:\\n break\\n time.sleep(FLAGS.eval_interval_secs)\",\n \"def train(self, network_parameters=network_model, eval_steps=100):\\n #model_dir=TFFLAGS.train_dir\\n #self.model_dir=model_dir\\n network_parameters=buildNetwork()\\n model_path='models/central/'\\n save_path=\\\"models/cifar/clients\\\"\\n cifar_train_file=\\\"data/clients/cifar\\\"\\n cifar_test_file=\\\"data/clients/cifar\\\"\\n \\n batch_size = TFFLAGS.batch_size\\n\\n params = {\\\"accountant_type\\\": TFFLAGS.accountant_type,\\n \\\"task_id\\\": 0,\\n \\\"batch_size\\\": TFFLAGS.batch_size,\\n \\\"default_gradient_l2norm_bound\\\":\\n network_parameters.default_gradient_l2norm_bound,\\n \\\"num_hidden_layers\\\": TFFLAGS.num_hidden_layers,\\n \\\"hidden_layer_num_units\\\": TFFLAGS.hidden_layer_num_units,\\n \\\"num_examples\\\": self.num_training_images,\\n \\\"learning_rate\\\": TFFLAGS.lr,\\n \\\"end_learning_rate\\\": TFFLAGS.end_lr,\\n \\\"learning_rate_saturate_epochs\\\": TFFLAGS.lr_saturate_epochs\\n }\\n\\n params.update({\\\"sigma\\\": TFFLAGS.sigma})\\n #saver = tf.train.Saver()\\n\\n with tf.Graph().as_default(), tf.Session() as sess, tf.device('/cpu:0'):\\n # Create the basic Cifar model.\\n # TODO: GET INPUT FOR CLIENT\\n #images, labels = CifarInput(cifar_train_file, batch_size, TFFLAGS.randomize)\\n images, labels = cifar10_input.distorted_inputs(\\\"data/clients/cifar\\\", self.index, TFFLAGS.batch_size)\\n \\n\\n logits, projection, training_params = utils.BuildNetwork(\\n images, network_parameters)\\n \\n \\n cost = tf.nn.softmax_cross_entropy_with_logits(\\n logits=logits, labels=tf.one_hot(labels, 10))\\n\\n # The actual cost is the average across the examples.\\n cost = tf.reduce_sum(cost, [0]) / batch_size\\n\\n priv_accountant = accountant.GaussianMomentsAccountant(self.num_training_images)\\n sigma = TFFLAGS.sigma\\n with_privacy = TFFLAGS.sigma > 0\\n with_privacy = False\\n # Note: Here and below, we scale down the l2norm_bound by\\n # batch_size. This is because per_example_gradients computes the\\n # gradient of the minibatch loss with respect to each individual\\n # example, and the minibatch loss (for our model) is the *average*\\n # loss over examples in the minibatch. Hence, the scale of the\\n # per-example gradients goes like 1 / batch_size.\\n gaussian_sanitizer = sanitizer.AmortizedGaussianSanitizer(\\n priv_accountant, \\n [network_parameters.default_gradient_l2norm_bound / batch_size, True])\\n\\n for var in training_params:\\n if \\\"gradient_l2norm_bound\\\" in training_params[var]:\\n l2bound = training_params[var][\\\"gradient_l2norm_bound\\\"] / batch_size\\n gaussian_sanitizer.set_option(var,\\n sanitizer.ClipOption(l2bound, True))\\n lr = tf.placeholder(tf.float32)\\n eps = tf.placeholder(tf.float32)\\n delta = tf.placeholder(tf.float32)\\n\\n init_ops = []\\n\\n # Add global_step\\n global_step = tf.Variable(0, dtype=tf.int32, trainable=False,\\n name=\\\"global_step\\\")\\n\\n if with_privacy:\\n gd_op = dp_optimizer.DPGradientDescentOptimizer(\\n lr,\\n [eps, delta],\\n gaussian_sanitizer,\\n sigma=sigma,\\n batches_per_lot=TFFLAGS.batches_per_lot).minimize(\\n cost, global_step=global_step)\\n else:\\n gd_op = tf.train.GradientDescentOptimizer(lr).minimize(cost)\\n\\n saver = tf.train.Saver()\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n\\n # We need to maintain the intialization sequence.\\n #for v in tf.trainable_variables():\\n # sess.run(tf.variables_initializer([v]))\\n #sess.run(tf.global_variables_initializer())\\n \\n ##### NEED DIS TO LOAD MODEL PLS.\\n saver.restore(sess, tf.train.latest_checkpoint(save_path))\\n\\n sess.run(init_ops)\\n\\n start_time = time.time()\\n prev_time = start_time\\n filename = \\\"client-\\\" + str(self.index) + \\\"-results-0.json\\\"\\n log_path = os.path.join(save_path, filename)\\n print(log_path)\\n target_eps = [float(s) for s in TFFLAGS.target_eps.split(\\\",\\\")]\\n max_target_eps = max(target_eps)\\n\\n lot_size = TFFLAGS.batches_per_lot * TFFLAGS.batch_size\\n lots_per_epoch = self.num_training_images / lot_size\\n for step in range(TFFLAGS.num_training_steps):\\n epoch = step / lots_per_epoch\\n curr_lr = utils.VaryRate(TFFLAGS.lr, TFFLAGS.end_lr,\\n TFFLAGS.lr_saturate_epochs, epoch)\\n curr_eps = utils.VaryRate(TFFLAGS.eps, TFFLAGS.end_eps,\\n TFFLAGS.eps_saturate_epochs, epoch)\\n for _ in range(TFFLAGS.batches_per_lot):\\n _ = sess.run(\\n [gd_op], feed_dict={lr: curr_lr, eps: curr_eps, delta: TFFLAGS.delta})\\n sys.stderr.write(\\\"step: %d\\\\n\\\" % step)\\n\\n # See if we should stop training due to exceeded privacy budget:\\n should_terminate = False\\n terminate_spent_eps_delta = None\\n if with_privacy and TFFLAGS.terminate_based_on_privacy:\\n terminate_spent_eps_delta = priv_accountant.get_privacy_spent(\\n sess, target_eps=[max_target_eps])[0]\\n # For the Moments accountant, we should always have\\n # spent_eps == max_target_eps.\\n if (terminate_spent_eps_delta.spent_delta > TFFLAGS.target_delta or\\n terminate_spent_eps_delta.spent_eps > max_target_eps):\\n should_terminate = True\\n\\n if (eval_steps > 0 and (step + 1) % eval_steps == 0) or should_terminate:\\n if with_privacy:\\n spent_eps_deltas = priv_accountant.get_privacy_spent(\\n sess, target_eps=target_eps)\\n else:\\n spent_eps_deltas = [accountant.EpsDelta(0, 0)]\\n for spent_eps, spent_delta in spent_eps_deltas:\\n sys.stderr.write(\\\"spent privacy: eps %.4f delta %.5g\\\\n\\\" % (\\n spent_eps, spent_delta))\\n path = save_path + \\\"/model%s.ckpt\\\"%self.client\\n saver.save(sess, save_path=path)\\n train_accuracy, _ = self.Eval(cifar_train_file, network_parameters,\\n num_testing_images=self.num_testing_images,\\n randomize=True, load_path=TFFLAGS.save_path)\\n sys.stderr.write(\\\"train_accuracy: %.2f\\\\n\\\" % train_accuracy)\\n \\n curr_time = time.time()\\n elapsed_time = curr_time - prev_time\\n prev_time = curr_time\\n \\n self.results.append({\\\"step\\\": step+1, # Number of lots trained so far.\\n \\\"elapsed_secs\\\": elapsed_time,\\n \\\"spent_eps_deltas\\\": spent_eps_deltas,\\n \\\"train_accuracy\\\": train_accuracy})\\n loginfo = {\\\"elapsed_secs\\\": curr_time-start_time,\\n \\\"spent_eps_deltas\\\": spent_eps_deltas,\\n \\\"train_accuracy\\\": train_accuracy,\\n \\\"num_training_steps\\\": step+1, # Steps so far.\\n \\\"result_series\\\": self.results}\\n loginfo.update(params)\\n if log_path:\\n with tf.gfile.Open(log_path, \\\"w\\\") as f:\\n json.dump(loginfo, f, indent=2)\\n f.write(\\\"\\\\n\\\")\\n f.close()\\n if should_terminate:\\n for t in tf.trainable_variables():\\n weights.append(t.eval(session=sess))\\n break\\n for t in tf.trainable_variables():\\n weights.append(t.eval(session=sess))\\n \\n coord.request_stop()\\n coord.join(threads)\",\n \"def run_crnet(model, epoch=100):\\n criterion = CRLoss()\\n\\n optimizer_ft = optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-5)\\n exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=50, gamma=0.1)\\n\\n print('start loading SCUTFBP5500 dataset...')\\n train_loader, test_loader = data_loader.load_scutfbp5500_data()\\n train_model_with_crloss(model=model, train_dataloader=train_loader, test_dataloader=test_loader,\\n criterion=criterion, optimizer=optimizer_ft, scheduler=exp_lr_scheduler, num_epochs=epoch,\\n inference=False)\",\n \"def resnet50_cifar10(pretrained=True, progress=True, use_data_parallel=False, **kwargs):\\n return _model('resnet50_cifar10', resnet50, pretrained, progress, use_data_parallel, **kwargs)\",\n \"def train(self):\\n # Track initial loss/accuracy\\n self.validation_epoch()\\n for epoch in range(self.epochs):\\n # Perform a full pass through all the training samples\\n for batch_it, (X_batch, Y_batch) in enumerate(self.dataloader_train):\\n # X_batch is the CIFAR10 images. Shape: [batch_size, 3, 32, 32]\\n # Y_batch is the CIFAR10 image label. Shape: [batch_size]\\n # Transfer images / labels to GPU VRAM, if possible\\n X_batch = to_cuda(X_batch)\\n Y_batch = to_cuda(Y_batch)\\n\\n # Perform the forward pass\\n predictions = self.model(X_batch)\\n # Compute the cross entropy loss for the batch\\n loss = self.loss_criterion(predictions, Y_batch)\\n\\n # Backpropagation\\n loss.backward()\\n\\n # Gradient descent step\\n self.optimizer.step()\\n \\n # Reset all computed gradients to 0\\n self.optimizer.zero_grad()\\n # Compute loss/accuracy for all three datasets.\\n if batch_it % self.validation_check == 0:\\n self.validation_epoch()\\n # Check early stopping criteria.\\n if self.should_early_stop():\\n print(\\\"Early stopping.\\\")\\n return\",\n \"def train():\\n\\n ### DO NOT CHANGE SEEDS!\\n # Set the random seeds for reproducibility\\n np.random.seed(42)\\n epoch_num = 3\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n model = ConvNet(3, 10)\\n\\n #Obtain Dataset\\n train_dataset = cifar10_utils.get_cifar10()['train']\\n val_dataset = cifar10_utils.get_cifar10()['validation']\\n test_dataset = cifar10_utils.get_cifar10()['test']\\n\\n train_loader = torch.utils.data.DataLoader(\\n train_dataset,\\n batch_size = BATCH_SIZE_DEFAULT,\\n drop_last = True)\\n\\n criterion = nn.CrossEntropyLoss()\\n optimizer = torch.optim.Adam(model.parameters())\\n for epoch in range(epoch_num):\\n model.train()\\n losses = []\\n accs = []\\n for i_iter in range(int(train_dataset.num_examples/BATCH_SIZE_DEFAULT)):\\n images, labels = train_dataset.next_batch(BATCH_SIZE_DEFAULT)\\n images, labels = torch.tensor(images), torch.tensor(labels, dtype = torch.long)\\n pred = model(images)\\n labels = torch.argmax(labels, dim=1)\\n loss = criterion(pred, labels)\\n pred_result = torch.argmax(pred, dim=1)\\n acc = accuracy(pred_result, labels)\\n accs.append(acc)\\n model.zero_grad()\\n loss.backward()\\n optimizer.step()\\n losses.append(loss)\\n if i_iter % 100 ==0:\\n msg = 'Epoch:[{}/{}] Iter: [{}/{}], Loss: {: .6f}, ACC:[{: .6f}]'.format(epoch, epoch_num, i_iter, int(train_dataset.num_examples/BATCH_SIZE_DEFAULT), sum(losses)/len(losses), sum(accs)/len(accs))\\n print(msg)\\n with open('./log.txt', 'a') as f:\\n f.write(msg)\\n f.write('\\\\n')\\n msg_epoch = '--------Epoch: [{}/{}], Loss: {: .6f}, ACC:[{: .6f}]-------'.format(epoch, epoch_num, sum(losses)/len(losses), sum(accs)/len(accs))\\n print(msg_epoch)\\n with open('./log.txt', 'a') as f:\\n f.write(msg)\\n f.write('\\\\n')\\n #raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def run(self):\\n params = self.params\\n\\n # load data\\n self.data = self.load_data()\\n # check if loaded classification data set is using the same dict as pretrained model\\n if not self.data['dico'] == self._embedder.dico:\\n self.compare_dict(self.data['dico'], self._embedder.dico)\\n raise Exception((\\\"Dictionary in evaluation data (%i words) seems different than the one \\\" +\\n \\\"in the pretrained model (%i words). Please verify you used the same dictionary, \\\" +\\n \\\"and the same values for max_vocab and min_count.\\\") % (len(self.data['dico']),\\n len(self._embedder.dico)))\\n\\n # embedder\\n self.encoder = copy.deepcopy(self._embedder)\\n self.encoder.cuda()\\n\\n # projection layer: CHANGE 3 to your number of classes output\\n self.proj = nn.Sequential(*[\\n nn.Dropout(params.dropout),\\n nn.Linear(self.encoder.out_dim, params.clf_output_dim)\\n ]).cuda()\\n\\n # optimizers: use different optimizers to tune embedding layer and projection layer\\n self.optimizer_e = get_optimizer(list(self.encoder.get_parameters(params.finetune_layers)), params.optimizer_e)\\n self.optimizer_p = get_optimizer(self.proj.parameters(), params.optimizer_p)\\n best_acc = 0\\n eval_metric = \\\"CLF_valid_en_acc\\\"\\n # train and evaluate the model\\n for epoch in range(params.n_epochs):\\n # update epoch\\n self.epoch = epoch\\n\\n # training\\n logger.info(\\\"CLF - Training epoch %i ...\\\" % epoch)\\n self.train()\\n\\n # evaluation\\n logger.info(\\\"CLF - Evaluating epoch %i ...\\\" % epoch)\\n with torch.no_grad():\\n scores = self.eval()\\n if scores[eval_metric] > best_acc:\\n logger.info('New best score for %s: %.6f' % (eval_metric, scores[eval_metric]))\\n self.save_checkpoint('best-%s' % eval_metric)\\n self.decrease_counts = 0\\n best_acc = scores[eval_metric]\\n else:\\n logger.info(\\\"Not a better validation score (%i / %i).\\\"\\n % (self.decrease_counts, self.decrease_counts_max))\\n self.decrease_counts += 1\\n if self.decrease_counts > self.decrease_counts_max:\\n logger.info(\\\"Stopping criterion has been below its best value for more \\\"\\n \\\"than %i epochs. Ending the experiment...\\\" % self.decrease_counts_max)\\n exit()\\n self.scores.update(scores)\",\n \"def train_resnet():\\n\\n # load data\\n training_sets = load_augmented_dataset()\\n\\n # build models\\n model_resnet = build_resnetv2()\\n\\n baseWeights_t = model_resnet.get_weights()\\n\\n for training_set in training_sets:\\n print(\\\" Starting training for set {}\\\".format(str(training_set)))\\n model_resnet.set_weights(baseWeights_t) # Resets model\\n train_x = np.load(os.path.join(\\\"./model_cache/train_data\\\", training_sets[training_set][0]))\\n train_y = np.load(os.path.join(\\\"./model_cache/train_data\\\", training_sets[training_set][1]))\\n\\n early_stopping_monitor = EarlyStopping(patience=3)\\n history = model_resnet.fit(train_x, train_y, batch_size=32, epochs=40, verbose=1, validation_split=0.2,\\n shuffle=True,\\n callbacks=[early_stopping_monitor])\\n\\n mpu.plot_accuracy_loss(history,\\n \\\"./model_cache/train_data/{}_resnet_plots.png\\\".format(str(training_set)))\\n\\n upload_blob(BUCKET_NAME, \\\"./model_cache/train_data/{}_resnet_plots.png\\\".format(str(training_set)),\\n \\\"model_charts/{}_resnet_plots.png\\\".format(str(training_set)))\\n\\n model_resnet.save(\\\"./model_cache/train_data/{}_resnet.h5\\\".format(str(training_set)))\\n\\n upload_blob(BUCKET_NAME, \\\"./model_cache/train_data/{}_resnet.h5\\\".format(str(training_set)),\\n \\\"saved_models/{}_resnet.h5\\\".format(str(training_set)))\",\n \"def train(self):\\n best_loss = math.inf\\n for _ in range(self.epoch, self.end_epoch):\\n self.summary_writer.add_scalar('epoch', self.epoch, self.total_steps)\\n epoch_loss, _ = self.run_epoch(self.dataloader)\\n if epoch_loss < best_loss:\\n best_loss = epoch_loss\\n # save best module as onnx format\\n dummy_input = torch.randn((10, 3, self.image_dim, self.image_dim))\\n module_path = os.path.join(self.models_dir, 'resnet.onnx')\\n self.save_module(\\n self.resnet.module, module_path, save_onnx=True, dummy_input=dummy_input)\\n self.save_checkpoint('resnet_e{}_state.pth'.format(self.epoch))\\n\\n # validate step\\n val_loss, _ = self.validate()\\n\\n # update learning rates\\n self.lr_scheduler.step(val_loss)\\n self.save_learning_rate(self.summary_writer, self.optimizer, self.total_steps)\\n self.epoch += 1\\n self.test()\",\n \"def load_CIFAR10(ROOT):\\r\\n xs = []\\r\\n ys = []\\r\\n for b in range(1,6):\\r\\n f = os.path.join(ROOT, 'data_batch_%d' % (b, ))\\r\\n X, Y = load_CIFAR_batch(f)\\r\\n xs.append(X)\\r\\n ys.append(Y)\\r\\n Xtr = np.concatenate(xs)\\r\\n Ytr = np.concatenate(ys)\\r\\n del X, Y\\r\\n Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))\\r\\n return Xtr, Ytr, Xte, Yte\\r\\n\\r\\n\\tdef get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=10000):\\r\\n # Load the raw CIFAR-10 data\\r\\n \\r\\n cifar10_dir = 'Downloads/cifar-10-batches-py'\\r\\n \\r\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\r\\n\\r\\n # Subsample the data\\r\\n mask = range(num_training, num_training + num_validation)\\r\\n X_val = X_train[mask]\\r\\n y_val = y_train[mask]\\r\\n mask = range(num_training)\\r\\n X_train = X_train[mask]\\r\\n y_train = y_train[mask]\\r\\n mask = range(num_test)\\r\\n X_test = X_test[mask]\\r\\n y_test = y_test[mask]\\r\\n\\r\\n x_train = X_train.astype('float32') \\r\\n x_test = X_test.astype('float32')\\r\\n \\r\\n x_train = x_train.reshape(-1, 32, 32, 3)\\r\\n x_test = x_test.reshape(-1, 32, 32, 3)\\r\\n x_train /= 255\\r\\n x_test /= 255\\r\\n\\r\\n return x_train, y_train, X_val, y_val, x_test, y_test\",\n \"def __init__(self, **kwargs):\\n super(CIFAR10Classifier, self).__init__() #pylint: disable=super-with-arguments\\n self.model_conv = models.resnet50(pretrained=True)\\n for param in self.model_conv.parameters():\\n param.requires_grad = False\\n num_ftrs = self.model_conv.fc.in_features\\n num_classes = 10\\n self.model_conv.fc = nn.Linear(num_ftrs, num_classes)\\n\\n self.scheduler = None\\n self.optimizer = None\\n self.args = kwargs\\n\\n self.train_acc = Accuracy()\\n self.val_acc = Accuracy()\\n self.test_acc = Accuracy()\\n\\n self.preds = []\\n self.target = []\\n self.example_input_array = torch.rand((1, 3, 64, 64))\",\n \"def eval(self):\\n self.train(mode=False)\",\n \"def train_crf(threads=3, hyperparameter_crf='1.5', cut_off='5', alg='CRF-L2'):\\n\\n print '\\\\n\\\\ttrain crf'\\n os.system('crf_learn -p ' + threads +\\n ' -c ' + hyperparameter_crf +\\n ' -f ' + cut_off +\\n ' -a ' + alg +\\n ' ' + template_file + ' ' + train_file_crf + ' ' + model_file)\\n print '\\\\t--done\\\\n'\",\n \"def train():\\r\\n with tf.Graph().as_default():\\r\\n global_step = tf.train.get_or_create_global_step()\\r\\n # Get images and labels for CIFAR-10.\\r\\n # Force input pipeline to CPU:0 to avoid operations sometimes ending up on\\r\\n # GPU and resulting in a slow down.\\r\\n with tf.device('/cpu:0'):\\r\\n signals, labels = cnnHAR.distorted_inputs()\\r\\n print('<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>')\\r\\n \\r\\n # Build a Graph that computes the logits predictions from the\\r\\n # inference model.\\r\\n #training = tf.placeholder(tf.bool)\\r\\n \\r\\n pool11=cnnHAR.inference_cov11(signals,'_01')\\r\\n reshape1=cnnHAR.inference_cov21(pool11,'_01')\\r\\n local21=cnnHAR.inference_local21(reshape1,'_01')\\r\\n local31=cnnHAR.inference_local31(local21,'_01')\\r\\n local41=cnnHAR.inference_local41(local31,'_01')\\r\\n logits1=cnnHAR.inference_output1(local41,'_01')\\r\\n \\r\\n \\r\\n pool12=cnnHAR.inference_cov11(signals,'_02')\\r\\n reshape2=cnnHAR.inference_cov21(pool12,'_02')\\r\\n local22=cnnHAR.inference_local21(reshape2,'_02')\\r\\n local32=cnnHAR.inference_local31(local22,'_02')\\r\\n local42=cnnHAR.inference_local41(local32,'_02')\\r\\n logits2=cnnHAR.inference_output1(local42,'_02')\\r\\n \\r\\n \\r\\n pool13=cnnHAR.inference_cov11(signals,'_03')\\r\\n reshape3=cnnHAR.inference_cov21(pool13,'_03')\\r\\n local23=cnnHAR.inference_local21(reshape3,'_03')\\r\\n local33=cnnHAR.inference_local31(local23,'_03')\\r\\n local43=cnnHAR.inference_local41(local33,'_03')\\r\\n logits3=cnnHAR.inference_output1(local43,'_03')\\r\\n \\r\\n \\r\\n pool14=cnnHAR.inference_cov11(signals,'_04')\\r\\n reshape4=cnnHAR.inference_cov21(pool14,'_04')\\r\\n local24=cnnHAR.inference_local21(reshape4,'_04')\\r\\n local34=cnnHAR.inference_local31(local24,'_04')\\r\\n local44=cnnHAR.inference_local41(local34,'_04')\\r\\n logits4=cnnHAR.inference_output1(local44,'_04')\\r\\n\\r\\n \\r\\n pool15=cnnHAR.inference_cov11(signals,'_05')\\r\\n reshape5=cnnHAR.inference_cov21(pool15,'_05')\\r\\n local25=cnnHAR.inference_local21(reshape5,'_05')\\r\\n local35=cnnHAR.inference_local31(local25,'_05')\\r\\n local45=cnnHAR.inference_local41(local35,'_05')\\r\\n logits5=cnnHAR.inference_output1(local45,'_05')\\r\\n\\r\\n pool16=cnnHAR.inference_cov11(signals,'_06')\\r\\n reshape6=cnnHAR.inference_cov21(pool16,'_06')\\r\\n local26=cnnHAR.inference_local21(reshape6,'_06')\\r\\n local36=cnnHAR.inference_local31(local26,'_06')\\r\\n local46=cnnHAR.inference_local41(local36,'_06')\\r\\n logits6=cnnHAR.inference_output1(local46,'_06')\\r\\n \\r\\n\\r\\n loss1=cnnHAR.loss(logits1, labels,'_01')\\r\\n loss2=cnnHAR.loss(logits2, labels,'_02')\\r\\n loss3=cnnHAR.loss(logits3, labels,'_03')\\r\\n loss4=cnnHAR.loss(logits4, labels,'_04')\\r\\n loss5=cnnHAR.loss(logits5, labels,'_05')\\r\\n loss6=cnnHAR.loss(logits6, labels,'_06')\\r\\n \\r\\n train_op1 = cnnHAR.train(loss1, global_step,'_01')\\r\\n train_op2 = cnnHAR.train(loss2, global_step,'_02')\\r\\n train_op3 = cnnHAR.train(loss3, global_step,'_03')\\r\\n train_op4 = cnnHAR.train(loss4, global_step,'_04')\\r\\n train_op5 = cnnHAR.train(loss5, global_step,'_05')\\r\\n train_op6 = cnnHAR.train(loss6, global_step,'_06')\\r\\n \\r\\n \\r\\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\r\\n class _LoggerHook(tf.train.SessionRunHook):\\r\\n \\\"\\\"\\\"Logs loss and runtime.\\\"\\\"\\\"\\r\\n\\r\\n def begin(self):\\r\\n self._step = -1\\r\\n self._start_time = time.time()\\r\\n\\r\\n def before_run(self, run_context):\\r\\n self._step += 1\\r\\n #print('~~~~~~~~~~~~~~~~before run1~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\\r\\n #tmp = tf.concat([labels,signals],1)\\r\\n \\r\\n index=int(self._step%(num*7)/7)\\r\\n if index==0:\\r\\n return tf.train.SessionRunArgs(loss1)\\r\\n elif index==1:\\r\\n return tf.train.SessionRunArgs(loss2)\\r\\n elif index==2:\\r\\n return tf.train.SessionRunArgs(loss3)\\r\\n elif index==3:\\r\\n return tf.train.SessionRunArgs(loss4)\\r\\n elif index==4:\\r\\n return tf.train.SessionRunArgs(loss5)\\r\\n elif index==5:\\r\\n return tf.train.SessionRunArgs(loss6)\\r\\n \\r\\n # Asks for loss value.\\r\\n\\r\\n def after_run(self, run_context, run_values):\\r\\n# if self._step == 1000:\\r\\n# #tf.Session().run(tf.global_variables_initializer())\\r\\n# ndar = np.array(run_values.results)\\r\\n# np.savetxt(\\\"logits.csv\\\", ndar.reshape(128,256), delimiter=\\\",\\\")\\r\\n \\r\\n if int((self._step-1) / log_frequency)%10==0 and (self._step%(num*7)+1)%7==0 and int(self._step%(num*7)/7)==0:#(self._step-1) % (log_frequency)== 0:\\r\\n #print('~~~~~~~~~~~~~~~~after run1~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\\r\\n '''\\r\\n current_time = time.time()\\r\\n duration = current_time - self._start_time\\r\\n self._start_time = current_time\\r\\n \\r\\n loss_value = run_values.results\\r\\n examples_per_sec = log_frequency * batch_size / duration\\r\\n sec_per_batch = float(duration / log_frequency)\\r\\n format_str = ('%s: step %d, loss = %.8f (%.1f examples/sec; %.3f '\\r\\n 'sec/batch)')\\r\\n '''\\r\\n format_str = ('%s: step %d loss%d=%0.8f')\\r\\n print(format_str % (datetime.now(), self._step+1, int(self._step%(num*7)/7)+1,run_values.results))\\r\\n \\r\\n class _LoggerHook2(tf.train.SessionRunHook):\\r\\n \\\"\\\"\\\"Logs signals.\\\"\\\"\\\"\\r\\n\\r\\n def begin(self):\\r\\n self._step = -1\\r\\n\\r\\n def before_run(self, run_context):\\r\\n self._step += 1\\r\\n #print('~~~~~~~~~~~~~~~~before run2~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\\r\\n return tf.train.SessionRunArgs(logits) # Asks for logits.\\r\\n\\r\\n def after_run(self, run_context, run_values):\\r\\n if self._step == max_steps-1:#:\\r\\n print('~~~~~~~~~~~~~~~~after run2~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\\r\\n ndar = np.array(run_values.results)\\r\\n np.savetxt(\\\"logits\\\"+str(self._step)+\\\".csv\\\", ndar.reshape(batch_size,NUM_CLASSES), delimiter=\\\",\\\")\\r\\n\\r\\n class _LoggerHook3(tf.train.SessionRunHook):\\r\\n \\\"\\\"\\\"Logs labels.\\\"\\\"\\\"\\r\\n\\r\\n def begin(self):\\r\\n self._step = -1\\r\\n\\r\\n def before_run(self, run_context):\\r\\n self._step += 1\\r\\n return tf.train.SessionRunArgs(labels) # Asks for labels.\\r\\n\\r\\n def after_run(self, run_context, run_values):\\r\\n if self._step == max_steps-1:\\r\\n ndar = np.array(run_values.results)\\r\\n np.savetxt(\\\"labels\\\"+str(self._step)+\\\".csv\\\", ndar.reshape(batch_size,NUM_CLASSES), delimiter=\\\",\\\")\\r\\n\\r\\n class _LoggerHook4(tf.train.SessionRunHook):\\r\\n \\\"\\\"\\\"Logs signals.\\\"\\\"\\\"\\r\\n\\r\\n def begin(self):\\r\\n self._step = -1\\r\\n\\r\\n def before_run(self, run_context):\\r\\n self._step += 1\\r\\n #print('~~~~~~~~~~~~~~~~before run4~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\\r\\n #return tf.train.SessionRunArgs(signals) # Asks for signals.\\r\\n\\r\\n def after_run(self, run_context, run_values):\\r\\n if (self._step+1)% (50*log_frequency) == 0:\\r\\n #if self._step == max_steps-1:#:\\r\\n #print('~~~~~~~~~~~~~~~~after run4~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\\r\\n cnnHAR_eval.main()\\r\\n\\r\\n with tf.train.MonitoredTrainingSession(\\r\\n checkpoint_dir=train_dir,\\r\\n hooks=[tf.train.StopAtStepHook(last_step=max_steps),\\r\\n #tf.train.NanTensorHook(loss),\\r\\n _LoggerHook(),\\r\\n #_LoggerHook2(),\\r\\n _LoggerHook4()],#,save_checkpoint_steps=5000\\r\\n config=tf.ConfigProto(\\r\\n log_device_placement=log_device_placement),save_checkpoint_steps=50*log_frequency) as mon_sess:\\r\\n ''',save_checkpoint_steps=10*log_frequency'''\\r\\n i=0\\r\\n while not mon_sess.should_stop():\\r\\n# mon_sess = tfdbg.LocalCLIDebugWrapperSession(mon_sess)\\r\\n #mon_sess.run([train_op1,extra_update_ops])\\r\\n #print('~~~~~~~~~~~~~~~~%d step:'%i)\\r\\n \\r\\n index=int(i%(num*7)/7)\\r\\n if index==0:\\r\\n #print('~~~~~~~~~~~~~~~~train_op1')\\r\\n mon_sess.run([train_op1,extra_update_ops])\\r\\n elif index==1:\\r\\n #print('~~~~~~~~~~~~~~~~train_op2')\\r\\n mon_sess.run([train_op2,extra_update_ops])\\r\\n elif index==2:\\r\\n #print('~~~~~~~~~~~~~~~~train_op3')\\r\\n mon_sess.run([train_op3,extra_update_ops])\\r\\n elif index==3:\\r\\n #print('~~~~~~~~~~~~~~~~train_op4')\\r\\n mon_sess.run([train_op4,extra_update_ops])\\r\\n elif index==4:\\r\\n #print('~~~~~~~~~~~~~~~~train_op5')\\r\\n mon_sess.run([train_op5,extra_update_ops])\\r\\n elif index==5:\\r\\n #print('~~~~~~~~~~~~~~~~train_op6')\\r\\n mon_sess.run([train_op6,extra_update_ops])\\r\\n '''\\r\\n elif index==6:\\r\\n #print('~~~~~~~~~~~~~~~~train_op1')\\r\\n mon_sess.run([train_op7,extra_update_ops])\\r\\n elif index==7:\\r\\n #print('~~~~~~~~~~~~~~~~train_op2')\\r\\n mon_sess.run([train_op8,extra_update_ops])\\r\\n elif index==8:\\r\\n #print('~~~~~~~~~~~~~~~~train_op3')\\r\\n mon_sess.run([train_op9,extra_update_ops])\\r\\n elif index==9:\\r\\n #print('~~~~~~~~~~~~~~~~train_op4')\\r\\n mon_sess.run([train_op10,extra_update_ops])\\r\\n elif index==10:\\r\\n #print('~~~~~~~~~~~~~~~~train_op5')\\r\\n mon_sess.run([train_op11,extra_update_ops])\\r\\n elif index==11:\\r\\n #print('~~~~~~~~~~~~~~~~train_op6')\\r\\n mon_sess.run([train_op12,extra_update_ops])\\r\\n '''\\r\\n i=i+1\\r\\n \\r\\n #print('~~~~~~~~~~~~~~~~one session ends~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')\\r\",\n \"def run(self):\\n for _ in range(self.epoch, conf.FX_MAX_EPOCHS):\\n self.train()\\n\\n with torch.no_grad():\\n self.test()\\n\\n self.epoch += 1\\n self.save_ck()\\n\\n self.show_completion_msg()\",\n \"def main():\\r\\n # assert tf.__version__[0] == \\\"2\\\"\\r\\n\\r\\n \\\"\\\"\\\" Load Config \\\"\\\"\\\"\\r\\n with open('./config/config_origin.json', 'r') as f:\\r\\n CONFIG = json.load(f)\\r\\n BATCH_SIZE = CONFIG[\\\"BATCH_SIZE\\\"]\\r\\n ROOT_PATH = CONFIG[\\\"ROOT_PATH\\\"]\\r\\n TRAIN_DATA_DIR = CONFIG[\\\"TRAIN_DATA_DIR\\\"]\\r\\n TEST_DATA_DIR = CONFIG[\\\"TEST_DATA_DIR\\\"]\\r\\n TRAIN_DATA_DIR = os.path.join(ROOT_PATH, TRAIN_DATA_DIR)\\r\\n TEST_DATA_DIR = os.path.join(ROOT_PATH, TEST_DATA_DIR)\\r\\n MODEL_CKPT = CONFIG[\\\"MODEL_CKPT\\\"]\\r\\n\\r\\n \\\"\\\"\\\" Prepare Model \\\"\\\"\\\"\\r\\n n = 6 # order of ResNetv2\\r\\n version = 2\\r\\n depth = model_depth(n, version)\\r\\n MODEL_TYPE = 'ResNet%dv%d' % (depth, version)\\r\\n SAVES_DIR = \\\"models-%s/\\\" % MODEL_TYPE\\r\\n SAVES_DIR = os.path.join(ROOT_PATH, SAVES_DIR)\\r\\n MODEL_CKPT = os.path.join(SAVES_DIR, MODEL_CKPT)\\r\\n\\r\\n # Features directory\\r\\n FEATURE_DIR = os.path.join(ROOT_PATH, \\\"features\\\")\\r\\n FEATURE_DIR = os.path.join(FEATURE_DIR, \\\"models-%s/\\\" % MODEL_TYPE)\\r\\n if not os.path.exists(FEATURE_DIR):\\r\\n os.mkdir(FEATURE_DIR)\\r\\n\\r\\n if not os.path.exists(SAVES_DIR):\\r\\n os.mkdir(SAVES_DIR)\\r\\n model = resnet_v2(input_shape=INPUT_SHAPE, depth=depth, num_classes=2)\\r\\n model.compile(loss='categorical_crossentropy',\\r\\n optimizer=Adam(learning_rate=lr_schedule(TRAINING_EPOCHS)),\\r\\n metrics=METRICS)\\r\\n # model.summary()\\r\\n print(MODEL_TYPE)\\r\\n\\r\\n \\\"\\\"\\\" Load Weights \\\"\\\"\\\"\\r\\n model_ckpt_file = os.path.join(SAVES_DIR, MODEL_CKPT)\\r\\n if os.path.exists(model_ckpt_file):\\r\\n print(\\\"Model ckpt found! Loading...:%s\\\" % model_ckpt_file)\\r\\n model.load_weights(model_ckpt_file)\\r\\n\\r\\n \\\"\\\"\\\" Extract Testing Data \\\"\\\"\\\"\\r\\n _train_filenames = os.listdir(os.path.join(TRAIN_DATA_DIR, \\\"bad_1\\\"))\\r\\n train_bad_df = pd.DataFrame({\\r\\n 'filename': _train_filenames\\r\\n })\\r\\n n_bad_samples = train_bad_df.shape[0]\\r\\n train_bad_df.to_csv(os.path.join(\\r\\n FEATURE_DIR, \\\"bad_samples_list.csv\\\"), index=False)\\r\\n\\r\\n \\\"\\\"\\\" Extract good samples \\\"\\\"\\\"\\r\\n _train_filenames = os.listdir(os.path.join(TRAIN_DATA_DIR, \\\"good_0\\\"))\\r\\n train_good_df = pd.DataFrame({\\r\\n 'filename': _train_filenames\\r\\n })\\r\\n n_good_samples = train_good_df.shape[0]\\r\\n train_good_df.to_csv(os.path.join(\\r\\n FEATURE_DIR, \\\"good_samples_list.csv\\\"), index=False)\\r\\n\\r\\n \\\"\\\"\\\" Create bad sample validation generator \\\"\\\"\\\"\\r\\n train_bad_datagen = ImageDataGenerator(rescale=1./255)\\r\\n train_bad_generator = train_bad_datagen.flow_from_dataframe(\\r\\n train_bad_df,\\r\\n os.path.join(TRAIN_DATA_DIR, \\\"bad_1\\\"),\\r\\n x_col='filename',\\r\\n y_col=None,\\r\\n class_mode=None,\\r\\n target_size=IMAGE_SIZE,\\r\\n color_mode=\\\"grayscale\\\",\\r\\n batch_size=BATCH_SIZE,\\r\\n shuffle=False\\r\\n )\\r\\n\\r\\n \\\"\\\"\\\" Create bad sample validation generator \\\"\\\"\\\"\\r\\n train_good_datagen = ImageDataGenerator(rescale=1./255)\\r\\n train_good_generator = train_good_datagen.flow_from_dataframe(\\r\\n train_good_df,\\r\\n os.path.join(TRAIN_DATA_DIR, \\\"good_0\\\"),\\r\\n x_col='filename',\\r\\n y_col=None,\\r\\n class_mode=None,\\r\\n target_size=IMAGE_SIZE,\\r\\n color_mode=\\\"grayscale\\\",\\r\\n batch_size=BATCH_SIZE,\\r\\n shuffle=False\\r\\n )\\r\\n\\r\\n \\\"\\\"\\\" Extractor \\\"\\\"\\\"\\r\\n extractor = Model(\\r\\n model.inputs, model.layers[-2].output) # flatten_2 (Flatten) (None, 12544)\\r\\n # features = extractor.predict(data)\\r\\n\\r\\n \\\"\\\"\\\" Extract train set 的特征 \\\"\\\"\\\"\\r\\n import time\\r\\n # bad samples\\r\\n start = time.perf_counter()\\r\\n print(\\\"Start extracting bad samples...\\\")\\r\\n features = extractor.predict_generator(\\r\\n train_bad_generator, steps=np.ceil(n_bad_samples / BATCH_SIZE),\\r\\n workers=4, verbose=1)\\r\\n print(\\\"features.shape:\\\", features.shape) # (16/32/etc, 12544)\\r\\n np.save(os.path.join(FEATURE_DIR, \\\"features_train_bad.npy\\\"), features)\\r\\n\\r\\n elapsed = (time.perf_counter() - start)\\r\\n print(\\\"Prediction time used:\\\", elapsed)\\r\\n # TODO 用 pandas 存储\\r\\n # good samples\\r\\n start = time.perf_counter()\\r\\n print(\\\"Start extracting good samples...\\\")\\r\\n features = extractor.predict_generator(\\r\\n train_good_generator, steps=np.ceil(n_good_samples / BATCH_SIZE),\\r\\n workers=4, verbose=1)\\r\\n print(\\\"features.shape:\\\", features.shape) # (16/32/etc, 12544)\\r\\n np.save(os.path.join(FEATURE_DIR, \\\"features_train_good.npy\\\"), features)\\r\\n\\r\\n elapsed = (time.perf_counter() - start)\\r\\n print(\\\"Prediction time used:\\\", elapsed)\",\n \"def get_cifar10_cnn():\\n # Set defaults.\\n nb_classes = 10 #dataset dependent \\n batch_size = 128\\n epochs = 4\\n \\n # the data, shuffled and split between train and test sets\\n (x_train, y_train), (x_test, y_test) = cifar10.load_data()\\n \\n # convert class vectors to binary class matrices\\n y_train = to_categorical(y_train, nb_classes)\\n y_test = to_categorical(y_test, nb_classes)\\n\\n #x._train shape: (50000, 32, 32, 3)\\n #input shape (32, 32, 3)\\n input_shape = x_train.shape[1:]\\n\\n #print('x_train shape:', x_train.shape)\\n #print(x_train.shape[0], 'train samples')\\n #print(x_test.shape[0], 'test samples')\\n #print('input shape', input_shape)\\n \\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n x_train /= 255\\n x_test /= 255\\n\\n return (nb_classes, batch_size, input_shape, x_train, x_test, y_train, y_test, epochs)\",\n \"def train():\\n\\n ### DO NOT CHANGE SEEDS!\\n # Set the random seeds for reproducibility\\n np.random.seed(42)\\n\\n ## Prepare all functions\\n # Get number of units in each hidden layer specified in the string such as 100,100\\n if FLAGS.dnn_hidden_units:\\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\\\",\\\")\\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\\n else:\\n dnn_hidden_units = []\\n\\n # Get negative slope parameter for LeakyReLU\\n neg_slope = FLAGS.neg_slope\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n import matplotlib.pyplot as plt\\n\\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\\n train = data['train']\\n test = data['test']\\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\\n\\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\\n loss_module = CrossEntropyModule()\\n\\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n\\n images_test = test.images\\n labels_test = test.labels\\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\\n\\n for i in range(0, FLAGS.max_steps):\\n if PRINTS:\\n print('iter', i+1, end='\\\\r')\\n images, labels = train.next_batch(FLAGS.batch_size) \\n images = np.reshape(images, (images.shape[0], dim_x))\\n\\n pred = mlp.forward(images)\\n loss = loss_module.forward(pred, labels)\\n loss_grad = loss_module.backward(pred, labels)\\n mlp.backward(loss_grad)\\n\\n for module in reversed(mlp.modules):\\n if isinstance(module, LinearModule):\\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\\n if (i+1) % FLAGS.eval_freq == 0:\\n pred_test = mlp.forward(images_test)\\n loss_train[i // FLAGS.eval_freq] = loss\\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\\n if PRINTS:\\n print()\\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\\n\\n if PLOTS:\\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\\n fig.suptitle('Training curves for Numpy MLP\\\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\\n\\n ax[0].set_title('Loss')\\n ax[0].set_ylabel('Loss value')\\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[0].plot(loss_train, label='Train')\\n ax[0].plot(loss_test, label='Test')\\n ax[0].legend()\\n\\n ax[1].set_title('Accuracy')\\n ax[1].set_ylabel('Accuracy value')\\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[1].plot(accuracy_test, label='Test')\\n ax[1].legend()\\n plt.show()\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def train_and_eval_eccv(train, test):\\n train_vec = list()\\n train_label = list()\\n test_vec = list()\\n test_label = list()\\n\\n for k, v in train.items():\\n feature = np.concatenate((extract_feature(k, layer_name=\\\"conv5_2\\\"), extract_feature(k, layer_name=\\\"conv5_3\\\")),\\n axis=0)\\n train_vec.append(feature)\\n train_label.append(v)\\n\\n for k, v in test.items():\\n feature = np.concatenate((extract_feature(k, layer_name=\\\"conv5_2\\\"), extract_feature(k, layer_name=\\\"conv5_3\\\")),\\n axis=0)\\n test_vec.append(feature)\\n test_label.append(v)\\n\\n reg = linear_model.BayesianRidge()\\n reg.fit(np.array(train_vec), np.array(train_label))\\n mkdirs_if_not_exist('./model')\\n joblib.dump(reg, config['eccv_fbp_reg_model'])\\n\\n predicted_label = reg.predict(np.array(test_vec))\\n mae_lr = round(mean_absolute_error(np.array(test_label), predicted_label), 4)\\n rmse_lr = round(math.sqrt(mean_squared_error(np.array(test_label), predicted_label)), 4)\\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\\n\\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\\n\\n csv_tag = time.time()\\n\\n mkdirs_if_not_exist('./result')\\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\\n df.to_csv('./result/performance_%s.csv' % csv_tag, index=False)\\n\\n out_result(list(test.keys()), predicted_label.flatten().tolist(), test_label, None,\\n path='./result/detail_%s.csv' % csv_tag)\",\n \"def train():\\n ### DO NOT CHANGE SEEDS!\\n # Set the random seeds for reproducibility\\n np.random.seed(42)\\n\\n ## Prepare all functions\\n # Get number of units in each hidden layer specified in the string such as 100,100\\n if FLAGS.dnn_hidden_units:\\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\\\",\\\")\\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\\n else:\\n dnn_hidden_units = []\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n model = MLP(n_hidden=dnn_hidden_units,n_classes=10,batch_size=FLAGS.batch_size, input_dim=32*32*3, \\n weight_decay=FLAGS.weight_reg_strength, weight_scale=FLAGS.weight_init_scale)\\n\\n Datasets = utils.get_cifar10(data_dir = DATA_DIR_DEFAULT, one_hot = True, validation_size = 0)\\n \\n for i in range(1500): #(FLAGS.max_steps):\\n train_batch = Datasets.train.next_batch(batch_size = FLAGS.batch_size)\\n #Get the model output\\n logits = model.inference(x=train_batch[0].reshape([FLAGS.batch_size,32*32*3]))\\n #Get the loss and let the model set the loss derivative.\\n loss = model.loss(logits=logits, labels=train_batch[1])\\n #Perform training step\\n model.train_step(loss=loss, flags=FLAGS)\\n\\n #Every 100th iteratin print accuracy on the whole test set.\\n if i % 100 == 0:\\n # for layer in model.layers:\\n test_batch = Datasets.test.next_batch(batch_size = 200) #Datasets.test.num_examples\\n logits = model.inference(x=test_batch[0].reshape([200,32*32*3]))\\n print('-- Step: ', i, \\\" accuracy: \\\",model.accuracy(logits=logits,labels=test_batch[1]),'loss', loss )\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def catlin_run(workdir, cycles, cyclesize, gpuid = 0, max_testimages = 100000000000):\\n\\n # load val-data for evaluation\\n pyparams = pload(osp.join(workdir, 'valpyparams.pkl'))\\n imlist = [line.rstrip() for line in open(osp.join(workdir, 'vallist.txt'))][:max_testimages]\\n with open(osp.join(workdir, 'valdict.json')) as f:\\n imdict = json.load(f)\\n\\n # run\\n for i in range(cycles):\\n bct.run(workdir, gpuid = gpuid, nbr_iters = cyclesize)\\n _ = bct.classify_from_patchlist_wrapper(imlist, imdict, pyparams, workdir, gpuid = gpuid, save = True, net_prototxt = 'valnet.prototxt')\\n\\n # find and load optimal model\\n bestiter, _ = find_best_iter(workdir)\\n caffemodel = 'snapshot_iter_{}.caffemodel'.format(bestiter)\\n net = bct.load_model(workdir, caffemodel, gpuid = gpuid, net_prototxt = 'testnet.prototxt')\\n\\n # load test-data\\n pyparams = pload(osp.join(workdir, 'testpyparams.pkl'))\\n imlist = [line.rstrip() for line in open(osp.join(workdir, 'testlist.txt'))][:max_testimages]\\n with open(osp.join(workdir, 'testdict.json')) as f:\\n imdict = json.load(f)\\n\\n # run on test-data\\n (gtlist, estlist, scorelist) = bct.classify_from_patchlist(imlist, imdict, pyparams, net)\\n psave((gtlist, estlist, scorelist), osp.join(workdir, 'predictions_on_test.p'))\",\n \"def load_cifar(hparams):\\n all_labels = []\\n\\n total_batches_to_load = 5\\n assert hparams.train_size + hparams.validation_size <= 50000\\n if hparams.eval_test:\\n total_batches_to_load += 1\\n # Determine how many images we have loaded\\n total_dataset_size = 50000\\n train_dataset_size = total_dataset_size\\n if hparams.eval_test:\\n total_dataset_size += 10000\\n\\n if hparams.dataset == 'cifar10':\\n all_images = []\\n elif hparams.dataset == 'cifar100':\\n all_images = np.empty((1, 50000, 3072), dtype=np.uint8)\\n if hparams.eval_test:\\n test_data = np.empty((1, 10000, 3072), dtype=np.uint8)\\n if hparams.dataset == 'cifar10':\\n datafiles = [\\n 'data_batch_1', 'data_batch_2', 'data_batch_3', 'data_batch_4',\\n 'data_batch_5']\\n\\n if hparams.eval_test:\\n datafiles.append('test_batch')\\n num_classes = 10\\n elif hparams.dataset == 'cifar100':\\n datafiles = ['train']\\n if hparams.eval_test:\\n datafiles.append('test')\\n num_classes = 100\\n else:\\n raise NotImplementedError('Unimplemented dataset: ', hparams.dataset)\\n if hparams.dataset != 'test':\\n for file_num, f in enumerate(datafiles):\\n d = unpickle(os.path.join(hparams.data_path, f))\\n if hparams.dataset == 'cifar10':\\n labels = np.array(d['labels'])\\n else:\\n labels = np.array(d['fine_labels'])\\n if f == 'test':\\n test_data[0] = copy.deepcopy(d['data'])\\n if hparams.dataset == 'cifar10':\\n all_images.append(test_data)\\n else:\\n all_images = np.concatenate([all_images, test_data], axis=1)\\n else:\\n if hparams.dataset == 'cifar10':\\n all_images.append(copy.deepcopy(d['data']))\\n else:\\n all_images[file_num] = copy.deepcopy(d['data'])\\n nsamples = len(labels)\\n for idx in range(nsamples):\\n all_labels.append(labels[idx])\\n if hparams.dataset == 'cifar10':\\n all_images = np.concatenate(all_images, axis=0)\\n all_images = all_images.reshape(-1, 3072)\\n all_images = all_images.reshape(-1, 3, 32, 32) # pylint: disable=too-many-function-args\\n all_images = all_images.transpose(0, 2, 3, 1).copy()\\n all_images = all_images / 255.0\\n mean = augmentation_transforms.MEANS\\n std = augmentation_transforms.STDS\\n tf.logging.info('mean:{} std: {}'.format(mean, std))\\n all_images = (all_images - mean) / std\\n all_labels = np.eye(num_classes)[np.array(all_labels, dtype=np.int32)]\\n\\n assert len(all_images) == len(all_labels)\\n tf.logging.info(\\n 'In CIFAR10 loader, number of images: {}'.format(len(all_images)))\\n\\n extra_test_images = None\\n extra_test_labels = None\\n if hparams.extra_dataset == 'cifar10_1':\\n extra_test_ds = tfds.as_numpy(\\n tfds.load('cifar10_1', split='test', batch_size=-1))\\n extra_test_images = ((extra_test_ds['image'] / 255.0) - mean) / std\\n extra_test_labels = np.eye(num_classes)[np.array(\\n extra_test_ds['label'], dtype=np.int32)]\\n\\n # Break off test data\\n if hparams.eval_test:\\n test_images = all_images[train_dataset_size:]\\n test_labels = all_labels[train_dataset_size:]\\n else:\\n test_images = []\\n test_labels = []\\n all_images = all_images[:train_dataset_size]\\n all_labels = all_labels[:train_dataset_size]\\n return all_images, all_labels, test_images, test_labels, extra_test_images, extra_test_labels\",\n \"def train_and_evaluate(self) -> None:\\n with tf.Session() as self.sess:\\n # Initialize computation graph.\\n self.create_model()\\n\\n # Initialize variables.\\n tf.global_variables_initializer().run()\\n\\n # Initialize summary writer.\\n self.writer = tf.summary.FileWriter(logdir='conv_vis')\\n\\n for epoch_no in range(self.nb_epochs):\\n # Train model on next batch\\n batch_x, batch_y = self.mnist.train.next_batch(self.mb_size)\\n results = self.train_on_batch(batch_x, batch_y, global_step=epoch_no)\\n\\n if epoch_no > 0 and epoch_no % self.lr_decay_time == 0:\\n # Test on all samples.\\n self.test_on_all()\\n # Perform learning rate decay.\\n self.learning_rate /= 2\\n if epoch_no % 100 == 0:\\n self.logger.info(\\\"Epoch {0}: Loss: {1[0]}, accuracy: {1[1]}\\\".format(epoch_no, results))\\n batch_x_t, batch_y_t = self.mnist.test.next_batch(self.mb_size)\\n test_results = self.test_on_batch(batch_x_t, batch_y_t)\\n self.logger.info(\\\"(Test(batch): Loss: {0[0]}, accuracy: {0[1]}\\\".format(test_results))\\n self.test_on_all()\\n\\n # Save the trained model with all valuable variables.\\n saver = tf.train.Saver()\\n saver.save(sess=self.sess, save_path='./saved_model', global_step=epoch_no)\",\n \"def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\\n # Load the raw CIFAR-10 data\\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\n\\n # subsample the data\\n mask = range(num_training, num_training + num_validation)\\n X_val = X_train[mask]\\n y_val = y_train[mask]\\n mask = range(num_training)\\n X_train = X_train[mask]\\n y_train = y_train[mask]\\n mask = range(num_test)\\n X_test = X_test[mask]\\n y_test = y_test[mask]\\n mask = np.random.choice(num_training, num_dev, replace=False)\\n X_dev = X_train[mask]\\n y_dev = y_train[mask]\\n\\n # Preprocessing: reshape the image data into rows\\n X_train = np.reshape(X_train, (X_train.shape[0], -1))\\n X_val = np.reshape(X_val, (X_val.shape[0], -1))\\n X_test = np.reshape(X_test, (X_test.shape[0], -1))\\n X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\\n\\n # Normalize the data: subtract the mean image\\n mean_image = np.mean(X_train, axis=0)\\n X_train -= mean_image\\n X_val -= mean_image\\n X_test -= mean_image\\n X_dev -= mean_image\\n\\n # add bias dimension and transform into columns\\n X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\\n X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\\n X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\\n X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\\n\\n return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\",\n \"def build_resnet50(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\\n conv1_feats = nonlinear(conv1_feats, 'relu')\\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\\n\\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\\n \\n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128)\\n res3b_feats = self.basic_block2(res3a_feats, 'res3b', 'bn3b', is_train, use_batch_norm, 128)\\n res3c_feats = self.basic_block2(res3b_feats, 'res3c', 'bn3c', is_train, use_batch_norm, 128)\\n res3d_feats = self.basic_block2(res3c_feats, 'res3d', 'bn3d', is_train, use_batch_norm, 128)\\n\\n res4a_feats = self.basic_block(res3d_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\\n res4b_feats = self.basic_block2(res4a_feats, 'res4b', 'bn4b', is_train, use_batch_norm, 256)\\n res4c_feats = self.basic_block2(res4b_feats, 'res4c', 'bn4c', is_train, use_batch_norm, 256)\\n res4d_feats = self.basic_block2(res4c_feats, 'res4d', 'bn4d', is_train, use_batch_norm, 256)\\n res4e_feats = self.basic_block2(res4d_feats, 'res4e', 'bn4e', is_train, use_batch_norm, 256)\\n res4f_feats = self.basic_block2(res4e_feats, 'res4f', 'bn4f', is_train, use_batch_norm, 256)\\n\\n res5a_feats = self.basic_block(res4f_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\\n\\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\\n self.conv_feats = res5c_feats_flat\\n self.conv_feat_shape = [49, 2048]\\n self.num_ctx = 49 \\n self.dim_ctx = 2048\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def train_model_with_crloss(model, train_dataloader, test_dataloader, criterion, optimizer, scheduler, num_epochs=25,\\n inference=False):\\n model = model.float()\\n device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\\n\\n if torch.cuda.device_count() > 1:\\n print(\\\"Let's use\\\", torch.cuda.device_count(), \\\"GPUs!\\\")\\n model = nn.DataParallel(model)\\n model = model.to(device)\\n\\n if not inference:\\n model.train()\\n print('Start training CRNet...')\\n for epoch in range(num_epochs):\\n scheduler.step()\\n\\n running_loss = 0.0\\n for i, data in enumerate(train_dataloader, 0):\\n inputs, scores, classes = data['image'], data['label'], data['class']\\n\\n inputs = inputs.to(device)\\n scores = scores.to(device)\\n classes = classes.to(device)\\n\\n optimizer.zero_grad()\\n\\n inputs = inputs.float()\\n # scores = scores.float().view(cfg['batch_size'], -1)\\n # classes = classes.int().view(cfg['batch_size'], 3)\\n\\n reg_out, cls_out = model(inputs)\\n loss = criterion(cls_out, classes, reg_out, scores.float().unsqueeze(-1))\\n loss.backward()\\n optimizer.step()\\n\\n # print statistics\\n running_loss += loss.item()\\n if i % 10 == 9: # print every 10 mini-batches\\n print('[%d, %5d] loss: %.3f' %\\n (epoch + 1, i + 1, running_loss / 10))\\n running_loss = 0.0\\n\\n if epoch % 10 == 9:\\n model.eval()\\n with torch.no_grad():\\n tmp_y_pred = []\\n tmp_y_true = []\\n tmp_filenames = []\\n\\n for data in test_dataloader:\\n images, labels, classes, filename = data['image'], data['label'], data['class'], data[\\n 'filename']\\n\\n images = images.to(device)\\n labels = labels.to(device)\\n\\n reg_outputs, cls_outputs = model(images)\\n # _, predicted = torch.max(outputs.data, 1)\\n\\n tmp_y_true += labels.to(\\\"cpu\\\").detach().numpy().tolist()\\n tmp_y_pred += reg_outputs.to(\\\"cpu\\\").detach().numpy().tolist()\\n tmp_filenames += filename\\n\\n model_path_dir = './model'\\n mkdirs_if_not_exist(model_path_dir)\\n if torch.cuda.device_count() > 1:\\n torch.save(model.module.state_dict(),\\n os.path.join(model_path_dir, model.__class__.__name__ + '-epoch-%d.pth' % (epoch + 1)))\\n else:\\n torch.save(model.state_dict(),\\n os.path.join(model_path_dir, model.__class__.__name__ + '-epoch-%d.pth' % (epoch + 1)))\\n\\n rmse_lr = round(np.math.sqrt(mean_squared_error(np.array(tmp_y_true), np.array(tmp_y_pred).ravel())), 4)\\n mae_lr = round(mean_absolute_error(np.array(tmp_y_true), np.array(tmp_y_pred).ravel()), 4)\\n pc = round(np.corrcoef(np.array(tmp_y_true), np.array(tmp_y_pred).ravel())[0, 1], 4)\\n print('RMSE of {0} on test set: {1} '.format(model.__class__.__name__, rmse_lr))\\n print('MAE of {0} on test set: {1} '.format(model.__class__.__name__, mae_lr))\\n print('PC of {0} on test set: {1} '.format(model.__class__.__name__, pc))\\n\\n model.train()\\n\\n print('Finished training CRNet...\\\\n')\\n print('Saving trained model...')\\n model_path_dir = './model'\\n mkdirs_if_not_exist(model_path_dir)\\n if torch.cuda.device_count() > 1:\\n torch.save(model.module.state_dict(), os.path.join(model_path_dir, '%s.pth' % model.__class__.__name__))\\n else:\\n torch.save(model.state_dict(), os.path.join(model_path_dir, '%s.pth' % model.__class__.__name__))\\n\\n print('CRNet has been saved successfully~')\\n\\n else:\\n print('Loading pre-trained model...')\\n model.load_state_dict(torch.load(os.path.join('./model/%s.pth' % model.__class__.__name__)))\\n\\n model.eval()\\n\\n print('Start testing CRNet...')\\n predicted_labels = []\\n gt_labels = []\\n filenames = []\\n for data in test_dataloader:\\n images, scores, classes, filename = data['image'], data['label'], data['class'], data['filename']\\n images = images.to(device)\\n\\n reg_out, cls_out = model.forward(images)\\n\\n # bat_list = []\\n # for out in F.softmax(cls_out).to(\\\"cpu\\\"):\\n # tmp = 0\\n # for i in range(0, 3, 1):\\n # tmp += out[i] * (i - 1)\\n # bat_list.append(float(tmp.detach().numpy()))\\n\\n # predicted_labels += (0.6 * reg_out.to(\\\"cpu\\\").detach().numpy() + 0.4 * np.array(bat_list)).tolist()\\n\\n predicted_labels += reg_out.to(\\\"cpu\\\").detach().numpy().tolist()\\n gt_labels += scores.to(\\\"cpu\\\").detach().numpy().tolist()\\n filenames += filename\\n\\n mae_lr = round(mean_absolute_error(np.array(gt_labels), np.array(predicted_labels).ravel()), 4)\\n rmse_lr = round(np.math.sqrt(mean_squared_error(np.array(gt_labels), np.array(predicted_labels).ravel())), 4)\\n pc = round(np.corrcoef(np.array(gt_labels), np.array(predicted_labels).ravel())[0, 1], 4)\\n\\n print('===============The Mean Absolute Error of CRNet is {0}===================='.format(mae_lr))\\n print('===============The Root Mean Square Error of CRNet is {0}===================='.format(rmse_lr))\\n print('===============The Pearson Correlation of CRNet is {0}===================='.format(pc))\\n\\n col = ['filename', 'gt', 'pred']\\n df = pd.DataFrame([[filenames[i], gt_labels[i], predicted_labels[i][0]] for i in range(len(gt_labels))],\\n columns=col)\\n df.to_excel(\\\"./output.xlsx\\\", sheet_name='Output', index=False)\\n print('Output Excel has been generated~')\",\n \"def run_net(self,\\n pre_trained_chckpnt_dir ='' #for resuming training, load the model from this directory\\n ):\\n\\n _rd = _read_data(data=self.data)\\n\\n self.alpha_coeff=1\\n\\n #read path of the images for train, test, and validation\\n train_CTs, train_GTVs, train_Torso, train_penalize, train_surface,\\\\\\n validation_CTs, validation_GTVs, validation_Torso, validation_penalize, validation_surface,\\\\\\n test_CTs, test_GTVs, test_Torso, test_penalize,test_surface=_rd.read_data_path(fold=self.fold)\\n self.img_width = self.img_width\\n self.img_height = self.img_height\\n # ======================================\\n #validation instances\\n bunch_of_images_no=20\\n _image_class_vl = image_class(validation_CTs, validation_GTVs, validation_Torso,validation_penalize,validation_surface\\n , bunch_of_images_no=bunch_of_images_no, is_training=0,\\n patch_window=self.patch_window)\\n _patch_extractor_thread_vl = _patch_extractor_thread(_image_class=_image_class_vl,\\n sample_no=self.sample_no, patch_window=self.patch_window,\\n GTV_patchs_size=self.GTV_patchs_size,\\n tumor_percent=self.tumor_percent,\\n img_no=bunch_of_images_no,\\n mutex=settings.mutex,is_training=0,vl_sample_no=self.validation_samples\\n )\\n _fill_thread_vl = fill_thread(validation_CTs,\\n validation_GTVs,\\n validation_Torso,\\n validation_penalize,\\n validation_surface,\\n _image_class_vl,\\n sample_no=self.sample_no,\\n total_sample_no=self.validation_samples,\\n patch_window=self.patch_window,\\n GTV_patchs_size=self.GTV_patchs_size,\\n img_width=self.img_width, img_height=self.img_height,\\n mutex=settings.mutex,\\n tumor_percent=self.tumor_percent,\\n is_training=0,\\n patch_extractor=_patch_extractor_thread_vl,\\n fold=self.fold)\\n\\n\\n _fill_thread_vl.start()\\n _patch_extractor_thread_vl.start()\\n _read_thread_vl = read_thread(_fill_thread_vl, mutex=settings.mutex,\\n validation_sample_no=self.validation_samples, is_training=0)\\n _read_thread_vl.start()\\n # ======================================\\n #training instances\\n bunch_of_images_no = 24\\n _image_class = image_class(train_CTs, train_GTVs, train_Torso,train_penalize,train_surface\\n , bunch_of_images_no=bunch_of_images_no,is_training=1,patch_window=self.patch_window\\n )\\n patch_extractor_thread = _patch_extractor_thread(_image_class=_image_class,\\n sample_no=240, patch_window=self.patch_window,\\n GTV_patchs_size=self.GTV_patchs_size,\\n tumor_percent=self.tumor_percent,\\n img_no=bunch_of_images_no,\\n mutex=settings.mutex,is_training=1)\\n _fill_thread = fill_thread(train_CTs, train_GTVs, train_Torso,train_penalize,train_surface,\\n _image_class,\\n sample_no=self.sample_no,total_sample_no=self.sample_no,\\n patch_window=self.patch_window,\\n GTV_patchs_size=self.GTV_patchs_size,\\n img_width=self.img_width,\\n img_height=self.img_height,mutex=settings.mutex,\\n tumor_percent=self.tumor_percent,\\n is_training=1,\\n patch_extractor=patch_extractor_thread,\\n fold=self.fold)\\n\\n _fill_thread.start()\\n patch_extractor_thread.start()\\n\\n _read_thread = read_thread(_fill_thread,mutex=settings.mutex,is_training=1)\\n _read_thread.start()\\n # ======================================\\n\\n image = tf.placeholder(tf.float32, shape=[None, None, None, None, 1])\\n label = tf.placeholder(tf.float32, shape=[None, None, None, None, 2])\\n penalize = tf.placeholder(tf.float32, shape=[None, None, None, None,1])\\n surf_map = tf.placeholder(tf.float32, shape=[None, None, None, None,1])\\n loss_coef = tf.placeholder(tf.float32, shape=[None, 2]) # shape: batchno * 2 values for each class\\n alpha = tf.placeholder(tf.float32, name='alpha') # background coeff\\n beta = tf.placeholder(tf.float32, name='beta') # tumor coeff\\n\\n ave_vali_acc=tf.placeholder(tf.float32)\\n ave_loss_vali=tf.placeholder(tf.float32)\\n ave_dsc_vali=tf.placeholder(tf.float32)\\n\\n dropout=tf.placeholder(tf.float32,name='dropout')\\n is_training = tf.placeholder(tf.bool, name='is_training')\\n is_training_bn = tf.placeholder(tf.bool, name='is_training_bn')\\n dense_net_dim = tf.placeholder(tf.int32, name='dense_net_dim')\\n\\n _dn = _densenet_unet(self.densnet_unet_config,self.compression_coefficient,self.growth_rate) #create object\\n y=_dn.dens_net(image=image,is_training=is_training,dropout_rate1=0,dropout_rate2=0,dim=dense_net_dim,is_training_bn=is_training_bn)\\n # y = _dn.vgg(image)\\n\\n y_dirX = ((y[:, int(self.GTV_patchs_size / 2), :, :, 0, np.newaxis]))\\n label_dirX = (label[:, int(self.GTV_patchs_size / 2), :, :, 0, np.newaxis])\\n penalize_dirX = (penalize[:,16,:,:,0,np.newaxis])\\n surf_map_dirX = (surf_map[:,16,:,:,0,np.newaxis])\\n image_dirX = ((image[:, int(self.patch_window / 2), :, :, 0, np.newaxis]))\\n\\n show_img=tf.nn.softmax(y)[:, int(self.GTV_patchs_size / 2) , :, :, 0, np.newaxis]\\n tf.summary.image('outprunut',show_img , 3)\\n tf.summary.image('output without softmax',y_dirX ,3)\\n tf.summary.image('groundtruth', label_dirX,3)\\n tf.summary.image('penalize', penalize_dirX,3)\\n tf.summary.image('surf_map', surf_map_dirX,3)\\n tf.summary.image('image',image_dirX ,3)\\n\\n print('*****************************************')\\n print('*****************************************')\\n print('*****************************************')\\n sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))\\n devices = sess.list_devices()\\n print(devices)\\n\\n print(device_lib.list_local_devices())\\n print('*****************************************')\\n print('*****************************************')\\n print('*****************************************')\\n\\n train_writer = tf.summary.FileWriter(self.LOGDIR + '/train' ,graph=tf.get_default_graph())\\n validation_writer = tf.summary.FileWriter(self.LOGDIR + '/validation' , graph=sess.graph)\\n\\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n saver=tf.train.Saver(tf.global_variables(), max_to_keep=1000)\\n\\n\\n\\n #define the loss function\\n with tf.name_scope('cost'):\\n penalize_weight=0\\n [ penalized_loss,\\n soft_dice_coef,logt,lbl]=self.loss_instance.dice_plus_distance_penalize(logits=y, labels=label,penalize=penalize)\\n surface_loss= self.loss_instance.surface_loss(logits=y, labels=label, surf_map=surf_map)\\n cost = tf.reduce_mean((1.0 - soft_dice_coef[1])+penalize_weight*penalized_loss+surface_loss, name=\\\"cost\\\")\\n\\n #Setup the Tensorboard plots\\n tf.summary.scalar(\\\"cost\\\", cost)\\n f1_measure = self.loss_instance.f1_measure(logits=y, labels=label)\\n tf.summary.scalar(\\\"dice_bakground\\\", f1_measure[0])\\n tf.summary.scalar(\\\"dice_tumor\\\", f1_measure[1])\\n\\n pwc = self.loss_instance.PWC(y, label)\\n tf.summary.scalar(\\\"pwc_bakground\\\", pwc[0])\\n tf.summary.scalar(\\\"pwc_tumor\\\", pwc[1])\\n\\n recall = self.loss_instance.Recall(y, label)\\n tf.summary.scalar(\\\"recall_bakground\\\", recall[0])\\n tf.summary.scalar(\\\"recall_tumor\\\", recall[1])\\n\\n precision = self.loss_instance.Precision(y, label)\\n tf.summary.scalar(\\\"precision_bakground\\\", precision[0])\\n tf.summary.scalar(\\\"precision_tumor\\\", precision[1])\\n\\n fpr = self.loss_instance.FPR(y, label)\\n tf.summary.scalar(\\\"FPR_bakground\\\", fpr[0])\\n tf.summary.scalar(\\\"FPR_tumor\\\", fpr[1])\\n\\n fnr = self.loss_instance.FNR(y, label)\\n tf.summary.scalar(\\\"FNR_bakground\\\", fnr[0])\\n tf.summary.scalar(\\\"FNR_tumor\\\", fnr[1])\\n\\n extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n with tf.control_dependencies(extra_update_ops):\\n optimizer_tmp = tf.train.AdamOptimizer(self.learning_rate,epsilon=0.001)\\n optimizer = optimizer_tmp.minimize(cost)\\n\\n with tf.name_scope('validation'):\\n average_validation_accuracy=ave_vali_acc\\n average_validation_loss=ave_loss_vali\\n average_dsc_loss=ave_dsc_vali\\n tf.summary.scalar(\\\"average_validation_accuracy\\\",average_validation_accuracy)\\n tf.summary.scalar(\\\"average_validation_loss\\\",average_validation_loss)\\n tf.summary.scalar(\\\"average_dsc_loss\\\",average_dsc_loss)\\n\\n with tf.name_scope('accuracy'):\\n accuracy=self.loss_instance.accuracy_fn(y, label)\\n\\n tf.summary.scalar(\\\"accuracy\\\", accuracy)\\n\\n sess.run(tf.global_variables_initializer())\\n logging.debug('total number of variables %s' % (\\n np.sum([np.prod(v.get_shape().as_list()) for v in tf.trainable_variables()])))\\n summ=tf.summary.merge_all()\\n\\n point = 0 # starting point, starts from a value > 0 if training is resumed\\n itr1 = 0 # number of iterations\\n if len(pre_trained_chckpnt_dir):\\n ckpt = tf.train.get_checkpoint_state(pre_trained_chckpnt_dir)\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n point=int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\\n itr1=point\\n\\n\\n # patch_radius = 49\\n '''loop for epochs'''\\n\\n for epoch in range(self.total_epochs):\\n while self.no_sample_per_each_itr*int(point/self.no_sample_per_each_itr)<self.sample_no:\\n print('0')\\n print(\\\"epoch #: %d\\\" %(epoch))\\n startTime = time.time()\\n step = 0\\n self.beta_coeff=1+1 * np.exp(-point/2000)\\n # =============start validation================\\n if itr1 % self.display_validation_step ==0:\\n '''Validation: '''\\n loss_validation = 0\\n acc_validation = 0\\n validation_step = 0\\n dsc_validation=0\\n while (validation_step * self.batch_no_validation <settings.validation_totalimg_patch):\\n [validation_CT_image, validation_GTV_image,validation_Penalize_patch,validation_Surface_patch] = _image_class_vl.return_patches_validation( validation_step * self.batch_no_validation, (validation_step + 1) *self.batch_no_validation)\\n if (len(validation_CT_image)<self.batch_no_validation) | (len(validation_GTV_image)<self.batch_no_validation) | (len(validation_Penalize_patch)<self.batch_no_validation) | (len(validation_Surface_patch)<self.batch_no_validation) :\\n _read_thread_vl.resume()\\n time.sleep(0.5)\\n continue\\n\\n validation_CT_image_patchs = validation_CT_image\\n validation_GTV_label = validation_GTV_image\\n tic=time.time()\\n\\n [acc_vali, loss_vali,dsc_vali,surface_loss1] = sess.run([accuracy, cost,f1_measure,surface_loss],\\n feed_dict={image: validation_CT_image_patchs,\\n label: validation_GTV_label,\\n penalize: validation_Penalize_patch,\\n dropout: 1,\\n is_training: False,\\n ave_vali_acc: -1,\\n ave_loss_vali: -1,\\n ave_dsc_vali:-1,\\n dense_net_dim: self.patch_window,\\n is_training_bn:False,\\n alpha:1,\\n beta:1,\\n surf_map:validation_Surface_patch,\\n })\\n elapsed=time.time()-tic\\n\\n acc_validation += acc_vali\\n loss_validation += loss_vali\\n dsc_validation+=dsc_vali[1]\\n validation_step += 1\\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\\n print('nan problem')\\n process = psutil.Process(os.getpid())\\n\\n print(\\n '%d - > %d: elapsed_time:%d acc_validation: %f, loss_validation: %f, memory_percent: %4s' % (\\n validation_step,validation_step * self.batch_no_validation\\n , elapsed, acc_vali, loss_vali, str(process.memory_percent()),\\n ))\\n\\n settings.queue_isready_vl = False\\n acc_validation = acc_validation / (validation_step)\\n loss_validation = loss_validation / (validation_step)\\n dsc_validation = dsc_validation / (validation_step)\\n if np.isnan(dsc_validation) or np.isnan(loss_validation) or np.isnan(acc_validation):\\n print('nan problem')\\n _fill_thread_vl.kill_thread()\\n print('******Validation, step: %d , accuracy: %.4f, loss: %f*******' % (\\n itr1, acc_validation, loss_validation))\\n\\n [sum_validation] = sess.run([summ],\\n feed_dict={image: validation_CT_image_patchs,\\n label: validation_GTV_label,\\n penalize: validation_Penalize_patch,\\n dropout: 1,\\n is_training: False,\\n ave_vali_acc: acc_validation,\\n ave_loss_vali: loss_validation,\\n ave_dsc_vali:dsc_validation,\\n dense_net_dim: self.patch_window,\\n is_training_bn: False,\\n alpha: 1,\\n beta: 1,\\n surf_map: validation_Surface_patch,\\n\\n })\\n validation_writer.add_summary(sum_validation, point)\\n print('end of validation---------%d' % (point))\\n\\n #loop for training batches\\n while(step*self.batch_no<self.no_sample_per_each_itr):\\n [train_CT_image_patchs, train_GTV_label, train_Penalize_patch,loss_coef_weights,train_Surface_patch] = _image_class.return_patches( self.batch_no)\\n\\n if (len(train_CT_image_patchs)<self.batch_no)|(len(train_GTV_label)<self.batch_no)\\\\\\n |(len(train_Penalize_patch)<self.batch_no)|(len(train_Surface_patch)<self.batch_no):\\n time.sleep(0.5)\\n _read_thread.resume()\\n continue\\n\\n tic=time.time()\\n [acc_train1, loss_train1, optimizing,out,dsc_train11] = sess.run([accuracy, cost, optimizer,y,f1_measure],\\n feed_dict={image: train_CT_image_patchs,\\n label: train_GTV_label,\\n penalize: train_Penalize_patch,\\n # loss_coef: loss_coef_weights,\\n dropout: self.dropout_keep,\\n is_training: True,\\n ave_vali_acc: -1,\\n ave_loss_vali: -1,\\n ave_dsc_vali: -1,\\n dense_net_dim: self.patch_window,\\n is_training_bn: True,\\n alpha: self.alpha_coeff,\\n beta: self.beta_coeff,\\n surf_map: train_Surface_patch,\\n\\n })\\n elapsed=time.time()-tic\\n dsc_train1=dsc_train11[1]\\n\\n self.x_hist=self.x_hist+1\\n # np.hstack((self.x_hist, [np.ceil(\\n\\n [sum_train] = sess.run([summ],\\n feed_dict={image: train_CT_image_patchs,\\n label: train_GTV_label,\\n penalize: train_Penalize_patch,\\n dropout: self.dropout_keep, is_training: True,\\n ave_vali_acc: acc_train1,\\n ave_loss_vali: loss_train1,\\n ave_dsc_vali: dsc_train1,\\n dense_net_dim: self.patch_window,\\n is_training_bn: True,\\n alpha: self.alpha_coeff,\\n beta: self.beta_coeff,\\n surf_map: train_Surface_patch,\\n\\n })\\n train_writer.add_summary(sum_train,point)\\n step = step + 1\\n\\n process = psutil.Process(os.getpid())\\n\\n print(\\n 'point: %d, elapsed_time:%d step*self.batch_no:%f , LR: %.15f, acc_train1:%f, loss_train1:%f,memory_percent: %4s' % (\\n int((point)),elapsed,\\n step * self.batch_no, self.learning_rate, acc_train1, loss_train1,\\n str(process.memory_percent())))\\n\\n\\n point=int((point))\\n if point%100==0:\\n '''saveing model inter epoch'''\\n chckpnt_path = os.path.join(self.chckpnt_dir,\\n ('densenet_unet_inter_epoch%d_point%d.ckpt' % (epoch, point)))\\n saver.save(sess, chckpnt_path, global_step=point)\\n itr1 = itr1 + 1\\n point=point+1\\n endTime = time.time()\\n\\n #==============\\n '''saveing model after each epoch'''\\n chckpnt_path = os.path.join(self.chckpnt_dir, 'densenet_unet.ckpt')\\n saver.save(sess, chckpnt_path, global_step=epoch)\\n print(\\\"End of epoch----> %d, elapsed time: %d\\\" % (epoch, endTime - startTime))\",\n \"def run_cifar_gan(sess, G_train_step, G_loss, D_train_step, D_loss, G_extra_step, D_extra_step, show_every=250, print_every=50, batch_size=128, num_epoch=10):\\n # compute the number of iterations we need\\n max_iter = int(X.shape[0]*num_epoch/batch_size)\\n for it in range(max_iter):\\n # every show often, show a sample result\\n if it % show_every == 0:\\n samples = sess.run(G_sample)\\n fig = show_images_cifar(samples[:16],it/show_every)\\n plt.show()\\n # run a batch of data through the network\\n minibatch = X[np.random.randint(0,X.shape[0],batch_size)]\\n _, D_loss_curr = sess.run([D_train_step, D_loss], feed_dict={x: minibatch})\\n _, G_loss_curr = sess.run([G_train_step, G_loss])\\n\\n # print loss every so often.\\n # We want to make sure D_loss doesn't go to 0\\n #if it % print_every == 0:\\n print('Iter: {}, D: {:.4}, G:{:.4}'.format(it,D_loss_curr,G_loss_curr))\\n print('Final images')\\n samples = sess.run(G_sample)\\n\\n fig = show_images_cifar(samples[:16],it/show_every)\\n plt.show()\",\n \"def build_resnet101(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\\n conv1_feats = nonlinear(conv1_feats, 'relu')\\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\\n\\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\\n \\n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \\n temp = res3a_feats\\n for i in range(1, 4):\\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\\n res3b3_feats = temp\\n \\n res4a_feats = self.basic_block(res3b3_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\\n temp = res4a_feats\\n for i in range(1, 23):\\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\\n res4b22_feats = temp\\n\\n res5a_feats = self.basic_block(res4b22_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\\n\\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\\n self.conv_feats = res5c_feats_flat\\n self.conv_feat_shape = [49, 2048]\\n self.num_ctx = 49 \\n self.dim_ctx = 2048\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def setup(args):\\n cfg = get_cfg()\\n\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\\\"))\\n cfg.merge_from_list(args.opts)\\n\\n # configs for training\\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\\n cfg.DATASETS.TRAIN = (\\\"vidor_small_train\\\",)\\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\\n cfg.DATASETS.TRAIN = (\\\"vidor_small_10imgs_train\\\",)\\n else:\\n cfg.DATASETS.TRAIN = (\\\"vidor_large_train\\\",)\\n # cfg.DATALOADER.NUM_WORKERS = 2\\n if not args.eval_only:\\n cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(\\\"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\\\") # Let training initialize from model zoo\\n factor = 4\\n cfg.SOLVER.IMS_PER_BATCH = 16 * factor\\n cfg.SOLVER.BASE_LR = 0.0001 * factor # finetune using 10x smaller base_lr\\n cfg.SOLVER.MAX_ITER = 270000 // factor \\n cfg.SOLVER.STEPS = [210000 // factor, 250000 // factor]\\n # cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 128 # default: 512\\n cfg.MODEL.ROI_HEADS.NUM_CLASSES = 78\\n\\n # configs for testing\\n # cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, \\\"model_final.pth\\\")\\n if args.small_vidor: # cfg.DATASETS.VIDOR.SIZE == 'small':\\n cfg.DATASETS.TEST = (\\\"vidor_small_val\\\",)\\n elif args.small_vidor_10imgs: # cfg.DATASETS.VIDOR.SIZE == 'small-10imgs':\\n cfg.DATASETS.TEST = (\\\"vidor_small_10imgs_val\\\",)\\n else:\\n cfg.DATASETS.TEST = (\\\"vidor_large_val\\\",)\\n # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5\\n\\n # cfg.OUTPUT_DIR = './output/train_vidor_with_pseudo_labels'\\n \\n \\n if not args.eval_only:\\n os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)\\n cfg.freeze()\\n default_setup(cfg, args)\\n return cfg\",\n \"def plscorr_eval(train_fmri_ts, train_feat_ts, val_fmri_ts, val_feat_ts,\\n out_dir, mask_file):\\n train_feat_ts = train_feat_ts.reshape(-1, train_feat_ts.shape[3]).T\\n val_feat_ts = val_feat_ts.reshape(-1, val_feat_ts.shape[3]).T\\n train_fmri_ts = train_fmri_ts.T\\n val_fmri_ts = val_fmri_ts.T\\n\\n # Iteration loop for different component number\\n #for n in range(5, 19):\\n # print '--- Components number %s ---' %(n)\\n # plsca = PLSCanonical(n_components=n)\\n # plsca.fit(train_feat_ts, train_fmri_ts)\\n # pred_feat_c, pred_fmri_c = plsca.transform(val_feat_ts, val_fmri_ts)\\n # pred_fmri_ts = plsca.predict(val_feat_ts) \\n # # calculate correlation coefficient between truth and prediction\\n # r = corr2_coef(val_fmri_ts.T, pred_fmri_ts.T, mode='pair')\\n # # get top 20% corrcoef for model evaluation\\n # vsample = int(np.rint(0.2*len(r)))\\n # print 'Sample size for evaluation : %s' % (vsample)\\n # r.sort()\\n # meanr = np.mean(r[-1*vsample:])\\n # print 'Mean prediction corrcoef : %s' %(meanr)\\n \\n # model generation based on optimized CC number\\n cc_num = 10\\n plsca = PLSCanonical(n_components=cc_num)\\n plsca.fit(train_feat_ts, train_fmri_ts)\\n from sklearn.externals import joblib\\n joblib.dump(plsca, os.path.join(out_dir, 'plsca_model.pkl'))\\n plsca = joblib.load(os.path.join(out_dir, 'plsca_model.pkl'))\\n\\n # calculate correlation coefficient between truth and prediction\\n pred_fmri_ts = plsca.predict(val_feat_ts)\\n fmri_pred_r = corr2_coef(val_fmri_ts.T, pred_fmri_ts.T, mode='pair')\\n mask = vutil.data_swap(mask_file)\\n vxl_idx = np.nonzero(mask.flatten()==1)[0]\\n tmp = np.zeros_like(mask.flatten(), dtype=np.float64)\\n tmp[vxl_idx] = fmri_pred_r\\n tmp = tmp.reshape(mask.shape)\\n vutil.save2nifti(tmp, os.path.join(out_dir, 'pred_fmri_r.nii.gz'))\\n pred_feat_ts = pls_y_pred_x(plsca, val_fmri_ts)\\n pred_feat_ts = pred_feat_ts.T.reshape(96, 14, 14, 540)\\n np.save(os.path.join(out_dir, 'pred_feat.npy'), pred_feat_ts)\\n\\n # get PLS-CCA weights\\n feat_cc, fmri_cc = plsca.transform(train_feat_ts, train_fmri_ts)\\n np.save(os.path.join(out_dir, 'feat_cc.npy'), feat_cc)\\n np.save(os.path.join(out_dir, 'fmri_cc.npy'), fmri_cc)\\n feat_weight = plsca.x_weights_.reshape(96, 14, 14, cc_num)\\n #feat_weight = plsca.x_weights_.reshape(96, 11, 11, cc_num)\\n fmri_weight = plsca.y_weights_\\n np.save(os.path.join(out_dir, 'feat_weights.npy'), feat_weight)\\n np.save(os.path.join(out_dir, 'fmri_weights.npy'), fmri_weight)\\n fmri_orig_ccs = get_pls_components(plsca.y_scores_, plsca.y_loadings_)\\n np.save(os.path.join(out_dir, 'fmri_orig_ccs.npy'), fmri_orig_ccs)\",\n \"def train_and_eval(config, babas_data):\\n\\n if config.resume_from_checkpoint is not None:\\n try:\\n if config.augment_background == 'background':\\n bg = config.augment_background\\n else:\\n bg = None\\n rfc = config.resume_from_checkpoint\\n ic = config.include_validation\\n print 'Loading saved config: %s' % config.saved_config\\n config = np.load(config.saved_config).item()\\n config.resume_from_checkpoint = rfc\\n config.include_validation = ic\\n if not hasattr(config, 'augment_background'):\\n config.augment_background = 'constant'\\n if not hasattr(config, 'background_folder'):\\n config.background_folder = 'backgrounds'\\n if bg is not None:\\n print 'Overriding saved config to add kinect backgrounds to training.'\\n config.augment_background = bg\\n results_dir = rfc\\n except:\\n print 'Relying on default config file.'\\n\\n if babas_data: # Shitty naive training method\\n config.tfrecord_dir = '/media/data_cifs/monkey_tracking/data_for_babas/tfrecords_from_babas'\\n config.babas_tfrecord_dir = config.tfrecord_dir\\n config.steps_before_validation = 20\\n config.epochs = 2000\\n config.convert_labels_to_pixel_space = False\\n config.augment_background = 'constant'\\n\\n # Import your model\\n print 'Model directory: %s' % config.model_output\\n print 'Running model: %s' % config.model_type\\n model_file = import_cnn(config.model_type)\\n\\n # Prepare model training\\n dt_stamp = re.split(\\n '\\\\.', str(datetime.now()))[0].\\\\\\n replace(' ', '_').replace(':', '_').replace('-', '_')\\n dt_dataset = '%s_%s' % (config.model_type, dt_stamp)\\n if config.selected_joints is not None:\\n dt_dataset = '_%s' % (config.selected_joints) + dt_dataset\\n config.train_checkpoint = os.path.join(\\n config.model_output, dt_dataset) # timestamp this run\\n config.summary_dir = os.path.join(\\n config.train_summaries, dt_dataset)\\n results_dir = os.path.join(config.npy_dir, dt_dataset)\\n print 'Saving Dmurphy\\\\'s online updates to: %s' % results_dir\\n dir_list = [config.train_checkpoint, config.summary_dir, results_dir]\\n [tf_fun.make_dir(d) for d in dir_list]\\n\\n # Prepare model inputs\\n train_data = os.path.join(config.tfrecord_dir, config.train_tfrecords)\\n if config.babas_tfrecord_dir is not None:\\n train_babas_tfrecord_dir = os.path.join(\\n config.babas_tfrecord_dir,\\n config.train_tfrecords)\\n if config.include_validation or config.include_validation is None:\\n val_babas_tfrecord_dir = os.path.join(\\n config.babas_tfrecord_dir,\\n config.val_tfrecords)\\n else:\\n train_babas_tfrecord_dir = None\\n val_babas_tfrecord_dir = None\\n\\n if isinstance(config.include_validation, basestring):\\n validation_data = config.include_validation\\n elif config.include_validation == True:\\n validation_data = os.path.join(\\n config.tfrecord_dir,\\n config.val_tfrecords)\\n else:\\n validation_data = None\\n\\n print 'Using training set: %s' % train_data\\n print 'Using validation set: %s' % validation_data\\n\\n # Prepare data on CPU\\n with tf.device('/cpu:0'):\\n train_data_dict = inputs(\\n tfrecord_file=train_data,\\n batch_size=config.train_batch,\\n im_size=config.resize,\\n target_size=config.image_target_size,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n label_shape=config.num_classes,\\n num_epochs=config.epochs,\\n image_target_size=config.image_target_size,\\n image_input_size=config.image_input_size,\\n maya_conversion=config.maya_conversion,\\n max_value=config.max_depth,\\n normalize_labels=config.normalize_labels,\\n aux_losses=config.aux_losses,\\n selected_joints=config.selected_joints,\\n joint_names=config.joint_order,\\n num_dims=config.num_dims,\\n keep_dims=config.keep_dims,\\n mask_occluded_joints=config.mask_occluded_joints,\\n background_multiplier=config.background_multiplier,\\n augment_background=config.augment_background,\\n background_folder=config.background_folder,\\n randomize_background=config.randomize_background,\\n maya_joint_labels=config.labels,\\n babas_tfrecord_dir=train_babas_tfrecord_dir,\\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\\n image_target_size_is_flipped=config.image_target_size_is_flipped)\\n train_data_dict['deconv_label_size'] = len(config.labels)\\n\\n val_data_dict = inputs(\\n tfrecord_file=validation_data,\\n batch_size=config.validation_batch,\\n im_size=config.resize,\\n target_size=config.image_target_size,\\n model_input_shape=config.resize,\\n train=config.data_augmentations,\\n label_shape=config.num_classes,\\n num_epochs=config.epochs,\\n image_target_size=config.image_target_size,\\n image_input_size=config.image_input_size,\\n maya_conversion=config.maya_conversion,\\n max_value=config.max_depth,\\n normalize_labels=config.normalize_labels,\\n aux_losses=config.aux_losses,\\n selected_joints=config.selected_joints,\\n joint_names=config.joint_order,\\n num_dims=config.num_dims,\\n keep_dims=config.keep_dims,\\n mask_occluded_joints=config.mask_occluded_joints,\\n background_multiplier=config.background_multiplier,\\n augment_background='none',\\n background_folder=config.background_folder,\\n randomize_background=None,\\n maya_joint_labels=config.labels,\\n babas_tfrecord_dir=val_babas_tfrecord_dir,\\n convert_labels_to_pixel_space=config.convert_labels_to_pixel_space,\\n image_target_size_is_flipped=config.image_target_size_is_flipped)\\n val_data_dict['deconv_label_size'] = len(config.labels)\\n\\n # Check output_shape\\n if config.selected_joints is not None:\\n print 'Targeting joint: %s' % config.selected_joints\\n joint_shape = len(config.selected_joints) * config.keep_dims\\n if (config.num_classes // config.keep_dims) > (joint_shape):\\n print 'New target size: %s' % joint_shape\\n config.num_classes = joint_shape\\n\\n with tf.device('/gpu:0'):\\n with tf.variable_scope('cnn') as scope:\\n print 'Creating training graph:'\\n model = model_file.model_struct(\\n weight_npy_path=config.weight_npy_path)\\n train_mode = tf.get_variable(name='training', initializer=True)\\n model.build(\\n rgb=train_data_dict['image'],\\n target_variables=train_data_dict,\\n train_mode=train_mode,\\n batchnorm=config.batch_norm)\\n train_mu, train_var = tf.nn.moments(train_data_dict['image'], axes=[1, 2, 3])\\n tf.summary.histogram(\\\"train image mean\\\", train_mu)\\n tf.summary.histogram(\\\"train image std\\\", tf.sqrt(train_var))\\n if 'deconv_image' in config.aux_losses:\\n tf.summary.image('Deconv train', model.deconv)\\n if 'deconv_label' in config.aux_losses:\\n tf.summary.image(\\n 'Deconv label train',\\n tf.expand_dims(\\n tf.cast(\\n tf.argmax(model.deconv, axis=3), tf.float32), 3))\\n\\n # Setup validation op\\n if validation_data is not False:\\n scope.reuse_variables()\\n print 'Creating validation graph:'\\n val_model = model_file.model_struct()\\n val_model.build(\\n rgb=val_data_dict['image'],\\n target_variables=val_data_dict)\\n\\n # Calculate validation accuracy\\n val_mu, val_var = tf.nn.moments(val_data_dict['image'], axes=[1, 2, 3])\\n tf.summary.histogram(\\\"validation image mean\\\", val_mu)\\n tf.summary.histogram(\\\"validation image std\\\", tf.sqrt(val_var))\\n if 'label' in val_data_dict.keys():\\n # val_score = tf.reduce_mean(\\n # tf_fun.l2_loss(\\n # val_model.output, val_data_dict['label']))\\n if config.keep_dims == 3:\\n z_mask = tf.expand_dims(tf.tile([1, 1, 0], [int(val_data_dict['label'].get_shape()[-1]) // 3]), axis=0)\\n z_mask = tf.cast(z_mask, tf.float32)\\n val_model.output = val_model.output * z_mask\\n val_data_dict['label'] = val_data_dict['label'] * z_mask \\n val_score = tf.reduce_mean(tf.nn.l2_loss(val_model.output - val_data_dict['label']))\\n tf.summary.scalar(\\\"validation mse\\\", val_score)\\n if 'fc' in config.aux_losses:\\n tf.summary.image('FC val activations', val_model.final_fc)\\n if 'deconv_image' in config.aux_losses:\\n tf.summary.image('Deconv val', val_model.deconv)\\n if 'deconv_label' in config.aux_losses:\\n tf.summary.image(\\n 'Deconv label train',\\n tf.expand_dims(\\n tf.cast(\\n tf.argmax(val_model.deconv, axis=3),\\n tf.float32), 3))\\n tf.summary.image(\\n 'validation images',\\n tf.cast(val_data_dict['image'], tf.float32))\\n\\n # Prepare the loss functions:::\\n loss_list, loss_label = [], []\\n if 'label' in train_data_dict.keys():\\n # 1. Joint localization loss\\n if config.calculate_per_joint_loss == 'thomas':\\n label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n elif config.calculate_per_joint_loss == 'skeleton':\\n label_loss = tf_fun.skeleton_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n elif config.calculate_per_joint_loss == 'skeleton and joint':\\n label_loss = tf_fun.skeleton_loss(\\n model=model,\\n train_data_dict=train_data_dict,\\n config=config,\\n y_key='label',\\n yhat_key='output')\\n loss_list += [label_loss]\\n loss_label += ['skeleton loss']\\n delta = model['output'] - train_data_dict['label']\\n proc_weights = np.asarray(\\n config.dim_weight)[None,:].repeat(\\n len(config.joint_names), axis=0).reshape(1, -1)\\n delta *= proc_weights\\n # label_loss, use_joints, joint_variance = tf_fun.thomas_l1_loss(\\n # model=model,\\n # train_data_dict=train_data_dict,\\n # config=config,\\n # y_key='label',\\n # yhat_key='output')\\n # loss_list += [label_loss]\\n loss_list += [tf.nn.l2_loss(\\n model['output'] - train_data_dict['label'])]\\n else:\\n loss_list += [tf.nn.l2_loss(\\n model['output'] - train_data_dict['label'])]\\n loss_label += ['combined head']\\n for al in loss_helper.potential_aux_losses():\\n loss_list, loss_label = loss_helper.get_aux_losses(\\n loss_list=loss_list,\\n loss_label=loss_label,\\n train_data_dict=train_data_dict,\\n model=model,\\n aux_loss_dict=al,\\n domain_adaptation=train_babas_tfrecord_dir)\\n loss = tf.add_n(loss_list)\\n\\n # Add wd if necessary\\n if config.wd_penalty is not None:\\n _, l2_wd_layers = tf_fun.fine_tune_prepare_layers(\\n tf.trainable_variables(), config.wd_layers)\\n l2_wd_layers = [\\n x for x in l2_wd_layers if 'biases' not in x.name]\\n if config.wd_type == 'l1':\\n loss += (config.wd_penalty * tf.add_n(\\n [tf.reduce_sum(tf.abs(x)) for x in l2_wd_layers]))\\n elif config.wd_type == 'l2':\\n loss += (config.wd_penalty * tf.add_n(\\n [tf.nn.l2_loss(x) for x in l2_wd_layers]))\\n\\n optimizer = loss_helper.return_optimizer(config.optimizer)\\n optimizer = optimizer(config.lr)\\n\\n if hasattr(config, 'fine_tune_layers') and config.fine_tune_layers is not None:\\n print 'Finetuning learning for: %s' % config.fine_tune_layers\\n train_op, grads = tf_fun.finetune_learning(\\n loss,\\n trainables=tf.trainable_variables(),\\n fine_tune_layers=config.fine_tune_layers,\\n config=config\\n )\\n else:\\n # Op to calculate every variable gradient\\n grads = optimizer.compute_gradients(\\n loss, tf.trainable_variables())\\n # Op to update all variables according to their gradient\\n train_op = optimizer.apply_gradients(\\n grads_and_vars=grads)\\n\\n # Summarize all gradients and weights\\n [tf.summary.histogram(\\n var.name + '/gradient', grad)\\n for grad, var in grads if grad is not None]\\n # train_op = optimizer.minimize(loss)\\n\\n # Summarize losses\\n [tf.summary.scalar(lab, il) for lab, il in zip(\\n loss_label, loss_list)]\\n\\n # Summarize images and l1 weights\\n tf.summary.image(\\n 'train images',\\n tf.cast(train_data_dict['image'], tf.float32))\\n tf_fun.add_filter_summary(\\n trainables=tf.trainable_variables(),\\n target_layer='conv1_1_filters')\\n\\n # Set up summaries and saver\\n saver = tf.train.Saver(\\n tf.global_variables(), max_to_keep=config.keep_checkpoints)\\n summary_op = tf.summary.merge_all()\\n tf.add_to_collection('output', model.output)\\n\\n # Initialize the graph\\n sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\\n\\n # Need to initialize both of these if supplying num_epochs to inputs\\n sess.run(tf.group(tf.global_variables_initializer(),\\n tf.local_variables_initializer()))\\n summary_writer = tf.summary.FileWriter(config.summary_dir, sess.graph)\\n\\n # Set up exemplar threading\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n\\n # Create list of variables to run through training model\\n train_session_vars = {\\n 'train_op': train_op,\\n 'loss_value': loss,\\n 'im': train_data_dict['image'],\\n 'yhat': model.output,\\n 'ytrue': train_data_dict['label']\\n }\\n if hasattr(model, 'deconv'):\\n train_session_vars['deconv'] = model.deconv\\n if hasattr(model, 'final_fc'):\\n train_session_vars['fc'] = model.final_fc\\n\\n # Create list of variables to run through validation model\\n val_session_vars = {\\n 'val_acc': val_score,\\n 'val_pred': val_model.output,\\n 'val_ims': val_data_dict['image'],\\n 'val_true': val_data_dict['label'],\\n }\\n\\n # Create list of variables to save to numpys\\n save_training_vars = [\\n 'im',\\n 'yhat',\\n 'ytrue',\\n 'yhat'\\n ]\\n\\n for al in loss_helper.potential_aux_losses():\\n if al.keys()[0] in train_data_dict.keys():\\n y_key = '%s' % al.keys()[0]\\n train_session_vars[y_key] = train_data_dict[al.values()[0]['y_name']]\\n save_training_vars += [y_key]\\n\\n yhat_key = '%s_hat' % al.keys()[0]\\n train_session_vars[yhat_key] = model[al.values()[0]['model_name']]\\n save_training_vars += [yhat_key]\\n\\n # Start training loop\\n np.save(config.train_checkpoint, config)\\n step, losses = 0, []\\n num_joints = int(\\n train_data_dict['label'].get_shape()[-1]) // config.keep_dims\\n normalize_vec = tf_fun.get_normalization_vec(config, num_joints)\\n if config.resume_from_checkpoint is not None:\\n if '.ckpt' in config.resume_from_checkpoint:\\n ckpt = config.resume_from_checkpoint\\n 'Restoring specified checkpoint: %s' % config.resume_from_checkpoint\\n else:\\n ckpt = tf.train.latest_checkpoint(config.resume_from_checkpoint)\\n print 'Evaluating checkpoint: %s' % ckpt\\n saver.restore(sess, ckpt)\\n try:\\n while not coord.should_stop():\\n start_time = time.time()\\n train_out_dict = sess.run(train_session_vars.values())\\n train_out_dict = {k: v for k, v in zip(\\n train_session_vars.keys(), train_out_dict)}\\n losses.append(train_out_dict['loss_value'])\\n duration = time.time() - start_time\\n assert not np.isnan(\\n train_out_dict['loss_value']), 'Model diverged with loss = NaN'\\n if step % config.steps_before_validation == 0:\\n if validation_data is not False:\\n val_out_dict = sess.run(\\n val_session_vars.values())\\n val_out_dict = {k: v for k, v in zip(\\n val_session_vars.keys(), val_out_dict)}\\n # if config.normalize_labels:\\n # val_out_dict['val_pred'] *= normalize_vec\\n # val_out_dict['val_true'] *= normalize_vec\\n np.savez(\\n os.path.join(\\n results_dir, '%s_val_coors' % step),\\n val_pred=val_out_dict['val_pred'],\\n val_ims=val_out_dict['val_ims'],\\n val_true=val_out_dict['val_true'],\\n normalize_vec=normalize_vec)\\n with open(\\n os.path.join(\\n results_dir, '%s_config.p' % step), 'wb') as fp:\\n pickle.dump(config, fp)\\n\\n # Summaries\\n summary_str = sess.run(summary_op)\\n summary_writer.add_summary(summary_str, step)\\n\\n # Training status and validation accuracy attach 9177\\n format_str = (\\n '%s: step %d, loss = %.8f (%.1f examples/sec; '\\n '%.3f sec/batch) | '\\n 'Validation l2 loss = %s | logdir = %s')\\n print (format_str % (\\n datetime.now(), step, train_out_dict['loss_value'],\\n config.train_batch / duration, float(duration),\\n val_out_dict['val_acc'],\\n config.summary_dir))\\n\\n # Save the model checkpoint if it's the best yet\\n if config.normalize_labels:\\n train_out_dict['yhat'] *= normalize_vec\\n train_out_dict['ytrue'] *= normalize_vec\\n [save_training_data(\\n output_dir=results_dir,\\n data=train_out_dict[k],\\n name='%s_%s' % (k, step)) for k in save_training_vars]\\n saver.save(\\n sess, os.path.join(\\n config.train_checkpoint,\\n 'model_' + str(step) + '.ckpt'), global_step=step)\\n\\n else:\\n # Training status\\n format_str = ('%s: step %d, loss = %.8f (%.1f examples/sec; '\\n '%.3f sec/batch)')\\n print (format_str % (\\n datetime.now(),\\n step,\\n train_out_dict['loss_value'],\\n config.train_batch / duration,\\n float(duration)))\\n # End iteration\\n step += 1\\n\\n except tf.errors.OutOfRangeError:\\n print('Done training for %d epochs, %d steps.' % (config.epochs, step))\\n finally:\\n coord.request_stop()\\n dt_stamp = get_dt() # date-time stamp\\n np.save(\\n os.path.join(\\n config.tfrecord_dir, '%s_training_loss' % dt_stamp), losses)\\n coord.join(threads)\\n sess.close()\",\n \"def train():\\n args = arguments()\\n\\n # Create output directories\\n create_output_dir(args.outputDir)\\n\\n # Start Log File\\n log_path = os.path.join(args.outputDir, LOG_DIR, time.strftime('%Y-%m-%d_%H-%M-%S.log'))\\n log_file = Logger(log_path)\\n\\n # Log arguments\\n arg_str = ''\\n for arg in vars(args):\\n arg_str += \\\"\\\\n\\\" + \\\"{:30} {}\\\".format(str(arg), getattr(args, arg))\\n log_file.log_line(\\\"Arguments\\\", arg_str)\\n log_file.newline()\\n\\n # Load Params\\n configuration = config_cvppp.TrainConfig()\\n\\n # Log params\\n log_file.log_line(\\\"Config Parameters\\\\n\\\", configuration.to_string())\\n log_file.newline()\\n\\n ## Load dataset API (Already logged in the args log step)\\n train_dataset, crossVal_dataset = load_datasets(args)\\n\\n # Init the model\\n checkpoint_path = os.path.join(args.outputDir, CHECKPOINT_DIR)\\n training_model = model.MaskRCNN('training', configuration, checkpoint_path)\\n\\n # Load weights\\n if args.init == 'last':\\n weights_path = training_model.find_last()\\n log_file.log_line(\\\"Initialised with \\\", weights_path)\\n training_model.load_weights(weights_path, by_name=True)\\n\\n elif args.init == 'rand':\\n log_file.log_line(\\\"Initialised with \\\", \\\"random weights\\\")\\n pass\\n\\n else:\\n if not os.path.exists(args.init):\\n raise OSError('No weights at: ' + args.init)\\n \\n log_file.log_line(\\\"Initialised with \\\", args.init)\\n training_model.load_weights(args.init, by_name=True)\\n\\n # Train the model\\n augmentation = get_augmentation_sequence()\\n\\n custom_callbacks = None\\n\\n training_model.train(train_dataset, crossVal_dataset, \\n learning_rate=configuration.LEARNING_RATE, \\n epochs=args.numEpochs,\\n augmentation=augmentation,\\n layers='all',\\n custom_callbacks=custom_callbacks) # Train all layers\\n\\n # Close the log file\\n log_file.close()\",\n \"def main_train(lr, bs, cuda_id, not_distrib, fp16, loss_scale):\\r\\n torch.backends.cudnn.benchmark = True\\r\\n if fp16: assert torch.backends.cudnn.enabled, \\\"missing cudnn\\\"\\r\\n stats = (np.array([ 0.4914 , 0.48216, 0.44653]), np.array([ 0.24703, 0.24349, 0.26159]))\\r\\n sz=32\\r\\n PATH = Path(\\\"../../data/cifar10/\\\")\\r\\n tfms = tfms_from_stats(stats, sz, aug_tfms=[RandomCrop(sz), RandomFlip()], pad=sz//8)\\r\\n data1 = ImageClassifierData.from_paths(PATH, val_name='test', tfms=tfms, bs=bs)\\r\\n m = wrn_22().cuda()\\r\\n if not not_distrib: m = nn.parallel.DistributedDataParallel(m, device_ids=[cuda_id], output_device=cuda_id)\\r\\n learn = ConvLearner.from_model_data(m, data1)\\r\\n learn.crit = nn.CrossEntropyLoss()\\r\\n learn.metrics = [accuracy]\\r\\n trn_tfms = CustomTfm(0.5, 4, 32, 1)\\r\\n val_tfms = None\\r\\n data = DataBunch.from_files(PATH, trn_tfms, val_tfms, stats, torch.device('cuda', cuda_id), distrib=not not_distrib, val_name='test', bs=bs)\\r\\n learn.data.trn_dl, learn.data.val_dl = data.trn_dl, data.val_dl\\r\\n if fp16: learn.half()\\r\\n x,y = next(iter(data.trn_dl))\\r\\n opt_fn = get_opt_fn('Adam', 0.95, 0.99, False)\\r\\n learn.opt_fn = opt_fn\\r\\n cyc_len, pct = 30, 0.075\\r\\n nbs = [cyc_len * (1-pct) / 2, cyc_len * (1-pct) / 2, cyc_len * pct]\\r\\n phases = get_phases(lr, (0.95,0.85), opt_fn, 10, nbs, 0.1, True, False)\\r\\n #print_lr = PrintLR(learn)\\r\\n learn.fit_opt_sched(phases, loss_scale=loss_scale)\",\n \"def load_cifar10(data_path=\\\".\\\", test_size=0.2, random_state=1337):\\n test_path = os.path.join(data_path, \\\"cifar-10-batches-py/test_batch\\\")\\n train_paths = [os.path.join(data_path, \\\"cifar-10-batches-py/data_batch_%i\\\" % i) for i in range(1, 6)]\\n\\n if not os.path.exists(test_path) or not all(list(map(os.path.exists, train_paths))):\\n print (\\\"Dataset not found. Downloading...\\\")\\n download_cifar(data_path,\\n url='https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz',\\n tarname='cifar-10-python.tar.gz')\\n\\n train_batches = list(map(unpickle, train_paths))\\n test_batch = unpickle(test_path)\\n\\n X = np.concatenate([batch[\\\"data\\\"] for batch in train_batches]).reshape([-1, 3, 32, 32]).astype('float32') / 255\\n y = np.concatenate([batch[\\\"labels\\\"] for batch in train_batches]).astype('int32')\\n X_train, X_val, y_train, y_val = train_test_split(X, y,\\n test_size=test_size,\\n random_state=random_state)\\n\\n X_test = test_batch[\\\"data\\\"].reshape([-1, 3, 32, 32]).astype('float32') / 255\\n y_test = np.array(test_batch[\\\"labels\\\"]).astype('int32')\\n\\n return X_train, y_train, X_val, y_val, X_test, y_test\",\n \"def train():\\r\\n with tf.Graph().as_default():\\r\\n global_step = tf.Variable(0, trainable=False)\\r\\n\\r\\n # Get images and labels for CIFAR-10.\\r\\n images=tf.placeholder(\\\"float\\\",shape=[None,256,320,3])\\r\\n labels=tf.placeholder(\\\"float\\\",shape=[None])\\r\\n local6=tf.placeholder(\\\"float\\\",shape=[None])\\r\\n images, labels = inputs()\\r\\n logits = inference(images)\\r\\n loss = compute_loss(logits, labels)\\r\\n lr=0.001\\r\\n tf.summary.scalar('learning_rate', lr)\\r\\n opt = tf.train.GradientDescentOptimizer(lr)\\r\\n grads = opt.compute_gradients(loss)\\r\\n apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)\\r\\n train_op=apply_gradient_op\\r\\n\\r\\n # Create a saver.\\r\\n saver = tf.train.Saver(tf.global_variables())\\r\\n\\r\\n # Build the summary operation based on the TF collection of Summaries.\\r\\n summary_op = tf.summary.merge_all()\\r\\n\\r\\n # Build an initialization operation to run below.\\r\\n init = tf.global_variables_initializer()\\r\\n\\r\\n # Start running operations on the Graph.\\r\\n sess = tf.Session(config=tf.ConfigProto(\\r\\n log_device_placement=False))\\r\\n sess.run(init)\\r\\n\\r\\n # Start the queue runners.\\r\\n tf.train.start_queue_runners(sess=sess)\\r\\n\\r\\n summary_writer = tf.summary.FileWriter('/home/fzyue/Desktop/caffeendtoend/1', sess.graph)\\r\\n\\r\\n for step in xrange(500000):\\r\\n start_time = time.time()\\r\\n _, loss_value = sess.run([train_op, loss])\\r\\n duration = time.time() - start_time\\r\\n\\r\\n assert not np.isnan(loss_value), 'Model diverged with loss = NaN'\\r\\n\\r\\n if step % 10 == 0:\\r\\n num_examples_per_step = 64\\r\\n examples_per_sec = num_examples_per_step / duration\\r\\n sec_per_batch = float(duration)\\r\\n\\r\\n format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '\\r\\n 'sec/batch)')\\r\\n print (format_str % (datetime.now(), step, loss_value,\\r\\n examples_per_sec, sec_per_batch))\\r\\n #print(labels)\\r\\n #print (sess.run(logits))\\r\\n\\r\\n if step % 100 == 0:\\r\\n summary_str = sess.run(summary_op)\\r\\n summary_writer.add_summary(summary_str, step)\\r\\n\\r\\n # Save the model checkpoint periodically.\\r\\n if step % 1000 == 0 or (step + 1) == 500000:\\r\\n checkpoint_path = os.path.join('/home/fzyue/Desktop/caffeendtoend/1', 'model.ckpt')\\r\\n saver.save(sess, checkpoint_path, global_step=step)\",\n \"def executeCNN(args, files, var_targets, nn_arch, batchsize, epoch, mode, n_gpu=(1, 'avolkov'), shuffle=(False, None), tb_logger=False):\\n\\n print '\\\\nEpoch Interval:\\\\t', epoch[0], ' - ', epoch[1], '\\\\n'\\n\\n if epoch[0] == 0:\\n if nn_arch == 'DCNN':\\n if args.wires in ['U', 'V']: model = create_shared_dcnn_network_2()\\n elif args.wires in ['UV', 'U+V']: model = create_shared_dcnn_network_4()\\n else: raise ValueError('passed wire specifier need to be U/V/UV')\\n elif nn_arch == 'ResNet':\\n raise ValueError('Currently, this is not implemented')\\n elif nn_arch == 'Inception':\\n if args.wires in ['U', 'V']: model = create_shared_inception_network_2()\\n elif args.wires in ['UV', 'U+V']: model = create_shared_inception_network_4()\\n else: raise ValueError('passed wire specifier need to be U/V/UV')\\n elif nn_arch == 'Conv_LSTM':\\n raise ValueError('Currently, this is not implemented')\\n else:\\n raise ValueError('Currently, only DCNN and Inception are available as nn_arch')\\n else:\\n model = load_trained_model(args)\\n\\n if mode == 'train':\\n model.summary()\\n try: # plot model, install missing packages with conda install if it throws a module error\\n raise OSError\\n ks.utils.plot_model(model, to_file=args.folderOUT + '/plot_model.png',\\n show_shapes=True, show_layer_names=False)\\n except OSError:\\n save_plot_model_script(folderOUT=args.folderOUT)\\n print 'could not produce plot_model.png ---- run generate_model_plot on CPU'\\n\\n # exit()\\n\\n adam = ks.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0) # Default: epsi: None, Deep NN: epsi=0.1/1.0\\n optimizer = adam # Choose optimizer, only used if epoch == 0\\n\\n # model, batchsize = parallelize_model_to_n_gpus(model, n_gpu, batchsize) # TODO compile after restart????\\n # if n_gpu[0] > 1: model.compile(loss=loss_opt[0], optimizer=optimizer, metrics=[loss_opt[1]]) # TODO check\\n\\n if epoch[0] == 0:\\n print 'Compiling Keras model\\\\n'\\n model.compile(\\n loss='categorical_crossentropy',\\n optimizer=optimizer,\\n metrics=['accuracy'])\\n # TODO Add Precision/Recall to metric, see:\\n # TODO https://stackoverflow.com/questions/43076609/how-to-calculate-precision-and-recall-in-keras\\n\\n print 'optimizer epsilon:', model.optimizer.epsilon\\n\\n print \\\"\\\\nTraining begins in Epoch:\\\\t\\\", epoch\\n\\n model.save(args.folderOUT + \\\"models/model-000.hdf5\\\")\\n model.save_weights(args.folderOUT + \\\"models/weights-000.hdf5\\\")\\n model = fit_model(args, model, files, batchsize, var_targets, epoch, shuffle, n_events=None, tb_logger=tb_logger)\\n model.save_weights(args.folderOUT + \\\"models/weights_final.hdf5\\\")\\n model.save(args.folderOUT + \\\"models/model_final.hdf5\\\")\\n elif mode in ['valid']: #validation\\n # model.summary()\\n print 'Validate events'\\n print model\\n print model.get_layer(index=3)\\n exit()\\n\\n args.sources = \\\"\\\".join(sorted(args.sources))\\n args.position = \\\"\\\".join(sorted(args.position))\\n args.folderOUT += \\\"0validation/\\\" + args.sources + \\\"-\\\" + mode + \\\"-\\\" + args.position + \\\"-\\\" + str(args.num_weights) + \\\"-\\\" + args.wires + \\\"/\\\"\\n os.system(\\\"mkdir -p -m 770 %s \\\" % (args.folderOUT))\\n\\n EVENT_INFO = get_events(args=args, files=files, model=model,\\n fOUT=(args.folderOUT + \\\"events_\\\" + str(args.num_weights) + \\\"_\\\" + args.sources + \\\"-\\\" + mode + \\\"-\\\" + args.position + \\\"-\\\" + args.wires + \\\".hdf5\\\"))\\n\\n # EVENT_INFO['DNNPredClass'] = EVENT_INFO['DNNPred'].argmax(axis=-1)\\n # EVENT_INFO['DNNTrueClass'] = EVENT_INFO['DNNTrue'].argmax(axis=-1)\\n # EVENT_INFO['DNNPredTrueClass'] = EVENT_INFO['DNNPred'][:, 1]\\n\\n validation_mc_plots(args=args, folderOUT=args.folderOUT, data=EVENT_INFO)\\n else:\\n raise ValueError('chosen mode (%s) not available. Choose between train/mc/data'%(mode))\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--dataset_path',\\n type=str,\\n default='../Datasets2/cifar100Dataset.npy',\\n help='location of the dataset in numpy format', )\\n parser.add_argument('--train_steps',\\n type=int,\\n default=150000,\\n help='training steps', )\\n parser.add_argument('--measuring_step_size',\\n type=float,\\n default=0.1,\\n help='step size to where a second loss is determined to approximate the loss function '\\n 'in the direction of the gradient by a parabola', )\\n parser.add_argument('--momentum',\\n type=float,\\n default=0.4,\\n help='momentum term', )\\n parser.add_argument('--batch_size',\\n type=int,\\n default=128,\\n help='batch_size', )\\n parser.add_argument('--experiment_name',\\n type=str,\\n default=\\\"testmodel\\\",\\n help='the name of the experiment', )\\n parser.add_argument('--loose_approximation_factor',\\n type=float,\\n default=1.0,\\n help='intentionally approximate the function with less or more curvature. = 1/ step size adaptation '\\n 'less curvature <1 more curvature >1', )\\n parser.add_argument('--train_data_size',\\n type=int,\\n default=45000,\\n help='train data size,remaining elements define the evaluation_Res_Net set', )\\n parser.add_argument('--random_seed',\\n type=int,\\n default=1,\\n help='random number seed for numpy and tensorflow to get same results for multiple runs', )\\n parser.add_argument('--max_stepsize',\\n type=float,\\n default=3.6,\\n help='max stepsize in direction of the gradient', )\\n parser.add_argument('--decay',\\n type=float,\\n default=1,\\n help='max stepsize and measurment stepsize decay rate', )\\n parser.add_argument('--additional',\\n type=float,\\n default=100,\\n help='additional parameter', )\\n parser.add_argument('--num_gpus',\\n type=int,\\n default=1,\\n help='num gpus to train on', )\\n parser.add_argument('--optimizer',\\n type=str,\\n default=\\\"SLS\\\",\\n help='the optimizer to use', )\\n\\n FLAGS, unparsed = parser.parse_known_args()\\n for k, v in vars(FLAGS).items():\\n k, v = str(k), str(v)\\n print('%s: %s' % (k, v))\\n FLAGS.dataset_path = os.path.expanduser(FLAGS.dataset_path)\\n print(\\\"DatasetPath: \\\" + str(FLAGS.dataset_path))\\n\\n workpath = os.path.dirname(os.path.dirname(sys.argv[0])) + '/' # double dir name to get parent\\n\\n print(\\\"workpath: \\\" + workpath)\\n\\n # check gpus\\n local_device_protos = device_lib.list_local_devices()\\n num_available_gpus = len([x.name for x in local_device_protos if x.device_type == 'GPU'])\\n assert num_available_gpus >= FLAGS.num_gpus\\n print(\\\"GPUs available: {1:d} \\\\t GPUs used: {1:d}\\\".format(num_available_gpus, FLAGS.num_gpus))\\n\\n learning_rate_pf = lambda global_step, learning_rate: tf.train.piecewise_constant(global_step,\\n [75000.0, 112500.0],\\n [float(learning_rate),\\n float(learning_rate / 10),\\n float(learning_rate / 100),\\n ])\\n\\n if FLAGS.optimizer == \\\"PAL\\\":\\n optimizer = PAL(None, FLAGS.measuring_step_size, FLAGS.momentum, FLAGS.loose_approximation_factor,\\n FLAGS.max_stepsize, False)\\n elif FLAGS.optimizer == \\\"SLS\\\":\\n optimizer = SLS(n_batches_per_epoch=FLAGS.train_data_size // FLAGS.batch_size,\\n init_step_size=FLAGS.measuring_step_size, c=FLAGS.momentum,\\n beta_b=FLAGS.loose_approximation_factor, gamma=FLAGS.max_stepsize)\\n elif FLAGS.optimizer == \\\"OL\\\":\\n #optimizer = OptimalLineSearch(initial_search_step=FLAGS.measuring_step_size,\\n # max_num_of_steps=FLAGS.max_stepsize, momentum=FLAGS.momentum)\\n optimizer = OptimalLineSearch(initial_search_step=1.0,\\n max_num_of_steps=20.0, momentum=0.0)\\n\\n elif FLAGS.optimizer == \\\"RMSP\\\":\\n optimizer = TfOptimizer(tf.train.RMSPropOptimizer, learning_rate_pf,\\n {\\\"learning_rate\\\": FLAGS.measuring_step_size, \\\"decay\\\": FLAGS.momentum,\\n \\\"epsilon\\\": FLAGS.loose_approximation_factor})\\n elif FLAGS.optimizer == \\\"ADAM\\\":\\n optimizer = TfOptimizer(tf.train.AdamOptimizer, learning_rate_pf,\\n {\\\"learning_rate\\\": FLAGS.measuring_step_size, \\\"beta1\\\": FLAGS.momentum,\\n \\\"beta2\\\": FLAGS.loose_approximation_factor, \\\"epsilon\\\": FLAGS.max_stepsize})\\n elif FLAGS.optimizer == \\\"SGD\\\":\\n optimizer = TfOptimizer(tf.train.MomentumOptimizer, learning_rate_pf,\\n {\\\"learning_rate\\\": FLAGS.measuring_step_size, \\\"momentum\\\": FLAGS.momentum,\\n \\\"use_nesterov\\\": True})\\n elif FLAGS.optimizer == \\\"SGDHD\\\":\\n optimizer = TfOptimizer(SGDHD, None,\\n {\\\"learning_rate\\\": FLAGS.measuring_step_size, \\\"hyper_gradient_learning_rate\\\": FLAGS.momentum})\\n elif FLAGS.optimizer == \\\"ALIG\\\":\\n optimizer = TfOptimizer(AliGwithMomentum, None,\\n {\\\"max_lr\\\": FLAGS.measuring_step_size, \\\"momentum\\\": FLAGS.momentum})\\n elif FLAGS.optimizer == \\\"COCOB\\\":\\n optimizer = TfOptimizer(COCOB, None,\\n {\\\"alpha\\\": FLAGS.measuring_step_size})\\n\\n else:\\n raise ValueError(\\\"unknown optimizer flag:\\\" + FLAGS.optimizer)\\n\\n # Uncomment the network and dataset to use!\\n\\n # net_type= tolstoi_rnn.TolstoiRNN\\n\\n # net_type= simple_mnist_net.SimpleMnistNet\\n\\n # net_type=efficient_net_cifar10.EfficientNet\\n # net_type=mobile_net_v2_cifar10.MobileNetV2\\n net_type = resnet_32_cifar10.ResNet\\n # net_type=dense_net_cifar10.DenseNet\\n # net_type=resnet_34_IN_style_cifar.ResNet\\n\\n # net_type=efficient_net_cifar100.EfficientNet\\n # net_type=mobile_net_v2_cifar100.MobileNetV2\\n # net_type=resnet_32_cifar100.ResNet\\n # net_type=dense_net_cifar100.DenseNet\\n\\n # net_type=efficient_net_IM.EfficientNet\\n # net_type=mobile_net_v2_IM.MobileNetV2\\n # net_type=resnet_101_IM.ResNet\\n # net_type=resnet_50_IM.ResNet\\n # net_type=dense_net_IM.DenseNet\\n\\n # data_set_loader = ImageNetLoader\\n #data_set_loader = Cifar10Loader # also uncomment is_augment\\n #data_set_loader.is_augment = True\\n data_set_loader = Cifar100Loader\\n # data_set_loader = TolstoiLoader\\n # data_set_loader= MNISTLoader\\n\\n sys.stdout.flush()\\n\\n if FLAGS.optimizer == \\\"OL\\\":\\n net = net_frame_ol.NetFrame(net_type, data_set_loader, optimizer, FLAGS.num_gpus, FLAGS.random_seed,\\n FLAGS.train_data_size,\\n FLAGS.batch_size, FLAGS.dataset_path, workpath, FLAGS.experiment_name,\\n is_calc_angle=False)\\n else:\\n net = net_frame.NetFrame(net_type, data_set_loader, optimizer, FLAGS.num_gpus, FLAGS.random_seed,\\n FLAGS.train_data_size,\\n FLAGS.batch_size, FLAGS.dataset_path, workpath, FLAGS.experiment_name,\\n is_calc_angle=False) # 100. 0.001 # problem 1,1 or 20,1 -> very steep descent!\\n\\n is_failed = False\\n try:\\n mean_train_losses_per_interval, evaluation_accuracies, train_losses_for_each_step, step_sizes_for_each_step, \\\\\\n angles_for_each_step, grad_norms_for_each_step, train_time_for_each_step, tran_acc_per_interval, \\\\\\n eval_losses, avg_test_acc, avg_test_loss, all_first_derivatives, all_second_derivatives \\\\\\n = net.train(FLAGS.train_steps)\\n except Exception as e:\\n print(e.__doc__)\\n is_failed = True\\n print(\\\"FAILED\\\")\\n\\n if is_failed:\\n eval_data_wrapper = fu.EvalDataWrapper(FLAGS.experiment_name, FLAGS.random_seed, FLAGS.optimizer,\\n FLAGS.train_data_size,\\n FLAGS.train_steps, FLAGS.batch_size, FLAGS.measuring_step_size,\\n FLAGS.momentum,\\n FLAGS.loose_approximation_factor, FLAGS.max_stepsize, FLAGS.decay,\\n FLAGS.additional, [], [], [], [], None, None, is_failed)\\n else:\\n eval_data_wrapper = fu.EvalDataWrapper(FLAGS.experiment_name, FLAGS.random_seed, FLAGS.optimizer,\\n FLAGS.train_data_size,\\n FLAGS.train_steps, FLAGS.batch_size, FLAGS.measuring_step_size,\\n FLAGS.momentum,\\n FLAGS.loose_approximation_factor, FLAGS.max_stepsize, FLAGS.decay,\\n FLAGS.additional, mean_train_losses_per_interval, tran_acc_per_interval,\\n evaluation_accuracies, eval_losses, avg_test_acc, avg_test_loss, is_failed,\\n angles_for_each_step, step_sizes_for_each_step, grad_norms_for_each_step,\\n all_first_derivatives, all_second_derivatives\\n )\\n\\n fu.save_eval_data_wrapper(eval_data_wrapper, net.model_dir)\",\n \"def run_test(filepath):\\n num_class = 120 # dogbreeds class\\n model = Resnet50MO(num_class, checkpoint_path=None)\\n\\n # image settings\\n crop_size = model.input_size\\n scale_size = model.input_size\\n input_size = model.input_size\\n input_mean = model.input_mean\\n input_std = model.input_std\\n\\n # hyperparams settings\\n epochs = 1\\n batch_size = 32 # mini-batch-size\\n learning_rate = 0.01\\n momentum = 0.5\\n decay_factor = 10\\n eval_freq = 5 # in epochs\\n\\n # data generator settings: dataset and dataloader\\n train_dataset = DogImageset(filepath, input_size,\\n input_mean=input_mean, input_std=input_std)\\n val_dataset = DogImageset(filepath, input_size,\\n input_mean=input_mean, input_std=input_std)\\n \\n train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\\n val_loader = DataLoader(dataset=val_dataset, batch_size=batch_size, shuffle=False)\\n\\n # Loss and backprop settings\\n model.cuda()\\n criterion = torch.nn.CrossEntropyLoss()\\n optimizer = torch.optim.SGD(\\n model.parameters(),\\n lr=learning_rate,\\n momentum=momentum\\n )\\n\\n run_model_train_test(model, train_loader, criterion, optimizer)\",\n \"def loadData(self):\\n # Load the raw CIFAR-10 data\\n num_training = 49000\\n num_validation = 1000\\n num_test = 1000\\n subtract_mean = True\\n\\n cifar10_dir = '/home/parallels/PycharmProjects/Courses/232A/project2/stats232a/datasets/cifar-10-batches-py'\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\n\\n # Subsample the data\\n mask = list(range(num_training, num_training + num_validation))\\n X_val = X_train[mask]\\n y_val = y_train[mask]\\n mask = list(range(num_training))\\n X_train = X_train[mask]\\n y_train = y_train[mask]\\n mask = list(range(num_test))\\n X_test = X_test[mask]\\n y_test = y_test[mask]\\n\\n # Normalize the data: subtract the mean image\\n if subtract_mean:\\n mean_image = np.mean(X_train, axis=0)\\n X_train -= mean_image\\n X_val -= mean_image\\n X_test -= mean_image\\n\\n # Transpose so that channels come first\\n X_train = X_train.transpose(0, 3, 1, 2)\\n X_val = X_val.transpose(0, 3, 1, 2)\\n X_test = X_test.transpose(0, 3, 1, 2)\\n\\n # Package data into a dictionary\\n self.data = {\\n 'X_train': X_train, 'y_train': y_train,\\n 'X_val': X_val, 'y_val': y_val,\\n 'X_test': X_test, 'y_test': y_test,\\n }\",\n \"def main():\\n args = get_arguments()\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n \\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader_MultiClass_Loss(\\n args.data_dir,\\n args.data_list,\\n None, # No defined input size.\\n RANDOM_SEED,\\n False, # No random scale.\\n False, # No random mirror.\\n coord)\\n image, l2_catg, binary_catg, hinge_catg = reader.image, reader.l2_catg, reader.binary_catg, reader.hinge_catg\\n image_batch = tf.expand_dims(image, dim=0)\\n binary_catg_batch = tf.expand_dims(binary_catg, dim=0)\\n\\n # Create network.\\n net = DeepLabResNetModel({'data': image_batch}, is_training=False)\\n\\n # Which variables to load.\\n restore_var = tf.global_variables()\\n \\n # Predictions.\\n raw_output = net.layers['fc1_voc12']\\n\\n # Do the global average pooling\\n raw_output_bcgd_rmvd = raw_output[:,:,:,1:]\\n g_avg_pool = tf.reduce_mean(tf.reduce_mean(raw_output_bcgd_rmvd, axis=1, keep_dims=True),\\\\\\n axis=2, keep_dims=True) # Avg across the width and height dimension -> [Bx21]\\n g_avg_pool_sqzd = tf.squeeze(g_avg_pool, axis=[1, 2])\\n pred = tf.nn.softmax(g_avg_pool_sqzd)\\n\\n # Get the class activation map\\n raw_output_up = tf.image.resize_bilinear(raw_output_bcgd_rmvd, tf.shape(image_batch)[1:3,])\\n raw_output_up = raw_output_up - tf.reduce_min(tf.reduce_min(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True) + EPSILON\\n raw_output_up = raw_output_up / tf.reduce_max(tf.reduce_max(raw_output_up, axis=1, keep_dims=True), axis=2, keep_dims=True)\\n cam_m_1 = tf.argmax(raw_output_up, dimension=3) + 1\\n raw_output_catgs_rmvd = raw_output_up * tf.expand_dims(tf.expand_dims(binary_catg_batch, 1), 2)\\n cam_m_2 = tf.argmax(raw_output_catgs_rmvd, dimension=3) + 1\\n cam = tf.cast(tf.equal(cam_m_1, cam_m_2), tf.int64) * cam_m_1\\n\\n cam_batch = tf.expand_dims(cam, dim=3)\\n\\n # Set up tf session and initialize variables. \\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n \\n sess.run(init)\\n sess.run(tf.local_variables_initializer())\\n \\n # Load weights.\\n loader = tf.train.Saver(var_list=restore_var)\\n if args.restore_from is not None:\\n load(loader, sess, args.restore_from)\\n \\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n \\n # Iterate over training steps.\\n for step in range(args.num_steps):\\n preds, images, cams, bin_catg = sess.run([pred, image_batch, cam_batch, binary_catg])\\n \\\"\\\"\\\"\\n print(bin_catg)\\n print(np.unique(np.unique(cams)))\\n \\\"\\\"\\\"\\n img = inv_preprocess(images)\\n attMap = decode_labels(cams)\\n output_dir = './output_maps_binary_without_norm/'\\n img_name = output_dir + str(step) + '.jpg'\\n map_name = output_dir + str(step) + '.png'\\n misc.imsave(img_name, img[0,:,:,:])\\n misc.imsave(map_name, attMap[0,:,:,:])\\n coord.request_stop()\\n coord.join(threads)\",\n \"def train():\\n\\t# 1、make dataloader\\n\\ttrain_loader, val_loader, num_query, num_class = make_data_loader(cfg)\\n\\t#print(\\\"num_query:{},num_class:{}\\\".format(num_query,num_class))\\n\\n\\t# 2、make model\\n\\tmodel = build_model(cfg, num_class)\\n\\n\\t# model.eval()\\n\\t# x = model(img_tensor)\\n\\t# print(x.shape)\\n\\t# 3、 make optimizer\\n\\toptimizer = make_optimizer(cfg, model)\\n\\n\\t# 4、 make lr_scheduler\\n\\tscheduler = make_lr_scheduler(cfg, optimizer)\\n\\n\\t# 5、 make loss_func\\n\\tif cfg.MODEL.PCB_NECK:\\n\\t\\t# make loss specificially for pcb \\n\\t\\tloss_func = get_softmax_triplet_loss_fn(cfg, num_class)\\n\\telse:\\n\\t\\tloss_func = make_loss(cfg, num_class)\\n\\n\\t# get paramters\\n\\tlog_period = cfg.OUTPUT.LOG_PERIOD \\n\\tckpt_period =cfg.OUTPUT.CHECKPOINT_PERIOD\\n\\teval_period = cfg.OUTPUT.EVAL_PERIOD\\n\\toutput_dir = cfg.OUTPUT.ROOT_DIR\\n\\tdevice = cfg.MODEL.DEVICE\\n\\tepochs = cfg.SOLVER.MAX_EPOCHS\\n\\tuse_gpu = device == \\\"cuda\\\"\\n\\tuse_neck = cfg.MODEL.NECK or cfg.MODEL.LEARN_REGION \\n\\t# how many batch for each log\\n\\tbatch_size = cfg.SOLVER.IMGS_PER_BATCH\\n\\tbatch_num = len(train_loader) \\n\\t\\n\\tlog_iters = batch_num // log_period\\n\\tpretrained = cfg.MODEL.PRETRAIN_PATH != ''\\n\\tparallel = cfg.MODEL.PARALLEL \\t\\n\\tgrad_clip = cfg.DARTS.GRAD_CLIP \\n\\n\\tfeat_norm = cfg.TEST.FEAT_NORM \\n\\tckpt_save_path = cfg.OUTPUT.ROOT_DIR + cfg.OUTPUT.CKPT_DIR\\n\\tif not os.path.exists(ckpt_save_path):\\n\\t\\tos.makedirs(ckpt_save_path)\\n\\n\\n\\t# create *_result.xlsx\\n\\t# save the result for analyze\\n\\tname = (cfg.OUTPUT.LOG_NAME).split(\\\".\\\")[0] + \\\".xlsx\\\"\\n\\tresult_path = cfg.OUTPUT.ROOT_DIR + name\\n\\n\\twb = xl.Workbook()\\n\\tsheet = wb.worksheets[0]\\n\\ttitles = ['size/M','speed/ms','final_planes', 'acc', 'mAP', 'r1', 'r5', 'r10', 'loss',\\n\\t\\t\\t 'acc', 'mAP', 'r1', 'r5', 'r10', 'loss','acc', 'mAP', 'r1', 'r5', 'r10', 'loss']\\n\\tsheet.append(titles)\\n\\tcheck_epochs = [40, 80, 120, 160, 200, 240, 280, 320, 360, epochs]\\n\\tvalues = []\\n\\n\\tlogger = logging.getLogger('MobileNetReID.train')\\n\\t\\n\\t# count parameter\\n\\tsize = count_parameters(model)\\n\\tlogger.info(\\\"the param number of the model is {:.2f} M\\\".format(size))\\n\\t\\n\\tvalues.append(format(size, '.2f'))\\n\\tvalues.append(model.final_planes)\\n\\n\\tlogger.info(\\\"Start training\\\")\\n\\t\\n\\t#count = 183, x, y = batch -> 11712 for train\\n\\tif pretrained:\\n\\t\\tstart_epoch = model.start_epoch\\n\\n\\tif parallel:\\n\\t\\tmodel = nn.DataParallel(model)\\n\\n\\tif use_gpu:\\n\\t\\t# model = nn.DataParallel(model)\\n\\t\\tmodel.to(device)\\n\\t\\n\\t# save the best model\\n\\tbest_mAP, best_r1 = 0., 0.\\n\\tis_best = False\\n\\t# batch : img, pid, camid, img_path\\n\\tavg_loss, avg_acc = RunningAverageMeter(), RunningAverageMeter()\\n\\tavg_time, global_avg_time = AverageMeter(), AverageMeter()\\n\\tglobal_avg_time.reset()\\n\\tfor epoch in range(epochs):\\n\\t\\tscheduler.step()\\n\\n\\t\\tif pretrained and epoch < start_epoch - 1:\\n\\t\\t\\tcontinue\\n\\t\\n\\t\\tmodel.train()\\n\\t\\t# sum_loss, sum_acc = 0., 0.\\n\\t\\tavg_loss.reset()\\n\\t\\tavg_acc.reset()\\n\\t\\tavg_time.reset()\\n\\t\\tfor i, batch in enumerate(train_loader):\\n\\n\\t\\t\\tt0 = time.time()\\n\\t\\t\\timgs,labels = batch\\n\\n\\t\\t\\tif use_gpu:\\n\\t\\t\\t\\timgs = imgs.to(device)\\n\\t\\t\\t\\tlabels = labels.to(device)\\n\\n\\t\\t\\tres = model(imgs)\\n\\t\\t\\t# score, feat = model(imgs)\\n\\t\\t\\t# loss = loss_func(score, feat, labels)\\n\\t\\t\\tloss, acc = compute_loss_acc(use_neck, res, labels, loss_func)\\n\\t\\t\\t\\n\\t\\t\\tloss.backward()\\n\\t\\t\\tif grad_clip != 0:\\n\\t\\t\\t\\tnn.utils.clip_grad_norm(model.parameters(), grad_clip)\\n\\n\\t\\t\\toptimizer.step()\\n\\n\\t\\t\\toptimizer.zero_grad()\\n\\n\\t\\t\\t# acc = (score.max(1)[1] == labels).float().mean()\\n\\n\\t\\t\\t# sum_loss += loss\\n\\t\\t\\t# sum_acc += acc \\n\\t\\t\\tt1 = time.time()\\n\\t\\t\\tavg_time.update((t1 - t0) / batch_size)\\n\\t\\t\\tavg_loss.update(loss)\\n\\t\\t\\tavg_acc.update(acc)\\n\\n\\t\\t\\t#log the info \\n\\t\\t\\tif (i+1) % log_iters == 0:\\n\\n\\t\\t\\t\\tlogger.info(\\\"epoch {}: {}/{} with loss is {:.5f} and acc is {:.3f}\\\".format(\\n\\t\\t\\t\\t\\t epoch+1, i+1, batch_num, avg_loss.avg, avg_acc.avg))\\n\\n\\t\\tlr = optimizer.state_dict()['param_groups'][0]['lr']\\n\\t\\tlogger.info(\\\"end epochs {}/{} with lr: {:.5f} and avg_time is {:.3f} ms\\\".format(epoch+1, epochs, lr, avg_time.avg * 1000))\\n\\t\\tglobal_avg_time.update(avg_time.avg)\\n\\t\\t# change the lr \\n\\n\\t\\t# eval the model \\n\\t\\tif (epoch+1) % eval_period == 0 or (epoch + 1) == epochs :\\n\\t\\t\\t\\n\\t\\t\\tmodel.eval()\\n\\t\\t\\tmetrics = R1_mAP(num_query, use_gpu = use_gpu, feat_norm = feat_norm)\\n\\n\\t\\t\\twith torch.no_grad():\\n\\n\\t\\t\\t\\tfor vi, batch in enumerate(val_loader):\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\timgs, labels, camids = batch\\n\\n\\t\\t\\t\\t\\tif use_gpu:\\n\\t\\t\\t\\t\\t\\timgs = imgs.to(device)\\n\\n\\t\\t\\t\\t\\tfeats = model(imgs)\\n\\t\\t\\t\\t\\tmetrics.update((feats,labels, camids))\\n\\n\\t\\t\\t\\t#compute cmc and mAP\\n\\t\\t\\t\\tcmc, mAP = metrics.compute()\\n\\t\\t\\t\\tlogger.info(\\\"validation results at epoch:{}\\\".format(epoch + 1))\\n\\t\\t\\t\\tlogger.info(\\\"mAP:{:.2%}\\\".format(mAP))\\n\\t\\t\\t\\tfor r in [1,5,10]:\\n\\t\\t\\t\\t\\tlogger.info(\\\"CMC curve, Rank-{:<3}:{:.2%}\\\".format(r,cmc[r-1]))\\t\\n\\n\\t\\t\\t\\t# determine whether cur model is the best \\n\\t\\t\\t\\tif mAP > best_mAP:\\n\\t\\t\\t\\t\\tis_best = True\\n\\t\\t\\t\\t\\tbest_mAP = mAP\\n\\t\\t\\t\\t\\tlogger.info(\\\"Get a new best mAP\\\")\\n\\t\\t\\t\\tif cmc[0] > best_r1:\\n\\t\\t\\t\\t\\tis_best = True\\n\\t\\t\\t\\t\\tbest_r1 = cmc[0]\\n\\t\\t\\t\\t\\tlogger.info(\\\"Get a new best r1\\\")\\n\\n\\t\\t\\t\\t# add the result to sheet\\n\\t\\t\\t\\tif (epoch + 1) in check_epochs:\\n\\t\\t\\t\\t\\tval = [avg_acc.avg, mAP, cmc[0], cmc[4], cmc[9]]\\n\\t\\t\\t\\t\\tchange = [format(v * 100, '.2f') for v in val]\\n\\t\\t\\t\\t\\tchange.append(format(avg_loss.avg, '.3f'))\\n\\t\\t\\t\\t\\tvalues.extend(change)\\n\\n\\n\\t\\t# we hope that eval_period == ckpt_period or eval_period == k* ckpt_period where k is int\\t\\t\\t\\n\\t\\t# whether to save the model\\n\\t\\tif (epoch+1) % ckpt_period == 0 or is_best:\\n\\n\\t\\t\\tif parallel:\\n\\t\\t\\t\\ttorch.save(model.module.state_dict(), ckpt_save_path + \\\"checkpoint_{}.pth\\\".format(epoch + 1 ))\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttorch.save(model.state_dict(), ckpt_save_path + \\\"checkpoint_{}.pth\\\".format(epoch + 1 ))\\n\\n\\t\\t\\tlogger.info(\\\"checkpoint {} saved !\\\".format(epoch + 1))\\n\\n\\t\\t\\tif is_best:\\n\\t\\t\\t\\tif parallel:\\n\\t\\t\\t\\t\\ttorch.save(model.module.state_dict(), ckpt_save_path + \\\"best_ckpt.pth\\\")\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttorch.save(model.state_dict(), ckpt_save_path + \\\"best_ckpt.pth\\\")\\n\\t\\t\\t\\tlogger.info(\\\"best checkpoint was saved\\\")\\n\\t\\t\\t\\tis_best = False\\n\\t\\n\\tvalues.insert(1, format(global_avg_time.avg * 1000, '.2f'))\\n\\tsheet.append(values)\\n\\twb.save(result_path)\\n\\n\\tlogger.info(\\\"training is end, time for per imgs is {} ms\\\".format(global_avg_time.avg *1000))\",\n \"def train_cavia(args, config, path_model, device):\\n global DATA, PATH_BASE, PATH_DATA, N_CLS, NAME_DATA, NAME_BACKBONE\\n\\n if path_model is None:\\n masks_dict = None\\n learner = None\\n else:\\n print('Load net from', path_model)\\n save_dict = torch.load(path_model)\\n state_dict = save_dict['state_dict']\\n masks_dict = save_dict.get('masks_dict', None)\\n\\n learner = Learner(config, args.num_context_params, args.context_in)\\n learner.load_state_dict(state_dict)\\n\\n if masks_dict is None:\\n print('masks_dict is None!')\\n cr = 1.\\n else:\\n cr = get_cr(learner, masks_dict)\\n\\n cavia = Meta(args, config, learner).to(device)\\n\\n # save path\\n if path_model is None:\\n path_save = '%s/model/cavia_lobs/%s_%s/%d-way_%d-shot' % (\\n PATH_BASE, NAME_DATA, NAME_BACKBONE, args.n_way, args.k_spt)\\n else:\\n path_save = '/'.join(path_model.split('/')[:-1])\\n if not os.path.exists(path_save):\\n os.makedirs(path_save)\\n\\n # meta train\\n meta_train(cavia, args, masks_dict, device,\\n output=args.log_print,\\n save=args.save_each_epoch,\\n save_threshold=args.save_threshold,\\n test_each_epoch=args.test_each_epoch,\\n path_save=path_save,\\n cr=cr,\\n break_threshold=args.break_threshold)\\n\\n if not args.save_each_epoch:\\n # meta test\\n acc_avg, accs = meta_test(cavia, args, masks_dict, device)\\n\\n path_model = '%s/net_cr-1_acc-%.4f.pkl' % (path_save, acc_avg)\\n print('Save as %s' % path_model)\\n torch.save(\\n {\\n 'state_dict': cavia.net.state_dict(),\\n 'accs': accs,\\n 'config': config,\\n 'args': args\\n },\\n path_model\\n )\",\n \"def load_cifar10_data(img_rows, img_cols):\\n\\n # Load cifar10 training and validation sets\\n (X_train, Y_train), (X_valid, Y_valid) = cifar10.load_data()\\n\\n # Resize training images\\n X_train = np.array([cv2.resize(img, (img_rows, \\\\\\n img_cols)) for img in X_train[:, :, :, :]])\\n\\n X_valid = np.array([cv2.resize(img, (img_rows, \\\\\\n img_cols)) for img in X_valid[:, :, :, :]])\\n\\n # Check the data type of X_train or X_valid\\n for each in X_train:\\n print(type(each))\\n\\n # Transform targets to keras compatible format\\n Y_train = np_utils.to_categorical(Y_train, num_classes)\\n Y_valid = np_utils.to_categorical(Y_valid, num_classes)\\n\\n X_train = X_train.astype('float32')\\n X_valid = X_valid.astype('float32')\\n\\n # Data normalization\\n X_train = X_train / 255.0\\n X_valid = X_valid / 255.0\\n\\n return X_train, Y_train, X_valid, Y_valid\",\n \"def main():\\n nn = CarsClassifierModel()\\n train_x, train_y, test_x, test_y = nn.load_data_preprocess()\\n history = nn.run(train_x,train_y)\\n nn.evaluate(test_x, test_y)\\n nn.save(\\\"keras_nn_5\\\")\\n #nn.plots(history)\\n #print(train_x.shape)\\n #plt.imshow(train_x[52])\\n #plt.title(\\\"Car\\\")\\n #plt.show()\\n #print(train_y[52])\",\n \"def train():\\n init_distributed_mode(args)\\n save_dir = TRAIN_CFG['save_dir']\\n if not os.path.exists(save_dir) and torch.distributed.get_rank() == 0:\\n os.mkdir(save_dir)\\n kwargs = {}\\n # If augmenting data, disable Pytorch's own augmentataion\\n # This has to be done manually as augmentation is embedded\\n # refer : https://github.com/pytorch/vision/issues/2263\\n base_path = DATASET_CFG['base_path']\\n train_set = DATASET_CFG['train']\\n valid_set = DATASET_CFG['valid']\\n dset_mean_std = DATASET_CFG['mean_std']\\n if dset_mean_std is not None:\\n dataset_mean = [i/255. for i in dset_mean_std[0]]\\n dataset_std = [i/255. for i in dset_mean_std[1]]\\n else:\\n dataset_mean, dataset_std = compute_mean_std(base_path, train_set)\\n kwargs['image_mean'] = dataset_mean\\n kwargs['image_std'] = dataset_std\\n kwargs['min_size'] = DATASET_CFG['min_size']\\n kwargs['max_size'] = DATASET_CFG['max_size']\\n kwargs['box_detections_per_img'] = 300 # increase max det to max val in our benchmark\\n\\n # Set benchmark related parameters\\n if benchmark == 'ScutHead':\\n combined_cfg = {**cfg, **sh_anchors}\\n elif benchmark == 'CrowdHuman':\\n combined_cfg = {**cfg, **ch_anchors}\\n elif benchmark == 'Combined':\\n combined_cfg = {**cfg, **combined_anchors}\\n else:\\n raise ValueError(\\\"New dataset has to be registered\\\")\\n\\n # Create Model\\n default_filter = False\\n model = customRCNN(cfg=combined_cfg,\\n use_deform=NET_CFG['use_deform'],\\n ohem=NET_CFG['ohem'],\\n context=NET_CFG['context'],\\n custom_sampling=NET_CFG['custom_sampling'],\\n default_filter=default_filter,\\n soft_nms=NET_CFG['soft_nms'],\\n upscale_rpn=NET_CFG['upscale_rpn'],\\n median_anchors=NET_CFG['median_anchors'],\\n **kwargs).cuda() \\n model_without_ddp = model\\n if args.distributed:\\n model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu],\\n find_unused_parameters=True)\\n model_without_ddp = model.module\\n\\n # Create Optimizer\\n params = [p for p in model.parameters() if p.requires_grad]\\n optimizer = torch.optim.SGD(params, lr=HYP_CFG['learning_rate'],\\n momentum=HYP_CFG['learning_rate'],\\n weight_decay=HYP_CFG['weight_decay'])\\n\\n scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,\\n milestones=TRAIN_CFG['milestones'],\\n gamma=HYP_CFG['gamma'])\\n # Restore from checkpoint\\n pt_model = TRAIN_CFG['pretrained_model']\\n if pt_model:\\n model_without_ddp = restore_network(model_without_ddp, pt_model,\\n only_backbone=TRAIN_CFG['only_backbone'])\\n \\n # Create training and vaid dataset\\n dataset_param = {'mean': dataset_mean, 'std':dataset_std,\\n 'shape':(kwargs['min_size'], kwargs['max_size'])}\\n batch_size = HYP_CFG['batch_size']\\n train_dataset = HeadDataset(train_set,\\n base_path,\\n dataset_param,\\n train=True)\\n val_dataset = HeadDataset(valid_set,\\n base_path,\\n dataset_param,\\n train=False)\\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)\\n train_batch_sampler = torch.utils.data.BatchSampler(train_sampler,\\n batch_size,\\n drop_last=True)\\n train_data_loader = torch.utils.data.DataLoader(train_dataset,\\n batch_sampler=train_batch_sampler,\\n num_workers=args.num_workers,\\n collate_fn=collate_fn)\\n\\n val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset)\\n val_batch_sampler = torch.utils.data.BatchSampler(val_sampler,\\n batch_size,\\n drop_last=True)\\n val_data_loader = torch.utils.data.DataLoader(val_dataset,\\n batch_sampler=val_batch_sampler,\\n num_workers=args.num_workers,\\n collate_fn=collate_fn)\\n # Fastforward the LR decayer\\n start_epoch = TRAIN_CFG['start_epoch']\\n max_epoch = TRAIN_CFG['max_epoch']\\n for _ in range(0, -1):\\n scheduler.step()\\n\\n # Start training\\n print(\\\"======= Training for \\\" + str(max_epoch) + \\\"===========\\\")\\n for epoch in range(start_epoch, int(max_epoch) + 1):\\n if epoch % TRAIN_CFG['eval_every'] == 0:\\n print(\\\"========= Evaluating Model ==========\\\")\\n result_dict = evaluate(model, val_data_loader, benchmark=benchmark)\\n if torch.distributed.get_rank() == 0:\\n logging.info('Eval score at {0} epoch is {1}'.format(str(epoch),\\n result_dict))\\n \\n train_one_epoch(model, optimizer, train_data_loader,\\n device, epoch, print_freq=1000)\\n scheduler.step()\\n if torch.distributed.get_rank() == 0:\\n print(\\\"Saving model\\\")\\n torch.save(model.state_dict(), osp.join(save_dir,\\n TRAIN_CFG['exp_name'] + '_epoch_' + str(epoch) + '.pth'))\",\n \"def load_cifar10_data(self, data_path='data/cifar-10-batches-py',\\n n_train_samples=50000, n_test_samples=10000):\\n train_data = None\\n train_labels = []\\n\\n for i in range(1, 6):\\n data_dic = unpickle(data_path + '/data_batch_{}'.format(i))\\n if i == 1:\\n train_data = data_dic['data']\\n else:\\n train_data = np.vstack((train_data, data_dic['data']))\\n\\n train_labels += data_dic['labels']\\n\\n test_data_dic = unpickle(data_path + '/test_batch')\\n test_data = test_data_dic['data']\\n test_labels = test_data_dic['labels']\\n\\n train_data = train_data.reshape((len(train_data),\\n self.LOADED_IMG_DEPTH,\\n self.LOADED_IMG_HEIGHT,\\n self.LOADED_IMG_HEIGHT))\\n\\n train_data = np.rollaxis(train_data, 1, 4)\\n train_labels = np.array(train_labels)\\n\\n test_data = test_data.reshape((len(test_data),\\n self.LOADED_IMG_DEPTH,\\n self.LOADED_IMG_HEIGHT,\\n self.LOADED_IMG_HEIGHT))\\n\\n test_data = np.rollaxis(test_data, 1, 4)\\n test_labels = np.array(test_labels)\\n\\n self.train_dataset = {'data': train_data[0:n_train_samples],\\n 'labels': train_labels[0:n_train_samples],\\n 'cls': [np.zeros(10)\\n for i in range(n_train_samples)]}\\n\\n for i in range(0, n_train_samples):\\n self.train_dataset['cls'][i][self.train_dataset['labels'][i]] = 1.\\n\\n self.test_dataset = {'data': test_data[0:n_test_samples],\\n 'labels': test_labels[0:n_test_samples],\\n 'cls': [np.zeros(10)\\n for i in range(n_train_samples)]}\\n\\n for i in range(0, n_test_samples):\\n self.test_dataset['cls'][i][self.test_dataset['labels'][i]] = 1.\\n\\n self.train_dataset['data_array'] = np.array(\\n [item.flatten() for item in self.train_dataset['data']])\\n\\n self.train_dataset['labels_array'] = np.array(\\n [item.flatten() for item in self.train_dataset['labels']])\\n\\n self.train_dataset['cls_array'] = np.array(\\n [item.flatten() for item in self.train_dataset['cls']])\\n\\n self.test_dataset['data_array'] = np.array(\\n [item.flatten() for item in self.test_dataset['data']])\\n\\n self.test_dataset['labels_array'] = np.array(\\n [item.flatten() for item in self.test_dataset['labels']])\\n\\n self.test_dataset['cls_array'] = np.array(\\n [item.flatten() for item in self.test_dataset['cls']])\\n\\n return None\",\n \"def main():\\r\\n # Read dataset.\\r\\n reader = DatasetReader\\r\\n train_filename = sys.argv[1]\\r\\n test_filename = train_filename.replace('_train_', '_dev_')\\r\\n term_index, tag_index, train_data, test_data = reader.ReadData(train_filename, test_filename)\\r\\n (train_terms, train_tags, train_lengths) = train_data\\r\\n (test_terms, test_tags, test_lengths) = test_data\\r\\n\\r\\n model = SequenceModel(train_tags.shape[1], len(term_index), len(tag_index))\\r\\n model.build_inference()\\r\\n model.build_training()\\r\\n for j in range(5):\\r\\n model.train_epoch(train_terms,train_tags, train_lengths)\\r\\n print('Finished epoch %i. Evaluating ...' % (j+1))\\r\\n model.evaluate(test_terms, test_tags, test_lengths)\",\n \"def train(nepochs, model): \\n if model == 'cnn':\\n return gennet.train_cnn(nepochs, 'Resnet50')\\n elif model == 'logreg':\\n return gennet.train_logreg('Resnet50')\",\n \"def resume_routine_resnet_multibranch(config, verbose=(2,2),\\n weights_path='',\\n nb_epoch_finetune=0, nb_epoch_after=50,\\n stiefel_observed=None, stiefel_lr=0.01,\\n by_name=False):\\n image_gen = ImageDataGeneratorAdvanced(TARGET_SIZE, RESCALE_SMALL, True,\\n horizontal_flip=True,\\n )\\n resume_model_with_config(ResNet50_o2_multibranch, config,\\n weights_path=weights_path,\\n title='mit_indoor_resnet_MB',\\n verbose=verbose, image_gen=image_gen,\\n nb_epoch_after=nb_epoch_after, nb_epoch_finetune=nb_epoch_finetune,\\n stiefel_lr=stiefel_lr, stiefel_observed=stiefel_observed,\\n by_name=by_name)\",\n \"def test_cifar(args):\\n # type: () -> None\\n\\n # Build dataset and model\\n dataset = CIFAR10(path=args.path)\\n model = MEMCIFAR10(input_shape=dataset.shape, code_length=64, cpd_channels=100, mem_dim=500, shrink_thres=1.0 / 500).cuda().eval()\\n\\n # Set up result helper and perform test\\n helper = MEMResultHelper(dataset, model, checkpoints_dir=args.checkpoints, output_file='mem_cifar.txt')\\n helper.test_one_class_classification()\",\n \"def __train__(self):\\n if (self.type_camf == 'CAMF_CI'):\\n #users, items, context, ratings\\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = ci.fit()\\n elif (self.type_camf == 'CAMF_CU'):\\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = cu.fit()\\n elif (self.type_camf == 'CAMF_C'):\\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = c.fit()\\n\\n dummy_pred = np.zeros((predictions.shape))\\n for r, pred_array in enumerate(predictions):\\n for c, pred in enumerate(pred_array):\\n dummy_pred[r][c] = self.__check_ratings__(pred)\\n predictions = dummy_pred\\n #save a plot with a loss function\\n plots = prs.PlotRSData()\\n #print(losses)\\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\\\"_loop\\\"+str(self.loop))\\n pd.DataFrame(losses).to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ +\\\"losses_loop\\\"+str(self.loop)+\\\".csv\\\")\\n print('Saving the feature matrix...')\\n # set predictions back to the pivot table\\n self.__utility_saved_training__(predictions) \\n # save results\\n self.utility_predictions.to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ + \\\"_SGD_predictions_loop\\\"+str(self.loop)+\\\".csv\\\")\",\n \"def cifar10(transform=transforms.ToTensor()):\\n\\n\\t# Directories\\n\\tscript_dir = os.path.dirname(os.path.realpath(__file__))\\n\\tdata_dir = os.path.join(script_dir, 'data', 'cifar10')\\n\\n\\t# Load training set, downloading if necessary\\n\\tdataset = datasets.CIFAR10(data_dir, train=True, transform=transform, download=True)\\n\\n\\t# Split into train, val, and test sets\\n\\n\\t# Add 'classes' list and 'class_to_idx' lookup dictionary to both sets\\n\\tclasses = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', \\n\\t\\t'horse', 'ship', 'truck']\\n\\tclass_to_idx = {classes[i]: i for i in range(len(classes))}\\n\\n\\tdataset.classes = classes\\n\\tdataset.class_to_idx = class_to_idx\\n\\n\\treturn dataset\",\n \"def create_dataset_cifar10(data_path, batch_size=32, num_parallel_workers=8, do_train=True):\\r\\n # define dataset\\r\\n data_path = os.path.join(data_path, \\\"cifar-10-batches-bin\\\" if do_train else \\\"cifar-10-verify-bin\\\")\\r\\n\\r\\n cifar_ds = ds.Cifar10Dataset(data_path, num_parallel_workers=num_parallel_workers, shuffle=do_train)\\r\\n\\r\\n # define map operations\\r\\n resize_height, resize_width = 32, 32\\r\\n rescale = 1.0 / 255.0\\r\\n shift = 0.0\\r\\n random_crop_op = CV.RandomCrop([32, 32], [4, 4, 4, 4])\\r\\n random_horizontal_op = CV.RandomHorizontalFlip(prob=0.5)\\r\\n resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\\r\\n rescale_op = CV.Rescale(rescale, shift)\\r\\n normalize_op = CV.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.2023, 0.1994, 0.2010])\\r\\n hwc2chw_op = CV.HWC2CHW()\\r\\n type_cast_op = C.TypeCast(mstype.int32)\\r\\n\\r\\n if do_train:\\r\\n compose_op = [random_crop_op, random_horizontal_op, resize_op, rescale_op, normalize_op, hwc2chw_op]\\r\\n else:\\r\\n compose_op = [resize_op, rescale_op, normalize_op, hwc2chw_op]\\r\\n cifar_ds = cifar_ds.map(input_columns=\\\"image\\\", operations=compose_op, num_parallel_workers=num_parallel_workers)\\r\\n cifar_ds = cifar_ds.map(input_columns=\\\"label\\\", operations=type_cast_op, num_parallel_workers=num_parallel_workers)\\r\\n cifar_ds = cifar_ds.batch(batch_size, drop_remainder=True)\\r\\n\\r\\n return cifar_ds\",\n \"def execute(self):\\n for csnn_config in self.__config[\\\"csnnConfigs\\\"]:\\n csnn_name = csnn_config[\\\"modelName\\\"]\\n\\n try:\\n for dataset_config in self.__config[\\\"datasetConfigs\\\"]:\\n provider = getDatasetProvider(dataset_config)\\n if not dataset_config[\\\"nameOfDataset\\\"] in csnn_config[\\\"batchSizes\\\"].keys():\\n continue\\n for i in range(0, csnn_config[\\\"xFoldCrossValidation\\\"]):\\n model_dir = \\\"/\\\" + csnn_name + \\\"/\\\" + dataset_config[\\\"nameOfDataset\\\"] + \\\"/xFoldCrossVal\\\" + str(i)\\n self.__logger.info(\\\"Starting to train: \\\" + model_dir, \\\"CsnnVisualizationExperiment:execute\\\")\\n\\n if csnn_config[\\\"xFoldCrossValidation\\\"] <= 1:\\n xseed = None\\n else:\\n xseed = 42 + i\\n\\n dataset, dataset_generator = prepareDataset(provider, dataset_config, xfold_seed=xseed,\\n augment_data=csnn_config[\\\"augmentData\\\"])\\n\\n dataset_max_div, _ = prepareDataset(provider, dataset_config, xfold_seed=xseed,\\n augment_data=csnn_config[\\\"augmentData\\\"],\\n normalize_data=\\\"maxDiv\\\")\\n\\n self.__logger.info(\\\"Starting to create dataset encoding with: \\\" + model_dir,\\n \\\"CsnnVisualizationExperiment:execute\\\")\\n encoding_provider, encoding = prepareEncoding(csnn_config, dataset_generator, dataset,\\n dataset_config, csnn_name, self.__num_gpus,\\n model_dir + \\\"/Csnn\\\", zero_mean_unit_variance=\\n csnn_config[\\\"zeroMeanUnitVarianceEncoding\\\"],\\n return_with_encoding=dataset_max_div)\\n\\n self.__logger.info(\\\"Finished to create dataset encoding with: \\\" + model_dir,\\n \\\"CsnnVisualizationExperiment:execute\\\")\\n\\n self.__logger.info(\\\"Starting to create mean activities for: \\\" + model_dir,\\n \\\"CsnnVisualizationExperiment:execute\\\")\\n enc_for_label = {}\\n for i in range(0, len(encoding[\\\"y_test\\\"])):\\n enc_for_label.setdefault(np.argmax(encoding[\\\"y_test\\\"][i]), []).append(encoding[\\\"x_test\\\"][i])\\n\\n mean_ecs_for_label = []\\n for key, value in sorted(enc_for_label.items()):\\n mean_ec_for_label = np.mean(np.mean(np.mean(value, axis=0), axis=0), axis=0)\\n grid = csnn_config[\\\"layers\\\"][-1][\\\"somGrid\\\"]\\n mean_ec_for_label = np.reshape(mean_ec_for_label, [grid[0], grid[1], grid[2]])\\n mean_ecs_for_label.append(mean_ec_for_label)\\n\\n # Dir to save and reload model.\\n save_path = os.path.dirname(\\n sys.modules['__main__'].__file__) + \\\"/experimentResults\\\" + model_dir\\n if not os.path.exists(save_path):\\n os.makedirs(save_path)\\n np.save(save_path + \\\"/test_mean_acts\\\", np.array(mean_ecs_for_label))\\n self.__logger.info(\\\"Finised to create mean activities for: \\\" + model_dir,\\n \\\"CsnnVisualizationExperiment:execute\\\")\\n\\n self.__logger.info(\\\"Starting to create mean sub activities for: \\\" + model_dir,\\n \\\"CsnnVisualizationExperiment:execute\\\")\\n sub_encs = []\\n for enc in mean_ecs_for_label:\\n sub_encs_for_label = []\\n for kenc2 in mean_ecs_for_label:\\n sub_enc = enc - kenc2\\n sub_encs_for_label.append(sub_enc)\\n sub_encs.append(sub_encs_for_label)\\n\\n np.save(save_path + \\\"/test_sub_mean_acts\\\", np.array(sub_encs))\\n self.__logger.info(\\\"Finished to create mean sub activities for: \\\" + model_dir,\\n \\\"CsnnVisualizationExperiment:execute\\\")\\n\\n except Exception:\\n print(traceback.format_exc())\",\n \"def main(Args):\\n norm = [1.9844158727667542, 413.83759806375525,\\n 51.2789974336363, 1038.4760551905683]\\n input_pull = False\\n input_model_mapping = False\\n max_number = 2\\n count = 40000\\n catalog_name = os.path.join(DATA_PATH, 'OneDegSq.fits')\\n # Define parameters for mrcnn model with btk here\\n resid_model = btk_utils.Resid_btk_model(\\n Args.model_name, Args.model_path, MODEL_DIR, training=True,\\n images_per_gpu=4, validation_for_training=True)\\n # Load parameters for dataset and load model\\n resid_model.config.WEIGHT_DECAY = 0.001\\n resid_model.config.STEPS_PER_EPOCH = 1000\\n resid_model.config.VALIDATION_STEPS = 20\\n sampling_function = None\\n layers = 'all'\\n if Args.model_name == 'model1':\\n resid_model.config.BACKBONE = 'resnet41'\\n elif Args.model_name == 'model2':\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n elif Args.model_name == 'model3':\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n elif Args.model_name == 'model4':\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n elif Args.model_name == 'model5':\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet35'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n elif Args.model_name == 'model4_large':\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = '4+' # '3+'\\n elif Args.model_name == 'model6':\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0, 1, 51.2789974336363, 1038.4760551905683]\\n input_pull = True\\n elif Args.model_name == 'model7':\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model8': # stretch = 0.1, Q = 3\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model9': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1., 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10_again': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10_again2': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = None\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10_again3': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model10_2': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0., 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model11': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1., 0., 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model11_2': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1., 0., 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n elif Args.model_name == 'model12': # stretch = 2000, Q = 0.5\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n max_number = 6\\n elif Args.model_name == 'model12_again': # stretch = 2000, Q = 0.5 # larger learning rate\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n max_number = 10 # changed from 6 to 10 for run 4\\n elif Args.model_name == 'model12_again2': # stretch = 2000, Q = 0.5 # larger learning rate val set reduced to 10\\n resid_model.config.TRAIN_BN = False\\n resid_model.config.BACKBONE = 'resnet41'\\n resid_model.config.SKIP_P2_RPN = True\\n resid_model.config.BACKBONE_STRIDES = [8, 16, 32, 64]\\n resid_model.config.RPN_ANCHOR_SCALES = (8, 16, 32, 64)\\n sampling_function = btk_utils.resid_general_sampling_function_large\\n layers = 'all'\\n norm = [0., 1.45, 0, 1.] # [0, 1, 0, 1]\\n input_pull = True\\n input_model_mapping = True\\n max_number = 6\\n resid_model.config.VALIDATION_STEPS = 10\\n else:\\n raise AttributeError(\\\"model not found\\\", Args.model_name)\\n print(\\\"Train in model:\\\", Args.model_name)\\n resid_model.config.display()\\n resid_model.make_resid_model(catalog_name, count=count,\\n max_number=max_number, augmentation=True,\\n norm_val=norm, input_pull=input_pull,\\n sampling_function=sampling_function,\\n input_model_mapping=input_model_mapping)\\n learning_rate = resid_model.config.LEARNING_RATE/10.\\n np.random.seed(Args.epochs)\\n history = resid_model.model.train(resid_model.dataset,\\n resid_model.dataset_val,\\n learning_rate=learning_rate,\\n epochs=Args.epochs,\\n layers=layers)\\n name = Args.model_name + '_run2'\\n with open(name + \\\".dill\\\", 'wb') as handle:\\n dill.dump(history.history, handle)\\n learning_rate = resid_model.config.LEARNING_RATE/10.\\n np.random.seed(Args.epochs + 10)\\n history = resid_model.model.train(resid_model.dataset,\\n resid_model.dataset_val,\\n learning_rate=learning_rate,\\n epochs=Args.epochs+10,\\n layers=layers)\\n name = Args.model_name + '_run3'\\n with open(name + \\\".dill\\\", 'wb') as handle:\\n dill.dump(history.history, handle)\",\n \"def train_keras():\\n epochs = 2\\n strategy = tf.distribute.MirroredStrategy()\\n global_batch_size = strategy.num_replicas_in_sync * 32\\n train_dataset = create_dataset(global_batch_size)\\n\\n with strategy.scope():\\n model = ResNet50(input_shape=(224, 224, 3), num_classes=1000)\\n model.compile(loss=tf.keras.losses.CategoricalCrossentropy(),\\n optimizer=tf.keras.optimizers.Adam(),\\n metrics=['accuracy'])\\n model.fit(train_dataset, epochs=epochs)\",\n \"def configure_training_centralized(\\n task_spec: training_specs.TaskSpecCentralized,\\n *, # Caller passes below args by name.\\n resnet_layers: int = 18,\\n num_classes: int = 100,\\n l2_weight_decay: float = 1e-4,\\n) -> training_specs.RunnerSpecCentralized:\\n\\n return _Cifar100ImageTask(\\n task_spec,\\n resnet_layers=resnet_layers,\\n num_classes=num_classes,\\n l2_weight_decay=l2_weight_decay).build_centralized_runner_spec()\",\n \"def load_dataset_cifar10():\\n dirname = 'cifar-10-batches-py'\\n origin = 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'\\n path = get_file(dirname, origin=origin, untar=True)\\n\\n num_train_samples = 50000\\n\\n x_train = np.empty((num_train_samples, 3, 32, 32), dtype='uint8')\\n y_train = np.empty((num_train_samples,), dtype='uint8')\\n\\n for i in range(1, 6):\\n fpath = os.path.join(path, 'data_batch_' + str(i))\\n (x_train[(i - 1) * 10000: i * 10000, :, :, :],\\n y_train[(i - 1) * 10000: i * 10000]) = load_batch(fpath)\\n\\n fpath = os.path.join(path, 'test_batch')\\n x_test, y_test = load_batch(fpath)\\n\\n y_train = np.reshape(y_train, (len(y_train), 1))\\n y_test = np.reshape(y_test, (len(y_test), 1))\\n\\n return (x_train, y_train), (x_test, y_test)\",\n \"def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\\n # Load the raw CIFAR-10 data\\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\\n\\n # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\\n try:\\n del X_train, y_train\\n del X_test, y_test\\n print('Clear previously loaded data.')\\n except:\\n pass\\n\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\n\\n # Subsample the data\\n mask = list(range(num_training, num_training + num_validation))\\n X_val = X_train[mask]\\n y_val = y_train[mask]\\n mask = list(range(num_training))\\n X_train = X_train[mask]\\n y_train = y_train[mask]\\n mask = list(range(num_test))\\n X_test = X_test[mask]\\n y_test = y_test[mask]\\n\\n # Normalize the data: subtract the mean image\\n mean_image = np.mean(X_train, axis=0)\\n X_train -= mean_image\\n X_val -= mean_image\\n X_test -= mean_image\\n\\n # Reshape data to rows\\n X_train = X_train.reshape(num_training, -1)\\n X_val = X_val.reshape(num_validation, -1)\\n X_test = X_test.reshape(num_test, -1)\\n\\n return X_train, y_train, X_val, y_val, X_test, y_test\",\n \"def train(self):\\n if not os.path.isdir(self.C.log_path):\\n os.mkdir(self.C.log_path)\\n \\n callback = TensorBoard(self.C.log_path, write_graph=True, write_images=True)\\n callback.set_model(self.model_all)\\n\\n epoch_length = self.C.epoch_length\\n epochs = self.C.epochs\\n iter_num = 0\\n train_step = 0\\n\\n losses = np.zeros((epoch_length, 5))\\n rpn_accuracy_monitor = []\\n rpn_accuracy_epoch = []\\n best_loss = np.Inf\\n start_time = time.time()\\n\\n for epoch in range(epochs):\\n progbar = generic_utils.Progbar(epoch_length)\\n print('Epoch {}/{}'.format(epoch + 1, epochs))\\n\\n while True:\\n if len(rpn_accuracy_monitor) == epoch_length and self.C.verbose:\\n mean_overlapping_bboxes = float(sum(rpn_accuracy_monitor)) / len(rpn_accuracy_monitor)\\n rpn_accuracy_monitor = []\\n print('Average number of overlapping bounding boxes from RPN = {} for {} previous iterations'.format(mean_overlapping_bboxes, epoch_length))\\n if mean_overlapping_bboxes == 0:\\n print('RPN is not producing bounding boxes that overlap the ground truth boxes. Check RPN settings or keep training.')\\n\\n # data generator\\n X, Y, img_data = next(self.data_gen_train)\\n\\n loss_rpn = self.model_region_proposal.train_on_batch(X, Y)\\n self._write_log(callback, ['rpn_cls_loss', 'rpn_reg_loss'], loss_rpn, train_step)\\n\\n P_rpn = self.model_region_proposal.predict_on_batch(X)\\n\\n R = roi_helpers.rpn_to_roi(P_rpn[0], P_rpn[1], self.C, K.image_data_format(), use_regr=True, overlap_thresh=0.7, max_boxes=300)\\n # note: calc_iou converts from (x1,y1,x2,y2) to (x,y,w,h) format\\n X2, Y1, Y2, IouS = roi_helpers.calc_iou(R, img_data, self.C, self.class_mapping)\\n\\n if X2 is None:\\n rpn_accuracy_monitor.append(0)\\n rpn_accuracy_epoch.append(0)\\n continue\\n \\n # sampling positive/negative samples\\n neg_samples = np.where(Y1[0, :, -1] == 1)\\n pos_samples = np.where(Y1[0, :, -1] == 0)\\n\\n if len(neg_samples) > 0:\\n neg_samples = neg_samples[0]\\n else:\\n neg_samples = []\\n\\n if len(pos_samples) > 0:\\n pos_samples = pos_samples[0]\\n else:\\n pos_samples = []\\n\\n rpn_accuracy_monitor.append(len(pos_samples))\\n rpn_accuracy_epoch.append((len(pos_samples)))\\n\\n if self.C.num_roi > 1:\\n if len(pos_samples) < self.C.num_roi//2:\\n selected_pos_samples = pos_samples.tolist()\\n else:\\n selected_pos_samples = np.random.choice(pos_samples, \\n self.C.num_roi//2, \\n replace=False).tolist()\\n try:\\n selected_neg_samples = np.random.choice(neg_samples, \\n self.C.num_roi-len(selected_pos_samples), \\n replace=False).tolist()\\n except:\\n selected_neg_samples = np.random.choice(neg_samples, \\n self.C.num_roi-len(selected_pos_samples), \\n replace=True).tolist()\\n sel_samples = selected_pos_samples + selected_neg_samples\\n \\n else:\\n # in the extreme case where num_roi = 1, we pick a random pos or neg sample\\n selected_pos_samples = pos_samples.tolist()\\n selected_neg_samples = neg_samples.tolist()\\n if np.random.randint(0, 2):\\n sel_samples = random.choice(neg_samples)\\n else:\\n sel_samples = random.choice(pos_samples)\\n\\n loss_class = self.model_classifier.train_on_batch([X, X2[:, sel_samples, :]], \\n [Y1[:, sel_samples, :], \\n Y2[:, sel_samples, :]])\\n self._write_log(callback, \\n ['detection_cls_loss', 'detection_reg_loss', 'detection_acc'], \\n loss_class, train_step)\\n train_step += 1\\n\\n losses[iter_num, 0] = loss_rpn[1]\\n losses[iter_num, 1] = loss_rpn[2]\\n losses[iter_num, 2] = loss_class[1]\\n losses[iter_num, 3] = loss_class[2]\\n losses[iter_num, 4] = loss_class[3]\\n\\n iter_num += 1\\n\\n progbar.update(iter_num, \\n [('rpn_cls', np.mean(losses[:iter_num, 0])), \\n ('rpn_regr', np.mean(losses[:iter_num, 1])),\\n ('det_cls', np.mean(losses[:iter_num, 2])), \\n ('det_regr', np.mean(losses[:iter_num, 3]))])\\n\\n if iter_num == epoch_length:\\n loss_rpn_cls = np.mean(losses[:, 0])\\n loss_rpn_regr = np.mean(losses[:, 1])\\n loss_class_cls = np.mean(losses[:, 2])\\n loss_class_regr = np.mean(losses[:, 3])\\n class_acc = np.mean(losses[:, 4])\\n\\n mean_overlapping_bboxes = float(sum(rpn_accuracy_epoch)) / len(rpn_accuracy_epoch)\\n rpn_accuracy_epoch = []\\n\\n if self.C.verbose:\\n print('Mean number of bounding boxes from RPN overlapping ground truth boxes: {}'.format(mean_overlapping_bboxes))\\n print('Classifier accuracy for bounding boxes from RPN: {}'.format(class_acc))\\n print('Loss RPN classifier: {}'.format(loss_rpn_cls))\\n print('Loss RPN regression: {}'.format(loss_rpn_regr))\\n print('Loss Detector classifier: {}'.format(loss_class_cls))\\n print('Loss Detector regression: {}'.format(loss_class_regr))\\n print('Elapsed time: {}'.format(time.time() - start_time))\\n\\n curr_loss = loss_rpn_cls + loss_rpn_regr + loss_class_cls + loss_class_regr\\n iter_num = 0\\n start_time = time.time()\\n\\n self._write_log(callback,\\n ['Elapsed_time', 'mean_overlapping_bboxes', 'mean_rpn_cls_loss', \\n 'mean_rpn_reg_loss', 'mean_detection_cls_loss', 'mean_detection_reg_loss', \\n 'mean_detection_acc', 'total_loss'],\\n [time.time() - start_time, mean_overlapping_bboxes, loss_rpn_cls, \\n loss_rpn_regr, loss_class_cls, loss_class_regr, class_acc, curr_loss],\\n epoch)\\n\\n if curr_loss < best_loss:\\n if self.C.verbose:\\n print('Total loss decreased from {} to {}, saving weights'.format(best_loss,curr_loss))\\n best_loss = curr_loss\\n self.model_all.save_weights(self.C.model_path)\\n break\\n \\n print(\\\"traing completed.\\\")\",\n \"def _train(args): \\n\\n #device = 'cuda' if torch.cuda.is_available() else 'cpu'\\n device = 'cpu'\\n logger.info(\\\"Device Type: {}\\\".format(device))\\n\\n logger.info(\\\"Loading SUN360 dataset\\\")\\n transform = transforms.Compose(\\n [transforms.Resize((224,224)),\\n transforms.ToTensor(),\\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\\n target_transform = transforms.Compose([transforms.Resize((224,224)),\\n transforms.ToTensor()]) \\n\\n trainset = SUN360Dataset(\\\"imagedata.json\\\",transform = transform, target_transform = target_transform)\\n train_loader = DataLoader(trainset, batch_size=args.batch_size,\\n shuffle=True, num_workers=args.workers)\\n \\\"\\\"\\\"\\n testset = torchvision.datasets.CIFAR10(root=args.data_dir, train=False,\\n download=False, transform=transform)\\n test_loader = DataLoader(testset, batch_size=args.batch_size,\\n shuffle=False, num_workers=args.workers)\\n \\\"\\\"\\\" \\n\\n logger.info(\\\"Model loaded\\\")\\n model = EfficientNet.from_name('efficientnet-b0',conv_type='Equi')\\n\\n if torch.cuda.device_count() > 1:\\n logger.info(\\\"Gpu count: {}\\\".format(torch.cuda.device_count()))\\n model = nn.DataParallel(model)\\n\\n model = model.to(device)\\n\\n criterion = CELoss().to(device)\\n optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)\\n\\n for epoch in range(0, args.epochs):\\n running_loss = 0.0\\n for i, data in enumerate(train_loader):\\n # get the inputs\\n inputs, EM , CM = data\\n inputs, EM, CM = inputs.to(device), EM.to(device), CM.to(device)\\n\\n # zero the parameter gradients\\n optimizer.zero_grad()\\n\\n # forward + backward + optimize\\n outputs = model(inputs)\\n EMLoss, CMLoss = map_loss(outputs,EM,CM,criterion)\\n loss = EMLoss + CMLoss\\n loss.backward()\\n optimizer.step()\\n\\n # print statistics\\n running_loss += loss.item()\\n if i % 2000 == 1999: # print every 2000 mini-batches\\n print('[%d, %5d] loss: %.3f' %\\n (epoch + 1, i + 1, running_loss / 2000))\\n running_loss = 0.0\\n print('Finished Training')\\n return _save_model(model, args.model_dir)\",\n \"def train_one_epoch(self):\\n print('Training......')\\n\\n # set mode train\\n self.network.train()\\n\\n # prepare data\\n train_loss = 0\\n transform = transforms.Compose([Rescale(params.rescale_size),\\n RandomCrop(params.image_size),\\n RandomHorizontalFlip(),\\n ToTensor()\\n ])\\n\\n\\n\\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\\n\\n train_loader = DataLoader(dataset,\\n batch_size=params.train_batch,\\n shuffle=params.shuffle,\\n num_workers=params.dataloader_workers)\\n \\n train_size = 1896\\n if train_size % self.params.train_batch != 0:\\n total_batch = train_size // self.params.train_batch + 1\\n else:\\n total_batch = train_size // self.params.train_batch\\n recal = 0\\n precision = 0\\n F_one = 0\\n IOU = 0\\n accuracy_new = 0 \\n # train through dataset\\n for batch_idx, batch in enumerate(train_loader):\\n self.pb.click(batch_idx, total_batch)\\n image, label = batch['image'], batch['label']\\n image_cuda, label_cuda = image.cuda(), label.cuda()\\n\\n # checkpoint split\\n if self.params.should_split:\\n image_cuda.requires_grad_()\\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\\n else:\\n out = self.network(image_cuda)\\n\\n\\n loss = self.loss_fn(out, label_cuda)\\n \\n #display_image(out, label_cuda)\\n TP, FP, TN, FN = confusion(out, label_cuda)\\n recal = recal+TP\\n precision = precision+FP\\n F_one = F_one + TN\\n IOU = IOU+ FN \\n accuracy_final = accuracy(out, label_cuda)\\n accuracy_new = accuracy_new + accuracy_final\\n\\n # optimize\\n self.opt.zero_grad()\\n loss.backward()\\n self.opt.step()\\n\\n # accumulate\\n train_loss += loss.item()\\n\\n # record first loss\\n if self.train_loss == []:\\n self.train_loss.append(train_loss)\\n self.summary_writer.add_scalar('loss/train_loss', train_loss, 0)\\n \\n print(\\\"\\\\t\\\")\\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\\n print(accuracy_new/total_batch)\\n \\n self.pb.close()\\n train_loss /= total_batch\\n self.train_loss.append(train_loss)\\n\\n # add to summary\\n self.summary_writer.add_scalar('loss/train_loss', train_loss, self.epoch)\",\n \"def run_rfc():\\n num_folds = 5\\n with pd.HDFStore('./OT_clr_train_LGG_grade.h5') as store:\\n X = store['expression'].values\\n Y = store['labels'].values\\n\\n # standardize expression\\n mu = np.mean(X,axis=0)\\n std = np.std(X, axis=0)\\n X = (X-mu)/std\\n\\n # define Predictor object to manage nested CV\\n rf_predictor = Predictor(\\n CVmodel(RandomForestClassifier_skl,[4,8,16,32,64,128], 'max_depth',\\n n_estimators=100, n_jobs=-1),\\n scorers.accuracy_scorer)\\n # cross validate\\n rf_cross_validation_scores = \\\\\\n rf_predictor.cross_validate(X, Y,\\n outer_folds=num_folds, inner_folds=num_folds)\\n logger.info('Random Forest cross-validation = {0:.3f}'.format(\\n np.mean(rf_cross_validation_scores)))\",\n \"def train():\\r\\n print('Loading and compiling models...')\\r\\n model_systole = get_model()\\r\\n model_diastole = get_model()\\r\\n\\r\\n # load the preprocessed data with the heart cut-out\\r\\n print('Loading data...')\\r\\n X_train, scaling_train, ids_train, y_train = load_train_data()\\r\\n X_test, scaling_test, ids_test, y_test = load_test_data()\\r\\n\\r\\n nb_iter = 200 # a higher number seems to give rise to overfitting\\r\\n epochs_per_iter = 3 # reduces overfitting\\r\\n batch_size = 32 # not tuned - potential improvement\\r\\n calc_crps = 2 # calculate CRPS every n-th iteration (set to 0 if CRPS estimation is not needed)\\r\\n\\r\\n # remember min val. losses (best iterations), used as sigmas for submission\\r\\n min_val_loss_systole = sys.float_info.max\\r\\n min_val_loss_diastole = sys.float_info.max\\r\\n\\r\\n print('-'*50)\\r\\n print('Training...')\\r\\n print('-'*50)\\r\\n\\r\\n for i in range(nb_iter):\\r\\n print('-'*50)\\r\\n print('Iteration {0}/{1}'.format(i + 1, nb_iter))\\r\\n print('-'*50)\\r\\n\\r\\n # augment data to make up for low number of samples\\r\\n print('Augmenting images - rotations')\\r\\n X_train_aug = rotation_augmentation(X_train, 15)\\r\\n print('Augmenting images - shifts')\\r\\n X_train_aug = shift_augmentation(X_train_aug, 0.1, 0.1)\\r\\n\\r\\n print('Fitting systole model...')\\r\\n hist_systole = model_systole.fit([X_train_aug, scaling_train], y_train[:, 0], shuffle=True, nb_epoch=epochs_per_iter,\\r\\n batch_size=batch_size, validation_data=([X_test, scaling_test], y_test[:, 0]))\\r\\n\\r\\n print('Fitting diastole model...')\\r\\n hist_diastole = model_diastole.fit([X_train_aug, scaling_train], y_train[:, 1], shuffle=True, nb_epoch=epochs_per_iter,\\r\\n batch_size=batch_size, validation_data=([X_test, scaling_test], y_test[:, 1]))\\r\\n\\r\\n # sigmas for predicted data, actually loss function values (RMSE)\\r\\n loss_systole = hist_systole.history['loss'][-1]\\r\\n loss_diastole = hist_diastole.history['loss'][-1]\\r\\n val_loss_systole = hist_systole.history['val_loss'][-1]\\r\\n val_loss_diastole = hist_diastole.history['val_loss'][-1]\\r\\n\\r\\n if calc_crps > 0 and i % calc_crps == 0:\\r\\n print('Evaluating CRPS...')\\r\\n pred_systole = model_systole.predict([X_train, scaling_train], batch_size=batch_size, verbose=1)\\r\\n pred_diastole = model_diastole.predict([X_train, scaling_train], batch_size=batch_size, verbose=1)\\r\\n val_pred_systole = model_systole.predict([X_test, scaling_test], batch_size=batch_size, verbose=1)\\r\\n val_pred_diastole = model_diastole.predict([X_test, scaling_test], batch_size=batch_size, verbose=1)\\r\\n\\r\\n # CDF for train and test data (actually a step function)\\r\\n cdf_train = real_to_cdf(np.concatenate((y_train[:, 0], y_train[:, 1])))\\r\\n cdf_test = real_to_cdf(np.concatenate((y_test[:, 0], y_test[:, 1])))\\r\\n\\r\\n # CDF for predicted data\\r\\n cdf_pred_systole = real_to_cdf(pred_systole, loss_systole)\\r\\n cdf_pred_diastole = real_to_cdf(pred_diastole, loss_diastole)\\r\\n cdf_val_pred_systole = real_to_cdf(val_pred_systole, val_loss_systole)\\r\\n cdf_val_pred_diastole = real_to_cdf(val_pred_diastole, val_loss_diastole)\\r\\n\\r\\n # evaluate CRPS on training data\\r\\n crps_train = crps(cdf_train, np.concatenate((cdf_pred_systole, cdf_pred_diastole)))\\r\\n print('CRPS(train) = {0}'.format(crps_train))\\r\\n\\r\\n # evaluate CRPS on test data\\r\\n crps_test = crps(cdf_test, np.concatenate((cdf_val_pred_systole, cdf_val_pred_diastole)))\\r\\n print('CRPS(test) = {0}'.format(crps_test))\\r\\n\\r\\n print('Saving weights...')\\r\\n # save weights so they can be loaded later\\r\\n model_systole.save_weights('weights_systole.hdf5', overwrite=True)\\r\\n model_diastole.save_weights('weights_diastole.hdf5', overwrite=True)\\r\\n\\r\\n # for best (lowest) val losses, save weights\\r\\n if val_loss_systole < min_val_loss_systole:\\r\\n min_val_loss_systole = val_loss_systole\\r\\n model_systole.save_weights('weights_systole_best.hdf5', overwrite=True)\\r\\n\\r\\n if val_loss_diastole < min_val_loss_diastole:\\r\\n min_val_loss_diastole = val_loss_diastole\\r\\n model_diastole.save_weights('weights_diastole_best.hdf5', overwrite=True)\\r\\n\\r\\n # save best (lowest) val losses in file (to be later used for generating submission)\\r\\n with open('val_loss.txt', mode='w+') as f:\\r\\n f.write(str(min_val_loss_systole))\\r\\n f.write('\\\\n')\\r\\n f.write(str(min_val_loss_diastole))\",\n \"def build_resnet152(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\\n conv1_feats = nonlinear(conv1_feats, 'relu')\\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\\n\\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\\n \\n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \\n temp = res3a_feats\\n for i in range(1, 8):\\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\\n res3b7_feats = temp\\n \\n res4a_feats = self.basic_block(res3b7_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\\n temp = res4a_feats\\n for i in range(1, 36):\\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\\n res4b35_feats = temp\\n\\n res5a_feats = self.basic_block(res4b35_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\\n\\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\\n self.conv_feats = res5c_feats_flat\\n self.conv_feat_shape = [49, 2048]\\n self.num_ctx = 49 \\n self.dim_ctx = 2048\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def ffc_resnet101(pretrained=False, **kwargs):\\n model = FFCResNet(Bottleneck, [3, 4, 23, 3], **kwargs)\\n return model\",\n \"def cifar10_bin_model_fn(features, labels, mode, params):\\n\\n network = resnet_model.cifar10_resnet_v2_generator(\\n params['resnet_size'], _NUM_CLASSES, params['data_format']\\n )\\n\\n inputs = tf.reshape(features, [-1, _HEIGHT, _WIDTH, _DEPTH])\\n clabels = labels[:, :_NUM_CLASSES]\\n \\n # logits = network(inputs, mode == tf.estimator.ModeKeys.TRAIN)\\n logits = network(inputs, mode == tf.estimator.ModeKeys.TRAIN, name=\\\"main\\\")\\n probs = tf.sigmoid(logits)\\n\\n # slabels, smask = smooth_neg_labels(clabels, params[\\\"cutoff_weight\\\"], params[\\\"pen_prob\\\"])\\n # slabels, smask = smooth_neg_labels(clabels, 1*1/_NUM_CLASSES, 0.45)\\n bt_loss = tf.reduce_mean(per_class_bin_loss(probs, clabels, params[\\\"milden\\\"]), axis=1)\\n\\n loss = tf.reduce_mean(bt_loss, axis=0)\\n loss = tf.identity(loss, name=\\\"loss_vec\\\")\\n loss_sum = tf.summary.scalar(\\\"loss\\\", loss)\\n\\n probs_cal = tf.sigmoid(logits/params[\\\"temp\\\"])\\n rate = tf.reduce_max(probs_cal, axis=1)\\n\\n # loss = tf.Print(loss, [smask], summarize=100, message=\\\"smask: \\\")\\n # loss = tf.Print(loss, [tf.reduce_mean(probs)], summarize=100, message=\\\"mean: \\\")\\n # loss = tf.Print(loss, [rate], summarize=100, message=\\\"rate: \\\")\\n # loss = tf.Print(loss, [clabels, slabels], summarize=100, message=\\\"slabels: \\\")\\n\\n classes = tf.argmax(logits, axis=1)\\n accuracy_m = tf.metrics.accuracy( tf.argmax(clabels, axis=1), classes, name=\\\"accuracy_metric\\\")\\n accuracy = tf.identity(accuracy_m[1], name=\\\"accuracy_vec\\\")\\n accuracy_sum = tf.summary.scalar(\\\"accuracy\\\", accuracy)\\n\\n if mode == tf.estimator.ModeKeys.EVAL or params[\\\"predict\\\"]:\\n\\n # print # note this is labels not clabels\\n print_labels = tf.argmax(labels, axis=1)\\n print_rate = rate\\n print_probs = probs\\n print_logits = logits\\n\\n hooks = []\\n eval_metric_ops = { \\\"accuracy\\\": accuracy_m }\\n\\n # # printing stuff if predict\\n if params[\\\"predict\\\"]:\\n loss = tf.Print(loss, [print_labels], summarize=1000000, message='Targets')\\n loss = tf.Print(loss, [print_rate], summarize=1000000, message='Rate')\\n loss = tf.Print(loss, [print_probs], summarize=1000000, message='Probs')\\n loss = tf.Print(loss, [print_logits], summarize=1000000, message='Logits')\\n hooks = []\\n eval_metric_ops = {}\\n\\n return tf.estimator.EstimatorSpec(\\n mode=mode,\\n loss=loss,\\n eval_metric_ops = eval_metric_ops,\\n # evaluation_hooks=hooks,\\n )\\n\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n # Scale the learning rate linearly with the batch size. When the batch size\\n # is 128, the learning rate should be 0.1.\\n initial_learning_rate = 0.1 * params['batch_size'] / 128\\n batches_per_epoch = _NUM_IMAGES['train'] / params['batch_size']\\n global_step = tf.train.get_or_create_global_step()\\n\\n # Multiply the learning rate by 0.1 at 100, 150, and 200 epochs.\\n boundaries = [int(batches_per_epoch * epoch) for epoch in [100, 150, 200]]\\n values = [initial_learning_rate * decay for decay in [1, 0.1, 0.01, 0.001]]\\n learning_rate = tf.train.piecewise_constant(\\n tf.cast(global_step, tf.int32), boundaries, values, name=\\\"learning_rate_vec\\\")\\n\\n learning_rate_sum = tf.summary.scalar(\\\"learning_rate\\\", learning_rate)\\n\\n optimizer = tf.train.MomentumOptimizer(\\n learning_rate=learning_rate,\\n momentum=_MOMENTUM\\n )\\n\\n # Batch norm requires update ops to be added as a dependency to the train_op\\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n with tf.control_dependencies(update_ops):\\n train_op = optimizer.minimize(loss, global_step)\\n\\n hook = tf.train.SummarySaverHook(\\n summary_op=tf.summary.merge([accuracy_sum, learning_rate_sum]),\\n save_steps=1,\\n )\\n return tf.estimator.EstimatorSpec(\\n mode=mode,\\n loss=loss,\\n train_op=train_op,\\n training_hooks=[hook],\\n )\",\n \"def grid_search(train_labels: str, \\n test_labels: str, \\n output:str, \\n res:tuple=(120, 160), \\n lazy:bool=True, \\n batch_size:int=16, \\n epochs:int=20):\\n\\n # Data\\n print(\\\"=> Loading data.\\\")\\n train = FLIRDataset(train_labels, res=res, batch_size=batch_size)\\n test = FLIRDataset(test_labels, res=res, batch_size=batch_size)\\n\\n # In eager loading mode, train on everything.\\n if not lazy:\\n X_train, y_train = train.get_all()\\n X_test, y_test = test.get_all()\\n X_train = np.concatenate([X_train, X_test], axis=0)\\n y_train = np.concatenate([y_train, y_test], axis=0)\\n\\n\\n def net(x, num_classes=1):\\n x = K.applications.resnet_v2.ResNet50V2(include_top=False, weights=None, input_shape=x.shape[1:])(x)\\n x = K.layers.Flatten()(x)\\n x = K.layers.Dense(num_classes, activation=\\\"softmax\\\")(x)\\n return x\\n\\n print(\\\"\\\\n=> Training model.\\\")\\n input_tensor = K.layers.Input((160, 120, 1))\\n output_tensor = net(input_tensor, num_classes=train.num_classes())\\n model = K.Model(input_tensor, output_tensor)\\n\\n model.compile(optimizer=\\\"sgd\\\",\\n loss=\\\"categorical_crossentropy\\\",\\n metrics=[\\\"accuracy\\\"])\\n\\n # Train model\\n if lazy:\\n model.fit(x=train, \\n epochs=epochs, \\n validation_data=train, \\n verbose=2)\\n else:\\n model.fit(x=X_train, \\n y=y_train, \\n epochs=epochs, \\n batch_size=batch_size, \\n verbose=2)\\n\\n # Save weights\\n model.save_weights(os.path.join(output, \\\"flir_pretrained_weights.h5\\\"))\",\n \"def main():\\n logger.info(\\\"=> creating model ...\\\")\\n logger.info(\\\"Classes: %s\\\", cfg.classes)\\n\\n value_scale = 255\\n mean = [0.485, 0.456, 0.406]\\n mean = [item * value_scale for item in mean]\\n std = [0.229, 0.224, 0.225]\\n std = [item * value_scale for item in std]\\n gray_folder = os.path.join(cfg.result_path, 'gray')\\n color_folder = os.path.join(cfg.result_path, 'color')\\n\\n test_transform = pt_transform.Compose([pt_transform.Normalize(mean=mean, std=std, is_train=False)])\\n\\n if cfg.data_root[-1] == \\\"/\\\":\\n val_list = cfg.data_root + cfg.val_list\\n else:\\n val_list = cfg.data_root + '/' + cfg.val_list\\n\\n test_data = pt_dataset.SemData(\\n split='val', data_root=cfg.data_root,\\n data_list=val_list,\\n transform=test_transform)\\n\\n test_loader = ds.GeneratorDataset(test_data, column_names=[\\\"data\\\", \\\"label\\\"],\\n shuffle=False)\\n test_loader.batch(1)\\n colors = numpy.loadtxt(cfg.color_txt).astype('uint8')\\n\\n from src.model import cpnet\\n\\n CPNet = cpnet.CPNet(\\n prior_channels=256,\\n proir__size=60,\\n am_kernel_size=11,\\n pretrained=True,\\n pretrained_path=cfg.pretrain_path,\\n deep_base=True\\n )\\n\\n ms_checkpoint = load_checkpoint(cfg.ckpt)\\n load_param_into_net(CPNet, ms_checkpoint, strict_load=True)\\n CPNet.set_train(False)\\n test(test_loader, test_data.data_list, CPNet, cfg.classes, mean, std, cfg.base_size, cfg.test_h,\\n cfg.test_w, cfg.scales, gray_folder, color_folder, colors)\\n if cfg.split != 'test':\\n cal_acc(test_data.data_list, gray_folder, cfg.classes)\",\n \"def main(configuration_path, mode):\\n config = toml.load(configuration_path)\\n train_conf = read_config(config)\\n\\n click.echo(\\\"\\\\n Train config:\\\")\\n print(train_conf, \\\"\\\\n\\\")\\n\\n # create databunch\\n data = create_databunch(\\n data_path=train_conf[\\\"data_path\\\"],\\n fourier=train_conf[\\\"fourier\\\"],\\n batch_size=train_conf[\\\"batch_size\\\"],\\n )\\n\\n # get image size\\n train_conf[\\\"image_size\\\"] = data.train_ds[0][0][0].shape[1]\\n\\n # define architecture\\n arch = define_arch(\\n arch_name=train_conf[\\\"arch_name\\\"], img_size=train_conf[\\\"image_size\\\"]\\n )\\n\\n if mode == \\\"train\\\":\\n if train_conf[\\\"normalize\\\"] == \\\"mean\\\":\\n train_conf[\\\"norm_factors\\\"] = get_normalisation_factors(data)\\n # check out path and look for existing model files\\n check_outpath(train_conf[\\\"model_path\\\"], train_conf)\\n\\n click.echo(\\\"Start training of the model.\\\\n\\\")\\n\\n # define_learner\\n learn = define_learner(data, arch, train_conf)\\n\\n # load pretrained model\\n if train_conf[\\\"pre_model\\\"] != \\\"none\\\":\\n learn.create_opt()\\n load_pre_model(learn, train_conf[\\\"pre_model\\\"])\\n\\n # Train the model, except interrupt\\n # train_conf[\\\"comet_ml\\\"] = True\\n try:\\n if train_conf[\\\"comet_ml\\\"]:\\n learn.comet.experiment.log_parameters(train_conf)\\n with learn.comet.experiment.train():\\n learn.fit(train_conf[\\\"num_epochs\\\"])\\n else:\\n learn.fit(train_conf[\\\"num_epochs\\\"])\\n except KeyboardInterrupt:\\n pop_interrupt(learn, train_conf)\\n\\n end_training(learn, train_conf)\\n\\n if train_conf[\\\"inspection\\\"]:\\n after_training_plots(train_conf, rand=True)\\n\\n if mode == \\\"fine_tune\\\":\\n click.echo(\\\"Start fine tuning of the model.\\\\n\\\")\\n\\n # define_learner\\n learn = define_learner(\\n data,\\n arch,\\n train_conf,\\n )\\n\\n # load pretrained model\\n if train_conf[\\\"pre_model\\\"] == \\\"none\\\":\\n click.echo(\\\"Need a pre-trained modle for fine tuning!\\\")\\n return\\n\\n learn.create_opt()\\n load_pre_model(learn, train_conf[\\\"pre_model\\\"])\\n\\n # Train the model, except interrupt\\n try:\\n learn.fine_tune(train_conf[\\\"num_epochs\\\"])\\n except KeyboardInterrupt:\\n pop_interrupt(learn, train_conf)\\n\\n end_training(learn, train_conf)\\n if train_conf[\\\"inspection\\\"]:\\n after_training_plots(train_conf, rand=True)\\n\\n if mode == \\\"lr_find\\\":\\n click.echo(\\\"Start lr_find.\\\\n\\\")\\n if train_conf[\\\"normalize\\\"] == \\\"mean\\\":\\n train_conf[\\\"norm_factors\\\"] = get_normalisation_factors(data)\\n\\n # define_learner\\n learn = define_learner(data, arch, train_conf, lr_find=True)\\n\\n # load pretrained model\\n if train_conf[\\\"pre_model\\\"] != \\\"none\\\":\\n learn.create_opt()\\n load_pre_model(learn, train_conf[\\\"pre_model\\\"])\\n\\n learn.lr_find()\\n\\n # save loss plot\\n plot_lr_loss(\\n learn,\\n train_conf[\\\"arch_name\\\"],\\n Path(train_conf[\\\"model_path\\\"]).parent,\\n skip_last=5,\\n output_format=train_conf[\\\"format\\\"],\\n )\\n\\n if mode == \\\"plot_loss\\\":\\n click.echo(\\\"Start plotting loss.\\\\n\\\")\\n\\n # define_learner\\n learn = define_learner(data, arch, train_conf, plot_loss=True)\\n # load pretrained model\\n if Path(train_conf[\\\"model_path\\\"]).exists:\\n load_pre_model(learn, train_conf[\\\"model_path\\\"], plot_loss=True)\\n else:\\n click.echo(\\\"Selected model does not exist.\\\")\\n click.echo(\\\"Exiting.\\\\n\\\")\\n sys.exit()\\n\\n plot_lr(\\n learn, Path(train_conf[\\\"model_path\\\"]), output_format=train_conf[\\\"format\\\"]\\n )\\n plot_loss(\\n learn, Path(train_conf[\\\"model_path\\\"]), output_format=train_conf[\\\"format\\\"]\\n )\",\n \"def train():\\n with tf.Graph().as_default():\\n #global_step = tf.contrib.framework.get_or_create_global_step()\\n scope_1, scope_2 = \\\"parameters_1\\\", \\\"parameters_2\\\"\\n\\n with tf.variable_scope(scope_1):\\n #images_1, labels_1 = cifar10.inputs(False)\\n images_1 = tf.placeholder(tf.float32, shape=(None, cifar10.IMAGE_SIZE, cifar10.IMAGE_SIZE, 3))\\n labels_1 = tf.placeholder(tf.int32, shape=(None,))\\n logits_1 = cifar10.inference(images_1)\\n loss_1 = cifar10.loss(logits_1, labels_1, scope_1)\\n train_op_1 = cifar10.train(loss_1, scope_1)\\n top_k_op_1 = tf.nn.in_top_k(logits_1, labels_1, 1)\\n\\n with tf.variable_scope(scope_2):\\n #images_2, labels_2 = cifar10.inputs(False)\\n images_2 = tf.placeholder(tf.float32, shape=(None, cifar10.IMAGE_SIZE, cifar10.IMAGE_SIZE, 3))\\n labels_2 = tf.placeholder(tf.int32, shape=(None,))\\n logits_2 = cifar10.inference(images_2)\\n loss_2 = cifar10.loss(logits_2, labels_2, scope_2)\\n train_op_2 = cifar10.train(loss_2, scope_2)\\n top_k_op_2 = tf.nn.in_top_k(logits_2, labels_2, 1)\\n\\n variables_1 = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=\\\"parameters_1\\\")\\n variables_2 = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=\\\"parameters_2\\\")\\n assert(len(variables_1) == len(variables_2))\\n\\n images_raw, labels_raw, images_test_raw, labels_test_raw = load_cifar_data_raw()\\n assert(images_raw.shape[0] == cifar10.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN)\\n assert(images_test_raw.shape[0] == cifar10.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL)\\n\\n with tf.Session() as mon_sess:\\n\\n tf.initialize_all_variables().run()\\n tf.train.start_queue_runners(sess=mon_sess)\\n\\n # First we make sure the parameters of the two models are the same.\\n print(\\\"Making sure models have the same initial value...\\\")\\n for i in range(len(variables_1)):\\n v1 = variables_1[i]\\n v2 = variables_2[i]\\n shape1 = v1.get_shape().as_list()\\n shape2 = v2.get_shape().as_list()\\n if shape1 != shape2:\\n print(\\\"Error shapes are not the same: \\\", shape1, shape2)\\n assert(shape1 == shape2)\\n\\n images_fake = np.zeros((FLAGS.batch_size, cifar10.IMAGE_SIZE, cifar10.IMAGE_SIZE, 3))\\n labels_fake = np.zeros((FLAGS.batch_size,))\\n fd_fake = {images_1 : images_fake,\\n labels_1 : labels_fake,\\n images_2 : images_fake,\\n labels_2 : labels_fake}\\n v1, v2 = mon_sess.run([v1, v2], feed_dict=fd_fake)\\n v1, v2 = v1.flatten(), v2.flatten()\\n if np.linalg.norm(v1) != 0:\\n v1 = v1 / np.linalg.norm(v1)\\n if np.linalg.norm(v2) != 0:\\n v2 = v2 / np.linalg.norm(v2)\\n diff = np.linalg.norm(v1-v2)\\n print(\\\"Difference between variable weights: %f\\\" % diff)\\n assert(diff < 1e-7)\\n print(\\\"Done\\\")\\n\\n epoch = 0\\n n_perfect = 0\\n\\n # Exclude index refers to the index of the example to exclude.\\n # Swap index refers to the index of the example to swap with the example excluded.\\n exclude_index, swap_index = 0, 1\\n\\n while True:\\n\\n # Reshuffle data\\n perm = np.random.permutation(len(images_raw))\\n images_raw = images_raw[perm]\\n labels_raw = labels_raw[perm]\\n\\n # Aggregate all parameters\\n model_1_agg_variables = {}\\n model_2_agg_variables = {}\\n all_variables = {}\\n for i in range(len(variables_1)):\\n images_fake = np.zeros((FLAGS.batch_size, cifar10.IMAGE_SIZE, cifar10.IMAGE_SIZE, 3))\\n labels_fake = np.zeros((FLAGS.batch_size,))\\n fd_fake = {images_1 : images_fake,\\n labels_1 : labels_fake,\\n images_2 : images_fake,\\n labels_2 : labels_fake}\\n v1, v2 = variables_1[i], variables_2[i]\\n name_v1, name_v2 = v1.name, v2.name\\n v1, v2 = mon_sess.run([v1, v2], feed_dict=fd_fake)\\n\\n # Save all parameter weights\\n all_variables[\\\"model1/\\\" + name_v1] = v1\\n all_variables[\\\"model2/\\\" + name_v2] = v2\\n\\n v1, v2 = v1.flatten(), v2.flatten()\\n\\n if \\\"conv\\\" in variables_1[i].name:\\n agg_name = variables_1[i].name.split(\\\"/\\\")[-2]\\n if \\\"all\\\" not in model_1_agg_variables:\\n model_1_agg_variables[\\\"all\\\"] = np.array([])\\n if \\\"all\\\" not in model_2_agg_variables:\\n model_2_agg_variables[\\\"all\\\"] = np.array([])\\n if agg_name not in model_1_agg_variables:\\n model_1_agg_variables[agg_name] = np.array([])\\n if agg_name not in model_2_agg_variables:\\n model_2_agg_variables[agg_name] = np.array([])\\n model_1_agg_variables[agg_name] = np.hstack([model_1_agg_variables[agg_name], v1])\\n model_2_agg_variables[agg_name] = np.hstack([model_2_agg_variables[agg_name], v2])\\n model_1_agg_variables[\\\"all\\\"] = np.hstack([model_1_agg_variables[agg_name], v1])\\n model_2_agg_variables[\\\"all\\\"] = np.hstack([model_2_agg_variables[agg_name], v2])\\n\\n # Save all variables\\n output_file_name = \\\"%s/parameter_difference_batchsize_%d_epoch_%d_save\\\" % (save_directory, FLAGS.batch_size, epoch)\\n output_file = open(output_file_name, \\\"wb\\\")\\n cPickle.dump(all_variables, output_file)\\n output_file.close()\\n\\n # Test the saved values\\n if FLAGS.test_load_dumped_data_files:\\n input_file = open(output_file_name, \\\"rb\\\")\\n print(\\\"Testing whether loaded variables succeeded...\\\")\\n all_variables_loaded = cPickle.load(input_file)\\n input_file.close()\\n for k,v in all_variables_loaded.items():\\n assert(k in all_variables)\\n assert(np.all(np.equal(all_variables[k].flatten(), all_variables_loaded[k].flatten())))\\n print(\\\"Success!\\\")\\n\\n # Find parameter differences\\n layer_diffs = []\\n for layer_name, layer in model_1_agg_variables.items():\\n v1, v2 = model_1_agg_variables[layer_name], model_2_agg_variables[layer_name]\\n #if np.linalg.norm(v1) != 0:\\n # v1 = np.linalg.norm(v1)\\n #if np.linalg.norm(v2) != 0:\\n # v2 = np.linalg.norm(v2)\\n diff = np.linalg.norm(v1-v2)\\n layer_diffs.append((layer_name, diff))\\n print(\\\"Layer differences: \\\", (epoch, layer_diffs))\\n\\n # Evaluate on test data\\n print(\\\"Evaluating on test...\\\")\\n true_count_1, true_count_2 = 0, 0\\n cur_index = 0\\n for i in range(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL//FLAGS.eval_batchsize):\\n #print(\\\"%d of %d\\\" % (i, cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL//FLAGS.eval_batchsize))\\n\\n images_eval_real, labels_eval_real, cur_index = next_batch(FLAGS.eval_batchsize, images_test_raw, labels_test_raw, cur_index)\\n fd = {images_1 : images_eval_real,\\n labels_1 : labels_eval_real,\\n images_2 : images_eval_real,\\n labels_2 : labels_eval_real}\\n p1, p2 = mon_sess.run([top_k_op_1, top_k_op_2], feed_dict=fd)\\n true_count_1 += np.sum(p1)\\n true_count_2 += np.sum(p2)\\n\\n precision_test_1 = true_count_1 / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL)\\n precision_test_2 = true_count_2 / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL)\\n print(\\\"Done\\\")\\n\\n # Evaluate on train data\\n print(\\\"Evaluating on train...\\\")\\n true_count_1, true_count_2 = 0, 0\\n cur_index = 0\\n for i in range(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN//FLAGS.eval_batchsize):\\n #print(\\\"%d of %d\\\" % (i, cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN//FLAGS.eval_batchsize))\\n images_eval_real, labels_eval_real, cur_index = next_batch(FLAGS.eval_batchsize, images_raw, labels_raw, cur_index)\\n fd = {images_1 : images_eval_real,\\n labels_1 : labels_eval_real,\\n images_2 : images_eval_real,\\n labels_2 : labels_eval_real}\\n p1, p2 = mon_sess.run([top_k_op_1, top_k_op_2], feed_dict=fd)\\n true_count_1 += np.sum(p1)\\n true_count_2 += np.sum(p2)\\n\\n precision_train_1 = true_count_1 / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN)\\n precision_train_2 = true_count_2 / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN)\\n\\n output_file_name = \\\"%s/parameter_difference_batchsize_%d_epoch_%d_train_test_error\\\" % (save_directory, FLAGS.batch_size, epoch)\\n output_file = open(output_file_name, \\\"w\\\")\\n cPickle.dump([precision_train_1, precision_train_2, precision_test_1, precision_test_2], output_file)\\n output_file.close()\\n\\n if precision_train_1 >= .999 or precision_train_2 >= .999:\\n n_perfect += 1\\n if n_perfect >= 10:\\n break\\n print(\\\"Done\\\")\\n\\n # Print all the data related to figures 3 and 4 of https://arxiv.org/pdf/1509.01240.pdf\\n print(\\\"Layer distances: \\\", layer_diffs)\\n print(\\\"Epoch: %f TrainError1: %f TrainError2: %f TestError1: %f TestError2: %f\\\" % (epoch, 1-precision_train_1, 1-precision_train_2, 1-precision_test_1, 1-precision_test_2))\\n\\n # Optimize\\n cur_index = 0\\n for i in range(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN // FLAGS.batch_size + 1):\\n images_real_1, labels_real_1, next_index = next_batch(FLAGS.batch_size, images_raw,\\n labels_raw, cur_index,\\n exclude_index=exclude_index)\\n images_real_2, labels_real_2, next_index = next_batch(FLAGS.batch_size, images_raw,\\n labels_raw, cur_index,\\n exclude_index=exclude_index,\\n swap_index=swap_index)\\n\\n cur_index = next_index\\n\\n fd = {images_1 : images_real_1,\\n labels_1 : labels_real_1,\\n images_2 : images_real_2,\\n labels_2 : labels_real_2}\\n\\n mon_sess.run([train_op_1, train_op_2], feed_dict=fd)\\n l1, l2 = mon_sess.run([loss_1, loss_2], feed_dict=fd)\\n\\n if i % 100 == 0:\\n epoch_cur = epoch + i * FLAGS.batch_size / float(cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN)\\n print(\\\"Epoch: %f Losses: %f %f\\\" % (epoch_cur, l1, l2))\\n\\n epoch += 1\",\n \"def resnet10(**kwargs):\\n model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)\\n return model\",\n \"def load_cifar10(directory):\\n train_data = []\\n train_labels = []\\n for b in range(1, 6):\\n f = os.path.join(directory, 'data_batch_%d' % (b,))\\n X, Y = load_cifar10_batch(f)\\n train_data.append(X)\\n train_labels.append(Y)\\n train_data = np.concatenate(train_data)\\n train_labels = np.concatenate(train_labels)\\n del X, Y\\n test_data, test_labels = load_cifar10_batch(os.path.join(directory, 'test_batch'))\\n return train_data, train_labels, test_data, test_labels\",\n \"def trainNetwork():\\n plot_data = {}\\n plot_data['train_loss'] = []\\n plot_data['valid_loss'] = []\\n plot_data['train_acc'] = []\\n plot_data['valid_acc'] = []\\n plot_data['lr'] = []\\n SAVE_DIR = 'C:/Users/Dario/Desktop/Projekt/Drugi labos/lab2_torch/figures'\\n device = torch.device('cuda')\\n\\n net = ConvolutionalModel(3, 16, 128, 10).to(device=device)\\n\\n lossFunc = nn.CrossEntropyLoss()\\n optimizer = optim.Adam(net.parameters(), lr=0.001)\\n scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95)\\n\\n epoch = 10\\n \\n\\n for e in range(epoch):\\n \\n accLoss = 0.0\\n\\n for i, data in enumerate(data_load.trainloader, 0):\\n inputs, labels = data\\n inputs = inputs.to(device=device)\\n labels = labels.to(device=device)\\n\\n optimizer.zero_grad()\\n\\n outputs = net.forward(inputs)\\n loss = lossFunc(outputs, labels)\\n loss.backward()\\n optimizer.step()\\n\\n accLoss += loss.item()\\n\\n if i % 100 == 0:\\n print(\\\"Epoch: %d, Iteration: %5d, Loss: %.3f\\\" % ((e + 1), (i), (accLoss / (i + 1))))\\n \\n train_loss, train_acc = evaluate.evaluate(net, False)\\n val_loss, val_acc = evaluate.evaluate(net, True)\\n\\n plot_data['train_loss'] += [train_loss]\\n plot_data['valid_loss'] += [val_loss]\\n plot_data['train_acc'] += [train_acc]\\n plot_data['valid_acc'] += [val_acc]\\n plot_data['lr'] += [scheduler.get_lr()]\\n\\n scheduler.step()\\n\\n plot.plot_training_progress(SAVE_DIR, plot_data)\\n PATH = './CIFAR_10/cifar_netAdam.pth'\\n torch.save(net.state_dict(), PATH)\",\n \"def train_classifier(data, n_iters=3, batch_size=100):\\n tqdm.write(f'Training a dilated CNN classifier for {n_iters} iterations.')\\n (trainx, trainy), (valx, valy), (testx, testy) = data\\n train_size, val_size, test_size = trainx.shape[0], valx.shape[0], testx.shape[0]\\n train_batches = (train_size - 1) // batch_size + 1\\n val_batches = (val_size - 1) // batch_size + 1\\n test_batches = (test_size - 1) // batch_size + 1\\n\\n model = Network()\\n model.add_layer(ConvLayer(10, (3, 3), (1, 1), 2)) \\\\\\n .add_layer(ReluLayer()) \\\\\\n .add_layer(Pad2DLayer((2, 2))) \\\\\\n .add_layer(ConvLayer(10, (3, 3), (1, 1), 2)) \\\\\\n .add_layer(ReluLayer()) \\\\\\n .add_layer(Pool2DLayer((2, 2))) \\\\\\n .add_layer(ConvLayer(10, (3, 3), (1, 1), 2)) \\\\\\n .add_layer(ReluLayer()) \\\\\\n .add_layer(Pool2DLayer((2, 2))) \\\\\\n .add_layer(FlattenLayer()) \\\\\\n .add_layer(FCLayer(32)) \\\\\\n .add_layer(ReluLayer()) \\\\\\n .add_layer(FCLayer(10)) \\\\\\n .add_layer(SoftmaxCELayer())\\n for i in range(1, n_iters + 1):\\n train_order = np.random.permutation(train_size)\\n bar = trange(train_batches, file=sys.stdout)\\n for j in bar:\\n cost = model.forward(trainx[train_order[j * batch_size: (j + 1) * batch_size]],\\n trainy[train_order[j * batch_size: (j + 1) * batch_size]])\\n bar.set_description(f'Curr loss: {cost}')\\n model.backward()\\n model.adam_trainstep()\\n correct = []\\n for j in range(val_batches):\\n res = model.run(valx[j * batch_size:(j + 1) * batch_size])\\n correct.append(np.argmax(res, axis=1) == valy[j * batch_size:(j + 1) * batch_size])\\n tqdm.write(f'Validation accuracy: {np.mean(correct)}')\\n tqdm.write('-------------------------------------------------------')\\n\\n correct = []\\n for i in range(test_batches):\\n res = model.run(testx[i * batch_size:(i + 1) * batch_size])\\n correct.append(np.argmax(res, axis=1) == testy[i * batch_size:(i + 1) * batch_size])\\n tqdm.write(f'Test accuracy: {np.mean(correct)}')\\n tqdm.write('-------------------------------------------------------')\",\n \"def main():\\n\\tmodel = load_model(args.model)\\n\\tif not args.retrain:\\n\\t\\twhile True:\\n\\t\\t\\tvideos = glob.glob(args.input + '/*.mov')\\n\\t\\t\\tif len(videos) > 0:\\n\\t\\t\\t\\tlabel(videos, model)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tsleep(10)\\n\\telif args.retrain:\\n\\t\\t\\tpath, file = os.path.split(args.model)\\n\\t\\t\\tmodel.save(path + '/old_' + file)\\n\\n\\t\\t\\tX, Y = process_train_data(args.train)\\n\\t\\t\\tX_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state = 24)\\n\\n\\t\\t\\tes_cb = EarlyStopping(monitor='val_loss', patience=2, mode='auto', restore_best_weights=True)\\n\\t\\t\\thistory = model.fit(X_train, y_train, batch_size=32, epochs=50, callbacks=[es_cb], validation_data=(X_test, y_test), verbose=int(args.debug))\\n\\t\\t\\tmodel.save(args.model)\\n\\n\\t\\t\\tmaintain(args.train, 600)\",\n \"def resnet_model(images,\\n is_training,\\n num_classes,\\n resnet_size=50,\\n weight_decay=None,\\n kernel_size=7,\\n num_filters=64,\\n return_intermediate_values=False,\\n film_generator_fn=None,\\n film_generator_input=None,\\n pretrain_checkpoint=None):\\n # For bigger models, we want to use \\\"bottleneck\\\" layers\\n if resnet_size < 50:\\n bottleneck = False\\n else:\\n bottleneck = True\\n model = resnet_lib.Model(\\n resnet_size=resnet_size,\\n bottleneck=bottleneck,\\n num_classes=num_classes,\\n num_filters=num_filters,\\n kernel_size=kernel_size,\\n conv_stride=2,\\n first_pool_size=3,\\n first_pool_stride=2,\\n block_sizes=_get_block_sizes(resnet_size),\\n block_strides=[1, 2, 2, 2],\\n resnet_version=resnet_lib.DEFAULT_VERSION,\\n data_format='channels_last',\\n weight_decay=weight_decay,\\n dtype=resnet_lib.DEFAULT_DTYPE\\n )\\n final_dense = model(images, is_training,\\n film_generator_fn, film_generator_input)\\n if pretrain_checkpoint:\\n # Initialize variables in ResNet, excluding the final dense layer and any\\n # optimization-specific variables (e.g. Momentum, Adam Beta).\\n # When initializing on TPUs, use AbstractT2RModel.init_from_checkpoint_fn.\\n resnet_init_from_checkpoint_fn(pretrain_checkpoint)\\n if return_intermediate_values:\\n return resnet_endpoints(model)\\n else:\\n return final_dense\",\n \"def pretrain_nc_net(self, n_epochs=300):\\n optimizer = torch.optim.Adam(self.model.nc_net.parameters(), lr=self.lr, weight_decay=self.weight_decay)\\n best_val_auc = 0.\\n best_test_auc = 0.\\n best_res = None\\n self.model.nc_net.to(self.device)\\n user_features = self.user_features.to(self.device)\\n item_features = self.item_features.to(self.device)\\n self.labels = self.labels.to(self.device)\\n\\n cnt_wait = 0\\n patience = 50\\n for epoch in range(n_epochs):\\n self.model.nc_net.train()\\n self.model.nc_net.zero_grad()\\n input_adj = self.adj.clone()\\n input_adj = input_adj.to(self.device)\\n loss, nc_logits, _ = self.model.nc_net(input_adj, user_features, item_features)\\n loss.backward()\\n optimizer.step()\\n optimizer.zero_grad()\\n # Detach from computation graph\\n self.adj = self.adj.detach()\\n # Validation\\n self.model.nc_net.eval()\\n with torch.no_grad():\\n input_adj = self.adj.clone()\\n input_adj = input_adj.to(self.device)\\n _, nc_logits_eval, _ = self.model.nc_net(input_adj, user_features, item_features)\\n res_training = self.eval_node_cls(nc_logits[self.train_nid].detach(), self.labels[self.train_nid], self.n_classes)\\n res = self.eval_node_cls(nc_logits_eval[self.val_nid], self.labels[self.val_nid], self.n_classes)\\n\\n if res['auc'] > best_val_auc:\\n cnt_wait = 0\\n best_val_auc = res['auc']\\n test_auc = self.eval_node_cls(nc_logits_eval[self.test_nid], self.labels[self.test_nid], self.n_classes)['auc']\\n if test_auc > best_test_auc:\\n best_test_auc = test_auc\\n best_res = self.eval_node_cls(nc_logits_eval[self.test_nid], self.labels[self.test_nid], self.n_classes)\\n self.logger.info('NCNet pretrain, Epoch [{} / {}]: loss {:.4f}, train_auc {:.4f}, val_auc {:.4f}, test_auc {:.4f}, test_ap {:.4f}'\\n .format(epoch+1, n_epochs, loss.item(), res_training['auc'], res['auc'], test_auc, best_res['ap']))\\n else:\\n cnt_wait += 1\\n self.logger.info('NCNet pretrain, Epoch [{} / {}]: loss {:.4f}, train_auc {:.4f}, val_auc: {:.4f}'\\n .format(epoch+1, n_epochs, loss.item(), res_training['auc'], res['auc']))\\n\\n if cnt_wait >= patience:\\n self.logger.info('Early stop!')\\n break\\n\\n self.logger.info('Best Test Results: auc {:.4f}, ap {:.4f}'.format(best_res['auc'], best_res['ap']))\\n return best_res['auc'], best_res['ap']\",\n \"def eval_net(net, loader, device, n_val, cfg):\\n net.eval()\\n tot = 0\\n bce_loss = 0\\n dice_coef = 0\\n with tqdm(total=n_val, desc='Validation round', unit='img', leave=False) as pbar:\\n for imgs, true_masks in loader:\\n # for batch in loader:\\n # imgs = batch['image']\\n # true_masks = batch['mask']\\n\\n imgs = imgs.to(device=device, dtype=torch.float32)\\n mask_type = torch.float32 #if cfg.n_classes == 1 else torch.long\\n true_masks = true_masks.to(device=device, dtype=mask_type)\\n criterion_1 = BCE = F.binary_cross_entropy #(inputs, targets, reduction='mean')#StableBCELoss()#binary_xloss\\n criterion_2 = DiceLoss()\\n # compute loss\\n if cfg.deepsupervision:\\n masks_preds = net(imgs)\\n for masks_pred in masks_preds:\\n tot_ = 0\\n tot_bce = 0\\n tot_dice = 0\\n for true_mask, pred in zip(true_masks, masks_pred):\\n pred = (pred > cfg.out_threshold).float()\\n if cfg.n_classes > 1:\\n bce = criterion_1(F.sigmoid(pred), true_mask) \\n dice = criterion_2(pred, true_mask.float())\\n # sub_cross_entropy = F.cross_entropy(pred, true_mask).item()\\n # sub_cross_entropy = F.cross_entropy(pred.unsqueeze(dim=0), true_mask.unsqueeze(dim=0).squeeze(1)).item()\\n else:\\n sub_cross_entropy = dice_coeff(pred, true_mask.squeeze(dim=1)).item()\\n tot_bce += bce\\n tot_dice += dice\\n tot_bce = tot_bce / len(masks_preds)\\n tot_dice = tot_dice / len(masks_preds)\\n bce_loss += tot_bce\\n dice_coef += tot_dice\\n tot_ += tot_bce\\n tot_ += tot_dice\\n tot += tot_\\n else:\\n masks_pred = net(imgs)\\n for true_mask, pred in zip(true_masks, masks_pred):\\n pred = (pred > cfg.out_threshold).float()\\n if cfg.n_classes > 1:\\n tot += F.cross_entropy(pred.unsqueeze(dim=0), true_mask.unsqueeze(dim=0).squeeze(1)).item()\\n else:\\n tot += dice_coeff(pred, true_mask.squeeze(dim=1)).item()\\n\\n pbar.update(imgs.shape[0])\\n\\n return tot / n_val, bce_loss / n_val, dice_coef / n_val,\",\n \"def modified_resnet10(self) -> torch.nn.Module:\\n # initialize a Resnet-10 instance\\n net = torchvision.models.resnet._resnet(arch=\\\"resnet10\\\", block=torchvision.models.resnet.BasicBlock, layers=[1, 1, 1, 1], pretrained=False, progress=False)\\n\\n # the first layer will be a lazy convolutional layer with any input channels\\n net.conv1 = torch.nn.LazyConv2d(\\n out_channels=64,\\n kernel_size=(7, 7),\\n stride=(2, 2),\\n padding=(3, 3),\\n bias=not self.bn_affine\\n )\\n\\n # modify batch-norm layer to have momentum 1 and no tracking statistics\\n net.bn1 = torch.nn.BatchNorm2d(64, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n\\n net.layer1[0].bn1 = torch.nn.BatchNorm2d(64, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n net.layer1[0].bn2 = torch.nn.BatchNorm2d(64, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n\\n net.layer2[0].bn1 = torch.nn.BatchNorm2d(128, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n net.layer2[0].bn2 = torch.nn.BatchNorm2d(128, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n net.layer2[0].downsample[1] = torch.nn.BatchNorm2d(128, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n\\n net.layer3[0].bn1 = torch.nn.BatchNorm2d(256, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n net.layer3[0].bn2 = torch.nn.BatchNorm2d(256, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n net.layer3[0].downsample[1] = torch.nn.BatchNorm2d(256, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n\\n net.layer4[0].bn1 = torch.nn.BatchNorm2d(512, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n net.layer4[0].bn2 = torch.nn.BatchNorm2d(512, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n net.layer4[0].downsample[1] = torch.nn.BatchNorm2d(512, momentum=1, track_running_stats=False, affine=self.bn_affine)\\n\\n # last layer\\n if self.dim_output is not None:\\n net.fc = torch.nn.LazyLinear(out_features=self.dim_output)\\n else:\\n net.fc = torch.nn.Identity()\\n\\n # add dropout-2d after layers 1, 2, and 3\\n net.maxpool.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n\\n net.layer1[0].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n # net.layer1[1].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n net.layer1.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n\\n net.layer2[0].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n # net.layer2[1].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n net.layer2.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n\\n net.layer3[0].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n # net.layer3[1].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n net.layer3.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n\\n net.layer4[0].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n # net.layer4[1].add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n net.layer4.add_module(name='dropout2d', module=torch.nn.Dropout2d(p=self.dropout_prob))\\n\\n return net\",\n \"def run_eval(gt_anno, pred_anno):\\n coco = COCO(gt_anno)\\n coco_dets = coco.loadRes(pred_anno)\\n coco_eval = COCOeval(coco, coco_dets, \\\"keypoints\\\")\\n coco_eval.evaluate()\\n coco_eval.accumulate()\\n coco_eval.summarize()\\n coco_eval = COCOeval(coco, coco_dets, \\\"bbox\\\")\\n coco_eval.evaluate()\\n coco_eval.accumulate()\\n coco_eval.summarize()\",\n \"def train(self, mode=True):\\n super(ResNet, self).train(mode)\\n self._freeze_stages()\\n if mode and self.norm_eval:\\n for m in self.modules():\\n # trick: eval have effect on BatchNorm only\\n if isinstance(m, _BatchNorm):\\n m.eval()\",\n \"def run_epoch(model, data, optimizer, epoch):\\n traindata, valdata = data\\n\\n model.train()\\n train_bpd = epoch_iter(model, traindata, optimizer, epoch)\\n\\n model.eval()\\n val_bpd = epoch_iter(model, valdata, optimizer, epoch)\\n\\n return train_bpd, val_bpd\",\n \"def main():\\n args = get_arguments()\\n \\n # Create queue coordinator.\\n coord = tf.train.Coordinator()\\n\\n # Load reader.\\n with tf.name_scope(\\\"create_inputs\\\"):\\n reader = ImageReader(\\n args.data_dir,\\n args.data_list,\\n None, # No defined input size.\\n False, # No random scale.\\n False, # No random mirror.\\n args.ignore_label,\\n IMG_MEAN,\\n coord)\\n image, label = reader.image, reader.label\\n image_batch, label_batch = tf.expand_dims(image, dim=0), tf.expand_dims(label, dim=0) # Add one batch dimension.\\n\\n # Create network.\\n net = DeepLabResNetModel({'data': image_batch}, is_training=False, num_classes=args.num_classes)\\n\\n # Which variables to load.\\n restore_var = tf.global_variables()\\n\\n # Predictions.\\n raw_output = net.layers['fc1_voc12']\\n raw_output = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3,])\\n #raw_output = tf.argmax(raw_output, dimension=3)\\n #pred = tf.expand_dims(raw_output, dim=3) # Create 4-d tensor.\\n pred = raw_output\\n\\n # Set up TF session and initialize variables.\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n init = tf.global_variables_initializer()\\n\\n sess.run(init)\\n sess.run(tf.local_variables_initializer())\\n\\n # Load weights.\\n loader = tf.train.Saver(var_list=restore_var)\\n if args.restore_from is not None:\\n load(loader, sess, args.restore_from)\\n\\n # Start queue threads.\\n threads = tf.train.start_queue_runners(coord=coord, sess=sess)\\n\\n with open(args.data_list) as f:\\n content = f.readlines()\\n\\n content = [x.strip() for x in content]\\n\\n\\n \\n for index, value in enumerate(content):\\n print(\\\"outputting \\\"+str(index))\\n \\timg = tf.image.decode_png(tf.read_file(value.split()[0]), channels=3)\\n raw_img = misc.imread(value.split()[0])\\n print(type(raw_img))\\n \\t# Convert RGB to BGR.\\n \\timg_r, img_g, img_b = tf.split(axis=2, num_or_size_splits=3, value=img)\\n \\timg = tf.cast(tf.concat(axis=2, values=[img_b, img_g, img_r]), dtype=tf.float32)\\n \\t# Extract mean.\\n \\timg -= IMG_MEAN \\n \\t# Predictions.\\n \\traw_output = net.layers['fc1_voc12']\\n\\n \\traw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(img)[0:2,])\\n \\t#pred = raw_output_up\\n probabilities = tf.nn.softmax(raw_output_up)\\n pred = tf.argmax(raw_output_up, dimension=3)\\n \\tpred = tf.expand_dims(pred, dim=3)\\n \\t# Perform inference.\\n \\tpreds, probs = sess.run([pred, probabilities])\\n print(preds.shape)\\n print(probs.shape)\\n print(\\\"probs\\\")\\n print(probs)\\n softmax = probs[0, :, :, :]\\n print(\\\"softmax\\\")\\n print(softmax)\\n print(softmax.shape)\\n print(type(softmax))\\n processed_probabilities = softmax.transpose((2, 0, 1))\\n print(processed_probabilities.shape)\\n print(type(processed_probabilities))\\n crf_processed = performCRF(processed_probabilities, raw_img)\\n\\n im_preds = Image.fromarray(np.uint8(preds[0, :, :, 0]))\\n\\n print(\\\"preds shape\\\", preds.shape)\\n \\tmsk = decode_labels(preds, num_classes=args.num_classes)\\n \\tim = Image.fromarray(msk[0])\\n\\n print(\\\"crf_processed shape\\\", crf_processed.shape)\\n crf_processed = crf_processed.reshape(1, crf_processed.shape[0], crf_processed.shape[1], 1)\\n msk_crf = decode_labels(crf_processed, num_classes=args.num_classes)\\n im_crf = Image.fromarray(msk_crf[0])\\n\\n \\tif not os.path.exists(args.save_dir):\\n os.makedirs(args.save_dir)\\n #im_preds.save(args.save_dir +str(index).zfill(8) +'_predlabels_'+args.train_set+'.png')\\n \\tim.save(args.save_dir +str(index).zfill(8) +'_pred_'+args.train_set+'.png')\\n im_crf.save(args.save_dir +str(index).zfill(8) +'_predcrf_'+args.train_set+'.png')\",\n \"def run(self, data, training=False):\\n # Set mode\\n if training:\\n self._model.train()\\n else:\\n self._model.eval()\\n # Compute\\n return self._model(data)\",\n \"def run_training_loop():\\n logging.info(\\\"Starting the training loop.\\\")\\n\\n trainer = trainer_class(\\n output_dir=output_dir,\\n train_env=train_env,\\n eval_env=eval_env,\\n trajectory_dump_dir=trajectory_dump_dir,\\n )\\n trainer.training_loop(n_epochs=n_epochs)\",\n \"def load_cifar():\\n print('==> Preparing data..')\\n transform_train = transforms.Compose([\\n transforms.RandomCrop(32, padding=4),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\\n ])\\n\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\\n ])\\n\\n trainset = torchvision.datasets.CIFAR10(\\n root='./data', train=True, download=True, transform=transform_train)\\n trainloader = torch.utils.data.DataLoader(\\n trainset, batch_size=1024, shuffle=True, num_workers=8)\\n\\n testset = torchvision.datasets.CIFAR10(\\n root='./data', train=False, download=True, transform=transform_test)\\n testloader = torch.utils.data.DataLoader(\\n testset, batch_size=128, shuffle=False, num_workers=8)\\n return trainloader, testloader\",\n \"def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\\n # Load the raw CIFAR-10 data\\n cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\\n X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\\n \\n # Subsample the data\\n mask = range(num_training, num_training + num_validation)\\n X_val = X_train[mask]\\n y_val = y_train[mask]\\n mask = range(num_training)\\n X_train = X_train[mask]\\n y_train = y_train[mask]\\n mask = range(num_test)\\n X_test = X_test[mask]\\n y_test = y_test[mask]\\n\\n # Normalize the data: subtract the mean image\\n mean_image = np.mean(X_train, axis=0)\\n X_train -= mean_image\\n X_val -= mean_image\\n X_test -= mean_image\\n\\n # Reshape data to rows\\n X_train = X_train.reshape(num_training, -1)\\n X_val = X_val.reshape(num_validation, -1)\\n X_test = X_test.reshape(num_test, -1)\\n\\n pca = decomposition.PCA(n_components=None, whiten=False)\\n X_train = pca.fit_transform(X_train)\\n X_val = pca.transform(X_val)\\n X_test = pca.transform(X_test)\\n\\n return X_train, y_train, X_val, y_val, X_test, y_test\",\n \"def train(self):\\n self.ae_train(self.net0, self.ae0_optimizer, self.train0_loader, self.val_loader, name='Net0')\\n self.ae_train(self.net1, self.ae1_optimizer, self.train1_loader, self.val_loader, name='Net1')\\n self.ae_train(self.net2, self.ae2_optimizer, self.train2_loader, self.val_loader, name='Net2')\\n\\n self.classifier_train(self.net0, self.optimizer0, self.train0_loader, self.val_loader, name='Net0')\\n self.classifier_train(self.net1, self.optimizer1, self.train1_loader, self.val_loader, name='Net1')\\n self.classifier_train(self.net2, self.optimizer2, self.train2_loader, self.val_loader, name='Net2')\",\n \"def eval(test_snrs, model, model_name, test_samples, test_labels, tag, classes, batch_size):\\n # Import Packages\\n import os\\n import numpy as np\\n \\n # Function to plot the confusion matrices\\n import confusion_matrix\\n\\n # Compute Acuracy and plot confusion matrices by SNR\\n acc = np.zeros(len(test_snrs))\\n for s in range(len(test_snrs)):\\n\\n # extract classes @ SNR\\n test_X_i = test_samples[s]\\n test_Y_i = test_labels[s]\\n # estimate classes\\n test_Y_i_hat = model.predict(test_X_i)\\n conf = np.zeros([len(classes),len(classes)])\\n confnorm = np.zeros([len(classes),len(classes)])\\n for i in range(test_X_i.shape[0]):\\n j = list(test_Y_i[i,:]).index(1)\\n k = int(np.argmax(test_Y_i_hat[i,:]))\\n conf[j,k] = conf[j,k] + 1\\n for i in range(len(classes)):\\n confnorm[i,:] = conf[i,:] / np.sum(conf[i,:])\\n # Confusion matrix @ all SNRs in the test set\\n if s == 0 or s == len(test_snrs)-1:\\n filename = os.getcwd()+'/'+tag+'/Figures/'+ model_name + '_SNR_' + str(test_snrs[s]) + '_Confusion_Matrix.png'\\n confusion_matrix.plot(confnorm, tag, model_name, filename, labels=classes)\\n \\n cor = np.sum(np.diag(conf))\\n ncor = np.sum(conf) - cor\\n acc[s] = 1.0*cor/(cor+ncor)\\n # Save results\\n np.save(os.getcwd()+'/'+tag+'/Computed_Values/' + model_name + '_SNR_Accuracy', acc.astype('float32'))\\n print(model_name + ' Accuracy:\\\\n' + str(acc))\",\n \"def resnet101_classifier(num_rois, num_classes, base_model = None, weight_regularizer=None, bias_regularizer=None):\\n roi_input = Input(shape=(None, 4), name='roi_input')\\n\\n pooling_input = base_model.output if base_model else Input(shape=(None, None, FINAL_CONV_FILTERS))\\n model_input = base_model.input if base_model else pooling_input\\n resize_out = RoiResizeConv(POOLING_REGIONS, num_rois)([pooling_input, roi_input])\\n\\n out = td_conv_block(resize_out, 3, [512, 512, 2048], stage=5, block='a', strides=(1,1),\\n weight_regularizer=weight_regularizer, bias_regularizer=bias_regularizer,\\n td_input_shape=(num_rois, POOLING_REGIONS, POOLING_REGIONS, 1024),\\n use_conv_bias=False, separate_scale=True)\\n out = td_identity_block(out, 3, [512, 512, 2048], stage=5, block='b',\\n weight_regularizer=weight_regularizer, bias_regularizer=bias_regularizer,\\n use_conv_bias=False, separate_scale=True)\\n out = td_identity_block(out, 3, [512, 512, 2048], stage=5, block='c',\\n weight_regularizer=weight_regularizer, bias_regularizer=bias_regularizer,\\n use_conv_bias=False, separate_scale=True)\\n out = TimeDistributed(AveragePooling2D((7, 7)), name='avg_pool')(out)\\n\\n out = TimeDistributed(Flatten(name='flatten'))(out)\\n\\n gaussian_initializer_cls = TruncatedNormal(stddev=0.01)\\n gaussian_initializer_bbreg = TruncatedNormal(stddev=0.001)\\n\\n out_class = TimeDistributed(Dense(num_classes, activation='softmax',\\n kernel_initializer=gaussian_initializer_cls,\\n kernel_regularizer=weight_regularizer,\\n bias_regularizer=bias_regularizer\\n ),\\n name='dense_class_{}'.format(num_classes))(out)\\n out_reg = TimeDistributed(Dense(4 * (num_classes - 1), activation='linear',\\n kernel_initializer=gaussian_initializer_bbreg,\\n kernel_regularizer=weight_regularizer,\\n bias_regularizer=bias_regularizer\\n ),\\n name='dense_reg_{}'.format(num_classes))(out)\\n\\n cls_model = Model(inputs=[model_input, roi_input], outputs=[out_class, out_reg])\\n\\n this_dir = os.path.dirname(__file__)\\n weights_path = os.path.join(this_dir, '../models/resnet101_weights_tf.h5')\\n cls_model.load_weights(weights_path, by_name=True)\\n\\n return cls_model\",\n \"def loop(self, epochs, train_loader, val_loader, test_loader):\\n\\n self.all_epoch = epochs\\n self._resume()\\n\\n for ep in range(self.cur_epoch, epochs + 1):\\n self.cur_epoch = ep\\n\\n # conduct training, validation and test\\n self.train_loss = self.train(train_loader)\\n if ep % self.val_freq == 0:\\n self.val_loss = self.val(val_loader)\\n\\n if ep % self.test_freq == 0:\\n self.test_loss, rho, nmse = self.test(test_loader)\\n else:\\n rho, nmse = None, None\\n\\n # conduct saving, visualization and log printing\\n self._loop_postprocessing(rho, nmse)\",\n \"def load_CIFAR10(ROOT):\\n xs = []\\n ys = []\\n for b in range(1, 6):\\n f = os.path.join(ROOT, 'data_batch_%d' % (b,))\\n X, Y = load_CIFAR_batch(f)\\n xs.append(X)\\n ys.append(Y)\\n Xtr = np.concatenate(xs)\\n Ytr = np.concatenate(ys)\\n del X, Y\\n Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))\\n return Xtr, Ytr, Xte, Yte\",\n \"def make_NN(n_hidden, n_epoch, labelsdict, lr, device, model_name, trainloader, validloader, train_data, pretrain, finetune_whole, custom_model):\\n if custom_model == 2:\\n # Use custom two-layer convolution model\\n print(\\\"Using Two-Layer CNN\\\")\\n model = TwoLayerConvNet()\\n elif custom_model == 5:\\n print(\\\"Using Five-Layer CNN\\\")\\n # Use custom five-layer convolution model\\n model = FiveLayerConvNet()\\n else:\\n # Import NN model (either pretrained or not)\\n model = getattr(models, model_name)(pretrained=pretrain)\\n \\\"\\\"\\\" ===================================================================================== \\\"\\\"\\\"\\\"\\n \\n \\\"\\\"\\\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER FREEZE THE PARAMETERS OR NOT (WILBERT ARISTO) \\\"\\\"\\\"\\n # If we do not need to finetune whole model, freeze parameters that we don't need to re-train\\n if not finetune_whole:\\n for param in model.parameters():\\n param.requires_grad = False\\n \\\"\\\"\\\" ===================================================================================== \\\"\\\"\\\"\\\"\\n\\n n_out = len(labelsdict)\\n\\n \\\"\\\"\\\" CHANGED LAST LAYER TO model.fc IF WE ARE USING RESNET MODEL (WILBERT ARISTO) \\\"\\\"\\\"\\n if \\\"resnet\\\" in model_name:\\n # Make classifier\\n n_in = next(model.fc.modules()).in_features\\n model.fc = NN_Classifier(input_size=n_in, output_size=n_out, hidden_layers=n_hidden)\\n \\n \\\"\\\"\\\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER OPTIMIZE ALL PARAMETERS OR JUST THE LAST LAYER'S PARAMS (WILBERT ARISTO) \\\"\\\"\\\"\\n # Define optimizer\\n if finetune_whole:\\n optimizer = optim.Adam(model.parameters(), lr = lr)\\n else:\\n optimizer = optim.Adam(model.fc.parameters(), lr = lr)\\n \\\"\\\"\\\" ============================================================================================================================ \\\"\\\"\\\"\\\"\\n else:\\n # Make classifier\\n n_in = next(model.classifier.modules()).in_features\\n model.classifier = NN_Classifier(input_size=n_in, output_size=n_out, hidden_layers=n_hidden)\\n \\n \\\"\\\"\\\" IMPLEMENTATION OF finetune_whole ARGUMENT TO EITHER OPTIMIZE ALL PARAMETERS OR JUST THE LAST LAYER'S PARAMS (WILBERT ARISTO) \\\"\\\"\\\"\\n # Define optimizer\\n if finetune_whole:\\n optimizer = optim.Adam(model.parameters(), lr = lr)\\n else:\\n optimizer = optim.Adam(model.classifier.parameters(), lr = lr)\\n \\\"\\\"\\\" ============================================================================================================================ \\\"\\\"\\\"\\\"\\n \\\"\\\"\\\" ============================================================================================================================ \\\"\\\"\\\"\\\"\\n\\n # Define criterion\\n criterion = nn.NLLLoss() \\n\\n model.to(device)\\n start = time.time()\\n\\n epochs = n_epoch\\n steps = 0 \\n running_loss = 0\\n print_every = 40\\n for e in range(epochs):\\n model.train()\\n for images, labels in trainloader:\\n images, labels = images.to(device), labels.to(device)\\n\\n steps += 1\\n\\n optimizer.zero_grad()\\n\\n output = model.forward(images)\\n loss = criterion(output, labels)\\n loss.backward()\\n optimizer.step()\\n\\n running_loss += loss.item()\\n\\n if steps % print_every == 0:\\n # Eval mode for predictions\\n model.eval()\\n\\n # Turn off gradients for validation\\n with torch.no_grad():\\n test_loss, accuracy = validation(model, validloader, criterion, device)\\n\\n print(\\\"Epoch: {}/{} - \\\".format(e+1, epochs),\\n \\\"Training Loss: {:.3f} - \\\".format(running_loss/print_every),\\n \\\"Validation Loss: {:.3f} - \\\".format(test_loss/len(validloader)),\\n \\\"Validation Accuracy: {:.3f}\\\".format(accuracy/len(validloader)))\\n\\n running_loss = 0\\n\\n # Make sure training is back on\\n model.train()\\n \\n \\\"\\\"\\\" CHANGED LAST LAYER TO model.fc IF WE ARE USING RESNET MODEL (WILBERT ARISTO) \\\"\\\"\\\"\\n if \\\"resnet\\\" in model_name:\\n # Add model info \\n model.fc.n_in = n_in\\n model.fc.n_hidden = n_hidden\\n model.fc.n_out = n_out\\n model.fc.labelsdict = labelsdict\\n model.fc.lr = lr\\n model.fc.optimizer_state_dict = optimizer.state_dict\\n model.fc.model_name = model_name\\n model.fc.class_to_idx = train_data.class_to_idx\\n else:\\n # Add model info \\n model.classifier.n_in = n_in\\n model.classifier.n_hidden = n_hidden\\n model.classifier.n_out = n_out\\n model.classifier.labelsdict = labelsdict\\n model.classifier.lr = lr\\n model.classifier.optimizer_state_dict = optimizer.state_dict\\n model.classifier.model_name = model_name\\n model.classifier.class_to_idx = train_data.class_to_idx\\n \\\"\\\"\\\" ============================================================================================================================ \\\"\\\"\\\"\\\"\\n\\n print('model:', model_name, '- hidden layers:', n_hidden, '- epochs:', n_epoch, '- lr:', lr)\\n print(f\\\"Run time: {(time.time() - start)/60:.3f} min\\\")\\n return model\\n\\n# Define function to save checkpoint\\ndef save_checkpoint(model, path):\\n checkpoint = {'c_input': model.classifier.n_in,\\n 'c_hidden': model.classifier.n_hidden,\\n 'c_out': model.classifier.n_out,\\n 'labelsdict': model.classifier.labelsdict,\\n 'c_lr': model.classifier.lr,\\n 'state_dict': model.state_dict(),\\n 'c_state_dict': model.classifier.state_dict(),\\n 'opti_state_dict': model.classifier.optimizer_state_dict,\\n 'model_name': model.classifier.model_name,\\n 'class_to_idx': model.classifier.class_to_idx\\n }\\n torch.save(checkpoint, path)\\n \\n# Define function to load model\\ndef load_model(path):\\n cp = torch.load(path)\\n \\n # Import pre-trained NN model \\n model = getattr(models, cp['model_name'])(pretrained=True)\\n \\n # Freeze parameters that we don't need to re-train \\n for param in model.parameters():\\n param.requires_grad = False\\n \\n # Make classifier\\n model.classifier = NN_Classifier(input_size=cp['c_input'], output_size=cp['c_out'], \\\\\\n hidden_layers=cp['c_hidden'])\\n \\n # Add model info \\n model.classifier.n_in = cp['c_input']\\n model.classifier.n_hidden = cp['c_hidden']\\n model.classifier.n_out = cp['c_out']\\n model.classifier.labelsdict = cp['labelsdict']\\n model.classifier.lr = cp['c_lr']\\n model.classifier.optimizer_state_dict = cp['opti_state_dict']\\n model.classifier.model_name = cp['model_name']\\n model.classifier.class_to_idx = cp['class_to_idx']\\n model.load_state_dict(cp['state_dict'])\\n \\n return model\",\n \"def load_CIFAR10(ROOT):\\n xs = []\\n ys = []\\n for b in range(1,6):\\n f = os.path.join(ROOT, 'data_batch_%d' % (b, ))\\n X, Y = load_CIFAR_batch(f)\\n xs.append(X)\\n ys.append(Y)\\n Xtr = np.concatenate(xs)\\n Ytr = np.concatenate(ys)\\n del X, Y\\n Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))\\n return Xtr, Ytr, Xte, Yte\",\n \"def train_epoch(args, loss_func, pbar, train_loader, model, optimizer,\\n train_bpd, train_recon_error , train_perplexity):\\n model.train()\\n # Loop data in epoch\\n for x, _ in train_loader:\\n\\n # This break used for debugging\\n if args.max_iterations is not None:\\n if args.global_it > args.max_iterations:\\n break\\n\\n x = x.to(args.device)\\n\\n # Get reconstruction and vector quantization loss\\n # `x_prime`: reconstruction of `input`\\n # `vq_loss`: MSE(encoded embeddings, nearest emb in codebooks)\\n x_prime, vq_loss, perplexity = model(x)\\n\\n loss, log_pxz, bpd = loss_func(args, x_prime, x, vq_loss, model)\\n\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n\\n train_bpd.append((-1)*bpd.item())\\n train_recon_error.append((-1)*log_pxz.item())\\n train_perplexity.append(perplexity.item())\\n\\n # Print Average every 100 steps\\n if (args.global_it+1) % 100 == 0:\\n av_bpd = np.mean(train_bpd[-100:])\\n av_rec_err = np.mean(train_recon_error[-100:])\\n av_ppl = np.mean(train_perplexity[-100:])\\n if args.model == 'vqvae':\\n pbar.print_train(bpd=float(av_bpd), rec_err=float(av_rec_err),\\n increment=100)\\n elif args.model == 'diffvqvae':\\n pbar.print_train(bpd=float(av_bpd), temp=float(model.temp),\\n increment=100)\\n args.global_it += 1\",\n \"def run(self) -> None:\\n self.model = self.trainer.train_model(self.model, self.data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68692064","0.68146634","0.67452115","0.6699857","0.6683113","0.6682839","0.6632425","0.6484482","0.6415731","0.64139616","0.6357005","0.63551235","0.631291","0.6257653","0.6231015","0.6218077","0.62155414","0.6197411","0.6194097","0.6192405","0.6187572","0.6168042","0.61520773","0.613701","0.61349314","0.61162317","0.60984397","0.60976034","0.60947305","0.6086849","0.6086601","0.6071629","0.6052914","0.6048889","0.6047553","0.6045921","0.6045519","0.60283625","0.60256416","0.6014601","0.6002252","0.6000872","0.597687","0.5967008","0.59587926","0.5955514","0.59528047","0.5945396","0.59221643","0.5918027","0.5899712","0.58858806","0.5885551","0.58847827","0.58829","0.58795094","0.5877771","0.58770186","0.5876711","0.58746004","0.5873826","0.5861805","0.58606863","0.58584005","0.5857105","0.5850808","0.58433425","0.58340776","0.58330256","0.58297133","0.5827206","0.5802659","0.58016104","0.58010256","0.58000004","0.5799755","0.57889","0.57855445","0.57844317","0.57827526","0.5782385","0.5780374","0.57794034","0.5777248","0.57765025","0.5775527","0.5773996","0.57713157","0.5765713","0.5761763","0.5761647","0.57606745","0.5759653","0.5754263","0.5752895","0.57433134","0.5738464","0.57379603","0.57345116","0.57297015"],"string":"[\n \"0.68692064\",\n \"0.68146634\",\n \"0.67452115\",\n \"0.6699857\",\n \"0.6683113\",\n \"0.6682839\",\n \"0.6632425\",\n \"0.6484482\",\n \"0.6415731\",\n \"0.64139616\",\n \"0.6357005\",\n \"0.63551235\",\n \"0.631291\",\n \"0.6257653\",\n \"0.6231015\",\n \"0.6218077\",\n \"0.62155414\",\n \"0.6197411\",\n \"0.6194097\",\n \"0.6192405\",\n \"0.6187572\",\n \"0.6168042\",\n \"0.61520773\",\n \"0.613701\",\n \"0.61349314\",\n \"0.61162317\",\n \"0.60984397\",\n \"0.60976034\",\n \"0.60947305\",\n \"0.6086849\",\n \"0.6086601\",\n \"0.6071629\",\n \"0.6052914\",\n \"0.6048889\",\n \"0.6047553\",\n \"0.6045921\",\n \"0.6045519\",\n \"0.60283625\",\n \"0.60256416\",\n \"0.6014601\",\n \"0.6002252\",\n \"0.6000872\",\n \"0.597687\",\n \"0.5967008\",\n \"0.59587926\",\n \"0.5955514\",\n \"0.59528047\",\n \"0.5945396\",\n \"0.59221643\",\n \"0.5918027\",\n \"0.5899712\",\n \"0.58858806\",\n \"0.5885551\",\n \"0.58847827\",\n \"0.58829\",\n \"0.58795094\",\n \"0.5877771\",\n \"0.58770186\",\n \"0.5876711\",\n \"0.58746004\",\n \"0.5873826\",\n \"0.5861805\",\n \"0.58606863\",\n \"0.58584005\",\n \"0.5857105\",\n \"0.5850808\",\n \"0.58433425\",\n \"0.58340776\",\n \"0.58330256\",\n \"0.58297133\",\n \"0.5827206\",\n \"0.5802659\",\n \"0.58016104\",\n \"0.58010256\",\n \"0.58000004\",\n \"0.5799755\",\n \"0.57889\",\n \"0.57855445\",\n \"0.57844317\",\n \"0.57827526\",\n \"0.5782385\",\n \"0.5780374\",\n \"0.57794034\",\n \"0.5777248\",\n \"0.57765025\",\n \"0.5775527\",\n \"0.5773996\",\n \"0.57713157\",\n \"0.5765713\",\n \"0.5761763\",\n \"0.5761647\",\n \"0.57606745\",\n \"0.5759653\",\n \"0.5754263\",\n \"0.5752895\",\n \"0.57433134\",\n \"0.5738464\",\n \"0.57379603\",\n \"0.57345116\",\n \"0.57297015\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6743016"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":23394,"cells":{"query":{"kind":"string","value":"This is the main prediction adding function. It starts by grabbing a file to open from standard in, which contains one message board page. It processes each message contained in the page."},"document":{"kind":"string","value":"def main():\n\n # db_user = raw_input('DB username: ')\n db_user = 'oraclech'\n pw = getpass.getpass()\n\n odb = oracle_db.OracleDb(db_user, pw, database='oraclech_new')\n\n contest_id = raw_input('Current Contest ID? ')\n round_num = raw_input('Current Round Number? ')\n round_nums = round_num.split(',')\n topic_num = raw_input('Current Topic Number? ')\n page_num = raw_input('Current Page Number? ')\n\n contest = odb.GetContest(contest_id)\n\n try:\n file_path = '%s/r%dt%dp%02d.html' % (contest['Name'].lower(),\n int(round_nums[-1]),\n int(topic_num),\n int(page_num))\n file_path = '/home/oraclech/topics/' + file_path\n print file_path\n file = open(file_path, 'r')\n except IOError:\n file_path = raw_input('File to open (in /home/oraclech/topics/): ')\n file_path = '/home/oraclech/topics/' + file_path\n file = open(file_path, 'r')\n page = file.read()\n parser = message_board.Parser()\n messages = parser.Parse(page)\n\n for message in messages:\n message['Timestamp'] -= datetime.timedelta(minutes=TIME_OFFSET)\n ParsePredictions(odb, message, contest, round_nums)\n\n odb.Commit()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_poems(self):\n file = open(self.name, \"r\")\n content = file.readlines()\n for i in content:\n self.add_msg_and_index(i.strip())","def process_input_file(sess, char_dict, model_settings, model_vars, input_file):\n \n with open(input_file, 'r') as f:\n for s in f: # s is the line string\n if s and (len(s) > 0):\n chars = list(s.strip())\n cids = char_dict.chars2cids(chars)\n \n in_embedding = np.eye(model_settings['input_classes'])\n one_hot = in_embedding[cids]\n one_hot_by_t = np.expand_dims(one_hot, 1)\n\n # run session to retriev prob\n probs = process_sentence(sess, model_settings, model_vars, one_hot_by_t) \n labels = viterbi(probs)\n words = char_dict.chars2words(chars, labels)\n print('|'.join(words))","def start():\n\n global input, frameList, processPageList\n\n print \"\\n******************************************************************\"\n print \"\\tThis is a simulation for LRU replacement.\"\n print \"\\tAt any time you may choose to quit('q') this program.\"\n print \"******************************************************************\"\n\n # Open File\n with open(\"input.txt\") as f:\n original = f.readlines()\n\n # Remove \":\", \"\\n\"\n for line in original:\n input = line.replace(\":\", \"\")\n input = input.replace('\\n', \"\")\n\n # Split by tab, add to processList\n output = input.partition('\\t')\n\n # convert process to number\n pid = output[0]\n proc = int(pid[1])\n\n # convert binary page # to decimal\n page = int(str(output[2]), 2)\n\n # add process and page # to list\n processPageList.append([proc, page])","def main() -> None:\n\n # Retrieving the wiki URL\n url = get_api_url()\n print(url)\n\n # Creates file if it does not exist\n open(TEXT_FILE, \"a\")\n\n with open(TEXT_FILE, \"r\") as f:\n last_title = f.readline().strip()\n print(\"Starting from:\", last_title)\n\n # Retrieving the pages JSON and extracting page titles\n pages_json = get_pages_json(url, last_title)\n pages = pages_json[\"query\"][\"allpages\"]\n print(\"Pages to be scanned:\", pages)\n\n # Tagging operations\n for page in pages:\n curr_title = page[\"title\"]\n cats_to_add = get_categories(curr_title)\n if cats_to_add:\n print(\"Adding categories\", cats_to_add, \"to '%s'\" % curr_title)\n for cat in cats_to_add:\n add_category(curr_title, \"[[Category:\" + cat + \"]]\")\n\n # Extracting title to continue iterating from next run\n if \"continue\" in pages_json:\n continue_from_title = pages_json[\"continue\"][\"apcontinue\"]\n print(\"Continuing from:\", continue_from_title, \"next run.\")\n else:\n continue_from_title = \"\"\n\n with open(TEXT_FILE, \"w+\") as f:\n f.write(continue_from_title)\n print(\"Wrote\", continue_from_title, \"in\", TEXT_FILE)\n\n print(\"No pages left to be tagged\")","def main():\n token_dict_dict = {}\n all_dict = {}\n pronoun_proportion_list = []\n tag = 'PRP' # base tag for all pronouns, see 'https://www.clips.uantwerpen.be/pages/MBSP-tags' for more info\n\n for text in glob.glob(file_loc):\n file_title = os.path.basename(text).split('.')[0]\n\n with open(text, 'r') as f:\n speech = f.read()\n text_dict = {}\n\n try:\n #TextBlob goodness that tags all the words for me\n speech_blob = TextBlob(clean(speech))\n speech_blob.tags\n except:\n #for some reason Trump's address contained a unicode 128 character that I couldn't find\n #instead of getting rid of it in a single file, i decided to have an except that could catch that case in\n #all sitations and handle them accordingly\n\n #lets the user know that there was an issue, and that it's been handled\n print file_title,\n print \"contains unexpected unicode characters. they have been removed and the document has been processed\"\n\n #gets rid of all unicode characters. i could do this by default, but all the other files ran fine\n #so i didn't think it was worth it\n speech_blob = TextBlob(clean(speech.decode('unicode_escape').encode('ascii','ignore')))\n\n for token in speech_blob.tags:\n # builds the inital dictionary of data, only looks at words with a specified tag\n if tag in token[1]:\n try:\n text_dict[token[0]] += 1\n except:\n text_dict[token[0]] = 1\n try:\n all_dict[token[0]] += 1\n except:\n all_dict[token[0]] = 1\n #breaks the title into 3 pieces: number, president, date\n token_dict_dict[file_title] = text_dict\n partial_split, date = string.rsplit(file_title, '_', 1)\n num_pres, pres = string.split(partial_split, '_', 1)\n\n pronoun_proportion_list.append(\n (pres, date, total_to_proportion(pronoun_breakdown(token_dict_dict[file_title])))\n )\n create_pronoun_graph(sort_list_by_president_order(pronoun_proportion_list))","def main() -> None:\n\n\t# Retrieving the wiki URL\n\turl = get_api_url()\n\tprint(url)\n\n\t# Creates file if it does not exist\n\topen(TEXT_FILE, \"a\")\n\n\twith open(TEXT_FILE, \"r\") as f:\n\t\tlast_title = f.readline().strip()\n\t\tprint(\"Starting from:\", last_title)\n\n\tmodify_pages(url, last_title)\n\n\tprint(\"\\nNo pages left to be tagged\")","def main(fpath, html_dir):\n with open(fpath, \"r\") as fptr:\n pageid_emojis = {os.path.split(k)[-1]: v for k, v in json.load(fptr).items()}\n\n print(\"Loading emoji corpus. This may take a while...\")\n index, corpus = [], []\n for html_fpath in glob.glob(os.path.join(html_dir, \"*\")):\n with open(html_fpath, \"r\") as fptr:\n html = fptr.read()\n\n tree = etree.fromstring(html)\n text = \"\".join(tree.xpath(\".//text()\"))\n corpus.append(text)\n\n pageid = os.path.splitext(os.path.split(html_fpath)[-1])[0]\n index.append(pageid_emojis[pageid])\n\n vectorizer = sklearn.feature_extraction.text.TfidfVectorizer(\n max_features=10000, min_df=1, preprocessor=preprocess\n )\n\n print(\"Fitting Model. This may take a while...\")\n weights = vectorizer.fit_transform(corpus)\n\n model = {\n \"weights\": weights,\n \"columns\": vectorizer.get_feature_names(),\n \"index\": index,\n }\n\n with open(\"build/model.pckl\", \"wb\") as fptr:\n pickle.dump(model, fptr)","def Run():\n file_name = AskForFileName()\n file_content = ReadFileContents(file_name)\n head_list = BuildHeadList(file_content)\n atom_list = BuildAtomList(file_content)\n tail_list = BuildTailList(file_content)\n WriteNewFile(head_list, atom_list, tail_list)","def main(inputfname, outfname):\n with open(inputfname, 'rt', encoding='utf8') as fh:\n # first block\n reviews = []\n while True:\n comment = next(fh).strip()\n if not comment:\n # blank line, block separator\n break\n url_moviedb = next(fh).strip()\n url_moviedb, movie_id = fix_moviedb(url_moviedb)\n reviews.append((comment, url_moviedb, movie_id))\n\n # second block\n futures = []\n while True:\n try:\n title = next(fh).strip()\n except StopIteration:\n break\n if not title:\n continue\n url_moviedb = next(fh).strip()\n url_moviedb, movie_id = fix_moviedb(url_moviedb)\n futures.append((title, url_moviedb, movie_id))\n\n lines, viewed = process_reviews(reviews)\n lines.append(\"\")\n lines.extend(process_futures(futures))\n lines.append(\"\")\n\n pelis_lines, raw_pending = proc_pelshtml(futures, viewed)\n\n lines.extend(line.format(enter='', space=' ') for line in raw_pending)\n lines.append(\"\")\n lines.extend(pelis_lines)\n lines.extend(line.format(enter='<br/>', space=' ') for line in raw_pending)\n\n with open(outfname, 'wt', encoding='utf8') as fh:\n fh.write(\"\\n\".join(lines))","def data_preprocessing():\n lineid_content = get_lineid_content()\n print('Read movie_lines.txt file complete...')\n convos = get_convos()\n print('Read movie_conversations.txt file complete...')\n print('Building dataset')\n get_data(lineid_content, convos)","def main():\n feed_db, entry_db = openDBs(FEED_DB_FN, ENTRY_DB_FN)\n\n feeds = [ x.strip() for x in open(FEEDS_FN, \"r\").readlines() ]\n \n entries = getNewFeedEntries(feeds, feed_db, entry_db)\n \n if len(entries) > 0:\n out_fn = HTML_FN % time.strftime(\"%Y%m%d-%H%M%S\")\n writeAggregatorPage(entries, out_fn, DATE_HDR_TMPL, FEED_HDR_TMPL, \n ENTRY_TMPL, PAGE_TMPL)\n emailAggregatorPage(FROM_ADDR, TO_ADDR, SUBJECT, SMTP_HOST, out_fn)\n \n closeDBs(feed_db, entry_db)","def main(nlp, file_path, final_file_path, from_line=0, to_line=None):\n with open(final_file_path, \"w\") as parsed_file:\n with open(file_path) as cnn_dm:\n line = cnn_dm.readline().strip()\n article_idx = 0\n while article_idx < from_line:\n line = cnn_dm.readline().strip()\n article_idx += 1\n if to_line is None:\n while line is not None and line != '':\n process_line(nlp, line, parsed_file)\n article_idx += 1\n print(\"{} articles processed from file {}\".format(article_idx, file_path))\n line = cnn_dm.readline().strip()\n else:\n while article_idx < to_line and line is not None and line != '':\n process_line(nlp, line, parsed_file)\n article_idx += 1\n print(\"{}th article processed from file {}\".format(article_idx, file_path))\n line = cnn_dm.readline().strip()","def train(self, train_data):\n with open(train_data, 'r') as train_data:\n while True:\n tokens = train_data.readline().split()\n pos = train_data.readline().split()\n labels = train_data.readline().split()\n if not tokens or not pos or not labels:\n break\n # Generate transition probabilities\n for i in range(0, len(labels) - self.N_VALUE + 1):\n self.add_label_sequence(labels[i:i + self.N_VALUE])\n # Generate lexical generation probabilities\n for i in range(0, len(tokens)):\n token = tokens[i].lower()\n label = labels[i]\n self.add_word_tag(token, label)\n self.handle_unknowns()","def process_training_data(train_page_names):\n\n print('Reading data')\n images_train = []\n labels_train = []\n for page_name in train_page_names:\n images_train = utils.load_char_images(page_name, images_train)\n labels_train = utils.load_labels(page_name, labels_train)\n labels_train = np.array(labels_train)\n\n print('Extracting features from training data')\n bbox_size = get_bounding_box_size(images_train)\n fvectors_train_full = images_to_feature_vectors(images_train, bbox_size)\n\n model_data = dict()\n model_data['labels_train'] = labels_train.tolist()\n model_data['bbox_size'] = bbox_size\n\n print('Reducing to 10 dimensions')\n fvectors_train = reduce_dimensions(fvectors_train_full, model_data)\n\n model_data['fvectors_train'] = fvectors_train.tolist()\n\n with open('ListOfOneHundredThousandWords.txt') as word_file:\n words_list = [words.replace(\" \", \"\").strip('\\n').upper() for words in word_file]\n model_data['words'] = words_list\n\n return model_data","def __init__(self, messages):\n self.pq = PriorityQueue()\n self.cover = []\n self.words_in_cover = set()\n\n # add message dictionary and process all messages (add to priority queue)\n self.message_corpus = messages\n # TODO: process messages prior to ingestion\n for msg_id in self.message_corpus.iterkeys():\n self.add_entry(msg_id)","def main():\n with open(\"page_data.yaml\", 'r') as inputstr:\n config_data = yaml.safe_load(inputstr)\n ointf = OutputInterface('template.txt')\n table_data = get_song_artist_matches()\n ofilen = config_data['directory'] + os.sep + 'common_songs.html'\n title = 'Song Titles and Band Name Overlap'\n header = ['No.', 'Artist', 'Peak', 'Date', 'Song/Artist', 'Peak',\n 'Date', 'Song']\n ointf.build_page(ofilen, title, header, fmt_table(table_data))\n ointf.inject(XTRAEDIT)\n ointf.output()","def preprocess(self):\n\n self._build_labels_dict(['one', 'two', 'three', 'four', 'five'])\n\n with open(self.data_path + self.file_name, 'rb') as csvfile:\n\n reader = csv.reader(csvfile, delimiter=\",\")\n for row in reader:\n self.texts.append(row[1])\n self.labels.append(self.labels_index[row[0]])\n\n print('Found %s texts.' % len(self.texts))","def process(self):\n\n linelang = defaultdict(int)\n wordlang = defaultdict(int)\n\n linefont = defaultdict(int)\n wordfont = defaultdict(int)\n\n inputfiles = self.input_files\n for input_file in inputfiles:\n\n alignurl = input_file.url\n pcgts = parse(alignurl, True)\n page = pcgts.get_Page()\n regions = page.get_TextRegion()\n\n for region in regions:\n lines = region.get_TextLine()\n\n for line in lines:\n try:\n llang = line.primaryLanguage\n linelang[llang] += 1\n except TypeError:\n pass\n\n try:\n lfont = line.fontFamily\n linefont[lfont] += 1\n except TypeError:\n pass\n\n words = line.get_Word()\n for word in words:\n try:\n wlang = word.language\n wordlang[wlang] += 1\n except TypeError:\n pass\n\n try:\n wfont = word.get_TextStyle().fontFamily\n wordfont[wfont] += 1\n except TypeError:\n pass\n\n #predominant language\n try:\n lang = max(linelang, key=lambda k: linelang[k])\n except TypeError:\n try:\n lang = max(wordlang, key=lambda k: wordlang[k])\n except TypeError:\n lang = 'German'\n\n #predominant font\n try:\n font = max(linefont, key=lambda k: linefont[k])\n except TypeError:\n try:\n font = max(wordfont, key=lambda k: wordfont[k])\n except TypeError:\n font = 'Antiqua'\n\n\n print(lang)\n print(font)","def process(self):\n # Opening and preprocessing of the input file\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\n if self.options.mbtiles_fromdisk:\n i_parm=10\n if self.options.mbtiles_todisk:\n i_parm=11\n if self.options.verbose:\n print \"GDAL2MbTiles :mbtiles from/to disk [\",i_parm,\"] mbtiles_fromdisk[\",self.options.mbtiles_fromdisk,\"] mbtiles_todisk[\",self.options.mbtiles_todisk,\"]\"\n self.mbtiles_setup(i_parm)\n return\n else:\n if self.options.verbose:\n print \"GDAL2MbTiles :tile creation mbtiles[\",self.options.mbtiles,\"]\"\n self.open_input()\n # Generation of main metadata files and HTML viewers\n self.generate_metadata()\n # Generation of the lowest tiles\n self.generate_base_tiles()\n # Generation of the overview tiles (higher in the pyramid)\n self.generate_overview_tiles()\n # Generating of KML\n self.generate_kml()","def main():\n file = \"http://icarus.cs.weber.edu/~hvalle/hafb/words.txt\"\n words = fetch_words(file)\n print_items(words)","def gnumed_hl7_importer(file_name):\n #TODO ERROR for opening a file\n file = open(file_name)\n\n message = ''\n\n find_message_header = re.compile(r\"^MSH\")\n #TODO Have it be able to process both a directory or an individual file\n for n in file:\n if re.match(find_message_header, n):\n if message != '':\n process_lab_message(message)\n message = n + '\\r'\n else:\n message = message + n + '\\r'","def main():\n if sys.argv[1] == 'train':\n build_training_data()\n main_trainer()\n\n if sys.argv[1] == 'predict' and len(sys.argv) > 2:\n from predict import classification\n from AdaboostPredict import decision_stumps\n input_file = open(sys.argv[2])\n data = input_file.readlines()\n print(\"Decision Tree prediction\")\n for i in data:\n print(classification(i, i.strip().split()))\n\n print(\"\\nAdaboost prediction\")\n\n for i in data:\n print(decision_stumps(i, i.strip().split()))\n\n elif sys.argv[1] == 'predict':\n print('Wrong usage for prediction. Please supply a file after predict')","def parse_input():\n with open(\"input_07.txt\", \"r\") as f:\n for line in f:\n Bag(line)","def main(training_file_name):\n attribute, inverse = build_classifier(training_file_name)\n trained_file = open(TRAINED_FILE_NAME, mode='w')\n prolog(trained_file)\n write_body(trained_file, attribute, inverse)\n epilog(trained_file)","def process_from_file():\r\n global default_input_path\r\n print \"JoomFind v 1.0\"\r\n print \"\\n\\nTrying to read URL(s) form \" + default_input_path + \" file...\\n\"\r\n try:\r\n if not default_input_path:\r\n f = open(\"urls.txt\")\r\n else:\r\n f=open(default_input_path)\r\n cwd=os.getcwd()\r\n file_path = cwd + path_slash + f.name\r\n\t# extracting url's to list from file\r\n start_urls = [url.strip() for url in f.readlines() if url[0] not in ['#',' ',\"\\n\"]]\r\n if not start_urls:\r\n print \"File is empty. Add some URL(s) first.\\n\"\r\n f.close()\r\n return 0\r\n except:\r\n print \"File not found. Make sure it exists.\\n\"\r\n return 0\r\n #print start_urls\r\n \r\n num=str(len(start_urls))\r\n print \"Found \" + num + \" URL(s) on \" + time.asctime(time.localtime(time.time())) + \"\\n\"\r\n \r\n of=open(default_output_path,'a+')\r\n of.write(\"\\n\\n\\tScanning \" + num + \" URL(s) \")\r\n of.write(\"\\n\\n\\tDate\\Time : \" + time.asctime(time.localtime(time.time())) )\r\n of.write(\"\\n\\n\\tInput file path : \" + default_input_path + \"\\n\\n\")\r\n of.close()\r\n \r\n for url in start_urls:\r\n global provided_url\r\n provided_url=url\r\n print \"\\nWorking on URL \" + str(start_urls.index(url)+1) + \": \" + provided_url\r\n processing()\r\n print \"\\nAll done! Check '\" + default_output_path +\"' file for results.\\n\"","def train_model(filename):\n counts = get_file_counts(filename)\n new_file = open(filename, \"r\")\n num_lines = 0\n for line in new_file:\n num_lines += 1 \n #number of lines in file\n return counts_to_probs(counts, num_lines)","def pre_process(fname, num_ex, alt_speaker):\n conversation = []\n with PathManager.open(fname) as f:\n lines = f.readlines()\n random.shuffle(lines)\n lines = lines[:num_ex]\n for line in lines:\n data = json.loads(line)\n dialogue = data[\"dialog\"]\n for item in dialogue:\n speaker = item[0]['id']\n text = item[0]['text']\n conversation += [(speaker, text)]\n conversation += [(END_OF_CONVO, END_OF_CONVO)]\n\n return conversation","def parse_results_file(filename):\n\tfile = open(filename, 'r')\n\tpretext=[line for line in file.readlines() if line.strip()]\n\tfile.close()\n\n\ttext = []\n\tprocessed = []\n\tlanguages = 'NONE'\n\tID = 'NONE'\n\t\n\tmoreheader = raw_input('Extra header labels from question field (e.g.: item,condition,factor1,factor2): ')\n\tstim_type = raw_input('What type are your stims? (i.e. AcceptabilityJudgment): ')\n\toutput_loc = raw_input('Where would you like to put your parsed file? (enter filename path): ')\n\t\n\t#takes out comments\n\tfor line in pretext:\n\t\tif re.match('#', line):\n\t\t\tcontinue\n\t\telse:\n\t\t\ttext.append(line)\n\n\tfirst = 1;\n\n\tfor line in range(len(text)):\n\t\t#get their info\n\t\tif re.search('Form', text[line]):\n\t\t\tif re.search('number', text[line]):\n\t\t\t\tID = re.split('number,', text[line])[1].strip()\n\t\t\telif re.search('age', text[line]):\n\t\t\t\tlanguages = re.split('age,', text[line])[1].strip()\n\n\t\t#looks for the main stimulus type, as entered earlier\t\t\n\t\tif re.search(stim_type, text[line]):\n\t\t\tif first:\n\t\t\t\t#print 'first'\n\t\t\t\tprocessed.append(str(ID+ ','+languages+','+text[line]))\n\t\t\t\tfirst=0\n\t\t\telse:\n\t\t\t\ttoAmend = processed.pop()\n\t\t\t\t#print str('toAmend: ' + toAmend)\n\t\t\t\ttoAdd=''\n\t\t\t\tsplits = re.split('NULL,', text[line])\n\t\t\t\tfor thing in splits[1:]:\n\t\t\t\t\tif thing is not '':\n\t\t\t\t\t\ttoAdd = str(toAdd + ',' + thing.strip(','))\n\t\t\t\t#print str('toAdd: ' + toAdd)\n\t\t\t\tprocessed.append(str(toAmend.strip()+ toAdd))\n\t\t\t\tfirst = 1\n\n\t\t#if the line is a question line, there's more to append\n\t\tif re.search('Question', text[line]):\n\t\t\ttoAmend = processed.pop()\n\t\t\tpart = re.split('\\$', text[line])[1]\n\t\t\tpart.strip('$')\n\t\t\tparts = part.split('%2C')\n\t\t\tprocessed.append(str(toAmend.strip()+ ','+ string.join(parts, ',')+'\\n'))\n\t\t\t\n\toutput = open(output_loc, 'w')\n\n\theader = 'ID,Languages,Time sent,MD5 Hash of IP Address,Controller,Item Number,Element Number,Type,Group,Stimulus,Answer,RT,'\n\n\toutput.write(str(header+moreheader+'\\n'))\n\n\t#put it all into a text file\n\tfor line in processed:\n\t\toutput.write(line)\n\toutput.close()","def process(self, message, **kwargs):\n if self.classifier is None:\n self.train()\n\n if message.get(\"text\") is not None:\n sid = SentimentIntensityAnalyzer()\n res = sid.polarity_scores(message.get(\"text\"))\n key, value = max(res.items(), key=lambda x: x[1])\n\n if key == \"pos\":\n key = \"Positive\"\n elif key == \"neg\":\n key = \"Negative\"\n else:\n key = \"Neutral\"\n\n custom_tokens = self.remove_noise(word_tokenize(message.get(\"text\")))\n t = self.classifier.prob_classify(dict([token, True] for token in custom_tokens))\n\n sentiment = 'Positive' if t.prob('Positive') > t.prob('Negative') else 'Negative'\n confidence = max(t.prob('Positive'), t.prob('Negative'))\n\n found, entry = self.manager.getMovieName(message.get(\"text\"))\n movie = str(entry['original_title'].item())\n \n genre_entry, aux_found_genre = self.manager.fuzzy_find_genre(message.get(\"text\"), with_ratio=True)[0]\n genre = genre_entry\n \n\n if len(message.get(\"text\")) > 20:\n entity = self.convert_to_rasa(sentiment, confidence, name=\"our_sentiment_extractor\")\n else:\n entity = self.convert_to_rasa(key, value, name=\"builtin_sentiment_extractor\")\n\n message.set(\"sentiment\", [entity], add_to_output=True)\n\n entity = self.convert_movie_to_rasa(movie, found)\n message.set(\"movies\", [entity], add_to_output=True)\n\n if message.get(\"text\").strip() == \"no\":\n found_genre = False\n else:\n found_genre = True if aux_found_genre > 80 else False\n\n entity = self.convert_movie_to_rasa(genre, found_genre, entity=\"genres_detected\")\n print(entity)\n message.set(\"genres\", [entity], add_to_output=True)","def process_file(file_name):\n pass # delete this line and replace with your code here","def load_test_page(page_name, model):\n print(\"load_test_page\")\n\n print(\"\\tLoading the image feature vectors...\")\n bbox_size = model['bbox_size']\n images_test = utils.load_char_images(page_name)\n fvectors_test = images_to_feature_vectors(images_test, bbox_size)\n\n print(\"\\tPerforming dimensionality reduction...\")\n fvectors_test_reduced = reduce_dimensions(fvectors_test, model)\n\n print(\"\\tGetting the noise factor and calculating how many neighbours to use...\")\n im = np.array(Image.open(page_name + '.png'))\n #I use the full margins (200px on every side) to sample white areas.\n margin = 200\n white_sample = np.append(im[:margin,:],im[im.shape[0]-margin:,:])\n white_sample = np.append(white_sample, \n np.append(im[margin:im.shape[0]-margin,:margin],\n im[margin:im.shape[0]-margin,im.shape[1]-margin:]))\n neighbours_to_use = np.array([round(np.exp(np.var(white_sample)/2250))])\n neighbours_to_use.resize((1,10))\n print(\"\\t{0}-nearest neighbours will be used for '{1}'\".format(int(neighbours_to_use[0,0]), page_name))\n\n #Storing info on how many neigbours to use at the end of the list of feature\n # vectors, like page meta-data. Technically sneakily adds an extra dimension\n # to each feature vector, but as it's just \"one more number\", I emailed\n # Jon and he permitted me to do this.\n fvectors_test_reduced = np.vstack((fvectors_test_reduced, neighbours_to_use))\n\n print(\"\\tDone.\\n\")\n return fvectors_test_reduced","def createPostingList():\n try :\n ##### peut etre à mettre dans une fonction\n file_reader_last_read_list = initialize_file_readers()\n for idx, file_reader_and_last_read in enumerate(file_reader_last_read_list):\n file_reader_last_read_list[idx]=read_line_and_update(file_reader_and_last_read=file_reader_and_last_read)\n current_word = min_top_word(file_reader_last_read_list=file_reader_last_read_list)\n final_file = open(POSTING_LIST_PATH, \"w\")\n ######\n\n doc_dict = get_doc_dict(DOC_LIST_PATH)\n nb_doc = len(doc_dict)\n\n ### autre function\n i = 0 \n while current_word != \"|||\": \n current_PL = current_word_PL(current_word=current_word, file_reader_last_read_list=file_reader_last_read_list,\\\n doc_dict=doc_dict, nb_doc=nb_doc ) \n curent_string = \"\"\n for key, value in current_PL.items():\n curent_string = \" \" + str(key) + \" \" + str(value) + curent_string\n curent_string = current_word + curent_string\n final_file.write(curent_string + \"\\n\")\n current_word = min_top_word(file_reader_last_read_list=file_reader_last_read_list)\n #if i %1000 == 0:\n #print(i/1000)\n i +=1\n ####\n \n final_file.close()\n close_file_readers(file_reader_last_read_list=file_reader_last_read_list)\n \n except Exception as ex:\n print(ex)\n final_file.close()\n close_file_readers(file_reader_last_read_list=file_reader_last_read_list)","def process_input(fname,onlynugget,onlyarg):\n content=utils.readFileEncode(fname,'utf8')\n lines = content.split('\\n')[:-1]\n sentences=[]\n labels=[]\n sent=[]\n label=[]\n for i in range(len(lines)):\n if len(lines[i])>3:\n words=lines[i].split('\\t')\n word={'originalText':words[0],'offset':int(words[1])}\n sent.append(word)\n if onlynugget:\n if words[2] in NuggetList10:\n label.append(words[2]) \n else:\n label.append('O')\n elif onlyarg:\n if words[2] in ArgumentList:\n\n if 'Software' in words[2]:\n label.append(words[2][0:2]+'System')\n else:\n label.append(words[2])\n else:\n label.append('O')\n else:\n if len(sent)>0 and len(label)>0: \n sentences.append(sent)\n labels.append(label) \n sent=[]\n label=[]\n elif len(sent)==0 and i < len(lines)-1:\n sentences.append([])\n labels.append([])\n \n return sentences,labels","def _read(self, file_name):\n f = open(file_name)\n lines = f.readlines()\n begin = 0\n end = 0\n while end < len(lines):\n op = ''\n for l in lines[begin:]:\n end += 1\n op = l.split()[0]\n if op in operations:\n self.operations.append(op)\n break\n if op == '=push':\n nfa = Automaton(lines[begin:end - 1])\n self.aut_to_push.append(nfa)\n begin = end\n f.close()","def process_file(filename, skip_header):\n hist = {}\n fp = open(filename, encoding='utf8')\n\n if skip_header:\n skip_gutenberg_header(fp)\n\n\n for line in fp:\n if line.startswith('*** END OF THIS PROJECT'):\n break\n line = line.replace('-', ' ')\n strippables = string.punctuation + string.whitespace\n\n for word in line.split():\n # remove punctuation and convert to lowercase\n word = word.strip(strippables)\n word = word.lower()\n\n #update the histrogram\n hist[word] = hist.get(word, 0) + 1\n\n\n return hist","def main():\n filepath = input(\"Enter the Source File: \")\n with open(filepath, encoding=\"utf-8\") as f:\n sentences = f.readlines()\n sentences = \" \".join(sentences)\n\n summary = summarize_sentences(sentences)\n\n filepath_index = filepath.find(\".txt\")\n outputpath = filepath[:filepath_index] + \"_lexRank.txt\"\n\n with open(outputpath, \"w\") as w:\n for sentence in summary:\n w.write(str(sentence) + \"\\n\")","def process():","def process_messages(self):\n pass","def process(self):\n\n return self._load_next_file()","def process_paper(filename):\n\n # Start time\n start_time = time.time()\n\n # Read in the paper\n paper = useful_functions.read_in_paper(filename, sentences_as_lists=True)\n\n # Extract the gold summary\n gold = paper[\"HIGHLIGHTS\"]\n gold_string_list = [\" \".join(x) for x in gold]\n\n # Extract the title\n title = paper[\"MAIN-TITLE\"][0]\n title_string = \" \".join(title)\n\n # Extract the abstract\n abstract = paper[\"ABSTRACT\"]\n abstract_string_list = [\" \".join(x) for x in abstract]\n\n # Extract the keyphrases\n try:\n keyphrases = paper[\"KEYPHRASES\"][0]\n except IndexError:\n keyphrases = []\n\n # Turn the paper into a single string and calculate the bag of words score\n paper_string = \" \".join([\" \".join(x) for key, val in paper.iteritems() for x in val])\n bag_of_words = useful_functions.calculate_bag_of_words(paper_string)\n\n # Get the paper as a list of sentences, associating each sentence with its section name - will be used by oracle\n # to find best summary sentences.\n paper_sentences = [(\" \".join(x), key) for key, val in paper.iteritems() for x in val\n if key != \"ABSTRACT\"]\n\n # Create a list of sentences, their ROUGE-L scores with the Highlights and the section they occur in\n # (as a string)\n sents_scores_secs = []\n\n for sentence, section in paper_sentences:\n # For some reason the candidate sentence needs to be the only item in a list\n r_score = rouge.calc_score([sentence], gold_string_list)\n\n sents_scores_secs.append((sentence.split(\" \"), r_score, section))\n\n # Sort the sentences, scores and sections into descending order\n sents_scores_secs = sorted(sents_scores_secs, key=itemgetter(1), reverse=True)\n\n pos_sents_scores_secs = sents_scores_secs[:num_summary]\n neg_sents_scores_secs = sents_scores_secs[num_summary:]\n\n if len(neg_sents_scores_secs) < len(pos_sents_scores_secs):\n print(\"{}**** NOT A SUFFICIENT AMOUNT OF DATA IN PAPER {}, IGNORING PAPER ****{}\".format(\n Color.RED, filename, Color.END))\n return\n\n # Positive sentences\n positive_sents_secs_class = [(sent, sec, 1) for sent, _, sec in pos_sents_scores_secs]\n\n # Negative sentences\n\n # Take the sentences not used as positive and reverse it to have worst scores first then take an equal number\n neg_sents_scores_secs = [x for x in reversed(neg_sents_scores_secs)][:len(positive_sents_secs_class)]\n negative_sents_secs_class = [(sent, sec, 0) for sent, _, sec in neg_sents_scores_secs]\n\n # Don't create data from this paper if it's less than 40 sentences - i.e. there would be more positive than\n # negative data. The data needs to be balanced.\n #if len(positive_sents_secs_class) != len(negative_sents_secs_class):\n # print(\"{}**** NOT A SUFFICIENT AMOUNT OF DATA IN PAPER {}, IGNORING PAPER ****{}\".format(\n # Color.RED, filename, Color.END))\n # return\n\n # Concatenate the positive and negative sentences into a single data item and shuffle it\n data = positive_sents_secs_class + negative_sents_secs_class\n random.shuffle(data)\n\n # Average word vectors of each sentence and convert to list for JSON serialisation\n sentvecs_secs_class = [(useful_functions.sentence2vec(sent).tolist(), sec, y) for sent, sec, y in data]\n\n # Calculate features for each sentence\n features = [useful_functions.calculate_features(sent, bag_of_words, document_wordcount, keyphrases,\n abstract_string_list, title_string, sec)\n for sent, sec, y in data]\n\n # Calculate abstract vector\n abs_vector = useful_functions.abstract2vector(abstract_string_list).tolist()\n\n # Description of the data\n description_text = \"All text is of the form of a list of lists, where each sentence is a list of words. The\" \\\n \" sentences are of the form [(sentence (as a list of words), section in paper,\" \\\n \" classification)]. The sentence vectors are of a similar form, except the sentence text is\" \\\n \" replaced with the vector representation of the sentence. The features are of the form \" \\\n \"[(AbstractROUGE, TF-IDF, Document_TF-IDF, keyphrase_score, title_score, numeric_score,\" \\\n \" sentence_length, section)]. The dimensions of each sentence vector are [1x100]. The \" \\\n \"abstract vector is a single [1x100] vector also.\"\n\n # The data item that will be written for this paper\n data_item = {\n \"filename\": filename,\n \"gold\": gold,\n \"title\": paper[\"MAIN-TITLE\"],\n \"abstract\": abstract,\n \"abstract_vec\": abs_vector,\n \"sentences\": data,\n \"sentence_vecs\": sentvecs_secs_class,\n \"sentence_features\": features,\n \"description\": description_text\n }\n\n # Write the data out\n with open(TRAINING_DATA_WRITE_LOC + filename.strip(\".txt\") + \".json\", \"wb\") as f:\n json.dump(data_item, f)\n\n print(\"--> Finished processing {}, took {} seconds, data length: {}.\".format(\n filename, (time.time() - start_time), len(data)))","def Subtask4_pre_train_3():\n train_data = np.load(PATH + 'pre_train_2_Subtask4.npy', allow_pickle=True).item()\n\n evidence = []\n for d in train_data.items():\n for i in range(5):\n evidence.append(d[1][i])\n\n files = os.listdir(PATH + 'data/wiki-pages/wiki-pages/')\n documents = {}\n for i in files:\n with open(os.path.join(PATH + 'data/wiki-pages/wiki-pages/', i)) as fp:\n lines = fp.readlines()\n for line in lines:\n line = eval(line)\n if line['id'] in evidence:\n text = line['lines']\n documents[line['id']] = text\n with open(PATH + 'pre_train_3_Subtask4.txt', 'w', encoding='utf-8') as f:\n f.write(str(documents))","def main(board_name, card_name, checklist_name, api_key, token, file):\n items = [line.strip() for line in file]\n trello = Client(api_key, token)\n board = utils.get_board_by_name(trello, board_name)\n card = utils.get_card_by_name(board, card_name)\n utils.add_checklist(card, checklist_name, items)","def get_messages(message_count):\r\n\r\n file = open('messages.htm', encoding='UTF-8')\r\n\r\n html = file.read().split('</p>')\r\n file.close()\r\n\r\n TOTAL[0] = len(html) - 1\r\n\r\n # Gets rid of formatting at the beginning\r\n start = html[0].find('<div class=\"message\">')\r\n while not html[0][start].isnumeric():\r\n start += 1\r\n html[0] = html[0][start:]\r\n\r\n html.pop()\r\n\r\n threads = []\r\n\r\n que = Queue(maxsize=50)\r\n for line in html:\r\n try:\r\n clean_line = BeautifulSoup(line, 'lxml').getText()\r\n except Exception:\r\n print('Install lxml')\r\n #print(line)\r\n if len(clean_line) != 0:\r\n t = threading.Thread(target=add_option,\r\n args=(message_count, que, threads))\r\n que.put(clean_line)\r\n\r\n t.daemon = True\r\n t.start()\r\n threads.append(t)\r\n\r\n que.join()","def load(self):\n prob_data = open(self.probsfile,\"r\",encoding=\"utf-8\")\n self.probs = {trigram.split(\"\\t\")[0]:float(trigram.split(\"\\t\")[2]) for trigram in prob_data.readlines()}","def main ():\n\n\tfio = fileIo('input.txt')\n text = fio.getInput()\n\n\tp = re.compile(r'#?\\d[\\s\\.]?[\\s]?')\n\tout = filter(None, p.split(text))\n\ti = 0\n\tlistOfLists = []\n\t\n\n\tfor s in out:\n\t\ti += 1\n\t\ttext = nltk.word_tokenize(s)\n\t\tpos = nltk.pos_tag(text)\n\t\tpattern = \"NP: {<DT>?<JJ>*<NN>}\"\n\t\tNPChunker = nltk.RegexpParser(pattern)\n\t\tresult = NPChunker.parse(pos)\n\t\tlistOfLists.append( result )\n\n\tprint \"Noun Count:\\n\" + str(countNouns( listOfLists ))\n\tprint \"Verb Count:\\n\" + str(countVerbs( listOfLists ))\n\tprint \"Adjective Count:\\n\" + str(countAdjectives( listOfLists ))","def main():\r\n save_file_location = \"Item_List.txt\"\r\n data_file_a = open(save_file_location, \"a\") # Opens ItemList.txt which\r\n # is accessible in the file variable, in append mode (using this so that\r\n # if the file exists, nothing happens, but if it does not exist, it gets\r\n # created from w3schools.com\r\n data_file_a.close() # Close the file, I now know it exists\r\n loaded_list = load_from_file(save_file_location)\r\n print(\"Welcome to the To-Do List - Version: 0.1.2\")\r\n divider(42) # Length of welcome statement above\r\n menu_loop(loaded_list, save_file_location)","def __init__(self, seqfile, predfile):\n assert seqfile.endswith(\".mpd\"), predfile.endswith(\".pred\")\n\n self._seqfile = seqfile\n self._predfile = predfile\n self._parse = None # to stock the parsed sequences\n self._motifs = None","def train(self, trainfile):","def run():\n logger.info(f\"Process started:\")\n logger.info(f\"Converting Glove file to Word2Vec format\")\n convert_to_word2vec.convert(\n \"./data/source/glove.6B.50d.txt\", \"./data/source/glove.6B.50d.w2vformat.txt\"\n )\n\n logger.info(f\"Extracting Click Stream data\")\n extract_click_stream_data()\n\n logger.info(\"Extracting Wiki articles\")\n extract_wiki_articles()\n\n logger.info(f\"Generating Clickstream dataset\")\n generate_datasets()\n\n logger.info(\"Tokenizing articles\")\n WikiArticlesTokenizer().process()\n\n logger.info(\"Creating dataset with Wiki Articles\")\n create_wiki_articles_dataset()","def mk_eng_txt_files(self, **rewrite):\n\n\n print \"mk_eng_txt_files: RETRIEVING PAGE_LIST..........\"\n page_list = c_m.l_of_l_read(self.page_list_path)\n\n if len(page_list) < 1: # handling empty page_list case\n print \"mk_eng_txt_files: PAGE LIST IS NOT POPULATED, RUN HTML_File_Maker AND Text_Extractor MODULES FIRST\"\n else: # handling page_list for partially transalted sites\n print \"mk_eng_txt_files: IN CASE PAGE LIST ALREADY HAD SOME ENG_TEXT ENTRIES SETTING INITIAL new_page_list TO LAST KNOWN PAGE_LIST VERSION\"\n self.new_page_list = copy(page_list)\n\n\n\n # iterating throug unique text per page txts\n for data_set in page_list:\n self.p_text_f_name = data_set[2]\n print \"mk_eng_txt_files: TRANSLATING TEXT FROM FILE %s\" % self.p_text_f_name\n\n self.eng_p_text_f_name = \"eng_\" + self.p_text_f_name\n self.eng_p_text_f_path = self.text_eng_folder_path + self.eng_p_text_f_name\n\n self.page_text = c_m.simply_read(self.text_folder_path, self.p_text_f_name)\n\n # if page has less than 10 symbols it is not translated\n if len(self.page_text) < 10:\n print \"mk_eng_txt_files: NOT WORTH TRANSLATING, WRITING AS IS AND SKIPPING...\"\n c_m.simply_write(self.page_text, self.eng_p_text_f_path)\n\n elif len(self.page_text) > self.max_page_length:\n print \"mk_eng_txt_files: PAGE TEXT IS TOO LONG DEVIDING TO PARTS, TRANSLATING AND GETTING BACK FULL PAGE TEXT\"\n text_output = self.get_text_parts(**rewrite)\n\n else: # 10 < len(page_text) < 2000\n\n if rewrite[\"rewrite\"]:\n print \"mk_eng_txt_files: TRANSLATING IN REWRITE MODE\"\n text_output = self.get_text()\n\n\n elif not os.path.exists(self.eng_p_text_f_path):\n print \"mk_eng_txt_files: TRANSLATING IN ONLY ONCE MODE\"\n text_output = self.get_text()\n\n else:\n print \"mk_eng_txt_files: SKIPPING FILE, ALREADY TRANSLATED\"\n # continue\n\n # print \"WRITING TRANSLATED OUTPUT TO FILE: \", self.eng_p_text_f_name\n # c_m.simply_write(text_output, self.text_eng_folder_path, self.eng_p_text_f_name) \n data_set.append(self.eng_p_text_f_name) # updating dataset with eng_text file name\n self.new_page_list.append(data_set) # updating page list with updated entry\n\n\n print \"mk_eng_txt_files: DONE TRANSLATING SITE %s \" % self.domain\n print \"mk_eng_txt_files: UPDATING PAGE LIST WITH ENG TEXT FILE NAMES\"\n c_m.l_of_l_write(self.new_page_list, self.page_list_path)\n print \"mk_eng_txt_files: SITE TRANSLATION FINISHED, CLOSING CHROME WEBDIRVER\"\n self.loaded_driver.quit()","def __init__(self, fileinit, filegoal):\n \n self.board = Board(filegoal)\n self.numbernodes = 0\n Io = IO(fileinit)\n Io.init_reader()\n self.boxes = []\n i = 0\n j = 0\n for line in Io.file :\n for elem in line :\n if elem == \"$\" :\n self.boxes.append(Box(i,j))\n elif elem == \"@\":\n self.char = Char(i,j)\n j+=1\n j=0\n i+=1\n self.direction = [Direction.UP,Direction.DOWN,Direction.LEFT,Direction.RIGHT]\n \n self.goalsize = len(self.board.positionGoal)\n self.listCombi = heuristic.make_combi(self.board.positionGoal,self.goalsize)\n self.mini = 10000\n Problem.__init__(self, State(self.board,self.boxes,self.char,[]))","def main(args):\n\tprint(\"Reading the data\")\n\tdataDict = loadData(args.f, args.s)\n\n\tuseBothHalves = args.full\n\tuseEmb = args.emb or args.full\n\n\t#unpack the data\n\tif useEmb:\n\t\ttrainData = setupEmbeddings(dataDict[\"train_x\"], useBothHalves)\n\t\tdevData = setupEmbeddings(dataDict[\"dev_x\"], useBothHalves)\n\t\ttestData = setupEmbeddings(dataDict[\"test_x\"], useBothHalves)\n\telse:\n\t\ttrainData = dataDict[\"train_x\"]\n\t\tdevData = dataDict[\"dev_x\"]\n\t\ttestData = dataDict[\"test_x\"]\n\n\trawTrainingLabels = dataDict[\"train_y\"] \n\trawDevLabels = dataDict[\"dev_y\"] \n\trawTestingLabels = dataDict[\"test_y\"] \n\t\t\n\t#make the event map\n\teventMap = load(open(args.m))\n\n\tparams = Parameters(eventMap)\n\n\ttrainingLabels = eventMap.namesToMatrix(rawTrainingLabels)\n\tdevLabels = eventMap.namesToMatrix(rawDevLabels)\n\t#testingLabels = eventMap.namesToMatrix(rawTestingLabels)\n\n\tif args.dev:\n\t\tdata, labels = joinDev(trainData, trainingLabels, devData, devLabels)\n\n\telse:\n\t\tdata = trainData\n\t\tlabels = trainingLabels\n\n\tparams.emb = args.emb\n\tparams.useBothHalves = useBothHalves\n\tparams.samples = data[0].shape[0]\n\tparams.windowSize = data[0].shape[1]\n\tparams.batchSize = args.b\n\tparams.epochs = args.e\n\tparams.split = args.s\n\tparams.limit = args.limit\n\n\tif useEmb:\n\t\tw2vPath = \"data/vectors/word2vec/GoogleNews-vectors-negative300.bin.gz\"\n\t\tindexPath = \"data/word_index.p\"\n\t\t\n\t\t#load the weights\n\t\tw2v = loadW2V(w2vPath)\n\t\t\n\t\t#load the index\n\t\twordIndex = load(open(indexPath))\n\t\t\n\t\t#make the initial weights\n\t\tparams.wordWeights = makeEmbeddingWeights(w2v, wordIndex)\n\n\telse:\n\t\tparams.wordSize = data[0].shape[2]\n\n\tif args.s:\n\t\tparams.contextSize = data[2].shape[1]\n\telse:\n\n\t\tif useBothHalves:\n\t\t\tparams.contextSize = data[-1].shape[1]\n\t\telse:\n\t\t\tparams.contextSize = data[1].shape[1]\n\n\tprint(\"Training\")\n\n\tif args.std:\n\t\tprint(\"Standard Cross Validation\")\n\t\tvalidator = StandardSplitter(args.c)\n\t\n\telif args.strat:\n\t\tprint(\"Stratified Cross Validation\")\n\t\tvalidator = StratifiedSplitter(args.c)\n\n\telse:\n\t\tprint(\"Random Cross Validation\")\n\t\tvalidator = RandomSplitter(args.p, args.c)\n\n\tmkdir(args.o)\n\n\tmodels = crossTrain(data, labels, args.o, args.k, validator, params)\n\n\tprint(\"Make Predictions\")\n\t\n\t\"\"\"\n\t#make predictions\n\ttrainPred = majorityPredictions(models, trainData, args.b, len(eventMap))\n\tdevPred = majorityPredictions(models, devData, args.b, len(eventMap))\n\n\tprint(\"\\nEvalutation\")\n\n\tprint(\"-----Training Scores-----\")\n\tevaluatePredictions(trainPred, rawTrainingLabels, eventMap)\n\n\tprint(\"\\n-----Dev Scores------\")\n\tevaluatePredictions(devPred, rawDevLabels, eventMap)\n\n\tif args.t:\n\t\ttestPred = majorityPredictions(models, testData, args.b, len(eventMap))\n\t\t\n\t\tprint(\"\\n\\n-----Test Scores------\")\n\t\tevaluatePredictions(testPred, rawTestingLabels, eventMap)\n\t\"\"\"","def main():\n Tkinter.Tk().withdraw()\n try:\n #Ask user for the file and open the file in read mode\n file=tkFileDialog.askopenfile()\n\n try:\n #Read the file, split contents by lines, then split lines into words using \",\" as separator and\n # use the words to create carEvaluation object\n carevaluation_list=[CarEvaluation(*lines.split(\",\")) for lines in file.read().splitlines()]\n process_records(carevaluation_list)\n except Exception, e:\n print \"Error: Parsing file. Terminating the program! \" + str(e)\n sys.exit(e)\n finally:\n file.close()\n except Exception, e:\n print \"Error: Could not open the file to read. Terminating the program! \" + str(e)\n sys.exit(e)","def __init__(self, txt_path, in_vocab_path, out_vocab_path):\n self.txt_seqs = open(txt_path, encoding='utf8', errors='ignore').readlines()\n self.word2id = utils.load_vocab(in_vocab_path,\n extra_word_list=[\"<UNK>\", \"<END>\"])\n self.punc2id = utils.load_vocab(out_vocab_path,\n extra_word_list=[\" \"])\n self.class2punc = { k : v for (v, k) in self.punc2id.items()}","def run_from_file(f):\n #set defaults\n x_loops=1;max_steps=0;display_on=True;max_fps=10;garden_size=13;tako_number=20\n pop_max=40;max_width=1800;max_height=900;collect_data=True;export_all=False\n rand_nets=False;max_gen=0;genetic_mode=\"Plain\";learning_on=False\n seeds=None;garden_mode=\"Diverse Static\";family_detection=None;family_mod=0\n record_inbreeding=True;inbreed_lim=1.1;filename=\"default file\"\n hla_genes=0;binary_health=0;carrier_percentage=40;two_envs=False\n diff_envs=False;migration_rate=0;phen_pref=False\n\n \n atr_dict = {\"x_loops\": x_loops, \"max_steps\": max_steps,\n \"display_on\": display_on, \"max_fps\": max_fps,\n \"garden_size\": garden_size,\n \"tako_number\": tako_number, \"pop_max\": pop_max,\n \"max_width\": max_width, \"max_height\": max_height,\n \"collect_data\": collect_data, \"export_all\": export_all,\n \"rand_nets\": rand_nets, \"max_gen\": max_gen,\n \"genetic_mode\": genetic_mode, \"learning_on\": learning_on,\n \"seeds\": seeds, \"garden_mode\": garden_mode,\n \"family_detection\": family_detection, \"family_mod\": family_mod,\n \"record_inbreeding\": record_inbreeding,\n \"inbreed_lim\": inbreed_lim, \"filename\": filename,\n \"hla_genes\": hla_genes, \"binary_health\": binary_health,\n \"carrier_percentage\": carrier_percentage,\n \"two_envs\": two_envs, \"diff_envs\": diff_envs,\n \"migration_rate\": migration_rate, \"phen_pref\": phen_pref}\n \n ints = [\"x_loops\", \"max_steps\", \"garden_size\", \"tako_number\", \"pop_max\",\n \"max_width\", \"max_height\", \"max_gen\", \"hla_genes\",\n \"binary_health\", \"carrier_percentage\", \"max_fps\"]\n floats = [\"family_mod\", \"inbreed_lim\", \"migration_rate\"]\n strs = [\"genetic_mode\", \"garden_mode\", \"filename\"]\n bools = [\"display_on\", \"collect_data\", \"export_all\", \"rand_nets\",\n \"learning_on\", \"record_inbreeding\", \"two_envs\", \"diff_envs\",\n \"phen_pref\"]\n\n #then sets all user-defined settings from the file f\n with open(f) as exp_file:\n for line in exp_file:\n #comments\n if line[0] == \"#\":\n pass\n #blank line = run what we have, then continue\n #to read the file for a new set of parameters\n elif line == \"\\n\":\n run_experiment(atr_dict[\"x_loops\"], atr_dict[\"max_steps\"],\n atr_dict[\"display_on\"], atr_dict[\"max_fps\"],\n atr_dict[\"garden_size\"],\n atr_dict[\"tako_number\"], atr_dict[\"pop_max\"],\n atr_dict[\"max_width\"], atr_dict[\"max_height\"],\n atr_dict[\"collect_data\"], atr_dict[\"export_all\"],\n atr_dict[\"rand_nets\"], atr_dict[\"max_gen\"],\n atr_dict[\"genetic_mode\"],\n atr_dict[\"learning_on\"],\n atr_dict[\"seeds\"], atr_dict[\"garden_mode\"],\n atr_dict[\"family_detection\"],\n atr_dict[\"family_mod\"],\n atr_dict[\"record_inbreeding\"],\n atr_dict[\"inbreed_lim\"],\n atr_dict[\"hla_genes\"], atr_dict[\"binary_health\"],\n atr_dict[\"carrier_percentage\"],\n atr_dict[\"filename\"],\n atr_dict[\"two_envs\"],\n atr_dict[\"diff_envs\"],\n atr_dict[\"migration_rate\"],\n atr_dict[\"phen_pref\"])\n #reset defaults\n atr_dict = {\"x_loops\": x_loops, \"max_steps\": max_steps,\n \"display_on\": display_on, \"max_fps\": max_fps,\n \"garden_size\": garden_size,\n \"tako_number\": tako_number, \"pop_max\": pop_max,\n \"max_width\": max_width, \"max_height\": max_height,\n \"collect_data\": collect_data, \"export_all\": export_all,\n \"rand_nets\": rand_nets, \"max_gen\": max_gen,\n \"genetic_mode\": genetic_mode, \"learning_on\": learning_on,\n \"seeds\": seeds, \"garden_mode\": garden_mode,\n \"family_detection\": family_detection,\n \"family_mod\": family_mod,\n \"record_inbreeding\": record_inbreeding,\n \"inbreed_lim\": inbreed_lim, \"filename\": filename,\n \"hla_genes\": hla_genes, \"binary_health\": binary_health,\n \"carrier_percentage\": carrier_percentage,\n \"two_envs\": two_envs, \"diff_envs\": diff_envs,\n \"migration_rate\": migration_rate, \"phen_pref\": phen_pref}\n else:\n #get rid of newline character\n line = line[:-1]\n line = line.split(\": \")\n if line[0] in ints:\n val = int(line[1])\n elif line[0] in floats:\n val = float(line[1])\n elif line[0] in bools:\n val = True if line[1] == \"True\" else False\n elif line[0] in strs:\n val = line[1]\n elif line[0] == \"family_detection\":\n if line[1] == \"None\":\n val = None\n else:\n val = line[1]\n elif line[0] == \"seeds\":\n val = line[1].split(\" \")\n atr_dict[line[0]] = val\n #run the last one in the file\n run_experiment(atr_dict[\"x_loops\"], atr_dict[\"max_steps\"],\n atr_dict[\"display_on\"], atr_dict[\"max_fps\"],\n atr_dict[\"garden_size\"],\n atr_dict[\"tako_number\"], atr_dict[\"pop_max\"],\n atr_dict[\"max_width\"], atr_dict[\"max_height\"],\n atr_dict[\"collect_data\"], atr_dict[\"export_all\"],\n atr_dict[\"rand_nets\"], atr_dict[\"max_gen\"],\n atr_dict[\"genetic_mode\"],\n atr_dict[\"learning_on\"],\n atr_dict[\"seeds\"], atr_dict[\"garden_mode\"],\n atr_dict[\"family_detection\"],\n atr_dict[\"family_mod\"],\n atr_dict[\"record_inbreeding\"],\n atr_dict[\"inbreed_lim\"], atr_dict[\"hla_genes\"],\n atr_dict[\"binary_health\"], atr_dict[\"carrier_percentage\"],\n atr_dict[\"two_envs\"], atr_dict[\"diff_envs\"],\n atr_dict[\"migration_rate\"], atr_dict[\"phen_pref\"],\n atr_dict[\"filename\"])","def run(self):\n\n self.load_file()\n self.cat_to_num()\n self.split()","def process_page(page: int) -> None:\n request = requests.get(URL_TEMPLATE.format(LIBRE_FM_USERNAME, page))\n\n xml_page = ET.fromstring(request.text)\n all_listens = xml_page.getiterator(\"track\") # pylint: disable=deprecated-method\n\n listens = []\n for listen in all_listens:\n # Iterate each listen and extract required fields\n artist_mbids = None\n if listen.find(\"artist\") and listen.find(\"artist\").get(\"mbid\"):\n artist_mbids = [listen.find(\"artist\").get(\"mbid\")]\n\n listens.append(\n pylistenbrainz.Listen(\n artist_name=listen.find(\"artist\").text,\n artist_mbids=artist_mbids,\n release_name=listen.find(\"album\").text,\n release_mbid=listen.find(\"album\").get(\"mbid\"),\n track_name=listen.find(\"name\").text,\n recording_mbid=listen.find(\"mbid\").text,\n listened_at=listen.find(\"date\").get(\"uts\"),\n )\n )\n\n try:\n # Send all listens to Listenbrainz\n listenbrainz.submit_multiple_listens(listens)\n except pylistenbrainz.errors.ListenBrainzAPIException as exc:\n print(exc.message)\n raise exc","def main():\n\n # this part of the program opens student txt resume and detects key info\n\n # sets the name of resume txt file to be scanned for content\n resume_txt_file = \"resume.txt\"\n\n resume_txt = read_student_info(resume_txt_file)\n student_name = detect_name(resume_txt)\n student_email = detect_email(resume_txt)\n student_courses = detect_courses(resume_txt)\n student_projects = detect_projects(resume_txt)\n\n # this part of program prepares the code for html resume.\n\n # sets the location of the imput resume txt file to be reformatted by the program\n resume_template_file = \"resume_template.html\"\n\n # creates a resume template\n resume_output = read_html_template(resume_template_file)\n resume_output = remove_bottom_end_tags(resume_output)\n\n # adds page wrapper (open tag), student info, projects, courses, and bottom tags to the html code to-be-printed, in order mentioned\n resume_output = add_pagewrap(resume_output)\n resume_output = add_s_info(student_name, student_email, resume_output)\n resume_output = add_s_projects(student_projects, resume_output)\n resume_output = add_s_courses(student_courses, resume_output)\n resume_output = add_bottom_end_tags(resume_output)\n\n # print(resume_output)\n\n # this part of the program writes the resume output html code into resume.html\n\n # sets the resume.html file as output file\n fout = open(\"resume.html\", \"w\")\n # writes the html code!\n fout.writelines(resume_output)\n # saves to file and closes the output file resume.html\n fout.close()","def train():\n num_spam=0 \n num_ham=0\n spam_words=()\n ham_words=()\n pullData = open(\"labels\", \"r\").read()\n dataArray= pullData.split('\\n')\n #print(dataArray)\n dataArrayTrain=dataArray[0:21300] #opens training set from folder 000-070\n \n for eachLine in dataArrayTrain:\n kind,file = eachLine.split(' ')\n file=file.strip('../') \n #print(kind)\n #print(file)\n \n fileDir = os.path.dirname(os.path.realpath('__file__'))\n filepath = os.path.join(fileDir,file) \n print(filepath)\n email=\"\"\n fh = open(filepath, encoding=\"ascii\", errors=\"ignore\")\n for line in fh:\n email += line\n fh.close()\n email= email.lower()\n #print(email)\n email_words = processText(contentEmail(email))\n #print(email_words)\n email_words = tuple(list(set(email_words))) #converted it into a set to avoid repetition of words in every email\n #print(email_words)\n if (kind == \"spam\"):\n num_spam+=1 #counts how many spam emails\n spam_words= spam_words + tuple(email_words) #adds every word to a spam tuple\n\n elif (kind==\"ham\"):\n num_ham+=1 #counts how many ham emails\n ham_words= ham_words + tuple(email_words) #adds every word to a ham tuple\n\n spam_words= tuple(spam_words)\n ham_words= tuple(ham_words)\n\n \n count_spam = collections.Counter(spam_words) #counts how many times a words appears in all spam emails\n count_ham = collections.Counter(ham_words) #counts how many times a words appears in all ham emails\n total_count = (count_spam + count_ham).most_common(5000) #adds the total occurences of the words and gets top 5000\n #print(total_count)\n #print(num_ham, num_spam)\n\n top_words = []\n for everyword in total_count:\n top_words.append(everyword[0])\n for everyword in list(count_spam):\n if everyword not in top_words:\n del count_spam[everyword] #deletes words in spam emails not included in top 5000\n for everyword in list(count_ham):\n if everyword not in top_words:\n del count_ham[everyword] #deletes words in ham emails not included in top 5000\n #print(words, count_ham, count_spam)\n\n file_encoder = open(\"top_word_count.txt\", \"w+\", encoding = 'utf-8', errors = 'ignore')\n file_encoder.write(\"HERE ARE YOUR TOP 5000 WORDS: \"+\"\\n\"+str(total_count)+\"\\n\"+\"\\n\"+\"SPAM WORDS: \"+\"\\n\"+str(count_spam)+\"\\n\"+\"\\n\"+\"HAM WORDS: \"+\"\\n\"+str(count_ham))\n file_encoder.close()\n print(\"Counting and getting top 5000 words successful!\")\n probabilityGet(num_spam, num_ham, count_spam, count_ham)","def callback(message):\n installation_id = message.attributes['installation_id']\n repo_owner = message.attributes['repo_owner']\n repo_name = message.attributes['repo_name']\n issue_num = message.attributes['issue_num']\n logging.info(f'Receive issue #{issue_num} from {repo_owner}/{repo_name}')\n\n try:\n # predict labels\n self.load_yaml(repo_owner, repo_name)\n self.download_model_from_gcs()\n predictions, issue_embedding = self.predict_labels(repo_owner, repo_name, issue_num)\n self.add_labels_to_issue(installation_id, repo_owner, repo_name,\n issue_num, predictions)\n\n # log the prediction, which will be used to track the performance\n log_dict = {\n 'repo_owner': repo_owner,\n 'repo_name': repo_name,\n 'issue_num': int(issue_num),\n 'labels': predictions['labels']\n }\n logging.info(log_dict)\n\n except Exception as e:\n # hard to find out which errors should be handled differently (e.g., retrying for multiple times)\n # and how to handle the error that the same message causes for multiple times\n # so use generic exception to ignore all errors for now\n logging.error(f'Addressing issue #{issue_num} from {repo_owner}/{repo_name} causes an error')\n logging.error(f'Error type: {type(e)}')\n logging.error(e)\n\n # acknowledge the message, or pubsub will repeatedly attempt to deliver it\n message.ack()","def main():\n args = get_args()\n str_arg = args.arg\n int_arg = args.int\n flag_arg = args.flag\n #pos_arg = args.positional\n\n #read and open the annotations file\n intpro_dict = {}\n with open('InterPro_entry_list.tsv') as csvfile:\n reader = csv.DictReader(csvfile, delimiter='\\t')\n for row in reader:\n intpro_dict[row['ENTRY_AC']] = row['ENTRY_NAME']\n\n with open('model_topics.txt', 'r') as file:\n model_topics = file.read().replace('\\n', '')\n\n model_topics = re.sub(\"'\", \"\", model_topics)\n model_topics = re.sub(\"\\[\", \"\", model_topics)\n model_topics = re.sub(\"\\]\", \"\", model_topics)\n\n mtl = model_topics.split('), ')\n\n with open('output_topics.tsv' ,'w') as f:\n print('Topic\\tModel_coefficient\\tInterpro_ID\\tInterPro_ENTRY_NAME', file=f)\n for list in mtl:\n topic = list[1]\n split_list = list.split()\n id_re = re.compile('IPR\\d{3}')\n c_words = []\n for w in split_list:\n match = id_re.search(w)\n if match:\n c_words.append(w)\n c_words = [re.sub('\"', '', i) for i in c_words]\n for w in c_words:\n re.sub('\\)', '', w)\n coef, intpro = w.split('*')\n intpro = intpro[:9]\n\n if intpro in intpro_dict.keys():\n label = intpro_dict[intpro]\n else:\n label = ''\n\n print('{}\\t{}\\t{}\\t{}'.format(topic,coef,intpro,label), file=f)","def process_test_data_bigrams(file_path, label_matches, transition_probabilities):\r\n\tlabel_index_dict = {}\r\n\tstarting_index = 0\r\n\tline_number = 0\r\n\twith open(file_path) as f:\r\n\t\tfor line in f:\r\n\t\t\tif line_number%3 == 0:\r\n\t\t\t\tline = line.strip().lower().split('\\t')\r\n\t\t\t\tlabel_index_dict = process_sentence_bigrams(line, starting_index, label_matches, label_index_dict, transition_probabilities)\r\n\t\t\t\tstarting_index += len(line)\r\n\t\t\tline_number +=1\r\n\treturn label_index_dict","def read_proc_card(self,proc_card,cond=''):\n\n# Define Process\n\n ff=open(proc_card,'r')\n #read step by step \n # 1) find the begin of the definition of process\n # 2) read all process\n # 3) find multiparticle\n \n # 1) find the begin of the definition of process\n\n tag_proc=re.compile(r'''#\\s*Begin\\s+PROCESS\\s*#''',re.I)\n while 1:\n line=ff.readline()\n if line=='':\n sys.exit('bad proc_card information: missing BEGIN PROCESS tag')\n\n if tag_proc.search(line):\n break #(pass to step 2)\n\n # 2) read all process\n\n done=re.compile(r'''done''')\n end_coup=re.compile(r'''end_coup''')\n if cond:\n process=re.compile(r'''>.*@\\s*'''+cond,re.DOTALL)\n else:\n process=re.compile(r'''>''')\n\n while 1:\n line=ff.readline()\n if line=='':\n \n sys.exit('bad proc_card information: missing request process tag (end of file)')\n\n if done.search(line):\n if cond=='0':\n ff.close()\n return self.read_proc_card(proc_card)\n sys.exit('bad proc_card information: missing request process tag')\n \n if process.search(line):\n process_line=line\n break #(pass to step 3)\n\n\n # 3) find multiparticle\n begin_multi=re.compile(r'''#\\s*Begin\\s+MULTIPARTICLES\\s*#''',re.I)\n end_multi =re.compile(r'''#\\s*End\\s+MULTIPARTICLES\\s*#''',re.I)\n info =re.compile(r'''^(?P<tag>[\\S]+)\\s+(?P<multi>[\\S]*)''')\n multi={}\n in_multi_area=0\n while 1:\n line=ff.readline()\n if line=='':\n sys.exit('bad proc_card information: missing multiparticle tag') \n if end_multi.search(line):\n break\n\n if begin_multi.search(line):\n in_multi_area=1\n continue\n \n if in_multi_area:\n if info.search(line):\n info2= info.search(line)\n multi[info2.group('tag').lower()]=info2.group('multi')\n\n\n \n\n return process_line,multi","def load_data(self): # Loads data from 'SMSSpamCollection.txt'\n with open('SMSSpamCollection.txt') as sms_data:\n i = 0\n for line in sms_data:\n line = line.split(\"\\t\")\n message_id = \"SMS\" + str(i)\n self.spamorham[message_id] = line[0]\n self.messages[message_id] = line[1].strip()\n self.ids.append(message_id)\n self.wordcounts[message_id] = self.split_messages(line[1])\n i += 1\n self.NUMOFMESSAGES = i","def addEntry(self, listDictions):\n ## load xml\n improvDoc = loadIMProvFile(self.argsFile)\n entrname= 'Job'\n for dictions in listDictions:\n report = IMProvNode(entrname , None, **dictions)\n improvDoc.addNode(report)\n outfile = file( self.argsFile, 'w').write(str(improvDoc))\n return","def predict(self, datafile):","def procesPage(self, page):\n item = pywikibot.ItemPage.fromPage(page)\n pywikibot.output('Processing %s' % page)\n if not item.exists():\n pywikibot.output('%s doesn\\'t have a wikidata item :(' % page)\n #TODO FIXME: We should provide an option to create the page\n else:\n pagetext = page.get()\n templates = pywikibot.extract_templates_and_params(pagetext)\n for (template, fielddict) in templates:\n # We found the template we were looking for\n if template.replace(u'_', u' ')==self.templateTitle:\n for field, value in fielddict.items():\n # This field contains something useful for us\n if field in self.fields:\n # Check if the property isn't already set\n claim = pywikibot.Claim(self.repo, self.fields[field])\n if claim.getID() in item.get().get('claims'):\n pywikibot.output(u'A claim for %s already exists. Skipping' % (claim.getID(),))\n #TODO FIXME: This is a very crude way of dupe checking\n else:\n # Try to extract a valid page\n match = re.search(pywikibot.link_regex, value)\n if match:\n try:\n link = pywikibot.Link(match.group(1))\n linkedPage = pywikibot.Page(link)\n if linkedPage.isRedirectPage():\n linkedPage = linkedPage.getRedirectTarget()\n linkedItem = pywikibot.ItemPage.fromPage(linkedPage)\n claim.setTarget(linkedItem)\n pywikibot.output('Adding %s --> %s' % (claim.getID(), claim.getTarget().getID()))\n item.addClaim(claim)\n if self.source:\n claim.addSource(self.source, bot=True)\n except pywikibot.exceptions.NoPage:\n pywikibot.output('[[%s]] doesn\\'t exist so I can\\'t link to it' % (linkedItem.title(),))","def main():\n summary = dict()\n gba_file = open('gettysburg.txt', 'r')\n for line in gba_file:\n Process_line(line, summary)\n Pretty_print(summary)","def parse_file():\n\tfile_lines = []\n\n\t## For each line in the file, if it's not empty, store it\n\tfor line in fileinput.input():\n\t\tif len(line) > 1:\n\t\t\tfile_lines.append(line.strip())\n\t\n\trun_algorithms(file_lines)","def process_input_files(list_input_files):\n global dict_models_results\n global list_spacy_docs\n \n for input_file in list_input_files:\n prefix = prefix_from_filename(input_file)\n \n with open(input_file) as f:\n list_cases = json.load(f)\n dict_models_results[prefix] = list_cases\n \n \n #extract list of questions from all vignettes and create a mapping page -> vignette question\n dict_questions = {}\n for prefix, list_cases in dict_models_results.items():\n for vignette in list_cases:\n dict_questions[vignette[\"book_page\"]] = vignette[\"question\"]\n \n \n for book_page,question in dict_questions.items():\n doc_q = load_bner_onto_tokens_extension(question, book_page)\n list_spacy_docs.append(doc_q)\n \n return","def process_file(self, filename, order=2):\n fp = open(filename)\n self.skip_gutenberg_header(fp)\n\n for line in fp:\n for word in line.rstrip().split():\n self.process_word(word, order)\n\n #print(\">>>DEBUG the suffix map\")\n #i = 0\n #for k,v in self.suffix_map.items():\n # print(\"key is {}, value is {}\".format(k, v))\n # i += 1\n # if i > 10:\n # break","def load(self, file_name):\n try:\n [self.add_word(w) for w in open(file_name).read().splitlines()]\n except IOError as e:\n print(e)","def loadData(self):\n machineToNode = {}\n self.listOfMachines = []\n nextID = 0\n self.processingSteps = []\n with open(self.filename) as f:\n lines = f.read().splitlines()\n for line in lines:\n formatted = line.split(\"\\t\")\n order = int(formatted[0])\n machine = int(formatted[1])\n timestamp = float(formatted[2])\n if machine not in machineToNode: # normalizing machines according to the nodes (1,2,3... instead of 1,34,2...)\n machineToNode[machine] = nextID\n nextID +=1\n self.listOfMachines.append(machineToNode[machine]) # normalized list of all machines\n\n pstep = ProcessingStep(machineToNode[machine], timestamp, order)\n self.processingSteps.append(pstep)","def testingPhase(SP, HP):\n classification= {}\n TP, TN, FP, FN = 0,0,0,0\n\n pullData = open(\"labels\", \"r\").read()\n dataArray= pullData.split('\\n')\n dataArrayTest=dataArray[21301:-1] #opens files from folder 070 onwards \n \n for eachLine in dataArrayTest:\n kind,file = eachLine.split(' ')\n print(file,kind)\n if (kind == \"spam\"):\n SO = 1 #initially stating that it is a spam not a ham\n HO = 0\n elif (kind== \"ham\"):\n HO = 1\n SO = 0\n file=file.strip('../') \n fileDir = os.path.dirname(os.path.realpath('__file__'))\n filepath = os.path.join(fileDir,file) \n email=\"\"\n fh = open(filepath, encoding=\"ascii\", errors=\"ignore\")\n for line in fh:\n email += line\n fh.close()\n email= email.lower()\n email_words = processText(contentEmail(email))\n email_words = tuple(email_words)\n spam_ba= math.log(PS,10) #initially contains value of Spam Probability\n ham_ba= math.log(PH, 10) #initially contains value of Ham Probability\n\n\n \"\"\"BAYES THEOREM\"\"\"\n for word, value in SP.items(): \n if word in email_words:\n x = math.log(value, 10)\n spam_ba += x\n else:\n x = math.log(1-value, 10)\n #print(x)\n spam_ba += x \n if ham_ba > spam_ba:\n label=\"ham\"\n elif ham_ba < spam_ba:\n label=\"spam\"\n\n for word,value in HP.items(): \n if word in email_words:\n x = math.log(value, 10)\n #print(x)\n ham_ba += x \n else:\n x = math.log(1-value, 10)\n #print(x)\n ham_ba += x \n if ham_ba > spam_ba:\n label=\"ham\"\n elif ham_ba < spam_ba:\n label=\"spam\"\n\n print(\"Spam Prob: \" ,spam_ba, \"Ham Prob: \" ,ham_ba)\n\n #This part determines if the emails are ham or spam depending on the calculations\n if HO == 1 and label == \"ham\":\n TN +=1\n if HO == 1 and label == \"spam\":\n FP +=1\n if SO == 1 and label == \"spam\":\n TP +=1\n if SO == 1 and label == \"ham\":\n FN +=1\n #print(classification)\n print(TP, TN, FP, FN)\n print(spam_ba)\n print(ham_ba)\n \"\"\"COMPUTES PRECISION AND RECALL\"\"\"\n Precision = TP/(TP+FP)\n Recall = TP/(TP+FN)\n\n print(\"Precision: \", Precision, \" \", \"Recall: \", Recall)","def load_from_file(self, fp, sep='\\n'):\r\n n = 0\r\n body = ''\r\n l = fp.readline()\r\n while l:\r\n if l == sep:\r\n m = Message(self, body)\r\n self.write(m)\r\n n += 1\r\n print 'writing message %d' % n\r\n body = ''\r\n else:\r\n body = body + l\r\n l = fp.readline()\r\n return n","def main():\r\n\r\n prompt = 'Enter the name of the file that contains the card deck: '\r\n deck_file = open(get_valid_filename(prompt), 'r')\r\n deck = cipher_functions.read_deck(deck_file)\r\n deck_file.close()\r\n if not (cipher_functions.is_valid_deck(deck)):\r\n print('The supplied card deck is not a valid deck.')\r\n print('Encryption process stopping.')\r\n return\r\n\r\n prompt = 'Enter the name of the file that contains the message: '\r\n msg_file = open(get_valid_filename(prompt), 'r')\r\n messages = cipher_functions.read_messages(msg_file)\r\n msg_file.close()\r\n\r\n mode = get_encryption_mode()\r\n\r\n for msg in cipher_functions.process_messages(deck, messages, mode):\r\n print(msg)","def run(self):\n st.title('Acne Classifier')\n st.markdown(STYLE, unsafe_allow_html=True)\n file = st.file_uploader(\"Upload file\", type=self.fileTypes)\n show_file = st.empty()\n if not file:\n show_file.info(\"Please upload a file of type: \" + \", \".join([\"png\", \"jpg\"]))\n return\n\n file_bytes = np.asarray(bytearray(file.read()), dtype=np.uint8)\n opencv_image = cv2.imdecode(file_bytes, 1)\n cv2.imwrite('out.jpg', opencv_image)\n df = get_score()\n\n df2 = df.set_index('Issue')\n st.dataframe(df2)\n st.bar_chart(df2)\n\n if isinstance(file, BytesIO):\n show_file.image(file)\n else:\n data = pd.read_csv(file)\n st.dataframe(data.head(10))\n file.close()","def process_file(fname):\n # get the channel name\n # this is dirty code, come up with a better solution\n # e.g. storing the header info in the h5 file attrs\n man = SortingManagerGrouped(fname)\n try:\n entity = man.header['AcqEntName']\n except TypeError:\n entity = 'unknown'\n ncs_fname = os.path.basename(fname)[5:-3]\n print(ncs_fname)\n plot_fname = 'spikes_{}_{}'.format(entity, ncs_fname)\n save_fname = os.path.join(OVERVIEW, plot_fname)\n spikes_overview(ncs_fname, save_fname)","def classify_new_email(filename,probabilities_by_category,prior_by_category):\n ### TODO: Write your code here\n spam_distribution = 0\n ham_distribution = 0\n word_frequency = util.get_word_freq([filename])\n for w in word_frequency:\n if w in probabilities_by_category[0]:\n spam_distribution += word_frequency[w] * np.log(probabilities_by_category[0][w])\n if w in probabilities_by_category[1]:\n ham_distribution += word_frequency[w] * np.log(probabilities_by_category[1][w])\n spam_distribution += np.log(prior_by_category[0])\n ham_distribution += np.log(prior_by_category[1])\n\n predict = \"\"\n if(spam_distribution > ham_distribution):\n predict = \"spam\"\n else:\n predict = \"ham\"\n\n word_distribution = [spam_distribution, ham_distribution]\n\n classify_result = (predict, word_distribution)\n\n return classify_result","def file_input_run(self, filename):\r\n file = open(filename)\r\n file_content = file.read()\r\n content_list = file_content.split(\"\\n\")\r\n for command in content_list:\r\n if command == \"exit\":\r\n break\r\n try:\r\n self.input_mang.process_input(command)\r\n except Exception as e:\r\n print(e)","def main():\n download_insert_title_basics()\n download_insert_title_principals()\n download_insert_name_basics()\n download_insert_title_ratings()\n scrap_keywords()\n create_and_insert_soup()\n return","def predictFromFile(repoClassifier, strFileInput):\n #Checks file exists and txt file\n if os.path.exists(strFileInput) & string_operation.validate_txtfile(strFileInput):\n file = open(strFileInput, 'r')\n\n strReadFileDirectory = os.path.dirname(strFileInput)\n strReadFileName = os.path.basename(strFileInput)\n\n print(strReadFileName + 'was read successfully')\n strFileClassified = \"classified_\" + strReadFileName\n\n writeClassifiedTxtFile(file, strReadFileDirectory, strFileClassified, repoClassifier)\n else:\n print(\"File could no be read. Make sure you have permission or entered correct File (txt)\")","def probe(self):\n\n # make sure the filehandler is still valid\n # (e.g. file stat hasnt changed, file exists etc.)\n if not self.validate_file_handler():\n return []\n\n messages = []\n\n # read any new lines and push them onto the stack\n for line in self.fh.readlines(self.max_lines):\n data = {\"path\":self.path}\n msg = self.new_message()\n\n # process the line - this is where parsing happens\n parsed = self.process_line(line, data)\n if not parsed:\n continue\n data.update(parsed)\n\n # process the probe - this is where data assignment\n # happens\n data = self.process_probe(data)\n msg[\"data\"] = [data]\n messages.append(msg)\n\n\n # process all new messages before returning them\n # for emission\n messages = self.process_messages(messages)\n\n return messages","def _process(self, file: bytes) -> List[Tuple[str]]:\n decoded_text = file.decode('utf-8')\n # Replace end of line tokens\n if self.eol is not None and not self.split_by_sentence:\n decoded_text = decoded_text.replace('\\n', self.eol)\n\n # Split by sentence or unroll\n if self.split_by_sentence:\n nltk.download('punkt', quiet=True)\n text = [(sent.strip(),) for sent in nltk.tokenize.sent_tokenize(decoded_text)]\n else:\n text = [(decoded_text,)]\n\n return text","def process_file(filename):\n print \"Reading and Parsing File: {}\".format(filename)\n parsed_entries = file_parser(filename)\n print \"Starting to Process Entries\"\n chunked_entires = chunk_entries(parsed_entries)\n return [process_entries(entry) for entry in chunked_entires]","def main():\n parse_file(sys.argv[1])","def main():\n # Load and prep training files\n raw_speech_text = hg.load_training_file('trump_train.txt')\n speech_text = hg.prep_training(raw_speech_text)\n tweet_data = load_tweets('trump_tweets.json')\n raw_tweets = \"\"\n for dct in tweet_data:\n raw_tweets += \"{} \".format(dct['text'])\n tweets = hg.prep_training(raw_tweets)\n corpus = speech_text + tweets\n corpus = strip_punctuation(corpus)\n dict_1 = hg.map_one_to_one(corpus)\n dict_2 = hg.map_two_to_one(corpus)\n text = []\n \n # Introduction\n print(\"\\nTrump Speech Generator\\n\")\n print(\"Select words to add to speech\")\n print(\"\\'x\\' to exit\")\n print(\"\\'p\\' to add punctuation\")\n print(\"Select \\'p\\' before selecting the word you want to punctuate\")\n\n # Select first word\n options = corpus\n print ()\n selection = select_word(corpus)\n text.append(selection)\n \n # Select second word\n last = text[0]\n options = word_after_one(last, dict_1)\n print_text(text)\n selection = select_word(options)\n text.append(selection)\n \n # Select subsequent word\n while True:\n last = \"{} {}\".format(text[-2].strip(punctuation),\n text[-1].strip(punctuation))\n options = word_after_two(last, dict_2)\n if options == []:\n last = last.split()[1]\n options = word_after_one(last, dict_1)\n while options == []:\n last = random.choice(corpus)\n options = word_after_one(last, dict_1)\n print_text(text)\n selection = select_word(options)\n text.append(selection)\n \n print_text(text)","def preprocess_main():","def test_add_score():\n board = Board(640, 640, 8)\n board.add_score(\"test.txt\", \"User1\", 5)\n board.add_score(\"test.txt\", \"User2\", 10)\n board.add_score(\"test.txt\", \"User3\", 6)\n board.add_score(\"test.txt\", \"User4\", 11)\n open_file = open(\"test.txt\", \"r\")\n file_lines = []\n for line in open_file:\n file_lines.append(line.strip())\n assert file_lines[0] == \"User4 11\"\n assert file_lines[1] == \"User2 10\"\n assert file_lines[2] == \"User1 5\"\n assert file_lines[3] == \"User3 6\"","def train(self, data):\r\n pos_list = [\r\n \"adj\",\r\n \"adv\",\r\n \"adp\",\r\n \"conj\",\r\n \"det\",\r\n \"noun\",\r\n \"num\",\r\n \"pron\",\r\n \"prt\",\r\n \"verb\",\r\n \"x\",\r\n \".\",\r\n ]\r\n print(\"Train\")\r\n\r\n wordpos_list = [\r\n tuple([line[0][i], line[1][i]])\r\n for line in data\r\n for i in range(len(line[0]))\r\n ]\r\n\r\n pos_dict = {pos: {} for pos in pos_list}\r\n\r\n wordpos_count = Counter(wordpos_list)\r\n\r\n for w in wordpos_count:\r\n pos_dict[w[1]].update({w[0]: wordpos_count[w]})\r\n posterior_prob = {}\r\n emission_prob = {}\r\n for pos in pos_dict.keys():\r\n posterior_prob[pos] = float(sum(pos_dict[pos].values())) / len(wordpos_list)\r\n for pos in pos_dict.keys():\r\n emission_prob[pos] = {\r\n word: float(pos_dict[pos][word]) / sum(pos_dict[pos].values())\r\n for word in pos_dict[pos].keys()\r\n }\r\n\r\n trans_count = {}\r\n transition_prob = {}\r\n for pos in pos_list:\r\n trans_count[pos] = {}\r\n transition_prob[pos] = {}\r\n pair_list = [\r\n tuple([line[1][i], line[1][i + 1]])\r\n for line in data\r\n for i in range(len(line[1]) - 1)\r\n ]\r\n\r\n unique_list = list(set(pair_list))\r\n\r\n for element in unique_list:\r\n trans_count[element[0]].update({element[1]: pair_list.count(element)})\r\n\r\n for pos in pos_list:\r\n transition_prob[pos] = {pos: (1 / float(10 ** 8)) for pos in pos_list}\r\n for key, value in trans_count[pos].items():\r\n transition_prob[pos].update(\r\n {key: (value / float(sum(trans_count[pos].values())))}\r\n )\r\n initial_list = [line[1][0] for line in data]\r\n initial_count = Counter(initial_list)\r\n initial_prob = {\r\n pos: float(initial_count[pos]) / sum(initial_count.values())\r\n for pos in initial_count.keys()\r\n }\r\n self.position_list = pos_list\r\n self.emission_probability = emission_prob\r\n self.transition_probability = transition_prob\r\n self.initial_probability = initial_prob\r\n self.posterior_probability = posterior_prob","def main(infilename):\n graph = pydot.graph_from_dot_file(infilename)\n nodes = get_nodes_info(graph)\n load_links(graph, nodes)\n propagate_lineage(nodes)\n dump_status(nodes)","def process_test_data_trigrams(file_path, label_matches, transition_probabilities):\r\n\tlabel_index_dict = {}\r\n\tstarting_index = 0\r\n\tline_number = 0\r\n\twith open(file_path) as f:\r\n\t\tfor line in f:\r\n\t\t\tif line_number%3 == 0:\r\n\t\t\t\tline = line.strip().lower().split('\\t')\r\n\t\t\t\tlabel_index_dict = process_sentence_trigrams(line, starting_index, label_matches, label_index_dict, transition_probabilities)\r\n\t\t\t\tstarting_index += len(line)\r\n\t\t\tline_number +=1\r\n\treturn label_index_dict","def process_raw_phrases(file_path):","def analyse() -> 'html':\n storeFileName = ''\n if request.method == 'POST':\n \n if 'file' not in request.files:\n return render_mainpageerror('No file selected')\n \n file = request.files['file']\n if file.filename == '':\n return render_mainpageerror('Empty file name Please select a File to upload')\n \n if file and not allowed_file(file.filename):\n storeFileName = filename = secure_filename(file.filename)\n file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))\n return render_mainpageerror('Not allowed file format')\n \n if ' ' in file.filename:\n return render_mainpageerror('Please remove withespace from file name before uploading')\n \n if file and allowed_file(file.filename):\n originalFilename = file.filename\n storeFileName = filename = secure_filename(file.filename)\n file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))\n \n \n if len(storeFileName) == 0:\n return render_template('mainpage.html',\n title='Word association')\n else:\n wordsfromfile = readFile.red_uploaded_file(storeFileName)\n #print(wordsfromfile, 'The ans from pdf')\n if wordsfromfile == 'STOP':\n return render_mainpageerror('Cant find Encoding on PDF document')\n size = get_store()\n if not check_fileName(size):\n \"\"\"Analyse first time building up JSON file\"\"\"\n keyWords = readFile.read_JSON()\n allJson = readFile.load_JSON()\n data = Counter(wordsfromfile)\n printResultsExluds = []\n container = {}\n container['size'] = size\n container['file'] = storeFileName\n toDB = []\n for k, v in sorted(data.items()):\n if k in keyWords:\n string = allJson[k][:3]\n toDB.append({k : v})\n toDB.append(string)\n else:\n value = str(v)\n keystr = k + '(' + value + ')'\n printResultsExluds.append(keystr)\n for w in printResultsExluds:\n toDB.append({w:'was not found in the associations list'})\n\n container['files'] = toDB \n js = json.dumps(container)\n print(js)\n c = get_client()\n c.insert(json.loads(js))\n print('insert')\n \"\"\"If analysed first time\"\"\"\n return pr(size, 'Analysed first time')\n else:\n \"\"\"If already Analysed\"\"\"\n return pr(size,'Already analysed')","def population_text_parser():\n h = 480\n w = 640\n filenames = []\n # get corrispondence ppoints for all faces\n all_face_verticies = []\n for i in range(1, 41):\n if i == 2 or i == 3 or i == 4:\n # not in data set\n continue\n # get file name\n file_name = \"data/\"\n if i < 10:\n file_name += \"0\" + str(i)\n else:\n file_name += str(i)\n if i == 8 or i == 22 or i == 30 or i == 35 or i == 12 or i ==14 or i == 15:\n # female faces\n file_name += \"-1f.asf\"\n else:\n file_name += \"-1m.asf\"\n filenames.append(file_name[:-3] + \"bmp\")\n # Parse corrispondence points\n face_vertices = file_parser(file_name)\n all_face_verticies.append(np.array(face_vertices))\n\n # adding my face to the set\n # all_face_verticies.append(get_will_points())\n mean_vertices = np.array(sum(all_face_verticies)) / len(all_face_verticies)\n\n # face = plt.imread(filenames[0])\n # mean_vertices = ginput_to_array(appendCorners_other(face, mean_vertices))\n # Morph each of the faces in the dataset into the average shape.\n morphs = []\n for i in range(len(all_face_verticies)):\n # Read in src img\n print(\"Morphing face \" + str(i) + \" into the average shape.\")\n if i == len(all_face_verticies)-1:\n face = plt.imread(\"will_population.jpeg\")/255\n else:\n face = plt.imread(filenames[i])/255\n # print(face.shape)\n # print(mean_vertices)\n im_src_vertices = all_face_verticies[i]\n\n # Create Dalaunay triangulation for the ith morph set\n print(\"Computing Delaunay triangulation.\")\n # morph_verticies = morphPointSet(tri0_vertices, tri1_vertices, i/45)\n t = Delaunay(mean_vertices)\n trianguations = t.simplices\n\n # Compute Affine Transformation matrices for both transformations (src-->mid; dst-->mid)\n print(\"Computing Affine Transformation.\")\n affine_matrices_0 = computeAffines(trianguations, im_src_vertices, mean_vertices)\n affine_matrices_inv_0 = [linalg.inv(A) for A in affine_matrices_0]\n\n morph = warp(h, w, t, affine_matrices_inv_0, face)\n # if i == len(all_face_verticies) -1:\n # plt.imsave(\"will_in_danish_pop.png\", morph)\n morphs.append(morph)\n\n out = sum(morphs) * (1/len(morphs))\n return out","def insert_good_data():\n get_file_reply(files[0][0], files[0][1])\n get_file_reply(files[1][0], files[1][1])","def main():\n print \"Python has started\"\n #os.system(\"xterm -e \\\"pyhton Listen_link.py\\\"\") \n #print \"Started Listener\"\n tutorial = MoveGroupPythonIntefaceTutorial()\n model_info_prox = rospy.ServiceProxy('/gazebo/get_link_state', GetLinkState)\n rospy.wait_for_service('/gazebo/get_link_state')\n rospy.wait_for_service('/gazebo/get_model_state')\n # writer below is to pass sings to out Link Listener and recording program\n writer = rospy.Publisher('writer', String, queue_size=1)\n filestring = rospy.Publisher('filestring', String, queue_size=1)\n rospy.set_param('/move_group/trajectory_execution/allowed_start_tolerance',0)\n hello_str = \"Test listener is working %s\" % rospy.get_time()\n file_str = \"/NewFile\"\n writer.publish(hello_str)\n filestring.publish(file_str)\n print \"Generating a population\"\n #pop = Population(20,False,0) #should be an even number 10-20 \n pop = Population(20,True,941) #should be an even number 10-20 \n #\n if pop.gencount == 0:\n pop.gencount = pop.gencount + 1\n grav = GravityControl()\n velocity = VelocityControl()\n grav.init_values()\n grav.change_gravity(0.0,0.0,-9.8)\n\n generation = pop.gencount\n if pop.res_sim == False:\n pop.generate_inds(pop.numberinds,pop.numpoints,pop.xmin,pop.xmax,pop.ymin,pop.ymax,pop.zmin,pop.zmax,pop.vmin,pop.vmax,generation)\n pop.gen_wp()\n if pop.res_sim == True:\n print \"We have had a restart, attempting to load individuals\"\n pop.load_inds()\n pop.gen_wp()\n pop.gencount = 56\n check_valid_waypoints(pop.current_ind_instances)\n print \"Success adding table \"\n time.sleep(1)\n print \"============ Please ensure the Recorder is started and then Press `Enter` to execute joint state goal ...\"\n raw_input()\n tutorial.go_to_joint_state(0.0,-0.5,0.0,0.0,0.0,0.0) # note Rads each joint \n # The main loop for the program is below\n while (pop.gencount<100):\n \n grav.change_gravity(0.0,0.0,-9.8)\n print \"Starting for population count number\", pop.gencount\n run_simulation(tutorial,pop,pop.gencount,filestring,writer,velocity)\n #make gravity Heavier to change simulation of 'real' slightly\n grav.change_gravity(0.0,0.0,-10.8)\n run_real(tutorial,pop,pop.gencount,filestring,writer,velocity)\n # Evaluate, also calculates Euclidean based on collected data points between sim and real\n evaluate_pop(pop) # This is a GA function call to evauate this population before the next generatio \n \n\n print \"============ Exiting the Loop!\"","def uni_pred(uni_pred_file):\n print_section_title('Universal predict')\n \n # get all bins\n allbins = []\n fr = open(pre.bin_file, 'r')\n for line in fr.readlines():\n binname = line.split()[-1]\n if binname not in allbins:\n allbins.append(line.split()[-1])\n fr.close()\n allbins.sort()\n \n # start to predict\n is_unix = 0\n if is_win == 0:\n is_unix = 1\n print ' Get all candidate ORFs ...'\n cmd = '%s -p -n %s -s %s -t %s -b %s -u' % \\\n (pre.get_data, pre.project_name, pre.seqs_file, pre.tismodel, pre.bin_file)\n if is_unix == 0:\n cmd = '%s -p -n %s -s %s -t %s -b %s' % \\\n (pre.get_data, pre.project_name, pre.seqs_file, pre.tismodel, pre.bin_file)\n call(cmd, shell = True, stdout = PIPE)\n\n print ' Predict using universal model ...'\n print ' SVM probability mode:', pre.prob_status\n print ' SVM scroe cut-vaule:', pre.svm_cut_value\n cds_model_path = pre.cdsmodel\n name = pre.project_name\n cut_value = pre.svm_cut_value\n uni_w = open(uni_pred_file, 'w')\n uni_w.close()\n count = 1\n types = ['00', '01', '10', '11']\n for g in allbins:\n print '\\t', g\n for t in types:\n fea_file = name + '.' + g + '.fea_' + t\n orf_file = name + '.' + g + '.orf_' + t\n if not os.path.exists(fea_file):\n continue\n model_file = cds_model_path + os.sep + g + '_' + t + '.model'\n range_file = cds_model_path + os.sep + g + '_' + t + '.range'\n cds_pred_file = fea_file + '.cds'\n svm_predict(range_file, model_file, fea_file, orf_file, cut_value, pre.prob_status, cds_pred_file)\n\n cmd = '%s -a %s -b %s --a+b -o %s' % (pre.metalocs_operate, cds_pred_file, uni_pred_file, uni_pred_file)\n call(cmd, shell = True, stdout = PIPE)\n rm_files([fea_file, orf_file, cds_pred_file])\n count = count + 1\n return","def doTheJob(input_file):\n\n Parse.parseFile(input_file)\n Write.writeFile(input_file.replace(\".txt\", \".html\"))","def preMain(dictADT):\r\n data_addr = \"..\\\\csv\\\\normal.csv\"\r\n\r\n userPref = dictADT\r\n mainPref(\"base.txt\", userPref)\r\n\r\n sample_path = \"base.txt\"\r\n webing(sample_path, data_addr)\r\n\r\n path_in = \"base.txt\"\r\n path_out = \"..\\\\resultHTML\\\\result.html\"\r\n mover(path_in, path_out)\r\n\r\n baseDel(\"base.txt\")\r\n # baseDel(\"resultHTML\\\\result.html\")\r\n baseDel(\"..\\\\csv\\\\normal.csv\")\r\n return True"],"string":"[\n \"def load_poems(self):\\n file = open(self.name, \\\"r\\\")\\n content = file.readlines()\\n for i in content:\\n self.add_msg_and_index(i.strip())\",\n \"def process_input_file(sess, char_dict, model_settings, model_vars, input_file):\\n \\n with open(input_file, 'r') as f:\\n for s in f: # s is the line string\\n if s and (len(s) > 0):\\n chars = list(s.strip())\\n cids = char_dict.chars2cids(chars)\\n \\n in_embedding = np.eye(model_settings['input_classes'])\\n one_hot = in_embedding[cids]\\n one_hot_by_t = np.expand_dims(one_hot, 1)\\n\\n # run session to retriev prob\\n probs = process_sentence(sess, model_settings, model_vars, one_hot_by_t) \\n labels = viterbi(probs)\\n words = char_dict.chars2words(chars, labels)\\n print('|'.join(words))\",\n \"def start():\\n\\n global input, frameList, processPageList\\n\\n print \\\"\\\\n******************************************************************\\\"\\n print \\\"\\\\tThis is a simulation for LRU replacement.\\\"\\n print \\\"\\\\tAt any time you may choose to quit('q') this program.\\\"\\n print \\\"******************************************************************\\\"\\n\\n # Open File\\n with open(\\\"input.txt\\\") as f:\\n original = f.readlines()\\n\\n # Remove \\\":\\\", \\\"\\\\n\\\"\\n for line in original:\\n input = line.replace(\\\":\\\", \\\"\\\")\\n input = input.replace('\\\\n', \\\"\\\")\\n\\n # Split by tab, add to processList\\n output = input.partition('\\\\t')\\n\\n # convert process to number\\n pid = output[0]\\n proc = int(pid[1])\\n\\n # convert binary page # to decimal\\n page = int(str(output[2]), 2)\\n\\n # add process and page # to list\\n processPageList.append([proc, page])\",\n \"def main() -> None:\\n\\n # Retrieving the wiki URL\\n url = get_api_url()\\n print(url)\\n\\n # Creates file if it does not exist\\n open(TEXT_FILE, \\\"a\\\")\\n\\n with open(TEXT_FILE, \\\"r\\\") as f:\\n last_title = f.readline().strip()\\n print(\\\"Starting from:\\\", last_title)\\n\\n # Retrieving the pages JSON and extracting page titles\\n pages_json = get_pages_json(url, last_title)\\n pages = pages_json[\\\"query\\\"][\\\"allpages\\\"]\\n print(\\\"Pages to be scanned:\\\", pages)\\n\\n # Tagging operations\\n for page in pages:\\n curr_title = page[\\\"title\\\"]\\n cats_to_add = get_categories(curr_title)\\n if cats_to_add:\\n print(\\\"Adding categories\\\", cats_to_add, \\\"to '%s'\\\" % curr_title)\\n for cat in cats_to_add:\\n add_category(curr_title, \\\"[[Category:\\\" + cat + \\\"]]\\\")\\n\\n # Extracting title to continue iterating from next run\\n if \\\"continue\\\" in pages_json:\\n continue_from_title = pages_json[\\\"continue\\\"][\\\"apcontinue\\\"]\\n print(\\\"Continuing from:\\\", continue_from_title, \\\"next run.\\\")\\n else:\\n continue_from_title = \\\"\\\"\\n\\n with open(TEXT_FILE, \\\"w+\\\") as f:\\n f.write(continue_from_title)\\n print(\\\"Wrote\\\", continue_from_title, \\\"in\\\", TEXT_FILE)\\n\\n print(\\\"No pages left to be tagged\\\")\",\n \"def main():\\n token_dict_dict = {}\\n all_dict = {}\\n pronoun_proportion_list = []\\n tag = 'PRP' # base tag for all pronouns, see 'https://www.clips.uantwerpen.be/pages/MBSP-tags' for more info\\n\\n for text in glob.glob(file_loc):\\n file_title = os.path.basename(text).split('.')[0]\\n\\n with open(text, 'r') as f:\\n speech = f.read()\\n text_dict = {}\\n\\n try:\\n #TextBlob goodness that tags all the words for me\\n speech_blob = TextBlob(clean(speech))\\n speech_blob.tags\\n except:\\n #for some reason Trump's address contained a unicode 128 character that I couldn't find\\n #instead of getting rid of it in a single file, i decided to have an except that could catch that case in\\n #all sitations and handle them accordingly\\n\\n #lets the user know that there was an issue, and that it's been handled\\n print file_title,\\n print \\\"contains unexpected unicode characters. they have been removed and the document has been processed\\\"\\n\\n #gets rid of all unicode characters. i could do this by default, but all the other files ran fine\\n #so i didn't think it was worth it\\n speech_blob = TextBlob(clean(speech.decode('unicode_escape').encode('ascii','ignore')))\\n\\n for token in speech_blob.tags:\\n # builds the inital dictionary of data, only looks at words with a specified tag\\n if tag in token[1]:\\n try:\\n text_dict[token[0]] += 1\\n except:\\n text_dict[token[0]] = 1\\n try:\\n all_dict[token[0]] += 1\\n except:\\n all_dict[token[0]] = 1\\n #breaks the title into 3 pieces: number, president, date\\n token_dict_dict[file_title] = text_dict\\n partial_split, date = string.rsplit(file_title, '_', 1)\\n num_pres, pres = string.split(partial_split, '_', 1)\\n\\n pronoun_proportion_list.append(\\n (pres, date, total_to_proportion(pronoun_breakdown(token_dict_dict[file_title])))\\n )\\n create_pronoun_graph(sort_list_by_president_order(pronoun_proportion_list))\",\n \"def main() -> None:\\n\\n\\t# Retrieving the wiki URL\\n\\turl = get_api_url()\\n\\tprint(url)\\n\\n\\t# Creates file if it does not exist\\n\\topen(TEXT_FILE, \\\"a\\\")\\n\\n\\twith open(TEXT_FILE, \\\"r\\\") as f:\\n\\t\\tlast_title = f.readline().strip()\\n\\t\\tprint(\\\"Starting from:\\\", last_title)\\n\\n\\tmodify_pages(url, last_title)\\n\\n\\tprint(\\\"\\\\nNo pages left to be tagged\\\")\",\n \"def main(fpath, html_dir):\\n with open(fpath, \\\"r\\\") as fptr:\\n pageid_emojis = {os.path.split(k)[-1]: v for k, v in json.load(fptr).items()}\\n\\n print(\\\"Loading emoji corpus. This may take a while...\\\")\\n index, corpus = [], []\\n for html_fpath in glob.glob(os.path.join(html_dir, \\\"*\\\")):\\n with open(html_fpath, \\\"r\\\") as fptr:\\n html = fptr.read()\\n\\n tree = etree.fromstring(html)\\n text = \\\"\\\".join(tree.xpath(\\\".//text()\\\"))\\n corpus.append(text)\\n\\n pageid = os.path.splitext(os.path.split(html_fpath)[-1])[0]\\n index.append(pageid_emojis[pageid])\\n\\n vectorizer = sklearn.feature_extraction.text.TfidfVectorizer(\\n max_features=10000, min_df=1, preprocessor=preprocess\\n )\\n\\n print(\\\"Fitting Model. This may take a while...\\\")\\n weights = vectorizer.fit_transform(corpus)\\n\\n model = {\\n \\\"weights\\\": weights,\\n \\\"columns\\\": vectorizer.get_feature_names(),\\n \\\"index\\\": index,\\n }\\n\\n with open(\\\"build/model.pckl\\\", \\\"wb\\\") as fptr:\\n pickle.dump(model, fptr)\",\n \"def Run():\\n file_name = AskForFileName()\\n file_content = ReadFileContents(file_name)\\n head_list = BuildHeadList(file_content)\\n atom_list = BuildAtomList(file_content)\\n tail_list = BuildTailList(file_content)\\n WriteNewFile(head_list, atom_list, tail_list)\",\n \"def main(inputfname, outfname):\\n with open(inputfname, 'rt', encoding='utf8') as fh:\\n # first block\\n reviews = []\\n while True:\\n comment = next(fh).strip()\\n if not comment:\\n # blank line, block separator\\n break\\n url_moviedb = next(fh).strip()\\n url_moviedb, movie_id = fix_moviedb(url_moviedb)\\n reviews.append((comment, url_moviedb, movie_id))\\n\\n # second block\\n futures = []\\n while True:\\n try:\\n title = next(fh).strip()\\n except StopIteration:\\n break\\n if not title:\\n continue\\n url_moviedb = next(fh).strip()\\n url_moviedb, movie_id = fix_moviedb(url_moviedb)\\n futures.append((title, url_moviedb, movie_id))\\n\\n lines, viewed = process_reviews(reviews)\\n lines.append(\\\"\\\")\\n lines.extend(process_futures(futures))\\n lines.append(\\\"\\\")\\n\\n pelis_lines, raw_pending = proc_pelshtml(futures, viewed)\\n\\n lines.extend(line.format(enter='', space=' ') for line in raw_pending)\\n lines.append(\\\"\\\")\\n lines.extend(pelis_lines)\\n lines.extend(line.format(enter='<br/>', space=' ') for line in raw_pending)\\n\\n with open(outfname, 'wt', encoding='utf8') as fh:\\n fh.write(\\\"\\\\n\\\".join(lines))\",\n \"def data_preprocessing():\\n lineid_content = get_lineid_content()\\n print('Read movie_lines.txt file complete...')\\n convos = get_convos()\\n print('Read movie_conversations.txt file complete...')\\n print('Building dataset')\\n get_data(lineid_content, convos)\",\n \"def main():\\n feed_db, entry_db = openDBs(FEED_DB_FN, ENTRY_DB_FN)\\n\\n feeds = [ x.strip() for x in open(FEEDS_FN, \\\"r\\\").readlines() ]\\n \\n entries = getNewFeedEntries(feeds, feed_db, entry_db)\\n \\n if len(entries) > 0:\\n out_fn = HTML_FN % time.strftime(\\\"%Y%m%d-%H%M%S\\\")\\n writeAggregatorPage(entries, out_fn, DATE_HDR_TMPL, FEED_HDR_TMPL, \\n ENTRY_TMPL, PAGE_TMPL)\\n emailAggregatorPage(FROM_ADDR, TO_ADDR, SUBJECT, SMTP_HOST, out_fn)\\n \\n closeDBs(feed_db, entry_db)\",\n \"def main(nlp, file_path, final_file_path, from_line=0, to_line=None):\\n with open(final_file_path, \\\"w\\\") as parsed_file:\\n with open(file_path) as cnn_dm:\\n line = cnn_dm.readline().strip()\\n article_idx = 0\\n while article_idx < from_line:\\n line = cnn_dm.readline().strip()\\n article_idx += 1\\n if to_line is None:\\n while line is not None and line != '':\\n process_line(nlp, line, parsed_file)\\n article_idx += 1\\n print(\\\"{} articles processed from file {}\\\".format(article_idx, file_path))\\n line = cnn_dm.readline().strip()\\n else:\\n while article_idx < to_line and line is not None and line != '':\\n process_line(nlp, line, parsed_file)\\n article_idx += 1\\n print(\\\"{}th article processed from file {}\\\".format(article_idx, file_path))\\n line = cnn_dm.readline().strip()\",\n \"def train(self, train_data):\\n with open(train_data, 'r') as train_data:\\n while True:\\n tokens = train_data.readline().split()\\n pos = train_data.readline().split()\\n labels = train_data.readline().split()\\n if not tokens or not pos or not labels:\\n break\\n # Generate transition probabilities\\n for i in range(0, len(labels) - self.N_VALUE + 1):\\n self.add_label_sequence(labels[i:i + self.N_VALUE])\\n # Generate lexical generation probabilities\\n for i in range(0, len(tokens)):\\n token = tokens[i].lower()\\n label = labels[i]\\n self.add_word_tag(token, label)\\n self.handle_unknowns()\",\n \"def process_training_data(train_page_names):\\n\\n print('Reading data')\\n images_train = []\\n labels_train = []\\n for page_name in train_page_names:\\n images_train = utils.load_char_images(page_name, images_train)\\n labels_train = utils.load_labels(page_name, labels_train)\\n labels_train = np.array(labels_train)\\n\\n print('Extracting features from training data')\\n bbox_size = get_bounding_box_size(images_train)\\n fvectors_train_full = images_to_feature_vectors(images_train, bbox_size)\\n\\n model_data = dict()\\n model_data['labels_train'] = labels_train.tolist()\\n model_data['bbox_size'] = bbox_size\\n\\n print('Reducing to 10 dimensions')\\n fvectors_train = reduce_dimensions(fvectors_train_full, model_data)\\n\\n model_data['fvectors_train'] = fvectors_train.tolist()\\n\\n with open('ListOfOneHundredThousandWords.txt') as word_file:\\n words_list = [words.replace(\\\" \\\", \\\"\\\").strip('\\\\n').upper() for words in word_file]\\n model_data['words'] = words_list\\n\\n return model_data\",\n \"def __init__(self, messages):\\n self.pq = PriorityQueue()\\n self.cover = []\\n self.words_in_cover = set()\\n\\n # add message dictionary and process all messages (add to priority queue)\\n self.message_corpus = messages\\n # TODO: process messages prior to ingestion\\n for msg_id in self.message_corpus.iterkeys():\\n self.add_entry(msg_id)\",\n \"def main():\\n with open(\\\"page_data.yaml\\\", 'r') as inputstr:\\n config_data = yaml.safe_load(inputstr)\\n ointf = OutputInterface('template.txt')\\n table_data = get_song_artist_matches()\\n ofilen = config_data['directory'] + os.sep + 'common_songs.html'\\n title = 'Song Titles and Band Name Overlap'\\n header = ['No.', 'Artist', 'Peak', 'Date', 'Song/Artist', 'Peak',\\n 'Date', 'Song']\\n ointf.build_page(ofilen, title, header, fmt_table(table_data))\\n ointf.inject(XTRAEDIT)\\n ointf.output()\",\n \"def preprocess(self):\\n\\n self._build_labels_dict(['one', 'two', 'three', 'four', 'five'])\\n\\n with open(self.data_path + self.file_name, 'rb') as csvfile:\\n\\n reader = csv.reader(csvfile, delimiter=\\\",\\\")\\n for row in reader:\\n self.texts.append(row[1])\\n self.labels.append(self.labels_index[row[0]])\\n\\n print('Found %s texts.' % len(self.texts))\",\n \"def process(self):\\n\\n linelang = defaultdict(int)\\n wordlang = defaultdict(int)\\n\\n linefont = defaultdict(int)\\n wordfont = defaultdict(int)\\n\\n inputfiles = self.input_files\\n for input_file in inputfiles:\\n\\n alignurl = input_file.url\\n pcgts = parse(alignurl, True)\\n page = pcgts.get_Page()\\n regions = page.get_TextRegion()\\n\\n for region in regions:\\n lines = region.get_TextLine()\\n\\n for line in lines:\\n try:\\n llang = line.primaryLanguage\\n linelang[llang] += 1\\n except TypeError:\\n pass\\n\\n try:\\n lfont = line.fontFamily\\n linefont[lfont] += 1\\n except TypeError:\\n pass\\n\\n words = line.get_Word()\\n for word in words:\\n try:\\n wlang = word.language\\n wordlang[wlang] += 1\\n except TypeError:\\n pass\\n\\n try:\\n wfont = word.get_TextStyle().fontFamily\\n wordfont[wfont] += 1\\n except TypeError:\\n pass\\n\\n #predominant language\\n try:\\n lang = max(linelang, key=lambda k: linelang[k])\\n except TypeError:\\n try:\\n lang = max(wordlang, key=lambda k: wordlang[k])\\n except TypeError:\\n lang = 'German'\\n\\n #predominant font\\n try:\\n font = max(linefont, key=lambda k: linefont[k])\\n except TypeError:\\n try:\\n font = max(wordfont, key=lambda k: wordfont[k])\\n except TypeError:\\n font = 'Antiqua'\\n\\n\\n print(lang)\\n print(font)\",\n \"def process(self):\\n # Opening and preprocessing of the input file\\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\\n if self.options.mbtiles_fromdisk:\\n i_parm=10\\n if self.options.mbtiles_todisk:\\n i_parm=11\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :mbtiles from/to disk [\\\",i_parm,\\\"] mbtiles_fromdisk[\\\",self.options.mbtiles_fromdisk,\\\"] mbtiles_todisk[\\\",self.options.mbtiles_todisk,\\\"]\\\"\\n self.mbtiles_setup(i_parm)\\n return\\n else:\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :tile creation mbtiles[\\\",self.options.mbtiles,\\\"]\\\"\\n self.open_input()\\n # Generation of main metadata files and HTML viewers\\n self.generate_metadata()\\n # Generation of the lowest tiles\\n self.generate_base_tiles()\\n # Generation of the overview tiles (higher in the pyramid)\\n self.generate_overview_tiles()\\n # Generating of KML\\n self.generate_kml()\",\n \"def main():\\n file = \\\"http://icarus.cs.weber.edu/~hvalle/hafb/words.txt\\\"\\n words = fetch_words(file)\\n print_items(words)\",\n \"def gnumed_hl7_importer(file_name):\\n #TODO ERROR for opening a file\\n file = open(file_name)\\n\\n message = ''\\n\\n find_message_header = re.compile(r\\\"^MSH\\\")\\n #TODO Have it be able to process both a directory or an individual file\\n for n in file:\\n if re.match(find_message_header, n):\\n if message != '':\\n process_lab_message(message)\\n message = n + '\\\\r'\\n else:\\n message = message + n + '\\\\r'\",\n \"def main():\\n if sys.argv[1] == 'train':\\n build_training_data()\\n main_trainer()\\n\\n if sys.argv[1] == 'predict' and len(sys.argv) > 2:\\n from predict import classification\\n from AdaboostPredict import decision_stumps\\n input_file = open(sys.argv[2])\\n data = input_file.readlines()\\n print(\\\"Decision Tree prediction\\\")\\n for i in data:\\n print(classification(i, i.strip().split()))\\n\\n print(\\\"\\\\nAdaboost prediction\\\")\\n\\n for i in data:\\n print(decision_stumps(i, i.strip().split()))\\n\\n elif sys.argv[1] == 'predict':\\n print('Wrong usage for prediction. Please supply a file after predict')\",\n \"def parse_input():\\n with open(\\\"input_07.txt\\\", \\\"r\\\") as f:\\n for line in f:\\n Bag(line)\",\n \"def main(training_file_name):\\n attribute, inverse = build_classifier(training_file_name)\\n trained_file = open(TRAINED_FILE_NAME, mode='w')\\n prolog(trained_file)\\n write_body(trained_file, attribute, inverse)\\n epilog(trained_file)\",\n \"def process_from_file():\\r\\n global default_input_path\\r\\n print \\\"JoomFind v 1.0\\\"\\r\\n print \\\"\\\\n\\\\nTrying to read URL(s) form \\\" + default_input_path + \\\" file...\\\\n\\\"\\r\\n try:\\r\\n if not default_input_path:\\r\\n f = open(\\\"urls.txt\\\")\\r\\n else:\\r\\n f=open(default_input_path)\\r\\n cwd=os.getcwd()\\r\\n file_path = cwd + path_slash + f.name\\r\\n\\t# extracting url's to list from file\\r\\n start_urls = [url.strip() for url in f.readlines() if url[0] not in ['#',' ',\\\"\\\\n\\\"]]\\r\\n if not start_urls:\\r\\n print \\\"File is empty. Add some URL(s) first.\\\\n\\\"\\r\\n f.close()\\r\\n return 0\\r\\n except:\\r\\n print \\\"File not found. Make sure it exists.\\\\n\\\"\\r\\n return 0\\r\\n #print start_urls\\r\\n \\r\\n num=str(len(start_urls))\\r\\n print \\\"Found \\\" + num + \\\" URL(s) on \\\" + time.asctime(time.localtime(time.time())) + \\\"\\\\n\\\"\\r\\n \\r\\n of=open(default_output_path,'a+')\\r\\n of.write(\\\"\\\\n\\\\n\\\\tScanning \\\" + num + \\\" URL(s) \\\")\\r\\n of.write(\\\"\\\\n\\\\n\\\\tDate\\\\Time : \\\" + time.asctime(time.localtime(time.time())) )\\r\\n of.write(\\\"\\\\n\\\\n\\\\tInput file path : \\\" + default_input_path + \\\"\\\\n\\\\n\\\")\\r\\n of.close()\\r\\n \\r\\n for url in start_urls:\\r\\n global provided_url\\r\\n provided_url=url\\r\\n print \\\"\\\\nWorking on URL \\\" + str(start_urls.index(url)+1) + \\\": \\\" + provided_url\\r\\n processing()\\r\\n print \\\"\\\\nAll done! Check '\\\" + default_output_path +\\\"' file for results.\\\\n\\\"\",\n \"def train_model(filename):\\n counts = get_file_counts(filename)\\n new_file = open(filename, \\\"r\\\")\\n num_lines = 0\\n for line in new_file:\\n num_lines += 1 \\n #number of lines in file\\n return counts_to_probs(counts, num_lines)\",\n \"def pre_process(fname, num_ex, alt_speaker):\\n conversation = []\\n with PathManager.open(fname) as f:\\n lines = f.readlines()\\n random.shuffle(lines)\\n lines = lines[:num_ex]\\n for line in lines:\\n data = json.loads(line)\\n dialogue = data[\\\"dialog\\\"]\\n for item in dialogue:\\n speaker = item[0]['id']\\n text = item[0]['text']\\n conversation += [(speaker, text)]\\n conversation += [(END_OF_CONVO, END_OF_CONVO)]\\n\\n return conversation\",\n \"def parse_results_file(filename):\\n\\tfile = open(filename, 'r')\\n\\tpretext=[line for line in file.readlines() if line.strip()]\\n\\tfile.close()\\n\\n\\ttext = []\\n\\tprocessed = []\\n\\tlanguages = 'NONE'\\n\\tID = 'NONE'\\n\\t\\n\\tmoreheader = raw_input('Extra header labels from question field (e.g.: item,condition,factor1,factor2): ')\\n\\tstim_type = raw_input('What type are your stims? (i.e. AcceptabilityJudgment): ')\\n\\toutput_loc = raw_input('Where would you like to put your parsed file? (enter filename path): ')\\n\\t\\n\\t#takes out comments\\n\\tfor line in pretext:\\n\\t\\tif re.match('#', line):\\n\\t\\t\\tcontinue\\n\\t\\telse:\\n\\t\\t\\ttext.append(line)\\n\\n\\tfirst = 1;\\n\\n\\tfor line in range(len(text)):\\n\\t\\t#get their info\\n\\t\\tif re.search('Form', text[line]):\\n\\t\\t\\tif re.search('number', text[line]):\\n\\t\\t\\t\\tID = re.split('number,', text[line])[1].strip()\\n\\t\\t\\telif re.search('age', text[line]):\\n\\t\\t\\t\\tlanguages = re.split('age,', text[line])[1].strip()\\n\\n\\t\\t#looks for the main stimulus type, as entered earlier\\t\\t\\n\\t\\tif re.search(stim_type, text[line]):\\n\\t\\t\\tif first:\\n\\t\\t\\t\\t#print 'first'\\n\\t\\t\\t\\tprocessed.append(str(ID+ ','+languages+','+text[line]))\\n\\t\\t\\t\\tfirst=0\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttoAmend = processed.pop()\\n\\t\\t\\t\\t#print str('toAmend: ' + toAmend)\\n\\t\\t\\t\\ttoAdd=''\\n\\t\\t\\t\\tsplits = re.split('NULL,', text[line])\\n\\t\\t\\t\\tfor thing in splits[1:]:\\n\\t\\t\\t\\t\\tif thing is not '':\\n\\t\\t\\t\\t\\t\\ttoAdd = str(toAdd + ',' + thing.strip(','))\\n\\t\\t\\t\\t#print str('toAdd: ' + toAdd)\\n\\t\\t\\t\\tprocessed.append(str(toAmend.strip()+ toAdd))\\n\\t\\t\\t\\tfirst = 1\\n\\n\\t\\t#if the line is a question line, there's more to append\\n\\t\\tif re.search('Question', text[line]):\\n\\t\\t\\ttoAmend = processed.pop()\\n\\t\\t\\tpart = re.split('\\\\$', text[line])[1]\\n\\t\\t\\tpart.strip('$')\\n\\t\\t\\tparts = part.split('%2C')\\n\\t\\t\\tprocessed.append(str(toAmend.strip()+ ','+ string.join(parts, ',')+'\\\\n'))\\n\\t\\t\\t\\n\\toutput = open(output_loc, 'w')\\n\\n\\theader = 'ID,Languages,Time sent,MD5 Hash of IP Address,Controller,Item Number,Element Number,Type,Group,Stimulus,Answer,RT,'\\n\\n\\toutput.write(str(header+moreheader+'\\\\n'))\\n\\n\\t#put it all into a text file\\n\\tfor line in processed:\\n\\t\\toutput.write(line)\\n\\toutput.close()\",\n \"def process(self, message, **kwargs):\\n if self.classifier is None:\\n self.train()\\n\\n if message.get(\\\"text\\\") is not None:\\n sid = SentimentIntensityAnalyzer()\\n res = sid.polarity_scores(message.get(\\\"text\\\"))\\n key, value = max(res.items(), key=lambda x: x[1])\\n\\n if key == \\\"pos\\\":\\n key = \\\"Positive\\\"\\n elif key == \\\"neg\\\":\\n key = \\\"Negative\\\"\\n else:\\n key = \\\"Neutral\\\"\\n\\n custom_tokens = self.remove_noise(word_tokenize(message.get(\\\"text\\\")))\\n t = self.classifier.prob_classify(dict([token, True] for token in custom_tokens))\\n\\n sentiment = 'Positive' if t.prob('Positive') > t.prob('Negative') else 'Negative'\\n confidence = max(t.prob('Positive'), t.prob('Negative'))\\n\\n found, entry = self.manager.getMovieName(message.get(\\\"text\\\"))\\n movie = str(entry['original_title'].item())\\n \\n genre_entry, aux_found_genre = self.manager.fuzzy_find_genre(message.get(\\\"text\\\"), with_ratio=True)[0]\\n genre = genre_entry\\n \\n\\n if len(message.get(\\\"text\\\")) > 20:\\n entity = self.convert_to_rasa(sentiment, confidence, name=\\\"our_sentiment_extractor\\\")\\n else:\\n entity = self.convert_to_rasa(key, value, name=\\\"builtin_sentiment_extractor\\\")\\n\\n message.set(\\\"sentiment\\\", [entity], add_to_output=True)\\n\\n entity = self.convert_movie_to_rasa(movie, found)\\n message.set(\\\"movies\\\", [entity], add_to_output=True)\\n\\n if message.get(\\\"text\\\").strip() == \\\"no\\\":\\n found_genre = False\\n else:\\n found_genre = True if aux_found_genre > 80 else False\\n\\n entity = self.convert_movie_to_rasa(genre, found_genre, entity=\\\"genres_detected\\\")\\n print(entity)\\n message.set(\\\"genres\\\", [entity], add_to_output=True)\",\n \"def process_file(file_name):\\n pass # delete this line and replace with your code here\",\n \"def load_test_page(page_name, model):\\n print(\\\"load_test_page\\\")\\n\\n print(\\\"\\\\tLoading the image feature vectors...\\\")\\n bbox_size = model['bbox_size']\\n images_test = utils.load_char_images(page_name)\\n fvectors_test = images_to_feature_vectors(images_test, bbox_size)\\n\\n print(\\\"\\\\tPerforming dimensionality reduction...\\\")\\n fvectors_test_reduced = reduce_dimensions(fvectors_test, model)\\n\\n print(\\\"\\\\tGetting the noise factor and calculating how many neighbours to use...\\\")\\n im = np.array(Image.open(page_name + '.png'))\\n #I use the full margins (200px on every side) to sample white areas.\\n margin = 200\\n white_sample = np.append(im[:margin,:],im[im.shape[0]-margin:,:])\\n white_sample = np.append(white_sample, \\n np.append(im[margin:im.shape[0]-margin,:margin],\\n im[margin:im.shape[0]-margin,im.shape[1]-margin:]))\\n neighbours_to_use = np.array([round(np.exp(np.var(white_sample)/2250))])\\n neighbours_to_use.resize((1,10))\\n print(\\\"\\\\t{0}-nearest neighbours will be used for '{1}'\\\".format(int(neighbours_to_use[0,0]), page_name))\\n\\n #Storing info on how many neigbours to use at the end of the list of feature\\n # vectors, like page meta-data. Technically sneakily adds an extra dimension\\n # to each feature vector, but as it's just \\\"one more number\\\", I emailed\\n # Jon and he permitted me to do this.\\n fvectors_test_reduced = np.vstack((fvectors_test_reduced, neighbours_to_use))\\n\\n print(\\\"\\\\tDone.\\\\n\\\")\\n return fvectors_test_reduced\",\n \"def createPostingList():\\n try :\\n ##### peut etre à mettre dans une fonction\\n file_reader_last_read_list = initialize_file_readers()\\n for idx, file_reader_and_last_read in enumerate(file_reader_last_read_list):\\n file_reader_last_read_list[idx]=read_line_and_update(file_reader_and_last_read=file_reader_and_last_read)\\n current_word = min_top_word(file_reader_last_read_list=file_reader_last_read_list)\\n final_file = open(POSTING_LIST_PATH, \\\"w\\\")\\n ######\\n\\n doc_dict = get_doc_dict(DOC_LIST_PATH)\\n nb_doc = len(doc_dict)\\n\\n ### autre function\\n i = 0 \\n while current_word != \\\"|||\\\": \\n current_PL = current_word_PL(current_word=current_word, file_reader_last_read_list=file_reader_last_read_list,\\\\\\n doc_dict=doc_dict, nb_doc=nb_doc ) \\n curent_string = \\\"\\\"\\n for key, value in current_PL.items():\\n curent_string = \\\" \\\" + str(key) + \\\" \\\" + str(value) + curent_string\\n curent_string = current_word + curent_string\\n final_file.write(curent_string + \\\"\\\\n\\\")\\n current_word = min_top_word(file_reader_last_read_list=file_reader_last_read_list)\\n #if i %1000 == 0:\\n #print(i/1000)\\n i +=1\\n ####\\n \\n final_file.close()\\n close_file_readers(file_reader_last_read_list=file_reader_last_read_list)\\n \\n except Exception as ex:\\n print(ex)\\n final_file.close()\\n close_file_readers(file_reader_last_read_list=file_reader_last_read_list)\",\n \"def process_input(fname,onlynugget,onlyarg):\\n content=utils.readFileEncode(fname,'utf8')\\n lines = content.split('\\\\n')[:-1]\\n sentences=[]\\n labels=[]\\n sent=[]\\n label=[]\\n for i in range(len(lines)):\\n if len(lines[i])>3:\\n words=lines[i].split('\\\\t')\\n word={'originalText':words[0],'offset':int(words[1])}\\n sent.append(word)\\n if onlynugget:\\n if words[2] in NuggetList10:\\n label.append(words[2]) \\n else:\\n label.append('O')\\n elif onlyarg:\\n if words[2] in ArgumentList:\\n\\n if 'Software' in words[2]:\\n label.append(words[2][0:2]+'System')\\n else:\\n label.append(words[2])\\n else:\\n label.append('O')\\n else:\\n if len(sent)>0 and len(label)>0: \\n sentences.append(sent)\\n labels.append(label) \\n sent=[]\\n label=[]\\n elif len(sent)==0 and i < len(lines)-1:\\n sentences.append([])\\n labels.append([])\\n \\n return sentences,labels\",\n \"def _read(self, file_name):\\n f = open(file_name)\\n lines = f.readlines()\\n begin = 0\\n end = 0\\n while end < len(lines):\\n op = ''\\n for l in lines[begin:]:\\n end += 1\\n op = l.split()[0]\\n if op in operations:\\n self.operations.append(op)\\n break\\n if op == '=push':\\n nfa = Automaton(lines[begin:end - 1])\\n self.aut_to_push.append(nfa)\\n begin = end\\n f.close()\",\n \"def process_file(filename, skip_header):\\n hist = {}\\n fp = open(filename, encoding='utf8')\\n\\n if skip_header:\\n skip_gutenberg_header(fp)\\n\\n\\n for line in fp:\\n if line.startswith('*** END OF THIS PROJECT'):\\n break\\n line = line.replace('-', ' ')\\n strippables = string.punctuation + string.whitespace\\n\\n for word in line.split():\\n # remove punctuation and convert to lowercase\\n word = word.strip(strippables)\\n word = word.lower()\\n\\n #update the histrogram\\n hist[word] = hist.get(word, 0) + 1\\n\\n\\n return hist\",\n \"def main():\\n filepath = input(\\\"Enter the Source File: \\\")\\n with open(filepath, encoding=\\\"utf-8\\\") as f:\\n sentences = f.readlines()\\n sentences = \\\" \\\".join(sentences)\\n\\n summary = summarize_sentences(sentences)\\n\\n filepath_index = filepath.find(\\\".txt\\\")\\n outputpath = filepath[:filepath_index] + \\\"_lexRank.txt\\\"\\n\\n with open(outputpath, \\\"w\\\") as w:\\n for sentence in summary:\\n w.write(str(sentence) + \\\"\\\\n\\\")\",\n \"def process():\",\n \"def process_messages(self):\\n pass\",\n \"def process(self):\\n\\n return self._load_next_file()\",\n \"def process_paper(filename):\\n\\n # Start time\\n start_time = time.time()\\n\\n # Read in the paper\\n paper = useful_functions.read_in_paper(filename, sentences_as_lists=True)\\n\\n # Extract the gold summary\\n gold = paper[\\\"HIGHLIGHTS\\\"]\\n gold_string_list = [\\\" \\\".join(x) for x in gold]\\n\\n # Extract the title\\n title = paper[\\\"MAIN-TITLE\\\"][0]\\n title_string = \\\" \\\".join(title)\\n\\n # Extract the abstract\\n abstract = paper[\\\"ABSTRACT\\\"]\\n abstract_string_list = [\\\" \\\".join(x) for x in abstract]\\n\\n # Extract the keyphrases\\n try:\\n keyphrases = paper[\\\"KEYPHRASES\\\"][0]\\n except IndexError:\\n keyphrases = []\\n\\n # Turn the paper into a single string and calculate the bag of words score\\n paper_string = \\\" \\\".join([\\\" \\\".join(x) for key, val in paper.iteritems() for x in val])\\n bag_of_words = useful_functions.calculate_bag_of_words(paper_string)\\n\\n # Get the paper as a list of sentences, associating each sentence with its section name - will be used by oracle\\n # to find best summary sentences.\\n paper_sentences = [(\\\" \\\".join(x), key) for key, val in paper.iteritems() for x in val\\n if key != \\\"ABSTRACT\\\"]\\n\\n # Create a list of sentences, their ROUGE-L scores with the Highlights and the section they occur in\\n # (as a string)\\n sents_scores_secs = []\\n\\n for sentence, section in paper_sentences:\\n # For some reason the candidate sentence needs to be the only item in a list\\n r_score = rouge.calc_score([sentence], gold_string_list)\\n\\n sents_scores_secs.append((sentence.split(\\\" \\\"), r_score, section))\\n\\n # Sort the sentences, scores and sections into descending order\\n sents_scores_secs = sorted(sents_scores_secs, key=itemgetter(1), reverse=True)\\n\\n pos_sents_scores_secs = sents_scores_secs[:num_summary]\\n neg_sents_scores_secs = sents_scores_secs[num_summary:]\\n\\n if len(neg_sents_scores_secs) < len(pos_sents_scores_secs):\\n print(\\\"{}**** NOT A SUFFICIENT AMOUNT OF DATA IN PAPER {}, IGNORING PAPER ****{}\\\".format(\\n Color.RED, filename, Color.END))\\n return\\n\\n # Positive sentences\\n positive_sents_secs_class = [(sent, sec, 1) for sent, _, sec in pos_sents_scores_secs]\\n\\n # Negative sentences\\n\\n # Take the sentences not used as positive and reverse it to have worst scores first then take an equal number\\n neg_sents_scores_secs = [x for x in reversed(neg_sents_scores_secs)][:len(positive_sents_secs_class)]\\n negative_sents_secs_class = [(sent, sec, 0) for sent, _, sec in neg_sents_scores_secs]\\n\\n # Don't create data from this paper if it's less than 40 sentences - i.e. there would be more positive than\\n # negative data. The data needs to be balanced.\\n #if len(positive_sents_secs_class) != len(negative_sents_secs_class):\\n # print(\\\"{}**** NOT A SUFFICIENT AMOUNT OF DATA IN PAPER {}, IGNORING PAPER ****{}\\\".format(\\n # Color.RED, filename, Color.END))\\n # return\\n\\n # Concatenate the positive and negative sentences into a single data item and shuffle it\\n data = positive_sents_secs_class + negative_sents_secs_class\\n random.shuffle(data)\\n\\n # Average word vectors of each sentence and convert to list for JSON serialisation\\n sentvecs_secs_class = [(useful_functions.sentence2vec(sent).tolist(), sec, y) for sent, sec, y in data]\\n\\n # Calculate features for each sentence\\n features = [useful_functions.calculate_features(sent, bag_of_words, document_wordcount, keyphrases,\\n abstract_string_list, title_string, sec)\\n for sent, sec, y in data]\\n\\n # Calculate abstract vector\\n abs_vector = useful_functions.abstract2vector(abstract_string_list).tolist()\\n\\n # Description of the data\\n description_text = \\\"All text is of the form of a list of lists, where each sentence is a list of words. The\\\" \\\\\\n \\\" sentences are of the form [(sentence (as a list of words), section in paper,\\\" \\\\\\n \\\" classification)]. The sentence vectors are of a similar form, except the sentence text is\\\" \\\\\\n \\\" replaced with the vector representation of the sentence. The features are of the form \\\" \\\\\\n \\\"[(AbstractROUGE, TF-IDF, Document_TF-IDF, keyphrase_score, title_score, numeric_score,\\\" \\\\\\n \\\" sentence_length, section)]. The dimensions of each sentence vector are [1x100]. The \\\" \\\\\\n \\\"abstract vector is a single [1x100] vector also.\\\"\\n\\n # The data item that will be written for this paper\\n data_item = {\\n \\\"filename\\\": filename,\\n \\\"gold\\\": gold,\\n \\\"title\\\": paper[\\\"MAIN-TITLE\\\"],\\n \\\"abstract\\\": abstract,\\n \\\"abstract_vec\\\": abs_vector,\\n \\\"sentences\\\": data,\\n \\\"sentence_vecs\\\": sentvecs_secs_class,\\n \\\"sentence_features\\\": features,\\n \\\"description\\\": description_text\\n }\\n\\n # Write the data out\\n with open(TRAINING_DATA_WRITE_LOC + filename.strip(\\\".txt\\\") + \\\".json\\\", \\\"wb\\\") as f:\\n json.dump(data_item, f)\\n\\n print(\\\"--> Finished processing {}, took {} seconds, data length: {}.\\\".format(\\n filename, (time.time() - start_time), len(data)))\",\n \"def Subtask4_pre_train_3():\\n train_data = np.load(PATH + 'pre_train_2_Subtask4.npy', allow_pickle=True).item()\\n\\n evidence = []\\n for d in train_data.items():\\n for i in range(5):\\n evidence.append(d[1][i])\\n\\n files = os.listdir(PATH + 'data/wiki-pages/wiki-pages/')\\n documents = {}\\n for i in files:\\n with open(os.path.join(PATH + 'data/wiki-pages/wiki-pages/', i)) as fp:\\n lines = fp.readlines()\\n for line in lines:\\n line = eval(line)\\n if line['id'] in evidence:\\n text = line['lines']\\n documents[line['id']] = text\\n with open(PATH + 'pre_train_3_Subtask4.txt', 'w', encoding='utf-8') as f:\\n f.write(str(documents))\",\n \"def main(board_name, card_name, checklist_name, api_key, token, file):\\n items = [line.strip() for line in file]\\n trello = Client(api_key, token)\\n board = utils.get_board_by_name(trello, board_name)\\n card = utils.get_card_by_name(board, card_name)\\n utils.add_checklist(card, checklist_name, items)\",\n \"def get_messages(message_count):\\r\\n\\r\\n file = open('messages.htm', encoding='UTF-8')\\r\\n\\r\\n html = file.read().split('</p>')\\r\\n file.close()\\r\\n\\r\\n TOTAL[0] = len(html) - 1\\r\\n\\r\\n # Gets rid of formatting at the beginning\\r\\n start = html[0].find('<div class=\\\"message\\\">')\\r\\n while not html[0][start].isnumeric():\\r\\n start += 1\\r\\n html[0] = html[0][start:]\\r\\n\\r\\n html.pop()\\r\\n\\r\\n threads = []\\r\\n\\r\\n que = Queue(maxsize=50)\\r\\n for line in html:\\r\\n try:\\r\\n clean_line = BeautifulSoup(line, 'lxml').getText()\\r\\n except Exception:\\r\\n print('Install lxml')\\r\\n #print(line)\\r\\n if len(clean_line) != 0:\\r\\n t = threading.Thread(target=add_option,\\r\\n args=(message_count, que, threads))\\r\\n que.put(clean_line)\\r\\n\\r\\n t.daemon = True\\r\\n t.start()\\r\\n threads.append(t)\\r\\n\\r\\n que.join()\",\n \"def load(self):\\n prob_data = open(self.probsfile,\\\"r\\\",encoding=\\\"utf-8\\\")\\n self.probs = {trigram.split(\\\"\\\\t\\\")[0]:float(trigram.split(\\\"\\\\t\\\")[2]) for trigram in prob_data.readlines()}\",\n \"def main ():\\n\\n\\tfio = fileIo('input.txt')\\n text = fio.getInput()\\n\\n\\tp = re.compile(r'#?\\\\d[\\\\s\\\\.]?[\\\\s]?')\\n\\tout = filter(None, p.split(text))\\n\\ti = 0\\n\\tlistOfLists = []\\n\\t\\n\\n\\tfor s in out:\\n\\t\\ti += 1\\n\\t\\ttext = nltk.word_tokenize(s)\\n\\t\\tpos = nltk.pos_tag(text)\\n\\t\\tpattern = \\\"NP: {<DT>?<JJ>*<NN>}\\\"\\n\\t\\tNPChunker = nltk.RegexpParser(pattern)\\n\\t\\tresult = NPChunker.parse(pos)\\n\\t\\tlistOfLists.append( result )\\n\\n\\tprint \\\"Noun Count:\\\\n\\\" + str(countNouns( listOfLists ))\\n\\tprint \\\"Verb Count:\\\\n\\\" + str(countVerbs( listOfLists ))\\n\\tprint \\\"Adjective Count:\\\\n\\\" + str(countAdjectives( listOfLists ))\",\n \"def main():\\r\\n save_file_location = \\\"Item_List.txt\\\"\\r\\n data_file_a = open(save_file_location, \\\"a\\\") # Opens ItemList.txt which\\r\\n # is accessible in the file variable, in append mode (using this so that\\r\\n # if the file exists, nothing happens, but if it does not exist, it gets\\r\\n # created from w3schools.com\\r\\n data_file_a.close() # Close the file, I now know it exists\\r\\n loaded_list = load_from_file(save_file_location)\\r\\n print(\\\"Welcome to the To-Do List - Version: 0.1.2\\\")\\r\\n divider(42) # Length of welcome statement above\\r\\n menu_loop(loaded_list, save_file_location)\",\n \"def __init__(self, seqfile, predfile):\\n assert seqfile.endswith(\\\".mpd\\\"), predfile.endswith(\\\".pred\\\")\\n\\n self._seqfile = seqfile\\n self._predfile = predfile\\n self._parse = None # to stock the parsed sequences\\n self._motifs = None\",\n \"def train(self, trainfile):\",\n \"def run():\\n logger.info(f\\\"Process started:\\\")\\n logger.info(f\\\"Converting Glove file to Word2Vec format\\\")\\n convert_to_word2vec.convert(\\n \\\"./data/source/glove.6B.50d.txt\\\", \\\"./data/source/glove.6B.50d.w2vformat.txt\\\"\\n )\\n\\n logger.info(f\\\"Extracting Click Stream data\\\")\\n extract_click_stream_data()\\n\\n logger.info(\\\"Extracting Wiki articles\\\")\\n extract_wiki_articles()\\n\\n logger.info(f\\\"Generating Clickstream dataset\\\")\\n generate_datasets()\\n\\n logger.info(\\\"Tokenizing articles\\\")\\n WikiArticlesTokenizer().process()\\n\\n logger.info(\\\"Creating dataset with Wiki Articles\\\")\\n create_wiki_articles_dataset()\",\n \"def mk_eng_txt_files(self, **rewrite):\\n\\n\\n print \\\"mk_eng_txt_files: RETRIEVING PAGE_LIST..........\\\"\\n page_list = c_m.l_of_l_read(self.page_list_path)\\n\\n if len(page_list) < 1: # handling empty page_list case\\n print \\\"mk_eng_txt_files: PAGE LIST IS NOT POPULATED, RUN HTML_File_Maker AND Text_Extractor MODULES FIRST\\\"\\n else: # handling page_list for partially transalted sites\\n print \\\"mk_eng_txt_files: IN CASE PAGE LIST ALREADY HAD SOME ENG_TEXT ENTRIES SETTING INITIAL new_page_list TO LAST KNOWN PAGE_LIST VERSION\\\"\\n self.new_page_list = copy(page_list)\\n\\n\\n\\n # iterating throug unique text per page txts\\n for data_set in page_list:\\n self.p_text_f_name = data_set[2]\\n print \\\"mk_eng_txt_files: TRANSLATING TEXT FROM FILE %s\\\" % self.p_text_f_name\\n\\n self.eng_p_text_f_name = \\\"eng_\\\" + self.p_text_f_name\\n self.eng_p_text_f_path = self.text_eng_folder_path + self.eng_p_text_f_name\\n\\n self.page_text = c_m.simply_read(self.text_folder_path, self.p_text_f_name)\\n\\n # if page has less than 10 symbols it is not translated\\n if len(self.page_text) < 10:\\n print \\\"mk_eng_txt_files: NOT WORTH TRANSLATING, WRITING AS IS AND SKIPPING...\\\"\\n c_m.simply_write(self.page_text, self.eng_p_text_f_path)\\n\\n elif len(self.page_text) > self.max_page_length:\\n print \\\"mk_eng_txt_files: PAGE TEXT IS TOO LONG DEVIDING TO PARTS, TRANSLATING AND GETTING BACK FULL PAGE TEXT\\\"\\n text_output = self.get_text_parts(**rewrite)\\n\\n else: # 10 < len(page_text) < 2000\\n\\n if rewrite[\\\"rewrite\\\"]:\\n print \\\"mk_eng_txt_files: TRANSLATING IN REWRITE MODE\\\"\\n text_output = self.get_text()\\n\\n\\n elif not os.path.exists(self.eng_p_text_f_path):\\n print \\\"mk_eng_txt_files: TRANSLATING IN ONLY ONCE MODE\\\"\\n text_output = self.get_text()\\n\\n else:\\n print \\\"mk_eng_txt_files: SKIPPING FILE, ALREADY TRANSLATED\\\"\\n # continue\\n\\n # print \\\"WRITING TRANSLATED OUTPUT TO FILE: \\\", self.eng_p_text_f_name\\n # c_m.simply_write(text_output, self.text_eng_folder_path, self.eng_p_text_f_name) \\n data_set.append(self.eng_p_text_f_name) # updating dataset with eng_text file name\\n self.new_page_list.append(data_set) # updating page list with updated entry\\n\\n\\n print \\\"mk_eng_txt_files: DONE TRANSLATING SITE %s \\\" % self.domain\\n print \\\"mk_eng_txt_files: UPDATING PAGE LIST WITH ENG TEXT FILE NAMES\\\"\\n c_m.l_of_l_write(self.new_page_list, self.page_list_path)\\n print \\\"mk_eng_txt_files: SITE TRANSLATION FINISHED, CLOSING CHROME WEBDIRVER\\\"\\n self.loaded_driver.quit()\",\n \"def __init__(self, fileinit, filegoal):\\n \\n self.board = Board(filegoal)\\n self.numbernodes = 0\\n Io = IO(fileinit)\\n Io.init_reader()\\n self.boxes = []\\n i = 0\\n j = 0\\n for line in Io.file :\\n for elem in line :\\n if elem == \\\"$\\\" :\\n self.boxes.append(Box(i,j))\\n elif elem == \\\"@\\\":\\n self.char = Char(i,j)\\n j+=1\\n j=0\\n i+=1\\n self.direction = [Direction.UP,Direction.DOWN,Direction.LEFT,Direction.RIGHT]\\n \\n self.goalsize = len(self.board.positionGoal)\\n self.listCombi = heuristic.make_combi(self.board.positionGoal,self.goalsize)\\n self.mini = 10000\\n Problem.__init__(self, State(self.board,self.boxes,self.char,[]))\",\n \"def main(args):\\n\\tprint(\\\"Reading the data\\\")\\n\\tdataDict = loadData(args.f, args.s)\\n\\n\\tuseBothHalves = args.full\\n\\tuseEmb = args.emb or args.full\\n\\n\\t#unpack the data\\n\\tif useEmb:\\n\\t\\ttrainData = setupEmbeddings(dataDict[\\\"train_x\\\"], useBothHalves)\\n\\t\\tdevData = setupEmbeddings(dataDict[\\\"dev_x\\\"], useBothHalves)\\n\\t\\ttestData = setupEmbeddings(dataDict[\\\"test_x\\\"], useBothHalves)\\n\\telse:\\n\\t\\ttrainData = dataDict[\\\"train_x\\\"]\\n\\t\\tdevData = dataDict[\\\"dev_x\\\"]\\n\\t\\ttestData = dataDict[\\\"test_x\\\"]\\n\\n\\trawTrainingLabels = dataDict[\\\"train_y\\\"] \\n\\trawDevLabels = dataDict[\\\"dev_y\\\"] \\n\\trawTestingLabels = dataDict[\\\"test_y\\\"] \\n\\t\\t\\n\\t#make the event map\\n\\teventMap = load(open(args.m))\\n\\n\\tparams = Parameters(eventMap)\\n\\n\\ttrainingLabels = eventMap.namesToMatrix(rawTrainingLabels)\\n\\tdevLabels = eventMap.namesToMatrix(rawDevLabels)\\n\\t#testingLabels = eventMap.namesToMatrix(rawTestingLabels)\\n\\n\\tif args.dev:\\n\\t\\tdata, labels = joinDev(trainData, trainingLabels, devData, devLabels)\\n\\n\\telse:\\n\\t\\tdata = trainData\\n\\t\\tlabels = trainingLabels\\n\\n\\tparams.emb = args.emb\\n\\tparams.useBothHalves = useBothHalves\\n\\tparams.samples = data[0].shape[0]\\n\\tparams.windowSize = data[0].shape[1]\\n\\tparams.batchSize = args.b\\n\\tparams.epochs = args.e\\n\\tparams.split = args.s\\n\\tparams.limit = args.limit\\n\\n\\tif useEmb:\\n\\t\\tw2vPath = \\\"data/vectors/word2vec/GoogleNews-vectors-negative300.bin.gz\\\"\\n\\t\\tindexPath = \\\"data/word_index.p\\\"\\n\\t\\t\\n\\t\\t#load the weights\\n\\t\\tw2v = loadW2V(w2vPath)\\n\\t\\t\\n\\t\\t#load the index\\n\\t\\twordIndex = load(open(indexPath))\\n\\t\\t\\n\\t\\t#make the initial weights\\n\\t\\tparams.wordWeights = makeEmbeddingWeights(w2v, wordIndex)\\n\\n\\telse:\\n\\t\\tparams.wordSize = data[0].shape[2]\\n\\n\\tif args.s:\\n\\t\\tparams.contextSize = data[2].shape[1]\\n\\telse:\\n\\n\\t\\tif useBothHalves:\\n\\t\\t\\tparams.contextSize = data[-1].shape[1]\\n\\t\\telse:\\n\\t\\t\\tparams.contextSize = data[1].shape[1]\\n\\n\\tprint(\\\"Training\\\")\\n\\n\\tif args.std:\\n\\t\\tprint(\\\"Standard Cross Validation\\\")\\n\\t\\tvalidator = StandardSplitter(args.c)\\n\\t\\n\\telif args.strat:\\n\\t\\tprint(\\\"Stratified Cross Validation\\\")\\n\\t\\tvalidator = StratifiedSplitter(args.c)\\n\\n\\telse:\\n\\t\\tprint(\\\"Random Cross Validation\\\")\\n\\t\\tvalidator = RandomSplitter(args.p, args.c)\\n\\n\\tmkdir(args.o)\\n\\n\\tmodels = crossTrain(data, labels, args.o, args.k, validator, params)\\n\\n\\tprint(\\\"Make Predictions\\\")\\n\\t\\n\\t\\\"\\\"\\\"\\n\\t#make predictions\\n\\ttrainPred = majorityPredictions(models, trainData, args.b, len(eventMap))\\n\\tdevPred = majorityPredictions(models, devData, args.b, len(eventMap))\\n\\n\\tprint(\\\"\\\\nEvalutation\\\")\\n\\n\\tprint(\\\"-----Training Scores-----\\\")\\n\\tevaluatePredictions(trainPred, rawTrainingLabels, eventMap)\\n\\n\\tprint(\\\"\\\\n-----Dev Scores------\\\")\\n\\tevaluatePredictions(devPred, rawDevLabels, eventMap)\\n\\n\\tif args.t:\\n\\t\\ttestPred = majorityPredictions(models, testData, args.b, len(eventMap))\\n\\t\\t\\n\\t\\tprint(\\\"\\\\n\\\\n-----Test Scores------\\\")\\n\\t\\tevaluatePredictions(testPred, rawTestingLabels, eventMap)\\n\\t\\\"\\\"\\\"\",\n \"def main():\\n Tkinter.Tk().withdraw()\\n try:\\n #Ask user for the file and open the file in read mode\\n file=tkFileDialog.askopenfile()\\n\\n try:\\n #Read the file, split contents by lines, then split lines into words using \\\",\\\" as separator and\\n # use the words to create carEvaluation object\\n carevaluation_list=[CarEvaluation(*lines.split(\\\",\\\")) for lines in file.read().splitlines()]\\n process_records(carevaluation_list)\\n except Exception, e:\\n print \\\"Error: Parsing file. Terminating the program! \\\" + str(e)\\n sys.exit(e)\\n finally:\\n file.close()\\n except Exception, e:\\n print \\\"Error: Could not open the file to read. Terminating the program! \\\" + str(e)\\n sys.exit(e)\",\n \"def __init__(self, txt_path, in_vocab_path, out_vocab_path):\\n self.txt_seqs = open(txt_path, encoding='utf8', errors='ignore').readlines()\\n self.word2id = utils.load_vocab(in_vocab_path,\\n extra_word_list=[\\\"<UNK>\\\", \\\"<END>\\\"])\\n self.punc2id = utils.load_vocab(out_vocab_path,\\n extra_word_list=[\\\" \\\"])\\n self.class2punc = { k : v for (v, k) in self.punc2id.items()}\",\n \"def run_from_file(f):\\n #set defaults\\n x_loops=1;max_steps=0;display_on=True;max_fps=10;garden_size=13;tako_number=20\\n pop_max=40;max_width=1800;max_height=900;collect_data=True;export_all=False\\n rand_nets=False;max_gen=0;genetic_mode=\\\"Plain\\\";learning_on=False\\n seeds=None;garden_mode=\\\"Diverse Static\\\";family_detection=None;family_mod=0\\n record_inbreeding=True;inbreed_lim=1.1;filename=\\\"default file\\\"\\n hla_genes=0;binary_health=0;carrier_percentage=40;two_envs=False\\n diff_envs=False;migration_rate=0;phen_pref=False\\n\\n \\n atr_dict = {\\\"x_loops\\\": x_loops, \\\"max_steps\\\": max_steps,\\n \\\"display_on\\\": display_on, \\\"max_fps\\\": max_fps,\\n \\\"garden_size\\\": garden_size,\\n \\\"tako_number\\\": tako_number, \\\"pop_max\\\": pop_max,\\n \\\"max_width\\\": max_width, \\\"max_height\\\": max_height,\\n \\\"collect_data\\\": collect_data, \\\"export_all\\\": export_all,\\n \\\"rand_nets\\\": rand_nets, \\\"max_gen\\\": max_gen,\\n \\\"genetic_mode\\\": genetic_mode, \\\"learning_on\\\": learning_on,\\n \\\"seeds\\\": seeds, \\\"garden_mode\\\": garden_mode,\\n \\\"family_detection\\\": family_detection, \\\"family_mod\\\": family_mod,\\n \\\"record_inbreeding\\\": record_inbreeding,\\n \\\"inbreed_lim\\\": inbreed_lim, \\\"filename\\\": filename,\\n \\\"hla_genes\\\": hla_genes, \\\"binary_health\\\": binary_health,\\n \\\"carrier_percentage\\\": carrier_percentage,\\n \\\"two_envs\\\": two_envs, \\\"diff_envs\\\": diff_envs,\\n \\\"migration_rate\\\": migration_rate, \\\"phen_pref\\\": phen_pref}\\n \\n ints = [\\\"x_loops\\\", \\\"max_steps\\\", \\\"garden_size\\\", \\\"tako_number\\\", \\\"pop_max\\\",\\n \\\"max_width\\\", \\\"max_height\\\", \\\"max_gen\\\", \\\"hla_genes\\\",\\n \\\"binary_health\\\", \\\"carrier_percentage\\\", \\\"max_fps\\\"]\\n floats = [\\\"family_mod\\\", \\\"inbreed_lim\\\", \\\"migration_rate\\\"]\\n strs = [\\\"genetic_mode\\\", \\\"garden_mode\\\", \\\"filename\\\"]\\n bools = [\\\"display_on\\\", \\\"collect_data\\\", \\\"export_all\\\", \\\"rand_nets\\\",\\n \\\"learning_on\\\", \\\"record_inbreeding\\\", \\\"two_envs\\\", \\\"diff_envs\\\",\\n \\\"phen_pref\\\"]\\n\\n #then sets all user-defined settings from the file f\\n with open(f) as exp_file:\\n for line in exp_file:\\n #comments\\n if line[0] == \\\"#\\\":\\n pass\\n #blank line = run what we have, then continue\\n #to read the file for a new set of parameters\\n elif line == \\\"\\\\n\\\":\\n run_experiment(atr_dict[\\\"x_loops\\\"], atr_dict[\\\"max_steps\\\"],\\n atr_dict[\\\"display_on\\\"], atr_dict[\\\"max_fps\\\"],\\n atr_dict[\\\"garden_size\\\"],\\n atr_dict[\\\"tako_number\\\"], atr_dict[\\\"pop_max\\\"],\\n atr_dict[\\\"max_width\\\"], atr_dict[\\\"max_height\\\"],\\n atr_dict[\\\"collect_data\\\"], atr_dict[\\\"export_all\\\"],\\n atr_dict[\\\"rand_nets\\\"], atr_dict[\\\"max_gen\\\"],\\n atr_dict[\\\"genetic_mode\\\"],\\n atr_dict[\\\"learning_on\\\"],\\n atr_dict[\\\"seeds\\\"], atr_dict[\\\"garden_mode\\\"],\\n atr_dict[\\\"family_detection\\\"],\\n atr_dict[\\\"family_mod\\\"],\\n atr_dict[\\\"record_inbreeding\\\"],\\n atr_dict[\\\"inbreed_lim\\\"],\\n atr_dict[\\\"hla_genes\\\"], atr_dict[\\\"binary_health\\\"],\\n atr_dict[\\\"carrier_percentage\\\"],\\n atr_dict[\\\"filename\\\"],\\n atr_dict[\\\"two_envs\\\"],\\n atr_dict[\\\"diff_envs\\\"],\\n atr_dict[\\\"migration_rate\\\"],\\n atr_dict[\\\"phen_pref\\\"])\\n #reset defaults\\n atr_dict = {\\\"x_loops\\\": x_loops, \\\"max_steps\\\": max_steps,\\n \\\"display_on\\\": display_on, \\\"max_fps\\\": max_fps,\\n \\\"garden_size\\\": garden_size,\\n \\\"tako_number\\\": tako_number, \\\"pop_max\\\": pop_max,\\n \\\"max_width\\\": max_width, \\\"max_height\\\": max_height,\\n \\\"collect_data\\\": collect_data, \\\"export_all\\\": export_all,\\n \\\"rand_nets\\\": rand_nets, \\\"max_gen\\\": max_gen,\\n \\\"genetic_mode\\\": genetic_mode, \\\"learning_on\\\": learning_on,\\n \\\"seeds\\\": seeds, \\\"garden_mode\\\": garden_mode,\\n \\\"family_detection\\\": family_detection,\\n \\\"family_mod\\\": family_mod,\\n \\\"record_inbreeding\\\": record_inbreeding,\\n \\\"inbreed_lim\\\": inbreed_lim, \\\"filename\\\": filename,\\n \\\"hla_genes\\\": hla_genes, \\\"binary_health\\\": binary_health,\\n \\\"carrier_percentage\\\": carrier_percentage,\\n \\\"two_envs\\\": two_envs, \\\"diff_envs\\\": diff_envs,\\n \\\"migration_rate\\\": migration_rate, \\\"phen_pref\\\": phen_pref}\\n else:\\n #get rid of newline character\\n line = line[:-1]\\n line = line.split(\\\": \\\")\\n if line[0] in ints:\\n val = int(line[1])\\n elif line[0] in floats:\\n val = float(line[1])\\n elif line[0] in bools:\\n val = True if line[1] == \\\"True\\\" else False\\n elif line[0] in strs:\\n val = line[1]\\n elif line[0] == \\\"family_detection\\\":\\n if line[1] == \\\"None\\\":\\n val = None\\n else:\\n val = line[1]\\n elif line[0] == \\\"seeds\\\":\\n val = line[1].split(\\\" \\\")\\n atr_dict[line[0]] = val\\n #run the last one in the file\\n run_experiment(atr_dict[\\\"x_loops\\\"], atr_dict[\\\"max_steps\\\"],\\n atr_dict[\\\"display_on\\\"], atr_dict[\\\"max_fps\\\"],\\n atr_dict[\\\"garden_size\\\"],\\n atr_dict[\\\"tako_number\\\"], atr_dict[\\\"pop_max\\\"],\\n atr_dict[\\\"max_width\\\"], atr_dict[\\\"max_height\\\"],\\n atr_dict[\\\"collect_data\\\"], atr_dict[\\\"export_all\\\"],\\n atr_dict[\\\"rand_nets\\\"], atr_dict[\\\"max_gen\\\"],\\n atr_dict[\\\"genetic_mode\\\"],\\n atr_dict[\\\"learning_on\\\"],\\n atr_dict[\\\"seeds\\\"], atr_dict[\\\"garden_mode\\\"],\\n atr_dict[\\\"family_detection\\\"],\\n atr_dict[\\\"family_mod\\\"],\\n atr_dict[\\\"record_inbreeding\\\"],\\n atr_dict[\\\"inbreed_lim\\\"], atr_dict[\\\"hla_genes\\\"],\\n atr_dict[\\\"binary_health\\\"], atr_dict[\\\"carrier_percentage\\\"],\\n atr_dict[\\\"two_envs\\\"], atr_dict[\\\"diff_envs\\\"],\\n atr_dict[\\\"migration_rate\\\"], atr_dict[\\\"phen_pref\\\"],\\n atr_dict[\\\"filename\\\"])\",\n \"def run(self):\\n\\n self.load_file()\\n self.cat_to_num()\\n self.split()\",\n \"def process_page(page: int) -> None:\\n request = requests.get(URL_TEMPLATE.format(LIBRE_FM_USERNAME, page))\\n\\n xml_page = ET.fromstring(request.text)\\n all_listens = xml_page.getiterator(\\\"track\\\") # pylint: disable=deprecated-method\\n\\n listens = []\\n for listen in all_listens:\\n # Iterate each listen and extract required fields\\n artist_mbids = None\\n if listen.find(\\\"artist\\\") and listen.find(\\\"artist\\\").get(\\\"mbid\\\"):\\n artist_mbids = [listen.find(\\\"artist\\\").get(\\\"mbid\\\")]\\n\\n listens.append(\\n pylistenbrainz.Listen(\\n artist_name=listen.find(\\\"artist\\\").text,\\n artist_mbids=artist_mbids,\\n release_name=listen.find(\\\"album\\\").text,\\n release_mbid=listen.find(\\\"album\\\").get(\\\"mbid\\\"),\\n track_name=listen.find(\\\"name\\\").text,\\n recording_mbid=listen.find(\\\"mbid\\\").text,\\n listened_at=listen.find(\\\"date\\\").get(\\\"uts\\\"),\\n )\\n )\\n\\n try:\\n # Send all listens to Listenbrainz\\n listenbrainz.submit_multiple_listens(listens)\\n except pylistenbrainz.errors.ListenBrainzAPIException as exc:\\n print(exc.message)\\n raise exc\",\n \"def main():\\n\\n # this part of the program opens student txt resume and detects key info\\n\\n # sets the name of resume txt file to be scanned for content\\n resume_txt_file = \\\"resume.txt\\\"\\n\\n resume_txt = read_student_info(resume_txt_file)\\n student_name = detect_name(resume_txt)\\n student_email = detect_email(resume_txt)\\n student_courses = detect_courses(resume_txt)\\n student_projects = detect_projects(resume_txt)\\n\\n # this part of program prepares the code for html resume.\\n\\n # sets the location of the imput resume txt file to be reformatted by the program\\n resume_template_file = \\\"resume_template.html\\\"\\n\\n # creates a resume template\\n resume_output = read_html_template(resume_template_file)\\n resume_output = remove_bottom_end_tags(resume_output)\\n\\n # adds page wrapper (open tag), student info, projects, courses, and bottom tags to the html code to-be-printed, in order mentioned\\n resume_output = add_pagewrap(resume_output)\\n resume_output = add_s_info(student_name, student_email, resume_output)\\n resume_output = add_s_projects(student_projects, resume_output)\\n resume_output = add_s_courses(student_courses, resume_output)\\n resume_output = add_bottom_end_tags(resume_output)\\n\\n # print(resume_output)\\n\\n # this part of the program writes the resume output html code into resume.html\\n\\n # sets the resume.html file as output file\\n fout = open(\\\"resume.html\\\", \\\"w\\\")\\n # writes the html code!\\n fout.writelines(resume_output)\\n # saves to file and closes the output file resume.html\\n fout.close()\",\n \"def train():\\n num_spam=0 \\n num_ham=0\\n spam_words=()\\n ham_words=()\\n pullData = open(\\\"labels\\\", \\\"r\\\").read()\\n dataArray= pullData.split('\\\\n')\\n #print(dataArray)\\n dataArrayTrain=dataArray[0:21300] #opens training set from folder 000-070\\n \\n for eachLine in dataArrayTrain:\\n kind,file = eachLine.split(' ')\\n file=file.strip('../') \\n #print(kind)\\n #print(file)\\n \\n fileDir = os.path.dirname(os.path.realpath('__file__'))\\n filepath = os.path.join(fileDir,file) \\n print(filepath)\\n email=\\\"\\\"\\n fh = open(filepath, encoding=\\\"ascii\\\", errors=\\\"ignore\\\")\\n for line in fh:\\n email += line\\n fh.close()\\n email= email.lower()\\n #print(email)\\n email_words = processText(contentEmail(email))\\n #print(email_words)\\n email_words = tuple(list(set(email_words))) #converted it into a set to avoid repetition of words in every email\\n #print(email_words)\\n if (kind == \\\"spam\\\"):\\n num_spam+=1 #counts how many spam emails\\n spam_words= spam_words + tuple(email_words) #adds every word to a spam tuple\\n\\n elif (kind==\\\"ham\\\"):\\n num_ham+=1 #counts how many ham emails\\n ham_words= ham_words + tuple(email_words) #adds every word to a ham tuple\\n\\n spam_words= tuple(spam_words)\\n ham_words= tuple(ham_words)\\n\\n \\n count_spam = collections.Counter(spam_words) #counts how many times a words appears in all spam emails\\n count_ham = collections.Counter(ham_words) #counts how many times a words appears in all ham emails\\n total_count = (count_spam + count_ham).most_common(5000) #adds the total occurences of the words and gets top 5000\\n #print(total_count)\\n #print(num_ham, num_spam)\\n\\n top_words = []\\n for everyword in total_count:\\n top_words.append(everyword[0])\\n for everyword in list(count_spam):\\n if everyword not in top_words:\\n del count_spam[everyword] #deletes words in spam emails not included in top 5000\\n for everyword in list(count_ham):\\n if everyword not in top_words:\\n del count_ham[everyword] #deletes words in ham emails not included in top 5000\\n #print(words, count_ham, count_spam)\\n\\n file_encoder = open(\\\"top_word_count.txt\\\", \\\"w+\\\", encoding = 'utf-8', errors = 'ignore')\\n file_encoder.write(\\\"HERE ARE YOUR TOP 5000 WORDS: \\\"+\\\"\\\\n\\\"+str(total_count)+\\\"\\\\n\\\"+\\\"\\\\n\\\"+\\\"SPAM WORDS: \\\"+\\\"\\\\n\\\"+str(count_spam)+\\\"\\\\n\\\"+\\\"\\\\n\\\"+\\\"HAM WORDS: \\\"+\\\"\\\\n\\\"+str(count_ham))\\n file_encoder.close()\\n print(\\\"Counting and getting top 5000 words successful!\\\")\\n probabilityGet(num_spam, num_ham, count_spam, count_ham)\",\n \"def callback(message):\\n installation_id = message.attributes['installation_id']\\n repo_owner = message.attributes['repo_owner']\\n repo_name = message.attributes['repo_name']\\n issue_num = message.attributes['issue_num']\\n logging.info(f'Receive issue #{issue_num} from {repo_owner}/{repo_name}')\\n\\n try:\\n # predict labels\\n self.load_yaml(repo_owner, repo_name)\\n self.download_model_from_gcs()\\n predictions, issue_embedding = self.predict_labels(repo_owner, repo_name, issue_num)\\n self.add_labels_to_issue(installation_id, repo_owner, repo_name,\\n issue_num, predictions)\\n\\n # log the prediction, which will be used to track the performance\\n log_dict = {\\n 'repo_owner': repo_owner,\\n 'repo_name': repo_name,\\n 'issue_num': int(issue_num),\\n 'labels': predictions['labels']\\n }\\n logging.info(log_dict)\\n\\n except Exception as e:\\n # hard to find out which errors should be handled differently (e.g., retrying for multiple times)\\n # and how to handle the error that the same message causes for multiple times\\n # so use generic exception to ignore all errors for now\\n logging.error(f'Addressing issue #{issue_num} from {repo_owner}/{repo_name} causes an error')\\n logging.error(f'Error type: {type(e)}')\\n logging.error(e)\\n\\n # acknowledge the message, or pubsub will repeatedly attempt to deliver it\\n message.ack()\",\n \"def main():\\n args = get_args()\\n str_arg = args.arg\\n int_arg = args.int\\n flag_arg = args.flag\\n #pos_arg = args.positional\\n\\n #read and open the annotations file\\n intpro_dict = {}\\n with open('InterPro_entry_list.tsv') as csvfile:\\n reader = csv.DictReader(csvfile, delimiter='\\\\t')\\n for row in reader:\\n intpro_dict[row['ENTRY_AC']] = row['ENTRY_NAME']\\n\\n with open('model_topics.txt', 'r') as file:\\n model_topics = file.read().replace('\\\\n', '')\\n\\n model_topics = re.sub(\\\"'\\\", \\\"\\\", model_topics)\\n model_topics = re.sub(\\\"\\\\[\\\", \\\"\\\", model_topics)\\n model_topics = re.sub(\\\"\\\\]\\\", \\\"\\\", model_topics)\\n\\n mtl = model_topics.split('), ')\\n\\n with open('output_topics.tsv' ,'w') as f:\\n print('Topic\\\\tModel_coefficient\\\\tInterpro_ID\\\\tInterPro_ENTRY_NAME', file=f)\\n for list in mtl:\\n topic = list[1]\\n split_list = list.split()\\n id_re = re.compile('IPR\\\\d{3}')\\n c_words = []\\n for w in split_list:\\n match = id_re.search(w)\\n if match:\\n c_words.append(w)\\n c_words = [re.sub('\\\"', '', i) for i in c_words]\\n for w in c_words:\\n re.sub('\\\\)', '', w)\\n coef, intpro = w.split('*')\\n intpro = intpro[:9]\\n\\n if intpro in intpro_dict.keys():\\n label = intpro_dict[intpro]\\n else:\\n label = ''\\n\\n print('{}\\\\t{}\\\\t{}\\\\t{}'.format(topic,coef,intpro,label), file=f)\",\n \"def process_test_data_bigrams(file_path, label_matches, transition_probabilities):\\r\\n\\tlabel_index_dict = {}\\r\\n\\tstarting_index = 0\\r\\n\\tline_number = 0\\r\\n\\twith open(file_path) as f:\\r\\n\\t\\tfor line in f:\\r\\n\\t\\t\\tif line_number%3 == 0:\\r\\n\\t\\t\\t\\tline = line.strip().lower().split('\\\\t')\\r\\n\\t\\t\\t\\tlabel_index_dict = process_sentence_bigrams(line, starting_index, label_matches, label_index_dict, transition_probabilities)\\r\\n\\t\\t\\t\\tstarting_index += len(line)\\r\\n\\t\\t\\tline_number +=1\\r\\n\\treturn label_index_dict\",\n \"def read_proc_card(self,proc_card,cond=''):\\n\\n# Define Process\\n\\n ff=open(proc_card,'r')\\n #read step by step \\n # 1) find the begin of the definition of process\\n # 2) read all process\\n # 3) find multiparticle\\n \\n # 1) find the begin of the definition of process\\n\\n tag_proc=re.compile(r'''#\\\\s*Begin\\\\s+PROCESS\\\\s*#''',re.I)\\n while 1:\\n line=ff.readline()\\n if line=='':\\n sys.exit('bad proc_card information: missing BEGIN PROCESS tag')\\n\\n if tag_proc.search(line):\\n break #(pass to step 2)\\n\\n # 2) read all process\\n\\n done=re.compile(r'''done''')\\n end_coup=re.compile(r'''end_coup''')\\n if cond:\\n process=re.compile(r'''>.*@\\\\s*'''+cond,re.DOTALL)\\n else:\\n process=re.compile(r'''>''')\\n\\n while 1:\\n line=ff.readline()\\n if line=='':\\n \\n sys.exit('bad proc_card information: missing request process tag (end of file)')\\n\\n if done.search(line):\\n if cond=='0':\\n ff.close()\\n return self.read_proc_card(proc_card)\\n sys.exit('bad proc_card information: missing request process tag')\\n \\n if process.search(line):\\n process_line=line\\n break #(pass to step 3)\\n\\n\\n # 3) find multiparticle\\n begin_multi=re.compile(r'''#\\\\s*Begin\\\\s+MULTIPARTICLES\\\\s*#''',re.I)\\n end_multi =re.compile(r'''#\\\\s*End\\\\s+MULTIPARTICLES\\\\s*#''',re.I)\\n info =re.compile(r'''^(?P<tag>[\\\\S]+)\\\\s+(?P<multi>[\\\\S]*)''')\\n multi={}\\n in_multi_area=0\\n while 1:\\n line=ff.readline()\\n if line=='':\\n sys.exit('bad proc_card information: missing multiparticle tag') \\n if end_multi.search(line):\\n break\\n\\n if begin_multi.search(line):\\n in_multi_area=1\\n continue\\n \\n if in_multi_area:\\n if info.search(line):\\n info2= info.search(line)\\n multi[info2.group('tag').lower()]=info2.group('multi')\\n\\n\\n \\n\\n return process_line,multi\",\n \"def load_data(self): # Loads data from 'SMSSpamCollection.txt'\\n with open('SMSSpamCollection.txt') as sms_data:\\n i = 0\\n for line in sms_data:\\n line = line.split(\\\"\\\\t\\\")\\n message_id = \\\"SMS\\\" + str(i)\\n self.spamorham[message_id] = line[0]\\n self.messages[message_id] = line[1].strip()\\n self.ids.append(message_id)\\n self.wordcounts[message_id] = self.split_messages(line[1])\\n i += 1\\n self.NUMOFMESSAGES = i\",\n \"def addEntry(self, listDictions):\\n ## load xml\\n improvDoc = loadIMProvFile(self.argsFile)\\n entrname= 'Job'\\n for dictions in listDictions:\\n report = IMProvNode(entrname , None, **dictions)\\n improvDoc.addNode(report)\\n outfile = file( self.argsFile, 'w').write(str(improvDoc))\\n return\",\n \"def predict(self, datafile):\",\n \"def procesPage(self, page):\\n item = pywikibot.ItemPage.fromPage(page)\\n pywikibot.output('Processing %s' % page)\\n if not item.exists():\\n pywikibot.output('%s doesn\\\\'t have a wikidata item :(' % page)\\n #TODO FIXME: We should provide an option to create the page\\n else:\\n pagetext = page.get()\\n templates = pywikibot.extract_templates_and_params(pagetext)\\n for (template, fielddict) in templates:\\n # We found the template we were looking for\\n if template.replace(u'_', u' ')==self.templateTitle:\\n for field, value in fielddict.items():\\n # This field contains something useful for us\\n if field in self.fields:\\n # Check if the property isn't already set\\n claim = pywikibot.Claim(self.repo, self.fields[field])\\n if claim.getID() in item.get().get('claims'):\\n pywikibot.output(u'A claim for %s already exists. Skipping' % (claim.getID(),))\\n #TODO FIXME: This is a very crude way of dupe checking\\n else:\\n # Try to extract a valid page\\n match = re.search(pywikibot.link_regex, value)\\n if match:\\n try:\\n link = pywikibot.Link(match.group(1))\\n linkedPage = pywikibot.Page(link)\\n if linkedPage.isRedirectPage():\\n linkedPage = linkedPage.getRedirectTarget()\\n linkedItem = pywikibot.ItemPage.fromPage(linkedPage)\\n claim.setTarget(linkedItem)\\n pywikibot.output('Adding %s --> %s' % (claim.getID(), claim.getTarget().getID()))\\n item.addClaim(claim)\\n if self.source:\\n claim.addSource(self.source, bot=True)\\n except pywikibot.exceptions.NoPage:\\n pywikibot.output('[[%s]] doesn\\\\'t exist so I can\\\\'t link to it' % (linkedItem.title(),))\",\n \"def main():\\n summary = dict()\\n gba_file = open('gettysburg.txt', 'r')\\n for line in gba_file:\\n Process_line(line, summary)\\n Pretty_print(summary)\",\n \"def parse_file():\\n\\tfile_lines = []\\n\\n\\t## For each line in the file, if it's not empty, store it\\n\\tfor line in fileinput.input():\\n\\t\\tif len(line) > 1:\\n\\t\\t\\tfile_lines.append(line.strip())\\n\\t\\n\\trun_algorithms(file_lines)\",\n \"def process_input_files(list_input_files):\\n global dict_models_results\\n global list_spacy_docs\\n \\n for input_file in list_input_files:\\n prefix = prefix_from_filename(input_file)\\n \\n with open(input_file) as f:\\n list_cases = json.load(f)\\n dict_models_results[prefix] = list_cases\\n \\n \\n #extract list of questions from all vignettes and create a mapping page -> vignette question\\n dict_questions = {}\\n for prefix, list_cases in dict_models_results.items():\\n for vignette in list_cases:\\n dict_questions[vignette[\\\"book_page\\\"]] = vignette[\\\"question\\\"]\\n \\n \\n for book_page,question in dict_questions.items():\\n doc_q = load_bner_onto_tokens_extension(question, book_page)\\n list_spacy_docs.append(doc_q)\\n \\n return\",\n \"def process_file(self, filename, order=2):\\n fp = open(filename)\\n self.skip_gutenberg_header(fp)\\n\\n for line in fp:\\n for word in line.rstrip().split():\\n self.process_word(word, order)\\n\\n #print(\\\">>>DEBUG the suffix map\\\")\\n #i = 0\\n #for k,v in self.suffix_map.items():\\n # print(\\\"key is {}, value is {}\\\".format(k, v))\\n # i += 1\\n # if i > 10:\\n # break\",\n \"def load(self, file_name):\\n try:\\n [self.add_word(w) for w in open(file_name).read().splitlines()]\\n except IOError as e:\\n print(e)\",\n \"def loadData(self):\\n machineToNode = {}\\n self.listOfMachines = []\\n nextID = 0\\n self.processingSteps = []\\n with open(self.filename) as f:\\n lines = f.read().splitlines()\\n for line in lines:\\n formatted = line.split(\\\"\\\\t\\\")\\n order = int(formatted[0])\\n machine = int(formatted[1])\\n timestamp = float(formatted[2])\\n if machine not in machineToNode: # normalizing machines according to the nodes (1,2,3... instead of 1,34,2...)\\n machineToNode[machine] = nextID\\n nextID +=1\\n self.listOfMachines.append(machineToNode[machine]) # normalized list of all machines\\n\\n pstep = ProcessingStep(machineToNode[machine], timestamp, order)\\n self.processingSteps.append(pstep)\",\n \"def testingPhase(SP, HP):\\n classification= {}\\n TP, TN, FP, FN = 0,0,0,0\\n\\n pullData = open(\\\"labels\\\", \\\"r\\\").read()\\n dataArray= pullData.split('\\\\n')\\n dataArrayTest=dataArray[21301:-1] #opens files from folder 070 onwards \\n \\n for eachLine in dataArrayTest:\\n kind,file = eachLine.split(' ')\\n print(file,kind)\\n if (kind == \\\"spam\\\"):\\n SO = 1 #initially stating that it is a spam not a ham\\n HO = 0\\n elif (kind== \\\"ham\\\"):\\n HO = 1\\n SO = 0\\n file=file.strip('../') \\n fileDir = os.path.dirname(os.path.realpath('__file__'))\\n filepath = os.path.join(fileDir,file) \\n email=\\\"\\\"\\n fh = open(filepath, encoding=\\\"ascii\\\", errors=\\\"ignore\\\")\\n for line in fh:\\n email += line\\n fh.close()\\n email= email.lower()\\n email_words = processText(contentEmail(email))\\n email_words = tuple(email_words)\\n spam_ba= math.log(PS,10) #initially contains value of Spam Probability\\n ham_ba= math.log(PH, 10) #initially contains value of Ham Probability\\n\\n\\n \\\"\\\"\\\"BAYES THEOREM\\\"\\\"\\\"\\n for word, value in SP.items(): \\n if word in email_words:\\n x = math.log(value, 10)\\n spam_ba += x\\n else:\\n x = math.log(1-value, 10)\\n #print(x)\\n spam_ba += x \\n if ham_ba > spam_ba:\\n label=\\\"ham\\\"\\n elif ham_ba < spam_ba:\\n label=\\\"spam\\\"\\n\\n for word,value in HP.items(): \\n if word in email_words:\\n x = math.log(value, 10)\\n #print(x)\\n ham_ba += x \\n else:\\n x = math.log(1-value, 10)\\n #print(x)\\n ham_ba += x \\n if ham_ba > spam_ba:\\n label=\\\"ham\\\"\\n elif ham_ba < spam_ba:\\n label=\\\"spam\\\"\\n\\n print(\\\"Spam Prob: \\\" ,spam_ba, \\\"Ham Prob: \\\" ,ham_ba)\\n\\n #This part determines if the emails are ham or spam depending on the calculations\\n if HO == 1 and label == \\\"ham\\\":\\n TN +=1\\n if HO == 1 and label == \\\"spam\\\":\\n FP +=1\\n if SO == 1 and label == \\\"spam\\\":\\n TP +=1\\n if SO == 1 and label == \\\"ham\\\":\\n FN +=1\\n #print(classification)\\n print(TP, TN, FP, FN)\\n print(spam_ba)\\n print(ham_ba)\\n \\\"\\\"\\\"COMPUTES PRECISION AND RECALL\\\"\\\"\\\"\\n Precision = TP/(TP+FP)\\n Recall = TP/(TP+FN)\\n\\n print(\\\"Precision: \\\", Precision, \\\" \\\", \\\"Recall: \\\", Recall)\",\n \"def load_from_file(self, fp, sep='\\\\n'):\\r\\n n = 0\\r\\n body = ''\\r\\n l = fp.readline()\\r\\n while l:\\r\\n if l == sep:\\r\\n m = Message(self, body)\\r\\n self.write(m)\\r\\n n += 1\\r\\n print 'writing message %d' % n\\r\\n body = ''\\r\\n else:\\r\\n body = body + l\\r\\n l = fp.readline()\\r\\n return n\",\n \"def main():\\r\\n\\r\\n prompt = 'Enter the name of the file that contains the card deck: '\\r\\n deck_file = open(get_valid_filename(prompt), 'r')\\r\\n deck = cipher_functions.read_deck(deck_file)\\r\\n deck_file.close()\\r\\n if not (cipher_functions.is_valid_deck(deck)):\\r\\n print('The supplied card deck is not a valid deck.')\\r\\n print('Encryption process stopping.')\\r\\n return\\r\\n\\r\\n prompt = 'Enter the name of the file that contains the message: '\\r\\n msg_file = open(get_valid_filename(prompt), 'r')\\r\\n messages = cipher_functions.read_messages(msg_file)\\r\\n msg_file.close()\\r\\n\\r\\n mode = get_encryption_mode()\\r\\n\\r\\n for msg in cipher_functions.process_messages(deck, messages, mode):\\r\\n print(msg)\",\n \"def run(self):\\n st.title('Acne Classifier')\\n st.markdown(STYLE, unsafe_allow_html=True)\\n file = st.file_uploader(\\\"Upload file\\\", type=self.fileTypes)\\n show_file = st.empty()\\n if not file:\\n show_file.info(\\\"Please upload a file of type: \\\" + \\\", \\\".join([\\\"png\\\", \\\"jpg\\\"]))\\n return\\n\\n file_bytes = np.asarray(bytearray(file.read()), dtype=np.uint8)\\n opencv_image = cv2.imdecode(file_bytes, 1)\\n cv2.imwrite('out.jpg', opencv_image)\\n df = get_score()\\n\\n df2 = df.set_index('Issue')\\n st.dataframe(df2)\\n st.bar_chart(df2)\\n\\n if isinstance(file, BytesIO):\\n show_file.image(file)\\n else:\\n data = pd.read_csv(file)\\n st.dataframe(data.head(10))\\n file.close()\",\n \"def process_file(fname):\\n # get the channel name\\n # this is dirty code, come up with a better solution\\n # e.g. storing the header info in the h5 file attrs\\n man = SortingManagerGrouped(fname)\\n try:\\n entity = man.header['AcqEntName']\\n except TypeError:\\n entity = 'unknown'\\n ncs_fname = os.path.basename(fname)[5:-3]\\n print(ncs_fname)\\n plot_fname = 'spikes_{}_{}'.format(entity, ncs_fname)\\n save_fname = os.path.join(OVERVIEW, plot_fname)\\n spikes_overview(ncs_fname, save_fname)\",\n \"def classify_new_email(filename,probabilities_by_category,prior_by_category):\\n ### TODO: Write your code here\\n spam_distribution = 0\\n ham_distribution = 0\\n word_frequency = util.get_word_freq([filename])\\n for w in word_frequency:\\n if w in probabilities_by_category[0]:\\n spam_distribution += word_frequency[w] * np.log(probabilities_by_category[0][w])\\n if w in probabilities_by_category[1]:\\n ham_distribution += word_frequency[w] * np.log(probabilities_by_category[1][w])\\n spam_distribution += np.log(prior_by_category[0])\\n ham_distribution += np.log(prior_by_category[1])\\n\\n predict = \\\"\\\"\\n if(spam_distribution > ham_distribution):\\n predict = \\\"spam\\\"\\n else:\\n predict = \\\"ham\\\"\\n\\n word_distribution = [spam_distribution, ham_distribution]\\n\\n classify_result = (predict, word_distribution)\\n\\n return classify_result\",\n \"def file_input_run(self, filename):\\r\\n file = open(filename)\\r\\n file_content = file.read()\\r\\n content_list = file_content.split(\\\"\\\\n\\\")\\r\\n for command in content_list:\\r\\n if command == \\\"exit\\\":\\r\\n break\\r\\n try:\\r\\n self.input_mang.process_input(command)\\r\\n except Exception as e:\\r\\n print(e)\",\n \"def main():\\n download_insert_title_basics()\\n download_insert_title_principals()\\n download_insert_name_basics()\\n download_insert_title_ratings()\\n scrap_keywords()\\n create_and_insert_soup()\\n return\",\n \"def predictFromFile(repoClassifier, strFileInput):\\n #Checks file exists and txt file\\n if os.path.exists(strFileInput) & string_operation.validate_txtfile(strFileInput):\\n file = open(strFileInput, 'r')\\n\\n strReadFileDirectory = os.path.dirname(strFileInput)\\n strReadFileName = os.path.basename(strFileInput)\\n\\n print(strReadFileName + 'was read successfully')\\n strFileClassified = \\\"classified_\\\" + strReadFileName\\n\\n writeClassifiedTxtFile(file, strReadFileDirectory, strFileClassified, repoClassifier)\\n else:\\n print(\\\"File could no be read. Make sure you have permission or entered correct File (txt)\\\")\",\n \"def probe(self):\\n\\n # make sure the filehandler is still valid\\n # (e.g. file stat hasnt changed, file exists etc.)\\n if not self.validate_file_handler():\\n return []\\n\\n messages = []\\n\\n # read any new lines and push them onto the stack\\n for line in self.fh.readlines(self.max_lines):\\n data = {\\\"path\\\":self.path}\\n msg = self.new_message()\\n\\n # process the line - this is where parsing happens\\n parsed = self.process_line(line, data)\\n if not parsed:\\n continue\\n data.update(parsed)\\n\\n # process the probe - this is where data assignment\\n # happens\\n data = self.process_probe(data)\\n msg[\\\"data\\\"] = [data]\\n messages.append(msg)\\n\\n\\n # process all new messages before returning them\\n # for emission\\n messages = self.process_messages(messages)\\n\\n return messages\",\n \"def _process(self, file: bytes) -> List[Tuple[str]]:\\n decoded_text = file.decode('utf-8')\\n # Replace end of line tokens\\n if self.eol is not None and not self.split_by_sentence:\\n decoded_text = decoded_text.replace('\\\\n', self.eol)\\n\\n # Split by sentence or unroll\\n if self.split_by_sentence:\\n nltk.download('punkt', quiet=True)\\n text = [(sent.strip(),) for sent in nltk.tokenize.sent_tokenize(decoded_text)]\\n else:\\n text = [(decoded_text,)]\\n\\n return text\",\n \"def process_file(filename):\\n print \\\"Reading and Parsing File: {}\\\".format(filename)\\n parsed_entries = file_parser(filename)\\n print \\\"Starting to Process Entries\\\"\\n chunked_entires = chunk_entries(parsed_entries)\\n return [process_entries(entry) for entry in chunked_entires]\",\n \"def main():\\n parse_file(sys.argv[1])\",\n \"def main():\\n # Load and prep training files\\n raw_speech_text = hg.load_training_file('trump_train.txt')\\n speech_text = hg.prep_training(raw_speech_text)\\n tweet_data = load_tweets('trump_tweets.json')\\n raw_tweets = \\\"\\\"\\n for dct in tweet_data:\\n raw_tweets += \\\"{} \\\".format(dct['text'])\\n tweets = hg.prep_training(raw_tweets)\\n corpus = speech_text + tweets\\n corpus = strip_punctuation(corpus)\\n dict_1 = hg.map_one_to_one(corpus)\\n dict_2 = hg.map_two_to_one(corpus)\\n text = []\\n \\n # Introduction\\n print(\\\"\\\\nTrump Speech Generator\\\\n\\\")\\n print(\\\"Select words to add to speech\\\")\\n print(\\\"\\\\'x\\\\' to exit\\\")\\n print(\\\"\\\\'p\\\\' to add punctuation\\\")\\n print(\\\"Select \\\\'p\\\\' before selecting the word you want to punctuate\\\")\\n\\n # Select first word\\n options = corpus\\n print ()\\n selection = select_word(corpus)\\n text.append(selection)\\n \\n # Select second word\\n last = text[0]\\n options = word_after_one(last, dict_1)\\n print_text(text)\\n selection = select_word(options)\\n text.append(selection)\\n \\n # Select subsequent word\\n while True:\\n last = \\\"{} {}\\\".format(text[-2].strip(punctuation),\\n text[-1].strip(punctuation))\\n options = word_after_two(last, dict_2)\\n if options == []:\\n last = last.split()[1]\\n options = word_after_one(last, dict_1)\\n while options == []:\\n last = random.choice(corpus)\\n options = word_after_one(last, dict_1)\\n print_text(text)\\n selection = select_word(options)\\n text.append(selection)\\n \\n print_text(text)\",\n \"def preprocess_main():\",\n \"def test_add_score():\\n board = Board(640, 640, 8)\\n board.add_score(\\\"test.txt\\\", \\\"User1\\\", 5)\\n board.add_score(\\\"test.txt\\\", \\\"User2\\\", 10)\\n board.add_score(\\\"test.txt\\\", \\\"User3\\\", 6)\\n board.add_score(\\\"test.txt\\\", \\\"User4\\\", 11)\\n open_file = open(\\\"test.txt\\\", \\\"r\\\")\\n file_lines = []\\n for line in open_file:\\n file_lines.append(line.strip())\\n assert file_lines[0] == \\\"User4 11\\\"\\n assert file_lines[1] == \\\"User2 10\\\"\\n assert file_lines[2] == \\\"User1 5\\\"\\n assert file_lines[3] == \\\"User3 6\\\"\",\n \"def train(self, data):\\r\\n pos_list = [\\r\\n \\\"adj\\\",\\r\\n \\\"adv\\\",\\r\\n \\\"adp\\\",\\r\\n \\\"conj\\\",\\r\\n \\\"det\\\",\\r\\n \\\"noun\\\",\\r\\n \\\"num\\\",\\r\\n \\\"pron\\\",\\r\\n \\\"prt\\\",\\r\\n \\\"verb\\\",\\r\\n \\\"x\\\",\\r\\n \\\".\\\",\\r\\n ]\\r\\n print(\\\"Train\\\")\\r\\n\\r\\n wordpos_list = [\\r\\n tuple([line[0][i], line[1][i]])\\r\\n for line in data\\r\\n for i in range(len(line[0]))\\r\\n ]\\r\\n\\r\\n pos_dict = {pos: {} for pos in pos_list}\\r\\n\\r\\n wordpos_count = Counter(wordpos_list)\\r\\n\\r\\n for w in wordpos_count:\\r\\n pos_dict[w[1]].update({w[0]: wordpos_count[w]})\\r\\n posterior_prob = {}\\r\\n emission_prob = {}\\r\\n for pos in pos_dict.keys():\\r\\n posterior_prob[pos] = float(sum(pos_dict[pos].values())) / len(wordpos_list)\\r\\n for pos in pos_dict.keys():\\r\\n emission_prob[pos] = {\\r\\n word: float(pos_dict[pos][word]) / sum(pos_dict[pos].values())\\r\\n for word in pos_dict[pos].keys()\\r\\n }\\r\\n\\r\\n trans_count = {}\\r\\n transition_prob = {}\\r\\n for pos in pos_list:\\r\\n trans_count[pos] = {}\\r\\n transition_prob[pos] = {}\\r\\n pair_list = [\\r\\n tuple([line[1][i], line[1][i + 1]])\\r\\n for line in data\\r\\n for i in range(len(line[1]) - 1)\\r\\n ]\\r\\n\\r\\n unique_list = list(set(pair_list))\\r\\n\\r\\n for element in unique_list:\\r\\n trans_count[element[0]].update({element[1]: pair_list.count(element)})\\r\\n\\r\\n for pos in pos_list:\\r\\n transition_prob[pos] = {pos: (1 / float(10 ** 8)) for pos in pos_list}\\r\\n for key, value in trans_count[pos].items():\\r\\n transition_prob[pos].update(\\r\\n {key: (value / float(sum(trans_count[pos].values())))}\\r\\n )\\r\\n initial_list = [line[1][0] for line in data]\\r\\n initial_count = Counter(initial_list)\\r\\n initial_prob = {\\r\\n pos: float(initial_count[pos]) / sum(initial_count.values())\\r\\n for pos in initial_count.keys()\\r\\n }\\r\\n self.position_list = pos_list\\r\\n self.emission_probability = emission_prob\\r\\n self.transition_probability = transition_prob\\r\\n self.initial_probability = initial_prob\\r\\n self.posterior_probability = posterior_prob\",\n \"def main(infilename):\\n graph = pydot.graph_from_dot_file(infilename)\\n nodes = get_nodes_info(graph)\\n load_links(graph, nodes)\\n propagate_lineage(nodes)\\n dump_status(nodes)\",\n \"def process_test_data_trigrams(file_path, label_matches, transition_probabilities):\\r\\n\\tlabel_index_dict = {}\\r\\n\\tstarting_index = 0\\r\\n\\tline_number = 0\\r\\n\\twith open(file_path) as f:\\r\\n\\t\\tfor line in f:\\r\\n\\t\\t\\tif line_number%3 == 0:\\r\\n\\t\\t\\t\\tline = line.strip().lower().split('\\\\t')\\r\\n\\t\\t\\t\\tlabel_index_dict = process_sentence_trigrams(line, starting_index, label_matches, label_index_dict, transition_probabilities)\\r\\n\\t\\t\\t\\tstarting_index += len(line)\\r\\n\\t\\t\\tline_number +=1\\r\\n\\treturn label_index_dict\",\n \"def process_raw_phrases(file_path):\",\n \"def analyse() -> 'html':\\n storeFileName = ''\\n if request.method == 'POST':\\n \\n if 'file' not in request.files:\\n return render_mainpageerror('No file selected')\\n \\n file = request.files['file']\\n if file.filename == '':\\n return render_mainpageerror('Empty file name Please select a File to upload')\\n \\n if file and not allowed_file(file.filename):\\n storeFileName = filename = secure_filename(file.filename)\\n file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))\\n return render_mainpageerror('Not allowed file format')\\n \\n if ' ' in file.filename:\\n return render_mainpageerror('Please remove withespace from file name before uploading')\\n \\n if file and allowed_file(file.filename):\\n originalFilename = file.filename\\n storeFileName = filename = secure_filename(file.filename)\\n file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))\\n \\n \\n if len(storeFileName) == 0:\\n return render_template('mainpage.html',\\n title='Word association')\\n else:\\n wordsfromfile = readFile.red_uploaded_file(storeFileName)\\n #print(wordsfromfile, 'The ans from pdf')\\n if wordsfromfile == 'STOP':\\n return render_mainpageerror('Cant find Encoding on PDF document')\\n size = get_store()\\n if not check_fileName(size):\\n \\\"\\\"\\\"Analyse first time building up JSON file\\\"\\\"\\\"\\n keyWords = readFile.read_JSON()\\n allJson = readFile.load_JSON()\\n data = Counter(wordsfromfile)\\n printResultsExluds = []\\n container = {}\\n container['size'] = size\\n container['file'] = storeFileName\\n toDB = []\\n for k, v in sorted(data.items()):\\n if k in keyWords:\\n string = allJson[k][:3]\\n toDB.append({k : v})\\n toDB.append(string)\\n else:\\n value = str(v)\\n keystr = k + '(' + value + ')'\\n printResultsExluds.append(keystr)\\n for w in printResultsExluds:\\n toDB.append({w:'was not found in the associations list'})\\n\\n container['files'] = toDB \\n js = json.dumps(container)\\n print(js)\\n c = get_client()\\n c.insert(json.loads(js))\\n print('insert')\\n \\\"\\\"\\\"If analysed first time\\\"\\\"\\\"\\n return pr(size, 'Analysed first time')\\n else:\\n \\\"\\\"\\\"If already Analysed\\\"\\\"\\\"\\n return pr(size,'Already analysed')\",\n \"def population_text_parser():\\n h = 480\\n w = 640\\n filenames = []\\n # get corrispondence ppoints for all faces\\n all_face_verticies = []\\n for i in range(1, 41):\\n if i == 2 or i == 3 or i == 4:\\n # not in data set\\n continue\\n # get file name\\n file_name = \\\"data/\\\"\\n if i < 10:\\n file_name += \\\"0\\\" + str(i)\\n else:\\n file_name += str(i)\\n if i == 8 or i == 22 or i == 30 or i == 35 or i == 12 or i ==14 or i == 15:\\n # female faces\\n file_name += \\\"-1f.asf\\\"\\n else:\\n file_name += \\\"-1m.asf\\\"\\n filenames.append(file_name[:-3] + \\\"bmp\\\")\\n # Parse corrispondence points\\n face_vertices = file_parser(file_name)\\n all_face_verticies.append(np.array(face_vertices))\\n\\n # adding my face to the set\\n # all_face_verticies.append(get_will_points())\\n mean_vertices = np.array(sum(all_face_verticies)) / len(all_face_verticies)\\n\\n # face = plt.imread(filenames[0])\\n # mean_vertices = ginput_to_array(appendCorners_other(face, mean_vertices))\\n # Morph each of the faces in the dataset into the average shape.\\n morphs = []\\n for i in range(len(all_face_verticies)):\\n # Read in src img\\n print(\\\"Morphing face \\\" + str(i) + \\\" into the average shape.\\\")\\n if i == len(all_face_verticies)-1:\\n face = plt.imread(\\\"will_population.jpeg\\\")/255\\n else:\\n face = plt.imread(filenames[i])/255\\n # print(face.shape)\\n # print(mean_vertices)\\n im_src_vertices = all_face_verticies[i]\\n\\n # Create Dalaunay triangulation for the ith morph set\\n print(\\\"Computing Delaunay triangulation.\\\")\\n # morph_verticies = morphPointSet(tri0_vertices, tri1_vertices, i/45)\\n t = Delaunay(mean_vertices)\\n trianguations = t.simplices\\n\\n # Compute Affine Transformation matrices for both transformations (src-->mid; dst-->mid)\\n print(\\\"Computing Affine Transformation.\\\")\\n affine_matrices_0 = computeAffines(trianguations, im_src_vertices, mean_vertices)\\n affine_matrices_inv_0 = [linalg.inv(A) for A in affine_matrices_0]\\n\\n morph = warp(h, w, t, affine_matrices_inv_0, face)\\n # if i == len(all_face_verticies) -1:\\n # plt.imsave(\\\"will_in_danish_pop.png\\\", morph)\\n morphs.append(morph)\\n\\n out = sum(morphs) * (1/len(morphs))\\n return out\",\n \"def insert_good_data():\\n get_file_reply(files[0][0], files[0][1])\\n get_file_reply(files[1][0], files[1][1])\",\n \"def main():\\n print \\\"Python has started\\\"\\n #os.system(\\\"xterm -e \\\\\\\"pyhton Listen_link.py\\\\\\\"\\\") \\n #print \\\"Started Listener\\\"\\n tutorial = MoveGroupPythonIntefaceTutorial()\\n model_info_prox = rospy.ServiceProxy('/gazebo/get_link_state', GetLinkState)\\n rospy.wait_for_service('/gazebo/get_link_state')\\n rospy.wait_for_service('/gazebo/get_model_state')\\n # writer below is to pass sings to out Link Listener and recording program\\n writer = rospy.Publisher('writer', String, queue_size=1)\\n filestring = rospy.Publisher('filestring', String, queue_size=1)\\n rospy.set_param('/move_group/trajectory_execution/allowed_start_tolerance',0)\\n hello_str = \\\"Test listener is working %s\\\" % rospy.get_time()\\n file_str = \\\"/NewFile\\\"\\n writer.publish(hello_str)\\n filestring.publish(file_str)\\n print \\\"Generating a population\\\"\\n #pop = Population(20,False,0) #should be an even number 10-20 \\n pop = Population(20,True,941) #should be an even number 10-20 \\n #\\n if pop.gencount == 0:\\n pop.gencount = pop.gencount + 1\\n grav = GravityControl()\\n velocity = VelocityControl()\\n grav.init_values()\\n grav.change_gravity(0.0,0.0,-9.8)\\n\\n generation = pop.gencount\\n if pop.res_sim == False:\\n pop.generate_inds(pop.numberinds,pop.numpoints,pop.xmin,pop.xmax,pop.ymin,pop.ymax,pop.zmin,pop.zmax,pop.vmin,pop.vmax,generation)\\n pop.gen_wp()\\n if pop.res_sim == True:\\n print \\\"We have had a restart, attempting to load individuals\\\"\\n pop.load_inds()\\n pop.gen_wp()\\n pop.gencount = 56\\n check_valid_waypoints(pop.current_ind_instances)\\n print \\\"Success adding table \\\"\\n time.sleep(1)\\n print \\\"============ Please ensure the Recorder is started and then Press `Enter` to execute joint state goal ...\\\"\\n raw_input()\\n tutorial.go_to_joint_state(0.0,-0.5,0.0,0.0,0.0,0.0) # note Rads each joint \\n # The main loop for the program is below\\n while (pop.gencount<100):\\n \\n grav.change_gravity(0.0,0.0,-9.8)\\n print \\\"Starting for population count number\\\", pop.gencount\\n run_simulation(tutorial,pop,pop.gencount,filestring,writer,velocity)\\n #make gravity Heavier to change simulation of 'real' slightly\\n grav.change_gravity(0.0,0.0,-10.8)\\n run_real(tutorial,pop,pop.gencount,filestring,writer,velocity)\\n # Evaluate, also calculates Euclidean based on collected data points between sim and real\\n evaluate_pop(pop) # This is a GA function call to evauate this population before the next generatio \\n \\n\\n print \\\"============ Exiting the Loop!\\\"\",\n \"def uni_pred(uni_pred_file):\\n print_section_title('Universal predict')\\n \\n # get all bins\\n allbins = []\\n fr = open(pre.bin_file, 'r')\\n for line in fr.readlines():\\n binname = line.split()[-1]\\n if binname not in allbins:\\n allbins.append(line.split()[-1])\\n fr.close()\\n allbins.sort()\\n \\n # start to predict\\n is_unix = 0\\n if is_win == 0:\\n is_unix = 1\\n print ' Get all candidate ORFs ...'\\n cmd = '%s -p -n %s -s %s -t %s -b %s -u' % \\\\\\n (pre.get_data, pre.project_name, pre.seqs_file, pre.tismodel, pre.bin_file)\\n if is_unix == 0:\\n cmd = '%s -p -n %s -s %s -t %s -b %s' % \\\\\\n (pre.get_data, pre.project_name, pre.seqs_file, pre.tismodel, pre.bin_file)\\n call(cmd, shell = True, stdout = PIPE)\\n\\n print ' Predict using universal model ...'\\n print ' SVM probability mode:', pre.prob_status\\n print ' SVM scroe cut-vaule:', pre.svm_cut_value\\n cds_model_path = pre.cdsmodel\\n name = pre.project_name\\n cut_value = pre.svm_cut_value\\n uni_w = open(uni_pred_file, 'w')\\n uni_w.close()\\n count = 1\\n types = ['00', '01', '10', '11']\\n for g in allbins:\\n print '\\\\t', g\\n for t in types:\\n fea_file = name + '.' + g + '.fea_' + t\\n orf_file = name + '.' + g + '.orf_' + t\\n if not os.path.exists(fea_file):\\n continue\\n model_file = cds_model_path + os.sep + g + '_' + t + '.model'\\n range_file = cds_model_path + os.sep + g + '_' + t + '.range'\\n cds_pred_file = fea_file + '.cds'\\n svm_predict(range_file, model_file, fea_file, orf_file, cut_value, pre.prob_status, cds_pred_file)\\n\\n cmd = '%s -a %s -b %s --a+b -o %s' % (pre.metalocs_operate, cds_pred_file, uni_pred_file, uni_pred_file)\\n call(cmd, shell = True, stdout = PIPE)\\n rm_files([fea_file, orf_file, cds_pred_file])\\n count = count + 1\\n return\",\n \"def doTheJob(input_file):\\n\\n Parse.parseFile(input_file)\\n Write.writeFile(input_file.replace(\\\".txt\\\", \\\".html\\\"))\",\n \"def preMain(dictADT):\\r\\n data_addr = \\\"..\\\\\\\\csv\\\\\\\\normal.csv\\\"\\r\\n\\r\\n userPref = dictADT\\r\\n mainPref(\\\"base.txt\\\", userPref)\\r\\n\\r\\n sample_path = \\\"base.txt\\\"\\r\\n webing(sample_path, data_addr)\\r\\n\\r\\n path_in = \\\"base.txt\\\"\\r\\n path_out = \\\"..\\\\\\\\resultHTML\\\\\\\\result.html\\\"\\r\\n mover(path_in, path_out)\\r\\n\\r\\n baseDel(\\\"base.txt\\\")\\r\\n # baseDel(\\\"resultHTML\\\\\\\\result.html\\\")\\r\\n baseDel(\\\"..\\\\\\\\csv\\\\\\\\normal.csv\\\")\\r\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5945443","0.5409753","0.5362085","0.5329677","0.52767473","0.5266814","0.5265608","0.52539533","0.5241925","0.5217411","0.5205404","0.51909417","0.5187099","0.51860255","0.5160676","0.5133867","0.5133248","0.51240563","0.5112366","0.51108074","0.5107463","0.51022255","0.5090593","0.5090475","0.5085295","0.5069151","0.50685585","0.5063926","0.50522864","0.5047008","0.50397027","0.5031417","0.5028308","0.5009689","0.50092715","0.4996679","0.49791372","0.49455157","0.49358913","0.4935796","0.49324757","0.49174768","0.4905932","0.49042374","0.4904045","0.49012673","0.49006915","0.4891786","0.48793137","0.48716986","0.48653197","0.4862535","0.48613343","0.48525","0.4850115","0.48484063","0.4846913","0.48456648","0.48428416","0.48408762","0.48376393","0.48344877","0.4814308","0.4811421","0.48056614","0.48039973","0.48035946","0.48016834","0.479441","0.47894242","0.4772488","0.4771832","0.47688007","0.47662064","0.47655752","0.4761671","0.4760276","0.47576028","0.4756679","0.47550085","0.47512528","0.47509044","0.47478157","0.47464257","0.47453567","0.47436956","0.4742678","0.47413218","0.47399086","0.47293666","0.47151247","0.47117335","0.47114864","0.47110203","0.47081268","0.47027183","0.47023362","0.47020674","0.46990472","0.46978056"],"string":"[\n \"0.5945443\",\n \"0.5409753\",\n \"0.5362085\",\n \"0.5329677\",\n \"0.52767473\",\n \"0.5266814\",\n \"0.5265608\",\n \"0.52539533\",\n \"0.5241925\",\n \"0.5217411\",\n \"0.5205404\",\n \"0.51909417\",\n \"0.5187099\",\n \"0.51860255\",\n \"0.5160676\",\n \"0.5133867\",\n \"0.5133248\",\n \"0.51240563\",\n \"0.5112366\",\n \"0.51108074\",\n \"0.5107463\",\n \"0.51022255\",\n \"0.5090593\",\n \"0.5090475\",\n \"0.5085295\",\n \"0.5069151\",\n \"0.50685585\",\n \"0.5063926\",\n \"0.50522864\",\n \"0.5047008\",\n \"0.50397027\",\n \"0.5031417\",\n \"0.5028308\",\n \"0.5009689\",\n \"0.50092715\",\n \"0.4996679\",\n \"0.49791372\",\n \"0.49455157\",\n \"0.49358913\",\n \"0.4935796\",\n \"0.49324757\",\n \"0.49174768\",\n \"0.4905932\",\n \"0.49042374\",\n \"0.4904045\",\n \"0.49012673\",\n \"0.49006915\",\n \"0.4891786\",\n \"0.48793137\",\n \"0.48716986\",\n \"0.48653197\",\n \"0.4862535\",\n \"0.48613343\",\n \"0.48525\",\n \"0.4850115\",\n \"0.48484063\",\n \"0.4846913\",\n \"0.48456648\",\n \"0.48428416\",\n \"0.48408762\",\n \"0.48376393\",\n \"0.48344877\",\n \"0.4814308\",\n \"0.4811421\",\n \"0.48056614\",\n \"0.48039973\",\n \"0.48035946\",\n \"0.48016834\",\n \"0.479441\",\n \"0.47894242\",\n \"0.4772488\",\n \"0.4771832\",\n \"0.47688007\",\n \"0.47662064\",\n \"0.47655752\",\n \"0.4761671\",\n \"0.4760276\",\n \"0.47576028\",\n \"0.4756679\",\n \"0.47550085\",\n \"0.47512528\",\n \"0.47509044\",\n \"0.47478157\",\n \"0.47464257\",\n \"0.47453567\",\n \"0.47436956\",\n \"0.4742678\",\n \"0.47413218\",\n \"0.47399086\",\n \"0.47293666\",\n \"0.47151247\",\n \"0.47117335\",\n \"0.47114864\",\n \"0.47110203\",\n \"0.47081268\",\n \"0.47027183\",\n \"0.47023362\",\n \"0.47020674\",\n \"0.46990472\",\n \"0.46978056\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6416924"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23395,"cells":{"query":{"kind":"string","value":"This function parses the predictions in one individual message. If the message contains predictions, they will be inserted into the oracle database."},"document":{"kind":"string","value":"def ParsePredictions(odb, message, contest, round_nums):\n\n duel = 0\n if contest['CompetitorsPerMatch'] == 2:\n duel = 1\n\n user_id = odb.GetUserId(message['User'])\n if user_id is None:\n user_id = GetUserId(odb, message['User'], add_alt=1)\n # This enables admins to enter predictions for other users.\n # TODO: Make this a flag or something\n# if user_id in (1,2):\n# user_id = PromptForId(odb, message, user_id)\n\n # Split the message into lines so we can examine each for predictions.\n\n pattern = ('^\\s*(.*?)\\s*'\n '(?:over .*?)?'\n '(?:with\\s*)?'\n '(?:w/\\s*)?'\n '(?:\\W+\\s*)?'\n '(\\d{1,3}[,\\.]?\\d*)\\s*%')\n prediction_re = re.compile(pattern)\n lines = re.split('(?:<br />)+', message['Text'])\n for line in lines:\n match = prediction_re.search(line)\n\n if match is not None:\n winner_name = match.group(1)\n\n # Eliminate double quotes because they will cause problems with MySQL.\n winner_name = winner_name.replace('\"', '')\n \n percent = match.group(2)\n percent = percent.replace(',', '.')\n percent = float(percent)\n if percent > 100:\n percent = 100.0\n if duel and (float(percent) < 50):\n # This is an invalid prediction\n print 'Invalid prediction from %s: %s with %s' % (message['User'],\n winner_name, percent)\n continue\n \n winner_id = DecipherName(odb, winner_name, line, contest['Type'],\n contest['ContestId'], round_nums)\n if winner_id is None:\n continue\n\n match_id = odb.LookupMatchId(winner_id, round_nums, contest['ContestId'],\n message['Timestamp'])\n\n if match_id is None:\n print '\\n%s predicted a competitors who isn\\'t in this round:\\n%s\\n' \\\n % (message['User'], line)\n continue\n\n if duel:\n old_prediction = odb.GetPredictions(user_id=user_id, match_id=match_id)\n else:\n old_prediction = odb.GetPredictions(user_id=user_id, match_id=match_id,\n character_id=winner_id)\n if not old_prediction or \\\n old_prediction[0]['LastUpdated'] <= message['Timestamp']:\n # Check if the prediction is late.\n\n match_info = odb.GetMatches(match_id=match_id)\n time_margin = datetime.timedelta(minutes=0)\n if message['Timestamp'] + time_margin >= match_info[0]['MatchDate']:\n print '\\nAccept late prediction from %s posted at %s?' \\\n % (message['User'], message['Timestamp'])\n print '%s with %s' % (winner_name, percent)\n accept_late = raw_input('(y/n): ')\n if accept_late != 'y':\n continue\n\n odb.SetPrediction(user_id, match_id, winner_id, percent,\n message['Timestamp'], duel=duel)\n print '%s predicts match %s: %s with %s' % (message['User'], match_id,\n winner_name, percent)\n else:\n # We already have a newer prediction.\n print \"Ignoring old prediction from %s at %s\" % (message['User'],\n message['Timestamp'])\n\n # TODO(dscotton): Check if the prediction is being submitted too late."},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _parse_raw_predictions(self, raw_predictions):\n result = []\n for line in raw_predictions.split(\"\\n\"):\n line_parts = line.split(\"|\")\n type = line_parts[0]\n assert type.lstrip(\"*\") in (\n \"FP\", \"TP\", \"TN\", \"FN\"), 'Expected {} to be in (FP, TP, TN, FN), {}'.format(line[0], line)\n\n docid = line_parts[1]\n start_end = line_parts[2]\n entity_name = line_parts[3]\n alt_gene = None\n alt_gene_start_end = None\n\n if type.lstrip(\"*\") == \"TP\":\n start_end = line_parts[3]\n entity_name = line_parts[2]\n alt_gene = line_parts[4]\n alt_gene_start_end = line_parts[5]\n\n result.append({\n \"type\": type,\n \"docid\": docid,\n \"start_end\": start_end,\n \"entity_name\": entity_name,\n \"alt_gene\": alt_gene,\n \"alt_gene_start_end\": alt_gene_start_end,\n })\n return result","def process(self, message, **kwargs):\r\n # type: (Message, **Any) -> None\r\n\r\n start = time.time()\r\n intent = {\"name\": None, \"confidence\": 0.0}\r\n intent_ranking = []\r\n\r\n if self.predictor is None:\r\n logger.error(\"There is no trained tf.session: \"\r\n \"component is either not trained or \"\r\n \"didn't receive enough training data\")\r\n\r\n else:\r\n\r\n X = message.get(\"text_features\").tolist()\r\n examples = []\r\n feature = {}\r\n # convert input x to tf.feature with float feature spec\r\n feature['a_in'] = tf.train.Feature(float_list=tf.train.FloatList(value=X))\r\n # build tf.example for prediction\r\n example = tf.train.Example(\r\n features=tf.train.Features(\r\n feature=feature\r\n )\r\n )\r\n examples.append(example.SerializeToString())\r\n\r\n # Make predictions.\r\n logger.info(\"estimator prediction finished\")\r\n result_dict = self.predictor({'inputs': examples})\r\n result_score_list = result_dict['scores'][0]\r\n max_score = np.max(result_dict['scores'][0])\r\n max_index = np.argmax(result_dict['scores'][0])\r\n\r\n\r\n # if X contains all zeros do not predict some label\r\n\r\n\r\n\r\n if len(X)>0:\r\n intent = {\r\n \"name\": self.inv_intent_dict[max_index], \"confidence\": float(max_score)\r\n }\r\n ranking = result_score_list[:len(result_score_list)]\r\n intent_ranking = [{\"name\": self.inv_intent_dict[intent_idx],\r\n \"confidence\": float(score)}\r\n for intent_idx, score in enumerate(ranking)]\r\n\r\n\r\n intent_ranking = sorted(intent_ranking, key=lambda s: s['confidence'], reverse=True)\r\n\r\n message.set(\"intent\", intent, add_to_output=True)\r\n message.set(\"intent_ranking\", intent_ranking, add_to_output=True)\r\n end = time.time()\r\n logger.info(\"bert intent classifier time cost %.3f s\" % (end - start))","def parse_prediction(self, predictions):\n\t\tusers = list()\n\t\tprint(predictions)\n\t\tfor prediction in predictions:\n\t\t\tfor email in prediction:\n\t\t\t\tusers.append(email)\n\t\t\t\t\n\t\treturn users","def prediction(name=None, message=''):","def process(self, message, **kwargs):\n if self.classifier is None:\n self.train()\n\n if message.get(\"text\") is not None:\n sid = SentimentIntensityAnalyzer()\n res = sid.polarity_scores(message.get(\"text\"))\n key, value = max(res.items(), key=lambda x: x[1])\n\n if key == \"pos\":\n key = \"Positive\"\n elif key == \"neg\":\n key = \"Negative\"\n else:\n key = \"Neutral\"\n\n custom_tokens = self.remove_noise(word_tokenize(message.get(\"text\")))\n t = self.classifier.prob_classify(dict([token, True] for token in custom_tokens))\n\n sentiment = 'Positive' if t.prob('Positive') > t.prob('Negative') else 'Negative'\n confidence = max(t.prob('Positive'), t.prob('Negative'))\n\n found, entry = self.manager.getMovieName(message.get(\"text\"))\n movie = str(entry['original_title'].item())\n \n genre_entry, aux_found_genre = self.manager.fuzzy_find_genre(message.get(\"text\"), with_ratio=True)[0]\n genre = genre_entry\n \n\n if len(message.get(\"text\")) > 20:\n entity = self.convert_to_rasa(sentiment, confidence, name=\"our_sentiment_extractor\")\n else:\n entity = self.convert_to_rasa(key, value, name=\"builtin_sentiment_extractor\")\n\n message.set(\"sentiment\", [entity], add_to_output=True)\n\n entity = self.convert_movie_to_rasa(movie, found)\n message.set(\"movies\", [entity], add_to_output=True)\n\n if message.get(\"text\").strip() == \"no\":\n found_genre = False\n else:\n found_genre = True if aux_found_genre > 80 else False\n\n entity = self.convert_movie_to_rasa(genre, found_genre, entity=\"genres_detected\")\n print(entity)\n message.set(\"genres\", [entity], add_to_output=True)","def _postprocess(self, preds):\n ntok = preds.pop(\"ntok\")\n ids = preds.pop(\"input_ids\")[:ntok]\n preds[\"tokens\"] = self._detokenize(ids)\n\n # Decode predicted top-k tokens.\n # token_topk_preds will be a List[List[(word, prob)]]\n # Initialize prediction for 0th token as N/A.\n token_topk_preds = [[(\"N/A\", 1.)]]\n pred_ids = preds.pop(\"top_k_indices\")[:ntok] # <int>[num_tokens, k]\n pred_probs = preds.pop(\"top_k_probs\")[:ntok] # <float32>[num_tokens, k]\n for token_pred_ids, token_pred_probs in zip(pred_ids, pred_probs):\n token_pred_words = self._detokenize(token_pred_ids)\n token_topk_preds.append(list(zip(token_pred_words, token_pred_probs)))\n preds[\"pred_tokens\"] = token_topk_preds\n\n # Process attention.\n for key in preds:\n if not re.match(r\"layer_(\\d+)/attention\", key):\n continue\n # Select only real tokens, since most of this matrix is padding.\n # <float32>[num_heads, max_seq_length, max_seq_length]\n # -> <float32>[num_heads, num_tokens, num_tokens]\n preds[key] = preds[key][:, :ntok, :ntok].transpose((0, 2, 1))\n # Make a copy of this array to avoid memory leaks, since NumPy otherwise\n # keeps a pointer around that prevents the source array from being GCed.\n preds[key] = preds[key].copy()\n\n return preds","def process(self, message: \"Message\", **kwargs: Any) -> None:\n\n label, label_ranking = self.predict_label(message)\n\n message.set(\"intent\", label, add_to_output=True)\n message.set(\"intent_ranking\", label_ranking, add_to_output=True)","def test_service_api_predict_multiple_raw_classified(service_app):\n response = service_app.post('/predict',\n data=json.dumps(data),\n content_type='application/json')\n response_data = json.loads(response.data)\n assert response.headers['Content-Type'] == 'application/json'\n assert response.status_code == 200\n assert response_data['message'] == 'Records successfully classified'\n assert len(response_data['prediction'].keys()) == 102\n assert response_data['prediction']['business_outcome'] == [4, 5]\n assert response_data['prediction']['phat'] == [0.8228085289874678, 0.753958838418463]\n assert all(len(value) == 2 for value in response_data['prediction'].values())","def postprocess_relation_predictions(predictions):\n \n output = {}\n word_pairs = [wp.split(\" -> \") for wp in predictions.keys()]\n for wp in word_pairs:\n fp = \" -> \".join([wp[0], wp[1]])\n bp = \" -> \".join([wp[1], wp[0]])\n \n if predictions[fp][\"relations\"][0] == predictions[bp][\"relations\"][0]:\n if predictions[fp][\"confidence\"][0] > predictions[bp][\"confidence\"][0]:\n output[fp] = predictions[fp]\n else:\n output[bp] = predictions[bp]\n else:\n output[fp] = predictions[fp]\n output[bp] = predictions[bp]\n return output","def test_service_api_predict_single_raw_classified(service_app):\n response = service_app.post('/predict',\n data=json.dumps(data[1:2]),\n content_type='application/json')\n\n response_data = json.loads(response.data)\n assert response.headers['Content-Type'] == 'application/json'\n assert response.status_code == 200\n assert response_data['message'] == 'Records successfully classified'\n assert len(response_data['prediction'].keys()) == 102\n assert response_data['prediction']['business_outcome'] == [4]\n assert response_data['prediction']['phat'] == [0.8228085289874678]\n assert all(len(value) == 1 for value in response_data['prediction'].values())","def process_classified_message(self, message, classification): \n pass","def predict(request):\n request_json = request.get_json()\n if request_json and 'review_body' in request_json:\n content = request_json['review_body'] # TODO add review_summary\n prediction = get_prediction(\n content, 'projects/207895552307/locations/us-central1/models/TCN5004391989450375168')\n classifications = []\n return MessageToJson(prediction)\n else:\n return f'ERROR: Missing review_body!'","def postprocess(self, data):\n all_predictions, all_nbest_json, scores_diff_json = predictions(self._dev_dataset,\n data,\n self._tokenizer)\n\n if len(all_nbest_json) == 0 or len(all_nbest_json[0]) == 0:\n return [{'predicted': '',\n 'confidence': 0}]\n\n return [{'predicted': all_nbest_json[0][0]['text'],\n 'confidence': all_nbest_json[0][0]['probability']}]","def validate(self, validate_data):\n with open(validate_data, 'r') as validate_data:\n true_positive = 0\n true_negative = 0\n false_positive = 0\n false_negative = 0\n result = {}\n for type in self.label_type_map:\n result[type] = []\n while True:\n tokens = validate_data.readline().split()\n pos = validate_data.readline().split()\n labels = validate_data.readline().split()\n if not tokens or not pos or not labels:\n break\n # Classify all named entities in a sentence 85\n curr_results = self.viterbi(tokens)\n for i in range(0, len(labels)):\n if curr_results[i] != 'O':\n if labels[i] == 'O':\n false_positive += 1 # Not 'O', but should be 'O'\n else:\n if self.label_type_map[labels[i]] == self.label_type_map[curr_results[i]]:\n true_positive += 1 # Correct prediction\n else:\n if labels[i] == 'O':\n true_negative += 1 # Correct prediction of 'O'\n else:\n false_negative += 1 # Predicted 'O', not 'O'\n # Calculate precision - TP / (TP + FP)\n precision = float(true_positive) / float(true_positive + false_positive)\n # Calculate recall - TP / (TP + FN)\n recall = float(true_positive) / float(true_positive + false_negative)\n # Calculate F-Score - 2 * P * R / (P + R)\n f_score = float(2*precision * recall) / float(precision + recall)\n print \"Precision: \" + str(precision)\n print \"Recall: \" + str(recall)\n print \"F-score: \" + str(f_score)","def rank_pre_extract(self, mention_data, predictions):\n mdata = pd.DataFrame(mention_data)\n\n\n\n\n pass","def model_evaluate(query):\n engine = create_engine('sqlite:///data/DisasterResponse.db')\n df = pd.read_sql_table('Messages', engine)\n\n model = joblib.load(\"models/model.pkl\")\n \n classification_labels = model.predict([query])[0]\n classification_results = dict(zip(df.columns[4:], classification_labels))\n\n return classification_labels, classification_results","def _process_prediction(\n prediction: Mapping[Text, np.ndarray],\n text_examples: Mapping[Text, eval_utils.OpenKpTextExample],\n writer_tfrecord,\n writer_jsonl,\n metrics: Optional[Mapping[int, _MetricAverager]] = None) -> None:\n # [kp_max_length, long_max_length] shape.\n ngram_logits = prediction['ngram_logits']\n\n features = collections.OrderedDict()\n features['ngram_logits'] = input_utils.create_float_feature(\n ngram_logits.flatten())\n\n position_predictions = eval_utils.logits_to_predictions(\n ngram_logits, max_predictions=FLAGS.max_position_predictions)\n # Sort predictions for convenience.\n position_predictions.sort(key=lambda x: x.logit, reverse=True)\n features['top_pos_logit'] = input_utils.create_float_feature(\n x.logit for x in position_predictions)\n features['top_pos_start_idx'] = input_utils.create_int_feature(\n x.start_idx for x in position_predictions)\n features['top_pos_phrase_len'] = input_utils.create_int_feature(\n x.phrase_len for x in position_predictions)\n\n url = ''.join(chr(x) for x in prediction['url_code_points'] if x != -1)\n features['url'] = input_utils.create_bytes_feature([url])\n\n if url in text_examples:\n text_example = text_examples[url]\n kp_predictions = text_example.get_key_phrase_predictions(\n position_predictions, max_predictions=FLAGS.max_kp_predictions)\n if len(kp_predictions) < FLAGS.max_kp_predictions:\n tf.logging.warn(f'Made fewer than `max_kp_predictions` for URL: {url}')\n writer_jsonl.write(\n json.dumps({\n 'url': url,\n 'KeyPhrases': [[kp] for kp in kp_predictions]\n }) + '\\n')\n\n features['kp_predictions'] = input_utils.create_bytes_feature(\n kp_predictions)\n\n if metrics is not None:\n precision, recall, f1 = text_example.get_score_full(kp_predictions)\n for i in (1, 3, 5):\n p = precision[i - 1]\n r = recall[i - 1]\n f = f1[i - 1]\n features[f'p_at_{i}'] = input_utils.create_float_feature([p])\n features[f'r_at_{i}'] = input_utils.create_float_feature([r])\n features[f'f1_at_{i}'] = input_utils.create_float_feature([f])\n metrics[i].add_example(precision=p, recall=r, f1=f)\n else:\n tf.logging.error(f'No text example found for URL: {url}')\n\n writer_tfrecord.write(\n tf.train.Example(features=tf.train.Features(\n feature=features)).SerializeToString())","def tag2predictions(ote_tag_sequence, ts_tag_sequence):\n n_tag = len(ote_tag_sequence)\n # opinion target sequence and targeted sentiment sequence\n ot_sequence, ts_sequence = [], []\n beg, end = -1, -1\n for i in range(n_tag):\n tag = ote_tag_sequence[i]\n if tag == 'S':\n ot_sequence.append((i, i))\n elif tag == 'B':\n beg = i\n elif tag == 'E':\n end = i\n if end > beg and beg != -1:\n ot_sequence.append((beg, end))\n beg, end = -1, -1\n sentiments = []\n beg, end = -1, -1\n for i in range(n_tag):\n ts_tag = ts_tag_sequence[i]\n # current position and sentiment\n eles = ts_tag.split('-')\n if len(eles) == 2:\n pos, sentiment = eles\n else:\n pos, sentiment = 'O', 'O'\n if sentiment != 'O':\n # current word is a subjective word\n sentiments.append(sentiment)\n if pos == 'S':\n # singleton\n ts_sequence.append((i, i, sentiments[0]))\n sentiments = []\n elif pos == 'B':\n beg = i\n elif pos == 'E':\n end = i\n # schema1: only the consistent sentiment tags are accepted\n # that is, all of the sentiment tags are the same\n if end > beg > -1 and len(set(sentiments)) == 1:\n ts_sequence.append((beg, end, sentiment))\n sentiments = []\n beg, end = -1, -1\n\n # schema2: only consider the sentiment at the beginning of the aspect span\n # if end > beg > -1:\n # ts_sequence.append((beg, end, sentiments[0]))\n # sentiments = []\n # beg, end = -1, -1\n return ot_sequence, ts_sequence","def parse(self, message):\n resp = json.loads((self.send_api_request(message)).decode('utf-8'))\n\n nlu_response = NLUResponse()\n nlu_response.text = message\n intent_schema = IntentSchema()\n if resp[\"result\"][\"metadata\"]:\n intent_schema.name = resp[\"result\"][\"metadata\"][\"intentName\"]\n intent_schema.confidence = resp[\"result\"][\"score\"]\n else: # fallback if no intent is given by the nlu\n intent_schema.name = \"greet\"\n intent_schema.confidence = 0.0\n nlu_response.intent = intent_schema\n print(\"Recognized Intent by Dialogflow {}\".format(intent_schema.name ))\n\n pp = pprint.PrettyPrinter(indent=4)\n #pp.pprint(resp)\n\n try:\n nlu_response.entities = []\n entities = resp[\"result\"][\"parameters\"]\n resolved_query = resp[\"result\"][\"resolvedQuery\"]\n\n for key, value in entities.items():\n if value:\n entity_schema = EntitiesSchema()\n entity_schema.start = resolved_query.find(value)\n entity_schema.end = resolved_query.find(value) + len(value)\n entity_schema.entity = key\n entity_schema.value = value\n nlu_response.entities.append(entity_schema)\n #print(\"Key: {}, Value: {}\".format(key, value))\n except Exception as err:\n logging.warning('No Entites extracted {}'.format(err))\n\n schema = RasaNLUSchema()\n data, error = schema.dump(nlu_response)\n\n return data","def insult_me(\n message : str \n ):\n \n #load model\n model = Detoxify('original')\n \n #predict toxicity\n results = model.predict(message)\n \n #echo results\n click.echo(pd.Series(results))","def post(self):\n result = {'status': 'error'}\n\n args = input_parser.parse_args()\n input_data = args['image'].read()\n image = self.model_wrapper._read_image(input_data)\n preds = self.model_wrapper._predict(image)\n\n # Modify this code if the schema is changed\n label_preds = [{'label_id': p[0], 'label': p[1], 'probability': p[2]} for p in [x for x in preds]]\n result['predictions'] = label_preds\n result['status'] = 'ok'\n\n return result","def predict(self, sentences: List[str]) -> List[Dict[str, Any]]:\n inputs, offset_mapping = self.tokenize(sentences=sentences)\n outputs = self.model(**inputs)\n logits = outputs[\"logits\"]\n predicted_intents = self.convert_intent_logits(intent_logits=logits[1])\n predicted_entities = self.convert_entities_logits(entities_logits=logits[0], offset_mapping=offset_mapping)\n predicted_outputs = []\n for sentence, intent_sentence, entities_sentence in zip(sentences, predicted_intents, predicted_entities):\n predicted_outputs.append({})\n predicted_outputs[-1].update(intent_sentence)\n predicted_outputs[-1].update({\"entities\": entities_sentence})\n for entity in predicted_outputs[-1][\"entities\"]:\n entity[\"text\"] = sentence[entity[\"start\"]: entity[\"end\"]]\n\n if self.synonym_dict.get(entity[\"text\"], None):\n entity[\"original_text\"] = entity[\"text\"]\n entity[\"text\"] = self.synonym_dict[entity[\"text\"]]\n\n predicted_outputs[-1][\"text\"] = sentence\n\n return predicted_outputs","def make_text_predictions(self, text, preprocessor):\n text = preprocessor.preprocess(text)\n y_pred = self.sgd_pipeline.predict_proba([text])\n return y_pred","def update_predictions(data):\n # TODO: Priority 1 - update predictions with inference results\n # TODO: Understand from a research team exactly what the data is going to look like\n trackID = data[0]\n prediction = data[1]\n confidence = data[2]\n to_Insert_Array = [trackID, prediction, confidence]\n OutPut_Data[trackID] = to_Insert_Array","def make_predictions(model, tokenizer, paragraphs):\n \n prediction_dataloader = bert_preprocess(paragraphs, tokenizer) \n predictions = eval_cpu(prediction_dataloader, model) \n malware_ids = get_pred_ids(predictions) \n return malware_ids","def _parse_fit_and_predict_result(result):\n if len(result) > 1 and result[1] and not isinstance(result[1], str):\n # Scores object does not resemble a label prediction (always string)\n y = result[0]\n scores = result[1]\n else:\n y = result\n scores = None\n return y, scores","def post(self):\n # use parser and find the user's query\n args = parser.parse_args()\n title = args['title']\n author = model.encode_author(args['author'])\n text = args['text']\n\n X = model.vector_and_stack(title=title, text=text, author=author)\n\n prediction = model.predict(X)\n\n # Output either 'Negative' or 'Positive' along with the score\n if round(prediction[0]) == 0:\n pred_text = 'Reliable News'\n else:\n pred_text = 'Unreliable News'\n\n # round the predict proba value and set to new variable\n confidence = round(prediction[0], 3)\n\n # create JSON object\n output = {'prediction': pred_text, 'fake_rate': confidence}\n\n return output, 200","def predict(self):\n\n global pos\n pos = (pos + 1) % len(ue_data) # iterate through entire list one by one in cycle manner and will be updated when live feed will be coming through KPIMON to influxDB\n sample = ue_data[pos]\n ue_df = pd.DataFrame([sample], columns=db.data.columns)\n val = predict_anomaly(self, ue_df)\n if (val is not None) and (len(val) > 2):\n msg_to_ts(self, val)","def postprocess(self, prediction_dict, **params):\r\n pass","def _preprocess(self):\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\n # self._get_frequent_features()\n # self._compactness_pruning()\n # self._redundancy_pruning()\n # self._get_features()\n self._extract_opinions()","async def predict(params: predict_text):\n tweet = params.text\n prediction = tf_model.predict(tweet)\n prediction_db = PredictionModel(\n text=tweet,\n label=prediction[\"label\"],\n score=prediction[\"score\"],\n time=prediction[\"elapsed_time\"],\n )\n db.session.add(prediction_db)\n db.session.commit()\n return prediction","def test_service_api_predict_single_raw_no_classification(service_app):\n response = service_app.post('/predict',\n data=json.dumps(data[:1]),\n content_type='application/json')\n assert response.headers['Content-Type'] == 'application/json'\n assert response.status_code == 200\n assert json.loads(response.data) == {'message': 'Records does not meet classification requirements'}","def label_7m(predictor, zhibo7m):\n for item_ in zhibo7m.find():\n try:\n live_texts_ = item_[\"content\"][\"textFeed\"]\n except Exception as e:\n zhibo7m.delete_one({\"_id\": item_['_id']})\n print(\"delete error id: {}\".format(item_[\"_id\"]))\n print(e)\n for l_index_, l_item_ in enumerate(live_texts_):\n l_item_[\"p_label\"] = predictor.predict(l_item_[\"msg\"])[0]\n live_texts_[l_index_] = l_item_\n # print(l_item_)\n zhibo7m.update_one({\"_id\": item_['_id']}, {\"$set\": {\"textFeed\": live_texts_}})","def predictFailures (self) :\n \n while self.traceData :\n\n if self.traceData [0] == self.traceType :\n\n self.totalEvents += 1\n\n if random.random () < self.recall :\n\n self.predictedEvents += 1\n self.pTraceHandle.write (\"%d\\t%d\\t%d\\n\" % (self.traceData [0], self.traceData [1], self.traceData [2]))\n self.correctPredictions += 1\n self.totalPredictions += 1\n\n self.readNextTraceLine (self.fTraceHandle)\n\n if self.precision < 1 :\n\n wrongPredictions = int ((float (self.correctPredictions * (1 - self.precision)) / self.precision) + 0.5)\n \n interval = int ((self.endTime - self.startTime) / wrongPredictions)\n start = self.startTime\n end = start + interval\n\n for i in range (wrongPredictions) :\n \n self.pTraceHandle.write (\"%d\\t%d\\t%d\\n\" % (0, random.randint (0, self.totalNodes - 1), \\\n random.randint (start, end - 1)))\n self.totalPredictions += 1\n start = end\n end = start + interval","def validate_and_insert_data(self):\r\n try:\r\n self.logger.log(self.log_file, 'Validating the prediction data!')\r\n # Delete good and bad data folders in case last run was\r\n # unsuccessful and the folders were not deleted\r\n self.data_validation.delete_existing_good_data_folder()\r\n self.data_validation.delete_existing_bad_data_folder()\r\n # Extract values from the prediction schema\r\n length_of_date_stamp_in_file, length_of_time_stamp_in_file, number_of_columns = \\\r\n self.data_validation.values_from_schema()\r\n # Generate a regex pattern to validate the file names\r\n regex = self.data_validation.generate_file_name_regex(length_of_date_stamp_in_file,\r\n length_of_time_stamp_in_file)\r\n # Validate file names of the prediction data\r\n self.data_validation.validate_file_names(regex)\r\n # Validate number of columns in the prediction data\r\n self.data_validation.validate_number_of_columns(number_of_columns)\r\n # Validate if any column has all of its values missing\r\n self.data_validation.validate_missing_values_in_columns()\r\n self.logger.log(self.log_file, 'Prediction data validated successfully!')\r\n\r\n self.logger.log(self.log_file, 'Transforming the prediction data!')\r\n # Replace missing values with 'NULL'\r\n self.data_transformation.replace_missing_values_with_null()\r\n # Format the 'Wafer' column\r\n self.data_transformation.format_wafer_column()\r\n self.logger.log(self.log_file, 'Prediction data transformed successfully!')\r\n\r\n self.logger.log(self.log_file, 'Inserting the prediction data!')\r\n # Insert the good prediction data into a MongoDB Atlas database\r\n self.data_insertion.insert_good_data_into_collection(self.collection_name, 'Wafer')\r\n # Delete the good data folder after loading its data into the database\r\n self.data_validation.delete_existing_good_data_folder()\r\n # Export the data from the database to a .CSV file\r\n self.data_insertion.copy_data_from_collection_to_csv_file(self.collection_name)\r\n # Move the remaining bad prediction data to an archive\r\n self.data_validation.archive_bad_prediction_data()\r\n self.logger.log(self.log_file, 'Prediction data inserted successfully!')\r\n return None\r\n except Exception as e:\r\n self.logger.log(self.log_file, 'Unexpected Error: %s' % e)\r\n raise e","def predict(prediction_request):\n\n feature_type = prediction_request['feature_type']\n\n if feature_type not in [MFCC, C_CENS, C_CQT, C_STFT, MEL]:\n raise Exception('Invalid Feature type for prediction: {}'.format(feature_type))\n\n model = model_from_feature[feature_type]\n\n prediction = np.argmax(model.predict([np.reshape(prediction_request['content'], (1, *prediction_request['content'].shape, 1))]), axis=1)[0]\n\n predicted_class = \"COPD\" if prediction == 0 else \"non-COPD\"\n\n print(\"Prediction for type {} = {}\".format(feature_type, predicted_class))\n\n socket.send_pyobj({\n 'model': feature_type,\n 'class': predicted_class\n })","def classify(self, documents):\n predictions = []\n for doc in documents:\n\n score_sod = math.log(self.priorSOD)\n score_pop = math.log(self.priorPOP)\n for term in doc.tokens:\n if term in self.cond_prob_sod.keys():\n score_sod += math.log(self.cond_prob_sod[term])\n if term in self.cond_prob_pop.keys():\n score_pop += math.log(self.cond_prob_pop[term])\n if(score_pop >= score_sod): #defaults to ham if score = even \n predictions.append('pop')\n else:\n predictions.append('sod')\n \n return predictions \n pass","def evaluate(parameters, f_eval, raw_sentences, parsed_sentences,\n id_to_tag, input_file_path):\n predictions = []\n for raw_sentence, data in zip(raw_sentences, parsed_sentences):\n input = create_input(data, parameters, False)\n if parameters['crf']:\n y_preds = np.array(f_eval(*input))[1:-1]\n else:\n y_preds = f_eval(*input).argmax(axis=1)\n p_tags = [id_to_tag[y_pred] for y_pred in y_preds]\n\n if parameters['tag_scheme'] == 'iobes':\n p_tags = iobes_iob(p_tags)\n\n for i, y_pred in enumerate(y_preds):\n new_line = \"%s %s\" % (raw_sentence[i][0], p_tags[i])\n predictions.append(new_line)\n predictions.append(\"\")\n output_path = os.path.join(opts.output, os.path.basename(input_file_path[:-4] + \"_Tagged.txt\"))\n with codecs.open(output_path, 'w', 'utf8') as f:\n f.write(\"\\n\".join(predictions))","def show_predictions(db_filename, predictions):\n\n db = FeverDocDB(db_filename)\n\n for line in predictions:\n\n if line['label'].upper() != \"NOT ENOUGH INFO\":\n macro_rec = evidence_macro_recall(line)\n if macro_rec[0] == 1.0:\n continue\n pages = set([page for page, _ in line['predicted_evidence']])\n evidence_set = set([(page, line_num) for page, line_num in line['predicted_evidence']])\n p_lines = []\n for page in pages:\n doc_lines = db.get_doc_lines(page)\n if not doc_lines:\n # print(page)\n continue\n doc_lines = [doc_line.split(\"\\t\")[1] if len(doc_line.split(\"\\t\")[1]) > 1 else \"\" for doc_line in\n doc_lines.split(\"\\n\")]\n p_lines.extend(zip(doc_lines, [page] * len(doc_lines), range(len(doc_lines))))\n\n print(\"claim: {}\".format(line['claim']))\n print(evidence_set)\n count = 0\n for doc_line in p_lines:\n if (doc_line[1], doc_line[2]) in evidence_set:\n print(\"the {}st evidence: {}\".format(count, doc_line[0]))\n count += 1","def _parse_predict_data(self, data):\n image, labels = self._parse_eval_data(data)\n return {\n 'images': image,\n 'labels': labels\n }","def model(msg):\n url = 'https://southcentralus.api.cognitive.microsoft.com/customvision/v3.0/Prediction/\\\n eff56ac8-0f36-41d9-93a9-da19396b0f30/detect/iterations/Iteration2_ppl_focus/image'\n headers = {\n 'Prediction-Key': os.getenv('AZURE_VIS_KEY'),\n 'Content-Type': 'application/octet-stream'\n }\n r = requests.post(url=url, headers=headers, data=msg['img'])\n predictions = r.json()\n print('Number of object predictions: {}'.format(\n len(predictions['predictions'])))\n print('Frame Number:', msg['frame_num'],\n 'Image Dimensions:', np.array(Image.open(BytesIO(msg['img']))).shape)\n Coord_matrix = Bbox(predictions)\n return Coord_matrix, len(predictions['predictions'])","def predict(comment):\n from allennlp.models.archival import load_archive\n from allennlp.predictors.predictor import Predictor\n from wongnai.wongnai_reader import WongnaiDatasetReader\n from wongnai.wongnai_classifier import WongnaiCommentClassifier\n from wongnai.wongnai_predictor import WongnaiCommentPredictor\n from pythainlp import word_tokenize\n\n archive = load_archive('model.tar.gz')\n wongnai_predictor = Predictor.from_archive(archive, 'wongnai_predictor')\n prediction = wongnai_predictor.predict_json({\"comment\": word_tokenize(comment)})\n print(prediction)","def parse_predictions(predicted_boxes, sem_cls_probs, objectness_probs, point_cloud, config_dict):\n\n sem_cls_probs = sem_cls_probs.detach().cpu().numpy() # B,num_proposal,10\n pred_sem_cls_prob = np.max(sem_cls_probs, -1) # B,num_proposal\n pred_sem_cls = np.argmax(sem_cls_probs, -1)\n obj_prob = objectness_probs.detach().cpu().numpy()\n\n pred_corners_3d_upright_camera = predicted_boxes.detach().cpu().numpy()\n\n K = pred_corners_3d_upright_camera.shape[1] # K==num_proposal\n bsize = pred_corners_3d_upright_camera.shape[0]\n nonempty_box_mask = np.ones((bsize, K))\n\n if config_dict[\"remove_empty_box\"]:\n # -------------------------------------\n # Remove predicted boxes without any point within them..\n batch_pc = point_cloud.cpu().numpy()[:, :, 0:3] # B,N,3\n for i in range(bsize):\n pc = batch_pc[i, :, :] # (N,3)\n for j in range(K):\n box3d = pred_corners_3d_upright_camera[i, j, :, :] # (8,3)\n box3d = flip_axis_to_depth(box3d)\n pc_in_box, inds = extract_pc_in_box3d(pc, box3d)\n if len(pc_in_box) < 5:\n nonempty_box_mask[i, j] = 0\n if nonempty_box_mask[i].sum() == 0:\n nonempty_box_mask[i, obj_prob[i].argmax()] = 1\n # -------------------------------------\n\n if \"no_nms\" in config_dict and config_dict[\"no_nms\"]:\n # pred_mask = np.ones((bsize, K))\n pred_mask = nonempty_box_mask\n elif not config_dict[\"use_3d_nms\"]:\n # ---------- NMS input: pred_with_prob in (B,K,7) -----------\n pred_mask = np.zeros((bsize, K))\n for i in range(bsize):\n boxes_2d_with_prob = np.zeros((K, 5))\n for j in range(K):\n boxes_2d_with_prob[j, 0] = np.min(pred_corners_3d_upright_camera[i, j, :, 0])\n boxes_2d_with_prob[j, 2] = np.max(pred_corners_3d_upright_camera[i, j, :, 0])\n boxes_2d_with_prob[j, 1] = np.min(pred_corners_3d_upright_camera[i, j, :, 2])\n boxes_2d_with_prob[j, 3] = np.max(pred_corners_3d_upright_camera[i, j, :, 2])\n boxes_2d_with_prob[j, 4] = obj_prob[i, j]\n nonempty_box_inds = np.where(nonempty_box_mask[i, :] == 1)[0]\n assert len(nonempty_box_inds) > 0\n pick = nms_2d_faster(\n boxes_2d_with_prob[nonempty_box_mask[i, :] == 1, :],\n config_dict[\"nms_iou\"],\n config_dict[\"use_old_type_nms\"],\n )\n assert len(pick) > 0\n pred_mask[i, nonempty_box_inds[pick]] = 1\n # ---------- NMS output: pred_mask in (B,K) -----------\n elif config_dict[\"use_3d_nms\"] and (not config_dict[\"cls_nms\"]):\n # ---------- NMS input: pred_with_prob in (B,K,7) -----------\n pred_mask = np.zeros((bsize, K))\n for i in range(bsize):\n boxes_3d_with_prob = np.zeros((K, 7))\n for j in range(K):\n boxes_3d_with_prob[j, 0] = np.min(pred_corners_3d_upright_camera[i, j, :, 0])\n boxes_3d_with_prob[j, 1] = np.min(pred_corners_3d_upright_camera[i, j, :, 1])\n boxes_3d_with_prob[j, 2] = np.min(pred_corners_3d_upright_camera[i, j, :, 2])\n boxes_3d_with_prob[j, 3] = np.max(pred_corners_3d_upright_camera[i, j, :, 0])\n boxes_3d_with_prob[j, 4] = np.max(pred_corners_3d_upright_camera[i, j, :, 1])\n boxes_3d_with_prob[j, 5] = np.max(pred_corners_3d_upright_camera[i, j, :, 2])\n boxes_3d_with_prob[j, 6] = obj_prob[i, j]\n nonempty_box_inds = np.where(nonempty_box_mask[i, :] == 1)[0]\n assert len(nonempty_box_inds) > 0\n pick = nms_3d_faster(\n boxes_3d_with_prob[nonempty_box_mask[i, :] == 1, :],\n config_dict[\"nms_iou\"],\n config_dict[\"use_old_type_nms\"],\n )\n assert len(pick) > 0\n pred_mask[i, nonempty_box_inds[pick]] = 1\n # ---------- NMS output: pred_mask in (B,K) -----------\n elif config_dict[\"use_3d_nms\"] and config_dict[\"cls_nms\"]:\n # ---------- NMS input: pred_with_prob in (B,K,8) -----------\n pred_mask = np.zeros((bsize, K))\n for i in range(bsize):\n boxes_3d_with_prob = np.zeros((K, 8))\n for j in range(K):\n boxes_3d_with_prob[j, 0] = np.min(pred_corners_3d_upright_camera[i, j, :, 0])\n boxes_3d_with_prob[j, 1] = np.min(pred_corners_3d_upright_camera[i, j, :, 1])\n boxes_3d_with_prob[j, 2] = np.min(pred_corners_3d_upright_camera[i, j, :, 2])\n boxes_3d_with_prob[j, 3] = np.max(pred_corners_3d_upright_camera[i, j, :, 0])\n boxes_3d_with_prob[j, 4] = np.max(pred_corners_3d_upright_camera[i, j, :, 1])\n boxes_3d_with_prob[j, 5] = np.max(pred_corners_3d_upright_camera[i, j, :, 2])\n boxes_3d_with_prob[j, 6] = obj_prob[i, j]\n boxes_3d_with_prob[j, 7] = pred_sem_cls[i, j] # only suppress if the two boxes are of the same class!!\n nonempty_box_inds = np.where(nonempty_box_mask[i, :] == 1)[0]\n assert len(nonempty_box_inds) > 0\n pick = nms_3d_faster_samecls(\n boxes_3d_with_prob[nonempty_box_mask[i, :] == 1, :],\n config_dict[\"nms_iou\"],\n config_dict[\"use_old_type_nms\"],\n )\n assert len(pick) > 0\n pred_mask[i, nonempty_box_inds[pick]] = 1\n # ---------- NMS output: pred_mask in (B,K) -----------\n\n batch_pred_map_cls = (\n []\n ) # a list (len: batch_size) of list (len: num of predictions per sample) of tuples of pred_cls, pred_box and conf (0-1)\n for i in range(bsize):\n if config_dict[\"per_class_proposal\"]:\n assert config_dict[\"use_cls_confidence_only\"] is False\n cur_list = []\n for ii in range(config_dict[\"dataset_config\"].num_semcls):\n cur_list += [\n (\n ii,\n pred_corners_3d_upright_camera[i, j],\n sem_cls_probs[i, j, ii] * obj_prob[i, j],\n )\n for j in range(pred_corners_3d_upright_camera.shape[1])\n if pred_mask[i, j] == 1 and obj_prob[i, j] > config_dict[\"conf_thresh\"]\n ]\n batch_pred_map_cls.append(cur_list)\n elif config_dict[\"use_cls_confidence_only\"]:\n batch_pred_map_cls.append(\n [\n (\n pred_sem_cls[i, j].item(),\n pred_corners_3d_upright_camera[i, j],\n sem_cls_probs[i, j, pred_sem_cls[i, j].item()],\n )\n for j in range(pred_corners_3d_upright_camera.shape[1])\n if pred_mask[i, j] == 1 and obj_prob[i, j] > config_dict[\"conf_thresh\"]\n ]\n )\n else:\n batch_pred_map_cls.append(\n [\n (\n pred_sem_cls[i, j].item(),\n pred_corners_3d_upright_camera[i, j],\n obj_prob[i, j],\n )\n for j in range(pred_corners_3d_upright_camera.shape[1])\n if pred_mask[i, j] == 1 and obj_prob[i, j] > config_dict[\"conf_thresh\"]\n ]\n )\n\n return batch_pred_map_cls","def _get_predictions(self, line: List[str]):\n example = self.tokenizer.encode_plus(\n [c for c in line],\n return_token_type_ids=True,\n return_attention_mask=True,\n return_tensors=\"pt\",\n )\n example = {k: v.to(self.device) for k, v in example.items()}\n prediction = self.model(example, training=False)[0]\n prediction = self.softmax_fn(prediction).cpu().data.numpy()\n prediction = prediction[1:-1, 1:].argmax(axis=-1)\n return prediction","def predict(self, datafile):\r\n \r\n # We load the test data and lower the text\r\n data_test = pd.read_csv(datafile, sep = \"\\t\", names = [\"polarity\", \"category\", \"word\", \"offsets\", \"sentence\"])\r\n data_test['sentence_l'] = data_test['sentence'].apply(str.lower)\r\n data_test['word'] = data_test['word'].apply(str.lower)\r\n \r\n # We try to keep all the no/nor/not words as this changes radically the sentiment analysis\r\n data_test['sentence_l'] = data_test[\"sentence_l\"].apply(lambda sentence: sentence.replace(\"can\\'t\", \"can not\"))\r\n data_test['sentence_l'] = data_test[\"sentence_l\"].apply(lambda sentence: sentence.replace(\"n\\'t\", \" not\"))\r\n \r\n # We clean the data and stem the words\r\n clean_sentences = []\r\n for row in data_test['sentence_l']:\r\n tokens = word_tokenize(row)\r\n tokens = [word for word in tokens if word.isalpha()]\r\n tokens = [w for w in tokens if not w in self.stopwords] \r\n tokens = [self.stemmer.stem(word) for word in tokens]\r\n clean_sentences.append(tokens)\r\n data_test['stems'] = clean_sentences\r\n \r\n # We also stem the target words to be coherent with the stemmed words in the sentences\r\n data_test['word'] = [self.stemmer.stem(word) for word in data_test['word']]\r\n\r\n # We recreate the sentences with the selected and cleaned words\r\n Classifier.create_sentence = staticmethod(Classifier.create_sentence)\r\n data_test.clean_sentence = Classifier.create_sentence(data_test.stems)\r\n \r\n # We create a BOW vector\r\n reviews_new_counts = self.restaurant_vect.transform(data_test.clean_sentence)\r\n \r\n # We transform the BOW vector with the tfidf scores\r\n reviews_new_tfidf = self.tfidf_transformer.transform(reviews_new_counts)\r\n \r\n # We make a prediction with the classifier\r\n self.pred = self.model.predict(reviews_new_tfidf)\r\n \r\n return self.pred","def prediction_processing(predictions, labels, threshold, step_nb):\n new_labels = []\n new_predictions = []\n number_sequences = step_nb//50\n\n for k in range(len(labels)//number_sequences):\n total_prediction = 0\n isLabelTrue = labels[number_sequences*k]\n for i in range(number_sequences):\n total_prediction += (1/predictions[number_sequences*k+i])\n if not(isLabelTrue == (labels[number_sequences*k+i])):\n logger.error('Problem.')\n if total_prediction > threshold:\n total_prediction = False\n else:\n total_prediction = True\n new_labels.append(isLabelTrue)\n new_predictions.append(total_prediction)\n\n recall_1 = recall_score(new_labels, new_predictions)\n recall_0 = recall_score(new_labels, new_predictions, pos_label=0)\n precision_1 = precision_score(new_labels, new_predictions)\n precision_0 = precision_score(new_labels, new_predictions, pos_label=0)\n return((recall_1, recall_0, precision_1, precision_0), new_predictions, new_labels)","def inspect_pair_with_model(model,sent1,sent2,expected_label):\n dp = dataPoint((sent1,sent2),expected_label)\n pred = model.predict(np.array(dp.get_features()).reshape(1,-1))\n if (pred == expected_label):\n print(\"succesfully predicted\")\n else:\n print(\"The model predicted \" + str(pred) + \" while we actually wanted \" + str(expected_label))\n print(\"The features for these sentences are: \")\n inspect_model(model)","def postprocess_predictions(predicted_aggregation_operators, predicted_table_cell_coords, table):\n # Process predicted aggregation operators\n aggregation_operators = {0: \"NONE\", 1: \"SUM\", 2: \"AVERAGE\", 3: \"COUNT\"}\n aggregation_predictions_string = [aggregation_operators[x] for x in predicted_aggregation_operators]\n\n # Process predicted table cell coordinates\n answers = []\n for coordinates in predicted_table_cell_coords:\n if len(coordinates) == 1:\n # 1 cell\n answers.append(table.iat[coordinates[0]])\n else:\n # > 1 cell\n cell_values = []\n for coordinate in coordinates:\n cell_values.append(table.iat[coordinate])\n answers.append(\", \".join(cell_values))\n\n # Return values\n return aggregation_predictions_string, answers","def make_prediction(self, title: str, body: str):\n data = pd.DataFrame({\n \"title\": [title],\n \"body\": [body],\n \"tags\": [\"\"]\n })\n data = self.extractor.process_df(data)\n prediction = self.__model.predict(self.df_to_inputs(data))\n print(\"PRED: \", prediction)\n\n explanation = self.interpret(title, body, data[self.FEATURES])\n return prediction, explanation","def convert_data(test_data,params,list_dict,rational_present=True,topk=2):\n \"\"\"input: params -- input dict, list_dict -- previous predictions containing rationals\n rational_present -- whether to keep rational only or remove them only\n topk -- how many words to select\"\"\"\n \n temp_dict={}\n for ele in list_dict:\n temp_dict[ele['annotation_id']]=ele['rationales'][0]['soft_rationale_predictions']\n \n test_data_modified=[]\n \n for index,row in tqdm(test_data.iterrows(),total=len(test_data)):\n try:\n attention=temp_dict[row['Post_id']]\n except KeyError:\n continue\n topk_indices = sorted(range(len(attention)), key=lambda i: attention[i])[-topk:]\n new_text =[]\n new_attention =[]\n if(rational_present):\n if(params['bert_tokens']):\n new_attention =[0]\n new_text = [101]\n for i in range(len(row['Text'])):\n if(i in topk_indices):\n new_text.append(row['Text'][i])\n new_attention.append(row['Attention'][i])\n if(params['bert_tokens']):\n new_attention.append(0)\n new_text.append(102)\n else:\n for i in range(len(row['Text'])):\n if(i not in topk_indices):\n new_text.append(row['Text'][i])\n new_attention.append(row['Attention'][i])\n test_data_modified.append([row['Post_id'],new_text,new_attention,row['Label']])\n\n df=pd.DataFrame(test_data_modified,columns=test_data.columns)\n return df","def predict(cls, input):\n clf = cls.get_model() \n\n input.to_csv(data_dir + 'vdok_predction_src_file.csv')\n\n q = qa_serializer_lang_selector(data_dir)\n q.serialize_record('vdok_predction_src_file.csv', task_name)\n q.select_lang([1], task_name).to_csv(data_dir + data_file, encoding= 'latin1')\n\n pipeline=['pos', 'lemma', 'synset', 'hype', 'hypo']\n\n bnlqd = fex_basic_nlp(data_file, data_dir)\n bnlqd.nlp_run(pipeline[0])\n bnlqd.nlp_run(pipeline[1])\n bnlqd.df_ac_lemma.to_csv(data_dir + 'Lemma-' + data_file, encoding= 'latin1')\n bnlqd.nlp_run(pipeline[2])\n bnlqd.df_ac_synset.to_csv(data_dir + 'Synset-' + data_file , encoding= 'latin1')\n bnlqd.nlp_run(pipeline[3])\n bnlqd.df_ac_hypernyms.to_csv(data_dir + 'Hypernyms-' + data_file, encoding= 'latin1')\n bnlqd.nlp_run(pipeline[4])\n bnlqd.df_ac_hyponyms.to_csv(data_dir + 'Hyponyms-' + data_file, encoding= 'latin1')\n\n bnlpd = fex_basic_nlp(def_file, data_dir, task_name)\n bnlpd.nlp_run(pipeline[0])\n bnlpd.nlp_run(pipeline[1])\n bnlpd.df_ac_lemma.to_csv(data_dir + 'Lemma-P-' + data_file, encoding= 'latin1')\n \n btgqd = bi_trigram(data_file, data_dir)\n btgqd.nlp_run(r'bigram')\n btgqd.nlp_run(r'trigram') \n\n stop_words_d = cls.remove_non_extracted_stop_word(bnlqd.df_ac_lemma, stop_words)\n\n oanc_shelve = oanc_resource + 'ANC-all-lemma-04262014.db'\n oalqd = odi_oanc_lemma_frequency(data_file, oanc_shelve, None, data_dir, stop_words_d) \n oalqd.oanc_lemma_frequency('Lemma-' + data_file, 'Student_Question_Index', 'Pre_Col_Name')\n \n stop_words_hy_d = cls.remove_non_extracted_stop_word(bnlqd.df_ac_lemma, stop_words_hy)\n\n ovlqd = odi_overlapping(data_file, def_file, data_dir, stop_words_d)\n ovlqd.count_overlapping('Lemma-' + data_file, 'Student_Question_Index',\n 'Pre_Col_Name', 'Question_ID', 'Question_ID_Sec',\n 'Lemma-P-' + data_file, 'Question_ID', 'Question_ID_Sec')\n ovlqd.count_overlapping_synset('Synset-' + data_file)\n ovlqd.count_overlapping_hypernyms('Hypernyms-' + data_file, stop_words_hy_d)\n ovlqd.count_overlapping_hyponyms('Hyponyms-' + data_file, stop_words_hy_d)\n\n df_ac_pmi_dist_bigram = cls.bi_trigram_pmi_distribution(pmi_bigram_file, data_dir, \n bnlqd.num_clm_in, btgqd.df_ac_bigram, 'bigram')\n df_ac_pmi_dist_trigram = cls.bi_trigram_pmi_distribution(pmi_trigram_file, data_dir, \n bnlqd.num_clm_in, btgqd.df_ac_trigram, 'Trigram')\n\n df_ac_aggregate = cls.aggregate_plim(bnlqd, oalqd, ovlqd, df_ac_pmi_dist_bigram, df_ac_pmi_dist_trigram,\n bnlpd, specific_count_lemmas, stop_words_pos, task_name)\n df_ac_aggregate.to_csv(data_dir + 'vdok_predction_Aggregate_plim.csv', encoding= 'latin1')\n df_ac_aggregate_item_level = cls.aggregate_item_level_plim(df_ac_aggregate, oalqd.stem_option_name_clm, \n task_name)\n df_ac_aggregate_item_level.to_csv(data_dir + 'vdok_predction_Key_Stem_Passage_Aggregate_plim.csv',\n encoding= 'latin1')\n\n rfrpod = tmv_RF_classify('Independent_Variable_w_Label-Def.csv', data_dir)\n rfrpod.load_data('vdok_predction_Key_Stem_Passage_Aggregate_plim.csv', True, drop_vars, dependent_var)\n clf.perform_prediction(rfrpod.df_ac_modeling_values)\n return clf.df_ac_classified","def predict_label(\n self, message: \"Message\"\n ) -> Tuple[Dict[Text, Any], List[Dict[Text, Any]]]:\n\n label = {\"name\": None, \"confidence\": 0.0}\n label_ranking = []\n\n if self.session is None:\n logger.error(\n \"There is no trained tf.session: \"\n \"component is either not trained or \"\n \"didn't receive enough training data.\"\n )\n return label, label_ranking\n\n # create session data from message and convert it into a batch of 1\n session_data = self._create_session_data([message])\n\n # if no text-features are present (e.g. incoming message is not in the\n # vocab), do not predict a random intent\n if not self._text_features_present(session_data):\n return label, label_ranking\n\n batch = train_utils.prepare_batch(\n session_data, tuple_sizes=self.batch_tuple_sizes\n )\n\n # load tf graph and session\n label_ids, message_sim = self._calculate_message_sim(batch)\n\n # if X contains all zeros do not predict some label\n if label_ids.size > 0:\n label = {\n \"name\": self.inverted_label_dict[label_ids[0]],\n \"confidence\": message_sim[0],\n }\n\n if self.ranking_length and 0 < self.ranking_length < LABEL_RANKING_LENGTH:\n output_length = self.ranking_length\n else:\n output_length = LABEL_RANKING_LENGTH\n\n ranking = list(zip(list(label_ids), message_sim))\n ranking = ranking[:output_length]\n label_ranking = [\n {\"name\": self.inverted_label_dict[label_idx], \"confidence\": score}\n for label_idx, score in ranking\n ]\n\n return label, label_ranking","def init_predict_text(self, decode_method=0, beam_size=5, convert_unk=True):\n text, score = self.build_predict_text_graph(self.input_text_feed, \n decode_method=decode_method, \n beam_size=beam_size, \n convert_unk=convert_unk)\n return text, score","def predict_str(self, s,saved_model):\n x = self.dataset.str_to_x(s,200)\n predicted_classes = self.predict_x(x,saved_model)\n chars = self.dataset.x_to_str(x)[0]\n labels = self.dataset.y_to_labels(predicted_classes)[0]\n\n \"\"\"\n Converting char to words and \n \"\"\"\n\n word = \"\"\n labels_per_word = []\n predictions = []\n\n\n for i in range(len(chars)):\n if(len(chars[i].strip()) and chars[i].strip()!='<PAD>'):\n word+=chars[i]\n labels_per_word.append(labels[i])\n else:#word over\n\n frequent_label = self.most_frequent(labels_per_word)\n predictions.append((None,None,word,frequent_label))\n word = ''\n labels_per_word = []\n if(chars[i].strip()=='<PAD>'):\n break\n\n\n return predictions","def predict(self, first_preprocessed_inputs,second_preprocessed_inputs,third_preprocessed_inputs):\r\n pass","def tag_notes(model_path,\n input_data_path,\n output_data_path,\n text_column_name,\n metadata_columns,\n prediction_column_name=constants.PREDICTION_COLUMN_NAME):\n\n print(\"Loading model from {}\".format(model_path))\n with open(model_path, 'rb') as f:\n model = pickle.load(f)\n\n print(\"Loading data from {}\".format(input_data_path))\n input_data = pd.read_json(input_data_path, orient='records', lines=True)\n\n print(\"Making predictions\")\n note_tag_predictions = model.predict_tag(\n data=input_data,\n text_column_name=text_column_name,\n metadata_columns=metadata_columns,\n prediction_column_name=prediction_column_name)\n\n print(\"Saving data to {}\".format(output_data_path))\n note_tag_predictions.to_json(output_data_path, orient='records', lines=True)","def extract_detections(self):\n self.rescue_model.setInput(self.human_blob)\n self.predictions = self.rescue_model.forward()","def predict(self, datafile):","def test_predict(self):\n\n docs = self.docs\n for m in self.models:\n preds = m.predict(docs)\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertEqual(len(preds), len(docs))\n self.assertEqual(preds.dtype, int)\n\n preds = m.predict(docs, output_type=\"probability\")\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertTrue(len(preds) == len(docs))\n s = preds.apply(lambda x: sum(x))\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\n\n # Test predictions when docs have new words\n new_docs = turicreate.SArray([{\"-1,-1\": 3.0, \"0,4\": 5.0, \"0,3\": 2.0}])\n preds = m.predict(new_docs)\n self.assertEqual(len(preds), len(new_docs))\n\n # Test additional burnin. Ideally we could show that things\n # converge as you increase burnin.\n preds_no_burnin = m.predict(docs, output_type=\"probability\", num_burnin=0)\n self.assertEqual(len(preds_no_burnin), len(docs))","def analyze():\n content = request.get_json()\n if model is None:\n return\n max_seq_length = model.max_seq_length\n test_data = content['text']\n data, seq_lengths, targets = prepare_text(\n test_data, max_seq_length, vocab_mapping)\n input_feed = {}\n input_feed[model.seq_input.name] = data\n input_feed[model.target.name] = targets\n input_feed[model.seq_lengths.name] = seq_lengths\n output_feed = [model.y]\n outputs = sess.run(output_feed, input_feed)\n score = np.argmax(outputs[0])\n probability = outputs[0].max(axis=1)[0]\n message = 'Value of sentiment: '\n if score > 0:\n message = message + 'positive'\n else:\n message = message + 'negative'\n message = message + ' with probability: ' + str(probability)\n result = json.dumps({\n 'score': str(score),\n 'probability': str(probability)\n })\n\n resp = Response(response=result, status=200, mimetype='application/json')\n\n return resp","def predict_tokens(self, tokens):\n return","def postprocess(self, inputs: Dict[str, Any],\n **postprocess_params) -> Dict[str, str]:\n text = inputs['text']\n logits = inputs[OutputKeys.LOGITS]\n predictions = torch.argmax(logits[0], dim=-1)\n logits = torch_nested_numpify(torch_nested_detach(logits))\n predictions = torch_nested_numpify(torch_nested_detach(predictions))\n offset_mapping = [x.cpu().tolist() for x in inputs['offset_mapping']]\n\n labels = [self.id2label[x] for x in predictions]\n if len(labels) > len(offset_mapping):\n labels = labels[1:-1]\n chunks = []\n chunk = {}\n for label, offsets in zip(labels, offset_mapping):\n if label[0] in 'BS':\n if chunk:\n chunk['span'] = text[chunk['start']:chunk['end']]\n chunks.append(chunk)\n chunk = {\n 'type': label[2:],\n 'start': offsets[0],\n 'end': offsets[1]\n }\n if label[0] in 'IES':\n if chunk:\n chunk['end'] = offsets[1]\n\n if label[0] in 'ES':\n if chunk:\n chunk['span'] = text[chunk['start']:chunk['end']]\n chunks.append(chunk)\n chunk = {}\n\n if chunk:\n chunk['span'] = text[chunk['start']:chunk['end']]\n chunks.append(chunk)\n\n # for cws outputs\n if len(chunks) > 0 and chunks[0]['type'] == 'cws':\n spans = [\n chunk['span'] for chunk in chunks if chunk['span'].strip()\n ]\n seg_result = ' '.join(spans)\n outputs = {OutputKeys.OUTPUT: seg_result}\n\n # for ner output\n else:\n outputs = {OutputKeys.OUTPUT: chunks}\n return outputs","def get_prediction_response(predictions):\n if len(predictions) == 0:\n # no player identified\n return [\"Sorry, I couldn't find any player with that last name. Please try a different name.\"]\n responses = []\n for prediction in predictions:\n # # handle error messages\n if isinstance(prediction, str):\n responses.append(prediction)\n continue\n\n # # response for identified player\n start_message = random.choice([\n 'I think ',\n 'I predict ',\n 'After careful consideration, I can say that ',\n 'It seems that ',\n ])\n if prediction['predicted_points'] > 1:\n plural_string = 's'\n else:\n plural_string = ''\n response = '%s %s %s (%s) of %s will probably score around %d point%s against %s in GW %d' % (\n start_message,\n prediction['first_name'],\n prediction['second_name'],\n prediction['position_short'],\n prediction['team_name'],\n prediction['predicted_points'],\n plural_string,\n prediction['opp_team_name'],\n prediction['week']\n )\n responses.append(response)\n return responses","def predict(data, model_predict):\n # Execute any steps you need to do before scoring\n\n # This method makes predictions against the raw, deserialized model\n #predictions = model_predict(data)\n\n data.to_csv(\"/opt/code/chemprop_folder/for_scoring.csv\", index=False)\n\n args = PredictArgs().parse_args([\n '--test_path', '/opt/chemprop_folder/for_scoring.csv',\n '--checkpoint_path', '/opt/code/model.pth',\n '--preds_path', '/opt/chemprop_folder/preds.csv'\n ])\n\n make_predictions(args)\n\n preds_df = pds.read_csv(\"/opt/chemprop_folder/preds.csv\")\n sh = str(preds_df.shape)\n print(sh)\n\n preds_df = preds_df.rename(columns = {\"p_np\": \"positive_class_label\"})\n preds_df = preds_df.drop(columns=['smiles'])\n preds_df[\"negative_class_label\"] = 1 - preds_df[\"positive_class_label\"]\n\n print(preds_df.head())\n\n # Execute any steps you need to do after scoring\n # Note: To properly send predictions back to DataRobot, the returned DataFrame should contain a\n # column for each output label for classification or a single value column for regression\n return preds_df","def post_process_predictions(self, labels, scene):\n pass","def predict(self, review):\n raise NotImplementedError","def classify(strings: List[str], params: Any) -> List[str]:\n \n # ############################ REPLACE THIS WITH YOUR CODE #############################\n def predict_one_sample(sample, train_dict, ngram_lvl=1):\n ngrams = [sample[i:i+ngram_lvl] for i in","def recognize(models: dict, test_set: SinglesData):\n warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n probabilities = []\n guesses = []\n # TODO implement the recognizer\n # return probabilities, guesses\n test_sequences = list(test_set.get_all_Xlengths().values())\n for test_X,test_Xlength in test_sequences:\n prob = {}\n maxlogLvalue = float(\"-inf\")\n guess = \"\"\n for word, model in models.items():\n try:\n logLvalue = model.score(test_X, test_Xlength) \n prob[word] = logLvalue\n if logLvalue > maxlogLvalue:\n guess = word\n maxlogLvalue = logLvalue\n except:\n prob[word] = float(\"-inf\")\n\n\n probabilities.append(prob) \n guesses.append(guess)\n\n return (probabilities,guesses)","def predict(self, expression=None):\r\n confidence_score = 0\r\n intent = None\r\n\r\n #intent, confidence_score = self.ncf(expression)\r\n intent, confidence_score = \"Test\",100\r\n l_msg = \"model found : {} and score is {}\".format(intent, confidence_score)\r\n log.debug(l_msg)\r\n\r\n return intent, confidence_score","def inference(self, inputs):\n\n input_ids = torch.tensor([inputs[\"head_ids\"]], dtype=torch.long).to(self.device)\n attention_masks = torch.tensor([inputs[\"attention_masks\"]], dtype=torch.bool).to(self.device)\n \n # Handling inference for sequence_classification.\n with torch.no_grad():\n output = self.model(input_ids, attention_masks)\n predict_label = output[0].argmax(dim=2)\n predict_string = self.tokenizer.decode_sent(input_ids[0].detach().cpu().numpy(), predict_label[0].detach().cpu().numpy())\n\n logger.info(\"Model predicted: '%s'\", predict_string)\n return [{'predict': predict_string}]","def run_prediction(data, sess, placeholders, scores): \r\n \r\n X, Y = data\r\n source_pl, target_pl, training_pl = placeholders\r\n split_set = int(math.floor(0.9*len(X))) # Value for spliting the set in 90% training / 10% test \r\n \r\n X_batch, Y_batch = batch(X[:split_set:], Y[:split_set:]) # Take a batch of sentences from the training set\r\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\r\n prediction = sess.run(scores, feed_dict=feed_dict) \r\n X_batch = np.squeeze(X_batch) \r\n prediction = np.squeeze(prediction)\r\n \r\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\r\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\r\n\r\n\t# Print the pairs source -> target\r\n for source, target in zip(source_sentences, target_sentences): \r\n print(source + \" --> \" + target)\r\n \r\n print(\"================================================================\")\r\n \r\n X_batch, Y_batch = batch(X[split_set+1:], Y[split_set+1:]) # Take a batch of sentences from the test set\r\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\r\n prediction = sess.run(scores, feed_dict=feed_dict) \r\n \r\n X_batch = np.squeeze(X_batch) \r\n prediction = np.squeeze(prediction)\r\n \r\n \r\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\r\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\r\n\r\n\t# Print the pairs source -> target\r\n for source, target in zip(source_sentences, target_sentences): \r\n print(source + \" --> \" + target)","def recognize_ngram(models: dict, test_set: SinglesData,probs,BIC_guesses):\n warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n probabilities = []\n guesses = []\n\n model = arpa.loadf(\"devel-lm-M3.sri.lm\")\n lm = model[0] # ARPA files may contain several models.\n # TODO implement the recognizer\n # return probabilities, guesses\n test_sequences = list(test_set.get_all_Xlengths().values())\n word_keys = list(test_set.get_all_Xlengths().keys())\n i = -1 \n for sentence in test_set.sentences_index.values():\n f = {}\n maxs = float(\"-inf\")\n prob = []\n words = []\n\n sentenceLength = 0\n for word_index in sentence:\n i+=1\n word = test_set.wordlist[word_index]\n sentenceLength+=1\n try:\n f[word] = probs[word][i]\n except:\n f[word] = float(\"-inf\")\n prob.append(f[word]) ## These are Just the probabilities unchanged from the BIC recognizer.\n \n # Find Six most probable words and generate the possible permutations \n sixwords = sorted(f,key=f.get,reverse=True)[:6]\n for k in permutations(sixwords, r=sentenceLength):\n l = 0\n for j in range(len(k)):\n l += f[k[j]]\n try:\n sentenceLP = l + 13*lm.log_s(\" \".join(k)) ## According to one student in the forum 13 is the best hyperparameter\n if sentenceLP > maxs: ## https://discussions.udacity.com/t/slm-data-for-this-asl-dataset/230822/8?u=spiros\n sentence = \" \".join(k)\n maxs = sentenceLP\n words = list(k)\n except:\n pass\n\n if(words == []):\n words = BIC_guesses[len(guesses):len(guesses)+sentenceLength] ## Fall back to BIC guesses\n probabilities.append(prob) \n guesses += words\n return (probabilities,guesses)","def sentence_prediction(self, sentence, echo=False):\n sentence = norm_input(sentence)\n sentence = self.typing_errors(sentence)\n sent_seq = self.tokenizer_x.texts_to_sequences([sentence])\n sentence_tok = pad_sequences(sent_seq, maxlen=self.sentence_size,\n dtype='int32')\n wi = self.tokenizer_y.word_index\n pr = self.model.predict(sentence_tok)[0]\n predictions = []\n for speechact, index in wi.items():\n predictions.append((round(pr[index]*100, 2), speechact))\n predictions.sort(key=lambda tup: tup[0])\n if echo:\n for p in predictions:\n print(str(p[0]).rjust(7) + \" -> \" + p[1])\n return predictions[-1][1]","def computeErrorRate(test_set, words_likely_tags):\n # initiate vars\n known_words = {} # those two dictionaries are optional, just for debuging\n unknown_words = {} # those two dictionaries are optional, just for debuging\n correct_predictions = 0\n total_predictions = 0\n correct_unknown_predictions = 0\n total_unknown_predictions = 0\n\n for i in range(len(test_set)): # iterate sentences\n test_sent = test_set[i]\n for j in range(len(test_sent)): # iterate words in sent\n w = test_sent[j][WORD]\n t = test_sent[j][TAG]\n\n # known words\n if w in words_likely_tags:\n if w in known_words:\n known_words[w][COUNTER_SHOWS] += 1\n if t == words_likely_tags[w]: # same tag\n known_words[w][COUNTER_EQUAL] += 1\n correct_predictions += 1\n else:\n if t == words_likely_tags[w]: # same tag\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\n correct_predictions += 1\n else:\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\n\n total_predictions += 1\n # unknown words\n else: # w not in words_likely_tags, treat w as unknown_word\n if w in unknown_words:\n unknown_words[w][COUNTER_SHOWS] += 1\n if t == UNKNOWN_TAG:\n # same tag as our model predicts for unknown words\n unknown_words[w][COUNTER_EQUAL] += 1\n correct_unknown_predictions += 1\n else:\n if t == UNKNOWN_TAG: # same tag\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\n correct_unknown_predictions += 1\n else:\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\n\n total_unknown_predictions += 1\n\n # print('correct_predictions......... = ', correct_predictions)\n # print('total_predictions........... = ', total_predictions)\n # print('correct_unknown_predictions. = ', correct_unknown_predictions)\n # print('total_unknown_predictions... = ', total_unknown_predictions)\n err_rate_known = 1 - correct_predictions/total_predictions\n err_rate_unknown = 1 - correct_unknown_predictions/total_unknown_predictions\n # total_err = err_rate_known + err_rate_unknown\n tot_pred = total_predictions + total_unknown_predictions\n corr_pred = correct_predictions + correct_unknown_predictions\n total_err = 1 - corr_pred/tot_pred\n\n return err_rate_known, err_rate_unknown, total_err","def get_predictions(payload):\n return sm_client.invoke_endpoint(EndpointName=EMBEDDING_MODEL_ENDPOINT_NAME, \n Body=payload,\n ContentType='application/json')","def construct_NLP_model(self, df=None):\n import review_processing as rp\n # get words\n if df is not None:\n nitems = df.shape[0]\n col_names = df.columns.values\n if self.review_col_name not in col_names or \\\n self.sentiment_col_name not in col_names:\n sys.exit('construct_NL_model: The name {0}/{1} cannot be found'.\n format(self.review_col_name, self.sentiment_col_name))\n review_list = df[self.review_col_name].values.tolist()\n meaningful_words = map(self.review_to_meaningful_words,\n review_list)\n # Get training sentiment values\n self.sentiment = df[self.sentiment_col_name].values\n\n else:\n if self.training_file_name is None:\n sys.exit('construct_NLP_model: traning file name does not '\n 'exist')\n else:\n suffix = os.path.splitext(self.training_file_name)[1][1:]\n if suffix == 'csv':\n df = pd.read_csv(self.training_file_name)\n if self.review_col_name not in col_names or \\\n self.sentiment_col_name not in col_names::\n sys.exit('construct_NL_model: The name {0}/{1} cannot '\n ' be found'.format(self.review_col_name,\n self.sentiment_col_name))\n nitems = df.shape[0]\n review_list = df[review_col_name].values.tolist()\n meaningful_words = map(self.review_to_meaningful_words,\n review_list)\n elif suffix == 'json':\n data_dict_list = rp.load_data(self.training_file_name)\n if self.review_col_name not in data_dict_list.keys():\n sys.exit('construct_NL_model: The name {0} cannot be '\n 'found'.format(review_col_name))\n review_list = map(lambda x: x[review_col_name],\n data_dict_list)\n meaningful_words = map(self.review_to_meaningful_words,\n review_list)\n else:\n sys.exit('construct_NLP_model: file type not supported '\n 'yet!')\n\n # Training process of Bag of Worlds\n if self.NLP_model == 'BagofWords':\n print('construct_NLP_model: Creating bag of words...')\n self.vectorizer = CountVectorizer(analyzer='word',\n tokenizer=None,\n preprocessor=None,\n stop_words=None,\n max_features=self.maxfeature)\n self.train_data_features = vectorizer.fit_transform(\n meaningful_words)\n self.train_data_features = train_data_features.toarray()\n\n # vocab = vectorizer.get_feature_names()\n # dist = np.sum(train_data_features, axis=0)\n # for tag, count in zip(vocab, dist):\n # print(count, tag)\n\n else:\n sys.exit('construct_NLP_model: NLP_model type not supported yet!')","def predict_greedy(self, tokens: TokenSeq) -> Tuple[NDArray, PosSeq]:\n \n #array to hold predictions\n predictions = np.zeros((len(tokens), len(self.l), len(self.l)))\n for i in range(len(tokens)):\n\n for prev_tag in self.l:\n new_feature_matrix = []\n temp_dict = {}\n feature_dict = add_features(tokens, prev_tag ,i, temp_dict)\n new_feature_matrix.append(feature_dict)\n new_feature_matrix = self.vectorizer.transform(new_feature_matrix)\n \n probabilities = self.clf.predict_proba(new_feature_matrix)\n predictions[i, self.label_index(prev_tag)] = probabilities\n \n cur = len(probabilities[0])- 1\n final_predictions = []\n for i in range(len(predictions)):\n cur_pred = np.argmax(predictions[i, cur])\n final_predictions.append(cur_pred)\n cur = cur_pred\n ret_matrix = []\n #print(tokens)\n final_predictions = self.le.inverse_transform(final_predictions)\n #print(final_predictions)\n new_pos = final_predictions.tolist()\n new_pos.insert(0, \"<s>\")\n new_pos.pop(len(new_pos) - 1)\n for i in range(len(new_pos)):\n feature_dict = add_features(tokens, new_pos[i] ,i, temp_dict)\n ret_matrix.append(feature_dict)\n ret_matrix = self.vectorizer.transform(ret_matrix)\n\n return (ret_matrix, final_predictions)","def parser(sent_list): #input: list of sentences","def prepare_reg_data_for_prediction(dataframe, model_dict, user_keyword, task_name):\r\n parent_dir = Path.cwd().parent\r\n pickle_dir = parent_dir.joinpath('default_results', 'pickle_files_feat_eng')\r\n\r\n feature_X_user,affect_dataframe, affect_index_dataframe = df, df, df\r\n emo_X_test_dict = {}\r\n affect_index_dict ={}\r\n\r\n for emotion, model_prop in model_dict.items():\r\n #Get the data with the emotion class\r\n if user_keyword == 'validation':\r\n affect_dataframe = dataframe[dataframe['Affect Dimension'] == 1]\r\n affect_index_list = dataframe.index[dataframe['Affect Dimension'] == 1].tolist()\r\n else:\r\n affect_dataframe = dataframe[dataframe[emotion] == 1]\r\n affect_index_list = dataframe.index[dataframe[emotion] == 1].tolist()\r\n test_tweets = affect_dataframe.iloc[:, [0, 1, 2]]\r\n\r\n #Perform preprocessing, feature extraction and transformation for the tweets to be predicted\r\n print(emotion, test_tweets.shape)\r\n if test_tweets.empty == False:\r\n preprocessed_X_user = Preprocessor.perform(test_tweets, emotion, user_keyword, task_name)\r\n feature_X_user = Feature_Transformer.perform(preprocessed_X_user, emotion, user_keyword, task_name)\r\n vectorizer = Dictionaries.vectorizer_dict[model_prop[2]]\r\n\r\n #Fit transform the vectorizer with the corresponding preprocessed training data\r\n if os.path.exists(pickle_dir.joinpath(emotion + '_r_train_preprocess_df.pkl')):\r\n preprocess_train_df = pd.read_pickle(pickle_dir.joinpath(emotion + '_r_train_preprocess_df.pkl'))\r\n train_vect = vectorizer.fit_transform(preprocess_train_df['preprocessed_text'].values)\r\n train_vect_df = pd.DataFrame(train_vect.toarray(), columns=vectorizer.get_feature_names())\r\n print(emotion, 'train-shape', train_vect_df.shape, sep='\\n')\r\n else:\r\n #If the file doesnt exist, exit the program with instructions\r\n print('\\nRequired files does not exist.\\n\\n Please, train the models first by running > Modelling.py')\r\n sys.exit(1)\r\n\r\n # Use the same vectorizer to transform test data and then perform the feature union\r\n vector_X = vectorizer.transform(preprocessed_X_user['preprocessed_text'].values)\r\n test_vect_df = pd.DataFrame(vector_X.toarray(), columns=vectorizer.get_feature_names())\r\n X_test = pd.DataFrame(pd.concat([test_vect_df, feature_X_user], axis=1)) #####?\r\n emo_X_test_dict[emotion] = X_test\r\n affect_index_dict[emotion] = affect_index_list\r\n else:\r\n emo_X_test_dict[emotion] = pd.DataFrame\r\n affect_index_dict[emotion] = []\r\n\r\n return emo_X_test_dict, affect_index_dict","def parse_predictions(response_json):\n if not isinstance(response_json, collections.Mapping):\n raise ValueError(\n \"Invalid response received from prediction server: {}\".format(\n repr(response_json)))\n if PREDICTIONS_KEY not in response_json:\n raise ValueError(\n \"Required field '{}' missing in prediction server response: {}\".format(\n PREDICTIONS_KEY, repr(response_json)))\n return response_json.pop(PREDICTIONS_KEY)","def extract_pred_from_estimator_predictions(predictions):\n # print('predictions:', predictions)\n pred = np.array([])\n for prediction in predictions:\n pred = np.append(pred, prediction['predictions'])\n num_samples = len(pred)\n pred = pred.reshape((num_samples, ))\n return pred","def predict(self, text):\n tokens = ['[CLS]'] + self.tokenizer.tokenize(text) + ['[SEP]']\n xx = self.tokenizer.convert_tokens_to_ids(tokens)\n xx = torch.tensor(xx).unsqueeze(0).to(self.device)\n _, y_hat = self.model(xx)\n pred_tags = []\n for tag in y_hat.squeeze():\n pred_tags.append(idx2tag[tag.item()])\n return pred_tags, tokens","def predictor(path):\n # get keypoints from the image in a DF\n TEST_keypoints = []\n path = cv2.cvtColor(path, cv2.COLOR_BGR2RGB)\n img = movenet_inference_flat_v10(hub_model, path)\n TEST_keypoints.append(img)\n TEST_keypoints_df = pd.DataFrame(TEST_keypoints)\n\n # Rename columns in the DataFrames according to the values\n columns = []\n for point in kp_descriptions:\n for value in ('y', 'x', 'score'):\n columns.append(f'{point}_{value}')\n\n TEST_keypoints_df.columns = columns\n \n # add additional positional features\n TEST_keypoints_df = add_pos_features(TEST_keypoints_df, drop_scores=True)\n # predict the asana\n prediction_existing = model_fl.predict(TEST_keypoints_df)\n # initialize the predicted_asana to 107 (no asan found)\n predicted_asana = 107\n\n # assign the precited asana if accuracy more than threshold (12.5%)\n for i in range(1):\n mx = 0\n mx_label = -1\n for j in range(107):\n if(prediction_existing[i, j] > mx):\n mx_label = j\n mx = prediction_existing[i, j]\n predicted_asana = mx_label\n predicted_accuracy = prediction_existing[0, mx_label]\n if(predicted_accuracy < 0.125):\n predicted_asana = 107\n\n # print(predicted_asana)\n \n # find label from the json\n a = inv_map[str(predicted_asana)]\n # b = \"null\"\n\n print(\"predicted pose --> \", a)\n print(\"confidence = \", predicted_accuracy)\n # print(\"actual pose -->\", b)\n return a, img","def predict(self, sentences, batch_size=128):\n pred_tensors = [\n sentence_to_tensor(sentence, self.src_lang)\n for sentence in tqdm(sentences, desc=\"creating prediction tensors\")\n ]\n\n collate_fn = Collater(self.src_lang, predict=True)\n pred_dataloader = DataLoader(\n SimpleDataset(pred_tensors),\n batch_size=batch_size,\n collate_fn=collate_fn,\n )\n\n sentences = []\n words = []\n attention = []\n for batch in tqdm(pred_dataloader, desc=\"predict batch num\"):\n preds = self.predict_batch(batch.to(device))\n pred_sentences, pred_words, pred_attention = preds\n sentences.extend(pred_sentences)\n words.extend(pred_words)\n attention.extend(pred_attention)\n\n # sentences = [num pred sentences]\n # words = [num pred sentences, trg len]\n # attention = [num pred sentences, n heads, trg len, src len]\n\n return sentences, words, attention","def predict(self, sentence_list): # noqa: ignore flake8\"\n\n if self.src_2_ids is None:\n self.src_2_ids = load_word_dict(self.src_vocab_path)\n self.trg_2_ids = load_word_dict(self.trg_vocab_path)\n if self.model is None:\n if os.path.exists(self.model_path):\n self.model = Seq2Seq(\n encoder_vocab_size=len(self.src_2_ids),\n decoder_vocab_size=len(self.trg_2_ids),\n embed_size=self.embed_size,\n enc_hidden_size=self.hidden_size,\n dec_hidden_size=self.hidden_size,\n dropout=self.dropout\n )\n self.load_model()\n self.model.to(device)\n else:\n raise ValueError(\"Model not found. Please train the model first.\")\n self.model.eval()\n result = []\n for query in sentence_list:\n out = []\n tokens = [token.lower() for token in query]\n tokens = [SOS_TOKEN] + tokens + [EOS_TOKEN]\n src_ids = [self.src_2_ids[i] for i in tokens if i in self.src_2_ids]\n\n sos_idx = self.trg_2_ids[SOS_TOKEN]\n src_tensor = torch.from_numpy(np.array(src_ids).reshape(1, -1)).long().to(device)\n src_tensor_len = torch.from_numpy(np.array([len(src_ids)])).long().to(device)\n sos_tensor = torch.Tensor([[self.trg_2_ids[SOS_TOKEN]]]).long().to(device)\n translation, attn = self.model.translate(src_tensor, src_tensor_len, sos_tensor,\n self.max_length)\n translation = [self.id_2_trgs[i] for i in translation.data.cpu().numpy().reshape(-1) if\n i in self.id_2_trgs]\n for word in translation:\n if word != EOS_TOKEN:\n out.append(word)\n else:\n break\n result.append(''.join(out))\n return result","def generate_predictions(inputs, model, tokenizer):\n # Generate model results\n outputs = model(**inputs)\n\n # Convert logit outputs into predictions for table cells and aggregation operators\n predicted_table_cell_coords, predicted_aggregation_operators = tokenizer.convert_logits_to_predictions(\n inputs,\n outputs.logits.detach(),\n outputs.logits_aggregation.detach()\n )\n\n print(predicted_table_cell_coords)\n print(predicted_aggregation_operators)\n\n # Return values\n return predicted_table_cell_coords, predicted_aggregation_operators","def predict(self, documents):\n raise NotImplementedError()","def predict_sentences(self, sents):\n tkw=self.tkw\n sents_attr=[]\n sent_samples={\n \"word_inputs\":[],\n \"predicate_inputs\":[],\n \"postags_inputs\":[]\n }\n print('prepare data')\n for sid,sent in enumerate(sents):\n if sid % (int(np.ceil(len(sents)/100))) == 0:\n print(sid / len(sents))\n sent_str = \" \".join(sent)\n preds = [(word.i, str(word))\n for word\n in tkw.parser(sent_str)\n if word.tag_.startswith(\"V\")]\n num_of_samples = int(np.ceil(float(len(sent)) / self.sent_maxlen) * self.sent_maxlen)\n pred_list=[]\n for ind, pred in preds:\n cur_sample=self.encode_inputs([self.create_sample(sent, ind)])\n for name in [\"word_inputs\", \"predicate_inputs\", \"postags_inputs\"]:\n sent_samples[name].append(cur_sample[name])\n pred_list.append((ind, pred))\n sents_attr.append((num_of_samples,pred_list,len(sent)))\n for key in sent_samples:\n sent_samples[key]=np.concatenate(sent_samples[key],axis=0)\n print('predict data')\n X = sent_samples\n Y=self.model.predict(X)\n # print(Y[0])\n # print(Y[2])\n res=[]\n p=0\n for attr in sents_attr:\n num_of_samples,pred_list,sent_len=attr\n sample_len=num_of_samples//self.sent_maxlen\n ret=[]\n for pid,(ind, pred) in enumerate(pred_list):\n ret.append(((ind, pred),\n [(self.consolidate_label(label), float(prob))\n for (label, prob) in\n self.transform_output_probs(Y[p+pid*sample_len:p+(pid+1)*sample_len], \n get_prob = True).reshape(num_of_samples,\n 2)[:sent_len]]))\n res.append(ret)\n p+=len(pred_list)*sample_len\n return res","def process_pred_list(pred_list: List) -> List:\n result = []\n for item in pred_list:\n item_replace_special_char = item.replace(\"\\n\", \"\")\n meta_data = item_replace_special_char.split(\":\")\n label = meta_data[0]\n confidence = float(meta_data[1].split(\"\\t\")[0].strip(\" \").strip(\"%\")) / 100\n bbox_info = meta_data[2:]\n bbox = get_bbox(bbox_info)\n result.append([label, confidence, bbox])\n return result","def predict(self, data: pd.DataFrame):\n \n # call pipeline on question and text\n return self._pipeline(question=data.iloc[0].question, context=data.iloc[0].context)","def nlp(self, text):\n # Runs the NLP model on the input.\n doc = self.nlp_model(text)\n\n to = []\n when = []\n body = []\n\n # Group the labels into variables.\n for token in doc:\n if token.dep_ == \"TO\":\n to.append(token.text)\n elif token.dep_ == \"WHEN\":\n when.append(token.text)\n elif token.dep_ == \"BODY\":\n body.append(token.text)\n log.debug(\"%s %s\", token.text, token.dep_)\n\n # Get the time entity from the NLP model.\n time = datetime.now()\n if len(when) == 0:\n time = time + timedelta(seconds=5)\n else:\n time = tc.parse_time(when)\n\n _body = \" \".join(body)\n\n return (to, time, _body)","def process_prediction():\n try:\n input = np.array(request.json, dtype=np.float32)\n prediction = predictor.predict(input).numpy().tolist()\n return jsonify(result=prediction, status=\"Prediction succeeded\")\n except Exception as err:\n return jsonify(result=None, status=f\"Prediction failed: {err}\")","def predict(self, data):\n\t\tres = self.neuralNetworks.inference(self.dataCenter.process_inference_data(data))\n\t\tprint(res)","def predict(self, df):\n # TODO: REMOVE type column\n\n tokenizer = self.__create_tokenizer_from_hub_module()\n label_list = test_other[LABEL_COLUMN].unique().tolist()\n #label_list = [0, 1]\n test_features = self.__create_features(\n df, label_list,\n self.max_seq_len, tokenizer, 'text', 'type'\n )\n\n preds = []\n if type(self.model) == tf.estimator.Estimator:\n # Is trained\n input_fn = input_fn_builder(\n features=test_features,\n seq_length=self.max_seq_len,\n is_training=False,\n drop_remainder=False)\n pred = self.model.predict(input_fn=input_fn)\n for p in pred:\n preds.append(p)\n else:\n # Is loaded from a SavedModel\n # Format inputs\n inpu = {\n 'label_ids': np.array([x.label_id for x in test_features]).reshape(-1,),\n 'input_ids': np.array([x.input_ids for x in test_features]).reshape(-1, self.max_seq_len),\n 'input_mask': np.array([x.input_mask for x in test_features]).reshape(-1, self.max_seq_len),\n 'segment_ids': np.array([x.segment_ids for x in test_features]).reshape(-1, self.max_seq_len)\n }\n preds = self.model(inpu)\n\n return preds","def predict(self, sentences, batch_size=32):\n train_encodings = self.tokenizer(sentences,\n truncation=True,\n padding=True,\n max_length=500)\n\n train_dataset = TextDataset(train_encodings)\n\n loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)\n collect_outputs = []\n\n with torch.no_grad():\n for batch in loader:\n input_ids = batch['input_ids']\n attention_mask = batch['attention_mask']\n\n outputs = self.model(input_ids, attention_mask=attention_mask)\n collect_outputs.extend(torch.argmax(outputs[\"logits\"], axis=1).cpu().numpy().tolist())\n\n return [self.emotion_map[k] for k in collect_outputs]","def predict(self, text, threshold=.0):\n if not self.k_model or not self.w2v_model:\n raise RuntimeError(\"Model not in memory, please load it train new model\")\n start_at = time.time()\n x_test = keras.preprocessing.sequence.pad_sequences(\n self.tokenizer.texts_to_sequences(gensim.utils.simple_preprocess(text)),\n maxlen=self.k_max_sequence_len)\n # Predict\n confidences = self.k_model.predict(x_test)[0]\n # Get mex prediction\n idx = np.argmax(confidences)\n elapsed_time = time.time() - start_at\n if float(confidences[idx]) > threshold:\n return {\"label\": self.label_encoder.classes_[idx], \"confidence\": float(confidences[idx]),\n \"elapsed_time\": elapsed_time}\n return {\"label\": \"__OTHER__\", \"confidence\": float(confidences[idx]), \"elapsed_time\": elapsed_time}","def get_predictions():\n\n print(\"OK1\");\n print(\"OK2\");\n return;","def test_simulated_module_annotation_predict(simulated_ann_predict_vcf,\n simulated_ann_predict_csv):\n annotate(SIMULATED_VCF, TEST_VCF, predict=True, csv=True)\n with open(TEST_VCF) as out:\n assert simulated_ann_predict_vcf.read() == out.read()\n with open(TEST_CSV) as out:\n assert simulated_ann_predict_csv.read() == out.read()","def postprocess_for_inference(self,\n prediction: Dict[str, torch.Tensor],\n *args, **kwargs,\n ) -> Dict[str, torch.Tensor]:\n return {\"pred_seg\": self.logits_convert_fn(prediction[\"seg_logits\"])}","def postprocess_model_outputs(self, predictions, expected):\n\n predictions = {k: t.numpy() for k, t in predictions.items()}\n\n return predictions, expected"],"string":"[\n \"def _parse_raw_predictions(self, raw_predictions):\\n result = []\\n for line in raw_predictions.split(\\\"\\\\n\\\"):\\n line_parts = line.split(\\\"|\\\")\\n type = line_parts[0]\\n assert type.lstrip(\\\"*\\\") in (\\n \\\"FP\\\", \\\"TP\\\", \\\"TN\\\", \\\"FN\\\"), 'Expected {} to be in (FP, TP, TN, FN), {}'.format(line[0], line)\\n\\n docid = line_parts[1]\\n start_end = line_parts[2]\\n entity_name = line_parts[3]\\n alt_gene = None\\n alt_gene_start_end = None\\n\\n if type.lstrip(\\\"*\\\") == \\\"TP\\\":\\n start_end = line_parts[3]\\n entity_name = line_parts[2]\\n alt_gene = line_parts[4]\\n alt_gene_start_end = line_parts[5]\\n\\n result.append({\\n \\\"type\\\": type,\\n \\\"docid\\\": docid,\\n \\\"start_end\\\": start_end,\\n \\\"entity_name\\\": entity_name,\\n \\\"alt_gene\\\": alt_gene,\\n \\\"alt_gene_start_end\\\": alt_gene_start_end,\\n })\\n return result\",\n \"def process(self, message, **kwargs):\\r\\n # type: (Message, **Any) -> None\\r\\n\\r\\n start = time.time()\\r\\n intent = {\\\"name\\\": None, \\\"confidence\\\": 0.0}\\r\\n intent_ranking = []\\r\\n\\r\\n if self.predictor is None:\\r\\n logger.error(\\\"There is no trained tf.session: \\\"\\r\\n \\\"component is either not trained or \\\"\\r\\n \\\"didn't receive enough training data\\\")\\r\\n\\r\\n else:\\r\\n\\r\\n X = message.get(\\\"text_features\\\").tolist()\\r\\n examples = []\\r\\n feature = {}\\r\\n # convert input x to tf.feature with float feature spec\\r\\n feature['a_in'] = tf.train.Feature(float_list=tf.train.FloatList(value=X))\\r\\n # build tf.example for prediction\\r\\n example = tf.train.Example(\\r\\n features=tf.train.Features(\\r\\n feature=feature\\r\\n )\\r\\n )\\r\\n examples.append(example.SerializeToString())\\r\\n\\r\\n # Make predictions.\\r\\n logger.info(\\\"estimator prediction finished\\\")\\r\\n result_dict = self.predictor({'inputs': examples})\\r\\n result_score_list = result_dict['scores'][0]\\r\\n max_score = np.max(result_dict['scores'][0])\\r\\n max_index = np.argmax(result_dict['scores'][0])\\r\\n\\r\\n\\r\\n # if X contains all zeros do not predict some label\\r\\n\\r\\n\\r\\n\\r\\n if len(X)>0:\\r\\n intent = {\\r\\n \\\"name\\\": self.inv_intent_dict[max_index], \\\"confidence\\\": float(max_score)\\r\\n }\\r\\n ranking = result_score_list[:len(result_score_list)]\\r\\n intent_ranking = [{\\\"name\\\": self.inv_intent_dict[intent_idx],\\r\\n \\\"confidence\\\": float(score)}\\r\\n for intent_idx, score in enumerate(ranking)]\\r\\n\\r\\n\\r\\n intent_ranking = sorted(intent_ranking, key=lambda s: s['confidence'], reverse=True)\\r\\n\\r\\n message.set(\\\"intent\\\", intent, add_to_output=True)\\r\\n message.set(\\\"intent_ranking\\\", intent_ranking, add_to_output=True)\\r\\n end = time.time()\\r\\n logger.info(\\\"bert intent classifier time cost %.3f s\\\" % (end - start))\",\n \"def parse_prediction(self, predictions):\\n\\t\\tusers = list()\\n\\t\\tprint(predictions)\\n\\t\\tfor prediction in predictions:\\n\\t\\t\\tfor email in prediction:\\n\\t\\t\\t\\tusers.append(email)\\n\\t\\t\\t\\t\\n\\t\\treturn users\",\n \"def prediction(name=None, message=''):\",\n \"def process(self, message, **kwargs):\\n if self.classifier is None:\\n self.train()\\n\\n if message.get(\\\"text\\\") is not None:\\n sid = SentimentIntensityAnalyzer()\\n res = sid.polarity_scores(message.get(\\\"text\\\"))\\n key, value = max(res.items(), key=lambda x: x[1])\\n\\n if key == \\\"pos\\\":\\n key = \\\"Positive\\\"\\n elif key == \\\"neg\\\":\\n key = \\\"Negative\\\"\\n else:\\n key = \\\"Neutral\\\"\\n\\n custom_tokens = self.remove_noise(word_tokenize(message.get(\\\"text\\\")))\\n t = self.classifier.prob_classify(dict([token, True] for token in custom_tokens))\\n\\n sentiment = 'Positive' if t.prob('Positive') > t.prob('Negative') else 'Negative'\\n confidence = max(t.prob('Positive'), t.prob('Negative'))\\n\\n found, entry = self.manager.getMovieName(message.get(\\\"text\\\"))\\n movie = str(entry['original_title'].item())\\n \\n genre_entry, aux_found_genre = self.manager.fuzzy_find_genre(message.get(\\\"text\\\"), with_ratio=True)[0]\\n genre = genre_entry\\n \\n\\n if len(message.get(\\\"text\\\")) > 20:\\n entity = self.convert_to_rasa(sentiment, confidence, name=\\\"our_sentiment_extractor\\\")\\n else:\\n entity = self.convert_to_rasa(key, value, name=\\\"builtin_sentiment_extractor\\\")\\n\\n message.set(\\\"sentiment\\\", [entity], add_to_output=True)\\n\\n entity = self.convert_movie_to_rasa(movie, found)\\n message.set(\\\"movies\\\", [entity], add_to_output=True)\\n\\n if message.get(\\\"text\\\").strip() == \\\"no\\\":\\n found_genre = False\\n else:\\n found_genre = True if aux_found_genre > 80 else False\\n\\n entity = self.convert_movie_to_rasa(genre, found_genre, entity=\\\"genres_detected\\\")\\n print(entity)\\n message.set(\\\"genres\\\", [entity], add_to_output=True)\",\n \"def _postprocess(self, preds):\\n ntok = preds.pop(\\\"ntok\\\")\\n ids = preds.pop(\\\"input_ids\\\")[:ntok]\\n preds[\\\"tokens\\\"] = self._detokenize(ids)\\n\\n # Decode predicted top-k tokens.\\n # token_topk_preds will be a List[List[(word, prob)]]\\n # Initialize prediction for 0th token as N/A.\\n token_topk_preds = [[(\\\"N/A\\\", 1.)]]\\n pred_ids = preds.pop(\\\"top_k_indices\\\")[:ntok] # <int>[num_tokens, k]\\n pred_probs = preds.pop(\\\"top_k_probs\\\")[:ntok] # <float32>[num_tokens, k]\\n for token_pred_ids, token_pred_probs in zip(pred_ids, pred_probs):\\n token_pred_words = self._detokenize(token_pred_ids)\\n token_topk_preds.append(list(zip(token_pred_words, token_pred_probs)))\\n preds[\\\"pred_tokens\\\"] = token_topk_preds\\n\\n # Process attention.\\n for key in preds:\\n if not re.match(r\\\"layer_(\\\\d+)/attention\\\", key):\\n continue\\n # Select only real tokens, since most of this matrix is padding.\\n # <float32>[num_heads, max_seq_length, max_seq_length]\\n # -> <float32>[num_heads, num_tokens, num_tokens]\\n preds[key] = preds[key][:, :ntok, :ntok].transpose((0, 2, 1))\\n # Make a copy of this array to avoid memory leaks, since NumPy otherwise\\n # keeps a pointer around that prevents the source array from being GCed.\\n preds[key] = preds[key].copy()\\n\\n return preds\",\n \"def process(self, message: \\\"Message\\\", **kwargs: Any) -> None:\\n\\n label, label_ranking = self.predict_label(message)\\n\\n message.set(\\\"intent\\\", label, add_to_output=True)\\n message.set(\\\"intent_ranking\\\", label_ranking, add_to_output=True)\",\n \"def test_service_api_predict_multiple_raw_classified(service_app):\\n response = service_app.post('/predict',\\n data=json.dumps(data),\\n content_type='application/json')\\n response_data = json.loads(response.data)\\n assert response.headers['Content-Type'] == 'application/json'\\n assert response.status_code == 200\\n assert response_data['message'] == 'Records successfully classified'\\n assert len(response_data['prediction'].keys()) == 102\\n assert response_data['prediction']['business_outcome'] == [4, 5]\\n assert response_data['prediction']['phat'] == [0.8228085289874678, 0.753958838418463]\\n assert all(len(value) == 2 for value in response_data['prediction'].values())\",\n \"def postprocess_relation_predictions(predictions):\\n \\n output = {}\\n word_pairs = [wp.split(\\\" -> \\\") for wp in predictions.keys()]\\n for wp in word_pairs:\\n fp = \\\" -> \\\".join([wp[0], wp[1]])\\n bp = \\\" -> \\\".join([wp[1], wp[0]])\\n \\n if predictions[fp][\\\"relations\\\"][0] == predictions[bp][\\\"relations\\\"][0]:\\n if predictions[fp][\\\"confidence\\\"][0] > predictions[bp][\\\"confidence\\\"][0]:\\n output[fp] = predictions[fp]\\n else:\\n output[bp] = predictions[bp]\\n else:\\n output[fp] = predictions[fp]\\n output[bp] = predictions[bp]\\n return output\",\n \"def test_service_api_predict_single_raw_classified(service_app):\\n response = service_app.post('/predict',\\n data=json.dumps(data[1:2]),\\n content_type='application/json')\\n\\n response_data = json.loads(response.data)\\n assert response.headers['Content-Type'] == 'application/json'\\n assert response.status_code == 200\\n assert response_data['message'] == 'Records successfully classified'\\n assert len(response_data['prediction'].keys()) == 102\\n assert response_data['prediction']['business_outcome'] == [4]\\n assert response_data['prediction']['phat'] == [0.8228085289874678]\\n assert all(len(value) == 1 for value in response_data['prediction'].values())\",\n \"def process_classified_message(self, message, classification): \\n pass\",\n \"def predict(request):\\n request_json = request.get_json()\\n if request_json and 'review_body' in request_json:\\n content = request_json['review_body'] # TODO add review_summary\\n prediction = get_prediction(\\n content, 'projects/207895552307/locations/us-central1/models/TCN5004391989450375168')\\n classifications = []\\n return MessageToJson(prediction)\\n else:\\n return f'ERROR: Missing review_body!'\",\n \"def postprocess(self, data):\\n all_predictions, all_nbest_json, scores_diff_json = predictions(self._dev_dataset,\\n data,\\n self._tokenizer)\\n\\n if len(all_nbest_json) == 0 or len(all_nbest_json[0]) == 0:\\n return [{'predicted': '',\\n 'confidence': 0}]\\n\\n return [{'predicted': all_nbest_json[0][0]['text'],\\n 'confidence': all_nbest_json[0][0]['probability']}]\",\n \"def validate(self, validate_data):\\n with open(validate_data, 'r') as validate_data:\\n true_positive = 0\\n true_negative = 0\\n false_positive = 0\\n false_negative = 0\\n result = {}\\n for type in self.label_type_map:\\n result[type] = []\\n while True:\\n tokens = validate_data.readline().split()\\n pos = validate_data.readline().split()\\n labels = validate_data.readline().split()\\n if not tokens or not pos or not labels:\\n break\\n # Classify all named entities in a sentence 85\\n curr_results = self.viterbi(tokens)\\n for i in range(0, len(labels)):\\n if curr_results[i] != 'O':\\n if labels[i] == 'O':\\n false_positive += 1 # Not 'O', but should be 'O'\\n else:\\n if self.label_type_map[labels[i]] == self.label_type_map[curr_results[i]]:\\n true_positive += 1 # Correct prediction\\n else:\\n if labels[i] == 'O':\\n true_negative += 1 # Correct prediction of 'O'\\n else:\\n false_negative += 1 # Predicted 'O', not 'O'\\n # Calculate precision - TP / (TP + FP)\\n precision = float(true_positive) / float(true_positive + false_positive)\\n # Calculate recall - TP / (TP + FN)\\n recall = float(true_positive) / float(true_positive + false_negative)\\n # Calculate F-Score - 2 * P * R / (P + R)\\n f_score = float(2*precision * recall) / float(precision + recall)\\n print \\\"Precision: \\\" + str(precision)\\n print \\\"Recall: \\\" + str(recall)\\n print \\\"F-score: \\\" + str(f_score)\",\n \"def rank_pre_extract(self, mention_data, predictions):\\n mdata = pd.DataFrame(mention_data)\\n\\n\\n\\n\\n pass\",\n \"def model_evaluate(query):\\n engine = create_engine('sqlite:///data/DisasterResponse.db')\\n df = pd.read_sql_table('Messages', engine)\\n\\n model = joblib.load(\\\"models/model.pkl\\\")\\n \\n classification_labels = model.predict([query])[0]\\n classification_results = dict(zip(df.columns[4:], classification_labels))\\n\\n return classification_labels, classification_results\",\n \"def _process_prediction(\\n prediction: Mapping[Text, np.ndarray],\\n text_examples: Mapping[Text, eval_utils.OpenKpTextExample],\\n writer_tfrecord,\\n writer_jsonl,\\n metrics: Optional[Mapping[int, _MetricAverager]] = None) -> None:\\n # [kp_max_length, long_max_length] shape.\\n ngram_logits = prediction['ngram_logits']\\n\\n features = collections.OrderedDict()\\n features['ngram_logits'] = input_utils.create_float_feature(\\n ngram_logits.flatten())\\n\\n position_predictions = eval_utils.logits_to_predictions(\\n ngram_logits, max_predictions=FLAGS.max_position_predictions)\\n # Sort predictions for convenience.\\n position_predictions.sort(key=lambda x: x.logit, reverse=True)\\n features['top_pos_logit'] = input_utils.create_float_feature(\\n x.logit for x in position_predictions)\\n features['top_pos_start_idx'] = input_utils.create_int_feature(\\n x.start_idx for x in position_predictions)\\n features['top_pos_phrase_len'] = input_utils.create_int_feature(\\n x.phrase_len for x in position_predictions)\\n\\n url = ''.join(chr(x) for x in prediction['url_code_points'] if x != -1)\\n features['url'] = input_utils.create_bytes_feature([url])\\n\\n if url in text_examples:\\n text_example = text_examples[url]\\n kp_predictions = text_example.get_key_phrase_predictions(\\n position_predictions, max_predictions=FLAGS.max_kp_predictions)\\n if len(kp_predictions) < FLAGS.max_kp_predictions:\\n tf.logging.warn(f'Made fewer than `max_kp_predictions` for URL: {url}')\\n writer_jsonl.write(\\n json.dumps({\\n 'url': url,\\n 'KeyPhrases': [[kp] for kp in kp_predictions]\\n }) + '\\\\n')\\n\\n features['kp_predictions'] = input_utils.create_bytes_feature(\\n kp_predictions)\\n\\n if metrics is not None:\\n precision, recall, f1 = text_example.get_score_full(kp_predictions)\\n for i in (1, 3, 5):\\n p = precision[i - 1]\\n r = recall[i - 1]\\n f = f1[i - 1]\\n features[f'p_at_{i}'] = input_utils.create_float_feature([p])\\n features[f'r_at_{i}'] = input_utils.create_float_feature([r])\\n features[f'f1_at_{i}'] = input_utils.create_float_feature([f])\\n metrics[i].add_example(precision=p, recall=r, f1=f)\\n else:\\n tf.logging.error(f'No text example found for URL: {url}')\\n\\n writer_tfrecord.write(\\n tf.train.Example(features=tf.train.Features(\\n feature=features)).SerializeToString())\",\n \"def tag2predictions(ote_tag_sequence, ts_tag_sequence):\\n n_tag = len(ote_tag_sequence)\\n # opinion target sequence and targeted sentiment sequence\\n ot_sequence, ts_sequence = [], []\\n beg, end = -1, -1\\n for i in range(n_tag):\\n tag = ote_tag_sequence[i]\\n if tag == 'S':\\n ot_sequence.append((i, i))\\n elif tag == 'B':\\n beg = i\\n elif tag == 'E':\\n end = i\\n if end > beg and beg != -1:\\n ot_sequence.append((beg, end))\\n beg, end = -1, -1\\n sentiments = []\\n beg, end = -1, -1\\n for i in range(n_tag):\\n ts_tag = ts_tag_sequence[i]\\n # current position and sentiment\\n eles = ts_tag.split('-')\\n if len(eles) == 2:\\n pos, sentiment = eles\\n else:\\n pos, sentiment = 'O', 'O'\\n if sentiment != 'O':\\n # current word is a subjective word\\n sentiments.append(sentiment)\\n if pos == 'S':\\n # singleton\\n ts_sequence.append((i, i, sentiments[0]))\\n sentiments = []\\n elif pos == 'B':\\n beg = i\\n elif pos == 'E':\\n end = i\\n # schema1: only the consistent sentiment tags are accepted\\n # that is, all of the sentiment tags are the same\\n if end > beg > -1 and len(set(sentiments)) == 1:\\n ts_sequence.append((beg, end, sentiment))\\n sentiments = []\\n beg, end = -1, -1\\n\\n # schema2: only consider the sentiment at the beginning of the aspect span\\n # if end > beg > -1:\\n # ts_sequence.append((beg, end, sentiments[0]))\\n # sentiments = []\\n # beg, end = -1, -1\\n return ot_sequence, ts_sequence\",\n \"def parse(self, message):\\n resp = json.loads((self.send_api_request(message)).decode('utf-8'))\\n\\n nlu_response = NLUResponse()\\n nlu_response.text = message\\n intent_schema = IntentSchema()\\n if resp[\\\"result\\\"][\\\"metadata\\\"]:\\n intent_schema.name = resp[\\\"result\\\"][\\\"metadata\\\"][\\\"intentName\\\"]\\n intent_schema.confidence = resp[\\\"result\\\"][\\\"score\\\"]\\n else: # fallback if no intent is given by the nlu\\n intent_schema.name = \\\"greet\\\"\\n intent_schema.confidence = 0.0\\n nlu_response.intent = intent_schema\\n print(\\\"Recognized Intent by Dialogflow {}\\\".format(intent_schema.name ))\\n\\n pp = pprint.PrettyPrinter(indent=4)\\n #pp.pprint(resp)\\n\\n try:\\n nlu_response.entities = []\\n entities = resp[\\\"result\\\"][\\\"parameters\\\"]\\n resolved_query = resp[\\\"result\\\"][\\\"resolvedQuery\\\"]\\n\\n for key, value in entities.items():\\n if value:\\n entity_schema = EntitiesSchema()\\n entity_schema.start = resolved_query.find(value)\\n entity_schema.end = resolved_query.find(value) + len(value)\\n entity_schema.entity = key\\n entity_schema.value = value\\n nlu_response.entities.append(entity_schema)\\n #print(\\\"Key: {}, Value: {}\\\".format(key, value))\\n except Exception as err:\\n logging.warning('No Entites extracted {}'.format(err))\\n\\n schema = RasaNLUSchema()\\n data, error = schema.dump(nlu_response)\\n\\n return data\",\n \"def insult_me(\\n message : str \\n ):\\n \\n #load model\\n model = Detoxify('original')\\n \\n #predict toxicity\\n results = model.predict(message)\\n \\n #echo results\\n click.echo(pd.Series(results))\",\n \"def post(self):\\n result = {'status': 'error'}\\n\\n args = input_parser.parse_args()\\n input_data = args['image'].read()\\n image = self.model_wrapper._read_image(input_data)\\n preds = self.model_wrapper._predict(image)\\n\\n # Modify this code if the schema is changed\\n label_preds = [{'label_id': p[0], 'label': p[1], 'probability': p[2]} for p in [x for x in preds]]\\n result['predictions'] = label_preds\\n result['status'] = 'ok'\\n\\n return result\",\n \"def predict(self, sentences: List[str]) -> List[Dict[str, Any]]:\\n inputs, offset_mapping = self.tokenize(sentences=sentences)\\n outputs = self.model(**inputs)\\n logits = outputs[\\\"logits\\\"]\\n predicted_intents = self.convert_intent_logits(intent_logits=logits[1])\\n predicted_entities = self.convert_entities_logits(entities_logits=logits[0], offset_mapping=offset_mapping)\\n predicted_outputs = []\\n for sentence, intent_sentence, entities_sentence in zip(sentences, predicted_intents, predicted_entities):\\n predicted_outputs.append({})\\n predicted_outputs[-1].update(intent_sentence)\\n predicted_outputs[-1].update({\\\"entities\\\": entities_sentence})\\n for entity in predicted_outputs[-1][\\\"entities\\\"]:\\n entity[\\\"text\\\"] = sentence[entity[\\\"start\\\"]: entity[\\\"end\\\"]]\\n\\n if self.synonym_dict.get(entity[\\\"text\\\"], None):\\n entity[\\\"original_text\\\"] = entity[\\\"text\\\"]\\n entity[\\\"text\\\"] = self.synonym_dict[entity[\\\"text\\\"]]\\n\\n predicted_outputs[-1][\\\"text\\\"] = sentence\\n\\n return predicted_outputs\",\n \"def make_text_predictions(self, text, preprocessor):\\n text = preprocessor.preprocess(text)\\n y_pred = self.sgd_pipeline.predict_proba([text])\\n return y_pred\",\n \"def update_predictions(data):\\n # TODO: Priority 1 - update predictions with inference results\\n # TODO: Understand from a research team exactly what the data is going to look like\\n trackID = data[0]\\n prediction = data[1]\\n confidence = data[2]\\n to_Insert_Array = [trackID, prediction, confidence]\\n OutPut_Data[trackID] = to_Insert_Array\",\n \"def make_predictions(model, tokenizer, paragraphs):\\n \\n prediction_dataloader = bert_preprocess(paragraphs, tokenizer) \\n predictions = eval_cpu(prediction_dataloader, model) \\n malware_ids = get_pred_ids(predictions) \\n return malware_ids\",\n \"def _parse_fit_and_predict_result(result):\\n if len(result) > 1 and result[1] and not isinstance(result[1], str):\\n # Scores object does not resemble a label prediction (always string)\\n y = result[0]\\n scores = result[1]\\n else:\\n y = result\\n scores = None\\n return y, scores\",\n \"def post(self):\\n # use parser and find the user's query\\n args = parser.parse_args()\\n title = args['title']\\n author = model.encode_author(args['author'])\\n text = args['text']\\n\\n X = model.vector_and_stack(title=title, text=text, author=author)\\n\\n prediction = model.predict(X)\\n\\n # Output either 'Negative' or 'Positive' along with the score\\n if round(prediction[0]) == 0:\\n pred_text = 'Reliable News'\\n else:\\n pred_text = 'Unreliable News'\\n\\n # round the predict proba value and set to new variable\\n confidence = round(prediction[0], 3)\\n\\n # create JSON object\\n output = {'prediction': pred_text, 'fake_rate': confidence}\\n\\n return output, 200\",\n \"def predict(self):\\n\\n global pos\\n pos = (pos + 1) % len(ue_data) # iterate through entire list one by one in cycle manner and will be updated when live feed will be coming through KPIMON to influxDB\\n sample = ue_data[pos]\\n ue_df = pd.DataFrame([sample], columns=db.data.columns)\\n val = predict_anomaly(self, ue_df)\\n if (val is not None) and (len(val) > 2):\\n msg_to_ts(self, val)\",\n \"def postprocess(self, prediction_dict, **params):\\r\\n pass\",\n \"def _preprocess(self):\\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\\n # self._get_frequent_features()\\n # self._compactness_pruning()\\n # self._redundancy_pruning()\\n # self._get_features()\\n self._extract_opinions()\",\n \"async def predict(params: predict_text):\\n tweet = params.text\\n prediction = tf_model.predict(tweet)\\n prediction_db = PredictionModel(\\n text=tweet,\\n label=prediction[\\\"label\\\"],\\n score=prediction[\\\"score\\\"],\\n time=prediction[\\\"elapsed_time\\\"],\\n )\\n db.session.add(prediction_db)\\n db.session.commit()\\n return prediction\",\n \"def test_service_api_predict_single_raw_no_classification(service_app):\\n response = service_app.post('/predict',\\n data=json.dumps(data[:1]),\\n content_type='application/json')\\n assert response.headers['Content-Type'] == 'application/json'\\n assert response.status_code == 200\\n assert json.loads(response.data) == {'message': 'Records does not meet classification requirements'}\",\n \"def label_7m(predictor, zhibo7m):\\n for item_ in zhibo7m.find():\\n try:\\n live_texts_ = item_[\\\"content\\\"][\\\"textFeed\\\"]\\n except Exception as e:\\n zhibo7m.delete_one({\\\"_id\\\": item_['_id']})\\n print(\\\"delete error id: {}\\\".format(item_[\\\"_id\\\"]))\\n print(e)\\n for l_index_, l_item_ in enumerate(live_texts_):\\n l_item_[\\\"p_label\\\"] = predictor.predict(l_item_[\\\"msg\\\"])[0]\\n live_texts_[l_index_] = l_item_\\n # print(l_item_)\\n zhibo7m.update_one({\\\"_id\\\": item_['_id']}, {\\\"$set\\\": {\\\"textFeed\\\": live_texts_}})\",\n \"def predictFailures (self) :\\n \\n while self.traceData :\\n\\n if self.traceData [0] == self.traceType :\\n\\n self.totalEvents += 1\\n\\n if random.random () < self.recall :\\n\\n self.predictedEvents += 1\\n self.pTraceHandle.write (\\\"%d\\\\t%d\\\\t%d\\\\n\\\" % (self.traceData [0], self.traceData [1], self.traceData [2]))\\n self.correctPredictions += 1\\n self.totalPredictions += 1\\n\\n self.readNextTraceLine (self.fTraceHandle)\\n\\n if self.precision < 1 :\\n\\n wrongPredictions = int ((float (self.correctPredictions * (1 - self.precision)) / self.precision) + 0.5)\\n \\n interval = int ((self.endTime - self.startTime) / wrongPredictions)\\n start = self.startTime\\n end = start + interval\\n\\n for i in range (wrongPredictions) :\\n \\n self.pTraceHandle.write (\\\"%d\\\\t%d\\\\t%d\\\\n\\\" % (0, random.randint (0, self.totalNodes - 1), \\\\\\n random.randint (start, end - 1)))\\n self.totalPredictions += 1\\n start = end\\n end = start + interval\",\n \"def validate_and_insert_data(self):\\r\\n try:\\r\\n self.logger.log(self.log_file, 'Validating the prediction data!')\\r\\n # Delete good and bad data folders in case last run was\\r\\n # unsuccessful and the folders were not deleted\\r\\n self.data_validation.delete_existing_good_data_folder()\\r\\n self.data_validation.delete_existing_bad_data_folder()\\r\\n # Extract values from the prediction schema\\r\\n length_of_date_stamp_in_file, length_of_time_stamp_in_file, number_of_columns = \\\\\\r\\n self.data_validation.values_from_schema()\\r\\n # Generate a regex pattern to validate the file names\\r\\n regex = self.data_validation.generate_file_name_regex(length_of_date_stamp_in_file,\\r\\n length_of_time_stamp_in_file)\\r\\n # Validate file names of the prediction data\\r\\n self.data_validation.validate_file_names(regex)\\r\\n # Validate number of columns in the prediction data\\r\\n self.data_validation.validate_number_of_columns(number_of_columns)\\r\\n # Validate if any column has all of its values missing\\r\\n self.data_validation.validate_missing_values_in_columns()\\r\\n self.logger.log(self.log_file, 'Prediction data validated successfully!')\\r\\n\\r\\n self.logger.log(self.log_file, 'Transforming the prediction data!')\\r\\n # Replace missing values with 'NULL'\\r\\n self.data_transformation.replace_missing_values_with_null()\\r\\n # Format the 'Wafer' column\\r\\n self.data_transformation.format_wafer_column()\\r\\n self.logger.log(self.log_file, 'Prediction data transformed successfully!')\\r\\n\\r\\n self.logger.log(self.log_file, 'Inserting the prediction data!')\\r\\n # Insert the good prediction data into a MongoDB Atlas database\\r\\n self.data_insertion.insert_good_data_into_collection(self.collection_name, 'Wafer')\\r\\n # Delete the good data folder after loading its data into the database\\r\\n self.data_validation.delete_existing_good_data_folder()\\r\\n # Export the data from the database to a .CSV file\\r\\n self.data_insertion.copy_data_from_collection_to_csv_file(self.collection_name)\\r\\n # Move the remaining bad prediction data to an archive\\r\\n self.data_validation.archive_bad_prediction_data()\\r\\n self.logger.log(self.log_file, 'Prediction data inserted successfully!')\\r\\n return None\\r\\n except Exception as e:\\r\\n self.logger.log(self.log_file, 'Unexpected Error: %s' % e)\\r\\n raise e\",\n \"def predict(prediction_request):\\n\\n feature_type = prediction_request['feature_type']\\n\\n if feature_type not in [MFCC, C_CENS, C_CQT, C_STFT, MEL]:\\n raise Exception('Invalid Feature type for prediction: {}'.format(feature_type))\\n\\n model = model_from_feature[feature_type]\\n\\n prediction = np.argmax(model.predict([np.reshape(prediction_request['content'], (1, *prediction_request['content'].shape, 1))]), axis=1)[0]\\n\\n predicted_class = \\\"COPD\\\" if prediction == 0 else \\\"non-COPD\\\"\\n\\n print(\\\"Prediction for type {} = {}\\\".format(feature_type, predicted_class))\\n\\n socket.send_pyobj({\\n 'model': feature_type,\\n 'class': predicted_class\\n })\",\n \"def classify(self, documents):\\n predictions = []\\n for doc in documents:\\n\\n score_sod = math.log(self.priorSOD)\\n score_pop = math.log(self.priorPOP)\\n for term in doc.tokens:\\n if term in self.cond_prob_sod.keys():\\n score_sod += math.log(self.cond_prob_sod[term])\\n if term in self.cond_prob_pop.keys():\\n score_pop += math.log(self.cond_prob_pop[term])\\n if(score_pop >= score_sod): #defaults to ham if score = even \\n predictions.append('pop')\\n else:\\n predictions.append('sod')\\n \\n return predictions \\n pass\",\n \"def evaluate(parameters, f_eval, raw_sentences, parsed_sentences,\\n id_to_tag, input_file_path):\\n predictions = []\\n for raw_sentence, data in zip(raw_sentences, parsed_sentences):\\n input = create_input(data, parameters, False)\\n if parameters['crf']:\\n y_preds = np.array(f_eval(*input))[1:-1]\\n else:\\n y_preds = f_eval(*input).argmax(axis=1)\\n p_tags = [id_to_tag[y_pred] for y_pred in y_preds]\\n\\n if parameters['tag_scheme'] == 'iobes':\\n p_tags = iobes_iob(p_tags)\\n\\n for i, y_pred in enumerate(y_preds):\\n new_line = \\\"%s %s\\\" % (raw_sentence[i][0], p_tags[i])\\n predictions.append(new_line)\\n predictions.append(\\\"\\\")\\n output_path = os.path.join(opts.output, os.path.basename(input_file_path[:-4] + \\\"_Tagged.txt\\\"))\\n with codecs.open(output_path, 'w', 'utf8') as f:\\n f.write(\\\"\\\\n\\\".join(predictions))\",\n \"def show_predictions(db_filename, predictions):\\n\\n db = FeverDocDB(db_filename)\\n\\n for line in predictions:\\n\\n if line['label'].upper() != \\\"NOT ENOUGH INFO\\\":\\n macro_rec = evidence_macro_recall(line)\\n if macro_rec[0] == 1.0:\\n continue\\n pages = set([page for page, _ in line['predicted_evidence']])\\n evidence_set = set([(page, line_num) for page, line_num in line['predicted_evidence']])\\n p_lines = []\\n for page in pages:\\n doc_lines = db.get_doc_lines(page)\\n if not doc_lines:\\n # print(page)\\n continue\\n doc_lines = [doc_line.split(\\\"\\\\t\\\")[1] if len(doc_line.split(\\\"\\\\t\\\")[1]) > 1 else \\\"\\\" for doc_line in\\n doc_lines.split(\\\"\\\\n\\\")]\\n p_lines.extend(zip(doc_lines, [page] * len(doc_lines), range(len(doc_lines))))\\n\\n print(\\\"claim: {}\\\".format(line['claim']))\\n print(evidence_set)\\n count = 0\\n for doc_line in p_lines:\\n if (doc_line[1], doc_line[2]) in evidence_set:\\n print(\\\"the {}st evidence: {}\\\".format(count, doc_line[0]))\\n count += 1\",\n \"def _parse_predict_data(self, data):\\n image, labels = self._parse_eval_data(data)\\n return {\\n 'images': image,\\n 'labels': labels\\n }\",\n \"def model(msg):\\n url = 'https://southcentralus.api.cognitive.microsoft.com/customvision/v3.0/Prediction/\\\\\\n eff56ac8-0f36-41d9-93a9-da19396b0f30/detect/iterations/Iteration2_ppl_focus/image'\\n headers = {\\n 'Prediction-Key': os.getenv('AZURE_VIS_KEY'),\\n 'Content-Type': 'application/octet-stream'\\n }\\n r = requests.post(url=url, headers=headers, data=msg['img'])\\n predictions = r.json()\\n print('Number of object predictions: {}'.format(\\n len(predictions['predictions'])))\\n print('Frame Number:', msg['frame_num'],\\n 'Image Dimensions:', np.array(Image.open(BytesIO(msg['img']))).shape)\\n Coord_matrix = Bbox(predictions)\\n return Coord_matrix, len(predictions['predictions'])\",\n \"def predict(comment):\\n from allennlp.models.archival import load_archive\\n from allennlp.predictors.predictor import Predictor\\n from wongnai.wongnai_reader import WongnaiDatasetReader\\n from wongnai.wongnai_classifier import WongnaiCommentClassifier\\n from wongnai.wongnai_predictor import WongnaiCommentPredictor\\n from pythainlp import word_tokenize\\n\\n archive = load_archive('model.tar.gz')\\n wongnai_predictor = Predictor.from_archive(archive, 'wongnai_predictor')\\n prediction = wongnai_predictor.predict_json({\\\"comment\\\": word_tokenize(comment)})\\n print(prediction)\",\n \"def parse_predictions(predicted_boxes, sem_cls_probs, objectness_probs, point_cloud, config_dict):\\n\\n sem_cls_probs = sem_cls_probs.detach().cpu().numpy() # B,num_proposal,10\\n pred_sem_cls_prob = np.max(sem_cls_probs, -1) # B,num_proposal\\n pred_sem_cls = np.argmax(sem_cls_probs, -1)\\n obj_prob = objectness_probs.detach().cpu().numpy()\\n\\n pred_corners_3d_upright_camera = predicted_boxes.detach().cpu().numpy()\\n\\n K = pred_corners_3d_upright_camera.shape[1] # K==num_proposal\\n bsize = pred_corners_3d_upright_camera.shape[0]\\n nonempty_box_mask = np.ones((bsize, K))\\n\\n if config_dict[\\\"remove_empty_box\\\"]:\\n # -------------------------------------\\n # Remove predicted boxes without any point within them..\\n batch_pc = point_cloud.cpu().numpy()[:, :, 0:3] # B,N,3\\n for i in range(bsize):\\n pc = batch_pc[i, :, :] # (N,3)\\n for j in range(K):\\n box3d = pred_corners_3d_upright_camera[i, j, :, :] # (8,3)\\n box3d = flip_axis_to_depth(box3d)\\n pc_in_box, inds = extract_pc_in_box3d(pc, box3d)\\n if len(pc_in_box) < 5:\\n nonempty_box_mask[i, j] = 0\\n if nonempty_box_mask[i].sum() == 0:\\n nonempty_box_mask[i, obj_prob[i].argmax()] = 1\\n # -------------------------------------\\n\\n if \\\"no_nms\\\" in config_dict and config_dict[\\\"no_nms\\\"]:\\n # pred_mask = np.ones((bsize, K))\\n pred_mask = nonempty_box_mask\\n elif not config_dict[\\\"use_3d_nms\\\"]:\\n # ---------- NMS input: pred_with_prob in (B,K,7) -----------\\n pred_mask = np.zeros((bsize, K))\\n for i in range(bsize):\\n boxes_2d_with_prob = np.zeros((K, 5))\\n for j in range(K):\\n boxes_2d_with_prob[j, 0] = np.min(pred_corners_3d_upright_camera[i, j, :, 0])\\n boxes_2d_with_prob[j, 2] = np.max(pred_corners_3d_upright_camera[i, j, :, 0])\\n boxes_2d_with_prob[j, 1] = np.min(pred_corners_3d_upright_camera[i, j, :, 2])\\n boxes_2d_with_prob[j, 3] = np.max(pred_corners_3d_upright_camera[i, j, :, 2])\\n boxes_2d_with_prob[j, 4] = obj_prob[i, j]\\n nonempty_box_inds = np.where(nonempty_box_mask[i, :] == 1)[0]\\n assert len(nonempty_box_inds) > 0\\n pick = nms_2d_faster(\\n boxes_2d_with_prob[nonempty_box_mask[i, :] == 1, :],\\n config_dict[\\\"nms_iou\\\"],\\n config_dict[\\\"use_old_type_nms\\\"],\\n )\\n assert len(pick) > 0\\n pred_mask[i, nonempty_box_inds[pick]] = 1\\n # ---------- NMS output: pred_mask in (B,K) -----------\\n elif config_dict[\\\"use_3d_nms\\\"] and (not config_dict[\\\"cls_nms\\\"]):\\n # ---------- NMS input: pred_with_prob in (B,K,7) -----------\\n pred_mask = np.zeros((bsize, K))\\n for i in range(bsize):\\n boxes_3d_with_prob = np.zeros((K, 7))\\n for j in range(K):\\n boxes_3d_with_prob[j, 0] = np.min(pred_corners_3d_upright_camera[i, j, :, 0])\\n boxes_3d_with_prob[j, 1] = np.min(pred_corners_3d_upright_camera[i, j, :, 1])\\n boxes_3d_with_prob[j, 2] = np.min(pred_corners_3d_upright_camera[i, j, :, 2])\\n boxes_3d_with_prob[j, 3] = np.max(pred_corners_3d_upright_camera[i, j, :, 0])\\n boxes_3d_with_prob[j, 4] = np.max(pred_corners_3d_upright_camera[i, j, :, 1])\\n boxes_3d_with_prob[j, 5] = np.max(pred_corners_3d_upright_camera[i, j, :, 2])\\n boxes_3d_with_prob[j, 6] = obj_prob[i, j]\\n nonempty_box_inds = np.where(nonempty_box_mask[i, :] == 1)[0]\\n assert len(nonempty_box_inds) > 0\\n pick = nms_3d_faster(\\n boxes_3d_with_prob[nonempty_box_mask[i, :] == 1, :],\\n config_dict[\\\"nms_iou\\\"],\\n config_dict[\\\"use_old_type_nms\\\"],\\n )\\n assert len(pick) > 0\\n pred_mask[i, nonempty_box_inds[pick]] = 1\\n # ---------- NMS output: pred_mask in (B,K) -----------\\n elif config_dict[\\\"use_3d_nms\\\"] and config_dict[\\\"cls_nms\\\"]:\\n # ---------- NMS input: pred_with_prob in (B,K,8) -----------\\n pred_mask = np.zeros((bsize, K))\\n for i in range(bsize):\\n boxes_3d_with_prob = np.zeros((K, 8))\\n for j in range(K):\\n boxes_3d_with_prob[j, 0] = np.min(pred_corners_3d_upright_camera[i, j, :, 0])\\n boxes_3d_with_prob[j, 1] = np.min(pred_corners_3d_upright_camera[i, j, :, 1])\\n boxes_3d_with_prob[j, 2] = np.min(pred_corners_3d_upright_camera[i, j, :, 2])\\n boxes_3d_with_prob[j, 3] = np.max(pred_corners_3d_upright_camera[i, j, :, 0])\\n boxes_3d_with_prob[j, 4] = np.max(pred_corners_3d_upright_camera[i, j, :, 1])\\n boxes_3d_with_prob[j, 5] = np.max(pred_corners_3d_upright_camera[i, j, :, 2])\\n boxes_3d_with_prob[j, 6] = obj_prob[i, j]\\n boxes_3d_with_prob[j, 7] = pred_sem_cls[i, j] # only suppress if the two boxes are of the same class!!\\n nonempty_box_inds = np.where(nonempty_box_mask[i, :] == 1)[0]\\n assert len(nonempty_box_inds) > 0\\n pick = nms_3d_faster_samecls(\\n boxes_3d_with_prob[nonempty_box_mask[i, :] == 1, :],\\n config_dict[\\\"nms_iou\\\"],\\n config_dict[\\\"use_old_type_nms\\\"],\\n )\\n assert len(pick) > 0\\n pred_mask[i, nonempty_box_inds[pick]] = 1\\n # ---------- NMS output: pred_mask in (B,K) -----------\\n\\n batch_pred_map_cls = (\\n []\\n ) # a list (len: batch_size) of list (len: num of predictions per sample) of tuples of pred_cls, pred_box and conf (0-1)\\n for i in range(bsize):\\n if config_dict[\\\"per_class_proposal\\\"]:\\n assert config_dict[\\\"use_cls_confidence_only\\\"] is False\\n cur_list = []\\n for ii in range(config_dict[\\\"dataset_config\\\"].num_semcls):\\n cur_list += [\\n (\\n ii,\\n pred_corners_3d_upright_camera[i, j],\\n sem_cls_probs[i, j, ii] * obj_prob[i, j],\\n )\\n for j in range(pred_corners_3d_upright_camera.shape[1])\\n if pred_mask[i, j] == 1 and obj_prob[i, j] > config_dict[\\\"conf_thresh\\\"]\\n ]\\n batch_pred_map_cls.append(cur_list)\\n elif config_dict[\\\"use_cls_confidence_only\\\"]:\\n batch_pred_map_cls.append(\\n [\\n (\\n pred_sem_cls[i, j].item(),\\n pred_corners_3d_upright_camera[i, j],\\n sem_cls_probs[i, j, pred_sem_cls[i, j].item()],\\n )\\n for j in range(pred_corners_3d_upright_camera.shape[1])\\n if pred_mask[i, j] == 1 and obj_prob[i, j] > config_dict[\\\"conf_thresh\\\"]\\n ]\\n )\\n else:\\n batch_pred_map_cls.append(\\n [\\n (\\n pred_sem_cls[i, j].item(),\\n pred_corners_3d_upright_camera[i, j],\\n obj_prob[i, j],\\n )\\n for j in range(pred_corners_3d_upright_camera.shape[1])\\n if pred_mask[i, j] == 1 and obj_prob[i, j] > config_dict[\\\"conf_thresh\\\"]\\n ]\\n )\\n\\n return batch_pred_map_cls\",\n \"def _get_predictions(self, line: List[str]):\\n example = self.tokenizer.encode_plus(\\n [c for c in line],\\n return_token_type_ids=True,\\n return_attention_mask=True,\\n return_tensors=\\\"pt\\\",\\n )\\n example = {k: v.to(self.device) for k, v in example.items()}\\n prediction = self.model(example, training=False)[0]\\n prediction = self.softmax_fn(prediction).cpu().data.numpy()\\n prediction = prediction[1:-1, 1:].argmax(axis=-1)\\n return prediction\",\n \"def predict(self, datafile):\\r\\n \\r\\n # We load the test data and lower the text\\r\\n data_test = pd.read_csv(datafile, sep = \\\"\\\\t\\\", names = [\\\"polarity\\\", \\\"category\\\", \\\"word\\\", \\\"offsets\\\", \\\"sentence\\\"])\\r\\n data_test['sentence_l'] = data_test['sentence'].apply(str.lower)\\r\\n data_test['word'] = data_test['word'].apply(str.lower)\\r\\n \\r\\n # We try to keep all the no/nor/not words as this changes radically the sentiment analysis\\r\\n data_test['sentence_l'] = data_test[\\\"sentence_l\\\"].apply(lambda sentence: sentence.replace(\\\"can\\\\'t\\\", \\\"can not\\\"))\\r\\n data_test['sentence_l'] = data_test[\\\"sentence_l\\\"].apply(lambda sentence: sentence.replace(\\\"n\\\\'t\\\", \\\" not\\\"))\\r\\n \\r\\n # We clean the data and stem the words\\r\\n clean_sentences = []\\r\\n for row in data_test['sentence_l']:\\r\\n tokens = word_tokenize(row)\\r\\n tokens = [word for word in tokens if word.isalpha()]\\r\\n tokens = [w for w in tokens if not w in self.stopwords] \\r\\n tokens = [self.stemmer.stem(word) for word in tokens]\\r\\n clean_sentences.append(tokens)\\r\\n data_test['stems'] = clean_sentences\\r\\n \\r\\n # We also stem the target words to be coherent with the stemmed words in the sentences\\r\\n data_test['word'] = [self.stemmer.stem(word) for word in data_test['word']]\\r\\n\\r\\n # We recreate the sentences with the selected and cleaned words\\r\\n Classifier.create_sentence = staticmethod(Classifier.create_sentence)\\r\\n data_test.clean_sentence = Classifier.create_sentence(data_test.stems)\\r\\n \\r\\n # We create a BOW vector\\r\\n reviews_new_counts = self.restaurant_vect.transform(data_test.clean_sentence)\\r\\n \\r\\n # We transform the BOW vector with the tfidf scores\\r\\n reviews_new_tfidf = self.tfidf_transformer.transform(reviews_new_counts)\\r\\n \\r\\n # We make a prediction with the classifier\\r\\n self.pred = self.model.predict(reviews_new_tfidf)\\r\\n \\r\\n return self.pred\",\n \"def prediction_processing(predictions, labels, threshold, step_nb):\\n new_labels = []\\n new_predictions = []\\n number_sequences = step_nb//50\\n\\n for k in range(len(labels)//number_sequences):\\n total_prediction = 0\\n isLabelTrue = labels[number_sequences*k]\\n for i in range(number_sequences):\\n total_prediction += (1/predictions[number_sequences*k+i])\\n if not(isLabelTrue == (labels[number_sequences*k+i])):\\n logger.error('Problem.')\\n if total_prediction > threshold:\\n total_prediction = False\\n else:\\n total_prediction = True\\n new_labels.append(isLabelTrue)\\n new_predictions.append(total_prediction)\\n\\n recall_1 = recall_score(new_labels, new_predictions)\\n recall_0 = recall_score(new_labels, new_predictions, pos_label=0)\\n precision_1 = precision_score(new_labels, new_predictions)\\n precision_0 = precision_score(new_labels, new_predictions, pos_label=0)\\n return((recall_1, recall_0, precision_1, precision_0), new_predictions, new_labels)\",\n \"def inspect_pair_with_model(model,sent1,sent2,expected_label):\\n dp = dataPoint((sent1,sent2),expected_label)\\n pred = model.predict(np.array(dp.get_features()).reshape(1,-1))\\n if (pred == expected_label):\\n print(\\\"succesfully predicted\\\")\\n else:\\n print(\\\"The model predicted \\\" + str(pred) + \\\" while we actually wanted \\\" + str(expected_label))\\n print(\\\"The features for these sentences are: \\\")\\n inspect_model(model)\",\n \"def postprocess_predictions(predicted_aggregation_operators, predicted_table_cell_coords, table):\\n # Process predicted aggregation operators\\n aggregation_operators = {0: \\\"NONE\\\", 1: \\\"SUM\\\", 2: \\\"AVERAGE\\\", 3: \\\"COUNT\\\"}\\n aggregation_predictions_string = [aggregation_operators[x] for x in predicted_aggregation_operators]\\n\\n # Process predicted table cell coordinates\\n answers = []\\n for coordinates in predicted_table_cell_coords:\\n if len(coordinates) == 1:\\n # 1 cell\\n answers.append(table.iat[coordinates[0]])\\n else:\\n # > 1 cell\\n cell_values = []\\n for coordinate in coordinates:\\n cell_values.append(table.iat[coordinate])\\n answers.append(\\\", \\\".join(cell_values))\\n\\n # Return values\\n return aggregation_predictions_string, answers\",\n \"def make_prediction(self, title: str, body: str):\\n data = pd.DataFrame({\\n \\\"title\\\": [title],\\n \\\"body\\\": [body],\\n \\\"tags\\\": [\\\"\\\"]\\n })\\n data = self.extractor.process_df(data)\\n prediction = self.__model.predict(self.df_to_inputs(data))\\n print(\\\"PRED: \\\", prediction)\\n\\n explanation = self.interpret(title, body, data[self.FEATURES])\\n return prediction, explanation\",\n \"def convert_data(test_data,params,list_dict,rational_present=True,topk=2):\\n \\\"\\\"\\\"input: params -- input dict, list_dict -- previous predictions containing rationals\\n rational_present -- whether to keep rational only or remove them only\\n topk -- how many words to select\\\"\\\"\\\"\\n \\n temp_dict={}\\n for ele in list_dict:\\n temp_dict[ele['annotation_id']]=ele['rationales'][0]['soft_rationale_predictions']\\n \\n test_data_modified=[]\\n \\n for index,row in tqdm(test_data.iterrows(),total=len(test_data)):\\n try:\\n attention=temp_dict[row['Post_id']]\\n except KeyError:\\n continue\\n topk_indices = sorted(range(len(attention)), key=lambda i: attention[i])[-topk:]\\n new_text =[]\\n new_attention =[]\\n if(rational_present):\\n if(params['bert_tokens']):\\n new_attention =[0]\\n new_text = [101]\\n for i in range(len(row['Text'])):\\n if(i in topk_indices):\\n new_text.append(row['Text'][i])\\n new_attention.append(row['Attention'][i])\\n if(params['bert_tokens']):\\n new_attention.append(0)\\n new_text.append(102)\\n else:\\n for i in range(len(row['Text'])):\\n if(i not in topk_indices):\\n new_text.append(row['Text'][i])\\n new_attention.append(row['Attention'][i])\\n test_data_modified.append([row['Post_id'],new_text,new_attention,row['Label']])\\n\\n df=pd.DataFrame(test_data_modified,columns=test_data.columns)\\n return df\",\n \"def predict(cls, input):\\n clf = cls.get_model() \\n\\n input.to_csv(data_dir + 'vdok_predction_src_file.csv')\\n\\n q = qa_serializer_lang_selector(data_dir)\\n q.serialize_record('vdok_predction_src_file.csv', task_name)\\n q.select_lang([1], task_name).to_csv(data_dir + data_file, encoding= 'latin1')\\n\\n pipeline=['pos', 'lemma', 'synset', 'hype', 'hypo']\\n\\n bnlqd = fex_basic_nlp(data_file, data_dir)\\n bnlqd.nlp_run(pipeline[0])\\n bnlqd.nlp_run(pipeline[1])\\n bnlqd.df_ac_lemma.to_csv(data_dir + 'Lemma-' + data_file, encoding= 'latin1')\\n bnlqd.nlp_run(pipeline[2])\\n bnlqd.df_ac_synset.to_csv(data_dir + 'Synset-' + data_file , encoding= 'latin1')\\n bnlqd.nlp_run(pipeline[3])\\n bnlqd.df_ac_hypernyms.to_csv(data_dir + 'Hypernyms-' + data_file, encoding= 'latin1')\\n bnlqd.nlp_run(pipeline[4])\\n bnlqd.df_ac_hyponyms.to_csv(data_dir + 'Hyponyms-' + data_file, encoding= 'latin1')\\n\\n bnlpd = fex_basic_nlp(def_file, data_dir, task_name)\\n bnlpd.nlp_run(pipeline[0])\\n bnlpd.nlp_run(pipeline[1])\\n bnlpd.df_ac_lemma.to_csv(data_dir + 'Lemma-P-' + data_file, encoding= 'latin1')\\n \\n btgqd = bi_trigram(data_file, data_dir)\\n btgqd.nlp_run(r'bigram')\\n btgqd.nlp_run(r'trigram') \\n\\n stop_words_d = cls.remove_non_extracted_stop_word(bnlqd.df_ac_lemma, stop_words)\\n\\n oanc_shelve = oanc_resource + 'ANC-all-lemma-04262014.db'\\n oalqd = odi_oanc_lemma_frequency(data_file, oanc_shelve, None, data_dir, stop_words_d) \\n oalqd.oanc_lemma_frequency('Lemma-' + data_file, 'Student_Question_Index', 'Pre_Col_Name')\\n \\n stop_words_hy_d = cls.remove_non_extracted_stop_word(bnlqd.df_ac_lemma, stop_words_hy)\\n\\n ovlqd = odi_overlapping(data_file, def_file, data_dir, stop_words_d)\\n ovlqd.count_overlapping('Lemma-' + data_file, 'Student_Question_Index',\\n 'Pre_Col_Name', 'Question_ID', 'Question_ID_Sec',\\n 'Lemma-P-' + data_file, 'Question_ID', 'Question_ID_Sec')\\n ovlqd.count_overlapping_synset('Synset-' + data_file)\\n ovlqd.count_overlapping_hypernyms('Hypernyms-' + data_file, stop_words_hy_d)\\n ovlqd.count_overlapping_hyponyms('Hyponyms-' + data_file, stop_words_hy_d)\\n\\n df_ac_pmi_dist_bigram = cls.bi_trigram_pmi_distribution(pmi_bigram_file, data_dir, \\n bnlqd.num_clm_in, btgqd.df_ac_bigram, 'bigram')\\n df_ac_pmi_dist_trigram = cls.bi_trigram_pmi_distribution(pmi_trigram_file, data_dir, \\n bnlqd.num_clm_in, btgqd.df_ac_trigram, 'Trigram')\\n\\n df_ac_aggregate = cls.aggregate_plim(bnlqd, oalqd, ovlqd, df_ac_pmi_dist_bigram, df_ac_pmi_dist_trigram,\\n bnlpd, specific_count_lemmas, stop_words_pos, task_name)\\n df_ac_aggregate.to_csv(data_dir + 'vdok_predction_Aggregate_plim.csv', encoding= 'latin1')\\n df_ac_aggregate_item_level = cls.aggregate_item_level_plim(df_ac_aggregate, oalqd.stem_option_name_clm, \\n task_name)\\n df_ac_aggregate_item_level.to_csv(data_dir + 'vdok_predction_Key_Stem_Passage_Aggregate_plim.csv',\\n encoding= 'latin1')\\n\\n rfrpod = tmv_RF_classify('Independent_Variable_w_Label-Def.csv', data_dir)\\n rfrpod.load_data('vdok_predction_Key_Stem_Passage_Aggregate_plim.csv', True, drop_vars, dependent_var)\\n clf.perform_prediction(rfrpod.df_ac_modeling_values)\\n return clf.df_ac_classified\",\n \"def predict_label(\\n self, message: \\\"Message\\\"\\n ) -> Tuple[Dict[Text, Any], List[Dict[Text, Any]]]:\\n\\n label = {\\\"name\\\": None, \\\"confidence\\\": 0.0}\\n label_ranking = []\\n\\n if self.session is None:\\n logger.error(\\n \\\"There is no trained tf.session: \\\"\\n \\\"component is either not trained or \\\"\\n \\\"didn't receive enough training data.\\\"\\n )\\n return label, label_ranking\\n\\n # create session data from message and convert it into a batch of 1\\n session_data = self._create_session_data([message])\\n\\n # if no text-features are present (e.g. incoming message is not in the\\n # vocab), do not predict a random intent\\n if not self._text_features_present(session_data):\\n return label, label_ranking\\n\\n batch = train_utils.prepare_batch(\\n session_data, tuple_sizes=self.batch_tuple_sizes\\n )\\n\\n # load tf graph and session\\n label_ids, message_sim = self._calculate_message_sim(batch)\\n\\n # if X contains all zeros do not predict some label\\n if label_ids.size > 0:\\n label = {\\n \\\"name\\\": self.inverted_label_dict[label_ids[0]],\\n \\\"confidence\\\": message_sim[0],\\n }\\n\\n if self.ranking_length and 0 < self.ranking_length < LABEL_RANKING_LENGTH:\\n output_length = self.ranking_length\\n else:\\n output_length = LABEL_RANKING_LENGTH\\n\\n ranking = list(zip(list(label_ids), message_sim))\\n ranking = ranking[:output_length]\\n label_ranking = [\\n {\\\"name\\\": self.inverted_label_dict[label_idx], \\\"confidence\\\": score}\\n for label_idx, score in ranking\\n ]\\n\\n return label, label_ranking\",\n \"def init_predict_text(self, decode_method=0, beam_size=5, convert_unk=True):\\n text, score = self.build_predict_text_graph(self.input_text_feed, \\n decode_method=decode_method, \\n beam_size=beam_size, \\n convert_unk=convert_unk)\\n return text, score\",\n \"def predict_str(self, s,saved_model):\\n x = self.dataset.str_to_x(s,200)\\n predicted_classes = self.predict_x(x,saved_model)\\n chars = self.dataset.x_to_str(x)[0]\\n labels = self.dataset.y_to_labels(predicted_classes)[0]\\n\\n \\\"\\\"\\\"\\n Converting char to words and \\n \\\"\\\"\\\"\\n\\n word = \\\"\\\"\\n labels_per_word = []\\n predictions = []\\n\\n\\n for i in range(len(chars)):\\n if(len(chars[i].strip()) and chars[i].strip()!='<PAD>'):\\n word+=chars[i]\\n labels_per_word.append(labels[i])\\n else:#word over\\n\\n frequent_label = self.most_frequent(labels_per_word)\\n predictions.append((None,None,word,frequent_label))\\n word = ''\\n labels_per_word = []\\n if(chars[i].strip()=='<PAD>'):\\n break\\n\\n\\n return predictions\",\n \"def predict(self, first_preprocessed_inputs,second_preprocessed_inputs,third_preprocessed_inputs):\\r\\n pass\",\n \"def tag_notes(model_path,\\n input_data_path,\\n output_data_path,\\n text_column_name,\\n metadata_columns,\\n prediction_column_name=constants.PREDICTION_COLUMN_NAME):\\n\\n print(\\\"Loading model from {}\\\".format(model_path))\\n with open(model_path, 'rb') as f:\\n model = pickle.load(f)\\n\\n print(\\\"Loading data from {}\\\".format(input_data_path))\\n input_data = pd.read_json(input_data_path, orient='records', lines=True)\\n\\n print(\\\"Making predictions\\\")\\n note_tag_predictions = model.predict_tag(\\n data=input_data,\\n text_column_name=text_column_name,\\n metadata_columns=metadata_columns,\\n prediction_column_name=prediction_column_name)\\n\\n print(\\\"Saving data to {}\\\".format(output_data_path))\\n note_tag_predictions.to_json(output_data_path, orient='records', lines=True)\",\n \"def extract_detections(self):\\n self.rescue_model.setInput(self.human_blob)\\n self.predictions = self.rescue_model.forward()\",\n \"def predict(self, datafile):\",\n \"def test_predict(self):\\n\\n docs = self.docs\\n for m in self.models:\\n preds = m.predict(docs)\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertEqual(len(preds), len(docs))\\n self.assertEqual(preds.dtype, int)\\n\\n preds = m.predict(docs, output_type=\\\"probability\\\")\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertTrue(len(preds) == len(docs))\\n s = preds.apply(lambda x: sum(x))\\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\\n\\n # Test predictions when docs have new words\\n new_docs = turicreate.SArray([{\\\"-1,-1\\\": 3.0, \\\"0,4\\\": 5.0, \\\"0,3\\\": 2.0}])\\n preds = m.predict(new_docs)\\n self.assertEqual(len(preds), len(new_docs))\\n\\n # Test additional burnin. Ideally we could show that things\\n # converge as you increase burnin.\\n preds_no_burnin = m.predict(docs, output_type=\\\"probability\\\", num_burnin=0)\\n self.assertEqual(len(preds_no_burnin), len(docs))\",\n \"def analyze():\\n content = request.get_json()\\n if model is None:\\n return\\n max_seq_length = model.max_seq_length\\n test_data = content['text']\\n data, seq_lengths, targets = prepare_text(\\n test_data, max_seq_length, vocab_mapping)\\n input_feed = {}\\n input_feed[model.seq_input.name] = data\\n input_feed[model.target.name] = targets\\n input_feed[model.seq_lengths.name] = seq_lengths\\n output_feed = [model.y]\\n outputs = sess.run(output_feed, input_feed)\\n score = np.argmax(outputs[0])\\n probability = outputs[0].max(axis=1)[0]\\n message = 'Value of sentiment: '\\n if score > 0:\\n message = message + 'positive'\\n else:\\n message = message + 'negative'\\n message = message + ' with probability: ' + str(probability)\\n result = json.dumps({\\n 'score': str(score),\\n 'probability': str(probability)\\n })\\n\\n resp = Response(response=result, status=200, mimetype='application/json')\\n\\n return resp\",\n \"def predict_tokens(self, tokens):\\n return\",\n \"def postprocess(self, inputs: Dict[str, Any],\\n **postprocess_params) -> Dict[str, str]:\\n text = inputs['text']\\n logits = inputs[OutputKeys.LOGITS]\\n predictions = torch.argmax(logits[0], dim=-1)\\n logits = torch_nested_numpify(torch_nested_detach(logits))\\n predictions = torch_nested_numpify(torch_nested_detach(predictions))\\n offset_mapping = [x.cpu().tolist() for x in inputs['offset_mapping']]\\n\\n labels = [self.id2label[x] for x in predictions]\\n if len(labels) > len(offset_mapping):\\n labels = labels[1:-1]\\n chunks = []\\n chunk = {}\\n for label, offsets in zip(labels, offset_mapping):\\n if label[0] in 'BS':\\n if chunk:\\n chunk['span'] = text[chunk['start']:chunk['end']]\\n chunks.append(chunk)\\n chunk = {\\n 'type': label[2:],\\n 'start': offsets[0],\\n 'end': offsets[1]\\n }\\n if label[0] in 'IES':\\n if chunk:\\n chunk['end'] = offsets[1]\\n\\n if label[0] in 'ES':\\n if chunk:\\n chunk['span'] = text[chunk['start']:chunk['end']]\\n chunks.append(chunk)\\n chunk = {}\\n\\n if chunk:\\n chunk['span'] = text[chunk['start']:chunk['end']]\\n chunks.append(chunk)\\n\\n # for cws outputs\\n if len(chunks) > 0 and chunks[0]['type'] == 'cws':\\n spans = [\\n chunk['span'] for chunk in chunks if chunk['span'].strip()\\n ]\\n seg_result = ' '.join(spans)\\n outputs = {OutputKeys.OUTPUT: seg_result}\\n\\n # for ner output\\n else:\\n outputs = {OutputKeys.OUTPUT: chunks}\\n return outputs\",\n \"def get_prediction_response(predictions):\\n if len(predictions) == 0:\\n # no player identified\\n return [\\\"Sorry, I couldn't find any player with that last name. Please try a different name.\\\"]\\n responses = []\\n for prediction in predictions:\\n # # handle error messages\\n if isinstance(prediction, str):\\n responses.append(prediction)\\n continue\\n\\n # # response for identified player\\n start_message = random.choice([\\n 'I think ',\\n 'I predict ',\\n 'After careful consideration, I can say that ',\\n 'It seems that ',\\n ])\\n if prediction['predicted_points'] > 1:\\n plural_string = 's'\\n else:\\n plural_string = ''\\n response = '%s %s %s (%s) of %s will probably score around %d point%s against %s in GW %d' % (\\n start_message,\\n prediction['first_name'],\\n prediction['second_name'],\\n prediction['position_short'],\\n prediction['team_name'],\\n prediction['predicted_points'],\\n plural_string,\\n prediction['opp_team_name'],\\n prediction['week']\\n )\\n responses.append(response)\\n return responses\",\n \"def predict(data, model_predict):\\n # Execute any steps you need to do before scoring\\n\\n # This method makes predictions against the raw, deserialized model\\n #predictions = model_predict(data)\\n\\n data.to_csv(\\\"/opt/code/chemprop_folder/for_scoring.csv\\\", index=False)\\n\\n args = PredictArgs().parse_args([\\n '--test_path', '/opt/chemprop_folder/for_scoring.csv',\\n '--checkpoint_path', '/opt/code/model.pth',\\n '--preds_path', '/opt/chemprop_folder/preds.csv'\\n ])\\n\\n make_predictions(args)\\n\\n preds_df = pds.read_csv(\\\"/opt/chemprop_folder/preds.csv\\\")\\n sh = str(preds_df.shape)\\n print(sh)\\n\\n preds_df = preds_df.rename(columns = {\\\"p_np\\\": \\\"positive_class_label\\\"})\\n preds_df = preds_df.drop(columns=['smiles'])\\n preds_df[\\\"negative_class_label\\\"] = 1 - preds_df[\\\"positive_class_label\\\"]\\n\\n print(preds_df.head())\\n\\n # Execute any steps you need to do after scoring\\n # Note: To properly send predictions back to DataRobot, the returned DataFrame should contain a\\n # column for each output label for classification or a single value column for regression\\n return preds_df\",\n \"def post_process_predictions(self, labels, scene):\\n pass\",\n \"def predict(self, review):\\n raise NotImplementedError\",\n \"def classify(strings: List[str], params: Any) -> List[str]:\\n \\n # ############################ REPLACE THIS WITH YOUR CODE #############################\\n def predict_one_sample(sample, train_dict, ngram_lvl=1):\\n ngrams = [sample[i:i+ngram_lvl] for i in\",\n \"def recognize(models: dict, test_set: SinglesData):\\n warnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n probabilities = []\\n guesses = []\\n # TODO implement the recognizer\\n # return probabilities, guesses\\n test_sequences = list(test_set.get_all_Xlengths().values())\\n for test_X,test_Xlength in test_sequences:\\n prob = {}\\n maxlogLvalue = float(\\\"-inf\\\")\\n guess = \\\"\\\"\\n for word, model in models.items():\\n try:\\n logLvalue = model.score(test_X, test_Xlength) \\n prob[word] = logLvalue\\n if logLvalue > maxlogLvalue:\\n guess = word\\n maxlogLvalue = logLvalue\\n except:\\n prob[word] = float(\\\"-inf\\\")\\n\\n\\n probabilities.append(prob) \\n guesses.append(guess)\\n\\n return (probabilities,guesses)\",\n \"def predict(self, expression=None):\\r\\n confidence_score = 0\\r\\n intent = None\\r\\n\\r\\n #intent, confidence_score = self.ncf(expression)\\r\\n intent, confidence_score = \\\"Test\\\",100\\r\\n l_msg = \\\"model found : {} and score is {}\\\".format(intent, confidence_score)\\r\\n log.debug(l_msg)\\r\\n\\r\\n return intent, confidence_score\",\n \"def inference(self, inputs):\\n\\n input_ids = torch.tensor([inputs[\\\"head_ids\\\"]], dtype=torch.long).to(self.device)\\n attention_masks = torch.tensor([inputs[\\\"attention_masks\\\"]], dtype=torch.bool).to(self.device)\\n \\n # Handling inference for sequence_classification.\\n with torch.no_grad():\\n output = self.model(input_ids, attention_masks)\\n predict_label = output[0].argmax(dim=2)\\n predict_string = self.tokenizer.decode_sent(input_ids[0].detach().cpu().numpy(), predict_label[0].detach().cpu().numpy())\\n\\n logger.info(\\\"Model predicted: '%s'\\\", predict_string)\\n return [{'predict': predict_string}]\",\n \"def run_prediction(data, sess, placeholders, scores): \\r\\n \\r\\n X, Y = data\\r\\n source_pl, target_pl, training_pl = placeholders\\r\\n split_set = int(math.floor(0.9*len(X))) # Value for spliting the set in 90% training / 10% test \\r\\n \\r\\n X_batch, Y_batch = batch(X[:split_set:], Y[:split_set:]) # Take a batch of sentences from the training set\\r\\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\\r\\n prediction = sess.run(scores, feed_dict=feed_dict) \\r\\n X_batch = np.squeeze(X_batch) \\r\\n prediction = np.squeeze(prediction)\\r\\n \\r\\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\\r\\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\\r\\n\\r\\n\\t# Print the pairs source -> target\\r\\n for source, target in zip(source_sentences, target_sentences): \\r\\n print(source + \\\" --> \\\" + target)\\r\\n \\r\\n print(\\\"================================================================\\\")\\r\\n \\r\\n X_batch, Y_batch = batch(X[split_set+1:], Y[split_set+1:]) # Take a batch of sentences from the test set\\r\\n feed_dict = {source_pl: X_batch, target_pl: Y_batch, training_pl: False}\\r\\n prediction = sess.run(scores, feed_dict=feed_dict) \\r\\n \\r\\n X_batch = np.squeeze(X_batch) \\r\\n prediction = np.squeeze(prediction)\\r\\n \\r\\n \\r\\n source_sentences = treatment.sentences_from_one_hot(X_batch, CORPUS_ENGLISH)\\r\\n target_sentences = treatment.sentences_from_one_hot(prediction, CORPUS_FRENCH)\\r\\n\\r\\n\\t# Print the pairs source -> target\\r\\n for source, target in zip(source_sentences, target_sentences): \\r\\n print(source + \\\" --> \\\" + target)\",\n \"def recognize_ngram(models: dict, test_set: SinglesData,probs,BIC_guesses):\\n warnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n probabilities = []\\n guesses = []\\n\\n model = arpa.loadf(\\\"devel-lm-M3.sri.lm\\\")\\n lm = model[0] # ARPA files may contain several models.\\n # TODO implement the recognizer\\n # return probabilities, guesses\\n test_sequences = list(test_set.get_all_Xlengths().values())\\n word_keys = list(test_set.get_all_Xlengths().keys())\\n i = -1 \\n for sentence in test_set.sentences_index.values():\\n f = {}\\n maxs = float(\\\"-inf\\\")\\n prob = []\\n words = []\\n\\n sentenceLength = 0\\n for word_index in sentence:\\n i+=1\\n word = test_set.wordlist[word_index]\\n sentenceLength+=1\\n try:\\n f[word] = probs[word][i]\\n except:\\n f[word] = float(\\\"-inf\\\")\\n prob.append(f[word]) ## These are Just the probabilities unchanged from the BIC recognizer.\\n \\n # Find Six most probable words and generate the possible permutations \\n sixwords = sorted(f,key=f.get,reverse=True)[:6]\\n for k in permutations(sixwords, r=sentenceLength):\\n l = 0\\n for j in range(len(k)):\\n l += f[k[j]]\\n try:\\n sentenceLP = l + 13*lm.log_s(\\\" \\\".join(k)) ## According to one student in the forum 13 is the best hyperparameter\\n if sentenceLP > maxs: ## https://discussions.udacity.com/t/slm-data-for-this-asl-dataset/230822/8?u=spiros\\n sentence = \\\" \\\".join(k)\\n maxs = sentenceLP\\n words = list(k)\\n except:\\n pass\\n\\n if(words == []):\\n words = BIC_guesses[len(guesses):len(guesses)+sentenceLength] ## Fall back to BIC guesses\\n probabilities.append(prob) \\n guesses += words\\n return (probabilities,guesses)\",\n \"def sentence_prediction(self, sentence, echo=False):\\n sentence = norm_input(sentence)\\n sentence = self.typing_errors(sentence)\\n sent_seq = self.tokenizer_x.texts_to_sequences([sentence])\\n sentence_tok = pad_sequences(sent_seq, maxlen=self.sentence_size,\\n dtype='int32')\\n wi = self.tokenizer_y.word_index\\n pr = self.model.predict(sentence_tok)[0]\\n predictions = []\\n for speechact, index in wi.items():\\n predictions.append((round(pr[index]*100, 2), speechact))\\n predictions.sort(key=lambda tup: tup[0])\\n if echo:\\n for p in predictions:\\n print(str(p[0]).rjust(7) + \\\" -> \\\" + p[1])\\n return predictions[-1][1]\",\n \"def computeErrorRate(test_set, words_likely_tags):\\n # initiate vars\\n known_words = {} # those two dictionaries are optional, just for debuging\\n unknown_words = {} # those two dictionaries are optional, just for debuging\\n correct_predictions = 0\\n total_predictions = 0\\n correct_unknown_predictions = 0\\n total_unknown_predictions = 0\\n\\n for i in range(len(test_set)): # iterate sentences\\n test_sent = test_set[i]\\n for j in range(len(test_sent)): # iterate words in sent\\n w = test_sent[j][WORD]\\n t = test_sent[j][TAG]\\n\\n # known words\\n if w in words_likely_tags:\\n if w in known_words:\\n known_words[w][COUNTER_SHOWS] += 1\\n if t == words_likely_tags[w]: # same tag\\n known_words[w][COUNTER_EQUAL] += 1\\n correct_predictions += 1\\n else:\\n if t == words_likely_tags[w]: # same tag\\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\\n correct_predictions += 1\\n else:\\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\\n\\n total_predictions += 1\\n # unknown words\\n else: # w not in words_likely_tags, treat w as unknown_word\\n if w in unknown_words:\\n unknown_words[w][COUNTER_SHOWS] += 1\\n if t == UNKNOWN_TAG:\\n # same tag as our model predicts for unknown words\\n unknown_words[w][COUNTER_EQUAL] += 1\\n correct_unknown_predictions += 1\\n else:\\n if t == UNKNOWN_TAG: # same tag\\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\\n correct_unknown_predictions += 1\\n else:\\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\\n\\n total_unknown_predictions += 1\\n\\n # print('correct_predictions......... = ', correct_predictions)\\n # print('total_predictions........... = ', total_predictions)\\n # print('correct_unknown_predictions. = ', correct_unknown_predictions)\\n # print('total_unknown_predictions... = ', total_unknown_predictions)\\n err_rate_known = 1 - correct_predictions/total_predictions\\n err_rate_unknown = 1 - correct_unknown_predictions/total_unknown_predictions\\n # total_err = err_rate_known + err_rate_unknown\\n tot_pred = total_predictions + total_unknown_predictions\\n corr_pred = correct_predictions + correct_unknown_predictions\\n total_err = 1 - corr_pred/tot_pred\\n\\n return err_rate_known, err_rate_unknown, total_err\",\n \"def get_predictions(payload):\\n return sm_client.invoke_endpoint(EndpointName=EMBEDDING_MODEL_ENDPOINT_NAME, \\n Body=payload,\\n ContentType='application/json')\",\n \"def construct_NLP_model(self, df=None):\\n import review_processing as rp\\n # get words\\n if df is not None:\\n nitems = df.shape[0]\\n col_names = df.columns.values\\n if self.review_col_name not in col_names or \\\\\\n self.sentiment_col_name not in col_names:\\n sys.exit('construct_NL_model: The name {0}/{1} cannot be found'.\\n format(self.review_col_name, self.sentiment_col_name))\\n review_list = df[self.review_col_name].values.tolist()\\n meaningful_words = map(self.review_to_meaningful_words,\\n review_list)\\n # Get training sentiment values\\n self.sentiment = df[self.sentiment_col_name].values\\n\\n else:\\n if self.training_file_name is None:\\n sys.exit('construct_NLP_model: traning file name does not '\\n 'exist')\\n else:\\n suffix = os.path.splitext(self.training_file_name)[1][1:]\\n if suffix == 'csv':\\n df = pd.read_csv(self.training_file_name)\\n if self.review_col_name not in col_names or \\\\\\n self.sentiment_col_name not in col_names::\\n sys.exit('construct_NL_model: The name {0}/{1} cannot '\\n ' be found'.format(self.review_col_name,\\n self.sentiment_col_name))\\n nitems = df.shape[0]\\n review_list = df[review_col_name].values.tolist()\\n meaningful_words = map(self.review_to_meaningful_words,\\n review_list)\\n elif suffix == 'json':\\n data_dict_list = rp.load_data(self.training_file_name)\\n if self.review_col_name not in data_dict_list.keys():\\n sys.exit('construct_NL_model: The name {0} cannot be '\\n 'found'.format(review_col_name))\\n review_list = map(lambda x: x[review_col_name],\\n data_dict_list)\\n meaningful_words = map(self.review_to_meaningful_words,\\n review_list)\\n else:\\n sys.exit('construct_NLP_model: file type not supported '\\n 'yet!')\\n\\n # Training process of Bag of Worlds\\n if self.NLP_model == 'BagofWords':\\n print('construct_NLP_model: Creating bag of words...')\\n self.vectorizer = CountVectorizer(analyzer='word',\\n tokenizer=None,\\n preprocessor=None,\\n stop_words=None,\\n max_features=self.maxfeature)\\n self.train_data_features = vectorizer.fit_transform(\\n meaningful_words)\\n self.train_data_features = train_data_features.toarray()\\n\\n # vocab = vectorizer.get_feature_names()\\n # dist = np.sum(train_data_features, axis=0)\\n # for tag, count in zip(vocab, dist):\\n # print(count, tag)\\n\\n else:\\n sys.exit('construct_NLP_model: NLP_model type not supported yet!')\",\n \"def predict_greedy(self, tokens: TokenSeq) -> Tuple[NDArray, PosSeq]:\\n \\n #array to hold predictions\\n predictions = np.zeros((len(tokens), len(self.l), len(self.l)))\\n for i in range(len(tokens)):\\n\\n for prev_tag in self.l:\\n new_feature_matrix = []\\n temp_dict = {}\\n feature_dict = add_features(tokens, prev_tag ,i, temp_dict)\\n new_feature_matrix.append(feature_dict)\\n new_feature_matrix = self.vectorizer.transform(new_feature_matrix)\\n \\n probabilities = self.clf.predict_proba(new_feature_matrix)\\n predictions[i, self.label_index(prev_tag)] = probabilities\\n \\n cur = len(probabilities[0])- 1\\n final_predictions = []\\n for i in range(len(predictions)):\\n cur_pred = np.argmax(predictions[i, cur])\\n final_predictions.append(cur_pred)\\n cur = cur_pred\\n ret_matrix = []\\n #print(tokens)\\n final_predictions = self.le.inverse_transform(final_predictions)\\n #print(final_predictions)\\n new_pos = final_predictions.tolist()\\n new_pos.insert(0, \\\"<s>\\\")\\n new_pos.pop(len(new_pos) - 1)\\n for i in range(len(new_pos)):\\n feature_dict = add_features(tokens, new_pos[i] ,i, temp_dict)\\n ret_matrix.append(feature_dict)\\n ret_matrix = self.vectorizer.transform(ret_matrix)\\n\\n return (ret_matrix, final_predictions)\",\n \"def parser(sent_list): #input: list of sentences\",\n \"def prepare_reg_data_for_prediction(dataframe, model_dict, user_keyword, task_name):\\r\\n parent_dir = Path.cwd().parent\\r\\n pickle_dir = parent_dir.joinpath('default_results', 'pickle_files_feat_eng')\\r\\n\\r\\n feature_X_user,affect_dataframe, affect_index_dataframe = df, df, df\\r\\n emo_X_test_dict = {}\\r\\n affect_index_dict ={}\\r\\n\\r\\n for emotion, model_prop in model_dict.items():\\r\\n #Get the data with the emotion class\\r\\n if user_keyword == 'validation':\\r\\n affect_dataframe = dataframe[dataframe['Affect Dimension'] == 1]\\r\\n affect_index_list = dataframe.index[dataframe['Affect Dimension'] == 1].tolist()\\r\\n else:\\r\\n affect_dataframe = dataframe[dataframe[emotion] == 1]\\r\\n affect_index_list = dataframe.index[dataframe[emotion] == 1].tolist()\\r\\n test_tweets = affect_dataframe.iloc[:, [0, 1, 2]]\\r\\n\\r\\n #Perform preprocessing, feature extraction and transformation for the tweets to be predicted\\r\\n print(emotion, test_tweets.shape)\\r\\n if test_tweets.empty == False:\\r\\n preprocessed_X_user = Preprocessor.perform(test_tweets, emotion, user_keyword, task_name)\\r\\n feature_X_user = Feature_Transformer.perform(preprocessed_X_user, emotion, user_keyword, task_name)\\r\\n vectorizer = Dictionaries.vectorizer_dict[model_prop[2]]\\r\\n\\r\\n #Fit transform the vectorizer with the corresponding preprocessed training data\\r\\n if os.path.exists(pickle_dir.joinpath(emotion + '_r_train_preprocess_df.pkl')):\\r\\n preprocess_train_df = pd.read_pickle(pickle_dir.joinpath(emotion + '_r_train_preprocess_df.pkl'))\\r\\n train_vect = vectorizer.fit_transform(preprocess_train_df['preprocessed_text'].values)\\r\\n train_vect_df = pd.DataFrame(train_vect.toarray(), columns=vectorizer.get_feature_names())\\r\\n print(emotion, 'train-shape', train_vect_df.shape, sep='\\\\n')\\r\\n else:\\r\\n #If the file doesnt exist, exit the program with instructions\\r\\n print('\\\\nRequired files does not exist.\\\\n\\\\n Please, train the models first by running > Modelling.py')\\r\\n sys.exit(1)\\r\\n\\r\\n # Use the same vectorizer to transform test data and then perform the feature union\\r\\n vector_X = vectorizer.transform(preprocessed_X_user['preprocessed_text'].values)\\r\\n test_vect_df = pd.DataFrame(vector_X.toarray(), columns=vectorizer.get_feature_names())\\r\\n X_test = pd.DataFrame(pd.concat([test_vect_df, feature_X_user], axis=1)) #####?\\r\\n emo_X_test_dict[emotion] = X_test\\r\\n affect_index_dict[emotion] = affect_index_list\\r\\n else:\\r\\n emo_X_test_dict[emotion] = pd.DataFrame\\r\\n affect_index_dict[emotion] = []\\r\\n\\r\\n return emo_X_test_dict, affect_index_dict\",\n \"def parse_predictions(response_json):\\n if not isinstance(response_json, collections.Mapping):\\n raise ValueError(\\n \\\"Invalid response received from prediction server: {}\\\".format(\\n repr(response_json)))\\n if PREDICTIONS_KEY not in response_json:\\n raise ValueError(\\n \\\"Required field '{}' missing in prediction server response: {}\\\".format(\\n PREDICTIONS_KEY, repr(response_json)))\\n return response_json.pop(PREDICTIONS_KEY)\",\n \"def extract_pred_from_estimator_predictions(predictions):\\n # print('predictions:', predictions)\\n pred = np.array([])\\n for prediction in predictions:\\n pred = np.append(pred, prediction['predictions'])\\n num_samples = len(pred)\\n pred = pred.reshape((num_samples, ))\\n return pred\",\n \"def predict(self, text):\\n tokens = ['[CLS]'] + self.tokenizer.tokenize(text) + ['[SEP]']\\n xx = self.tokenizer.convert_tokens_to_ids(tokens)\\n xx = torch.tensor(xx).unsqueeze(0).to(self.device)\\n _, y_hat = self.model(xx)\\n pred_tags = []\\n for tag in y_hat.squeeze():\\n pred_tags.append(idx2tag[tag.item()])\\n return pred_tags, tokens\",\n \"def predictor(path):\\n # get keypoints from the image in a DF\\n TEST_keypoints = []\\n path = cv2.cvtColor(path, cv2.COLOR_BGR2RGB)\\n img = movenet_inference_flat_v10(hub_model, path)\\n TEST_keypoints.append(img)\\n TEST_keypoints_df = pd.DataFrame(TEST_keypoints)\\n\\n # Rename columns in the DataFrames according to the values\\n columns = []\\n for point in kp_descriptions:\\n for value in ('y', 'x', 'score'):\\n columns.append(f'{point}_{value}')\\n\\n TEST_keypoints_df.columns = columns\\n \\n # add additional positional features\\n TEST_keypoints_df = add_pos_features(TEST_keypoints_df, drop_scores=True)\\n # predict the asana\\n prediction_existing = model_fl.predict(TEST_keypoints_df)\\n # initialize the predicted_asana to 107 (no asan found)\\n predicted_asana = 107\\n\\n # assign the precited asana if accuracy more than threshold (12.5%)\\n for i in range(1):\\n mx = 0\\n mx_label = -1\\n for j in range(107):\\n if(prediction_existing[i, j] > mx):\\n mx_label = j\\n mx = prediction_existing[i, j]\\n predicted_asana = mx_label\\n predicted_accuracy = prediction_existing[0, mx_label]\\n if(predicted_accuracy < 0.125):\\n predicted_asana = 107\\n\\n # print(predicted_asana)\\n \\n # find label from the json\\n a = inv_map[str(predicted_asana)]\\n # b = \\\"null\\\"\\n\\n print(\\\"predicted pose --> \\\", a)\\n print(\\\"confidence = \\\", predicted_accuracy)\\n # print(\\\"actual pose -->\\\", b)\\n return a, img\",\n \"def predict(self, sentences, batch_size=128):\\n pred_tensors = [\\n sentence_to_tensor(sentence, self.src_lang)\\n for sentence in tqdm(sentences, desc=\\\"creating prediction tensors\\\")\\n ]\\n\\n collate_fn = Collater(self.src_lang, predict=True)\\n pred_dataloader = DataLoader(\\n SimpleDataset(pred_tensors),\\n batch_size=batch_size,\\n collate_fn=collate_fn,\\n )\\n\\n sentences = []\\n words = []\\n attention = []\\n for batch in tqdm(pred_dataloader, desc=\\\"predict batch num\\\"):\\n preds = self.predict_batch(batch.to(device))\\n pred_sentences, pred_words, pred_attention = preds\\n sentences.extend(pred_sentences)\\n words.extend(pred_words)\\n attention.extend(pred_attention)\\n\\n # sentences = [num pred sentences]\\n # words = [num pred sentences, trg len]\\n # attention = [num pred sentences, n heads, trg len, src len]\\n\\n return sentences, words, attention\",\n \"def predict(self, sentence_list): # noqa: ignore flake8\\\"\\n\\n if self.src_2_ids is None:\\n self.src_2_ids = load_word_dict(self.src_vocab_path)\\n self.trg_2_ids = load_word_dict(self.trg_vocab_path)\\n if self.model is None:\\n if os.path.exists(self.model_path):\\n self.model = Seq2Seq(\\n encoder_vocab_size=len(self.src_2_ids),\\n decoder_vocab_size=len(self.trg_2_ids),\\n embed_size=self.embed_size,\\n enc_hidden_size=self.hidden_size,\\n dec_hidden_size=self.hidden_size,\\n dropout=self.dropout\\n )\\n self.load_model()\\n self.model.to(device)\\n else:\\n raise ValueError(\\\"Model not found. Please train the model first.\\\")\\n self.model.eval()\\n result = []\\n for query in sentence_list:\\n out = []\\n tokens = [token.lower() for token in query]\\n tokens = [SOS_TOKEN] + tokens + [EOS_TOKEN]\\n src_ids = [self.src_2_ids[i] for i in tokens if i in self.src_2_ids]\\n\\n sos_idx = self.trg_2_ids[SOS_TOKEN]\\n src_tensor = torch.from_numpy(np.array(src_ids).reshape(1, -1)).long().to(device)\\n src_tensor_len = torch.from_numpy(np.array([len(src_ids)])).long().to(device)\\n sos_tensor = torch.Tensor([[self.trg_2_ids[SOS_TOKEN]]]).long().to(device)\\n translation, attn = self.model.translate(src_tensor, src_tensor_len, sos_tensor,\\n self.max_length)\\n translation = [self.id_2_trgs[i] for i in translation.data.cpu().numpy().reshape(-1) if\\n i in self.id_2_trgs]\\n for word in translation:\\n if word != EOS_TOKEN:\\n out.append(word)\\n else:\\n break\\n result.append(''.join(out))\\n return result\",\n \"def generate_predictions(inputs, model, tokenizer):\\n # Generate model results\\n outputs = model(**inputs)\\n\\n # Convert logit outputs into predictions for table cells and aggregation operators\\n predicted_table_cell_coords, predicted_aggregation_operators = tokenizer.convert_logits_to_predictions(\\n inputs,\\n outputs.logits.detach(),\\n outputs.logits_aggregation.detach()\\n )\\n\\n print(predicted_table_cell_coords)\\n print(predicted_aggregation_operators)\\n\\n # Return values\\n return predicted_table_cell_coords, predicted_aggregation_operators\",\n \"def predict(self, documents):\\n raise NotImplementedError()\",\n \"def predict_sentences(self, sents):\\n tkw=self.tkw\\n sents_attr=[]\\n sent_samples={\\n \\\"word_inputs\\\":[],\\n \\\"predicate_inputs\\\":[],\\n \\\"postags_inputs\\\":[]\\n }\\n print('prepare data')\\n for sid,sent in enumerate(sents):\\n if sid % (int(np.ceil(len(sents)/100))) == 0:\\n print(sid / len(sents))\\n sent_str = \\\" \\\".join(sent)\\n preds = [(word.i, str(word))\\n for word\\n in tkw.parser(sent_str)\\n if word.tag_.startswith(\\\"V\\\")]\\n num_of_samples = int(np.ceil(float(len(sent)) / self.sent_maxlen) * self.sent_maxlen)\\n pred_list=[]\\n for ind, pred in preds:\\n cur_sample=self.encode_inputs([self.create_sample(sent, ind)])\\n for name in [\\\"word_inputs\\\", \\\"predicate_inputs\\\", \\\"postags_inputs\\\"]:\\n sent_samples[name].append(cur_sample[name])\\n pred_list.append((ind, pred))\\n sents_attr.append((num_of_samples,pred_list,len(sent)))\\n for key in sent_samples:\\n sent_samples[key]=np.concatenate(sent_samples[key],axis=0)\\n print('predict data')\\n X = sent_samples\\n Y=self.model.predict(X)\\n # print(Y[0])\\n # print(Y[2])\\n res=[]\\n p=0\\n for attr in sents_attr:\\n num_of_samples,pred_list,sent_len=attr\\n sample_len=num_of_samples//self.sent_maxlen\\n ret=[]\\n for pid,(ind, pred) in enumerate(pred_list):\\n ret.append(((ind, pred),\\n [(self.consolidate_label(label), float(prob))\\n for (label, prob) in\\n self.transform_output_probs(Y[p+pid*sample_len:p+(pid+1)*sample_len], \\n get_prob = True).reshape(num_of_samples,\\n 2)[:sent_len]]))\\n res.append(ret)\\n p+=len(pred_list)*sample_len\\n return res\",\n \"def process_pred_list(pred_list: List) -> List:\\n result = []\\n for item in pred_list:\\n item_replace_special_char = item.replace(\\\"\\\\n\\\", \\\"\\\")\\n meta_data = item_replace_special_char.split(\\\":\\\")\\n label = meta_data[0]\\n confidence = float(meta_data[1].split(\\\"\\\\t\\\")[0].strip(\\\" \\\").strip(\\\"%\\\")) / 100\\n bbox_info = meta_data[2:]\\n bbox = get_bbox(bbox_info)\\n result.append([label, confidence, bbox])\\n return result\",\n \"def predict(self, data: pd.DataFrame):\\n \\n # call pipeline on question and text\\n return self._pipeline(question=data.iloc[0].question, context=data.iloc[0].context)\",\n \"def nlp(self, text):\\n # Runs the NLP model on the input.\\n doc = self.nlp_model(text)\\n\\n to = []\\n when = []\\n body = []\\n\\n # Group the labels into variables.\\n for token in doc:\\n if token.dep_ == \\\"TO\\\":\\n to.append(token.text)\\n elif token.dep_ == \\\"WHEN\\\":\\n when.append(token.text)\\n elif token.dep_ == \\\"BODY\\\":\\n body.append(token.text)\\n log.debug(\\\"%s %s\\\", token.text, token.dep_)\\n\\n # Get the time entity from the NLP model.\\n time = datetime.now()\\n if len(when) == 0:\\n time = time + timedelta(seconds=5)\\n else:\\n time = tc.parse_time(when)\\n\\n _body = \\\" \\\".join(body)\\n\\n return (to, time, _body)\",\n \"def process_prediction():\\n try:\\n input = np.array(request.json, dtype=np.float32)\\n prediction = predictor.predict(input).numpy().tolist()\\n return jsonify(result=prediction, status=\\\"Prediction succeeded\\\")\\n except Exception as err:\\n return jsonify(result=None, status=f\\\"Prediction failed: {err}\\\")\",\n \"def predict(self, data):\\n\\t\\tres = self.neuralNetworks.inference(self.dataCenter.process_inference_data(data))\\n\\t\\tprint(res)\",\n \"def predict(self, df):\\n # TODO: REMOVE type column\\n\\n tokenizer = self.__create_tokenizer_from_hub_module()\\n label_list = test_other[LABEL_COLUMN].unique().tolist()\\n #label_list = [0, 1]\\n test_features = self.__create_features(\\n df, label_list,\\n self.max_seq_len, tokenizer, 'text', 'type'\\n )\\n\\n preds = []\\n if type(self.model) == tf.estimator.Estimator:\\n # Is trained\\n input_fn = input_fn_builder(\\n features=test_features,\\n seq_length=self.max_seq_len,\\n is_training=False,\\n drop_remainder=False)\\n pred = self.model.predict(input_fn=input_fn)\\n for p in pred:\\n preds.append(p)\\n else:\\n # Is loaded from a SavedModel\\n # Format inputs\\n inpu = {\\n 'label_ids': np.array([x.label_id for x in test_features]).reshape(-1,),\\n 'input_ids': np.array([x.input_ids for x in test_features]).reshape(-1, self.max_seq_len),\\n 'input_mask': np.array([x.input_mask for x in test_features]).reshape(-1, self.max_seq_len),\\n 'segment_ids': np.array([x.segment_ids for x in test_features]).reshape(-1, self.max_seq_len)\\n }\\n preds = self.model(inpu)\\n\\n return preds\",\n \"def predict(self, sentences, batch_size=32):\\n train_encodings = self.tokenizer(sentences,\\n truncation=True,\\n padding=True,\\n max_length=500)\\n\\n train_dataset = TextDataset(train_encodings)\\n\\n loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)\\n collect_outputs = []\\n\\n with torch.no_grad():\\n for batch in loader:\\n input_ids = batch['input_ids']\\n attention_mask = batch['attention_mask']\\n\\n outputs = self.model(input_ids, attention_mask=attention_mask)\\n collect_outputs.extend(torch.argmax(outputs[\\\"logits\\\"], axis=1).cpu().numpy().tolist())\\n\\n return [self.emotion_map[k] for k in collect_outputs]\",\n \"def predict(self, text, threshold=.0):\\n if not self.k_model or not self.w2v_model:\\n raise RuntimeError(\\\"Model not in memory, please load it train new model\\\")\\n start_at = time.time()\\n x_test = keras.preprocessing.sequence.pad_sequences(\\n self.tokenizer.texts_to_sequences(gensim.utils.simple_preprocess(text)),\\n maxlen=self.k_max_sequence_len)\\n # Predict\\n confidences = self.k_model.predict(x_test)[0]\\n # Get mex prediction\\n idx = np.argmax(confidences)\\n elapsed_time = time.time() - start_at\\n if float(confidences[idx]) > threshold:\\n return {\\\"label\\\": self.label_encoder.classes_[idx], \\\"confidence\\\": float(confidences[idx]),\\n \\\"elapsed_time\\\": elapsed_time}\\n return {\\\"label\\\": \\\"__OTHER__\\\", \\\"confidence\\\": float(confidences[idx]), \\\"elapsed_time\\\": elapsed_time}\",\n \"def get_predictions():\\n\\n print(\\\"OK1\\\");\\n print(\\\"OK2\\\");\\n return;\",\n \"def test_simulated_module_annotation_predict(simulated_ann_predict_vcf,\\n simulated_ann_predict_csv):\\n annotate(SIMULATED_VCF, TEST_VCF, predict=True, csv=True)\\n with open(TEST_VCF) as out:\\n assert simulated_ann_predict_vcf.read() == out.read()\\n with open(TEST_CSV) as out:\\n assert simulated_ann_predict_csv.read() == out.read()\",\n \"def postprocess_for_inference(self,\\n prediction: Dict[str, torch.Tensor],\\n *args, **kwargs,\\n ) -> Dict[str, torch.Tensor]:\\n return {\\\"pred_seg\\\": self.logits_convert_fn(prediction[\\\"seg_logits\\\"])}\",\n \"def postprocess_model_outputs(self, predictions, expected):\\n\\n predictions = {k: t.numpy() for k, t in predictions.items()}\\n\\n return predictions, expected\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61501306","0.6139516","0.60400605","0.5975302","0.5914858","0.5826979","0.582425","0.57627505","0.5746949","0.5707061","0.56706715","0.5667077","0.5660581","0.5609151","0.56070286","0.5595583","0.55625534","0.5559505","0.5535425","0.55325687","0.55043447","0.5487266","0.5471245","0.54620105","0.5452101","0.5431067","0.54127175","0.54061115","0.5394219","0.5383141","0.53379613","0.5315984","0.53150105","0.530938","0.52990335","0.5296995","0.52944964","0.5294017","0.52839446","0.5271319","0.52647734","0.52579874","0.52575916","0.52549595","0.52535117","0.5253132","0.5237644","0.5237147","0.5232579","0.52319396","0.5210438","0.52048725","0.51949036","0.5187168","0.51850075","0.51769716","0.5176448","0.51751906","0.5174313","0.5157477","0.51509225","0.51499426","0.513733","0.51366246","0.51339567","0.512711","0.5117724","0.5116776","0.51116675","0.5110975","0.5100446","0.509966","0.50972074","0.50930756","0.50839806","0.5083089","0.5072228","0.5060763","0.50594574","0.50526667","0.5051976","0.5045989","0.50447994","0.50423163","0.5034844","0.50345516","0.50324214","0.5030526","0.50272053","0.50246716","0.5023672","0.5023631","0.50184834","0.5014244","0.5011813","0.5011603","0.500754","0.5004658","0.50017524","0.49968466"],"string":"[\n \"0.61501306\",\n \"0.6139516\",\n \"0.60400605\",\n \"0.5975302\",\n \"0.5914858\",\n \"0.5826979\",\n \"0.582425\",\n \"0.57627505\",\n \"0.5746949\",\n \"0.5707061\",\n \"0.56706715\",\n \"0.5667077\",\n \"0.5660581\",\n \"0.5609151\",\n \"0.56070286\",\n \"0.5595583\",\n \"0.55625534\",\n \"0.5559505\",\n \"0.5535425\",\n \"0.55325687\",\n \"0.55043447\",\n \"0.5487266\",\n \"0.5471245\",\n \"0.54620105\",\n \"0.5452101\",\n \"0.5431067\",\n \"0.54127175\",\n \"0.54061115\",\n \"0.5394219\",\n \"0.5383141\",\n \"0.53379613\",\n \"0.5315984\",\n \"0.53150105\",\n \"0.530938\",\n \"0.52990335\",\n \"0.5296995\",\n \"0.52944964\",\n \"0.5294017\",\n \"0.52839446\",\n \"0.5271319\",\n \"0.52647734\",\n \"0.52579874\",\n \"0.52575916\",\n \"0.52549595\",\n \"0.52535117\",\n \"0.5253132\",\n \"0.5237644\",\n \"0.5237147\",\n \"0.5232579\",\n \"0.52319396\",\n \"0.5210438\",\n \"0.52048725\",\n \"0.51949036\",\n \"0.5187168\",\n \"0.51850075\",\n \"0.51769716\",\n \"0.5176448\",\n \"0.51751906\",\n \"0.5174313\",\n \"0.5157477\",\n \"0.51509225\",\n \"0.51499426\",\n \"0.513733\",\n \"0.51366246\",\n \"0.51339567\",\n \"0.512711\",\n \"0.5117724\",\n \"0.5116776\",\n \"0.51116675\",\n \"0.5110975\",\n \"0.5100446\",\n \"0.509966\",\n \"0.50972074\",\n \"0.50930756\",\n \"0.50839806\",\n \"0.5083089\",\n \"0.5072228\",\n \"0.5060763\",\n \"0.50594574\",\n \"0.50526667\",\n \"0.5051976\",\n \"0.5045989\",\n \"0.50447994\",\n \"0.50423163\",\n \"0.5034844\",\n \"0.50345516\",\n \"0.50324214\",\n \"0.5030526\",\n \"0.50272053\",\n \"0.50246716\",\n \"0.5023672\",\n \"0.5023631\",\n \"0.50184834\",\n \"0.5014244\",\n \"0.5011813\",\n \"0.5011603\",\n \"0.500754\",\n \"0.5004658\",\n \"0.50017524\",\n \"0.49968466\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6788969"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23396,"cells":{"query":{"kind":"string","value":"Get the user id of an unrecognized user."},"document":{"kind":"string","value":"def GetUserId(odb, username, add_alt=0):\n\n print 'Unrecognized user %s.' % (username)\n alt = raw_input('Is this user in our DB (y/n)? ')\n if alt == 'y':\n main_name = raw_input('What is their primary username? ')\n user_id = odb.GetUserId(main_name)\n if user_id is None:\n user_id = GetUserId(odb, main_name)\n if add_alt:\n odb.AddAlt(user_id, username)\n return user_id\n\n else:\n return odb.AddUser(username)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _get_unknown_userid(self):\n cursor = self.conn.cursor()\n unknown_user_str = dbtypes.User.null\n cursor.execute(\"select id from users where uniqueid='%s'\" % unknown_user_str)\n return cursor.fetchone()[0]","def _get_user_id(self, user: Optional[Dict[str, Any]]) -> Optional[str]:\n return user[\"id\"] if user and \"id\" in user else None","def get_user_id(self, user):\n\n found_user = self.search(user)\n\n if found_user:\n return found_user[\"data\"][0][\"id\"]\n else:\n raise UserNotFound(\"User \" + user + \" not found.\")","def user_id(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"user_id\")","def user_id(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"user_id\")","def user_id(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"user_id\")","def test_get_user_id_unknown_user(self):\n print('(' + self.test_get_user_id.__name__+')',\n self.test_get_user_id.__doc__)\n self.assertIsNone(self.connection.get_user_id(\n NON_EXIST_PATIENT_USERNAME))","def user_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"user_id\")","def user_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"user_id\")","def user_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"user_id\")","def get_user_id():\n csc_name = get_user_csc_name()\n if csc_name:\n return csc_name\n haka_id = get_user_haka_identifier()\n if haka_id:\n return haka_id\n return None","def get_user_id(self):\n return self.id_user","def user_id(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"user_id\")","def get_user_id(self):\n raise NotImplementedError","def _get_uid(self, user):\n if not isinstance(user, int):\n user = pwd.getpwnam(user).pw_uid\n return user","def _get_user_id(self, name):\n try:\n apiResponse = twitchAPI.twitchAPIGet(\"/users\", {\"login\": name}) #Try to get user id from API\n userID = apiResponse[\"data\"][0][\"id\"]\n except (KeyError, APIUnavailable):\n userID = input(\"Please enter the user id of the user: \")\n except IndexError: #If Twitch API does not return user id\n print(\"That user does not exist on Twitch.\")\n userID = False\n return(userID)","async def user_id(\n event,\n user_id: ('user_id', 'Get the id of an other user?', 'user') = None,\n):\n if user_id is None:\n user_id = event.user.id\n \n return str(user_id)","def user_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"user_id\")","def user_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"user_id\")","def user_id(self):\n return self.status.user[\"id\"]","def get_user_id(sdk, username):\n users = sdk.users.get_by_username(username)[\"users\"]\n if not users:\n raise UserDoesNotExistError(username)\n return users[0][\"userUid\"]","def user_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"user_id\")","def user_id(self):\n # type: () -> string_types\n return self._user_id","def user_id(self):\n return json_loads(self.user_json).get('id')","def user_huid(self) -> Optional[UUID]:\n return self.user.user_huid","def user_id(self):\n return self._user_id","def user_id(self):\n return self._user_id","def user_id(self):\n return self._user_id","def user_id(self):\n return self._user_id","def user_id(self):\n return self._user_id","def __parse_user_id(self, data):\n if 'user_id' in data:\n return data['user_id']\n if 'user' in data:\n return data['user']['id']\n return None","def get_user_id():\n user_id = session.get(\"user_id\")\n return user_id if user_id else None","def get_user_id(self):\r\n message = self.q(css='BODY').text[0].strip()\r\n match = re.search(r' user_id ([^$]+)$', message)\r\n return match.groups()[0] if match else None","def validate_user_id(self, value):\n if not User.objects.filter(id=value).exists():\n raise serializers.ValidationError('User with this id does not exist.')\n return value","def unauthenticated_userid(self, request):\n credentials = self._get_credentials(request)\n if credentials:\n return credentials[0]","def user_id(self) -> str:\n return self._user_id","def user_id(self) -> str:\n return self._user_id","def unauthenticated_userid(self, request):\n params = self._get_auth_params(request)\n if params is None:\n return None\n return params.get(\"username\")","def get_user(self, user_id):\n return None # noqa: WPS324","def get_user_id(username):\n rv = query_db('select user_id from user where username = %s',\n [username], one=True)\n return rv[0] if rv else None","def unauthenticated_userid(self, request):\n authorization = request.headers.get('Authorization', '')\n try:\n authmeth, token = authorization.split(' ', 1)\n except ValueError:\n return None\n if authmeth.lower() != 'bearer':\n return None\n\n user_id, client_name = self._verify_token(token, request)\n\n # Don't add suffix if authentication failed, or no specific client name is configured\n if client_name is None or client_name == 'default':\n return user_id\n\n return '{}-{}'.format(user_id, client_name)","def get_user_id(username):\n rv = query_db('select user_id from user where username = ?',\n [username], one=True)\n return rv[0] if rv else None","def get_user_id(username):\n rv = query_db('select user_id from user where username = ?',\n [username], one=True)\n return rv[0] if rv else None","def get_user_id(username):\n rv = query_db('select user_id from user where username = ?',\n [username], one=True)\n return rv[0] if rv else None","def get_id(self, username):\n\n users_list = self.get_list()\n for user_info in users_list:\n if user_info['username'] == username:\n return user_info['id']\n # return None\n raise UserNotFoundException(\"User {0} not found\".format(username))","def get_user_id(user_name):\n try:\n return_msg = {}\n result = \"\"\n\n with UserDao() as userDao:\n user_id = userDao.getUserId(user_name) \n if user_id:\n return user_id\n else:\n return_msg['error'] = 'No such user'\n return return_msg\n\n except DB_Exception as e:\n db.close()\n return_msg[\"error\"] = e.args[1]\n return return_msg","def get_id(self) -> int:\n return self.user_id","def get_user_id(username):\n rv = query_db('select user_id from users where username = ?',\n [username], one=True)\n return rv[0] if rv else None","def get_user(self, user_id):\n\n i = self.gdb.nodes.indexes.get('users')\n if str(user_id).isalnum(): # numerical ID\n results = i.get('user_id', user_id) # always iterable\n else:\n results = i.get('screen_name', user_id) # always iterable\n\n if len(results) == 1:\n log.info('Found existing users, ID %s' % user_id)\n return results[0]\n else:\n log.info('No user in graph with ID %s' % user_id)\n return None","def get_identifier(self, request):\r\n try:\r\n return request._authentication_backend.get_identifier(request)\r\n except AttributeError:\r\n return 'nouser'","def get_identifier(self, request):\r\n if hasattr(request, 'user'):\r\n try:\r\n return request.user.get_username()\r\n except AttributeError:\r\n pass\r\n return 'nouser'","def get_slack_id(user):\n members = get_slack_users()\n user_name = [member for member in members if member.get('profile').get(\n 'email') == user['email']]\n return user_name[0].get('id') if user_name else ''","def get_user_id(username):\n rv = query_db('SELECT user_id FROM users where username = ?', \n [username], one=True)\n return rv[0] if rv else None","def user_invitation_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"user_invitation_id\")","def get_user_id(self, session, **kwargs):\n return None","def get_userid(self):\n user_id = \"\"\n if self.is_valid():\n user_id = self.__httprequest.session[\"lti_user_id\"]\n return user_id","def user_id(self):\n return lamin_user_settings().id","def __getUserIdByDCCConnection(self, c):\n try:\n UserId = self.__IpToUser[self.getIpStringByDCCConnection(c)]['userid']\n if UserId > 0:\n return UserId\n else:\n return NOT_AUTHED\n except KeyError:\n return NOT_AUTHED","def get_id(self):\n return self.user_id","def get_user_id(self, name):\n if '@' in name:\n params = {\n 'method': 'flickr.people.findByEmail',\n 'find_email': name\n }\n else:\n params = {\n 'method': 'flickr.people.findByUsername',\n 'username': name\n }\n response = self.oauth_session.get(self.API_ENDPOINT, params=params)\n json_response = response.json()\n if json_response['stat'] == 'fail':\n raise FlickrError(json_response['message'])\n return json_response['user']['id']","def context_user_id(self) -> str | None:\n return bytes_to_uuid_hex_or_none(self.context_user_id_bin)","def get_user_id(self, details, response):\n return response['uid']","def user_invitation_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"user_invitation_id\")","def user_id(self) -> Optional[pulumi.Input[str]]:\n warnings.warn(\"\"\"Deprecated. Unique ID of the user on whose behalf transfer is done.\"\"\", DeprecationWarning)\n pulumi.log.warn(\"\"\"user_id is deprecated: Deprecated. Unique ID of the user on whose behalf transfer is done.\"\"\")\n\n return pulumi.get(self, \"user_id\")","def get_user_id():\n return os.getuid()","def user_id(self) -> str:\n return self.app_config()[\"metadata.user.id\"]","def get_user_id(email):\n try:\n user = session.query(User).filter_by(email=email).one()\n return user.id\n except Exception as e:\n print 'No user found for ' + email + ': ' + str(e)\n return None","def get_user_id(self, details, response):\n return details[\"user_id\"]","def _get_user_id(self):\n auth_response = self._slack_client.api_call(\"auth.test\")\n\n if auth_response.get(\"ok\") is not None and auth_response[\"ok\"]:\n bot_id = auth_response[\"user_id\"]\n logger.info(\"Connected to slack with user id: {}\".format(bot_id))\n return bot_id\n else:\n raise PermissionError(auth_response[\"error\"])","def _get_user_id(username):\n user_id = select(u.user_id for u in UserInformationData if u.username == username).first()\n\n return user_id","def get_user_id(email):\n try:\n user = session.query(User).filter_by(email=email).one()\n return user.id\n except NoResultFound:\n return -1\n except MultipleResultsFound:\n return -1","def unauthenticated_userid(self, request):\n # we verify and extract the token here, so that we can\n # inspect the claims in the callback\n # if verify fails, we return None\n # any claims in the request.env\n claims = self._validate_access_token(request)\n if not claims:\n return None\n oidc = self._get_utility(request)\n return claims.get(oidc.userid_claim)","def getUserID(self):\n\t\treturn self.UserID","async def get_unverified(self, user, guild_id):\n\n doc = await self.db[str(guild_id)].find_one({'id': user.id})\n if doc is None or len(doc['unverified']) == 0:\n return -1\n else:\n return doc['unverified']","def get_user_id(event, destination=None):\n ret = event.source.user_id\n if not ret:\n ret = destination\n\n return ret","def get_current_user_id(data):\n current_user = api.user.get_current()\n if current_user:\n return current_user.getId()\n return None","def exists(cls, user_id):\n user_id = int(user_id)\n user = DB_USER_TABLE.get(doc_id=user_id)\n if not user:\n raise ValueError(f\"unknown user '{user_id}'\")\n return user_id","def get_user_id(username):\n if not user_exists(username):\n return -1\n sql = \"SELECT id \" \\\n \"FROM users \" \\\n \"WHERE username=:username\"\n result = db.session.execute(sql, {\"username\": username})\n user_id = result.fetchone()[0]\n return user_id","def get_user_id_or_ip():\r\n user_id = current_user.id if current_user.is_authenticated() else None\r\n user_ip = request.remote_addr or \"127.0.0.1\" if current_user.is_anonymous() else None\r\n return dict(user_id=user_id, user_ip=user_ip)","def userId(self) -> Optional[str]:\n return self.params.get(ChannelBuilder.PARAM_USER_ID, None)","def unauthenticated_userid(self, request):\n authorization = request.headers.get('Authorization')\n if authorization is None:\n return None\n token_object = find_token_for_authorization(authorization)\n if token_object is None:\n raise httpexceptions.HTTPUnauthorized(headers={\n 'WWW-Authenticate': 'Bearer realm=\"Weasyl\" error=\"invalid_token\"',\n })\n return token_object.userid","def get_keystone_v3_user_id(self, user_name):\n LOG_OBJ.debug(\"Get the user ID.\")\n\n _url = \"http://\" + self.host_ip + \":35357/v3/users?name=\" + \\\n str(user_name)\n _headers = {'x-auth-token': self.cloud_admin_info[\"token_domain\"],\n 'content-type': 'application/json'}\n _body = None\n\n response = self.request(\"GET\", _url, _headers, _body)\n\n if response is None:\n LOG_OBJ.error(\"No response from Server while getting the \"\n \"ID of user\")\n print (\"No response from Server while getting the \"\n \"ID of user\")\n return response\n\n if response.status not in [200, 201, 202, 203, 204]:\n LOG_OBJ.error(\"Get user ID Failed with status %s and error \"\n \": %s\" % (response.status, response.data))\n print (\"Get user ID Failed with status %s and error : %s\" %\n (response.status, response.data))\n return response.status\n\n output = json.loads(response.data)\n LOG_OBJ.info(\"user details : %s \" % output)\n print (\"user details : %s \" % output)\n if len(output['users']) != 1:\n LOG_OBJ.debug(\"No. of users with name %s is %s\"\n % (user_name, len(output['users'])))\n print(\"No. of users with name %s is %s\"\n % (user_name, len(output['users'])))\n return\n return output['users'][0]['id']","def users_user_id_get(userId): # noqa: E501\n base.check_session()\n return _cleanuser(_finduser(userId))","def get_user_id(username):\n # rv = query_db('select user_id from user where username = ?',\n # [username], one=True)\n # return rv[0] if rv else None\n # db = get_db()\n # print \"LOOKHERE UID\"\n rv = mongo.db.users.find_one({'username': username}, {'_id': []})\n print rv['_id']\n return rv['_id'] if rv else None","def user_id(self):\n return text_type(hash(self.username))","def get_user_id(session, email):\n try:\n user = session.query(User).filter_by(email=email).one()\n return user.id\n\n except BaseException:\n return None","def _get_or_create_user(self, user):\n self.cursor.execute('SELECT id FROM user WHERE fb_id=%s', (user['id'],))\n user_ids = self.cursor.fetchall()\n assert len(user_ids) <= 1, 'Too many users: ' + user_ids\n if len(user_ids) == 1:\n return user_ids[0][0]\n else:\n self.cursor.execute('INSERT INTO user (fb_id, name) VALUES (%s,%s)', (user['id'], user['name']))\n return self.cursor.lastrowid","def current_user_id(data_client):\n try:\n return data_client.current_user().id\n except tk.HTTPError as error:\n skip_or_fail(tk.HTTPError, \"ID of current user could not be retrieved!\", error)","def get_numeric_id(self, user_name):\n url = 'https://www.facebook.com/' + user_name\n self.get(url)\n source = self.page_source\n try:\n match = re.search(r\"profile_id=(\\d*)\", source)\n numeric_id = match.group(1)\n return numeric_id\n except (AttributeError, TypeError, KeyError, ValueError):\n log.error(\"Numeric ID not found, returning 0\")\n return 0","def get_auth0_id_of_user(email):\n return _get_auth0_id_of_user(email,\n token_redis_connection(),\n auth0_token(),\n current_app.config)","def get_id(self): \n\t\treturn (self.user_id)","async def getuserid(ctx, user=None):\n if user == None:\n await ctx.send(f\"Your user ID is `{ctx.message.author.id}`.\")\n elif user[:3] != \"<@!\":\n member = ctx.message.guild.get_member_named(user)\n await ctx.send(f\"The user ID of {user} is: `{member.id}`\")\n else:\n user = user.replace(\"<@!\", \"\").replace(\">\", \"\")\n await ctx.send(f\"The user ID of <@{user}> is `{user}`.\")","def unique_id_for_user(user):\r\n # Setting course_id to '' makes it not affect the generated hash,\r\n # and thus produce the old per-student anonymous id\r\n return anonymous_id_for_user(user, None)","def get_user_id(lookup_value, lookup_type='email'):\n lookup_type = _validate_lookup_type(lookup_type)\n if '@' not in lookup_value:\n exception_msg = f\"The lookup type is 'email' but '{lookup_value}' is not a valid email address.\"\n raise errors.exceptions.LookupMismatchError(exception_msg)\n user_data = core.get_data('people', lookup_value, lookup_type, return_json=True)\n user_id = user_data['id']\n return user_id","def get_userid():\n return _userid()","def test_get_user_non_exist_id(self):\n print('(' + self.test_get_user_non_exist_id.__name__+')',\n self.test_get_user_non_exist_id.__doc__)\n self.assertIsNone(self.connection.get_user(NON_EXIST_PATIENT_USERNAME))","def get_user_id(email):\n try:\n user = session.query(User).filter_by(email=email).one()\n return user.id\n except:\n return None","def get_current_user_id():\n user = get_current_user()\n return user.pk if user and user.is_authenticated else None","def custom_user_id(self):\n # type: () -> string_types\n return self._custom_user_id","async def get_user(self, user_target: str) -> Optional[User]:\n if len(user_target) >= 17:\n try:\n user_id = int(user_target)\n except ValueError:\n pass\n else:\n user: User = self.bot.get_user(user_id)\n if user is None:\n try:\n user = await self.bot.fetch_user(user_id)\n except NotFound:\n return None\n return user\n return None"],"string":"[\n \"def _get_unknown_userid(self):\\n cursor = self.conn.cursor()\\n unknown_user_str = dbtypes.User.null\\n cursor.execute(\\\"select id from users where uniqueid='%s'\\\" % unknown_user_str)\\n return cursor.fetchone()[0]\",\n \"def _get_user_id(self, user: Optional[Dict[str, Any]]) -> Optional[str]:\\n return user[\\\"id\\\"] if user and \\\"id\\\" in user else None\",\n \"def get_user_id(self, user):\\n\\n found_user = self.search(user)\\n\\n if found_user:\\n return found_user[\\\"data\\\"][0][\\\"id\\\"]\\n else:\\n raise UserNotFound(\\\"User \\\" + user + \\\" not found.\\\")\",\n \"def user_id(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def user_id(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def user_id(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def test_get_user_id_unknown_user(self):\\n print('(' + self.test_get_user_id.__name__+')',\\n self.test_get_user_id.__doc__)\\n self.assertIsNone(self.connection.get_user_id(\\n NON_EXIST_PATIENT_USERNAME))\",\n \"def user_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def user_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def user_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def get_user_id():\\n csc_name = get_user_csc_name()\\n if csc_name:\\n return csc_name\\n haka_id = get_user_haka_identifier()\\n if haka_id:\\n return haka_id\\n return None\",\n \"def get_user_id(self):\\n return self.id_user\",\n \"def user_id(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def get_user_id(self):\\n raise NotImplementedError\",\n \"def _get_uid(self, user):\\n if not isinstance(user, int):\\n user = pwd.getpwnam(user).pw_uid\\n return user\",\n \"def _get_user_id(self, name):\\n try:\\n apiResponse = twitchAPI.twitchAPIGet(\\\"/users\\\", {\\\"login\\\": name}) #Try to get user id from API\\n userID = apiResponse[\\\"data\\\"][0][\\\"id\\\"]\\n except (KeyError, APIUnavailable):\\n userID = input(\\\"Please enter the user id of the user: \\\")\\n except IndexError: #If Twitch API does not return user id\\n print(\\\"That user does not exist on Twitch.\\\")\\n userID = False\\n return(userID)\",\n \"async def user_id(\\n event,\\n user_id: ('user_id', 'Get the id of an other user?', 'user') = None,\\n):\\n if user_id is None:\\n user_id = event.user.id\\n \\n return str(user_id)\",\n \"def user_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def user_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def user_id(self):\\n return self.status.user[\\\"id\\\"]\",\n \"def get_user_id(sdk, username):\\n users = sdk.users.get_by_username(username)[\\\"users\\\"]\\n if not users:\\n raise UserDoesNotExistError(username)\\n return users[0][\\\"userUid\\\"]\",\n \"def user_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def user_id(self):\\n # type: () -> string_types\\n return self._user_id\",\n \"def user_id(self):\\n return json_loads(self.user_json).get('id')\",\n \"def user_huid(self) -> Optional[UUID]:\\n return self.user.user_huid\",\n \"def user_id(self):\\n return self._user_id\",\n \"def user_id(self):\\n return self._user_id\",\n \"def user_id(self):\\n return self._user_id\",\n \"def user_id(self):\\n return self._user_id\",\n \"def user_id(self):\\n return self._user_id\",\n \"def __parse_user_id(self, data):\\n if 'user_id' in data:\\n return data['user_id']\\n if 'user' in data:\\n return data['user']['id']\\n return None\",\n \"def get_user_id():\\n user_id = session.get(\\\"user_id\\\")\\n return user_id if user_id else None\",\n \"def get_user_id(self):\\r\\n message = self.q(css='BODY').text[0].strip()\\r\\n match = re.search(r' user_id ([^$]+)$', message)\\r\\n return match.groups()[0] if match else None\",\n \"def validate_user_id(self, value):\\n if not User.objects.filter(id=value).exists():\\n raise serializers.ValidationError('User with this id does not exist.')\\n return value\",\n \"def unauthenticated_userid(self, request):\\n credentials = self._get_credentials(request)\\n if credentials:\\n return credentials[0]\",\n \"def user_id(self) -> str:\\n return self._user_id\",\n \"def user_id(self) -> str:\\n return self._user_id\",\n \"def unauthenticated_userid(self, request):\\n params = self._get_auth_params(request)\\n if params is None:\\n return None\\n return params.get(\\\"username\\\")\",\n \"def get_user(self, user_id):\\n return None # noqa: WPS324\",\n \"def get_user_id(username):\\n rv = query_db('select user_id from user where username = %s',\\n [username], one=True)\\n return rv[0] if rv else None\",\n \"def unauthenticated_userid(self, request):\\n authorization = request.headers.get('Authorization', '')\\n try:\\n authmeth, token = authorization.split(' ', 1)\\n except ValueError:\\n return None\\n if authmeth.lower() != 'bearer':\\n return None\\n\\n user_id, client_name = self._verify_token(token, request)\\n\\n # Don't add suffix if authentication failed, or no specific client name is configured\\n if client_name is None or client_name == 'default':\\n return user_id\\n\\n return '{}-{}'.format(user_id, client_name)\",\n \"def get_user_id(username):\\n rv = query_db('select user_id from user where username = ?',\\n [username], one=True)\\n return rv[0] if rv else None\",\n \"def get_user_id(username):\\n rv = query_db('select user_id from user where username = ?',\\n [username], one=True)\\n return rv[0] if rv else None\",\n \"def get_user_id(username):\\n rv = query_db('select user_id from user where username = ?',\\n [username], one=True)\\n return rv[0] if rv else None\",\n \"def get_id(self, username):\\n\\n users_list = self.get_list()\\n for user_info in users_list:\\n if user_info['username'] == username:\\n return user_info['id']\\n # return None\\n raise UserNotFoundException(\\\"User {0} not found\\\".format(username))\",\n \"def get_user_id(user_name):\\n try:\\n return_msg = {}\\n result = \\\"\\\"\\n\\n with UserDao() as userDao:\\n user_id = userDao.getUserId(user_name) \\n if user_id:\\n return user_id\\n else:\\n return_msg['error'] = 'No such user'\\n return return_msg\\n\\n except DB_Exception as e:\\n db.close()\\n return_msg[\\\"error\\\"] = e.args[1]\\n return return_msg\",\n \"def get_id(self) -> int:\\n return self.user_id\",\n \"def get_user_id(username):\\n rv = query_db('select user_id from users where username = ?',\\n [username], one=True)\\n return rv[0] if rv else None\",\n \"def get_user(self, user_id):\\n\\n i = self.gdb.nodes.indexes.get('users')\\n if str(user_id).isalnum(): # numerical ID\\n results = i.get('user_id', user_id) # always iterable\\n else:\\n results = i.get('screen_name', user_id) # always iterable\\n\\n if len(results) == 1:\\n log.info('Found existing users, ID %s' % user_id)\\n return results[0]\\n else:\\n log.info('No user in graph with ID %s' % user_id)\\n return None\",\n \"def get_identifier(self, request):\\r\\n try:\\r\\n return request._authentication_backend.get_identifier(request)\\r\\n except AttributeError:\\r\\n return 'nouser'\",\n \"def get_identifier(self, request):\\r\\n if hasattr(request, 'user'):\\r\\n try:\\r\\n return request.user.get_username()\\r\\n except AttributeError:\\r\\n pass\\r\\n return 'nouser'\",\n \"def get_slack_id(user):\\n members = get_slack_users()\\n user_name = [member for member in members if member.get('profile').get(\\n 'email') == user['email']]\\n return user_name[0].get('id') if user_name else ''\",\n \"def get_user_id(username):\\n rv = query_db('SELECT user_id FROM users where username = ?', \\n [username], one=True)\\n return rv[0] if rv else None\",\n \"def user_invitation_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"user_invitation_id\\\")\",\n \"def get_user_id(self, session, **kwargs):\\n return None\",\n \"def get_userid(self):\\n user_id = \\\"\\\"\\n if self.is_valid():\\n user_id = self.__httprequest.session[\\\"lti_user_id\\\"]\\n return user_id\",\n \"def user_id(self):\\n return lamin_user_settings().id\",\n \"def __getUserIdByDCCConnection(self, c):\\n try:\\n UserId = self.__IpToUser[self.getIpStringByDCCConnection(c)]['userid']\\n if UserId > 0:\\n return UserId\\n else:\\n return NOT_AUTHED\\n except KeyError:\\n return NOT_AUTHED\",\n \"def get_id(self):\\n return self.user_id\",\n \"def get_user_id(self, name):\\n if '@' in name:\\n params = {\\n 'method': 'flickr.people.findByEmail',\\n 'find_email': name\\n }\\n else:\\n params = {\\n 'method': 'flickr.people.findByUsername',\\n 'username': name\\n }\\n response = self.oauth_session.get(self.API_ENDPOINT, params=params)\\n json_response = response.json()\\n if json_response['stat'] == 'fail':\\n raise FlickrError(json_response['message'])\\n return json_response['user']['id']\",\n \"def context_user_id(self) -> str | None:\\n return bytes_to_uuid_hex_or_none(self.context_user_id_bin)\",\n \"def get_user_id(self, details, response):\\n return response['uid']\",\n \"def user_invitation_id(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"user_invitation_id\\\")\",\n \"def user_id(self) -> Optional[pulumi.Input[str]]:\\n warnings.warn(\\\"\\\"\\\"Deprecated. Unique ID of the user on whose behalf transfer is done.\\\"\\\"\\\", DeprecationWarning)\\n pulumi.log.warn(\\\"\\\"\\\"user_id is deprecated: Deprecated. Unique ID of the user on whose behalf transfer is done.\\\"\\\"\\\")\\n\\n return pulumi.get(self, \\\"user_id\\\")\",\n \"def get_user_id():\\n return os.getuid()\",\n \"def user_id(self) -> str:\\n return self.app_config()[\\\"metadata.user.id\\\"]\",\n \"def get_user_id(email):\\n try:\\n user = session.query(User).filter_by(email=email).one()\\n return user.id\\n except Exception as e:\\n print 'No user found for ' + email + ': ' + str(e)\\n return None\",\n \"def get_user_id(self, details, response):\\n return details[\\\"user_id\\\"]\",\n \"def _get_user_id(self):\\n auth_response = self._slack_client.api_call(\\\"auth.test\\\")\\n\\n if auth_response.get(\\\"ok\\\") is not None and auth_response[\\\"ok\\\"]:\\n bot_id = auth_response[\\\"user_id\\\"]\\n logger.info(\\\"Connected to slack with user id: {}\\\".format(bot_id))\\n return bot_id\\n else:\\n raise PermissionError(auth_response[\\\"error\\\"])\",\n \"def _get_user_id(username):\\n user_id = select(u.user_id for u in UserInformationData if u.username == username).first()\\n\\n return user_id\",\n \"def get_user_id(email):\\n try:\\n user = session.query(User).filter_by(email=email).one()\\n return user.id\\n except NoResultFound:\\n return -1\\n except MultipleResultsFound:\\n return -1\",\n \"def unauthenticated_userid(self, request):\\n # we verify and extract the token here, so that we can\\n # inspect the claims in the callback\\n # if verify fails, we return None\\n # any claims in the request.env\\n claims = self._validate_access_token(request)\\n if not claims:\\n return None\\n oidc = self._get_utility(request)\\n return claims.get(oidc.userid_claim)\",\n \"def getUserID(self):\\n\\t\\treturn self.UserID\",\n \"async def get_unverified(self, user, guild_id):\\n\\n doc = await self.db[str(guild_id)].find_one({'id': user.id})\\n if doc is None or len(doc['unverified']) == 0:\\n return -1\\n else:\\n return doc['unverified']\",\n \"def get_user_id(event, destination=None):\\n ret = event.source.user_id\\n if not ret:\\n ret = destination\\n\\n return ret\",\n \"def get_current_user_id(data):\\n current_user = api.user.get_current()\\n if current_user:\\n return current_user.getId()\\n return None\",\n \"def exists(cls, user_id):\\n user_id = int(user_id)\\n user = DB_USER_TABLE.get(doc_id=user_id)\\n if not user:\\n raise ValueError(f\\\"unknown user '{user_id}'\\\")\\n return user_id\",\n \"def get_user_id(username):\\n if not user_exists(username):\\n return -1\\n sql = \\\"SELECT id \\\" \\\\\\n \\\"FROM users \\\" \\\\\\n \\\"WHERE username=:username\\\"\\n result = db.session.execute(sql, {\\\"username\\\": username})\\n user_id = result.fetchone()[0]\\n return user_id\",\n \"def get_user_id_or_ip():\\r\\n user_id = current_user.id if current_user.is_authenticated() else None\\r\\n user_ip = request.remote_addr or \\\"127.0.0.1\\\" if current_user.is_anonymous() else None\\r\\n return dict(user_id=user_id, user_ip=user_ip)\",\n \"def userId(self) -> Optional[str]:\\n return self.params.get(ChannelBuilder.PARAM_USER_ID, None)\",\n \"def unauthenticated_userid(self, request):\\n authorization = request.headers.get('Authorization')\\n if authorization is None:\\n return None\\n token_object = find_token_for_authorization(authorization)\\n if token_object is None:\\n raise httpexceptions.HTTPUnauthorized(headers={\\n 'WWW-Authenticate': 'Bearer realm=\\\"Weasyl\\\" error=\\\"invalid_token\\\"',\\n })\\n return token_object.userid\",\n \"def get_keystone_v3_user_id(self, user_name):\\n LOG_OBJ.debug(\\\"Get the user ID.\\\")\\n\\n _url = \\\"http://\\\" + self.host_ip + \\\":35357/v3/users?name=\\\" + \\\\\\n str(user_name)\\n _headers = {'x-auth-token': self.cloud_admin_info[\\\"token_domain\\\"],\\n 'content-type': 'application/json'}\\n _body = None\\n\\n response = self.request(\\\"GET\\\", _url, _headers, _body)\\n\\n if response is None:\\n LOG_OBJ.error(\\\"No response from Server while getting the \\\"\\n \\\"ID of user\\\")\\n print (\\\"No response from Server while getting the \\\"\\n \\\"ID of user\\\")\\n return response\\n\\n if response.status not in [200, 201, 202, 203, 204]:\\n LOG_OBJ.error(\\\"Get user ID Failed with status %s and error \\\"\\n \\\": %s\\\" % (response.status, response.data))\\n print (\\\"Get user ID Failed with status %s and error : %s\\\" %\\n (response.status, response.data))\\n return response.status\\n\\n output = json.loads(response.data)\\n LOG_OBJ.info(\\\"user details : %s \\\" % output)\\n print (\\\"user details : %s \\\" % output)\\n if len(output['users']) != 1:\\n LOG_OBJ.debug(\\\"No. of users with name %s is %s\\\"\\n % (user_name, len(output['users'])))\\n print(\\\"No. of users with name %s is %s\\\"\\n % (user_name, len(output['users'])))\\n return\\n return output['users'][0]['id']\",\n \"def users_user_id_get(userId): # noqa: E501\\n base.check_session()\\n return _cleanuser(_finduser(userId))\",\n \"def get_user_id(username):\\n # rv = query_db('select user_id from user where username = ?',\\n # [username], one=True)\\n # return rv[0] if rv else None\\n # db = get_db()\\n # print \\\"LOOKHERE UID\\\"\\n rv = mongo.db.users.find_one({'username': username}, {'_id': []})\\n print rv['_id']\\n return rv['_id'] if rv else None\",\n \"def user_id(self):\\n return text_type(hash(self.username))\",\n \"def get_user_id(session, email):\\n try:\\n user = session.query(User).filter_by(email=email).one()\\n return user.id\\n\\n except BaseException:\\n return None\",\n \"def _get_or_create_user(self, user):\\n self.cursor.execute('SELECT id FROM user WHERE fb_id=%s', (user['id'],))\\n user_ids = self.cursor.fetchall()\\n assert len(user_ids) <= 1, 'Too many users: ' + user_ids\\n if len(user_ids) == 1:\\n return user_ids[0][0]\\n else:\\n self.cursor.execute('INSERT INTO user (fb_id, name) VALUES (%s,%s)', (user['id'], user['name']))\\n return self.cursor.lastrowid\",\n \"def current_user_id(data_client):\\n try:\\n return data_client.current_user().id\\n except tk.HTTPError as error:\\n skip_or_fail(tk.HTTPError, \\\"ID of current user could not be retrieved!\\\", error)\",\n \"def get_numeric_id(self, user_name):\\n url = 'https://www.facebook.com/' + user_name\\n self.get(url)\\n source = self.page_source\\n try:\\n match = re.search(r\\\"profile_id=(\\\\d*)\\\", source)\\n numeric_id = match.group(1)\\n return numeric_id\\n except (AttributeError, TypeError, KeyError, ValueError):\\n log.error(\\\"Numeric ID not found, returning 0\\\")\\n return 0\",\n \"def get_auth0_id_of_user(email):\\n return _get_auth0_id_of_user(email,\\n token_redis_connection(),\\n auth0_token(),\\n current_app.config)\",\n \"def get_id(self): \\n\\t\\treturn (self.user_id)\",\n \"async def getuserid(ctx, user=None):\\n if user == None:\\n await ctx.send(f\\\"Your user ID is `{ctx.message.author.id}`.\\\")\\n elif user[:3] != \\\"<@!\\\":\\n member = ctx.message.guild.get_member_named(user)\\n await ctx.send(f\\\"The user ID of {user} is: `{member.id}`\\\")\\n else:\\n user = user.replace(\\\"<@!\\\", \\\"\\\").replace(\\\">\\\", \\\"\\\")\\n await ctx.send(f\\\"The user ID of <@{user}> is `{user}`.\\\")\",\n \"def unique_id_for_user(user):\\r\\n # Setting course_id to '' makes it not affect the generated hash,\\r\\n # and thus produce the old per-student anonymous id\\r\\n return anonymous_id_for_user(user, None)\",\n \"def get_user_id(lookup_value, lookup_type='email'):\\n lookup_type = _validate_lookup_type(lookup_type)\\n if '@' not in lookup_value:\\n exception_msg = f\\\"The lookup type is 'email' but '{lookup_value}' is not a valid email address.\\\"\\n raise errors.exceptions.LookupMismatchError(exception_msg)\\n user_data = core.get_data('people', lookup_value, lookup_type, return_json=True)\\n user_id = user_data['id']\\n return user_id\",\n \"def get_userid():\\n return _userid()\",\n \"def test_get_user_non_exist_id(self):\\n print('(' + self.test_get_user_non_exist_id.__name__+')',\\n self.test_get_user_non_exist_id.__doc__)\\n self.assertIsNone(self.connection.get_user(NON_EXIST_PATIENT_USERNAME))\",\n \"def get_user_id(email):\\n try:\\n user = session.query(User).filter_by(email=email).one()\\n return user.id\\n except:\\n return None\",\n \"def get_current_user_id():\\n user = get_current_user()\\n return user.pk if user and user.is_authenticated else None\",\n \"def custom_user_id(self):\\n # type: () -> string_types\\n return self._custom_user_id\",\n \"async def get_user(self, user_target: str) -> Optional[User]:\\n if len(user_target) >= 17:\\n try:\\n user_id = int(user_target)\\n except ValueError:\\n pass\\n else:\\n user: User = self.bot.get_user(user_id)\\n if user is None:\\n try:\\n user = await self.bot.fetch_user(user_id)\\n except NotFound:\\n return None\\n return user\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80115664","0.7302841","0.7226531","0.7225523","0.7225523","0.7088756","0.7004554","0.6994547","0.6994547","0.6994547","0.6941295","0.6934723","0.68709123","0.68640584","0.6849172","0.67509985","0.6687582","0.66480327","0.66480327","0.66307473","0.65980554","0.6598002","0.65929526","0.65900993","0.6577164","0.65690535","0.65690535","0.65690535","0.65690535","0.65690535","0.65668714","0.65222436","0.6497611","0.6489173","0.6483602","0.64777154","0.64777154","0.64718544","0.64329565","0.6416147","0.6415422","0.6350678","0.6350678","0.6350678","0.6348191","0.6345307","0.6291992","0.62916285","0.62675774","0.6251475","0.6247613","0.6234273","0.6230262","0.62213326","0.6212606","0.6199849","0.6186137","0.61792743","0.61688733","0.61626256","0.6160115","0.6151015","0.61078614","0.61064863","0.6091072","0.6083639","0.6078539","0.6074358","0.60724413","0.60682774","0.6063238","0.6062644","0.6059939","0.60513604","0.60440934","0.60346895","0.602944","0.60274035","0.60255975","0.6018312","0.60074234","0.600371","0.6001835","0.5982479","0.59699696","0.59676486","0.5958744","0.59524024","0.5951391","0.5947181","0.5941619","0.59333575","0.59324944","0.5931541","0.5913694","0.59034973","0.58985996","0.58970547","0.58896786","0.5889645"],"string":"[\n \"0.80115664\",\n \"0.7302841\",\n \"0.7226531\",\n \"0.7225523\",\n \"0.7225523\",\n \"0.7088756\",\n \"0.7004554\",\n \"0.6994547\",\n \"0.6994547\",\n \"0.6994547\",\n \"0.6941295\",\n \"0.6934723\",\n \"0.68709123\",\n \"0.68640584\",\n \"0.6849172\",\n \"0.67509985\",\n \"0.6687582\",\n \"0.66480327\",\n \"0.66480327\",\n \"0.66307473\",\n \"0.65980554\",\n \"0.6598002\",\n \"0.65929526\",\n \"0.65900993\",\n \"0.6577164\",\n \"0.65690535\",\n \"0.65690535\",\n \"0.65690535\",\n \"0.65690535\",\n \"0.65690535\",\n \"0.65668714\",\n \"0.65222436\",\n \"0.6497611\",\n \"0.6489173\",\n \"0.6483602\",\n \"0.64777154\",\n \"0.64777154\",\n \"0.64718544\",\n \"0.64329565\",\n \"0.6416147\",\n \"0.6415422\",\n \"0.6350678\",\n \"0.6350678\",\n \"0.6350678\",\n \"0.6348191\",\n \"0.6345307\",\n \"0.6291992\",\n \"0.62916285\",\n \"0.62675774\",\n \"0.6251475\",\n \"0.6247613\",\n \"0.6234273\",\n \"0.6230262\",\n \"0.62213326\",\n \"0.6212606\",\n \"0.6199849\",\n \"0.6186137\",\n \"0.61792743\",\n \"0.61688733\",\n \"0.61626256\",\n \"0.6160115\",\n \"0.6151015\",\n \"0.61078614\",\n \"0.61064863\",\n \"0.6091072\",\n \"0.6083639\",\n \"0.6078539\",\n \"0.6074358\",\n \"0.60724413\",\n \"0.60682774\",\n \"0.6063238\",\n \"0.6062644\",\n \"0.6059939\",\n \"0.60513604\",\n \"0.60440934\",\n \"0.60346895\",\n \"0.602944\",\n \"0.60274035\",\n \"0.60255975\",\n \"0.6018312\",\n \"0.60074234\",\n \"0.600371\",\n \"0.6001835\",\n \"0.5982479\",\n \"0.59699696\",\n \"0.59676486\",\n \"0.5958744\",\n \"0.59524024\",\n \"0.5951391\",\n \"0.5947181\",\n \"0.5941619\",\n \"0.59333575\",\n \"0.59324944\",\n \"0.5931541\",\n \"0.5913694\",\n \"0.59034973\",\n \"0.58985996\",\n \"0.58970547\",\n \"0.58896786\",\n \"0.5889645\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6174131"},"document_rank":{"kind":"string","value":"58"}}},{"rowIdx":23397,"cells":{"query":{"kind":"string","value":"Figure out a competitor id based on a userinput name."},"document":{"kind":"string","value":"def DecipherName(odb, winner_name, line, type, contest, round_nums):\n\n competitor_id = None\n competitors = odb.GetCompetitors(winner_name, type=type)\n if competitors and len(competitors) > 1:\n comps_in_round = []\n for comp in competitors:\n if odb.IsCompetitorInRounds(comp['CompetitorId'], contest, round_nums):\n comps_in_round.append(comp)\n competitors = comps_in_round\n\n # Now try just with people in the round\n if not competitors:\n print 'Couldn\\'t recognize competitor name for this prediction:'\n print '\"', line, '\"'\n comp_name = raw_input('Enter a name or leave blank to skip: ')\n if comp_name != '':\n competitor_id = DecipherName(odb, comp_name, line, type, contest,\n round_nums)\n elif len(competitors) > 1:\n for comp in competitors:\n if comp['Name'] == winner_name:\n return comp['CompetitorId']\n print 'Who is this prediction for?\\n\\n\"%s\"\\n' % (line)\n for comp in competitors:\n print \"%s, Id=%s\" % (comp['Name'], comp['CompetitorId'])\n competitor_id = raw_input('\\nEnter CompetitorId: ')\n if competitor_id == '':\n competitor_id = None\n else:\n competitor_id = competitors[0]['CompetitorId']\n\n if competitor_id is not None:\n competitor_id = int(competitor_id)\n\n return competitor_id"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_id(cls, name):\n assert name, 'name is empty'\n if name in cls._ids:\n return cls._ids[name]\n sql = \"SELECT id FROM hive_communities WHERE name = :name\"\n cid = DB.query_one(sql, name=name)\n if cid:\n cls._ids[name] = cid\n cls._names[cid] = name\n return cid","def person_id_for_name(name):\n person_ids = list(names.get(name.lower(), set()))\n if len(person_ids) == 0:\n return None\n elif len(person_ids) > 1:\n print(f\"Which '{name}'?\")\n for person_id in person_ids:\n person = people[person_id]\n name = person[\"name\"]\n birth = person[\"birth\"]\n print(f\"ID: {person_id}, Name: {name}, Birth: {birth}\")\n try:\n person_id = input(\"Intended Person ID: \")\n if person_id in person_ids:\n return person_id\n except ValueError:\n pass\n return None\n else:\n return person_ids[0]","def person_id_for_name(name):\n person_ids = list(names.get(name.lower(), set()))\n if len(person_ids) == 0:\n return None\n elif len(person_ids) > 1:\n print(f\"Which '{name}'?\")\n for person_id in person_ids:\n person = people[person_id]\n name = person[\"name\"]\n birth = person[\"birth\"]\n print(f\"ID: {person_id}, Name: {name}, Birth: {birth}\")\n try:\n person_id = input(\"Intended Person ID: \")\n if person_id in person_ids:\n return person_id\n except ValueError:\n pass\n return None\n else:\n return person_ids[0]","def get_input_id_by_name(self, input_name):\n\n return self.get_input_by_name(input_name).id","def get_id_from_user():\n from bokeh.io import curdoc\n try:\n name = curdoc().session_context.request.arguments.get('id')[0]\n if isinstance(name, bytes):\n wc_id = name.decode()\n except (TypeError, KeyError, AttributeError):\n wc_id = '57a25492-4260-4a17-83c2-30526d67c7b1'\n\n return wc_id","def make_odorant_selector(name):\n return dcc.Input(\n id=\"cid_%s\" % name,\n placeholder=\"Enter a PubChem ID number...\",\n type=\"number\",\n value=None,\n )","def _get_user_id(self, name):\n try:\n apiResponse = twitchAPI.twitchAPIGet(\"/users\", {\"login\": name}) #Try to get user id from API\n userID = apiResponse[\"data\"][0][\"id\"]\n except (KeyError, APIUnavailable):\n userID = input(\"Please enter the user id of the user: \")\n except IndexError: #If Twitch API does not return user id\n print(\"That user does not exist on Twitch.\")\n userID = False\n return(userID)","def guiID(name):\r\n if not gGUIIDS.has_key(name):\r\n gGUIIDS[name] = wx.NewId()\r\n return gGUIIDS[name]","def get_id(self, name=None):\n\n # Support using integer IDs directly\n if isinstance(name, int):\n return name\n\n self.ensure_loaded()\n if name is not None:\n ems_systems = self.search('name', name.upper(), searchtype=\"match\")\n if ems_systems.empty:\n sys_names = self.list_all()['name'].to_list()\n raise ValueError(\n 'No matching systems found. You have access to: {0}'.format(sys_names))\n id = ems_systems.iloc[0]['id']\n else:\n ems_systems = self.list_all()\n if ems_systems.shape[0] == 1:\n id = ems_systems.iloc[0]['id']\n else:\n raise LookupError(\n 'Multiple ems systems found. Please select one from the available:\\n{0}'\n .format(ems_systems.loc[:, ['id', 'name']])\n )\n return id","def output_name_to_id(self, name):\n for i, o in list(r.outputs.items()):\n if o.name == name:\n return i","def name_to_id(self, name, add_if_missing=False):\n if isinstance(name, basestring):\n # lookup name or assign new\n if name not in self.names:\n if not add_if_missing:\n raise ValueError(\"name \" + name + \" not found\")\n # Use an empty slot in the list if one exists.\n try:\n id_ = self.names.index(None)\n self.names[id_] = name\n self.hashesperid[id_] = 0\n except ValueError:\n self.names.append(name)\n self.hashesperid = np.append(self.hashesperid, [0])\n id_ = self.names.index(name)\n else:\n # we were passed in a numerical id\n id_ = name\n return id_","def get_party_id_by_name(party_name: str) -> int:\n # Open a new connection\n db, cursor = db_connector.cursor()\n use_name = \"\"\n for chars in party_name:\n if chars in [\"'\", '\"']:\n use_name = use_name + \"%\"\n else:\n use_name = use_name + chars\n query = \"select id from party where name LIKE '{}';\".format(use_name)\n cursor.execute(query)\n data = cursor.fetchall()\n db.disconnect()\n return data[0][0]","def get_id_from_name(self, the_name: str) -> Optional[str]:\n\n prospective = None\n for key, value in self.labels.items():\n if value == the_name:\n prospective = key\n break\n return prospective","def ask_for_interface():\n return input(\"Interface name : \")","def get_id():\n inp = option_text('Input widget id:')\n add_to_collected('id', inp)\n OPTIONS['id'] = inp\n return","def getName():\n\n tcflush(sys.stdin, TCIFLUSH)\n name = input(\" You say:\\n \")\n updateNameDatabase(name)\n return name","def id_from_input_path(input):\n input = get_base_name(input)\n parts = input.split('_')\n parts = parts[:-2]\n input = '_'.join(parts)\n return input","def get_id_from_name(slack_client, name):\n api_call = slack_client.api_call(\"users.list\")\n if api_call.get('ok'):\n # retrieve all users so we can find our bot\n users = api_call.get('members')\n for user in users:\n if 'name' in user and user['name'] == name:\n return user.get('id')\n return None","def get_bank_id_by_name(bank_name: str) -> int:\n # Open a new connection\n db, cursor = db_connector.cursor()\n\n query = \"select id from bank where name = '{}';\".format(bank_name)\n cursor.execute(query)\n data = cursor.fetchall()\n db.disconnect()\n return data[0][0]","def get_supplier_id_by_name(supplier_name: str) -> int:\n # Open a new connection\n db, cursor = db_connector.cursor()\n use_name = \"\"\n for chars in supplier_name:\n if chars in [\"'\", '\"']:\n use_name = use_name + \"%\"\n else:\n use_name = use_name+chars\n\n query = \"select id from supplier where name LIKE '{}'\".format(str(use_name))\n cursor.execute(query)\n data = cursor.fetchall()\n db.disconnect()\n return data[0][0]","def find_supercomputer_id():\n hostname = socket.gethostname()\n if hostname.startswith('john') or hostname.startswith('farnarkle'):\n return 1\n elif hostname.startswith('mwa') or hostname.startswith('garrawarla'):\n return 2\n elif hostname.startswith('x86') or hostname.startswith('arm'):\n return 3\n else:\n logger.error('Unknown computer {}. Exiting'.format(hostname))\n sys.exit(1)","def getPlayerIDFromName(name):\n\n # Connect to the database.\n conn, c = main.connect()\n\n # Select the player that matches the name.\n SQL = \"SELECT playerID FROM player WHERE playerName=%s\"\n data = (name, )\n c.execute(SQL, data)\n\n toReturn = c.fetchone()\n\n conn.commit()\n conn.close()\n\n # Only return the first result\n return toReturn[0]","def validated_id(cls, name):\n if name:\n if name in cls._ids:\n return cls._ids[name]\n if cls.validated_name(name):\n if Accounts.exists(name):\n return cls.get_id(name)\n return None","def club_id(self, club_name):\r\n # UTF-8 comparison\r\n headers = {\"Content-type\": \"application/x-www-form-urlencoded\", \"Accept\": \"text/plain\",\r\n 'Referer': 'http://' + self.domain + '/', \"User-Agent\": user_agent}\r\n req = self.session.get('http://' + self.domain, headers=headers).content\r\n soup = BeautifulSoup(req, \"html.parser\")\r\n for i in soup.find('table', cellpadding=2).find_all('tr'):\r\n # Get teamid from the bets\r\n team1 = i.find('a')['title']\r\n team2 = i.find_all('a')[1]['title']\r\n if club_name == team1:\r\n return i.find('a')['href'].split('cid=')[1]\r\n elif club_name == team2:\r\n return i.find_all('a')[1]['href'].split('cid=')[1]\r\n return None","def get_name():\r\n name = input(\"What is the customer's name?: \")\r\n\r\n return name","def getPlayerName(i):\n while True:\n str_to_ask = \"Input name for Player \" + str(i) + \": \"\n name = input(str_to_ask).strip()\n if name != '': \n return name","def fetch_user_id(name):\n queryset = run_query(f\"SELECT id from users where name='{name}'\")\n output = queryset.fetchone()\n return output[0] if output else None","def get_identifier(self, request):\r\n username, api_key = self.extract_credentials(request)\r\n return username or 'nouser'","def convert_name_to_id(self, item_name): \n if item_name not in self.__dict_name_to_id or len(self.__dict_name_to_id[item_name]) > 1:\n return None\n return self.__dict_name_to_id[item_name][0]","def name_to_id(player_name):\n # This is fairly unsophisticated, just does a CRC32 on the name. Can be\n # optimized both for compute requirements and collision frequency using\n # another hashing algorithm.\n return binascii.crc32(player_name) & 0xFFFFFFFF","def get_name():\n return raw_input(\"What's your name? \")","def _ecc_id(self, ecc_type_name):\n return self.ecc_lookup[ecc_type_name]","def get_unique_id(name: str) -> str:\n name = get_data_source(name)\n suffixes = \".\".join(sfx for sfx in get_format_suffixes(name) if sfx)\n return re.sub(rf\"[.]{suffixes}$\", \"\", name)","def _idname(self, args: list = None, separator: str = ':'):\n components = [self._namespace(), self._podname(), self._container(), str(os.getpid())]\n if args is not None:\n components = components + [str(c) for c in args]\n return separator.join(components)","def getID():","def make_id(self, name: str) -> str:\n # id_cache is intentionally mutable\n id = self.id_cache.get(name)\n if not id:\n id = 'epub-%d' % self.env.new_serialno('epub')\n self.id_cache[name] = id\n return id","def get_pipeline_id(app='', name=''):\n return_id = None\n\n pipelines = get_all_pipelines(app=app)\n\n for pipeline in pipelines:\n LOG.debug('ID of %(name)s: %(id)s', pipeline)\n\n if pipeline['name'] == name:\n return_id = pipeline['id']\n LOG.info('Pipeline %s found, ID: %s', name, return_id)\n break\n\n return return_id","def get_well_id(self, name):\n\n idx = -1\n if type(name) is str:\n wells_names = self.wells_list()\n if name in wells_names:\n idx = wells_names.index(name)\n return(idx)","def get_identifier(self):","def get_data_id(self, name):\n\n idx = -1\n if type(name) is str:\n data_names = self.data_list()\n if name in data_names:\n idx = data_names.index(name)\n return(idx)","def unique_id(self) -> str:\n return \"_\".join([self._name, \"climate\"])","def get_company(self, name):\n return self.instance.company.id","def get_id_from_project_name(name: str) -> int:\n proj = db.session.query(TProjects).filter(TProjects.name == name).first()\n\n if proj is None:\n return -1\n\n return proj.id_project","def getComputer(this):\n comp_id = \"192.168.0.78\"\n return comp_id","def get_user_id(input_data, index, columns):\n user_id = input_data.loc[index, columns[0]]\n new_user_number = int(user_id.split('_')[1])\n return new_user_number","def id(user=None):\n command = \"id {0}\".format(user) if user else \"id\"\n system_command(command)","def get_name():\n print(\"\")\n name = input(\"Greetings, what do we call you?: \")\n return name","def _take_id(song_name, ID_prefix = 'CrossComp'):\n if not isinstance(song_name, str):\n warn(\"The given song_name ({}) is not a valid string. Returning a nan.\".format(song_name))\n return np.NaN\n match = re.search(r'{}-\\d+'.format(ID_prefix), song_name)\n if match is not None:\n return match.group(0)\n else:\n warn(\"CrossEra ID not found in song name \\\" {} \\\". Returning a nan.\".format(song_name))\n return np.NaN","def get_device_id_by_name(self, device_name):\n\n return self.get_device_by_name(device_name).id","def _get_suggested_id(self, info: dict) -> str:\n return info[CONF_NAME]","def name():\n\treturn input('Masukkan Nama : ')","def getPlayerID(self, cardname, rating):\n inputoverall = int(rating)\n inputcardname = cardname.lower()\n\n # First attempts to find ID in user input list\n for player in self.getPlayerListFromGUI():\n p_overall = int(player[2])\n p_cardname = player[1]\n p_cardname = p_cardname.lower()\n\n diff = p_overall - inputoverall\n\n pid = int(player[7])\n\n if (diff == 0):\n if (p_cardname == inputcardname):\n return pid\n\n # If not found in small player list, check master list (takes longer)\n with open('./data/players_database.csv', 'r', encoding=\"utf8\") as read_obj:\n csv_reader = reader(read_obj)\n\n for player in csv_reader:\n card = player[0]\n firstname = player[1]\n lastname = player[2]\n playerrating = player[3]\n id = player[4]\n\n diff = int(rating) - int(playerrating)\n\n fullname = firstname + \" \" + lastname\n id = int(id)\n if (diff == 0):\n if (cardname == card):\n return id\n if ((cardname == firstname) or (cardname == lastname)):\n return id\n if (fullname == cardname):\n return id\n\n # If not found, raise error\n log_event(self.queue, \"Player ID not found for: \" +\n str(cardname) + \" \" + str(rating))\n return 0","def get_client_id(name, sort_code):\n output = None\n\n sql = u'SELECT client_company_ID ' \\\n u'FROM client_company_TBL ' \\\n u'WHERE name = %s ' \\\n u'AND sort_code = %s'\n\n data = (name, sort_code)\n c.execute(sql, data)\n value = c.fetchone()\n if value is not None:\n output = value[0]\n\n return output","def giveId(what,string):\n if what == \"characters\":\n return list(engine.execute(f\"SELECT char_id FROM characters WHERE name ='{string}';\"))[0][0]\n elif what == \"episodes\":\n return list(engine.execute(f\"SELECT ep_id FROM episodes WHERE episode ='{string}';\"))[0][0]","def name(who):\r\n if who == 0:\r\n return 'Player 0'\r\n elif who == 1:\r\n return 'Player 1'\r\n else:\r\n return 'An unknown player'","def create_name() -> str:\r\n user_input = str(input(\"What is your name?\\n\"))\r\n return user_input","def get_ident():\n return -1","def get_id(category, name):\n item = Ingredients.query.filter_by(category=category).filter_by(name=name).first()\n if(item):\n return item.id \n else:\n return None","def fregion_id_by_name(name=None):\n f_region_types = FilteredElementCollector(doc).OfClass(FilledRegionType)\n for fregion_type in f_region_types:\n fregion_name = Element.Name.GetValue(fregion_type)\n if not name or name.lower() == fregion_name.lower():\n return fregion_type.Id\n # Loops through all, not found: use last\n else:\n print('Color not specified or not found.')\n return fregion_type.Id","async def _get_account_id(db, name):\n assert name, 'no account name specified'\n _id = await db.query_one(\"SELECT id FROM hive_accounts WHERE name = :n\", n=name)\n assert _id, \"account not found: `%s`\" % name\n return _id","def __assign_name_id(self):\n if not self.name_id:\n self.name_id = str(BaseTicketing.objects.create())","def get_user_choice():\n user_input = input('Your choice: ')\n return user_input","def get_id(self):\n return self.name","def get_id(self, name=None, code='default'):\n\t\tairport_id = self.search(Airport._col_tr[code], name)['id'].tolist()\n\t\treturn airport_id if len(airport_id) > 1 else airport_id[0]","def find_employee_id(self,name):\n nam = list(self.emp_id.values())\n val = nam.index(name)\n ids = list(self.emp_id.keys())\n id = ids[val]\n return id","def get_company(self, name):\n return self.store.company.id","def get_fastq_id(fastq_name):\n return fastq_name.split(' ')[0]","def id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"id\")","def id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"id\")","def get_game_id(self) -> str:\n return self.game_name_entry.get()","def get_id_from_name(item_name):\n try:\n return next(item for item in mapping if item[\"name\"].lower() == item_name.lower())[\"id\"]\n except StopIteration:\n return None","def make_uid(self) -> str:\n while True:\n uid = ''.join(secrets.choice(self.CHARS) for i in range(self.uid_length))\n\n if self.user_repo.get_by_uid(uid) is None:\n return uid","def get_opponent_of(self, name):\n log.debug('Opponent for '+name)\n opponent = self.get_feature_of(name, FIELD.OPPONENT)\n if not opponent:\n log.debug('--> opponent undefined')\n if ',' in opponent:\n log.debug('return random opponent from '+opponent)\n return random.choice(opponent.split(',')).strip()\n return opponent.strip()","def get_id_by_name(self, name):\n\n for category in self.category_list:\n if name == category.name:\n return category.id\n response = self.client._get(f\"/site.json\")[\"categories\"]\n for dic in response:\n if dic[\"name\"] == name:\n return dic[\"id\"]\n raise ValueError(\"no Category with given name has been found\")","def fetch_current_user_id(s):","def logical_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"logical_id\")","def logical_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"logical_id\")","def logical_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"logical_id\")","def logical_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"logical_id\")","def taskid(name):\n return \"(select id from event_type where name = '{}')\".format(name)","def test_explicit_identity_name(dummy_command):\n # get_identities will return some options.\n dummy_command.get_identities.return_value = {\n \"38EBD6F8903EC63C238B04C1067833814CE47CA3\": \"Developer ID Application: Example Corporation Ltd (Z2K4383DLE)\",\n \"11E77FB58F13F6108B38110D5D92233C58ED38C5\": \"iPhone Developer: Jane Smith (BXAH5H869S)\",\n }\n\n # The identity will be the one the user specified as an option.\n result = dummy_command.select_identity(\"iPhone Developer: Jane Smith (BXAH5H869S)\")\n\n assert result == (\n \"11E77FB58F13F6108B38110D5D92233C58ED38C5\",\n \"iPhone Developer: Jane Smith (BXAH5H869S)\",\n )\n\n # User input was not solicited\n assert dummy_command.input.prompts == []","def id_from_input(task_ids):\n\n while True:\n index = kb.getch()\n\n # Return none if no input\n if index == \"\":\n return None\n\n try:\n id = task_ids[int(index) - 1]\n except (IndexError, ValueError):\n print(\"Out of range.\")\n continue\n\n # Reject zero and negative numbers because they\n # work in lists and we accept only positive input\n if int(index) <= 0:\n print(\"Out of range.\")\n continue\n\n return id","def findUserNum(self, kvl):\n \n for k, v in kvl.items():\n if k == \"YourUserNum\":\n cid = int(v[0])\n return cid\n return None","def _ident(name: Optional[Union[quoted_name, str]]) -> Optional[str]:\n if name is None:\n return name\n elif isinstance(name, quoted_name):\n return str(name)\n elif isinstance(name, str):\n return name","def detect_own_id() -> str:\n\n pod = os.environ.get('POD_ID', None)\n if pod is not None:\n return pod\n\n user = getpass.getuser()\n host = socket.getfqdn()\n now = datetime.datetime.utcnow().isoformat()\n rnd = ''.join(random.choices('abcdefhijklmnopqrstuvwxyz0123456789', k=6))\n return f'{user}@{host}/{now}/{rnd}'","def org_id(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"org_id\")","def find_program(name):\r\n return name","def get_identifier(self, request):\r\n try:\r\n return request._authentication_backend.get_identifier(request)\r\n except AttributeError:\r\n return 'nouser'","def gets_user_name():\n name = raw_input(\"What's your name? \")\n return name","def get_frigate_entity_unique_id(\n config_entry_id: str, type_name: str, name: str\n) -> str:\n return f\"{config_entry_id}:{type_name}:{name}\"","def idn(self):\n\n if self.driver in [drivers.pyvisa, drivers.lgpib]:\n return self.ask('*idn?')","def get_archetype_id(archetype):\n archetype = archetype.lower()\n if archetype == 'warrior':\n return ARCH_WARRIOR_ID\n elif archetype == 'wizard':\n return ARCH_WIZARD_ID\n elif archetype == 'archer':\n return ARCH_ARCHER_ID\n elif archetype == 'cleric':\n return ARCH_CLERIC_ID\n else:\n l.error(\"There is no valid Archetype ID for: {}\".format(archetype))","def add_competitor(name):\n competitors.append(Competitor(name))","def get_name(self):\n name = input(\"What is your name? \")\n if len(name) > 0:\n self.name = name","def config_user_name() -> str:\n print(\"User not configured.\\nPlease enter your name: \")\n name = sys.stdin.readline().strip()\n\n return name","def runAskLeoIDDialog(self) -> Optional[str]:\n if g.unitTesting:\n return None\n message = (\n \"leoID.txt not found\\n\\n\" +\n \"Please enter an id that identifies you uniquely.\\n\" +\n \"Your cvs/bzr login name is a good choice.\\n\\n\" +\n \"Leo uses this id to uniquely identify nodes.\\n\\n\" +\n \"Your id must contain only letters and numbers\\n\" +\n \"and must be at least 3 characters in length.\")\n parent = None\n title = 'Enter Leo id'\n s, ok = QtWidgets.QInputDialog.getText(parent, title, message)\n\n return s","def get_available_id(self):\n n = 0\n while True:\n id = '<name_{}>'.format(n)\n if id not in self.database:\n break\n n += 1\n return id","def generateMinionID(self, machine_name):\n minion_id = self._removeWhitespaces(machine_name)\n return minion_id","def get_id(disk):\n\n #TODO\n return \"Unknown\"","def convert_chart_name_to_id(chart_name):\n ordered_coa = OrderedDict(chart_of_accounts)\n r = list(ordered_coa.keys()).index(chart_name)\n return r"],"string":"[\n \"def get_id(cls, name):\\n assert name, 'name is empty'\\n if name in cls._ids:\\n return cls._ids[name]\\n sql = \\\"SELECT id FROM hive_communities WHERE name = :name\\\"\\n cid = DB.query_one(sql, name=name)\\n if cid:\\n cls._ids[name] = cid\\n cls._names[cid] = name\\n return cid\",\n \"def person_id_for_name(name):\\n person_ids = list(names.get(name.lower(), set()))\\n if len(person_ids) == 0:\\n return None\\n elif len(person_ids) > 1:\\n print(f\\\"Which '{name}'?\\\")\\n for person_id in person_ids:\\n person = people[person_id]\\n name = person[\\\"name\\\"]\\n birth = person[\\\"birth\\\"]\\n print(f\\\"ID: {person_id}, Name: {name}, Birth: {birth}\\\")\\n try:\\n person_id = input(\\\"Intended Person ID: \\\")\\n if person_id in person_ids:\\n return person_id\\n except ValueError:\\n pass\\n return None\\n else:\\n return person_ids[0]\",\n \"def person_id_for_name(name):\\n person_ids = list(names.get(name.lower(), set()))\\n if len(person_ids) == 0:\\n return None\\n elif len(person_ids) > 1:\\n print(f\\\"Which '{name}'?\\\")\\n for person_id in person_ids:\\n person = people[person_id]\\n name = person[\\\"name\\\"]\\n birth = person[\\\"birth\\\"]\\n print(f\\\"ID: {person_id}, Name: {name}, Birth: {birth}\\\")\\n try:\\n person_id = input(\\\"Intended Person ID: \\\")\\n if person_id in person_ids:\\n return person_id\\n except ValueError:\\n pass\\n return None\\n else:\\n return person_ids[0]\",\n \"def get_input_id_by_name(self, input_name):\\n\\n return self.get_input_by_name(input_name).id\",\n \"def get_id_from_user():\\n from bokeh.io import curdoc\\n try:\\n name = curdoc().session_context.request.arguments.get('id')[0]\\n if isinstance(name, bytes):\\n wc_id = name.decode()\\n except (TypeError, KeyError, AttributeError):\\n wc_id = '57a25492-4260-4a17-83c2-30526d67c7b1'\\n\\n return wc_id\",\n \"def make_odorant_selector(name):\\n return dcc.Input(\\n id=\\\"cid_%s\\\" % name,\\n placeholder=\\\"Enter a PubChem ID number...\\\",\\n type=\\\"number\\\",\\n value=None,\\n )\",\n \"def _get_user_id(self, name):\\n try:\\n apiResponse = twitchAPI.twitchAPIGet(\\\"/users\\\", {\\\"login\\\": name}) #Try to get user id from API\\n userID = apiResponse[\\\"data\\\"][0][\\\"id\\\"]\\n except (KeyError, APIUnavailable):\\n userID = input(\\\"Please enter the user id of the user: \\\")\\n except IndexError: #If Twitch API does not return user id\\n print(\\\"That user does not exist on Twitch.\\\")\\n userID = False\\n return(userID)\",\n \"def guiID(name):\\r\\n if not gGUIIDS.has_key(name):\\r\\n gGUIIDS[name] = wx.NewId()\\r\\n return gGUIIDS[name]\",\n \"def get_id(self, name=None):\\n\\n # Support using integer IDs directly\\n if isinstance(name, int):\\n return name\\n\\n self.ensure_loaded()\\n if name is not None:\\n ems_systems = self.search('name', name.upper(), searchtype=\\\"match\\\")\\n if ems_systems.empty:\\n sys_names = self.list_all()['name'].to_list()\\n raise ValueError(\\n 'No matching systems found. You have access to: {0}'.format(sys_names))\\n id = ems_systems.iloc[0]['id']\\n else:\\n ems_systems = self.list_all()\\n if ems_systems.shape[0] == 1:\\n id = ems_systems.iloc[0]['id']\\n else:\\n raise LookupError(\\n 'Multiple ems systems found. Please select one from the available:\\\\n{0}'\\n .format(ems_systems.loc[:, ['id', 'name']])\\n )\\n return id\",\n \"def output_name_to_id(self, name):\\n for i, o in list(r.outputs.items()):\\n if o.name == name:\\n return i\",\n \"def name_to_id(self, name, add_if_missing=False):\\n if isinstance(name, basestring):\\n # lookup name or assign new\\n if name not in self.names:\\n if not add_if_missing:\\n raise ValueError(\\\"name \\\" + name + \\\" not found\\\")\\n # Use an empty slot in the list if one exists.\\n try:\\n id_ = self.names.index(None)\\n self.names[id_] = name\\n self.hashesperid[id_] = 0\\n except ValueError:\\n self.names.append(name)\\n self.hashesperid = np.append(self.hashesperid, [0])\\n id_ = self.names.index(name)\\n else:\\n # we were passed in a numerical id\\n id_ = name\\n return id_\",\n \"def get_party_id_by_name(party_name: str) -> int:\\n # Open a new connection\\n db, cursor = db_connector.cursor()\\n use_name = \\\"\\\"\\n for chars in party_name:\\n if chars in [\\\"'\\\", '\\\"']:\\n use_name = use_name + \\\"%\\\"\\n else:\\n use_name = use_name + chars\\n query = \\\"select id from party where name LIKE '{}';\\\".format(use_name)\\n cursor.execute(query)\\n data = cursor.fetchall()\\n db.disconnect()\\n return data[0][0]\",\n \"def get_id_from_name(self, the_name: str) -> Optional[str]:\\n\\n prospective = None\\n for key, value in self.labels.items():\\n if value == the_name:\\n prospective = key\\n break\\n return prospective\",\n \"def ask_for_interface():\\n return input(\\\"Interface name : \\\")\",\n \"def get_id():\\n inp = option_text('Input widget id:')\\n add_to_collected('id', inp)\\n OPTIONS['id'] = inp\\n return\",\n \"def getName():\\n\\n tcflush(sys.stdin, TCIFLUSH)\\n name = input(\\\" You say:\\\\n \\\")\\n updateNameDatabase(name)\\n return name\",\n \"def id_from_input_path(input):\\n input = get_base_name(input)\\n parts = input.split('_')\\n parts = parts[:-2]\\n input = '_'.join(parts)\\n return input\",\n \"def get_id_from_name(slack_client, name):\\n api_call = slack_client.api_call(\\\"users.list\\\")\\n if api_call.get('ok'):\\n # retrieve all users so we can find our bot\\n users = api_call.get('members')\\n for user in users:\\n if 'name' in user and user['name'] == name:\\n return user.get('id')\\n return None\",\n \"def get_bank_id_by_name(bank_name: str) -> int:\\n # Open a new connection\\n db, cursor = db_connector.cursor()\\n\\n query = \\\"select id from bank where name = '{}';\\\".format(bank_name)\\n cursor.execute(query)\\n data = cursor.fetchall()\\n db.disconnect()\\n return data[0][0]\",\n \"def get_supplier_id_by_name(supplier_name: str) -> int:\\n # Open a new connection\\n db, cursor = db_connector.cursor()\\n use_name = \\\"\\\"\\n for chars in supplier_name:\\n if chars in [\\\"'\\\", '\\\"']:\\n use_name = use_name + \\\"%\\\"\\n else:\\n use_name = use_name+chars\\n\\n query = \\\"select id from supplier where name LIKE '{}'\\\".format(str(use_name))\\n cursor.execute(query)\\n data = cursor.fetchall()\\n db.disconnect()\\n return data[0][0]\",\n \"def find_supercomputer_id():\\n hostname = socket.gethostname()\\n if hostname.startswith('john') or hostname.startswith('farnarkle'):\\n return 1\\n elif hostname.startswith('mwa') or hostname.startswith('garrawarla'):\\n return 2\\n elif hostname.startswith('x86') or hostname.startswith('arm'):\\n return 3\\n else:\\n logger.error('Unknown computer {}. Exiting'.format(hostname))\\n sys.exit(1)\",\n \"def getPlayerIDFromName(name):\\n\\n # Connect to the database.\\n conn, c = main.connect()\\n\\n # Select the player that matches the name.\\n SQL = \\\"SELECT playerID FROM player WHERE playerName=%s\\\"\\n data = (name, )\\n c.execute(SQL, data)\\n\\n toReturn = c.fetchone()\\n\\n conn.commit()\\n conn.close()\\n\\n # Only return the first result\\n return toReturn[0]\",\n \"def validated_id(cls, name):\\n if name:\\n if name in cls._ids:\\n return cls._ids[name]\\n if cls.validated_name(name):\\n if Accounts.exists(name):\\n return cls.get_id(name)\\n return None\",\n \"def club_id(self, club_name):\\r\\n # UTF-8 comparison\\r\\n headers = {\\\"Content-type\\\": \\\"application/x-www-form-urlencoded\\\", \\\"Accept\\\": \\\"text/plain\\\",\\r\\n 'Referer': 'http://' + self.domain + '/', \\\"User-Agent\\\": user_agent}\\r\\n req = self.session.get('http://' + self.domain, headers=headers).content\\r\\n soup = BeautifulSoup(req, \\\"html.parser\\\")\\r\\n for i in soup.find('table', cellpadding=2).find_all('tr'):\\r\\n # Get teamid from the bets\\r\\n team1 = i.find('a')['title']\\r\\n team2 = i.find_all('a')[1]['title']\\r\\n if club_name == team1:\\r\\n return i.find('a')['href'].split('cid=')[1]\\r\\n elif club_name == team2:\\r\\n return i.find_all('a')[1]['href'].split('cid=')[1]\\r\\n return None\",\n \"def get_name():\\r\\n name = input(\\\"What is the customer's name?: \\\")\\r\\n\\r\\n return name\",\n \"def getPlayerName(i):\\n while True:\\n str_to_ask = \\\"Input name for Player \\\" + str(i) + \\\": \\\"\\n name = input(str_to_ask).strip()\\n if name != '': \\n return name\",\n \"def fetch_user_id(name):\\n queryset = run_query(f\\\"SELECT id from users where name='{name}'\\\")\\n output = queryset.fetchone()\\n return output[0] if output else None\",\n \"def get_identifier(self, request):\\r\\n username, api_key = self.extract_credentials(request)\\r\\n return username or 'nouser'\",\n \"def convert_name_to_id(self, item_name): \\n if item_name not in self.__dict_name_to_id or len(self.__dict_name_to_id[item_name]) > 1:\\n return None\\n return self.__dict_name_to_id[item_name][0]\",\n \"def name_to_id(player_name):\\n # This is fairly unsophisticated, just does a CRC32 on the name. Can be\\n # optimized both for compute requirements and collision frequency using\\n # another hashing algorithm.\\n return binascii.crc32(player_name) & 0xFFFFFFFF\",\n \"def get_name():\\n return raw_input(\\\"What's your name? \\\")\",\n \"def _ecc_id(self, ecc_type_name):\\n return self.ecc_lookup[ecc_type_name]\",\n \"def get_unique_id(name: str) -> str:\\n name = get_data_source(name)\\n suffixes = \\\".\\\".join(sfx for sfx in get_format_suffixes(name) if sfx)\\n return re.sub(rf\\\"[.]{suffixes}$\\\", \\\"\\\", name)\",\n \"def _idname(self, args: list = None, separator: str = ':'):\\n components = [self._namespace(), self._podname(), self._container(), str(os.getpid())]\\n if args is not None:\\n components = components + [str(c) for c in args]\\n return separator.join(components)\",\n \"def getID():\",\n \"def make_id(self, name: str) -> str:\\n # id_cache is intentionally mutable\\n id = self.id_cache.get(name)\\n if not id:\\n id = 'epub-%d' % self.env.new_serialno('epub')\\n self.id_cache[name] = id\\n return id\",\n \"def get_pipeline_id(app='', name=''):\\n return_id = None\\n\\n pipelines = get_all_pipelines(app=app)\\n\\n for pipeline in pipelines:\\n LOG.debug('ID of %(name)s: %(id)s', pipeline)\\n\\n if pipeline['name'] == name:\\n return_id = pipeline['id']\\n LOG.info('Pipeline %s found, ID: %s', name, return_id)\\n break\\n\\n return return_id\",\n \"def get_well_id(self, name):\\n\\n idx = -1\\n if type(name) is str:\\n wells_names = self.wells_list()\\n if name in wells_names:\\n idx = wells_names.index(name)\\n return(idx)\",\n \"def get_identifier(self):\",\n \"def get_data_id(self, name):\\n\\n idx = -1\\n if type(name) is str:\\n data_names = self.data_list()\\n if name in data_names:\\n idx = data_names.index(name)\\n return(idx)\",\n \"def unique_id(self) -> str:\\n return \\\"_\\\".join([self._name, \\\"climate\\\"])\",\n \"def get_company(self, name):\\n return self.instance.company.id\",\n \"def get_id_from_project_name(name: str) -> int:\\n proj = db.session.query(TProjects).filter(TProjects.name == name).first()\\n\\n if proj is None:\\n return -1\\n\\n return proj.id_project\",\n \"def getComputer(this):\\n comp_id = \\\"192.168.0.78\\\"\\n return comp_id\",\n \"def get_user_id(input_data, index, columns):\\n user_id = input_data.loc[index, columns[0]]\\n new_user_number = int(user_id.split('_')[1])\\n return new_user_number\",\n \"def id(user=None):\\n command = \\\"id {0}\\\".format(user) if user else \\\"id\\\"\\n system_command(command)\",\n \"def get_name():\\n print(\\\"\\\")\\n name = input(\\\"Greetings, what do we call you?: \\\")\\n return name\",\n \"def _take_id(song_name, ID_prefix = 'CrossComp'):\\n if not isinstance(song_name, str):\\n warn(\\\"The given song_name ({}) is not a valid string. Returning a nan.\\\".format(song_name))\\n return np.NaN\\n match = re.search(r'{}-\\\\d+'.format(ID_prefix), song_name)\\n if match is not None:\\n return match.group(0)\\n else:\\n warn(\\\"CrossEra ID not found in song name \\\\\\\" {} \\\\\\\". Returning a nan.\\\".format(song_name))\\n return np.NaN\",\n \"def get_device_id_by_name(self, device_name):\\n\\n return self.get_device_by_name(device_name).id\",\n \"def _get_suggested_id(self, info: dict) -> str:\\n return info[CONF_NAME]\",\n \"def name():\\n\\treturn input('Masukkan Nama : ')\",\n \"def getPlayerID(self, cardname, rating):\\n inputoverall = int(rating)\\n inputcardname = cardname.lower()\\n\\n # First attempts to find ID in user input list\\n for player in self.getPlayerListFromGUI():\\n p_overall = int(player[2])\\n p_cardname = player[1]\\n p_cardname = p_cardname.lower()\\n\\n diff = p_overall - inputoverall\\n\\n pid = int(player[7])\\n\\n if (diff == 0):\\n if (p_cardname == inputcardname):\\n return pid\\n\\n # If not found in small player list, check master list (takes longer)\\n with open('./data/players_database.csv', 'r', encoding=\\\"utf8\\\") as read_obj:\\n csv_reader = reader(read_obj)\\n\\n for player in csv_reader:\\n card = player[0]\\n firstname = player[1]\\n lastname = player[2]\\n playerrating = player[3]\\n id = player[4]\\n\\n diff = int(rating) - int(playerrating)\\n\\n fullname = firstname + \\\" \\\" + lastname\\n id = int(id)\\n if (diff == 0):\\n if (cardname == card):\\n return id\\n if ((cardname == firstname) or (cardname == lastname)):\\n return id\\n if (fullname == cardname):\\n return id\\n\\n # If not found, raise error\\n log_event(self.queue, \\\"Player ID not found for: \\\" +\\n str(cardname) + \\\" \\\" + str(rating))\\n return 0\",\n \"def get_client_id(name, sort_code):\\n output = None\\n\\n sql = u'SELECT client_company_ID ' \\\\\\n u'FROM client_company_TBL ' \\\\\\n u'WHERE name = %s ' \\\\\\n u'AND sort_code = %s'\\n\\n data = (name, sort_code)\\n c.execute(sql, data)\\n value = c.fetchone()\\n if value is not None:\\n output = value[0]\\n\\n return output\",\n \"def giveId(what,string):\\n if what == \\\"characters\\\":\\n return list(engine.execute(f\\\"SELECT char_id FROM characters WHERE name ='{string}';\\\"))[0][0]\\n elif what == \\\"episodes\\\":\\n return list(engine.execute(f\\\"SELECT ep_id FROM episodes WHERE episode ='{string}';\\\"))[0][0]\",\n \"def name(who):\\r\\n if who == 0:\\r\\n return 'Player 0'\\r\\n elif who == 1:\\r\\n return 'Player 1'\\r\\n else:\\r\\n return 'An unknown player'\",\n \"def create_name() -> str:\\r\\n user_input = str(input(\\\"What is your name?\\\\n\\\"))\\r\\n return user_input\",\n \"def get_ident():\\n return -1\",\n \"def get_id(category, name):\\n item = Ingredients.query.filter_by(category=category).filter_by(name=name).first()\\n if(item):\\n return item.id \\n else:\\n return None\",\n \"def fregion_id_by_name(name=None):\\n f_region_types = FilteredElementCollector(doc).OfClass(FilledRegionType)\\n for fregion_type in f_region_types:\\n fregion_name = Element.Name.GetValue(fregion_type)\\n if not name or name.lower() == fregion_name.lower():\\n return fregion_type.Id\\n # Loops through all, not found: use last\\n else:\\n print('Color not specified or not found.')\\n return fregion_type.Id\",\n \"async def _get_account_id(db, name):\\n assert name, 'no account name specified'\\n _id = await db.query_one(\\\"SELECT id FROM hive_accounts WHERE name = :n\\\", n=name)\\n assert _id, \\\"account not found: `%s`\\\" % name\\n return _id\",\n \"def __assign_name_id(self):\\n if not self.name_id:\\n self.name_id = str(BaseTicketing.objects.create())\",\n \"def get_user_choice():\\n user_input = input('Your choice: ')\\n return user_input\",\n \"def get_id(self):\\n return self.name\",\n \"def get_id(self, name=None, code='default'):\\n\\t\\tairport_id = self.search(Airport._col_tr[code], name)['id'].tolist()\\n\\t\\treturn airport_id if len(airport_id) > 1 else airport_id[0]\",\n \"def find_employee_id(self,name):\\n nam = list(self.emp_id.values())\\n val = nam.index(name)\\n ids = list(self.emp_id.keys())\\n id = ids[val]\\n return id\",\n \"def get_company(self, name):\\n return self.store.company.id\",\n \"def get_fastq_id(fastq_name):\\n return fastq_name.split(' ')[0]\",\n \"def id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"id\\\")\",\n \"def id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"id\\\")\",\n \"def get_game_id(self) -> str:\\n return self.game_name_entry.get()\",\n \"def get_id_from_name(item_name):\\n try:\\n return next(item for item in mapping if item[\\\"name\\\"].lower() == item_name.lower())[\\\"id\\\"]\\n except StopIteration:\\n return None\",\n \"def make_uid(self) -> str:\\n while True:\\n uid = ''.join(secrets.choice(self.CHARS) for i in range(self.uid_length))\\n\\n if self.user_repo.get_by_uid(uid) is None:\\n return uid\",\n \"def get_opponent_of(self, name):\\n log.debug('Opponent for '+name)\\n opponent = self.get_feature_of(name, FIELD.OPPONENT)\\n if not opponent:\\n log.debug('--> opponent undefined')\\n if ',' in opponent:\\n log.debug('return random opponent from '+opponent)\\n return random.choice(opponent.split(',')).strip()\\n return opponent.strip()\",\n \"def get_id_by_name(self, name):\\n\\n for category in self.category_list:\\n if name == category.name:\\n return category.id\\n response = self.client._get(f\\\"/site.json\\\")[\\\"categories\\\"]\\n for dic in response:\\n if dic[\\\"name\\\"] == name:\\n return dic[\\\"id\\\"]\\n raise ValueError(\\\"no Category with given name has been found\\\")\",\n \"def fetch_current_user_id(s):\",\n \"def logical_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"logical_id\\\")\",\n \"def logical_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"logical_id\\\")\",\n \"def logical_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"logical_id\\\")\",\n \"def logical_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"logical_id\\\")\",\n \"def taskid(name):\\n return \\\"(select id from event_type where name = '{}')\\\".format(name)\",\n \"def test_explicit_identity_name(dummy_command):\\n # get_identities will return some options.\\n dummy_command.get_identities.return_value = {\\n \\\"38EBD6F8903EC63C238B04C1067833814CE47CA3\\\": \\\"Developer ID Application: Example Corporation Ltd (Z2K4383DLE)\\\",\\n \\\"11E77FB58F13F6108B38110D5D92233C58ED38C5\\\": \\\"iPhone Developer: Jane Smith (BXAH5H869S)\\\",\\n }\\n\\n # The identity will be the one the user specified as an option.\\n result = dummy_command.select_identity(\\\"iPhone Developer: Jane Smith (BXAH5H869S)\\\")\\n\\n assert result == (\\n \\\"11E77FB58F13F6108B38110D5D92233C58ED38C5\\\",\\n \\\"iPhone Developer: Jane Smith (BXAH5H869S)\\\",\\n )\\n\\n # User input was not solicited\\n assert dummy_command.input.prompts == []\",\n \"def id_from_input(task_ids):\\n\\n while True:\\n index = kb.getch()\\n\\n # Return none if no input\\n if index == \\\"\\\":\\n return None\\n\\n try:\\n id = task_ids[int(index) - 1]\\n except (IndexError, ValueError):\\n print(\\\"Out of range.\\\")\\n continue\\n\\n # Reject zero and negative numbers because they\\n # work in lists and we accept only positive input\\n if int(index) <= 0:\\n print(\\\"Out of range.\\\")\\n continue\\n\\n return id\",\n \"def findUserNum(self, kvl):\\n \\n for k, v in kvl.items():\\n if k == \\\"YourUserNum\\\":\\n cid = int(v[0])\\n return cid\\n return None\",\n \"def _ident(name: Optional[Union[quoted_name, str]]) -> Optional[str]:\\n if name is None:\\n return name\\n elif isinstance(name, quoted_name):\\n return str(name)\\n elif isinstance(name, str):\\n return name\",\n \"def detect_own_id() -> str:\\n\\n pod = os.environ.get('POD_ID', None)\\n if pod is not None:\\n return pod\\n\\n user = getpass.getuser()\\n host = socket.getfqdn()\\n now = datetime.datetime.utcnow().isoformat()\\n rnd = ''.join(random.choices('abcdefhijklmnopqrstuvwxyz0123456789', k=6))\\n return f'{user}@{host}/{now}/{rnd}'\",\n \"def org_id(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"org_id\\\")\",\n \"def find_program(name):\\r\\n return name\",\n \"def get_identifier(self, request):\\r\\n try:\\r\\n return request._authentication_backend.get_identifier(request)\\r\\n except AttributeError:\\r\\n return 'nouser'\",\n \"def gets_user_name():\\n name = raw_input(\\\"What's your name? \\\")\\n return name\",\n \"def get_frigate_entity_unique_id(\\n config_entry_id: str, type_name: str, name: str\\n) -> str:\\n return f\\\"{config_entry_id}:{type_name}:{name}\\\"\",\n \"def idn(self):\\n\\n if self.driver in [drivers.pyvisa, drivers.lgpib]:\\n return self.ask('*idn?')\",\n \"def get_archetype_id(archetype):\\n archetype = archetype.lower()\\n if archetype == 'warrior':\\n return ARCH_WARRIOR_ID\\n elif archetype == 'wizard':\\n return ARCH_WIZARD_ID\\n elif archetype == 'archer':\\n return ARCH_ARCHER_ID\\n elif archetype == 'cleric':\\n return ARCH_CLERIC_ID\\n else:\\n l.error(\\\"There is no valid Archetype ID for: {}\\\".format(archetype))\",\n \"def add_competitor(name):\\n competitors.append(Competitor(name))\",\n \"def get_name(self):\\n name = input(\\\"What is your name? \\\")\\n if len(name) > 0:\\n self.name = name\",\n \"def config_user_name() -> str:\\n print(\\\"User not configured.\\\\nPlease enter your name: \\\")\\n name = sys.stdin.readline().strip()\\n\\n return name\",\n \"def runAskLeoIDDialog(self) -> Optional[str]:\\n if g.unitTesting:\\n return None\\n message = (\\n \\\"leoID.txt not found\\\\n\\\\n\\\" +\\n \\\"Please enter an id that identifies you uniquely.\\\\n\\\" +\\n \\\"Your cvs/bzr login name is a good choice.\\\\n\\\\n\\\" +\\n \\\"Leo uses this id to uniquely identify nodes.\\\\n\\\\n\\\" +\\n \\\"Your id must contain only letters and numbers\\\\n\\\" +\\n \\\"and must be at least 3 characters in length.\\\")\\n parent = None\\n title = 'Enter Leo id'\\n s, ok = QtWidgets.QInputDialog.getText(parent, title, message)\\n\\n return s\",\n \"def get_available_id(self):\\n n = 0\\n while True:\\n id = '<name_{}>'.format(n)\\n if id not in self.database:\\n break\\n n += 1\\n return id\",\n \"def generateMinionID(self, machine_name):\\n minion_id = self._removeWhitespaces(machine_name)\\n return minion_id\",\n \"def get_id(disk):\\n\\n #TODO\\n return \\\"Unknown\\\"\",\n \"def convert_chart_name_to_id(chart_name):\\n ordered_coa = OrderedDict(chart_of_accounts)\\n r = list(ordered_coa.keys()).index(chart_name)\\n return r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6559644","0.65396285","0.65396285","0.63410085","0.5949359","0.5924379","0.58869797","0.5779381","0.5747495","0.5730306","0.5696639","0.5695518","0.56872874","0.5674879","0.5640459","0.5591031","0.5586947","0.5575347","0.5573894","0.5563811","0.5533301","0.5528647","0.5502601","0.54888666","0.54815924","0.54628265","0.5451526","0.544606","0.5444281","0.54196656","0.5416969","0.54155624","0.5408167","0.53950477","0.53861964","0.53839487","0.5381981","0.536689","0.53540564","0.53512335","0.53500146","0.53365815","0.5320123","0.53177494","0.53161854","0.53094584","0.5294085","0.529343","0.5293024","0.52927953","0.5290525","0.528134","0.5275225","0.5273547","0.5266948","0.52654266","0.52636427","0.52611536","0.5245324","0.5242734","0.52389413","0.5236143","0.52359706","0.5235607","0.52338886","0.52334553","0.5232402","0.5230767","0.5230767","0.5227254","0.5223263","0.5220085","0.5217174","0.5216404","0.5216373","0.52112263","0.52112263","0.52112263","0.52112263","0.520903","0.51889443","0.5174981","0.51749593","0.5172933","0.51726395","0.5171866","0.51703596","0.51643693","0.51586264","0.51540786","0.5153977","0.5153236","0.51435554","0.51415867","0.51306015","0.51295227","0.5113486","0.511177","0.5107243","0.5103287"],"string":"[\n \"0.6559644\",\n \"0.65396285\",\n \"0.65396285\",\n \"0.63410085\",\n \"0.5949359\",\n \"0.5924379\",\n \"0.58869797\",\n \"0.5779381\",\n \"0.5747495\",\n \"0.5730306\",\n \"0.5696639\",\n \"0.5695518\",\n \"0.56872874\",\n \"0.5674879\",\n \"0.5640459\",\n \"0.5591031\",\n \"0.5586947\",\n \"0.5575347\",\n \"0.5573894\",\n \"0.5563811\",\n \"0.5533301\",\n \"0.5528647\",\n \"0.5502601\",\n \"0.54888666\",\n \"0.54815924\",\n \"0.54628265\",\n \"0.5451526\",\n \"0.544606\",\n \"0.5444281\",\n \"0.54196656\",\n \"0.5416969\",\n \"0.54155624\",\n \"0.5408167\",\n \"0.53950477\",\n \"0.53861964\",\n \"0.53839487\",\n \"0.5381981\",\n \"0.536689\",\n \"0.53540564\",\n \"0.53512335\",\n \"0.53500146\",\n \"0.53365815\",\n \"0.5320123\",\n \"0.53177494\",\n \"0.53161854\",\n \"0.53094584\",\n \"0.5294085\",\n \"0.529343\",\n \"0.5293024\",\n \"0.52927953\",\n \"0.5290525\",\n \"0.528134\",\n \"0.5275225\",\n \"0.5273547\",\n \"0.5266948\",\n \"0.52654266\",\n \"0.52636427\",\n \"0.52611536\",\n \"0.5245324\",\n \"0.5242734\",\n \"0.52389413\",\n \"0.5236143\",\n \"0.52359706\",\n \"0.5235607\",\n \"0.52338886\",\n \"0.52334553\",\n \"0.5232402\",\n \"0.5230767\",\n \"0.5230767\",\n \"0.5227254\",\n \"0.5223263\",\n \"0.5220085\",\n \"0.5217174\",\n \"0.5216404\",\n \"0.5216373\",\n \"0.52112263\",\n \"0.52112263\",\n \"0.52112263\",\n \"0.52112263\",\n \"0.520903\",\n \"0.51889443\",\n \"0.5174981\",\n \"0.51749593\",\n \"0.5172933\",\n \"0.51726395\",\n \"0.5171866\",\n \"0.51703596\",\n \"0.51643693\",\n \"0.51586264\",\n \"0.51540786\",\n \"0.5153977\",\n \"0.5153236\",\n \"0.51435554\",\n \"0.51415867\",\n \"0.51306015\",\n \"0.51295227\",\n \"0.5113486\",\n \"0.511177\",\n \"0.5107243\",\n \"0.5103287\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5925194"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":23398,"cells":{"query":{"kind":"string","value":"Prompt for user input to figure out who predictions are for. This function is written so that the Oracle host can post predictions in the topic for other users."},"document":{"kind":"string","value":"def PromptForId(odb, message, orig_id=1):\n\n print 'Is this prediction for someone other than the poster?\\n\\n%s\\n\\n' % \\\n (message['Text'])\n diff_user = raw_input('(y/n): ')\n\n if diff_user == 'n':\n return orig_id\n \n user_name = raw_input('Username this prediction is for? ')\n user_id = odb.GetUserId(user_name)\n\n if user_id is None:\n print 'Unrecognized username, try again.\\n'\n return PromptForId(odb, message, orig_id)\n\n else:\n return user_id"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def do_prompt(self):\n # we need _something_ in the dictionary even if the user decides to use all defaults\n # otherwise for some unknown reason it won't work\n user_in = {'__meta__': '__user_input__'}\n\n print('Please enter the information asked for in the following prompts in order to configure your deployment')\n # get the config information from the user\n for p in self.prompts:\n answer = input(p['prompt'])\n if len(answer.strip()) > 0 and 'variable' in p.keys():\n user_in[p['variable']] = answer\n\n # return the data\n return user_in","def main():\n\n google_email = raw_input('Email: ')\n google_password = getpass('Password: ')\n auth = GetAuthentication(google_email, google_password)\n model = raw_input('Model: ')\n\n query = []\n message = 'Enter feature for classification. Type quit when done: '\n while True:\n feature = raw_input(message)\n if feature == 'quit':\n break\n try:\n float(feature)\n query.append(float(feature))\n except ValueError:\n query.append(feature)\n print query\n print Predict(auth, model, query)","def build_dataset_prompt():\n\n print(\"\")\n print(\"Let's start by choosing what features you'd like to look at/explore!\")","def interactive_shell():\n print(\"\"\"\nTo exit, enter 'EXIT'.\nEnter a sentence like \ninput> wth is it????\"\"\")\n\n while True:\n try:\n # for python 2\n sentence = raw_input(\"input> \")\n except NameError:\n # for python 3\n sentence = input(\"input> \")\n\n words_raw = sentence.strip()\n\n if words_raw == \"EXIT\":\n break\n \n words_raw = Encoder.str2uni(words_raw)\n label_prob, label_pred = predict(words_raw)\n if label_pred[0] == 0:\n print(\"OUTPUT> Subversive \\t\\t PROB> %.2f\"%(100*(1-label_prob.data[0])))\n else:\n print(\"OUTPUT> None \\t\\t PROB> %.2f\"%(100*label_prob.data[0]))","def user_question():\n return input('What would you like? (espresso/latte/cappuccino): ')","def prompt():\n\n\t# Inform the user on what price data has been taken\n\tprint(\"\\nCurrent available historical data for calibration: \")\n\tdata_files = listdir('call_data/')\n\tfor i in range(len(data_files)):\n\t\tprint(data_files[i])\n\t# Ask the user if they would like to sample more points\n\tdone = False\n\twhile done != True:\n\t\tinp = input(\"\\nWould you like to sample more historical price data? (y/n) \")\n\t\ttry:\n\t\t\tif inp.lower() == 'y':\n\t\t\t\tsample_calls.random_calls()\n\t\t\tif inp.lower() == 'n':\n\t\t\t\tprint(\"Continuing to analysis.\\n\")\n\t\t\t\tdone = True\n\t\t\telse:\n\t\t\t\tprint(\"Invalid input.\")\n\t\texcept ValueError:\n\t\t\tprint(\"\\nUnable to interpret input. Please try again.\")","def get_input(self):\n if self.console_label is None:\n self.text_area.delete('1.0', END)\n print(\"The training has finished and the training file was created and sent to the server! Go Back.\")\n return\n\n valid_responses = {'y', 'n', 'u', 'f'}\n\n user_input = self.user_input.get()\n\n self.user_input.delete(0, END)\n\n if user_input not in valid_responses:\n return\n\n self.console_label.label_record_pair(user_input, self.current_record_pair)\n\n if user_input == 'f':\n self.upload_training_file()\n self.current_record_pair = None\n self.console_label = None\n self.text_area.delete('1.0', END)\n return\n\n self.text_area.yview(END)\n\n self.current_record_pair = self.console_label.get_uncertain_pair()","def response_training_prompt(self):\n self._last_response = \"training_prompt\"\n print(\"Training Prompt\")\n self.user_stats.set_followup(self._last_worst_grip)\n return Mglove_str_gen.training_prompt(self.user_stats.get_followup())","def __ask_query(self):\n self.__output = list()\n return input(form('What do you want to search?\\n> '))","def use_random_keyword_classifier():\n while True:\n utterance = input(\"\\n\\nEnter utterance you want to classify, \\ntype menu or exit to go back:\\n-> \").lower()\n if utterance == \"menu\" or utterance == \"exit\":\n break\n else:\n try:\n label_pred = random_keyword_classifier(utterance)\n print(\"Prediction: {0}\".format(*label_pred))\n except ValueError:\n print(\"Prediction: {0}\".format(\"null\"))","def prediction(name=None, message=''):","def get_user_input(hparams=None):\n utterance = input()\n # End the chat\n if utterance == 'end()':\n return utterance, utterance\n # Authorization not present\n if not hparams or not hparams.UNAME or not hparams.TOKEN:\n return utterance, utterance\n\n results = get_results(hparams, utterance)\n textual_errors = results['textual_errors']\n\n correct_sent = correct_utterance(textual_errors, utterance)\n if not correct_sent == utterance:\n print_result(results)\n print(\"The correct form is: \", correct_sent)\n print()\n # Return the correct sentence and the original utterance\n return correct_sent, utterance","def ask(self):\n keyword = input(self.foretext)\n\n self.input_asked = True\n\n if keyword in self.keywords:\n self.retrieved_input = keyword\n if keyword in self.functions:\n function, args, kwargs = self.functions[keyword]\n return function(*args, **kwargs)\n\n else:\n return keyword\n else:\n return self.fallback(keyword)","def print_recommendations_from_user_input(self):\n\n getting_name = True\n\n print(\"Please enter username and press enter:\\n\")\n\n while getting_name:\n username = input()\n\n redditor = self(username)\n\n if not redditor.username:\n print(\"Redditor does not exist. Please enter again.\\n\")\n continue\n\n break\n\n redditor.print_recommendations()","def prompt(self):\n # TODO: fix null input\n print('Enter user input: ')\n userinput = input()\n print(f'User chose: {userinput}')\n return userinput","def use_keyword_classifier():\n while True:\n utterance = input(\"\\n\\nEnter utterance you want to classify, \\ntype menu or exit to go back:\\n-> \").lower()\n if utterance == \"menu\" or utterance == \"exit\":\n break\n else:\n try:\n label_pred = keyword_classifier(utterance)\n print(\"Prediction: {0}\".format(*label_pred))\n except ValueError:\n print(\"Prediction: {0}\".format(\"null\"))","def _ask(threshold, matcher, facts):\n io.reply('What do you want to ask me?')\n while True:\n message = io.prompt_without_parse('ask')\n response = ask(threshold, matcher, facts, message)\n type = response['type']\n if type == 'invalid':\n io.reply(response['validation_mesage'])\n elif type == 'no_match':\n # TODO: how to give detailed information on why no match was found?\n io.reply('Sorry. My digital brain is not yet fully evolved. I did not understand it.')\n io.reply('Could you rephrase the question, so I might be able to understand it?')\n return\n elif type == 'select_match':\n _select_match(response['matches'])\n else:\n io.reply(response['answer'])\n return","def ask(self, prompt: str) -> str:\n raise NotImplementedError","def question():\n print('Enter 1 to search database by habitat with detailed information\\nEnter 2 to search database by coordinates \\nEnter 3 to search by habitat in csv file for a quick overview without detail')\n print('habitat search options so far:\\n Alpenvorland, Niederrheinisches Tiefland, Oberrheinisches Tiefland')\n src = int(input('Enter here:'))\n\n if src == 1:\n habitat = input('Enter name of habitat\\n')\n query = \"habitat = '\" + habitat + \"'\"\n search_db_via_query(query)\n elif src == 2:\n search_by_coordinates()\n elif src == 3:\n search_by_habitat()\n else:\n print('no data')","def displayPredictions(predictions):\n if predictions == []:\n print(\"\\n No predictions to display. Run manual game analysis and select games to predict first.\")\n print(\"\\nPress enter to return to previous menu.\\n\")\n input()\n return\n else:\n print(\"\\n Predictions\")\n print(\"-----------\\n\")\n for game in predictions:\n print(game[0],game[1],game[2],game[3])\n print(\"\\nPress enter to return to previous menu.\\n\")\n input()\n return","def getUserInput():\n\n logging.info(\"\\nGood day! Press enter to accept default reduction options.\")\n\n fullReduction = getParam(\n \"Do a full data reduction with default parameters loaded from recipes/default_input.cfg? [no]: \",\n False,\n \"Type yes to start Nifty with data reduction input parameters loaded from recipes/default_input.cfg file.\"\n )\n if fullReduction == False:\n # \"Select in\". User has to turn individual steps on.\n # TODO(nat): Implement these steps.\n date = \"\"\n program = \"\"\n copy = \"\"\n\n sort = getParam(\n \"Sort data? [no]: \",\n False\n )\n rawPath = getParam(\n \"Path to raw files directory? [~/data]: \",\n \"~/data\"\n )\n tel = getParam(\n \"Apply a telluric correction? [no]: \",\n False\n )\n # See if we want to reduce the baseline calibrations. And if so, which substeps\n # to perform.\n calibrationReduction = getParam(\n \"Reduce baseline calibrations? [no]: \",\n False\n )\n # By default do all of them.\n rstart = getParam(\n \"Starting point of baseline calibration reductions? [1]: \",\n 1\n )\n rstop = getParam(\n \"Stopping point of baseline calibration reductions? [4]: \",\n 4\n )\n\n # Check for tellurics as well; by default do all reduction steps.\n telluricReduction = getParam(\n \"Reduce telluric data? [no]: \",\n False\n )\n telStart = getParam(\n \"Starting point of science and telluric reductions? [1]: \",\n 1\n )\n telStop = getParam(\n \"Stopping point of science and telluric reductions? [6]: \",\n 6\n )\n # Set the telluric application correction method. Choices are iraf.telluric and a python variant.\n # Set the h-line removal method with the vega() function in nifsReduce as default.\n hline_method = getParam(\n \"H-line removal method? [vega]: \",\n \"vega\"\n )\n # Set yes or no for interactive the h line removal, telluric correction, and continuum fitting\n hlineinter = getParam(\n \"Interative H-line removal? [no]: \",\n False\n )\n continuuminter = getParam(\n \"Interative telluric continuum fitting? [no]: \",\n False\n )\n telluric_correction_method = getParam(\n \"Telluric correction method? [python]: \",\n \"python\"\n )\n telinter = getParam(\n \"Interactive telluric correction? [no]: \",\n False\n )\n # Check for science as well.\n scienceReduction = getParam(\n \"Reduce science data? [no]: \",\n False\n )\n sciStart = getParam(\n \"Starting point of science and telluric reductions? [1]: \",\n 1\n )\n sciStop = getParam(\n \"Stopping point of science and telluric reductions? [6]: \",\n 6\n )\n efficiencySpectrumCorrection = getParam(\n \"Do a flux calibration? [no]: \",\n False\n )\n spectemp = getParam(\n \"Effective temperature in kelvin of telluric standard star? [\"\"]: \",\n \"\"\n )\n mag = getParam(\n \"Magnitude of standard star? [\"\"]: \",\n \"\"\n )\n merge = getParam(\n \"Produce one final 3D cube? [no]: \",\n False\n )\n use_pq_offsets = getParam(\n \"Use pq offsets to merge data cubes? [yes]: \",\n \"yes\"\n )\n im3dtran = getParam(\n \"Transpose cubes for faster merging? [no]: \",\n False\n )\n over = getParam(\n \"Overwrite old files? [no]: \",\n False\n )\n debug = getParam(\n \"Pause after each data reduction step? [yes]: \",\n \"yes\"\n )\n\n # Serialize and save the options as a .cfg file.\n options = ConfigObj(unrepr=True)\n options['date'] = date\n options['program'] = program\n options['rawPath'] = rawPath\n options['over'] = over\n options['copy'] = copy\n options['sort'] = sort\n options['calibrationReduction'] = calibrationReduction\n options['scienceReduction'] = scienceReduction\n options['merge'] = merge\n options['tel'] = tel\n options['telluricReduction'] = telluricReduction\n options['spectemp'] = spectemp\n options['mag'] = mag\n options['efficiencySpectrumCorrection'] = efficiencySpectrumCorrection\n options['rstart']= rstart\n options['rstop'] = rstop\n options['telStart'] = telStart\n options['telStop'] = telStop\n options['sciStart'] = sciStart\n options['sciStop'] = sciStop\n options['hline_method'] = hline_method\n options['hlineinter'] = hlineinter\n options['continuuminter'] = continuuminter\n options['telluric_correction_method'] = telluric_correction_method\n options['telinter'] = telinter\n options['use_pq_offsets'] = use_pq_offsets\n options['im3dtran'] = im3dtran\n options['debug'] = debug\n with open(RUNTIME_DATA_PATH+'/config.cfg', 'w') as outfile:\n options.write(outfile)\n\n return fullReduction","def prompt_user(prompt):\r\n # raw_input returns the empty string for \"enter\"\r\n yes = set(['yes', 'y'])\r\n no = set(['no','n'])\r\n\r\n try:\r\n print(prompt)\r\n choice = raw_input().lower()\r\n # would like to test for exception here, but not sure if we can do that without importing IPython\r\n except:\r\n print('Stdin is not implemented.')\r\n print('You need to set')\r\n print('overide_manual_authorize=True')\r\n print('to proceed with the download. Please set that variable and continue.')\r\n raise\r\n\r\n\r\n if choice in yes:\r\n return True\r\n elif choice in no:\r\n return False\r\n else:\r\n print(\"Your response was a \" + choice)\r\n print(\"Please respond with 'yes', 'y' or 'no', 'n'\")\r\n #return prompt_user()\r","def prompt(self, upstream_name):\n self.prompt_events[upstream_name].set()","def ask_user_input(self, sentence):\n user_input = raw_input(sentence + \" : \")\n return user_input","def nlu_cli(default_mood, user_id):\n mood = -1 # TODO currently superfulous while loop given default mood.\n while mood not in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:\n mood = input(\n \"Enter your current mood on a scale of 1 to 10 where \"\n + \"1 is negative, 5 is neutral, and 10 is positive (default is \"\n + str(default_mood) + \"): \"\n )\n if mood == \"\" or not mood.isdigit():\n mood = default_mood\n else:\n mood = int(mood)\n mood = default_mood if mood == \"\" else int(mood)\n\n topic = \"\"\n while topic == \"\":\n topic = input(\"Enter Topic: \").strip().lower()\n\n #loop until they select correct dialogue act, show help after first fail\n dialogue_act = \"\"\n first = True\n da_names = [da.name for da in DA if da.name not in\n ['statement', 'question', 'response_action']\n ]\n while dialogue_act not in da_names:\n dialogue_act = input(\"Enter dialogue Act: \").strip().lower()\n\n # TODO add help print out descriptions\n if first and dialogue_act not in da_names:\n first = False\n # Help, details what each dialogue act means.\n print(\"Enter a dialogue act from list below:\\n\", da_names)\n\n question_type = None\n if is_question(DA[dialogue_act]):\n question_type = \"\"\n first = True\n question_types = [qt.name for qt in QT]\n while question_type not in question_types:\n question_type = input(\"Enter question type: \").strip().lower()\n\n # TODO add help print out descriptions\n if first and question_type not in question_types:\n first = False\n # Help, details what each dialogue act means.\n print(\"Enter a question type from list below:\\n\",\n question_types)\n\n text = input(\n \"Enter utterance text: \"\n ).strip()\n\n sentiment = -1\n while sentiment not in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:\n sentiment = input(\n \"Enter utterance sentiment 1 to 10. \"\n + \"1 negative, 5 neutral, and 10 positive: \"\n )\n sentiment = -1 if sentiment == \"\" else int(sentiment)\n\n assertiveness = -1\n while assertiveness not in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:\n assertiveness = input(\n \"Enter utterance assertiveness 1 to 10. \"\n + \"1 passive/listening oriented, 5 neutral, and \"\n + \"10 assertive/leading conversation: \"\n )\n assertiveness = -1 if assertiveness == \"\" else int(assertiveness)\n\n return Utterance(\n user_id,\n DA[dialogue_act],\n topic,\n sentiment,\n assertiveness,\n text,\n question_type\n ), mood","def topics_from_user_input(self):\n\n getting_name = True\n\n print(\"\\nPlease enter username and press enter:\\n\")\n\n while getting_name:\n username = input()\n\n redditor = self(username)\n\n if not redditor.username:\n print(\"Redditor does not exist. Please enter again.\\n\")\n continue\n\n break\n\n redditor.print_topics()","def get_user_input(arg_pair: EviPair):\n global HUMAN_CORRECT_PRED\n\n while True:\n try:\n choice = int(raw_input())\n\n if choice in [1,2]:\n\n if choice == arg_pair.label:\n HUMAN_CORRECT_PRED += 1\n\n break\n else:\n print(WRONG_INPUT)\n except ValueError:\n print(WRONG_INPUT)\n\n return choice","def UserInput(self, username, userinput):\n pass","def getQuestion():\n cat = getCategories(True)\n print(\"--- Categories ---\")\n print(cat[0])\n print(cat[1])\n print(cat[2])\n userInput = input(\"Please, pick a subject: \\n\").casefold()\n\n\n \n if userInput != \"other\":\n print(\"You have chosen: \" + userInput.title())\n print(\"##############################\")\n #Input question here XD\n\n \n\n question, answer, w, t = getQuestion(userInput, \"easy\")\n \n userAnswer = input(question)\n if userAnswer.lower() == answer.lower():\n print(\"Wehey \\n\")\n elif userAnswer.lower() != answer.lower():\n print(\"This is not the answer fool!\")\n print(\"The answer is: \\n\")\n print(answer + \"\\n\")\n elif userInput == \"other\":\n print(\"You have chosen: \" + userInput.title())\n print(\"##############################\")\n userInput = input(\"Want to hear a joke, fun fact or something random? \\n\")\n if userInput == \"Yes\" or userInput == \"yes\":\n print(random.choice(randomStuff) + \"\\n\")","def getInput():\t\n\tglobal active_\n\n\t#to disable the service \n\tactive_ = False \n\t\n\t# reading the previous input\n\tprev_input_ = rospy.get_param('/input')\n\tinput_ = prev_input_\n\t\n\t#in order to make the user to choose one of the 5 possible inputs\n\twhile (prev_input_ == input_) or (input_ > 5 or input_ < 1):\n\t\tif input_ > 5 or input_ < 1: \n\t\t\t#in the case in which the user make another selection\n\t\t\tprint \"Unknown input, please try again\" \n\t\t\n\t\t#propose to the user which are the real possibilities\n\t\tprint(\"Please select one of the following senteces\\n\")\n\t\tprint(\"1 - Move the robot randomly in the environment, by choosing one of six possible target positions\\n\")\n\t\tprint(\"2 - The user can chose the next target position\\n\")\n\t\tprint(\"3 - Start following the external walls\\n\")\n\t\tprint(\"4 - Stop the robot in the last position\\n\")\n\t\tprint(\"5 - Change the planning algorithm from move_base to bug0 and vice versa\\n\")\n\n\t\t#read the input typed by the user\t\n\t\tinput_ = (int(raw_input(\"Please select a number between 1 and 5: \")))\n\n\t#set the choice made by the user\n\tif input_ >= 1 and input_ <= 5:\n\t\trospy.set_param('/input', input_)","def interactive_shell(model):\n model.logger.info(\"\"\"\nThis is an interactive mode.\nTo exit, enter 'exit'.\nYou can enter a sentence like\ninput> I love Paris\"\"\")\n\n while True:\n try:\n # for python 2\n sentence = input(\"input> \")\n except NameError:\n # for python 3\n sentence = input(\"input> \")\n\n words_raw = sentence.strip().split(\" \")\n\n if words_raw == [\"exit\"]:\n break\n\n preds = model.predict(words_raw)\n to_print = align_data({\"input\": words_raw, \"output\": preds})\n\n for key, seq in to_print.items():\n model.logger.info(seq)","def ask(self):\n subprocess.run([\"say\", \"-v\", \"Kyoko\", str(self.answer)])","def utter(fileNames):\n model = __initModel(fileNames)\n\n print(\"Please enter your sentence...\")\n\n try:\n while True:\n utterance = input()\n print(numpy.random.choice(list(model.keys()), 1, p=list(model.values()))[0])\n\n except KeyboardInterrupt:\n pass","def ask(self, question):\n\n\t\t# If you're just trying to test voice detection, you can uncomment\n\t\t# the following 5 lines. Bobby will guess \"yellow flashlight\" and will prompt\n\t\t# you to correct him by saying \"blue flashlight\"\n\n\t\t# fake_answers = [\"no\", \"yes\", \"yes\", \"yes\", \"no\", \"yes\", \"yes\"]\n\t\t# global count\n\t\t# count += 1\n\t\t# print question\n\t\t# return fake_answers[count - 1]\n\n\t\t# self.say(question)\n\t\t# #starts listening for an answer\n\t\t# self.asr.subscribe(\"TEST_ASR\")\n\t\t# data = (None, 0)\n\t\t# while not data[0]:\n\t\t# \tdata = self.mem.getData(\"WordRecognized\")\n\t\t# #stops listening after he hears yes or no\n\t\t# self.asr.unsubscribe(\"TEST_ASR\")\n\t\t#\n\t\t# print data\n\t\t#\n\t\t# for word in self.yes_no_vocab:\n\t\t# \tfor syn in self.yes_no_vocab[word]:\n\t\t# \t\tif data[0] == syn:\n\t\t# \t\t\treturn word","def tinker (predictor):\n col_size = predictor.max_label_length()\n while True:\n try:\n sentence = input('\\nEnter a sentence to classify (\"exit\" to quit): ')\n if sentence == 'exit':\n print(\"Goodbye!\")\n sys.exit(0)\n print(\"\")\n results = predictor.predict(sentence)\n print(f\"Index | {'Subject'.ljust(col_size)} | {'Object'.ljust(col_size)} | Sentence\")\n print(f\"------|-{'-' * col_size}-|-{'-' * col_size}-|---------\")\n for result in results:\n idx, sentence, subj, obj = result\n print(f\"{str(idx).rjust(5)} | {subj.ljust(col_size)} | {obj.ljust(col_size)} | {sentence}\")\n except KeyboardInterrupt:\n print(\"Goodbye!\")\n sys.exit(0)","def _prompt_user(self):\n print '\\nPlease enter the ff. Just leave blank to accept default.\\n'\n self._handle_param(param='start',\n msg='Starting date (Ex. Feb 1, 2016): ')\n self._handle_param(param='end',\n msg='Ending date (Ex. Aug 1, 2016): ')","def user_interaction():\n # Some information for the usage\n print(\"For every following question: \\nIf you want to do it, type the number of how many \"\n \"should be generated. If you don't want to do it, type anything else.\")\n male_single = input(\"\\nDo you want to generate single male names? \")\n\n # This is the principle that will be used for every question. If the\n # given input is an integer, it will run the program for how often\n # it was told. If it wasn't an integer, the conversion will fail and\n # we will just move on to the next one.\n try:\n for i in range(int(male_single)):\n print(male_name())\n except ValueError:\n pass\n\n female_single = input(\"\\nDo you want to generate single female names? \")\n try:\n for i in range(int(female_single)):\n print(female_name())\n except ValueError:\n pass\n\n last_single = input(\"\\nDo you want to generate single last names? \")\n try:\n for i in range(int(last_single)):\n print(last_name())\n except ValueError:\n pass\n\n male_double = input(\"\\nDo you want to generate double male names? \")\n try:\n for i in range(int(male_double)):\n print(double_name(\"male\"))\n except ValueError:\n pass\n\n female_double = input(\"\\nDo you want to generate double female names? \")\n try:\n for i in range(int(female_double)):\n print(double_name(\"female\"))\n except ValueError:\n pass\n\n last_double = input(\"\\nDo you want to generate double last names? \")\n try:\n for i in range(int(last_double)):\n print(double_name(\"family\"))\n except ValueError:\n pass\n\n full = input(\"\\nDo you want to generate full names? \")\n try:\n for i in range(int(full)):\n print(full_name())\n except ValueError:\n pass\n\n statistic_name = input(\"\\nDo you want to statistically test names? \")\n try:\n statistical_test_name(int(statistic_name))\n except ValueError:\n pass\n\n full_identity = input(\"\\nDo you want to generate full identities? \")\n try:\n for i in range(int(full_identity)):\n print(identity())\n except ValueError:\n pass\n\n sorted_list = input(\"\\nDo you want to create a sorted list? \")\n try:\n generate_sorted(int(sorted_list))\n except ValueError:\n pass\n\n statistics_full = input(\"\\nDo you want to create a full statistic over both names and \"\n \"addresses? \")\n try:\n statistical_test(int(statistics_full))\n except ValueError:\n pass\n\n print(\"\\nThank you for using this program.\\nSee you soon,\\nTristan and Oliver\")","def inask(question: str) -> str:\n answer = input(question)\n return answer","def get_user_text_input(self):\n\t\tuser_input = raw_input('You: ')\n\t\treturn user_input","def askforinput(msg='Do you want to proceed?', tab='', newline='\\n'):\n while True:\n inp = input(ColorText(f\"{newline}{tab}INPUT NEEDED: {msg} \\n{tab}(yes | no): \").warn().__str__()).lower()\n if inp in ['yes', 'no']:\n if inp == 'no' and msg=='Do you want to proceed?':\n print(ColorText('exiting %s' % sys.argv[0]).fail())\n exit()\n break\n else:\n print(ColorText(\"Please respond with 'yes' or 'no'\").fail())\n return inp","def ask_user_input(prompt: str) -> str:\n return input(prompt)","def ask(self) -> data_input:\n print(\"===========================\")\n post_student_data = self.pre_data\n for i in post_student_data:\n if post_student_data[i] != \"N/A\":\n print(f\"{i}: {post_student_data[i]}\")\n print(\"===========================\")\n post_data = self.data_input(post_student_data)\n return post_data","def ask_question(self, question):\n self.response((question))\n return input()","def prompt_for_var_name():\n return input('Variable name? ')","def parse_user_selections(self):\n if \"model2\" in sys.argv:\n self.model_choice = \"model2\"\n else:\n self.model_choice = \"model1\"\n\n if \"Virginia\" in sys.argv:\n self.region = \"Virginia\"\n self.region_name = 'us-east-1'\n elif \"California\" in sys.argv:\n self.region = \"California\"\n self.region_name = 'us-west-1'\n else:\n self.region = \"Oregon\"\n self.region_name = 'us-west-2'\n\n if self.verbose_mode:\n print \"** will run the Machine Learning %s\" % self.model_choice\n print \"\\n** Running on %s Elastic Map Reduce server\" % self.region","async def predict(input_data: schemas.MultipleUserDataInputs) -> Any:\n print(input_data.inputs)\n input_df = jsonable_encoder(input_data.inputs)[0][\"user_handle\"]\n print(input_df)\n logger.info(f\"Making prediction on inputs: {input_data.inputs}\")\n results = make_prediction(input_df)\n\n logger.info(f\"Prediction results: {results.get('predictions')}\")\n\n return results","def build_user_input(self):\n pass","def interact_model(\n model_name='117M',\n asker=None,\n responder=None,\n restore_from=None,\n seed=None,\n length=None,\n temperature=1,\n top_k=0,\n top_p=0.0,\n penalize=0,\n prompt=None\n):\n if asker is None:\n raise Exception(\"Add a name present in the training dataset that you will be chatting as\")\n if responder is None:\n raise Exception(\"Add a name present in the training dataset that gpt will be chatting as\")\n\n enc = encoder.get_encoder(model_name)\n hparams = model.default_hparams()\n with open(os.path.join('models', model_name, 'hparams.json')) as f:\n hparams.override_from_dict(json.load(f))\n\n if length is None:\n length = hparams.n_ctx // 2\n elif length > hparams.n_ctx:\n raise ValueError(\"Can't get samples longer than window size: %s\" % hparams.n_ctx)\n\n with tflex.Session(graph=tf.Graph()) as sess:\n context = tf.placeholder(tf.int32, [1, None])\n np.random.seed(seed)\n tf.set_random_seed(seed)\n output = sample.sample_sequence(\n hparams=hparams, length=length,\n context=context,\n batch_size=1,\n temperature=temperature, top_k=top_k, top_p=top_p, penalize=penalize\n )\n\n saver = tflex.Saver()\n if restore_from is None:\n restore_from = os.path.join('models', model_name)\n ckpt = tflex.latest_checkpoint(restore_from)\n saver.restore(sess, ckpt)\n\n input_ = ''\n time = 1924862493344\n while True:\n time = increase_time(time)\n input_ = input_ + f'({time}) {asker}: ' + input(f\"{asker}: \")\n time = increase_time(time)\n input_ = input_ + f'\\n ({time}) {responder}: '\n if len(input_) > 1 and input_.endswith('\\n'):\n input_ = input_[:-1]\n context_tokens = enc.encode(input_)\n out = sess.run(output, feed_dict={\n context: [context_tokens]\n })[:, len(context_tokens):]\n enc.decode(out[0])\n text = enc.decode(out[0]).split(f') {asker}', 1)[0]\n print(f'\\n ({time}) {responder}: ' + text.rsplit('(', 1)[0])\n input_ = input_ + text\n sys.stdout.flush()","def predict():\r\n variance=request.args.get('variance')\r\n skewness=request.args.get('skewness')\r\n curtosis=request.args.get('curtosis')\r\n entropy=request.args.get('entropy')\r\n scaling=scaler.transform([[variance,skewness,curtosis,entropy]])\r\n prediction=classifier.predict(scaling)\r\n if prediction[0] == 0:\r\n return 'It is an Authentic Note'\r\n else:\r\n return \"It is a fake note\"","def prompt(self, question):\n self.output(' ')\n self.output(question)\n self.output(self.parse_response(str(self.ui())))","def prompt_user_account_to_get_interest():\n print('What account do you want 0.5% automatic interest?:')\n return input()","def textinput(self, title, prompt):\n return simpledialog.askstring(title, prompt)","def prompt_tech_selection(technologies=config.TECHNOLOGIES):\n print(\"Select technology number for probability analysis from:\")\n for i, tech in enumerate(technologies):\n print(f\"{i + 1}. {tech}\")\n print(\"Insert technology number for probability analysis:\")\n\n user_input = input()\n if not user_input.isdigit() or int(user_input) > len(technologies) or int(user_input) < 1:\n selection = 1\n logging.warning(f\"Bad input, using default selection {selection}\")\n else:\n selection = int(user_input)\n return technologies[selection - 1]","def prediction_input() -> str:\r\n recipe_list = [\"Organic Red Helles\", \"Organic Pilsner\",\r\n \"Organic Dunkel\"]\r\n month_list = [\"Nov\", \"Dec\", \"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\",\r\n \"Jul\", \"Aug\", \"Sep\", \"Oct\"]\r\n return render_template(\"prediction_input.html\", recipes=recipe_list,\r\n months=month_list)","def query(prompt, parameters=None, options={'use_cache': False}):\n\n API_URL = \"https://api-inference.huggingface.co/models/EleutherAI/gpt-neo-2.7B\"\n headers = {\"Authorization\": f\"Bearer {API_TOKEN}\"}\n body = {\"inputs\":prompt,'parameters':parameters,'options':options}\n response = requests.request(\"POST\", API_URL, headers=headers, data= json.dumps(body))\n try:\n response.raise_for_status()\n except requests.exceptions.HTTPError:\n print(\"Prompt:\")\n print(prompt)\n return \"API Error: \"+\" \".join(response.json()['error'])\n else:\n return response.json()[0]['generated_text']","def ask_user_for_relevance(query_results):\n for i, result in enumerate(query_results):\n hdr = 'Result #%d ' % (i+1)\n prompt_text = 'Is result #%d relevant? [y/n] ' % (i+1)\n print '\\n' + hdr + '-'*(70 - len(hdr))\n print result.to_formatted_string()\n print '-'*70\n while True:\n user_in = raw_input(prompt_text).strip().lower()\n if user_in == 'y' or user_in == 'n':\n break\n if user_in == 'y':\n result.is_relevant = True","def print_sample(arg_pair: EviPair):\n print('Please think about which argument you '\n 'would prefer in a discussion about: '\n '\\'{}\\' '.format(arg_pair.topic))\n print('First evidence has stance {} : '.format(arg_pair.first_stance))\n print(arg_pair.first_evi)\n print('Second evidence has stance {} : '.format(arg_pair.second_stance))\n print(arg_pair.second_evi)\n print('Enter your choice: ')\n nn_prediction = predict_and_eval(arg_pair)\n print('Neuronal Network selected evidence {}'.format(nn_prediction))\n print('By an acceptance rate of {} sample was labeled as {} \\n'.\n format(arg_pair.acceptance_rate, arg_pair.label))","def _interactive_training(filebasename, cluster, identifier):\n info = None\n prc = None\n if identifier == \"unknown\":\n info = \"\"\"The system has not identified this speaker!\"\"\"\n else:\n info = \"The system identified this speaker as '\" + identifier + \"'!\"\n print info\n while True:\n try:\n char = raw_input(\"\\n 1) Listen\\n 2) Set \" + \n \" name\\n Press enter to skip\\n> \")\n except EOFError:\n print ''\n continue\n print ''\n if prc != None and prc.poll() == None:\n prc.kill()\n if char == \"1\":\n videocluster = str(filebasename + \"/\" + cluster)\n listwaves = os.listdir(videocluster)\n listw = [os.path.join(videocluster, f) for f in listwaves]\n wrd = \" \".join(listw)\n commandline = \"play \" + str(wrd)\n if sys.platform == 'win32':\n commandline = \"vlc \" + str(wrd)\n commandline = commandline.replace('\\\\', '\\\\\\\\')\n print \" Listening %s...\" % cluster\n args = shlex.split(commandline)\n prc = subprocess.Popen(args, stdin=CONFIGURATION.output_redirect,\n stdout=CONFIGURATION.output_redirect,\n stderr=CONFIGURATION.output_redirect)\n time.sleep(1)\n continue\n if char == \"2\":\n menu = False\n while not menu:\n name = raw_input(\"Type speaker name \"\n + \"or leave blank for unknown speaker: \")\n while True:\n if len(name) == 0:\n name = \"unknown\"\n if not name.isalnum():\n print 'No blank, dash or special chars allowed! Retry'\n# menu = True\n break\n okk = raw_input(\"Save as '\" + name + \"'? [Y/n/m] \")\n if okk in ('y', 'ye', 'yes', ''):\n return name\n if okk in ('n', 'no', 'nop', 'nope'):\n break\n if okk in ('m', \"menu\"):\n menu = True\n break\n if not menu:\n print \"Yes, no or menu, please!\"\n continue\n if char == \"\":\n return identifier\n print \"Type 1, 2 or enter to skip, please\"","def getInput(self):\n print('You will be asked to vote on 16 subjects refered by titles.')\n handicapped_infants = convertToFloat(str(input('Handicapped infants protection act - Vote by typing \"y\" or \"n\" or \"?\": ')))\n water_project_cost_sharing = convertToFloat(str(input('Water_project_cost_sharing - Vote by typing \"y\" or \"n\" or \"?\": ')))\n adoption_of_the_budget_resolution = convertToFloat(str(input('Adoption of the budget resolution - Vote by typing \"y\" or \"n\" or \"?\": ')))\n physician_fee_freeze = convertToFloat(str(input('Physician fee freeze - Vote by typing \"y\" or \"n\" or \"?\": ')))\n el_salvador_aid = convertToFloat(str(input('El salvador aid - Vote by typing \"y\" or \"n\" or \"?\": ')))\n religious_groups_in_schools = convertToFloat(str(input('Religious groups in schools - Vote by typing \"y\" or \"n\" or \"?\": ')))\n anti_satellite_test_ban = convertToFloat(str(input('Anti satellite test ban - Vote by typing \"y\" or \"n\" or \"?\": ')))\n aid_to_nicaraguan_contras = convertToFloat(str(input('Aid to nicaraguan contras - Vote by typing \"y\" or \"n\" or \"?\": ')))\n mx_missile = convertToFloat(str(input('Mx missile - Vote by typing \"y\" or \"n\" or \"?\": ')))\n immigration = convertToFloat(str(input('Immigration - Vote by typing \"y\" or \"n\" or \"?\": ')))\n synfuels_corporation_cutback = convertToFloat(str(input('Synfuels corporation cutback - Vote by typing \"y\" or \"n\" or \"?\": ')))\n education_spending = convertToFloat(str(input('Education spending - Vote by typing \"y\" or \"n\" or \"?\": ')))\n superfund_right_to_sue = convertToFloat(str(input('Superfund right to sue - Vote by typing \"y\" or \"n\" or \"?\": ')))\n crime = convertToFloat(str(input('Crime - Vote by typing \"y\" or \"n\" or \"?\": ')))\n duty_free_exports = convertToFloat(str(input('Duty free exports - Vote by typing \"y\" or \"n\" or \"?\": ')))\n export_administration_act_south_africa = convertToFloat(str(input('Export administration act south africa - Vote by typing \"y\" or \"n\" or \"?\": ')))\n\n self.inputData = np.array([handicapped_infants,water_project_cost_sharing,adoption_of_the_budget_resolution,physician_fee_freeze,el_salvador_aid,religious_groups_in_schools,anti_satellite_test_ban,aid_to_nicaraguan_contras,mx_missile,immigration,synfuels_corporation_cutback,education_spending,superfund_right_to_sue,crime,duty_free_exports,export_administration_act_south_africa])","def get_inputs(self):\n self.console.write(self.words.show_lines() + \"\\n\")\n self.console.write(self.jumper.jumper_output())\n guess = input(\"Guess a letter [a-z]: \").lower()\n self.good_guess = self.words.get_lines(guess)","def prompt_user_selection(self):\n self.print_users()\n user_input = self.input_for_user_selection()\n currently_selected = self.users[int(user_input)]\n return currently_selected","def input(self, prompt):\r\n return console_input(prompt)","def ask_user( prompt ):\n answer = raw_input( prompt )\n if answer.lower() in [\"y\",\"yes\"]:\n return True\n else:\n return False","def main():\n args = parse_args()\n mood = args.mood\n\n # Create both Personas for the user and the system\n user_persona = Persona(\"user\", mood, 5)\n simulated_persona = args.personality_profile\n #simulated_persona = Persona(args.personality_profile)\n\n # initiate conversation\n conversation_history = Conversation(\n [user_persona, simulated_persona]\n )\n\n ongoing_conversation = True\n while ongoing_conversation:\n # Query user for utterance\n utterance, mood = nlu_cli(mood)\n\n # update conversation history\n conversation_history.add_utterance(utterance)\n\n # update user persona\n if user_persona.personality.mood != mood:\n user_persona.personality.set_mood(mood)\n\n print(\"output NLU_CLI data:\\n\")\n utterance.print_out()\n print(\"\\n\", mood, \"\\n\")\n\n print(\"output conversation_history updated\\n\")\n conversation_history.print_out()\n\n print(\"output user_persona.mood updated\\n\")\n user_persona.print_out()\n\n if utterance.dialogue_act == DA.farewell:\n ongoing_conversation = False","def process_ask_configs(config):\n\n if config.confluence_ask_user:\n print('(request to accept username from interactive session)')\n print(' Instance: ' + config.confluence_server_url)\n\n default_user = config.confluence_server_user\n u_str = ''\n if default_user:\n u_str = ' [{}]'.format(default_user)\n\n target_user = compat.input(' User{}: '.format(u_str)) or default_user\n if not target_user:\n raise ConfluenceConfigurationError('no user provided')\n\n config.confluence_server_user = target_user\n\n if config.confluence_ask_password:\n print('(request to accept password from interactive session)')\n if not config.confluence_ask_user:\n print(' Instance: ' + config.confluence_server_url)\n print(' User: ' + config.confluence_server_user)\n sys.stdout.write(' Password: ')\n sys.stdout.flush()\n config.confluence_server_pass = util.getpass2('')\n if not config.confluence_server_pass:\n raise ConfluenceConfigurationError('no password provided')","def ask_input(self, prompt):\n self._vim.command('call inputsave()')\n self._vim.command('let user_input = input(\"{} \")'.format(prompt))\n self._vim.command('call inputrestore()')\n response = self._vim.eval('user_input')\n self._vim.command('unlet user_input')\n return response","def get_user_input(self, msg):\n resp = input(msg)\n return resp","def prompt(self):\n return input(self.message + \": \").strip()","def ask(self):\n self.term = str(input(\"What are you looking for? (Coffee, Restaurants, Museums, Bars) \"))\n if self.term.lower() == 'quit':\n sys.exit()\n self.destination = str(input(\"Where are you looking to go? (Neighborhood, City or City, State) \"))\n if self.destination.lower() == 'quit':\n sys.exit()\n \n \n #Request/JSON\n self.request = self.session.get(\"http://api.yelp.com/v2/search\", params={'term': self.term,'location': self.destination})\n self.request = self.request.json()\n \n #Dataframing\n self.menu = json_normalize(self.request['businesses'])\n self.menu.index = list(range(1, 21))\n self.menu = self.menu[['name', 'categories', 'location.address', 'location.city', 'location.coordinate.latitude', \\\n 'location.coordinate.longitude', 'review_count', 'rating', 'snippet_text']]\\\n .sort_values(['rating'], ascending=False).sort_index()","def predict():\n to_predict = np.zeros(5).reshape(1, 5)\n features = ['is_male', 'num_interactions_with_cust_service', 'late_on_payment', 'age', 'years_in_contract']\n for i, feat in enumerate(features):\n if request.args.get(feat) is not None:\n to_predict[0][i] = request.args.get(feat)\n\n response = clf2.predict(to_predict)\n\n if response:\n return \"The customer is likely to churn\"\n else:\n return \"He is a loyal customer\"","def pose_question(self, keyword):\n\n # Determine correct answer\n correct_answer = self.quiz_info[keyword]\n \n # Prevent correct answer from being used twice\n weights = [1 if d != correct_answer else 0 for d in self.quiz_info.values()]\n wrong_answers = random.choices(list(self.quiz_info.values()), weights=weights, k=3)\n wrong_iter = iter(wrong_answers)\n\n # Define answer choices as letters and randomly choose the correct answer\n shuffled_answers = ['a', 'b', 'c', 'd']\n answers = shuffled_answers[:]\n random.shuffle(shuffled_answers)\n correct_choice = shuffled_answers.pop()\n correct_idx = answers.index(correct_choice)\n\n print(\"\\nSelect the correct definition of '{}'\\n\".format(keyword))\n for idx, ans in enumerate(answers):\n\n if idx == correct_idx:\n print(\" \" + ans + ')\\t' + self._format_answer(correct_answer) + '\\n')\n else:\n print(\" \" + ans + ')\\t' + self._format_answer(next(wrong_iter)) + '\\n')\n \n user_choice = input(\"Enter your selection: \").strip().lower()\n while user_choice not in answers:\n print(\"You must select from ['a', 'b', 'c', 'd']...\")\n user_choice = input(\"Enter your selection: \").strip().lower()\n\n return user_choice == correct_choice","def respond(self,obs):\n if obs.timestep == 0:\n #If it's the first timestep, we have no clue. Since we don't even know if we are going to ask questions in the\n #future, we go ahead and init the inference engine for future use.\n self.p_obs = copy.deepcopy(obs)\n self.tracking_stations = self.get_remaining_stations(obs)\n self.inference_engine = inference_engine(self.tracking_agent,self.tracking_stations)\n #And set the knowledge source to inference so the next step we know where to look for in the upcoming step.\n self.knowledge.source[0] = ORIGIN.Inference\n\n #And pick a target station at random since we have to move forward.\n target_station = np.random.choice(self.tracking_stations) #pick a station at random.\n\n else:\n curr_k_id = self.knowledge.get_current_job_station_id()\n\n #Checking what knowledge we have.\n if (self.knowledge.source[curr_k_id]==ORIGIN.Answer):\n #Then we simply work on the station because we have an answer telling us that that's the station to work on.\n target_station = self.knowledge.station_order[curr_k_id]\n\n elif (self.knowledge.source[curr_k_id] == None):\n #which means we just finished a station in the last time-step. This calls for re-initalizing the inference_engine\n self.tracking_stations = self.get_remaining_stations(obs)\n self.inference_engine = inference_engine(self.tracking_agent,self.tracking_stations)\n target_station = np.random.choice(self.tracking_stations)\n\n elif (self.knowledge.source[curr_k_id]==ORIGIN.Inference):\n #Which means we have been working on a inference for a station.\n target_station = self.inference_engine.inference_step(self.p_obs,obs)\n self.knowledge.update_knowledge_from_inference(target_station)\n warnings.WarningMessage(\"Provision resetting inference_engine when a station is finished\")\n\n else:\n #it should never come to this.\n raise Exception(\"Some mistake around\")\n\n \"\"\"\n Okay, now that we know which station we should be headed to, we need to ensure the nitty-gritty details.\n Do we have a tool?\n If yes,\n if it matches our target station:\n destination: station\n else:\n destination: base\n else:\n destination: base\n \n Are we near our destination?\n Yes:\n Is it the base?\n Pick up the tool.\n else:\n execute work action.\n No:\n keep moving. \n \"\"\" \n\n if self.tool is not None:\n if self.tool == target_station:\n destination = obs.allPos[obs.stationIndices[target_station]]\n else:\n destination = global_defs.TOOL_BASE\n else:\n destination = global_defs.TOOL_BASE\n\n if utils.is_neighbor(self.pos,destination):\n if destination == global_defs.TOOL_BASE:\n #We are at the base to pick up a tool.\n desired_action = global_defs.Actions.NOOP\n self.tool = target_station\n else:\n #we are the station to work.\n desired_action = global_defs.Actions.WORK\n else:\n #Navigate to destination.\n desired_action = None\n\n obstacles = copy.deepcopy(obs.allPos).remove(self.pos)\n proposal = utils.generate_proposal(self.pos,destination,obstacles,desired_action)\n return proposal","def prompt_message(\n get_user_input: GetInputFunc, output_func: OutputFunc\n) -> Tuple[SensorRun, bool]:\n sensor_type = prompt_sensor_type(get_user_input, output_func)\n mount = prompt_str_input(\n 'pipette mounts:\"left\" or \"right\", gripper mount: \"gripper\"', get_user_input\n )\n serial_number = prompt_str_input(\"instrument serial number\", get_user_input)\n auto_zero = prompt_bool_input(\"auto zero?\", get_user_input)\n minutes = prompt_float_input(\"script run time in minutes\", get_user_input)\n output_to_csv = prompt_bool_input(\"output to csv?\", get_user_input)\n\n sensor_run = SensorRun(sensor_type, serial_number, bool(auto_zero), minutes, mount)\n return sensor_run, output_to_csv","def ask(question):\n while True:\n query = input('{}\\n Reply (y/n) >>'.format(question))\n res = query[0].lower()\n if query == '' or not res in ['y', 'n']:\n pass\n else:\n break\n\n if res == 'y':\n return True\n else:\n return False","def prompt_for_survey(console: io.IO):\n msg = ('Would you like to take a survey to provide your feedback for '\n 'the deployment process? [y/N]')\n\n do_survey = prompt.binary_prompt(msg, console, default=False)\n if do_survey:\n webbrowser.open_url(_SURVEY_LINK)","def prompt() -> None:\n\n username = click.prompt(\n text=\"Please enter a username\",\n type=click.STRING\n )\n password = click.prompt(\n text=\"Please enter a new password\",\n hide_input=True,\n confirmation_prompt=True\n )\n newsletter_subscription = click.prompt(\n text=\"Would you like to subscribe to our newsletter?\",\n default=False,\n type=click.BOOL\n )\n favorite_color=click.prompt(\n text=\"What is your favorite color?\",\n type=click.Choice([\"blue\", \"green\", \"yellow\"], case_sensitive=False)\n )\n\n click.echo(\n f\"Username: {username} | Password: {'*' * len(password)} | \"\n + f\"Newsletter: {newsletter_subscription} | Favorite color: \"\n + click.style(favorite_color, fg=favorite_color)\n )","def user_prompt(prompt, default=None):\n prompt = f\"\\n {prompt} [{default}] runs or type an amount: \"\n response = input(prompt)\n if not response and default:\n return default\n else:\n return response","def enter_follow_up_patient(project_path: str, project_name: str):\n # Get Follow Up Log\n follow_up_log_path = os.path.join(project_path, 'logs', 'Follow_Up_Log.xlsx')\n\n while True:\n choice = input(\"Would you like to enter a new patient onto the Follow Up log [Y/N]? \")\n\n if choice and choice.strip() and choice.lower() == 'y':\n patient_data = rsm.get_data_from_user.get_follow_up_data()\n rsm.add_patient_to_excel_file.add_patient(follow_up_log_path,\n patient_data,\n 'Follow_Up_Log')\n print(\"Successfully added patient to {} Follow Up log\".format(project_name))\n\n elif choice and choice.strip() and choice.lower() == 'n':\n break\n else:\n print(\"Please enter Y or N\")","def reply_request(question: str, reply_options = ['y', 'yes', 'n', 'no'], show_reply = False):\n\n reply = None \n while not reply in reply_options:\n reply = input(question).lower()\n else:\n if show_reply:\n print(f'Your choice: {reply}')\n \n if reply in ['yes', 'no']:\n return reply[0]\n else:\n return reply","def ask(prompt):\n\n return renpy.exports.invoke_in_new_context(renpy.store.layout.yesno_prompt, None, prompt)","def get_yes_no_input(logger, text, default=None):\n if default:\n default = default.strip().lower()\n\n y = \"Y\" if default == \"y\" else \"y\"\n n = \"N\" if default == \"n\" else \"n\"\n\n prompt = f\"{text} [{yellow(y)}/{yellow(n)}]\"\n user_input = \"\"\n\n while not user_input:\n logger(prompt, end=\"\")\n user_input = input(\" \").strip().lower()\n if user_input == \"\" and default:\n user_input = default\n\n return user_input","def prompt():\n program_info = ('Dice Rolling Simulator\\n'\n 'Author: Franklin Pinnock\\n'\n 'Language: Python 3.4\\n'\n 'Version: 1.0\\n')\n print(program_info)","def ask_user(d):\n\n # Print welcome message\n msg = bold('Welcome to the Hieroglyph %s quickstart utility.') % (\n version(),\n )\n print(msg)\n msg = \"\"\"\nThis will ask questions for creating a Hieroglyph project, and then ask\nsome basic Sphinx questions.\n\"\"\"\n print(msg)\n\n # set a few defaults that we don't usually care about for Hieroglyph\n d.update({\n 'version': datetime.date.today().strftime('%Y.%m.%d'),\n 'release': datetime.date.today().strftime('%Y.%m.%d'),\n 'make_mode': True,\n })\n\n if 'project' not in d:\n print('''\nThe presentation title will be included on the title slide.''')\n d['project'] = sphinx_quickstart.do_prompt('Presentation title')\n if 'author' not in d:\n d['author'] = sphinx_quickstart.do_prompt('Author name(s)')\n\n # slide_theme\n theme_entrypoints = pkg_resources.iter_entry_points('hieroglyph.theme')\n\n themes = [\n t.load()\n for t in theme_entrypoints\n ]\n\n msg = \"\"\"\nAvailable themes:\n\n\"\"\"\n\n for theme in themes:\n msg += '\\n'.join([\n bold(theme['name']),\n theme['desc'],\n '', '',\n ])\n\n msg += \"\"\"Which theme would you like to use?\"\"\"\n print(msg)\n\n d['slide_theme'] = sphinx_quickstart.do_prompt(\n 'Slide Theme',\n themes[0]['name'],\n sphinx_quickstart.choice(\n *[t['name'] for t in themes]\n ),\n )\n\n # Ask original questions\n print(\"\")\n sphinx_quickstart.ask_user(d)","def example_single(args, model, word2idx):\n #在命令行中加载和分段<目标、（推特内容）>配对\n while True:\n target = raw_input(\"问题: \")\n tweet = raw_input(\"回答: \")\n targets = [str(target)]\n tweets = [str(tweet)]\n seged_tweets = yutils.seg_sentence(tweets, choice=\"list\", place=\"hpc\") # may use lexicon here\n seged_targets = yutils.seg_sentence(targets, choice=\"list\", place=\"hpc\")\n predictions = evaluate(args, model, word2idx, seged_tweets, seged_targets)\n print(\"预测结果: \", predictions)","def post(self):\n # use parser and find the user's query\n args = parser.parse_args()\n title = args['title']\n author = model.encode_author(args['author'])\n text = args['text']\n\n X = model.vector_and_stack(title=title, text=text, author=author)\n\n prediction = model.predict(X)\n\n # Output either 'Negative' or 'Positive' along with the score\n if round(prediction[0]) == 0:\n pred_text = 'Reliable News'\n else:\n pred_text = 'Unreliable News'\n\n # round the predict proba value and set to new variable\n confidence = round(prediction[0], 3)\n\n # create JSON object\n output = {'prediction': pred_text, 'fake_rate': confidence}\n\n return output, 200","def main():\r\n train('train.dat','out','dt')\r\n predict('test.dat','out')\r\n while(True):\r\n command=input(\"Enter the option you want to use, type exit to quit: \").split()\r\n if command[0] == 'exit':\r\n exit()\r\n elif command[0] == 'train':\r\n examples = command[1]\r\n hypothesisOut = command[2]\r\n learning_type = command[3]\r\n print(\"Starting training...\")\r\n train(examples, hypothesisOut, learning_type)\r\n print(\"Training is done.\")\r\n\r\n elif command[0] == 'predict':\r\n hypothesis = command[1]\r\n file = command[2]\r\n print(\"Starting to predict...\")\r\n print(\"The predictions are: \")\r\n predictions = predict(hypothesis, file)","def prompt(question):\n print('\\n')\n while True:\n reply = str(input(question+' (y/n): ')).lower().strip()\n if reply[:1] == 'y':\n return True\n if reply[:1] == 'n':\n return False","def use_random_forest_classifier(classifier, vectorizer, labels):\n while True:\n utterance = input(\"\\n\\nEnter utterance you want to classify, \\ntype menu or exit to go back:\\n-> \").lower()\n if utterance == \"menu\" or utterance == \"exit\":\n break\n else:\n y_pred = classifier.predict(vectorizer.transform([utterance]))\n\n try:\n label_pred = labels[y_pred[0].tolist().index(1)]\n print(\"Prediction: {0}\".format(label_pred))\n except ValueError:\n print(\"Prediction: {0}\".format(\"null\"))","def get_host_name():\r\n\tglobal HOST_NAME\r\n\r\n\twhile True:\r\n\t\tname_of_host = input(\"What is your name (As it appears in zoom without the '(Host, me)' part)? \")\r\n\t\tHOST_NAME = name_of_host + \" (Host, me)\"\r\n\t\tcorrect = input(f\"Host name set as {HOST_NAME}, is this correct? [Y/N]: \")\r\n\t\tif correct.upper() == \"Y\":\r\n\t\t\treturn","def show_predictions(result, invalid, event):\n\n s.sendReply(\n event,\n f'Predictions: {result if result else \"none\"}\\n'\n f'Invalid: {\", \".join(invalid) if invalid else \"none\"}',\n )\n\n if result:\n s.sendReply(\n event,\n \"Note: The models do not take news or current events into account. \"\n \"Some models work better for different stocks based on their behaviour, \"\n \"try following the predictions for a while to determine which is best.\",\n )","def get_user_choice():\n user_input = input('Your choice: ')\n return user_input","def prompt(self, upstream_name):\n request = PromptRequest(upstream_name=upstream_name)\n response = self.stub.Prompt(request, timeout=5)","def suggest(ctx, request: str):\n replacer = Replacer(ctx.obj.get('GKG_API_KEY'))\n suggestion = replacer.suggest(request)\n if suggestion == request:\n logger.info(\n 'Result from Google Knowledge Graph equals input: \"{0}\"', request,\n )\n elif suggestion:\n logger.info('Result from Google Knowledge Graph: \"{0}\"', suggestion)\n else:\n logger.info(\n 'No results in the Google Knowledge Graph for: \"{0}\"', request,\n )","def _get_user_input(query, valid, default):\n\n # Wait for valid user input and return choice upon receipt\n while True:\n choice = input(query)\n if default is not None and choice == \"\":\n return default\n elif choice in valid:\n return choice\n else:\n print(\"Please respond with '\" + \\\n \"or '\".join(opt + \"' \" for opt in valid) + \"\\n\")","def Prompt(self,message):\n\t\tself.acad.ActiveDocument.Utility.Prompt(message)","def query(self,text_input,prefix='answer:',convert_to_string=True):\n predictions, raw_outputs = self.model.predict([text_input])\n raw_outputs = [np.max(softmax([s[1][0] for s in v.items()][0])) for v in raw_outputs[0]]\n preds = [[(i[0],i[1],raw_outputs[k]) for i in p.items()][0] for k,p in enumerate(predictions[0])]\n return self._post_process_output(preds,convert_to_string=convert_to_string)","def _interactive_input_fn(hparams, decode_hp):\n num_samples = decode_hp.num_samples if decode_hp.num_samples > 0 else 1\n decode_length = decode_hp.extra_length\n input_type = \"text\"\n p_hparams = hparams.problem_hparams\n has_input = \"inputs\" in p_hparams.modality\n vocabulary = p_hparams.vocabulary[\"inputs\" if has_input else \"targets\"]\n # This should be longer than the longest input.\n const_array_size = 10000\n # Import readline if available for command line editing and recall.\n try:\n import readline # pylint: disable=g-import-not-at-top,unused-variable\n except ImportError:\n pass\n while True:\n prompt = (\"INTERACTIVE MODE num_samples=%d decode_length=%d \\n\"\n \" it=<input_type> ('text' or 'image' or 'label', default: \"\n \"text)\\n\"\n \" ns=<num_samples> (changes number of samples, default: 1)\\n\"\n \" dl=<decode_length> (changes decode length, default: 100)\\n\"\n \" <%s> (decode)\\n\"\n \" q (quit)\\n\"\n \">\" % (num_samples, decode_length,\n \"source_string\" if has_input else \"target_prefix\"))\n input_string = input(prompt)\n if input_string == \"q\":\n return\n elif input_string[:3] == \"ns=\":\n num_samples = int(input_string[3:])\n elif input_string[:3] == \"dl=\":\n decode_length = int(input_string[3:])\n elif input_string[:3] == \"it=\":\n input_type = input_string[3:]\n else:\n if input_type == \"text\":\n input_ids = vocabulary.encode(input_string)\n if has_input:\n input_ids.append(text_encoder.EOS_ID)\n x = [num_samples, decode_length, len(input_ids)] + input_ids\n assert len(x) < const_array_size\n x += [0] * (const_array_size - len(x))\n features = {\n \"inputs\": np.array(x).astype(np.int32),\n }\n elif input_type == \"image\":\n input_path = input_string\n img = vocabulary.encode(input_path)\n features = {\n \"inputs\": img.astype(np.int32),\n }\n elif input_type == \"label\":\n input_ids = [int(input_string)]\n x = [num_samples, decode_length, len(input_ids)] + input_ids\n features = {\n \"inputs\": np.array(x).astype(np.int32),\n }\n else:\n raise Exception(\"Unsupported input type.\")\n for k, v in six.iteritems(\n problem_lib.problem_hparams_to_features(p_hparams)):\n features[k] = np.array(v).astype(np.int32)\n yield features","def countryInput(self, prompt):\n while True:\n name = input(prompt)\n if name not in self.travel_db.countries:\n print(\"Invalid country name. Please make sure name is capitalized.\")\n else:\n return name","def request_input(self, possibles=[]):\n answer = self.console.input('Type your request here:')\n if len(possibles) > 0 and self.numeric:\n invalid = True\n while invalid:\n try:\n answer = int(answer)\n invalid = False\n break\n except:\n answer = self.console.input('Type your request here (numbers only):')\n\n answer = possibles[answer - 1]\n else:\n if answer.find('quit') != -1:\n self.running = False\n else:\n if answer.find('quit') != -1:\n self.running = False\n return answer","def proceed():\n c_print(\"********** PROCEED? **********\")\n # capture user input\n confirm = input(\" \" * 36 + \"(y/n) \")\n # quit script if not confirmed\n if confirm.lower() != \"y\":\n c_print(\"******* EXITING SCRIPT *******\")\n print(\"~\" * 80)\n exit()\n else:\n c_print(\"********* PROCEEDING *********\")"],"string":"[\n \"def do_prompt(self):\\n # we need _something_ in the dictionary even if the user decides to use all defaults\\n # otherwise for some unknown reason it won't work\\n user_in = {'__meta__': '__user_input__'}\\n\\n print('Please enter the information asked for in the following prompts in order to configure your deployment')\\n # get the config information from the user\\n for p in self.prompts:\\n answer = input(p['prompt'])\\n if len(answer.strip()) > 0 and 'variable' in p.keys():\\n user_in[p['variable']] = answer\\n\\n # return the data\\n return user_in\",\n \"def main():\\n\\n google_email = raw_input('Email: ')\\n google_password = getpass('Password: ')\\n auth = GetAuthentication(google_email, google_password)\\n model = raw_input('Model: ')\\n\\n query = []\\n message = 'Enter feature for classification. Type quit when done: '\\n while True:\\n feature = raw_input(message)\\n if feature == 'quit':\\n break\\n try:\\n float(feature)\\n query.append(float(feature))\\n except ValueError:\\n query.append(feature)\\n print query\\n print Predict(auth, model, query)\",\n \"def build_dataset_prompt():\\n\\n print(\\\"\\\")\\n print(\\\"Let's start by choosing what features you'd like to look at/explore!\\\")\",\n \"def interactive_shell():\\n print(\\\"\\\"\\\"\\nTo exit, enter 'EXIT'.\\nEnter a sentence like \\ninput> wth is it????\\\"\\\"\\\")\\n\\n while True:\\n try:\\n # for python 2\\n sentence = raw_input(\\\"input> \\\")\\n except NameError:\\n # for python 3\\n sentence = input(\\\"input> \\\")\\n\\n words_raw = sentence.strip()\\n\\n if words_raw == \\\"EXIT\\\":\\n break\\n \\n words_raw = Encoder.str2uni(words_raw)\\n label_prob, label_pred = predict(words_raw)\\n if label_pred[0] == 0:\\n print(\\\"OUTPUT> Subversive \\\\t\\\\t PROB> %.2f\\\"%(100*(1-label_prob.data[0])))\\n else:\\n print(\\\"OUTPUT> None \\\\t\\\\t PROB> %.2f\\\"%(100*label_prob.data[0]))\",\n \"def user_question():\\n return input('What would you like? (espresso/latte/cappuccino): ')\",\n \"def prompt():\\n\\n\\t# Inform the user on what price data has been taken\\n\\tprint(\\\"\\\\nCurrent available historical data for calibration: \\\")\\n\\tdata_files = listdir('call_data/')\\n\\tfor i in range(len(data_files)):\\n\\t\\tprint(data_files[i])\\n\\t# Ask the user if they would like to sample more points\\n\\tdone = False\\n\\twhile done != True:\\n\\t\\tinp = input(\\\"\\\\nWould you like to sample more historical price data? (y/n) \\\")\\n\\t\\ttry:\\n\\t\\t\\tif inp.lower() == 'y':\\n\\t\\t\\t\\tsample_calls.random_calls()\\n\\t\\t\\tif inp.lower() == 'n':\\n\\t\\t\\t\\tprint(\\\"Continuing to analysis.\\\\n\\\")\\n\\t\\t\\t\\tdone = True\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint(\\\"Invalid input.\\\")\\n\\t\\texcept ValueError:\\n\\t\\t\\tprint(\\\"\\\\nUnable to interpret input. Please try again.\\\")\",\n \"def get_input(self):\\n if self.console_label is None:\\n self.text_area.delete('1.0', END)\\n print(\\\"The training has finished and the training file was created and sent to the server! Go Back.\\\")\\n return\\n\\n valid_responses = {'y', 'n', 'u', 'f'}\\n\\n user_input = self.user_input.get()\\n\\n self.user_input.delete(0, END)\\n\\n if user_input not in valid_responses:\\n return\\n\\n self.console_label.label_record_pair(user_input, self.current_record_pair)\\n\\n if user_input == 'f':\\n self.upload_training_file()\\n self.current_record_pair = None\\n self.console_label = None\\n self.text_area.delete('1.0', END)\\n return\\n\\n self.text_area.yview(END)\\n\\n self.current_record_pair = self.console_label.get_uncertain_pair()\",\n \"def response_training_prompt(self):\\n self._last_response = \\\"training_prompt\\\"\\n print(\\\"Training Prompt\\\")\\n self.user_stats.set_followup(self._last_worst_grip)\\n return Mglove_str_gen.training_prompt(self.user_stats.get_followup())\",\n \"def __ask_query(self):\\n self.__output = list()\\n return input(form('What do you want to search?\\\\n> '))\",\n \"def use_random_keyword_classifier():\\n while True:\\n utterance = input(\\\"\\\\n\\\\nEnter utterance you want to classify, \\\\ntype menu or exit to go back:\\\\n-> \\\").lower()\\n if utterance == \\\"menu\\\" or utterance == \\\"exit\\\":\\n break\\n else:\\n try:\\n label_pred = random_keyword_classifier(utterance)\\n print(\\\"Prediction: {0}\\\".format(*label_pred))\\n except ValueError:\\n print(\\\"Prediction: {0}\\\".format(\\\"null\\\"))\",\n \"def prediction(name=None, message=''):\",\n \"def get_user_input(hparams=None):\\n utterance = input()\\n # End the chat\\n if utterance == 'end()':\\n return utterance, utterance\\n # Authorization not present\\n if not hparams or not hparams.UNAME or not hparams.TOKEN:\\n return utterance, utterance\\n\\n results = get_results(hparams, utterance)\\n textual_errors = results['textual_errors']\\n\\n correct_sent = correct_utterance(textual_errors, utterance)\\n if not correct_sent == utterance:\\n print_result(results)\\n print(\\\"The correct form is: \\\", correct_sent)\\n print()\\n # Return the correct sentence and the original utterance\\n return correct_sent, utterance\",\n \"def ask(self):\\n keyword = input(self.foretext)\\n\\n self.input_asked = True\\n\\n if keyword in self.keywords:\\n self.retrieved_input = keyword\\n if keyword in self.functions:\\n function, args, kwargs = self.functions[keyword]\\n return function(*args, **kwargs)\\n\\n else:\\n return keyword\\n else:\\n return self.fallback(keyword)\",\n \"def print_recommendations_from_user_input(self):\\n\\n getting_name = True\\n\\n print(\\\"Please enter username and press enter:\\\\n\\\")\\n\\n while getting_name:\\n username = input()\\n\\n redditor = self(username)\\n\\n if not redditor.username:\\n print(\\\"Redditor does not exist. Please enter again.\\\\n\\\")\\n continue\\n\\n break\\n\\n redditor.print_recommendations()\",\n \"def prompt(self):\\n # TODO: fix null input\\n print('Enter user input: ')\\n userinput = input()\\n print(f'User chose: {userinput}')\\n return userinput\",\n \"def use_keyword_classifier():\\n while True:\\n utterance = input(\\\"\\\\n\\\\nEnter utterance you want to classify, \\\\ntype menu or exit to go back:\\\\n-> \\\").lower()\\n if utterance == \\\"menu\\\" or utterance == \\\"exit\\\":\\n break\\n else:\\n try:\\n label_pred = keyword_classifier(utterance)\\n print(\\\"Prediction: {0}\\\".format(*label_pred))\\n except ValueError:\\n print(\\\"Prediction: {0}\\\".format(\\\"null\\\"))\",\n \"def _ask(threshold, matcher, facts):\\n io.reply('What do you want to ask me?')\\n while True:\\n message = io.prompt_without_parse('ask')\\n response = ask(threshold, matcher, facts, message)\\n type = response['type']\\n if type == 'invalid':\\n io.reply(response['validation_mesage'])\\n elif type == 'no_match':\\n # TODO: how to give detailed information on why no match was found?\\n io.reply('Sorry. My digital brain is not yet fully evolved. I did not understand it.')\\n io.reply('Could you rephrase the question, so I might be able to understand it?')\\n return\\n elif type == 'select_match':\\n _select_match(response['matches'])\\n else:\\n io.reply(response['answer'])\\n return\",\n \"def ask(self, prompt: str) -> str:\\n raise NotImplementedError\",\n \"def question():\\n print('Enter 1 to search database by habitat with detailed information\\\\nEnter 2 to search database by coordinates \\\\nEnter 3 to search by habitat in csv file for a quick overview without detail')\\n print('habitat search options so far:\\\\n Alpenvorland, Niederrheinisches Tiefland, Oberrheinisches Tiefland')\\n src = int(input('Enter here:'))\\n\\n if src == 1:\\n habitat = input('Enter name of habitat\\\\n')\\n query = \\\"habitat = '\\\" + habitat + \\\"'\\\"\\n search_db_via_query(query)\\n elif src == 2:\\n search_by_coordinates()\\n elif src == 3:\\n search_by_habitat()\\n else:\\n print('no data')\",\n \"def displayPredictions(predictions):\\n if predictions == []:\\n print(\\\"\\\\n No predictions to display. Run manual game analysis and select games to predict first.\\\")\\n print(\\\"\\\\nPress enter to return to previous menu.\\\\n\\\")\\n input()\\n return\\n else:\\n print(\\\"\\\\n Predictions\\\")\\n print(\\\"-----------\\\\n\\\")\\n for game in predictions:\\n print(game[0],game[1],game[2],game[3])\\n print(\\\"\\\\nPress enter to return to previous menu.\\\\n\\\")\\n input()\\n return\",\n \"def getUserInput():\\n\\n logging.info(\\\"\\\\nGood day! Press enter to accept default reduction options.\\\")\\n\\n fullReduction = getParam(\\n \\\"Do a full data reduction with default parameters loaded from recipes/default_input.cfg? [no]: \\\",\\n False,\\n \\\"Type yes to start Nifty with data reduction input parameters loaded from recipes/default_input.cfg file.\\\"\\n )\\n if fullReduction == False:\\n # \\\"Select in\\\". User has to turn individual steps on.\\n # TODO(nat): Implement these steps.\\n date = \\\"\\\"\\n program = \\\"\\\"\\n copy = \\\"\\\"\\n\\n sort = getParam(\\n \\\"Sort data? [no]: \\\",\\n False\\n )\\n rawPath = getParam(\\n \\\"Path to raw files directory? [~/data]: \\\",\\n \\\"~/data\\\"\\n )\\n tel = getParam(\\n \\\"Apply a telluric correction? [no]: \\\",\\n False\\n )\\n # See if we want to reduce the baseline calibrations. And if so, which substeps\\n # to perform.\\n calibrationReduction = getParam(\\n \\\"Reduce baseline calibrations? [no]: \\\",\\n False\\n )\\n # By default do all of them.\\n rstart = getParam(\\n \\\"Starting point of baseline calibration reductions? [1]: \\\",\\n 1\\n )\\n rstop = getParam(\\n \\\"Stopping point of baseline calibration reductions? [4]: \\\",\\n 4\\n )\\n\\n # Check for tellurics as well; by default do all reduction steps.\\n telluricReduction = getParam(\\n \\\"Reduce telluric data? [no]: \\\",\\n False\\n )\\n telStart = getParam(\\n \\\"Starting point of science and telluric reductions? [1]: \\\",\\n 1\\n )\\n telStop = getParam(\\n \\\"Stopping point of science and telluric reductions? [6]: \\\",\\n 6\\n )\\n # Set the telluric application correction method. Choices are iraf.telluric and a python variant.\\n # Set the h-line removal method with the vega() function in nifsReduce as default.\\n hline_method = getParam(\\n \\\"H-line removal method? [vega]: \\\",\\n \\\"vega\\\"\\n )\\n # Set yes or no for interactive the h line removal, telluric correction, and continuum fitting\\n hlineinter = getParam(\\n \\\"Interative H-line removal? [no]: \\\",\\n False\\n )\\n continuuminter = getParam(\\n \\\"Interative telluric continuum fitting? [no]: \\\",\\n False\\n )\\n telluric_correction_method = getParam(\\n \\\"Telluric correction method? [python]: \\\",\\n \\\"python\\\"\\n )\\n telinter = getParam(\\n \\\"Interactive telluric correction? [no]: \\\",\\n False\\n )\\n # Check for science as well.\\n scienceReduction = getParam(\\n \\\"Reduce science data? [no]: \\\",\\n False\\n )\\n sciStart = getParam(\\n \\\"Starting point of science and telluric reductions? [1]: \\\",\\n 1\\n )\\n sciStop = getParam(\\n \\\"Stopping point of science and telluric reductions? [6]: \\\",\\n 6\\n )\\n efficiencySpectrumCorrection = getParam(\\n \\\"Do a flux calibration? [no]: \\\",\\n False\\n )\\n spectemp = getParam(\\n \\\"Effective temperature in kelvin of telluric standard star? [\\\"\\\"]: \\\",\\n \\\"\\\"\\n )\\n mag = getParam(\\n \\\"Magnitude of standard star? [\\\"\\\"]: \\\",\\n \\\"\\\"\\n )\\n merge = getParam(\\n \\\"Produce one final 3D cube? [no]: \\\",\\n False\\n )\\n use_pq_offsets = getParam(\\n \\\"Use pq offsets to merge data cubes? [yes]: \\\",\\n \\\"yes\\\"\\n )\\n im3dtran = getParam(\\n \\\"Transpose cubes for faster merging? [no]: \\\",\\n False\\n )\\n over = getParam(\\n \\\"Overwrite old files? [no]: \\\",\\n False\\n )\\n debug = getParam(\\n \\\"Pause after each data reduction step? [yes]: \\\",\\n \\\"yes\\\"\\n )\\n\\n # Serialize and save the options as a .cfg file.\\n options = ConfigObj(unrepr=True)\\n options['date'] = date\\n options['program'] = program\\n options['rawPath'] = rawPath\\n options['over'] = over\\n options['copy'] = copy\\n options['sort'] = sort\\n options['calibrationReduction'] = calibrationReduction\\n options['scienceReduction'] = scienceReduction\\n options['merge'] = merge\\n options['tel'] = tel\\n options['telluricReduction'] = telluricReduction\\n options['spectemp'] = spectemp\\n options['mag'] = mag\\n options['efficiencySpectrumCorrection'] = efficiencySpectrumCorrection\\n options['rstart']= rstart\\n options['rstop'] = rstop\\n options['telStart'] = telStart\\n options['telStop'] = telStop\\n options['sciStart'] = sciStart\\n options['sciStop'] = sciStop\\n options['hline_method'] = hline_method\\n options['hlineinter'] = hlineinter\\n options['continuuminter'] = continuuminter\\n options['telluric_correction_method'] = telluric_correction_method\\n options['telinter'] = telinter\\n options['use_pq_offsets'] = use_pq_offsets\\n options['im3dtran'] = im3dtran\\n options['debug'] = debug\\n with open(RUNTIME_DATA_PATH+'/config.cfg', 'w') as outfile:\\n options.write(outfile)\\n\\n return fullReduction\",\n \"def prompt_user(prompt):\\r\\n # raw_input returns the empty string for \\\"enter\\\"\\r\\n yes = set(['yes', 'y'])\\r\\n no = set(['no','n'])\\r\\n\\r\\n try:\\r\\n print(prompt)\\r\\n choice = raw_input().lower()\\r\\n # would like to test for exception here, but not sure if we can do that without importing IPython\\r\\n except:\\r\\n print('Stdin is not implemented.')\\r\\n print('You need to set')\\r\\n print('overide_manual_authorize=True')\\r\\n print('to proceed with the download. Please set that variable and continue.')\\r\\n raise\\r\\n\\r\\n\\r\\n if choice in yes:\\r\\n return True\\r\\n elif choice in no:\\r\\n return False\\r\\n else:\\r\\n print(\\\"Your response was a \\\" + choice)\\r\\n print(\\\"Please respond with 'yes', 'y' or 'no', 'n'\\\")\\r\\n #return prompt_user()\\r\",\n \"def prompt(self, upstream_name):\\n self.prompt_events[upstream_name].set()\",\n \"def ask_user_input(self, sentence):\\n user_input = raw_input(sentence + \\\" : \\\")\\n return user_input\",\n \"def nlu_cli(default_mood, user_id):\\n mood = -1 # TODO currently superfulous while loop given default mood.\\n while mood not in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:\\n mood = input(\\n \\\"Enter your current mood on a scale of 1 to 10 where \\\"\\n + \\\"1 is negative, 5 is neutral, and 10 is positive (default is \\\"\\n + str(default_mood) + \\\"): \\\"\\n )\\n if mood == \\\"\\\" or not mood.isdigit():\\n mood = default_mood\\n else:\\n mood = int(mood)\\n mood = default_mood if mood == \\\"\\\" else int(mood)\\n\\n topic = \\\"\\\"\\n while topic == \\\"\\\":\\n topic = input(\\\"Enter Topic: \\\").strip().lower()\\n\\n #loop until they select correct dialogue act, show help after first fail\\n dialogue_act = \\\"\\\"\\n first = True\\n da_names = [da.name for da in DA if da.name not in\\n ['statement', 'question', 'response_action']\\n ]\\n while dialogue_act not in da_names:\\n dialogue_act = input(\\\"Enter dialogue Act: \\\").strip().lower()\\n\\n # TODO add help print out descriptions\\n if first and dialogue_act not in da_names:\\n first = False\\n # Help, details what each dialogue act means.\\n print(\\\"Enter a dialogue act from list below:\\\\n\\\", da_names)\\n\\n question_type = None\\n if is_question(DA[dialogue_act]):\\n question_type = \\\"\\\"\\n first = True\\n question_types = [qt.name for qt in QT]\\n while question_type not in question_types:\\n question_type = input(\\\"Enter question type: \\\").strip().lower()\\n\\n # TODO add help print out descriptions\\n if first and question_type not in question_types:\\n first = False\\n # Help, details what each dialogue act means.\\n print(\\\"Enter a question type from list below:\\\\n\\\",\\n question_types)\\n\\n text = input(\\n \\\"Enter utterance text: \\\"\\n ).strip()\\n\\n sentiment = -1\\n while sentiment not in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:\\n sentiment = input(\\n \\\"Enter utterance sentiment 1 to 10. \\\"\\n + \\\"1 negative, 5 neutral, and 10 positive: \\\"\\n )\\n sentiment = -1 if sentiment == \\\"\\\" else int(sentiment)\\n\\n assertiveness = -1\\n while assertiveness not in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:\\n assertiveness = input(\\n \\\"Enter utterance assertiveness 1 to 10. \\\"\\n + \\\"1 passive/listening oriented, 5 neutral, and \\\"\\n + \\\"10 assertive/leading conversation: \\\"\\n )\\n assertiveness = -1 if assertiveness == \\\"\\\" else int(assertiveness)\\n\\n return Utterance(\\n user_id,\\n DA[dialogue_act],\\n topic,\\n sentiment,\\n assertiveness,\\n text,\\n question_type\\n ), mood\",\n \"def topics_from_user_input(self):\\n\\n getting_name = True\\n\\n print(\\\"\\\\nPlease enter username and press enter:\\\\n\\\")\\n\\n while getting_name:\\n username = input()\\n\\n redditor = self(username)\\n\\n if not redditor.username:\\n print(\\\"Redditor does not exist. Please enter again.\\\\n\\\")\\n continue\\n\\n break\\n\\n redditor.print_topics()\",\n \"def get_user_input(arg_pair: EviPair):\\n global HUMAN_CORRECT_PRED\\n\\n while True:\\n try:\\n choice = int(raw_input())\\n\\n if choice in [1,2]:\\n\\n if choice == arg_pair.label:\\n HUMAN_CORRECT_PRED += 1\\n\\n break\\n else:\\n print(WRONG_INPUT)\\n except ValueError:\\n print(WRONG_INPUT)\\n\\n return choice\",\n \"def UserInput(self, username, userinput):\\n pass\",\n \"def getQuestion():\\n cat = getCategories(True)\\n print(\\\"--- Categories ---\\\")\\n print(cat[0])\\n print(cat[1])\\n print(cat[2])\\n userInput = input(\\\"Please, pick a subject: \\\\n\\\").casefold()\\n\\n\\n \\n if userInput != \\\"other\\\":\\n print(\\\"You have chosen: \\\" + userInput.title())\\n print(\\\"##############################\\\")\\n #Input question here XD\\n\\n \\n\\n question, answer, w, t = getQuestion(userInput, \\\"easy\\\")\\n \\n userAnswer = input(question)\\n if userAnswer.lower() == answer.lower():\\n print(\\\"Wehey \\\\n\\\")\\n elif userAnswer.lower() != answer.lower():\\n print(\\\"This is not the answer fool!\\\")\\n print(\\\"The answer is: \\\\n\\\")\\n print(answer + \\\"\\\\n\\\")\\n elif userInput == \\\"other\\\":\\n print(\\\"You have chosen: \\\" + userInput.title())\\n print(\\\"##############################\\\")\\n userInput = input(\\\"Want to hear a joke, fun fact or something random? \\\\n\\\")\\n if userInput == \\\"Yes\\\" or userInput == \\\"yes\\\":\\n print(random.choice(randomStuff) + \\\"\\\\n\\\")\",\n \"def getInput():\\t\\n\\tglobal active_\\n\\n\\t#to disable the service \\n\\tactive_ = False \\n\\t\\n\\t# reading the previous input\\n\\tprev_input_ = rospy.get_param('/input')\\n\\tinput_ = prev_input_\\n\\t\\n\\t#in order to make the user to choose one of the 5 possible inputs\\n\\twhile (prev_input_ == input_) or (input_ > 5 or input_ < 1):\\n\\t\\tif input_ > 5 or input_ < 1: \\n\\t\\t\\t#in the case in which the user make another selection\\n\\t\\t\\tprint \\\"Unknown input, please try again\\\" \\n\\t\\t\\n\\t\\t#propose to the user which are the real possibilities\\n\\t\\tprint(\\\"Please select one of the following senteces\\\\n\\\")\\n\\t\\tprint(\\\"1 - Move the robot randomly in the environment, by choosing one of six possible target positions\\\\n\\\")\\n\\t\\tprint(\\\"2 - The user can chose the next target position\\\\n\\\")\\n\\t\\tprint(\\\"3 - Start following the external walls\\\\n\\\")\\n\\t\\tprint(\\\"4 - Stop the robot in the last position\\\\n\\\")\\n\\t\\tprint(\\\"5 - Change the planning algorithm from move_base to bug0 and vice versa\\\\n\\\")\\n\\n\\t\\t#read the input typed by the user\\t\\n\\t\\tinput_ = (int(raw_input(\\\"Please select a number between 1 and 5: \\\")))\\n\\n\\t#set the choice made by the user\\n\\tif input_ >= 1 and input_ <= 5:\\n\\t\\trospy.set_param('/input', input_)\",\n \"def interactive_shell(model):\\n model.logger.info(\\\"\\\"\\\"\\nThis is an interactive mode.\\nTo exit, enter 'exit'.\\nYou can enter a sentence like\\ninput> I love Paris\\\"\\\"\\\")\\n\\n while True:\\n try:\\n # for python 2\\n sentence = input(\\\"input> \\\")\\n except NameError:\\n # for python 3\\n sentence = input(\\\"input> \\\")\\n\\n words_raw = sentence.strip().split(\\\" \\\")\\n\\n if words_raw == [\\\"exit\\\"]:\\n break\\n\\n preds = model.predict(words_raw)\\n to_print = align_data({\\\"input\\\": words_raw, \\\"output\\\": preds})\\n\\n for key, seq in to_print.items():\\n model.logger.info(seq)\",\n \"def ask(self):\\n subprocess.run([\\\"say\\\", \\\"-v\\\", \\\"Kyoko\\\", str(self.answer)])\",\n \"def utter(fileNames):\\n model = __initModel(fileNames)\\n\\n print(\\\"Please enter your sentence...\\\")\\n\\n try:\\n while True:\\n utterance = input()\\n print(numpy.random.choice(list(model.keys()), 1, p=list(model.values()))[0])\\n\\n except KeyboardInterrupt:\\n pass\",\n \"def ask(self, question):\\n\\n\\t\\t# If you're just trying to test voice detection, you can uncomment\\n\\t\\t# the following 5 lines. Bobby will guess \\\"yellow flashlight\\\" and will prompt\\n\\t\\t# you to correct him by saying \\\"blue flashlight\\\"\\n\\n\\t\\t# fake_answers = [\\\"no\\\", \\\"yes\\\", \\\"yes\\\", \\\"yes\\\", \\\"no\\\", \\\"yes\\\", \\\"yes\\\"]\\n\\t\\t# global count\\n\\t\\t# count += 1\\n\\t\\t# print question\\n\\t\\t# return fake_answers[count - 1]\\n\\n\\t\\t# self.say(question)\\n\\t\\t# #starts listening for an answer\\n\\t\\t# self.asr.subscribe(\\\"TEST_ASR\\\")\\n\\t\\t# data = (None, 0)\\n\\t\\t# while not data[0]:\\n\\t\\t# \\tdata = self.mem.getData(\\\"WordRecognized\\\")\\n\\t\\t# #stops listening after he hears yes or no\\n\\t\\t# self.asr.unsubscribe(\\\"TEST_ASR\\\")\\n\\t\\t#\\n\\t\\t# print data\\n\\t\\t#\\n\\t\\t# for word in self.yes_no_vocab:\\n\\t\\t# \\tfor syn in self.yes_no_vocab[word]:\\n\\t\\t# \\t\\tif data[0] == syn:\\n\\t\\t# \\t\\t\\treturn word\",\n \"def tinker (predictor):\\n col_size = predictor.max_label_length()\\n while True:\\n try:\\n sentence = input('\\\\nEnter a sentence to classify (\\\"exit\\\" to quit): ')\\n if sentence == 'exit':\\n print(\\\"Goodbye!\\\")\\n sys.exit(0)\\n print(\\\"\\\")\\n results = predictor.predict(sentence)\\n print(f\\\"Index | {'Subject'.ljust(col_size)} | {'Object'.ljust(col_size)} | Sentence\\\")\\n print(f\\\"------|-{'-' * col_size}-|-{'-' * col_size}-|---------\\\")\\n for result in results:\\n idx, sentence, subj, obj = result\\n print(f\\\"{str(idx).rjust(5)} | {subj.ljust(col_size)} | {obj.ljust(col_size)} | {sentence}\\\")\\n except KeyboardInterrupt:\\n print(\\\"Goodbye!\\\")\\n sys.exit(0)\",\n \"def _prompt_user(self):\\n print '\\\\nPlease enter the ff. Just leave blank to accept default.\\\\n'\\n self._handle_param(param='start',\\n msg='Starting date (Ex. Feb 1, 2016): ')\\n self._handle_param(param='end',\\n msg='Ending date (Ex. Aug 1, 2016): ')\",\n \"def user_interaction():\\n # Some information for the usage\\n print(\\\"For every following question: \\\\nIf you want to do it, type the number of how many \\\"\\n \\\"should be generated. If you don't want to do it, type anything else.\\\")\\n male_single = input(\\\"\\\\nDo you want to generate single male names? \\\")\\n\\n # This is the principle that will be used for every question. If the\\n # given input is an integer, it will run the program for how often\\n # it was told. If it wasn't an integer, the conversion will fail and\\n # we will just move on to the next one.\\n try:\\n for i in range(int(male_single)):\\n print(male_name())\\n except ValueError:\\n pass\\n\\n female_single = input(\\\"\\\\nDo you want to generate single female names? \\\")\\n try:\\n for i in range(int(female_single)):\\n print(female_name())\\n except ValueError:\\n pass\\n\\n last_single = input(\\\"\\\\nDo you want to generate single last names? \\\")\\n try:\\n for i in range(int(last_single)):\\n print(last_name())\\n except ValueError:\\n pass\\n\\n male_double = input(\\\"\\\\nDo you want to generate double male names? \\\")\\n try:\\n for i in range(int(male_double)):\\n print(double_name(\\\"male\\\"))\\n except ValueError:\\n pass\\n\\n female_double = input(\\\"\\\\nDo you want to generate double female names? \\\")\\n try:\\n for i in range(int(female_double)):\\n print(double_name(\\\"female\\\"))\\n except ValueError:\\n pass\\n\\n last_double = input(\\\"\\\\nDo you want to generate double last names? \\\")\\n try:\\n for i in range(int(last_double)):\\n print(double_name(\\\"family\\\"))\\n except ValueError:\\n pass\\n\\n full = input(\\\"\\\\nDo you want to generate full names? \\\")\\n try:\\n for i in range(int(full)):\\n print(full_name())\\n except ValueError:\\n pass\\n\\n statistic_name = input(\\\"\\\\nDo you want to statistically test names? \\\")\\n try:\\n statistical_test_name(int(statistic_name))\\n except ValueError:\\n pass\\n\\n full_identity = input(\\\"\\\\nDo you want to generate full identities? \\\")\\n try:\\n for i in range(int(full_identity)):\\n print(identity())\\n except ValueError:\\n pass\\n\\n sorted_list = input(\\\"\\\\nDo you want to create a sorted list? \\\")\\n try:\\n generate_sorted(int(sorted_list))\\n except ValueError:\\n pass\\n\\n statistics_full = input(\\\"\\\\nDo you want to create a full statistic over both names and \\\"\\n \\\"addresses? \\\")\\n try:\\n statistical_test(int(statistics_full))\\n except ValueError:\\n pass\\n\\n print(\\\"\\\\nThank you for using this program.\\\\nSee you soon,\\\\nTristan and Oliver\\\")\",\n \"def inask(question: str) -> str:\\n answer = input(question)\\n return answer\",\n \"def get_user_text_input(self):\\n\\t\\tuser_input = raw_input('You: ')\\n\\t\\treturn user_input\",\n \"def askforinput(msg='Do you want to proceed?', tab='', newline='\\\\n'):\\n while True:\\n inp = input(ColorText(f\\\"{newline}{tab}INPUT NEEDED: {msg} \\\\n{tab}(yes | no): \\\").warn().__str__()).lower()\\n if inp in ['yes', 'no']:\\n if inp == 'no' and msg=='Do you want to proceed?':\\n print(ColorText('exiting %s' % sys.argv[0]).fail())\\n exit()\\n break\\n else:\\n print(ColorText(\\\"Please respond with 'yes' or 'no'\\\").fail())\\n return inp\",\n \"def ask_user_input(prompt: str) -> str:\\n return input(prompt)\",\n \"def ask(self) -> data_input:\\n print(\\\"===========================\\\")\\n post_student_data = self.pre_data\\n for i in post_student_data:\\n if post_student_data[i] != \\\"N/A\\\":\\n print(f\\\"{i}: {post_student_data[i]}\\\")\\n print(\\\"===========================\\\")\\n post_data = self.data_input(post_student_data)\\n return post_data\",\n \"def ask_question(self, question):\\n self.response((question))\\n return input()\",\n \"def prompt_for_var_name():\\n return input('Variable name? ')\",\n \"def parse_user_selections(self):\\n if \\\"model2\\\" in sys.argv:\\n self.model_choice = \\\"model2\\\"\\n else:\\n self.model_choice = \\\"model1\\\"\\n\\n if \\\"Virginia\\\" in sys.argv:\\n self.region = \\\"Virginia\\\"\\n self.region_name = 'us-east-1'\\n elif \\\"California\\\" in sys.argv:\\n self.region = \\\"California\\\"\\n self.region_name = 'us-west-1'\\n else:\\n self.region = \\\"Oregon\\\"\\n self.region_name = 'us-west-2'\\n\\n if self.verbose_mode:\\n print \\\"** will run the Machine Learning %s\\\" % self.model_choice\\n print \\\"\\\\n** Running on %s Elastic Map Reduce server\\\" % self.region\",\n \"async def predict(input_data: schemas.MultipleUserDataInputs) -> Any:\\n print(input_data.inputs)\\n input_df = jsonable_encoder(input_data.inputs)[0][\\\"user_handle\\\"]\\n print(input_df)\\n logger.info(f\\\"Making prediction on inputs: {input_data.inputs}\\\")\\n results = make_prediction(input_df)\\n\\n logger.info(f\\\"Prediction results: {results.get('predictions')}\\\")\\n\\n return results\",\n \"def build_user_input(self):\\n pass\",\n \"def interact_model(\\n model_name='117M',\\n asker=None,\\n responder=None,\\n restore_from=None,\\n seed=None,\\n length=None,\\n temperature=1,\\n top_k=0,\\n top_p=0.0,\\n penalize=0,\\n prompt=None\\n):\\n if asker is None:\\n raise Exception(\\\"Add a name present in the training dataset that you will be chatting as\\\")\\n if responder is None:\\n raise Exception(\\\"Add a name present in the training dataset that gpt will be chatting as\\\")\\n\\n enc = encoder.get_encoder(model_name)\\n hparams = model.default_hparams()\\n with open(os.path.join('models', model_name, 'hparams.json')) as f:\\n hparams.override_from_dict(json.load(f))\\n\\n if length is None:\\n length = hparams.n_ctx // 2\\n elif length > hparams.n_ctx:\\n raise ValueError(\\\"Can't get samples longer than window size: %s\\\" % hparams.n_ctx)\\n\\n with tflex.Session(graph=tf.Graph()) as sess:\\n context = tf.placeholder(tf.int32, [1, None])\\n np.random.seed(seed)\\n tf.set_random_seed(seed)\\n output = sample.sample_sequence(\\n hparams=hparams, length=length,\\n context=context,\\n batch_size=1,\\n temperature=temperature, top_k=top_k, top_p=top_p, penalize=penalize\\n )\\n\\n saver = tflex.Saver()\\n if restore_from is None:\\n restore_from = os.path.join('models', model_name)\\n ckpt = tflex.latest_checkpoint(restore_from)\\n saver.restore(sess, ckpt)\\n\\n input_ = ''\\n time = 1924862493344\\n while True:\\n time = increase_time(time)\\n input_ = input_ + f'({time}) {asker}: ' + input(f\\\"{asker}: \\\")\\n time = increase_time(time)\\n input_ = input_ + f'\\\\n ({time}) {responder}: '\\n if len(input_) > 1 and input_.endswith('\\\\n'):\\n input_ = input_[:-1]\\n context_tokens = enc.encode(input_)\\n out = sess.run(output, feed_dict={\\n context: [context_tokens]\\n })[:, len(context_tokens):]\\n enc.decode(out[0])\\n text = enc.decode(out[0]).split(f') {asker}', 1)[0]\\n print(f'\\\\n ({time}) {responder}: ' + text.rsplit('(', 1)[0])\\n input_ = input_ + text\\n sys.stdout.flush()\",\n \"def predict():\\r\\n variance=request.args.get('variance')\\r\\n skewness=request.args.get('skewness')\\r\\n curtosis=request.args.get('curtosis')\\r\\n entropy=request.args.get('entropy')\\r\\n scaling=scaler.transform([[variance,skewness,curtosis,entropy]])\\r\\n prediction=classifier.predict(scaling)\\r\\n if prediction[0] == 0:\\r\\n return 'It is an Authentic Note'\\r\\n else:\\r\\n return \\\"It is a fake note\\\"\",\n \"def prompt(self, question):\\n self.output(' ')\\n self.output(question)\\n self.output(self.parse_response(str(self.ui())))\",\n \"def prompt_user_account_to_get_interest():\\n print('What account do you want 0.5% automatic interest?:')\\n return input()\",\n \"def textinput(self, title, prompt):\\n return simpledialog.askstring(title, prompt)\",\n \"def prompt_tech_selection(technologies=config.TECHNOLOGIES):\\n print(\\\"Select technology number for probability analysis from:\\\")\\n for i, tech in enumerate(technologies):\\n print(f\\\"{i + 1}. {tech}\\\")\\n print(\\\"Insert technology number for probability analysis:\\\")\\n\\n user_input = input()\\n if not user_input.isdigit() or int(user_input) > len(technologies) or int(user_input) < 1:\\n selection = 1\\n logging.warning(f\\\"Bad input, using default selection {selection}\\\")\\n else:\\n selection = int(user_input)\\n return technologies[selection - 1]\",\n \"def prediction_input() -> str:\\r\\n recipe_list = [\\\"Organic Red Helles\\\", \\\"Organic Pilsner\\\",\\r\\n \\\"Organic Dunkel\\\"]\\r\\n month_list = [\\\"Nov\\\", \\\"Dec\\\", \\\"Jan\\\", \\\"Feb\\\", \\\"Mar\\\", \\\"Apr\\\", \\\"May\\\", \\\"Jun\\\",\\r\\n \\\"Jul\\\", \\\"Aug\\\", \\\"Sep\\\", \\\"Oct\\\"]\\r\\n return render_template(\\\"prediction_input.html\\\", recipes=recipe_list,\\r\\n months=month_list)\",\n \"def query(prompt, parameters=None, options={'use_cache': False}):\\n\\n API_URL = \\\"https://api-inference.huggingface.co/models/EleutherAI/gpt-neo-2.7B\\\"\\n headers = {\\\"Authorization\\\": f\\\"Bearer {API_TOKEN}\\\"}\\n body = {\\\"inputs\\\":prompt,'parameters':parameters,'options':options}\\n response = requests.request(\\\"POST\\\", API_URL, headers=headers, data= json.dumps(body))\\n try:\\n response.raise_for_status()\\n except requests.exceptions.HTTPError:\\n print(\\\"Prompt:\\\")\\n print(prompt)\\n return \\\"API Error: \\\"+\\\" \\\".join(response.json()['error'])\\n else:\\n return response.json()[0]['generated_text']\",\n \"def ask_user_for_relevance(query_results):\\n for i, result in enumerate(query_results):\\n hdr = 'Result #%d ' % (i+1)\\n prompt_text = 'Is result #%d relevant? [y/n] ' % (i+1)\\n print '\\\\n' + hdr + '-'*(70 - len(hdr))\\n print result.to_formatted_string()\\n print '-'*70\\n while True:\\n user_in = raw_input(prompt_text).strip().lower()\\n if user_in == 'y' or user_in == 'n':\\n break\\n if user_in == 'y':\\n result.is_relevant = True\",\n \"def print_sample(arg_pair: EviPair):\\n print('Please think about which argument you '\\n 'would prefer in a discussion about: '\\n '\\\\'{}\\\\' '.format(arg_pair.topic))\\n print('First evidence has stance {} : '.format(arg_pair.first_stance))\\n print(arg_pair.first_evi)\\n print('Second evidence has stance {} : '.format(arg_pair.second_stance))\\n print(arg_pair.second_evi)\\n print('Enter your choice: ')\\n nn_prediction = predict_and_eval(arg_pair)\\n print('Neuronal Network selected evidence {}'.format(nn_prediction))\\n print('By an acceptance rate of {} sample was labeled as {} \\\\n'.\\n format(arg_pair.acceptance_rate, arg_pair.label))\",\n \"def _interactive_training(filebasename, cluster, identifier):\\n info = None\\n prc = None\\n if identifier == \\\"unknown\\\":\\n info = \\\"\\\"\\\"The system has not identified this speaker!\\\"\\\"\\\"\\n else:\\n info = \\\"The system identified this speaker as '\\\" + identifier + \\\"'!\\\"\\n print info\\n while True:\\n try:\\n char = raw_input(\\\"\\\\n 1) Listen\\\\n 2) Set \\\" + \\n \\\" name\\\\n Press enter to skip\\\\n> \\\")\\n except EOFError:\\n print ''\\n continue\\n print ''\\n if prc != None and prc.poll() == None:\\n prc.kill()\\n if char == \\\"1\\\":\\n videocluster = str(filebasename + \\\"/\\\" + cluster)\\n listwaves = os.listdir(videocluster)\\n listw = [os.path.join(videocluster, f) for f in listwaves]\\n wrd = \\\" \\\".join(listw)\\n commandline = \\\"play \\\" + str(wrd)\\n if sys.platform == 'win32':\\n commandline = \\\"vlc \\\" + str(wrd)\\n commandline = commandline.replace('\\\\\\\\', '\\\\\\\\\\\\\\\\')\\n print \\\" Listening %s...\\\" % cluster\\n args = shlex.split(commandline)\\n prc = subprocess.Popen(args, stdin=CONFIGURATION.output_redirect,\\n stdout=CONFIGURATION.output_redirect,\\n stderr=CONFIGURATION.output_redirect)\\n time.sleep(1)\\n continue\\n if char == \\\"2\\\":\\n menu = False\\n while not menu:\\n name = raw_input(\\\"Type speaker name \\\"\\n + \\\"or leave blank for unknown speaker: \\\")\\n while True:\\n if len(name) == 0:\\n name = \\\"unknown\\\"\\n if not name.isalnum():\\n print 'No blank, dash or special chars allowed! Retry'\\n# menu = True\\n break\\n okk = raw_input(\\\"Save as '\\\" + name + \\\"'? [Y/n/m] \\\")\\n if okk in ('y', 'ye', 'yes', ''):\\n return name\\n if okk in ('n', 'no', 'nop', 'nope'):\\n break\\n if okk in ('m', \\\"menu\\\"):\\n menu = True\\n break\\n if not menu:\\n print \\\"Yes, no or menu, please!\\\"\\n continue\\n if char == \\\"\\\":\\n return identifier\\n print \\\"Type 1, 2 or enter to skip, please\\\"\",\n \"def getInput(self):\\n print('You will be asked to vote on 16 subjects refered by titles.')\\n handicapped_infants = convertToFloat(str(input('Handicapped infants protection act - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n water_project_cost_sharing = convertToFloat(str(input('Water_project_cost_sharing - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n adoption_of_the_budget_resolution = convertToFloat(str(input('Adoption of the budget resolution - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n physician_fee_freeze = convertToFloat(str(input('Physician fee freeze - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n el_salvador_aid = convertToFloat(str(input('El salvador aid - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n religious_groups_in_schools = convertToFloat(str(input('Religious groups in schools - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n anti_satellite_test_ban = convertToFloat(str(input('Anti satellite test ban - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n aid_to_nicaraguan_contras = convertToFloat(str(input('Aid to nicaraguan contras - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n mx_missile = convertToFloat(str(input('Mx missile - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n immigration = convertToFloat(str(input('Immigration - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n synfuels_corporation_cutback = convertToFloat(str(input('Synfuels corporation cutback - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n education_spending = convertToFloat(str(input('Education spending - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n superfund_right_to_sue = convertToFloat(str(input('Superfund right to sue - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n crime = convertToFloat(str(input('Crime - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n duty_free_exports = convertToFloat(str(input('Duty free exports - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n export_administration_act_south_africa = convertToFloat(str(input('Export administration act south africa - Vote by typing \\\"y\\\" or \\\"n\\\" or \\\"?\\\": ')))\\n\\n self.inputData = np.array([handicapped_infants,water_project_cost_sharing,adoption_of_the_budget_resolution,physician_fee_freeze,el_salvador_aid,religious_groups_in_schools,anti_satellite_test_ban,aid_to_nicaraguan_contras,mx_missile,immigration,synfuels_corporation_cutback,education_spending,superfund_right_to_sue,crime,duty_free_exports,export_administration_act_south_africa])\",\n \"def get_inputs(self):\\n self.console.write(self.words.show_lines() + \\\"\\\\n\\\")\\n self.console.write(self.jumper.jumper_output())\\n guess = input(\\\"Guess a letter [a-z]: \\\").lower()\\n self.good_guess = self.words.get_lines(guess)\",\n \"def prompt_user_selection(self):\\n self.print_users()\\n user_input = self.input_for_user_selection()\\n currently_selected = self.users[int(user_input)]\\n return currently_selected\",\n \"def input(self, prompt):\\r\\n return console_input(prompt)\",\n \"def ask_user( prompt ):\\n answer = raw_input( prompt )\\n if answer.lower() in [\\\"y\\\",\\\"yes\\\"]:\\n return True\\n else:\\n return False\",\n \"def main():\\n args = parse_args()\\n mood = args.mood\\n\\n # Create both Personas for the user and the system\\n user_persona = Persona(\\\"user\\\", mood, 5)\\n simulated_persona = args.personality_profile\\n #simulated_persona = Persona(args.personality_profile)\\n\\n # initiate conversation\\n conversation_history = Conversation(\\n [user_persona, simulated_persona]\\n )\\n\\n ongoing_conversation = True\\n while ongoing_conversation:\\n # Query user for utterance\\n utterance, mood = nlu_cli(mood)\\n\\n # update conversation history\\n conversation_history.add_utterance(utterance)\\n\\n # update user persona\\n if user_persona.personality.mood != mood:\\n user_persona.personality.set_mood(mood)\\n\\n print(\\\"output NLU_CLI data:\\\\n\\\")\\n utterance.print_out()\\n print(\\\"\\\\n\\\", mood, \\\"\\\\n\\\")\\n\\n print(\\\"output conversation_history updated\\\\n\\\")\\n conversation_history.print_out()\\n\\n print(\\\"output user_persona.mood updated\\\\n\\\")\\n user_persona.print_out()\\n\\n if utterance.dialogue_act == DA.farewell:\\n ongoing_conversation = False\",\n \"def process_ask_configs(config):\\n\\n if config.confluence_ask_user:\\n print('(request to accept username from interactive session)')\\n print(' Instance: ' + config.confluence_server_url)\\n\\n default_user = config.confluence_server_user\\n u_str = ''\\n if default_user:\\n u_str = ' [{}]'.format(default_user)\\n\\n target_user = compat.input(' User{}: '.format(u_str)) or default_user\\n if not target_user:\\n raise ConfluenceConfigurationError('no user provided')\\n\\n config.confluence_server_user = target_user\\n\\n if config.confluence_ask_password:\\n print('(request to accept password from interactive session)')\\n if not config.confluence_ask_user:\\n print(' Instance: ' + config.confluence_server_url)\\n print(' User: ' + config.confluence_server_user)\\n sys.stdout.write(' Password: ')\\n sys.stdout.flush()\\n config.confluence_server_pass = util.getpass2('')\\n if not config.confluence_server_pass:\\n raise ConfluenceConfigurationError('no password provided')\",\n \"def ask_input(self, prompt):\\n self._vim.command('call inputsave()')\\n self._vim.command('let user_input = input(\\\"{} \\\")'.format(prompt))\\n self._vim.command('call inputrestore()')\\n response = self._vim.eval('user_input')\\n self._vim.command('unlet user_input')\\n return response\",\n \"def get_user_input(self, msg):\\n resp = input(msg)\\n return resp\",\n \"def prompt(self):\\n return input(self.message + \\\": \\\").strip()\",\n \"def ask(self):\\n self.term = str(input(\\\"What are you looking for? (Coffee, Restaurants, Museums, Bars) \\\"))\\n if self.term.lower() == 'quit':\\n sys.exit()\\n self.destination = str(input(\\\"Where are you looking to go? (Neighborhood, City or City, State) \\\"))\\n if self.destination.lower() == 'quit':\\n sys.exit()\\n \\n \\n #Request/JSON\\n self.request = self.session.get(\\\"http://api.yelp.com/v2/search\\\", params={'term': self.term,'location': self.destination})\\n self.request = self.request.json()\\n \\n #Dataframing\\n self.menu = json_normalize(self.request['businesses'])\\n self.menu.index = list(range(1, 21))\\n self.menu = self.menu[['name', 'categories', 'location.address', 'location.city', 'location.coordinate.latitude', \\\\\\n 'location.coordinate.longitude', 'review_count', 'rating', 'snippet_text']]\\\\\\n .sort_values(['rating'], ascending=False).sort_index()\",\n \"def predict():\\n to_predict = np.zeros(5).reshape(1, 5)\\n features = ['is_male', 'num_interactions_with_cust_service', 'late_on_payment', 'age', 'years_in_contract']\\n for i, feat in enumerate(features):\\n if request.args.get(feat) is not None:\\n to_predict[0][i] = request.args.get(feat)\\n\\n response = clf2.predict(to_predict)\\n\\n if response:\\n return \\\"The customer is likely to churn\\\"\\n else:\\n return \\\"He is a loyal customer\\\"\",\n \"def pose_question(self, keyword):\\n\\n # Determine correct answer\\n correct_answer = self.quiz_info[keyword]\\n \\n # Prevent correct answer from being used twice\\n weights = [1 if d != correct_answer else 0 for d in self.quiz_info.values()]\\n wrong_answers = random.choices(list(self.quiz_info.values()), weights=weights, k=3)\\n wrong_iter = iter(wrong_answers)\\n\\n # Define answer choices as letters and randomly choose the correct answer\\n shuffled_answers = ['a', 'b', 'c', 'd']\\n answers = shuffled_answers[:]\\n random.shuffle(shuffled_answers)\\n correct_choice = shuffled_answers.pop()\\n correct_idx = answers.index(correct_choice)\\n\\n print(\\\"\\\\nSelect the correct definition of '{}'\\\\n\\\".format(keyword))\\n for idx, ans in enumerate(answers):\\n\\n if idx == correct_idx:\\n print(\\\" \\\" + ans + ')\\\\t' + self._format_answer(correct_answer) + '\\\\n')\\n else:\\n print(\\\" \\\" + ans + ')\\\\t' + self._format_answer(next(wrong_iter)) + '\\\\n')\\n \\n user_choice = input(\\\"Enter your selection: \\\").strip().lower()\\n while user_choice not in answers:\\n print(\\\"You must select from ['a', 'b', 'c', 'd']...\\\")\\n user_choice = input(\\\"Enter your selection: \\\").strip().lower()\\n\\n return user_choice == correct_choice\",\n \"def respond(self,obs):\\n if obs.timestep == 0:\\n #If it's the first timestep, we have no clue. Since we don't even know if we are going to ask questions in the\\n #future, we go ahead and init the inference engine for future use.\\n self.p_obs = copy.deepcopy(obs)\\n self.tracking_stations = self.get_remaining_stations(obs)\\n self.inference_engine = inference_engine(self.tracking_agent,self.tracking_stations)\\n #And set the knowledge source to inference so the next step we know where to look for in the upcoming step.\\n self.knowledge.source[0] = ORIGIN.Inference\\n\\n #And pick a target station at random since we have to move forward.\\n target_station = np.random.choice(self.tracking_stations) #pick a station at random.\\n\\n else:\\n curr_k_id = self.knowledge.get_current_job_station_id()\\n\\n #Checking what knowledge we have.\\n if (self.knowledge.source[curr_k_id]==ORIGIN.Answer):\\n #Then we simply work on the station because we have an answer telling us that that's the station to work on.\\n target_station = self.knowledge.station_order[curr_k_id]\\n\\n elif (self.knowledge.source[curr_k_id] == None):\\n #which means we just finished a station in the last time-step. This calls for re-initalizing the inference_engine\\n self.tracking_stations = self.get_remaining_stations(obs)\\n self.inference_engine = inference_engine(self.tracking_agent,self.tracking_stations)\\n target_station = np.random.choice(self.tracking_stations)\\n\\n elif (self.knowledge.source[curr_k_id]==ORIGIN.Inference):\\n #Which means we have been working on a inference for a station.\\n target_station = self.inference_engine.inference_step(self.p_obs,obs)\\n self.knowledge.update_knowledge_from_inference(target_station)\\n warnings.WarningMessage(\\\"Provision resetting inference_engine when a station is finished\\\")\\n\\n else:\\n #it should never come to this.\\n raise Exception(\\\"Some mistake around\\\")\\n\\n \\\"\\\"\\\"\\n Okay, now that we know which station we should be headed to, we need to ensure the nitty-gritty details.\\n Do we have a tool?\\n If yes,\\n if it matches our target station:\\n destination: station\\n else:\\n destination: base\\n else:\\n destination: base\\n \\n Are we near our destination?\\n Yes:\\n Is it the base?\\n Pick up the tool.\\n else:\\n execute work action.\\n No:\\n keep moving. \\n \\\"\\\"\\\" \\n\\n if self.tool is not None:\\n if self.tool == target_station:\\n destination = obs.allPos[obs.stationIndices[target_station]]\\n else:\\n destination = global_defs.TOOL_BASE\\n else:\\n destination = global_defs.TOOL_BASE\\n\\n if utils.is_neighbor(self.pos,destination):\\n if destination == global_defs.TOOL_BASE:\\n #We are at the base to pick up a tool.\\n desired_action = global_defs.Actions.NOOP\\n self.tool = target_station\\n else:\\n #we are the station to work.\\n desired_action = global_defs.Actions.WORK\\n else:\\n #Navigate to destination.\\n desired_action = None\\n\\n obstacles = copy.deepcopy(obs.allPos).remove(self.pos)\\n proposal = utils.generate_proposal(self.pos,destination,obstacles,desired_action)\\n return proposal\",\n \"def prompt_message(\\n get_user_input: GetInputFunc, output_func: OutputFunc\\n) -> Tuple[SensorRun, bool]:\\n sensor_type = prompt_sensor_type(get_user_input, output_func)\\n mount = prompt_str_input(\\n 'pipette mounts:\\\"left\\\" or \\\"right\\\", gripper mount: \\\"gripper\\\"', get_user_input\\n )\\n serial_number = prompt_str_input(\\\"instrument serial number\\\", get_user_input)\\n auto_zero = prompt_bool_input(\\\"auto zero?\\\", get_user_input)\\n minutes = prompt_float_input(\\\"script run time in minutes\\\", get_user_input)\\n output_to_csv = prompt_bool_input(\\\"output to csv?\\\", get_user_input)\\n\\n sensor_run = SensorRun(sensor_type, serial_number, bool(auto_zero), minutes, mount)\\n return sensor_run, output_to_csv\",\n \"def ask(question):\\n while True:\\n query = input('{}\\\\n Reply (y/n) >>'.format(question))\\n res = query[0].lower()\\n if query == '' or not res in ['y', 'n']:\\n pass\\n else:\\n break\\n\\n if res == 'y':\\n return True\\n else:\\n return False\",\n \"def prompt_for_survey(console: io.IO):\\n msg = ('Would you like to take a survey to provide your feedback for '\\n 'the deployment process? [y/N]')\\n\\n do_survey = prompt.binary_prompt(msg, console, default=False)\\n if do_survey:\\n webbrowser.open_url(_SURVEY_LINK)\",\n \"def prompt() -> None:\\n\\n username = click.prompt(\\n text=\\\"Please enter a username\\\",\\n type=click.STRING\\n )\\n password = click.prompt(\\n text=\\\"Please enter a new password\\\",\\n hide_input=True,\\n confirmation_prompt=True\\n )\\n newsletter_subscription = click.prompt(\\n text=\\\"Would you like to subscribe to our newsletter?\\\",\\n default=False,\\n type=click.BOOL\\n )\\n favorite_color=click.prompt(\\n text=\\\"What is your favorite color?\\\",\\n type=click.Choice([\\\"blue\\\", \\\"green\\\", \\\"yellow\\\"], case_sensitive=False)\\n )\\n\\n click.echo(\\n f\\\"Username: {username} | Password: {'*' * len(password)} | \\\"\\n + f\\\"Newsletter: {newsletter_subscription} | Favorite color: \\\"\\n + click.style(favorite_color, fg=favorite_color)\\n )\",\n \"def user_prompt(prompt, default=None):\\n prompt = f\\\"\\\\n {prompt} [{default}] runs or type an amount: \\\"\\n response = input(prompt)\\n if not response and default:\\n return default\\n else:\\n return response\",\n \"def enter_follow_up_patient(project_path: str, project_name: str):\\n # Get Follow Up Log\\n follow_up_log_path = os.path.join(project_path, 'logs', 'Follow_Up_Log.xlsx')\\n\\n while True:\\n choice = input(\\\"Would you like to enter a new patient onto the Follow Up log [Y/N]? \\\")\\n\\n if choice and choice.strip() and choice.lower() == 'y':\\n patient_data = rsm.get_data_from_user.get_follow_up_data()\\n rsm.add_patient_to_excel_file.add_patient(follow_up_log_path,\\n patient_data,\\n 'Follow_Up_Log')\\n print(\\\"Successfully added patient to {} Follow Up log\\\".format(project_name))\\n\\n elif choice and choice.strip() and choice.lower() == 'n':\\n break\\n else:\\n print(\\\"Please enter Y or N\\\")\",\n \"def reply_request(question: str, reply_options = ['y', 'yes', 'n', 'no'], show_reply = False):\\n\\n reply = None \\n while not reply in reply_options:\\n reply = input(question).lower()\\n else:\\n if show_reply:\\n print(f'Your choice: {reply}')\\n \\n if reply in ['yes', 'no']:\\n return reply[0]\\n else:\\n return reply\",\n \"def ask(prompt):\\n\\n return renpy.exports.invoke_in_new_context(renpy.store.layout.yesno_prompt, None, prompt)\",\n \"def get_yes_no_input(logger, text, default=None):\\n if default:\\n default = default.strip().lower()\\n\\n y = \\\"Y\\\" if default == \\\"y\\\" else \\\"y\\\"\\n n = \\\"N\\\" if default == \\\"n\\\" else \\\"n\\\"\\n\\n prompt = f\\\"{text} [{yellow(y)}/{yellow(n)}]\\\"\\n user_input = \\\"\\\"\\n\\n while not user_input:\\n logger(prompt, end=\\\"\\\")\\n user_input = input(\\\" \\\").strip().lower()\\n if user_input == \\\"\\\" and default:\\n user_input = default\\n\\n return user_input\",\n \"def prompt():\\n program_info = ('Dice Rolling Simulator\\\\n'\\n 'Author: Franklin Pinnock\\\\n'\\n 'Language: Python 3.4\\\\n'\\n 'Version: 1.0\\\\n')\\n print(program_info)\",\n \"def ask_user(d):\\n\\n # Print welcome message\\n msg = bold('Welcome to the Hieroglyph %s quickstart utility.') % (\\n version(),\\n )\\n print(msg)\\n msg = \\\"\\\"\\\"\\nThis will ask questions for creating a Hieroglyph project, and then ask\\nsome basic Sphinx questions.\\n\\\"\\\"\\\"\\n print(msg)\\n\\n # set a few defaults that we don't usually care about for Hieroglyph\\n d.update({\\n 'version': datetime.date.today().strftime('%Y.%m.%d'),\\n 'release': datetime.date.today().strftime('%Y.%m.%d'),\\n 'make_mode': True,\\n })\\n\\n if 'project' not in d:\\n print('''\\nThe presentation title will be included on the title slide.''')\\n d['project'] = sphinx_quickstart.do_prompt('Presentation title')\\n if 'author' not in d:\\n d['author'] = sphinx_quickstart.do_prompt('Author name(s)')\\n\\n # slide_theme\\n theme_entrypoints = pkg_resources.iter_entry_points('hieroglyph.theme')\\n\\n themes = [\\n t.load()\\n for t in theme_entrypoints\\n ]\\n\\n msg = \\\"\\\"\\\"\\nAvailable themes:\\n\\n\\\"\\\"\\\"\\n\\n for theme in themes:\\n msg += '\\\\n'.join([\\n bold(theme['name']),\\n theme['desc'],\\n '', '',\\n ])\\n\\n msg += \\\"\\\"\\\"Which theme would you like to use?\\\"\\\"\\\"\\n print(msg)\\n\\n d['slide_theme'] = sphinx_quickstart.do_prompt(\\n 'Slide Theme',\\n themes[0]['name'],\\n sphinx_quickstart.choice(\\n *[t['name'] for t in themes]\\n ),\\n )\\n\\n # Ask original questions\\n print(\\\"\\\")\\n sphinx_quickstart.ask_user(d)\",\n \"def example_single(args, model, word2idx):\\n #在命令行中加载和分段<目标、（推特内容）>配对\\n while True:\\n target = raw_input(\\\"问题: \\\")\\n tweet = raw_input(\\\"回答: \\\")\\n targets = [str(target)]\\n tweets = [str(tweet)]\\n seged_tweets = yutils.seg_sentence(tweets, choice=\\\"list\\\", place=\\\"hpc\\\") # may use lexicon here\\n seged_targets = yutils.seg_sentence(targets, choice=\\\"list\\\", place=\\\"hpc\\\")\\n predictions = evaluate(args, model, word2idx, seged_tweets, seged_targets)\\n print(\\\"预测结果: \\\", predictions)\",\n \"def post(self):\\n # use parser and find the user's query\\n args = parser.parse_args()\\n title = args['title']\\n author = model.encode_author(args['author'])\\n text = args['text']\\n\\n X = model.vector_and_stack(title=title, text=text, author=author)\\n\\n prediction = model.predict(X)\\n\\n # Output either 'Negative' or 'Positive' along with the score\\n if round(prediction[0]) == 0:\\n pred_text = 'Reliable News'\\n else:\\n pred_text = 'Unreliable News'\\n\\n # round the predict proba value and set to new variable\\n confidence = round(prediction[0], 3)\\n\\n # create JSON object\\n output = {'prediction': pred_text, 'fake_rate': confidence}\\n\\n return output, 200\",\n \"def main():\\r\\n train('train.dat','out','dt')\\r\\n predict('test.dat','out')\\r\\n while(True):\\r\\n command=input(\\\"Enter the option you want to use, type exit to quit: \\\").split()\\r\\n if command[0] == 'exit':\\r\\n exit()\\r\\n elif command[0] == 'train':\\r\\n examples = command[1]\\r\\n hypothesisOut = command[2]\\r\\n learning_type = command[3]\\r\\n print(\\\"Starting training...\\\")\\r\\n train(examples, hypothesisOut, learning_type)\\r\\n print(\\\"Training is done.\\\")\\r\\n\\r\\n elif command[0] == 'predict':\\r\\n hypothesis = command[1]\\r\\n file = command[2]\\r\\n print(\\\"Starting to predict...\\\")\\r\\n print(\\\"The predictions are: \\\")\\r\\n predictions = predict(hypothesis, file)\",\n \"def prompt(question):\\n print('\\\\n')\\n while True:\\n reply = str(input(question+' (y/n): ')).lower().strip()\\n if reply[:1] == 'y':\\n return True\\n if reply[:1] == 'n':\\n return False\",\n \"def use_random_forest_classifier(classifier, vectorizer, labels):\\n while True:\\n utterance = input(\\\"\\\\n\\\\nEnter utterance you want to classify, \\\\ntype menu or exit to go back:\\\\n-> \\\").lower()\\n if utterance == \\\"menu\\\" or utterance == \\\"exit\\\":\\n break\\n else:\\n y_pred = classifier.predict(vectorizer.transform([utterance]))\\n\\n try:\\n label_pred = labels[y_pred[0].tolist().index(1)]\\n print(\\\"Prediction: {0}\\\".format(label_pred))\\n except ValueError:\\n print(\\\"Prediction: {0}\\\".format(\\\"null\\\"))\",\n \"def get_host_name():\\r\\n\\tglobal HOST_NAME\\r\\n\\r\\n\\twhile True:\\r\\n\\t\\tname_of_host = input(\\\"What is your name (As it appears in zoom without the '(Host, me)' part)? \\\")\\r\\n\\t\\tHOST_NAME = name_of_host + \\\" (Host, me)\\\"\\r\\n\\t\\tcorrect = input(f\\\"Host name set as {HOST_NAME}, is this correct? [Y/N]: \\\")\\r\\n\\t\\tif correct.upper() == \\\"Y\\\":\\r\\n\\t\\t\\treturn\",\n \"def show_predictions(result, invalid, event):\\n\\n s.sendReply(\\n event,\\n f'Predictions: {result if result else \\\"none\\\"}\\\\n'\\n f'Invalid: {\\\", \\\".join(invalid) if invalid else \\\"none\\\"}',\\n )\\n\\n if result:\\n s.sendReply(\\n event,\\n \\\"Note: The models do not take news or current events into account. \\\"\\n \\\"Some models work better for different stocks based on their behaviour, \\\"\\n \\\"try following the predictions for a while to determine which is best.\\\",\\n )\",\n \"def get_user_choice():\\n user_input = input('Your choice: ')\\n return user_input\",\n \"def prompt(self, upstream_name):\\n request = PromptRequest(upstream_name=upstream_name)\\n response = self.stub.Prompt(request, timeout=5)\",\n \"def suggest(ctx, request: str):\\n replacer = Replacer(ctx.obj.get('GKG_API_KEY'))\\n suggestion = replacer.suggest(request)\\n if suggestion == request:\\n logger.info(\\n 'Result from Google Knowledge Graph equals input: \\\"{0}\\\"', request,\\n )\\n elif suggestion:\\n logger.info('Result from Google Knowledge Graph: \\\"{0}\\\"', suggestion)\\n else:\\n logger.info(\\n 'No results in the Google Knowledge Graph for: \\\"{0}\\\"', request,\\n )\",\n \"def _get_user_input(query, valid, default):\\n\\n # Wait for valid user input and return choice upon receipt\\n while True:\\n choice = input(query)\\n if default is not None and choice == \\\"\\\":\\n return default\\n elif choice in valid:\\n return choice\\n else:\\n print(\\\"Please respond with '\\\" + \\\\\\n \\\"or '\\\".join(opt + \\\"' \\\" for opt in valid) + \\\"\\\\n\\\")\",\n \"def Prompt(self,message):\\n\\t\\tself.acad.ActiveDocument.Utility.Prompt(message)\",\n \"def query(self,text_input,prefix='answer:',convert_to_string=True):\\n predictions, raw_outputs = self.model.predict([text_input])\\n raw_outputs = [np.max(softmax([s[1][0] for s in v.items()][0])) for v in raw_outputs[0]]\\n preds = [[(i[0],i[1],raw_outputs[k]) for i in p.items()][0] for k,p in enumerate(predictions[0])]\\n return self._post_process_output(preds,convert_to_string=convert_to_string)\",\n \"def _interactive_input_fn(hparams, decode_hp):\\n num_samples = decode_hp.num_samples if decode_hp.num_samples > 0 else 1\\n decode_length = decode_hp.extra_length\\n input_type = \\\"text\\\"\\n p_hparams = hparams.problem_hparams\\n has_input = \\\"inputs\\\" in p_hparams.modality\\n vocabulary = p_hparams.vocabulary[\\\"inputs\\\" if has_input else \\\"targets\\\"]\\n # This should be longer than the longest input.\\n const_array_size = 10000\\n # Import readline if available for command line editing and recall.\\n try:\\n import readline # pylint: disable=g-import-not-at-top,unused-variable\\n except ImportError:\\n pass\\n while True:\\n prompt = (\\\"INTERACTIVE MODE num_samples=%d decode_length=%d \\\\n\\\"\\n \\\" it=<input_type> ('text' or 'image' or 'label', default: \\\"\\n \\\"text)\\\\n\\\"\\n \\\" ns=<num_samples> (changes number of samples, default: 1)\\\\n\\\"\\n \\\" dl=<decode_length> (changes decode length, default: 100)\\\\n\\\"\\n \\\" <%s> (decode)\\\\n\\\"\\n \\\" q (quit)\\\\n\\\"\\n \\\">\\\" % (num_samples, decode_length,\\n \\\"source_string\\\" if has_input else \\\"target_prefix\\\"))\\n input_string = input(prompt)\\n if input_string == \\\"q\\\":\\n return\\n elif input_string[:3] == \\\"ns=\\\":\\n num_samples = int(input_string[3:])\\n elif input_string[:3] == \\\"dl=\\\":\\n decode_length = int(input_string[3:])\\n elif input_string[:3] == \\\"it=\\\":\\n input_type = input_string[3:]\\n else:\\n if input_type == \\\"text\\\":\\n input_ids = vocabulary.encode(input_string)\\n if has_input:\\n input_ids.append(text_encoder.EOS_ID)\\n x = [num_samples, decode_length, len(input_ids)] + input_ids\\n assert len(x) < const_array_size\\n x += [0] * (const_array_size - len(x))\\n features = {\\n \\\"inputs\\\": np.array(x).astype(np.int32),\\n }\\n elif input_type == \\\"image\\\":\\n input_path = input_string\\n img = vocabulary.encode(input_path)\\n features = {\\n \\\"inputs\\\": img.astype(np.int32),\\n }\\n elif input_type == \\\"label\\\":\\n input_ids = [int(input_string)]\\n x = [num_samples, decode_length, len(input_ids)] + input_ids\\n features = {\\n \\\"inputs\\\": np.array(x).astype(np.int32),\\n }\\n else:\\n raise Exception(\\\"Unsupported input type.\\\")\\n for k, v in six.iteritems(\\n problem_lib.problem_hparams_to_features(p_hparams)):\\n features[k] = np.array(v).astype(np.int32)\\n yield features\",\n \"def countryInput(self, prompt):\\n while True:\\n name = input(prompt)\\n if name not in self.travel_db.countries:\\n print(\\\"Invalid country name. Please make sure name is capitalized.\\\")\\n else:\\n return name\",\n \"def request_input(self, possibles=[]):\\n answer = self.console.input('Type your request here:')\\n if len(possibles) > 0 and self.numeric:\\n invalid = True\\n while invalid:\\n try:\\n answer = int(answer)\\n invalid = False\\n break\\n except:\\n answer = self.console.input('Type your request here (numbers only):')\\n\\n answer = possibles[answer - 1]\\n else:\\n if answer.find('quit') != -1:\\n self.running = False\\n else:\\n if answer.find('quit') != -1:\\n self.running = False\\n return answer\",\n \"def proceed():\\n c_print(\\\"********** PROCEED? **********\\\")\\n # capture user input\\n confirm = input(\\\" \\\" * 36 + \\\"(y/n) \\\")\\n # quit script if not confirmed\\n if confirm.lower() != \\\"y\\\":\\n c_print(\\\"******* EXITING SCRIPT *******\\\")\\n print(\\\"~\\\" * 80)\\n exit()\\n else:\\n c_print(\\\"********* PROCEEDING *********\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64296","0.6354998","0.63514704","0.6275108","0.6199466","0.6192252","0.6019146","0.59782445","0.5917745","0.590989","0.584681","0.58215415","0.5810385","0.579001","0.5771973","0.576907","0.5767045","0.5765213","0.5736743","0.5734095","0.57227224","0.57066315","0.5703555","0.5700363","0.5690616","0.5664714","0.5642506","0.56071585","0.55962694","0.5566717","0.5560368","0.5559319","0.5541041","0.55407625","0.55316937","0.55074966","0.550462","0.54836166","0.54763585","0.5466234","0.54644525","0.54582185","0.54571015","0.5455171","0.54390895","0.5434704","0.54247177","0.5423095","0.54192597","0.54155195","0.5414388","0.54079264","0.5404738","0.53850615","0.5382351","0.5340142","0.5332936","0.5329387","0.5300188","0.5297892","0.5295705","0.52928835","0.52734333","0.52728057","0.52701825","0.5267828","0.52673924","0.5264111","0.5259743","0.5248079","0.52348614","0.52310985","0.5218957","0.52126324","0.51878273","0.51873523","0.51823705","0.5179752","0.51743126","0.5173322","0.5172405","0.5170942","0.516892","0.5166793","0.51656455","0.51652396","0.51619476","0.5161575","0.5156809","0.51466817","0.51418996","0.5140402","0.5140397","0.5134031","0.5133019","0.51325285","0.513059","0.51302475","0.5129638","0.51288486"],"string":"[\n \"0.64296\",\n \"0.6354998\",\n \"0.63514704\",\n \"0.6275108\",\n \"0.6199466\",\n \"0.6192252\",\n \"0.6019146\",\n \"0.59782445\",\n \"0.5917745\",\n \"0.590989\",\n \"0.584681\",\n \"0.58215415\",\n \"0.5810385\",\n \"0.579001\",\n \"0.5771973\",\n \"0.576907\",\n \"0.5767045\",\n \"0.5765213\",\n \"0.5736743\",\n \"0.5734095\",\n \"0.57227224\",\n \"0.57066315\",\n \"0.5703555\",\n \"0.5700363\",\n \"0.5690616\",\n \"0.5664714\",\n \"0.5642506\",\n \"0.56071585\",\n \"0.55962694\",\n \"0.5566717\",\n \"0.5560368\",\n \"0.5559319\",\n \"0.5541041\",\n \"0.55407625\",\n \"0.55316937\",\n \"0.55074966\",\n \"0.550462\",\n \"0.54836166\",\n \"0.54763585\",\n \"0.5466234\",\n \"0.54644525\",\n \"0.54582185\",\n \"0.54571015\",\n \"0.5455171\",\n \"0.54390895\",\n \"0.5434704\",\n \"0.54247177\",\n \"0.5423095\",\n \"0.54192597\",\n \"0.54155195\",\n \"0.5414388\",\n \"0.54079264\",\n \"0.5404738\",\n \"0.53850615\",\n \"0.5382351\",\n \"0.5340142\",\n \"0.5332936\",\n \"0.5329387\",\n \"0.5300188\",\n \"0.5297892\",\n \"0.5295705\",\n \"0.52928835\",\n \"0.52734333\",\n \"0.52728057\",\n \"0.52701825\",\n \"0.5267828\",\n \"0.52673924\",\n \"0.5264111\",\n \"0.5259743\",\n \"0.5248079\",\n \"0.52348614\",\n \"0.52310985\",\n \"0.5218957\",\n \"0.52126324\",\n \"0.51878273\",\n \"0.51873523\",\n \"0.51823705\",\n \"0.5179752\",\n \"0.51743126\",\n \"0.5173322\",\n \"0.5172405\",\n \"0.5170942\",\n \"0.516892\",\n \"0.5166793\",\n \"0.51656455\",\n \"0.51652396\",\n \"0.51619476\",\n \"0.5161575\",\n \"0.5156809\",\n \"0.51466817\",\n \"0.51418996\",\n \"0.5140402\",\n \"0.5140397\",\n \"0.5134031\",\n \"0.5133019\",\n \"0.51325285\",\n \"0.513059\",\n \"0.51302475\",\n \"0.5129638\",\n \"0.51288486\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67718136"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23399,"cells":{"query":{"kind":"string","value":"Implement the closure here."},"document":{"kind":"string","value":"def _define_objective(self, inputs, labels, targets, intended_classes=None, true_classes=None):\n def closure(model, criterion, optimizer, target_grad, target_gnorm):\n \"\"\"This function will be evaluated on all GPUs.\"\"\" # noqa: D401\n outputs = model(inputs)\n if self.args.target_criterion in ['cw', 'carlini-wagner']:\n criterion = cw_loss\n else:\n pass # use the default for untargeted or targeted cross entropy\n poison_loss = criterion(outputs, labels)\n prediction = (outputs.data.argmax(dim=1) == labels).sum()\n poison_grad = torch.autograd.grad(poison_loss, model.parameters(), retain_graph=True, create_graph=True)\n\n passenger_loss = self._passenger_loss(poison_grad, target_grad, target_gnorm)\n if self.args.centreg != 0:\n passenger_loss = passenger_loss + self.args.centreg * poison_loss\n passenger_loss.backward(retain_graph=self.retain)\n return passenger_loss.detach().cpu(), prediction.detach().cpu()\n return closure"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def closure(self, t):\n raise NotImplementedError","def callback(self):\n pass # pragma: no cover","def __call__(self):\n\t\treturn","def __call__( self ):\n pass","def apply(self):","def apply(self) -> None:","def apply(self) -> None:","def closure(self):\n return self + self.boundary","def call(self):","def handle(self):","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def __call__(self) -> None:","def function(self):\n raise NotImplementedError","def executor(self):","def __call__(self):\n pass","def __call__(self):\n pass","def process(self):","def process(self):","def process(self):","def __call__(self):\n yield from self","def __call__(self):\n raise NotImplementedError","def apply(self): # pragma: no cover\n raise NotImplementedError","def apply(self):\n pass","def apply(self):\n pass","def __call__():","def __call__():","def __call__():","def __call__():","def __call__():","def __call__(self):","def __call__(self):","def __call__(self):\n return self.fn()","def create_callback(self, chain):","def iterate(self):","def handle(self) -> None:","def fn():","def _hook(self):","def processing(self):\n pass","def callback(self, *args):\n raise NotImplementedError()","def post_execute(self):","def __call__(self):\n return self.referee()","def run(self): \r\n return","def on_success(self) -> None:","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def _to_be_wrapped(self) -> None:","def process(self):\n pass","def application(self):","def __call__(self):\n return self","def func():","def post_processor(self):","def _apply(self, **kwargs):\n raise NotImplementedError","def result(self):","def result(self):","def final(self):\n pass","def _gen_closure(fnc,arg):\n return lambda s: fnc(arg)","def run(self):\n self.func()","def g():","def __call__(self):\r\n raise NotImplementedError('override me')","def __call__(self, f):\n raise NotImplementedError()","def _finished(self) -> None:","def _execute(self, _):\r\n pass","def firstFunction(self):","def handle(self):\n raise NotImplementedError","def __call__(self):\n raise NotImplementedError()","def __call__(self, **kwargs):\n raise NotImplementedError","def finished(self):","def perform_callback(self, *args, **kwargs):\n pass","def _make_halowait(self, f):\n return","def __call__(self) -> dict:\n\t\tpass","def fire(self):","def on_success(self):\n pass","def postLoopFunctions(self):\n\t\treturn","def callback_function(self):\n raise exceptions.NotImplementedError()","def done(self):","def done(self):","def apply(self, *args, **kwargs):\n pass","def map(self, function):\n pass","def _postprocess(self):","def __call__(self, *args, **kwargs):\n raise NotImplementedError","def __call__(self, *args, **kwargs):\n raise NotImplementedError","def __call__(self, *args, **kwargs):\n return self.f(*args, **kwargs)","def process(self):\n raise NotImplementedError","def task(self):","def task(self):","def method(self):","def __call__(self, *args, **kwargs):\n return function(args, addtional_info)","def on(self) -> None:","def __call__(self, x):\n pass"],"string":"[\n \"def closure(self, t):\\n raise NotImplementedError\",\n \"def callback(self):\\n pass # pragma: no cover\",\n \"def __call__(self):\\n\\t\\treturn\",\n \"def __call__( self ):\\n pass\",\n \"def apply(self):\",\n \"def apply(self) -> None:\",\n \"def apply(self) -> None:\",\n \"def closure(self):\\n return self + self.boundary\",\n \"def call(self):\",\n \"def handle(self):\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def __call__(self) -> None:\",\n \"def function(self):\\n raise NotImplementedError\",\n \"def executor(self):\",\n \"def __call__(self):\\n pass\",\n \"def __call__(self):\\n pass\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def __call__(self):\\n yield from self\",\n \"def __call__(self):\\n raise NotImplementedError\",\n \"def apply(self): # pragma: no cover\\n raise NotImplementedError\",\n \"def apply(self):\\n pass\",\n \"def apply(self):\\n pass\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__():\",\n \"def __call__(self):\",\n \"def __call__(self):\",\n \"def __call__(self):\\n return self.fn()\",\n \"def create_callback(self, chain):\",\n \"def iterate(self):\",\n \"def handle(self) -> None:\",\n \"def fn():\",\n \"def _hook(self):\",\n \"def processing(self):\\n pass\",\n \"def callback(self, *args):\\n raise NotImplementedError()\",\n \"def post_execute(self):\",\n \"def __call__(self):\\n return self.referee()\",\n \"def run(self): \\r\\n return\",\n \"def on_success(self) -> None:\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def _to_be_wrapped(self) -> None:\",\n \"def process(self):\\n pass\",\n \"def application(self):\",\n \"def __call__(self):\\n return self\",\n \"def func():\",\n \"def post_processor(self):\",\n \"def _apply(self, **kwargs):\\n raise NotImplementedError\",\n \"def result(self):\",\n \"def result(self):\",\n \"def final(self):\\n pass\",\n \"def _gen_closure(fnc,arg):\\n return lambda s: fnc(arg)\",\n \"def run(self):\\n self.func()\",\n \"def g():\",\n \"def __call__(self):\\r\\n raise NotImplementedError('override me')\",\n \"def __call__(self, f):\\n raise NotImplementedError()\",\n \"def _finished(self) -> None:\",\n \"def _execute(self, _):\\r\\n pass\",\n \"def firstFunction(self):\",\n \"def handle(self):\\n raise NotImplementedError\",\n \"def __call__(self):\\n raise NotImplementedError()\",\n \"def __call__(self, **kwargs):\\n raise NotImplementedError\",\n \"def finished(self):\",\n \"def perform_callback(self, *args, **kwargs):\\n pass\",\n \"def _make_halowait(self, f):\\n return\",\n \"def __call__(self) -> dict:\\n\\t\\tpass\",\n \"def fire(self):\",\n \"def on_success(self):\\n pass\",\n \"def postLoopFunctions(self):\\n\\t\\treturn\",\n \"def callback_function(self):\\n raise exceptions.NotImplementedError()\",\n \"def done(self):\",\n \"def done(self):\",\n \"def apply(self, *args, **kwargs):\\n pass\",\n \"def map(self, function):\\n pass\",\n \"def _postprocess(self):\",\n \"def __call__(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def __call__(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def __call__(self, *args, **kwargs):\\n return self.f(*args, **kwargs)\",\n \"def process(self):\\n raise NotImplementedError\",\n \"def task(self):\",\n \"def task(self):\",\n \"def method(self):\",\n \"def __call__(self, *args, **kwargs):\\n return function(args, addtional_info)\",\n \"def on(self) -> None:\",\n \"def __call__(self, x):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72084713","0.67918205","0.66439474","0.6594649","0.6570198","0.65522903","0.65522903","0.6530278","0.6526465","0.6436523","0.64173025","0.64173025","0.64173025","0.64173025","0.64173025","0.6416854","0.64145666","0.6391834","0.63399154","0.63399154","0.6248865","0.6248865","0.6248865","0.6223711","0.62008464","0.619801","0.6136008","0.6136008","0.6123594","0.6123594","0.6123594","0.6123594","0.6123594","0.6068346","0.6068346","0.602332","0.6023241","0.59947693","0.5953706","0.5945593","0.5923057","0.59104323","0.5902748","0.58954835","0.58864075","0.5872738","0.5867365","0.5831927","0.5831927","0.5831927","0.5831927","0.5831927","0.5831927","0.5831927","0.5831927","0.5831927","0.5831927","0.5825201","0.5814619","0.5784156","0.5784011","0.57718563","0.5767911","0.57664645","0.57611704","0.57611704","0.57546175","0.5752887","0.5750024","0.5744132","0.5734194","0.5728422","0.5719348","0.5711887","0.57081103","0.56990886","0.56990874","0.5693771","0.5678358","0.56699544","0.56691617","0.56681406","0.56534123","0.5652945","0.5652824","0.5634826","0.5631798","0.5631798","0.56264186","0.5618797","0.5611037","0.55909985","0.55909985","0.55815846","0.5580513","0.5578329","0.5578329","0.55773365","0.55767906","0.557105","0.5570572"],"string":"[\n \"0.72084713\",\n \"0.67918205\",\n \"0.66439474\",\n \"0.6594649\",\n \"0.6570198\",\n \"0.65522903\",\n \"0.65522903\",\n \"0.6530278\",\n \"0.6526465\",\n \"0.6436523\",\n \"0.64173025\",\n \"0.64173025\",\n \"0.64173025\",\n \"0.64173025\",\n \"0.64173025\",\n \"0.6416854\",\n \"0.64145666\",\n \"0.6391834\",\n \"0.63399154\",\n \"0.63399154\",\n \"0.6248865\",\n \"0.6248865\",\n \"0.6248865\",\n \"0.6223711\",\n \"0.62008464\",\n \"0.619801\",\n \"0.6136008\",\n \"0.6136008\",\n \"0.6123594\",\n \"0.6123594\",\n \"0.6123594\",\n \"0.6123594\",\n \"0.6123594\",\n \"0.6068346\",\n \"0.6068346\",\n \"0.602332\",\n \"0.6023241\",\n \"0.59947693\",\n \"0.5953706\",\n \"0.5945593\",\n \"0.5923057\",\n \"0.59104323\",\n \"0.5902748\",\n \"0.58954835\",\n \"0.58864075\",\n \"0.5872738\",\n \"0.5867365\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5831927\",\n \"0.5825201\",\n \"0.5814619\",\n \"0.5784156\",\n \"0.5784011\",\n \"0.57718563\",\n \"0.5767911\",\n \"0.57664645\",\n \"0.57611704\",\n \"0.57611704\",\n \"0.57546175\",\n \"0.5752887\",\n \"0.5750024\",\n \"0.5744132\",\n \"0.5734194\",\n \"0.5728422\",\n \"0.5719348\",\n \"0.5711887\",\n \"0.57081103\",\n \"0.56990886\",\n \"0.56990874\",\n \"0.5693771\",\n \"0.5678358\",\n \"0.56699544\",\n \"0.56691617\",\n \"0.56681406\",\n \"0.56534123\",\n \"0.5652945\",\n \"0.5652824\",\n \"0.5634826\",\n \"0.5631798\",\n \"0.5631798\",\n \"0.56264186\",\n \"0.5618797\",\n \"0.5611037\",\n \"0.55909985\",\n \"0.55909985\",\n \"0.55815846\",\n \"0.5580513\",\n \"0.5578329\",\n \"0.5578329\",\n \"0.55773365\",\n \"0.55767906\",\n \"0.557105\",\n \"0.5570572\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":233,"numItemsPerPage":100,"numTotalItems":95772,"offset":23300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjcwMzI1OCwianRpIjoiN2Q5MTliNzYtOTRkYy00ZmEyLWFlYmItMzU1YTJlMmMyZmM5Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY3MDY4NTgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.DikCxGG9cr5z-J_mXgwnYh-BHCr_7o2dEVrHk2imNe683IdiMZRSl8v07BmH5vp7ckPoe6Dfq8Ik0cv2pyFOAQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Signature as an XMLRPC 'signature'. | def xmlrpc_signatures(self):
return self.rpc_signatures | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_signature(self):\n sig_contents = \\\n self.payload + \".\" + \\\n b64encode(b\"application/xml\").decode(\"ascii\") + \".\" + \\\n b64encode(b\"base64url\").decode(\"ascii\") + \".\" + \\\n b64encode(b\"RSA-SHA256\").decode(\"ascii\")\n sig_hash... | [
"0.7184918",
"0.69686896",
"0.6912548",
"0.69076985",
"0.68146133",
"0.6725265",
"0.66943675",
"0.66943675",
"0.66943675",
"0.6634204",
"0.6633522",
"0.6561415",
"0.65550405",
"0.6549917",
"0.652938",
"0.64934224",
"0.64879084",
"0.64691335",
"0.64691335",
"0.6420456",
"0.640... | 0.61701065 | 34 |
Get an RPC signature by full name. | def get_method(self, method):
for provider in self.method_handlers:
for candidate in provider.xmlrpc_methods():
#self.env.log.debug(candidate)
p = Method(provider, *candidate)
if p.name == method:
return p
raise MethodNotFo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_signature(self, signature_name=None):\n return None, None",
"def methodSignature(self, name):\r\n methods = self._listMethods()\r\n for method in methods:\r\n if method == name:\r\n rtype = None\r\n ptypes = []\r\n parsed = gettags(... | [
"0.68723637",
"0.6210406",
"0.6134881",
"0.5682582",
"0.5608959",
"0.5547333",
"0.55103743",
"0.5493435",
"0.54649395",
"0.545117",
"0.5436935",
"0.5410457",
"0.5397576",
"0.5373635",
"0.53136307",
"0.530501",
"0.52819455",
"0.52735406",
"0.52712643",
"0.5222953",
"0.51910514... | 0.0 | -1 |
List all methods exposed via RPC. Returns a list of Method objects. | def all_methods(self, req):
for provider in self.method_handlers:
for candidate in provider.xmlrpc_methods():
# Expand all fields of method description
yield Method(provider, *candidate) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_methods(self):\n if not len(self.methods):\n try:\n self.methods = self.server.system.listMethods()\n except xmlrpclib.Fault, fault:\n raise BlogError(fault.faultString)\n\n return self.methods.sort()",
"def list_methods(self, request, co... | [
"0.78063536",
"0.7760441",
"0.75646675",
"0.75589406",
"0.73298264",
"0.73274004",
"0.70894814",
"0.7067124",
"0.6919358",
"0.69090086",
"0.6892955",
"0.6814702",
"0.6716248",
"0.66190255",
"0.6566362",
"0.6554939",
"0.651463",
"0.6479363",
"0.64611197",
"0.645592",
"0.644655... | 0.6903047 | 10 |
Takes an array of RPC calls encoded as structs of the form (in | def multicall(self, req, signatures):
for signature in signatures:
try:
yield self.get_method(signature['methodName'])(req, signature['params'])
except Exception, e:
yield e | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _electrum_rpc(client: StratumClient, requests: List[Tuple[str, ...]]) -> List:\n if len(requests) == 0:\n return []\n\n if len(requests) == 1:\n request = requests[0]\n response = await client.RPC(*request)\n return [response]\n\n response = await client.batch_rpc(req... | [
"0.61889356",
"0.5797257",
"0.57828593",
"0.5730372",
"0.5644468",
"0.55430084",
"0.55263215",
"0.5463228",
"0.5446705",
"0.53693557",
"0.53529286",
"0.53477484",
"0.52750164",
"0.5248507",
"0.52267796",
"0.5225138",
"0.52248627",
"0.52214015",
"0.52191406",
"0.51856226",
"0.... | 0.0 | -1 |
This method returns a list of strings, one for each (nonsystem) method supported by the RPC server. | def listMethods(self, req):
for method in self.all_methods(req):
yield method.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_rpc_method_names(self):\n return [name for name in dir(self) if _is_rpc_call_method(getattr(self, name))]",
"def get_rpc_method_names(self):\n return self._get_rpc_method_names()",
"def method_list(self):\n\t\tmethod_names = list(self.methods.keys())\n\t\tmethod_names.sort()\n\t\tmethod_... | [
"0.74507785",
"0.744676",
"0.71273005",
"0.7035459",
"0.6956781",
"0.6945243",
"0.68644214",
"0.6820046",
"0.67968106",
"0.6720064",
"0.6699861",
"0.665346",
"0.65834975",
"0.65580946",
"0.654632",
"0.64500207",
"0.644959",
"0.641104",
"0.64056057",
"0.6363595",
"0.6349203",
... | 0.62865925 | 22 |
This method takes one parameter, the name of a method implemented by the RPC server. It returns a documentation string describing the use of that method. If no such string is available, an empty string is returned. The documentation string may contain HTML markup. | def methodHelp(self, req, method):
p = self.get_method(method)
return '\n'.join((p.signature, '', p.description)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def methodHelp(self, name):\r\n methods = self._listMethods()\r\n for methodname in methods.keys():\r\n if methodname == name:\r\n return methods[methodname]\r\n raise RPCError(Faults.SIGNATURE_UNSUPPORTED)",
"def method(name, doc):\n import html\n\n params = ... | [
"0.7297669",
"0.694731",
"0.68896276",
"0.6688466",
"0.6388553",
"0.6385201",
"0.63499844",
"0.6292997",
"0.6292498",
"0.62701833",
"0.6107226",
"0.60769576",
"0.60552335",
"0.60015124",
"0.59173465",
"0.58777815",
"0.58560765",
"0.58364666",
"0.5824243",
"0.5823201",
"0.5823... | 0.71314836 | 1 |
This method takes one parameter, the name of a method implemented by the RPC server. It returns an array of possible signatures for this method. A signature is an array of types. The first of these types is the return type of the method, the rest are parameters. | def methodSignature(self, req, method):
p = self.get_method(method)
return [','.join([RPC_TYPES[x] for x in sig]) for sig in p.xmlrpc_signatures()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def methodSignature(self, name):\r\n methods = self._listMethods()\r\n for method in methods:\r\n if method == name:\r\n rtype = None\r\n ptypes = []\r\n parsed = gettags(methods[method])\r\n for thing in parsed:\r\n ... | [
"0.76971966",
"0.6802462",
"0.6156515",
"0.612154",
"0.60075223",
"0.5919079",
"0.5902551",
"0.5769066",
"0.5688802",
"0.55987453",
"0.55483836",
"0.54988164",
"0.5416799",
"0.54150325",
"0.5402403",
"0.5375287",
"0.5298141",
"0.5274757",
"0.5253134",
"0.5250529",
"0.521413",... | 0.6672202 | 2 |
Returns a list with three elements. First element is the epoch (0=Trac 0.10, 1=Trac 0.11 or higher). Second element is the major version number, third is the minor. Changes to the major version indicate API breaking changes, while minor version changes are simple additions, bug fixes, etc. | def getAPIVersion(self, req):
import re
import tracrpc
match = re.match(r'([0-9]+)\.([0-9]+)\.([0-9]+)', tracrpc.__version__)
return map(int, match.groups()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_version_number():\n return [0, 1, 0]",
"def epoch():\n\treturn time.time()",
"def epoch(self):\n return _coordsys.coordsys_epoch(self)",
"def get_server_version():\n url_address = 'https://raw.githubusercontent.com/muhammadfredo/FrMaya/master/FrMaya/version.py'\n url_data = urllib... | [
"0.618254",
"0.60157156",
"0.5808671",
"0.57772446",
"0.57352424",
"0.569133",
"0.56790584",
"0.5625292",
"0.5474962",
"0.5416474",
"0.5317114",
"0.5290706",
"0.52808994",
"0.5271004",
"0.5269445",
"0.52262104",
"0.5208265",
"0.5202156",
"0.51972467",
"0.5195646",
"0.5194441"... | 0.46996364 | 87 |
Read aligment file. Hansard alignment is expected. | def read_alignment(file):
alignments = list()
with open(file, 'r') as f:
for line in f:
line_lst = line.strip().split()
align_lst = list()
for pair in line_lst:
src_idx, tgt_idx = pair.split('-')
align_lst.append((int(src_idx),int(tgt_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_next_alignment(self, stream):",
"def read_alignment(filepath, filetype):\n\n return AlignIO.read(filepath, filetype)",
"def read_extended_alignment(self, path, aformat=\"stockholm\",\n assertion=False):\n handle = open(path, 'r')\n insertions = None\n ... | [
"0.7092832",
"0.67729056",
"0.66494703",
"0.65757024",
"0.6385235",
"0.6234432",
"0.61711687",
"0.5988653",
"0.5938738",
"0.590328",
"0.588054",
"0.58504915",
"0.58363646",
"0.58170205",
"0.5765209",
"0.5737609",
"0.57110476",
"0.5662642",
"0.5653508",
"0.5646126",
"0.5622445... | 0.65420896 | 4 |
Extract all phrases from word alignment. | def extract_phrase(self, src_text, tgt_text, alignment, max_phrase_len=0):
def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):
"""Extract a set of possible phrase given the source, language ranges.
"""
# print("rages", tgt_start, tgt_end, src_star... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_phrases(data,model):\n phrases = []\n alignment = model.alignment_idx\n for i in range(len(data)):\n sent_phrases = phrase_extraction(data[i][\"fr\"],data[i][\"en\"],alignment[i])\n phrases.append(sent_phrases)\n return phrases",
"def lemmatized_phrases(self):\n phras... | [
"0.7157194",
"0.6438471",
"0.61811405",
"0.6119933",
"0.6069589",
"0.60057",
"0.59385145",
"0.58645695",
"0.5848218",
"0.58418983",
"0.58405614",
"0.58251745",
"0.57417756",
"0.57353705",
"0.57185733",
"0.57103014",
"0.5676527",
"0.56694734",
"0.56662035",
"0.5655986",
"0.563... | 0.6709278 | 1 |
Extract a set of possible phrase given the source, language ranges. | def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):
# print("rages", tgt_start, tgt_end, src_start, src_end)
if tgt_end < 0:
return
# If `src_align_idx` out of the `src_start` and `src_target`.
for src_align_idx, tgt_align_idx ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_phrase(self, src_text, tgt_text, alignment, max_phrase_len=0):\n def extract_from_range(tgt_start, tgt_end, src_start, src_end, max_phrase_len):\n \"\"\"Extract a set of possible phrase given the source, language ranges.\n\n \"\"\"\n # print(\"rages\", tgt_start,... | [
"0.6873448",
"0.5602197",
"0.5513425",
"0.55112517",
"0.5479709",
"0.54267764",
"0.5333438",
"0.52627516",
"0.5251202",
"0.5215412",
"0.52010435",
"0.5196199",
"0.5195391",
"0.51823145",
"0.5178213",
"0.51594794",
"0.51498526",
"0.5126929",
"0.50857365",
"0.50619686",
"0.5037... | 0.70351136 | 0 |
Extract phrase from list of the parallel sentences. | def extract_phrase_from_parallel_sentences(self, src_lst,
tgt_lst,
word_alignment,
max_phrase_len=0,
save_phrase_table=None):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_phrases(data,model):\n phrases = []\n alignment = model.alignment_idx\n for i in range(len(data)):\n sent_phrases = phrase_extraction(data[i][\"fr\"],data[i][\"en\"],alignment[i])\n phrases.append(sent_phrases)\n return phrases",
"def sentence_parse(list_of_posts): \n fo... | [
"0.6296526",
"0.6136638",
"0.5852756",
"0.5819079",
"0.57264394",
"0.5696509",
"0.5664151",
"0.559129",
"0.55865973",
"0.55777866",
"0.5577783",
"0.5568261",
"0.553962",
"0.54893243",
"0.5487933",
"0.54764163",
"0.5456427",
"0.5454422",
"0.543709",
"0.5425575",
"0.5423253",
... | 0.6505854 | 0 |
Compute log probability of sorucetarget phrase pairs. Note that we compute log p(f|e) due to the noise channel assumption. | def compute_log_probs(self, phrases, save_to_file=None):
# Co-ocurrence for source and target phrase
tgt_src_cnt = defaultdict(lambda: defaultdict(int))
# ocurrence for target (English)
tgt_cnt = defaultdict(int)
# Compute frequency and co-occurence
for phrase_p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sentence_logprob(self, sentence):\n line = get_ngrams(sentence,3)\n log_por = 0.0\n for item in line:\n raw_por = self.smoothed_trigram_probability(item)\n log_por = log_por+math.log2(raw_por)\n\n return float(log_por)",
"def sentence_logprob(self, sentence):... | [
"0.74536216",
"0.72376466",
"0.6940813",
"0.69313174",
"0.6906261",
"0.6710182",
"0.6671943",
"0.66348374",
"0.66269255",
"0.66226804",
"0.658965",
"0.6519465",
"0.6512543",
"0.6429427",
"0.6417837",
"0.6415285",
"0.63980013",
"0.63869506",
"0.6386877",
"0.63799185",
"0.63781... | 0.7457257 | 0 |
Flatten nested list into a list of sorucetarget phrase pairs. | def flatten_phrase_collect(phrase_collect):
flatten_phrse_collect = list()
for phrase_lst in phrase_collect:
pass
return flatten_phrse_collect | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten(nested_list):\r\n return list(chain.from_iterable(nested_list))",
"def _flatten(phrases):\n return [' '.join(phrase) for phrase in phrases]",
"def flatten(nested_list):\n for elt in nested_list:\n if isinstance(elt, collections.Iterable) and not isinstance(elt, six.string_types)... | [
"0.68353754",
"0.6703909",
"0.6512857",
"0.65088475",
"0.64734936",
"0.640399",
"0.618579",
"0.6086874",
"0.6073905",
"0.60664827",
"0.60623664",
"0.604358",
"0.60098505",
"0.5991506",
"0.5989105",
"0.5989105",
"0.5974142",
"0.5966722",
"0.5949544",
"0.5914635",
"0.59093",
... | 0.69660723 | 0 |
Summary Split data into nq blocks. | def split_data(data, nq, flag=1):
if flag == 1:
quantiles = np.linspace(data.min(), data.max(), nq + 1)
elif flag == 2:
segs = np.linspace(0, 100, nq + 1)
quantiles = np.percentile(data, segs)
quantiles[0] = quantiles[0] - 1e-15
quantiles[-1] = quantiles[-1] + 1e-15
grp_names... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_chunk_size_priority_over_n_splits(self):\n with self.subTest(input='list', chunk_size=1, n_splits=6):\n self.assertEqual(get_n_chunks(self.test_data, iterable_len=None, chunk_size=1, n_splits=6, n_jobs=None), 13)\n with self.subTest(input='numpy', chunk_size=1, n_splits=6):\n ... | [
"0.57900053",
"0.5749784",
"0.55733985",
"0.55712456",
"0.55246603",
"0.55168134",
"0.5494334",
"0.5402945",
"0.5363317",
"0.5348577",
"0.532229",
"0.52557427",
"0.5247931",
"0.5193257",
"0.5171128",
"0.51542133",
"0.5153879",
"0.51524353",
"0.5149456",
"0.51452446",
"0.51341... | 0.5802561 | 0 |
Summary Calculate information coefficient | def calc_ic(data):
return scs.spearmanr(data[:, 0], data[:, 1]).correlation | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coefficient(self) -> float:\n ...",
"def get_perfect_information(self):\n raise NotImplementedError",
"def calculate(self):",
"def summary(self):\n raise NotImplementedError",
"def compute_statistics(self):",
"def estimateInfo(Analysis, ImageData, diffract, print_opt=False): ... | [
"0.67050064",
"0.6497096",
"0.64120954",
"0.62755823",
"0.6260611",
"0.6255357",
"0.6219407",
"0.6132243",
"0.6056515",
"0.6051543",
"0.6032649",
"0.602763",
"0.6024639",
"0.6019665",
"0.5987596",
"0.5975503",
"0.59576994",
"0.59452105",
"0.59376025",
"0.59330785",
"0.5923176... | 0.0 | -1 |
Summary Calculate mean square error | def calc_mse(data, ax=0):
return ((data[:, 0] - data[:, 1]) ** 2).mean(axis=ax) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MeanSqError(self):\r\n\t\treturn self.mse",
"def mean_squared_error(self):\n print('Mean squared error regression loss: ' + str(mean_squared_error(self.model.dataset.get_y_test(),\n self.model.get_predicted())))",
"def get_... | [
"0.7567138",
"0.7354275",
"0.726577",
"0.71755135",
"0.70000595",
"0.69570065",
"0.69317585",
"0.6890092",
"0.6858004",
"0.6785041",
"0.677055",
"0.67539006",
"0.6746916",
"0.6746916",
"0.6723674",
"0.67175984",
"0.66966164",
"0.66890544",
"0.6660599",
"0.66503626",
"0.664182... | 0.0 | -1 |
online maxminscale normalization using key basic statistics. | def update_maxminscale(stats_on_target, lastest_minmax):
target_xss, target_xs, target_xct = stats_on_target
xmn, xmx = lastest_minmax
zss = (target_xss - 2 * xmn * target_xs + target_xct * xmn**2) / (xmx - xmn)**2
zs = (target_xs - target_xct * xmn) / (xmx - xmn)
zct = target_xct
return zss, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _normalize(self, dataset):\n if self.max is None: # if we are normalizing the training set\n self.max, self.min = dataset.max(), dataset.min() # find max, min value for each columns\n for row in dataset.index: # for each row in dataset\n for c... | [
"0.63708794",
"0.62702864",
"0.61845",
"0.61675406",
"0.6165542",
"0.61498797",
"0.61322546",
"0.6095306",
"0.60869277",
"0.6003787",
"0.6002606",
"0.60010904",
"0.5944249",
"0.59147775",
"0.5865857",
"0.58601046",
"0.58502215",
"0.5845374",
"0.58325875",
"0.5817523",
"0.5789... | 0.6510492 | 0 |
online zscore normalization using key basic statistics. | def update_zscore(stats_on_target, lastest_mustd):
target_xss, target_xs, target_xct = stats_on_target
xmu, xstd = lastest_mustd
zss = (target_xss - 2 * target_xs * xmu + target_xct * xmu ** 2) / xstd ** 2
zs = (target_xs - target_xct * xmu) / xstd
zct = target_xct
return zss, zs, zct | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zscore(vals):",
"def z_score_std(train, test):\n scalers = {}\n for i, sample in enumerate(train):\n scalers[i] = StandardScaler()\n train[i] = scalers[i].fit_transform(sample)\n\n for i, sample in enumerate(test):\n test[i] = scalers[i].transform(sample)\n\n return train, te... | [
"0.66475713",
"0.6414201",
"0.6319118",
"0.6291525",
"0.61970514",
"0.618369",
"0.61619216",
"0.60951513",
"0.6063714",
"0.6052275",
"0.59794205",
"0.59628385",
"0.5939316",
"0.59123677",
"0.5901266",
"0.5896098",
"0.5873319",
"0.58584255",
"0.58458626",
"0.58458626",
"0.5845... | 0.6038549 | 10 |
Creates a FlowNone, takes the command to which the Node is linked to. | def __init__(self, command: str = None, hints: bool = True):
self.command = command
self.children = [] # (predicate, node)
self.hints = hints | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_new_flow(flow_root, requestor: Identifier, initial_command) \\\n -> Tuple[Optional[Flow], Optional[FlowNode]]:\n empty_context = {}\n flow = Flow(flow_root, requestor, empty_context)\n for possible_next_step in flow.next_steps():\n if possible_next_step.comman... | [
"0.62710094",
"0.5478883",
"0.5431005",
"0.5244744",
"0.5209037",
"0.52035606",
"0.5196872",
"0.50918037",
"0.50783676",
"0.5072429",
"0.49557534",
"0.4943564",
"0.48528713",
"0.48491302",
"0.48466516",
"0.48291168",
"0.47763118",
"0.47480133",
"0.47466248",
"0.4736746",
"0.4... | 0.49670023 | 10 |
Construct the flow graph by connecting this node to another node or a command. The predicate is a function that tells the flow executor if the flow can enter the step without the user intervention (automatically). | def connect(self, node_or_command: Union['FlowNode', str], predicate: Predicate = lambda _: False,
hints: bool = True):
node_to_connect_to = node_or_command if isinstance(node_or_command, FlowNode) else FlowNode(node_or_command,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_new_flow(flow_root, requestor: Identifier, initial_command) \\\n -> Tuple[Optional[Flow], Optional[FlowNode]]:\n empty_context = {}\n flow = Flow(flow_root, requestor, empty_context)\n for possible_next_step in flow.next_steps():\n if possible_next_step.comman... | [
"0.6413768",
"0.5331428",
"0.52776724",
"0.5124311",
"0.51223505",
"0.5108684",
"0.50600624",
"0.5043233",
"0.5042275",
"0.4964955",
"0.49122655",
"0.48988894",
"0.48981482",
"0.48565575",
"0.484811",
"0.4824072",
"0.48154116",
"0.4813976",
"0.4800156",
"0.4783596",
"0.478087... | 0.65801656 | 0 |
gets the predicate function for the specified child node. | def predicate_for_node(self, node: 'FlowNode'):
for predicate, possible_node in self.children:
if node == possible_node:
return predicate
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_predicate(self):\n return self._predicate",
"def predicate(f):\n wrapper = Predicate(f)\n update_wrapper(wrapper, f)\n return wrapper",
"def predicate (self) :\n\n return self.__predicate__",
"def to_predicate(self, node, f='predicate', map=None):\n\n if 'AK{}' == node.n... | [
"0.60676956",
"0.59117705",
"0.5859783",
"0.5716894",
"0.5592004",
"0.54098916",
"0.5391563",
"0.5362847",
"0.52606004",
"0.52374494",
"0.51913834",
"0.50643146",
"0.5036615",
"0.49944842",
"0.4963765",
"0.49336788",
"0.4933024",
"0.49324915",
"0.49315336",
"0.49314764",
"0.4... | 0.69061804 | 0 |
Get the next steps that can be automatically executed according to the set predicates. | def next_autosteps(self) -> List[FlowNode]:
return [node for predicate, node in self._current_step.children if predicate(self.ctx)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSteps():",
"def get_next_steps(self, steps):\n step_list = []\n\n steps_remaining = set(steps.keys())\n counter = 0\n max_counter = 10000\n next_steps = set()\n\n for step in steps_remaining:\n dependencies = steps[step]\n if len(dependencies... | [
"0.68260413",
"0.61826456",
"0.59532344",
"0.59049976",
"0.57587636",
"0.56449825",
"0.5614194",
"0.5475476",
"0.54743147",
"0.54043585",
"0.53964126",
"0.53883094",
"0.5375762",
"0.5372784",
"0.536757",
"0.53402436",
"0.5317131",
"0.5306998",
"0.53006005",
"0.5283597",
"0.52... | 0.4923968 | 72 |
Get all the possible next steps after this one (predicates statisfied or not). | def next_steps(self) -> List[FlowNode]:
return [node for predicate, node in self._current_step.children] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSteps():",
"def get_next_steps(self, steps):\n step_list = []\n\n steps_remaining = set(steps.keys())\n counter = 0\n max_counter = 10000\n next_steps = set()\n\n for step in steps_remaining:\n dependencies = steps[step]\n if len(dependencies... | [
"0.6234041",
"0.58860874",
"0.58491534",
"0.5800428",
"0.5592601",
"0.5583821",
"0.5574898",
"0.5521146",
"0.5507032",
"0.5441927",
"0.5365685",
"0.5339986",
"0.5337542",
"0.5333407",
"0.5318446",
"0.53063506",
"0.5300591",
"0.5297238",
"0.5295074",
"0.5279935",
"0.5268858",
... | 0.6419919 | 0 |
Move on along the flow. | def advance(self, next_step: FlowNode, enforce_predicate=True):
if enforce_predicate:
predicate = self._current_step.predicate_for_node(next_step)
if predicate is None:
raise ValueError(f'There is no such children: {next_step}.')
if not predicate(self.ctx):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self):\n self.position += 1",
"def step_forward(self):",
"def advance(self) -> None:\n pass",
"def advance(self):\n self._state = self._next_state",
"def step(self, move):",
"def forward( self ):\n self._has_change = True\n print( \"Forward\" )",
"def move... | [
"0.74384344",
"0.7432177",
"0.7052693",
"0.7011329",
"0.68793774",
"0.68633926",
"0.6843568",
"0.67537284",
"0.6722338",
"0.6645579",
"0.6625062",
"0.6621287",
"0.6621287",
"0.65949506",
"0.6572828",
"0.6572828",
"0.6572828",
"0.6570652",
"0.6545895",
"0.6537094",
"0.65001476... | 0.0 | -1 |
Helper property to get the name of the flow. | def name(self) -> str:
return self._root.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flow_name(self):\n # This never changes (so no read locking needed).\n return self._flowdetail.name",
"def flow_log_name(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"flow_log_name\")",
"def step_name(self):\n return self._step_name",
"def flow_id(self) -> ... | [
"0.89674693",
"0.79398876",
"0.69550246",
"0.6820289",
"0.68090695",
"0.68007225",
"0.6760528",
"0.6747862",
"0.67404884",
"0.67219657",
"0.6628888",
"0.6625101",
"0.6624028",
"0.6591873",
"0.6541664",
"0.653939",
"0.653911",
"0.653911",
"0.653911",
"0.6525508",
"0.6520471",
... | 0.0 | -1 |
The current step this Flow is waiting on. | def current_step(self) -> FlowNode:
return self._current_step | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def step(self):\n return self._step",
"def step(self):\n return self._step",
"def step(self):\n return self._step",
"def step(self):\n return self._step",
"def get_step(self):\n return self.step",
"def get_step(self):\n return self.step",
"def step(self):\n ... | [
"0.80897826",
"0.80897826",
"0.80897826",
"0.80897826",
"0.80040395",
"0.80040395",
"0.79046434",
"0.78787154",
"0.78659546",
"0.76517856",
"0.7590155",
"0.7244321",
"0.71743906",
"0.7152078",
"0.70949507",
"0.7006412",
"0.6945117",
"0.69421864",
"0.6877987",
"0.67704535",
"0... | 0.7882782 | 7 |
The original flowroot of this flow. | def root(self) -> FlowRoot:
return self._root | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def root_orig(self):\n if hasattr(self, \"orig\"):\n return self.orig.root_orig\n return self",
"def original(self):\n return self._original",
"def original(self):\n return self._original",
"def getOriginal(self,):\n\t\treturn self.original;",
"def root(self):\n\t\tre... | [
"0.73445743",
"0.6893548",
"0.6893548",
"0.6484647",
"0.63805735",
"0.63805735",
"0.6353325",
"0.6331243",
"0.6286299",
"0.62303126",
"0.62067777",
"0.62067777",
"0.62067777",
"0.6187001",
"0.6182318",
"0.6174468",
"0.6174468",
"0.6173917",
"0.6116025",
"0.60984105",
"0.60967... | 0.6993407 | 1 |
Get the name of this flow as described in its .plug file. | def name(self) -> str:
return self._name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getName(self):\n return self.stepDictionary[self.getLocation()]",
"def get_name(self):\n\t\treturn self.source.get_name()",
"def display_name(self):\n try:\n return self.plug_dict['PlugName'].value\n except KeyError:\n return self.name",
"def plugin_name(self):\... | [
"0.72229207",
"0.7183337",
"0.71583205",
"0.7149492",
"0.7129265",
"0.7129265",
"0.7129265",
"0.7129265",
"0.7129265",
"0.7129265",
"0.6979302",
"0.6975787",
"0.69578403",
"0.6936074",
"0.6934209",
"0.6915648",
"0.6910357",
"0.6910357",
"0.69089496",
"0.69063693",
"0.6899902"... | 0.0 | -1 |
Override if you want to do something at initialization phase (don't forget to super(Gnagna, self).activate()) | def activate(self) -> None:
self._bot.inject_flows_from(self)
self.is_activated = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def activate(self):\n pass",
"def activate(self):\n raise NotImplementedError(\"Shouldn't be called\")",
"def _activate(self):\n raise NotImplementedError('Subclasses must implement _activate()')",
"def activate(self):\n super(Pixiv_bot, self).activate()",
"def activate(self):\n... | [
"0.7181187",
"0.7162541",
"0.7085794",
"0.6996718",
"0.69452006",
"0.6700154",
"0.6605756",
"0.6589444",
"0.6585501",
"0.64778143",
"0.64478004",
"0.64478004",
"0.64430845",
"0.6431264",
"0.64214706",
"0.64119846",
"0.636943",
"0.63071525",
"0.6291065",
"0.6280463",
"0.628046... | 0.0 | -1 |
Override if you want to do something at tear down phase (don't forget to super(Gnagna, self).deactivate()) | def deactivate(self) -> None:
self._bot.remove_flows_from(self)
self.is_activated = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_deactivate(self) -> None:",
"def deactivate(self):\n pass",
"def deactivate(self):\n pass",
"def on_deactivate(self):",
"def deactivate(self):\n pass",
"def deactivate(self):\n super(Pixiv_bot, self).deactivate()",
"def deactivate(self):\n raise NotImplementedError... | [
"0.7673987",
"0.7613473",
"0.7613473",
"0.756088",
"0.7486912",
"0.7407235",
"0.72243154",
"0.7201043",
"0.70954955",
"0.7069063",
"0.69780624",
"0.69780624",
"0.69346464",
"0.69018716",
"0.69018716",
"0.68386066",
"0.68386066",
"0.67960036",
"0.6686626",
"0.6686626",
"0.6641... | 0.0 | -1 |
Helper to get a specific command. | def get_command(self, command_name: str):
self._bot.all_commands.get(command_name, None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cmd(self, command):\n return self.commands[command][\"cmd\"]",
"def get_command(self, ctx, cmd_name):\n path = \"%s.%s\" % (__name__, cmd_name)\n path = path.replace(\"-\", \"_\")\n try:\n module = importlib.import_module(path)\n return getattr(module, 'c... | [
"0.85638624",
"0.8320065",
"0.8262092",
"0.81505215",
"0.81448346",
"0.8041625",
"0.8030123",
"0.79733753",
"0.79297495",
"0.7919713",
"0.7854785",
"0.784091",
"0.77338827",
"0.76426506",
"0.76235944",
"0.7594374",
"0.7556176",
"0.753687",
"0.7505808",
"0.74881387",
"0.742349... | 0.78783715 | 10 |
Register a flow with this executor. | def add_flow(self, flow: FlowRoot):
with self._lock:
self.flow_roots[flow.name] = flow | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_flow(self, state, flow_id):\n self._flows[state] = flow_id\n _LOGGER.debug(\"Register state %s for flow_id %s\", state, flow_id)",
"def flow(self, flow):\n\n self._flow = flow",
"def add_flow_controller(cls, name, controller):\n cls.registered_controllers[name] = contro... | [
"0.69882387",
"0.67626894",
"0.6249088",
"0.61617434",
"0.6143314",
"0.5989838",
"0.58785754",
"0.5878573",
"0.58688176",
"0.5865792",
"0.5640574",
"0.56151783",
"0.5605409",
"0.56050324",
"0.553389",
"0.5516025",
"0.5483355",
"0.5407733",
"0.53915477",
"0.53600454",
"0.53564... | 0.6806603 | 1 |
Trigger workflows that may have command cmd as a auto_trigger or an in flight flow waiting for command. This assume cmd has been correctly executed. | def trigger(self, cmd: str, requestor: Identifier, extra_context=None) -> Optional[Flow]:
flow, next_step = self.check_inflight_flow_triggered(cmd, requestor)
if not flow:
flow, next_step = self._check_if_new_flow_is_triggered(cmd, requestor)
if not flow:
return None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_if_new_flow_is_triggered(self, cmd: str, user: Identifier) -> Tuple[Optional[Flow], Optional[FlowNode]]:\n log.debug(\"Test if the command %s is an auto-trigger for any flow ...\", cmd)\n with self._lock:\n for name, flow_root in self.flow_roots.items():\n if cmd ... | [
"0.715326",
"0.6214702",
"0.5785957",
"0.5547166",
"0.54532874",
"0.545297",
"0.5442159",
"0.5426565",
"0.54126877",
"0.54040956",
"0.5393063",
"0.5381227",
"0.53534704",
"0.5316226",
"0.5302364",
"0.5268394",
"0.5265039",
"0.5208793",
"0.5185608",
"0.51715356",
"0.5159973",
... | 0.6354978 | 1 |
Check if user is already running a flow. | def check_inflight_already_running(self, user: Identifier) -> bool:
with self._lock:
for flow in self.in_flight:
if flow.requestor == user:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IsRunning(self):\n current_urn = self.Get(self.Schema.CURRENT_FLOW_URN)\n if current_urn:\n current_flow = aff4.FACTORY.Open(urn=current_urn,\n token=self.token, mode=\"r\")\n runner = current_flow.GetRunner()\n return runner.context.state == rdfvalue.... | [
"0.69948125",
"0.6222682",
"0.61390924",
"0.60672396",
"0.6056235",
"0.5998055",
"0.59039176",
"0.5898025",
"0.58831185",
"0.5882401",
"0.58729315",
"0.58365375",
"0.58026636",
"0.5799237",
"0.5794511",
"0.57941985",
"0.57290274",
"0.57271695",
"0.5711765",
"0.57040274",
"0.5... | 0.7122003 | 0 |
Check if a command from a specific user was expected in one of the running flow. | def check_inflight_flow_triggered(self, cmd: str, user: Identifier) -> Tuple[Optional[Flow], Optional[FlowNode]]:
log.debug("Test if the command %s is a trigger for an inflight flow ...", cmd)
# TODO: What if 2 flows wait for the same command ?
with self._lock:
for flow in self.in_fl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isOp(self, user, channel=None):\n if channel is not None:\n return user in self.opsets[channel]\n\n for ch in self.opsets:\n if user in self.opsets[ch]:\n return True\n return False",
"def first_is_valid(command_from_user):\n arguement_entered_user... | [
"0.67603654",
"0.65981525",
"0.6361209",
"0.62355417",
"0.61246306",
"0.61216444",
"0.61108893",
"0.6083007",
"0.6078662",
"0.6053866",
"0.6019086",
"0.5988494",
"0.5978432",
"0.59757924",
"0.5973844",
"0.5965293",
"0.5941293",
"0.59410834",
"0.5940875",
"0.59181905",
"0.5878... | 0.6565895 | 2 |
Trigger workflows that may have command cmd as a auto_trigger.. This assume cmd has been correctly executed. | def _check_if_new_flow_is_triggered(self, cmd: str, user: Identifier) -> Tuple[Optional[Flow], Optional[FlowNode]]:
log.debug("Test if the command %s is an auto-trigger for any flow ...", cmd)
with self._lock:
for name, flow_root in self.flow_roots.items():
if cmd in flow_roo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trigger(self, cmd: str, requestor: Identifier, extra_context=None) -> Optional[Flow]:\n flow, next_step = self.check_inflight_flow_triggered(cmd, requestor)\n if not flow:\n flow, next_step = self._check_if_new_flow_is_triggered(cmd, requestor)\n if not flow:\n return... | [
"0.5883584",
"0.58415097",
"0.5791433",
"0.5771063",
"0.5762324",
"0.576105",
"0.5728582",
"0.567646",
"0.5645227",
"0.5643713",
"0.556337",
"0.5523932",
"0.54966164",
"0.5453627",
"0.54442376",
"0.54439944",
"0.5407391",
"0.5404491",
"0.53985775",
"0.53704196",
"0.53561866",... | 0.7032899 | 0 |
Helper method to create a new FLow. | def _create_new_flow(flow_root, requestor: Identifier, initial_command) \
-> Tuple[Optional[Flow], Optional[FlowNode]]:
empty_context = {}
flow = Flow(flow_root, requestor, empty_context)
for possible_next_step in flow.next_steps():
if possible_next_step.command == initia... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeLow(self, force = False):\n\t\tlow = self.reSize( 25, self.name + '_LOW', force )\n\t\treturn low",
"def low(self, low: float):\n if low is None:\n raise ValueError(\"Invalid value for `low`, must not be `None`\") # noqa: E501\n\n self._low = low",
"def toLow(self):\n\t\tif se... | [
"0.63650936",
"0.6023866",
"0.5982069",
"0.5945411",
"0.5836941",
"0.57704055",
"0.5701755",
"0.5534835",
"0.55330515",
"0.54922855",
"0.54561484",
"0.5453786",
"0.54480827",
"0.54108757",
"0.53992003",
"0.5381154",
"0.5377614",
"0.5369102",
"0.53397924",
"0.5339053",
"0.5302... | 0.0 | -1 |
Starts the execution of a Flow. | def start_flow(self, name: str, requestor: Identifier, initial_context: Mapping[str, Any]) -> Flow:
if name not in self.flow_roots:
raise ValueError(f'Flow {name} doesn\'t exist')
if self.check_inflight_already_running(requestor):
raise ValueError(f'User {str(requestor)} is alrea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tcp_start(self, flow: mitmproxy.tcp.TCPFlow):",
"def start_workflow(self, **params):\n raise NotImplementedError",
"def start_execution(self):\n self.send_message(\"control.start\",None)",
"def start(self):\n\t\tself.stream.start_stream()",
"def StartFlow(flow_cls, client_id=None, flow_ar... | [
"0.683366",
"0.67719877",
"0.6592364",
"0.6338926",
"0.6324526",
"0.63013583",
"0.6232596",
"0.62237495",
"0.61859214",
"0.61552155",
"0.6142482",
"0.6103612",
"0.6054195",
"0.6044066",
"0.6017107",
"0.60106254",
"0.6002352",
"0.5996425",
"0.5991264",
"0.59862465",
"0.5986246... | 0.63255805 | 4 |
Stops a specific flow. It is a no op if the flow doesn't exist. Returns the stopped flow if found. | def stop_flow(self, name: str, requestor: Identifier) -> Optional[Flow]:
with self._lock:
for flow in self.in_flight:
if flow.name == name and flow.check_identifier(requestor):
log.debug(f'Removing flow {str(flow)}.')
self.in_flight.remove(flow... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop(self, **kwargs):\n return self.client.api.stop(self.id, **kwargs)",
"def del_flow(self, flow_name):\n\n try:\n of_response = requests.delete(self.url + \"restconf/config/opendaylight-inventory:nodes/node/\" + self.id +\n \"/table/0/flow/\... | [
"0.5746109",
"0.5730475",
"0.56689626",
"0.5514384",
"0.5421373",
"0.5382266",
"0.5365279",
"0.5311939",
"0.53013855",
"0.5270593",
"0.5240544",
"0.5230865",
"0.5225166",
"0.52059144",
"0.5201256",
"0.5201256",
"0.51601064",
"0.51247495",
"0.5124382",
"0.511578",
"0.5107241",... | 0.72481436 | 0 |
This is where the flow execution happens from one of the thread of the pool. | def execute(self, flow: Flow):
while True:
autosteps = flow.next_autosteps()
steps = flow.next_steps()
if not steps:
log.debug("Flow ended correctly.Nothing left to do.")
with self._lock:
self.in_flight.remove(flow)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_thread(self):",
"def executor(self):",
"def process(self):\n pass",
"def do_work(self):",
"def proceed(self):\n pass",
"def task1(self):\n \n pass",
"def task(self):",
"def task(self):",
"def run(self): \r\n return",
"def step(self):\n ... | [
"0.7125269",
"0.7070647",
"0.64292413",
"0.63673204",
"0.6264586",
"0.62056714",
"0.61923915",
"0.61923915",
"0.61343116",
"0.6133616",
"0.61296713",
"0.60785925",
"0.6075723",
"0.6042503",
"0.5994667",
"0.5994667",
"0.5994667",
"0.5984182",
"0.5971679",
"0.5971174",
"0.59519... | 0.0 | -1 |
Transforms all symbols into words for the symbols. | def execute_layer(self, input_string):
in_progress_string = input_string
for symbol in MathSymbolsTransformLayer.SYMBOLS:
in_progress_string = re.sub('\\s*\\' + symbol + '\\s*', " " + MathSymbolsTransformLayer.SYMBOLS[symbol] + " ", in_progress_string)
return in_progress_string | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_words(self):\n\n for char, child in self.children.items():\n if child.is_word:\n yield f\"{char}\"\n else:\n for each in child.all_words():\n yield char + each",
"def __macronize(self):\n self.macronizations = [Scansion(... | [
"0.60693365",
"0.6052344",
"0.6034144",
"0.602034",
"0.59230673",
"0.5909303",
"0.5891831",
"0.58848506",
"0.58590794",
"0.5840725",
"0.58196265",
"0.5796355",
"0.576007",
"0.5752221",
"0.575202",
"0.57369643",
"0.57285815",
"0.57197636",
"0.5717165",
"0.57067674",
"0.5704195... | 0.0 | -1 |
Dump GeoJSONlike `dict` to WKB and write it to the `dest_file`. | def dump(obj, dest_file):
dest_file.write(dumps(obj)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_geojson(vec:gpd.GeoDataFrame, dest):\n\t\tdest = str(dest)\n\n\t\t# WGS 84\n\t\t#vec = vec.to_crs({'init': 'epsg:4326'})\n\n\t\tif os.path.isfile(dest):\n\t\t\tos.remove(dest)\n\t\t\t\n\t\tvec.to_file(dest, driver='GeoJSON', encoding='utf-8')",
"def write_completed_dictionary_to_file(the_dict):\n\ttry:... | [
"0.609739",
"0.5945163",
"0.58861214",
"0.5834858",
"0.5822751",
"0.57976556",
"0.5769467",
"0.5753955",
"0.5746957",
"0.57391405",
"0.57300645",
"0.5695011",
"0.567155",
"0.5647927",
"0.56312424",
"0.5610588",
"0.5568535",
"0.556709",
"0.55411667",
"0.55359286",
"0.55297506"... | 0.5775647 | 6 |
Load a GeoJSON `dict` object from a ``source_file`` containing WKB (as a byte string). | def load(source_file):
return loads(source_file.read()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_from_geojson(self, filename_or_url):",
"def load_file(file_path):\n with gzip.open(file_path, \"rb\") as fp:\n return json.loads(fp.read().decode('utf-8'))",
"def load_data(fname):\n # load the json in gzip format\n with gzip.open(fname, 'r') as fin:\n data = json.loads(fin.read... | [
"0.64010257",
"0.61291313",
"0.5681875",
"0.5647965",
"0.5605012",
"0.5605012",
"0.55837893",
"0.54541105",
"0.5407322",
"0.5381939",
"0.5341912",
"0.5317645",
"0.5309902",
"0.52989256",
"0.52811605",
"0.52782965",
"0.5248164",
"0.52470803",
"0.5245445",
"0.52391714",
"0.5237... | 0.5846785 | 2 |
Dump a GeoJSONlike `dict` to a WKB string. | def dumps(obj, big_endian=True):
geom_type = obj['type']
exporter = __dumps_registry.get(geom_type)
if exporter is None:
__unsupported_geom_type(geom_type)
return exporter(obj, big_endian) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_2_string(d):\n buff = io.StringIO()\n print_dictionary(d, output=buff)\n return buff.getvalue()",
"def render_dict(dict):\n\t\treturn str.encode(str(dict))",
"def json_dump_dict(dictionary):\n\n print(json.dumps(dictionary, indent=4, ensure_ascii=False).encode(\"utf8\").decode())\n\n re... | [
"0.6415069",
"0.59991217",
"0.5889633",
"0.5886834",
"0.58037204",
"0.57551813",
"0.5732175",
"0.5725547",
"0.5687833",
"0.5661887",
"0.56604487",
"0.5609592",
"0.556257",
"0.55397433",
"0.55241346",
"0.5521883",
"0.5501805",
"0.54972357",
"0.54923",
"0.54878175",
"0.5445764"... | 0.5338177 | 34 |
Construct a GeoJson `dict` from WKB (`string`). | def loads(string):
endianness = string[0:1]
if endianness == BIG_ENDIAN:
big_endian = True
elif endianness == LITTLE_ENDIAN:
big_endian = False
else:
raise ValueError("Invalid endian byte: '0x%s'. Expected 0x00 or 0x01"
% binascii.hexlify(endianness.encod... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wkt_to_geojson(wkt_data: str) -> dict:\n parsed_wkt = wkt.loads(wkt_data)\n\n geo = geometry.mapping(parsed_wkt)\n\n if geo[\"type\"] == \"GeometryCollection\":\n feature_collection = []\n for g in geo[\"geometries\"]:\n feature = geojson.Feature(geometry=g)\n featu... | [
"0.6401019",
"0.6142894",
"0.6066461",
"0.5939215",
"0.589859",
"0.5864854",
"0.58608633",
"0.58470094",
"0.58136404",
"0.5768865",
"0.57323337",
"0.5708001",
"0.5695813",
"0.56537974",
"0.55651915",
"0.55516964",
"0.5541796",
"0.55147684",
"0.55017436",
"0.54472226",
"0.5386... | 0.52620196 | 32 |
Dump a GeoJSONlike `dict` to a WKB string. | def __dump_point(obj, big_endian):
wkb_string = b''
if big_endian:
wkb_string += BIG_ENDIAN
else:
wkb_string += LITTLE_ENDIAN
coords = obj['coordinates']
num_dims = len(coords)
if num_dims == 2:
type_byte_str = __WKB['2D']['Point']
elif num_dims == 3:
type_b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_2_string(d):\n buff = io.StringIO()\n print_dictionary(d, output=buff)\n return buff.getvalue()",
"def render_dict(dict):\n\t\treturn str.encode(str(dict))",
"def json_dump_dict(dictionary):\n\n print(json.dumps(dictionary, indent=4, ensure_ascii=False).encode(\"utf8\").decode())\n\n re... | [
"0.6415069",
"0.59991217",
"0.5889633",
"0.5886834",
"0.58037204",
"0.57551813",
"0.5732175",
"0.5725547",
"0.5687833",
"0.5661887",
"0.5609592",
"0.556257",
"0.55397433",
"0.55241346",
"0.5521883",
"0.5501805",
"0.54972357",
"0.54923",
"0.54878175",
"0.5445764",
"0.5443978",... | 0.56604487 | 10 |
Dump a GeoJSONlike `dict` to a WKB string. | def __dump_linestring(obj, big_endian):
wkb_string = b''
if big_endian:
wkb_string += BIG_ENDIAN
else:
wkb_string += LITTLE_ENDIAN
coords = obj['coordinates']
vertex = coords[0]
# Infer the number of dimensions from the first vertex
num_dims = len(vertex)
if num_dims ==... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_2_string(d):\n buff = io.StringIO()\n print_dictionary(d, output=buff)\n return buff.getvalue()",
"def render_dict(dict):\n\t\treturn str.encode(str(dict))",
"def json_dump_dict(dictionary):\n\n print(json.dumps(dictionary, indent=4, ensure_ascii=False).encode(\"utf8\").decode())\n\n re... | [
"0.6415069",
"0.59991217",
"0.5889633",
"0.5886834",
"0.58037204",
"0.57551813",
"0.5732175",
"0.5725547",
"0.5687833",
"0.5661887",
"0.56604487",
"0.5609592",
"0.556257",
"0.55397433",
"0.55241346",
"0.5521883",
"0.5501805",
"0.54972357",
"0.54923",
"0.54878175",
"0.5445764"... | 0.49451002 | 97 |
Convert byte data for a Point to a GeoJSON `dict`. | def __load_point(big_endian, type_bytes, data_bytes):
endian_token = '>' if big_endian else '<'
if type_bytes == WKB_2D['Point']:
coords = struct.unpack('%sdd' % endian_token, data_bytes)
elif type_bytes == WKB_Z['Point']:
coords = struct.unpack('%sddd' % endian_token, data_bytes)
elif ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_geom(data: dict) -> dict:\n geom = geom_from_geojson(data)\n validate_geom(geom)\n return geom",
"def parse_point(line):\n return json.loads(line)",
"def to_data(self):\n point = {\n 'point': [self.pt[0], self.pt[1], self.pt[2]],\n 'layer_height': self.layer_heig... | [
"0.61113554",
"0.60749865",
"0.59794545",
"0.58607936",
"0.58315086",
"0.57933426",
"0.5684637",
"0.5668959",
"0.56447315",
"0.55123854",
"0.5489289",
"0.54598",
"0.5451788",
"0.54298854",
"0.54289055",
"0.5410997",
"0.5388101",
"0.5378883",
"0.5308924",
"0.5280801",
"0.52757... | 0.6990642 | 0 |
Cluster prey sequences according to mapped RefSeq | def refseq_based_clustering(self):
self.refseq_based = NonRedSetDict()
for prey in self.ivv_info.Prey_info().preys():
refseqid = self.get_refseq(prey)
if refseqid:
self.refseq_based.append_Dict(refseqid, prey) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refseq_based_clustering(self):\n self.refseq_based = Usefuls.NonRedSet.NonRedSetDict()\n for prey in self.ivv_info.Prey_info().preys():\n refseqid = self.get_refseq(prey)\n if refseqid:\n self.refseq_based.append_Dict(refseqid, prey)",
"def test_first_sequen... | [
"0.70106786",
"0.6068481",
"0.5995936",
"0.5906224",
"0.58543235",
"0.58283967",
"0.57719815",
"0.5765596",
"0.5720791",
"0.56829274",
"0.5669235",
"0.5604671",
"0.55728793",
"0.5560698",
"0.5556891",
"0.5496786",
"0.547497",
"0.540696",
"0.5392086",
"0.537271",
"0.5355906",
... | 0.70810395 | 0 |
Returns all RefSeqs. refseq_based_clustering() must be precalled. | def get_all_refseq(self):
return self.refseq_based.keys() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def references(self) -> \"IterableList[Reference]\":\n return Reference.list_items(self)",
"def get_all_refobjs(self, ):\n return cmds.ls(type=\"jb_reftrack\")",
"def references(self):\n ref_nodes = self.root.xpath(\".//bib-reference\")\n return list(\n itertools.chain.fr... | [
"0.67854905",
"0.64765537",
"0.6383024",
"0.6376954",
"0.6328095",
"0.61806107",
"0.61366177",
"0.61037624",
"0.60236764",
"0.60163116",
"0.59973496",
"0.599216",
"0.59824604",
"0.59700936",
"0.59552693",
"0.59420055",
"0.5773383",
"0.57720006",
"0.5713108",
"0.5703122",
"0.5... | 0.77024484 | 1 |
This creates the symbols out of a stylegallery | def create_symbols(self, style_gallery, style_gallery_name, class_to_export):
try:
symbols_element = self.xml_document.getElementsByTagName("symbols")[0]
except IndexError:
symbols_element = self.xml_document.createElement("symbols")
root_element = self.xml_document.getE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_image_caption_pairs(self):",
"def singleglyph(x):\n return [glyph(x)]",
"def build_schematic(self, bg=None):",
"def get_stylesheet():\n\n #ss_dict\n ss_dict = {'header_image' : HEADER_IMAGE,\n 'icon_true' : ICON_TRUE,\n 'icon_false' : ICON_FALSE,\n ... | [
"0.5846963",
"0.5831491",
"0.57929367",
"0.5631854",
"0.56144685",
"0.55986845",
"0.5543508",
"0.55282354",
"0.54610837",
"0.5445795",
"0.544179",
"0.5433599",
"0.54209745",
"0.54185355",
"0.53752816",
"0.5288781",
"0.5242281",
"0.52400696",
"0.5225346",
"0.51927286",
"0.5187... | 0.69908535 | 0 |
MNSIT data set reader. returns (images, labels, length) | def read(cls, filepath, dataset = "training"):
f = gzip.open(filepath, 'rb')
train, valid, test = pickle.load(f, encoding='latin1')
f.close()
if dataset == "training":
return (train[0], train[1], train[0].shape[0])
elif dataset == "valid":
return (valid[0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readmnist(dataset = \"training\", path = \".\"):\n\n if dataset is \"training\":\n fname_img = os.path.join(path, 'train-images.idx3-ubyte')\n fname_lbl = os.path.join(path, 'train-labels.idx1-ubyte')\n elif dataset is \"testing\":\n fname_img = os.path.join(path, 't10k-images.idx3-u... | [
"0.66662216",
"0.65385675",
"0.643039",
"0.63432693",
"0.631567",
"0.63038933",
"0.6299887",
"0.629129",
"0.6280542",
"0.6269882",
"0.62673384",
"0.6267094",
"0.62668735",
"0.6260505",
"0.6247463",
"0.6245875",
"0.6233323",
"0.62239766",
"0.6222394",
"0.62110656",
"0.619755",... | 0.0 | -1 |
verify and extract data from a given token. If the token is valid, it's signed content is returned, otherwise None is returned. | def verify_auth_token(token):
serializer = Serializer(SECRET_KEY)
try:
data = serializer.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
return data['token'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def processResponse(token, enc_key, sig_key):\n payload = []\n # Decrypt encrypted token (JWE).\n enc = jwe.JWE()\n enc.deserialize(token, key=enc_key)\n payload.append(enc.payload.decode(\"utf-8\"))\n # This again contains a signed token (JWS), so we deserialize it and verify the signature.\n ... | [
"0.6363309",
"0.6217495",
"0.609201",
"0.59909505",
"0.5985739",
"0.5863285",
"0.5818454",
"0.5784145",
"0.5750953",
"0.5744397",
"0.57275766",
"0.56975555",
"0.565575",
"0.5648551",
"0.55936986",
"0.55830073",
"0.5560457",
"0.54820657",
"0.5462631",
"0.54586816",
"0.5452226"... | 0.6205273 | 2 |
A permutation is an ordered arrangement of objects. For example, 3124 is one possible permutation of the digits 1, 2, 3 and 4. If all of the permutations are listed numerically or alphabetically, we call it lexicographic order. | def euler24():
# import math
# math.factorial(10) = 3628800, 3.6 million combinations
# math.factorial(9) = 362880, so the first digit is '2'
import time
start = time.time()
p = 10
limit = 1000000-1
result = []
LIST = [0,1,2,3,4,5,6,7,8,9]
# higest digit, 10! permutations ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def permutation(a):\n rs = _generator.get_random_state()\n return rs.permutation(a)",
"def permute(seq, permutation):\n return [seq[i] for i in permutation]",
"def apply_permutation(hyper, pol, perm):\n pass",
"def permutations(iterable):\n pass",
"def permutations(lst):\n pass # Rep... | [
"0.70878094",
"0.7079293",
"0.6798157",
"0.67574525",
"0.6739657",
"0.6581821",
"0.65798986",
"0.65650576",
"0.6544407",
"0.6519375",
"0.65156496",
"0.6494174",
"0.64923877",
"0.6444669",
"0.64227724",
"0.6330735",
"0.63139623",
"0.62964976",
"0.6294119",
"0.62916183",
"0.628... | 0.0 | -1 |
Load pretrained Container and Containee model | def load_unary_model(self, model_name):
model = Model(model_name, gpu_id = self.gpu_id)
if model_name == 'Container':
model.load_state_dict(torch.load(self.container_model_file))
else:
model.load_state_dict(torch.load(self.containee_model_file))
return m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(self):\n if self.ckpt_flag:\n LOG('Skip Loading Pre-trained Model......')\n else:\n if self.params.pre_trained_from is not None and os.path.exists(self.params.pre_trained_from):\n try:\n LOG('Loading Pre-trained Model at %s' % sel... | [
"0.68571305",
"0.6820545",
"0.6752037",
"0.67184067",
"0.6527125",
"0.64759344",
"0.64290243",
"0.642883",
"0.64130765",
"0.64024806",
"0.6402233",
"0.6401311",
"0.640032",
"0.6393529",
"0.63868666",
"0.63630337",
"0.6353995",
"0.6351601",
"0.63504255",
"0.63357174",
"0.63206... | 0.5897552 | 73 |
Implementation of forward System operation in parallel MRI or PFS(.) In | def A(x,mask,S):
xS = x*S
y_full = fft.fftshift(fft.fft2(fft.ifftshift(xS)))
y = y_full[:,mask]
return y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, *args: Any, **kwargs: Any) -> Any:\n with torch.autograd.profiler.record_function(\"FullyShardedDataParallel.forward\"):\n self._lazy_init()\n args, kwargs = self._fsdp_root_pre_forward(*args, **kwargs)\n unused = None\n unshard_fn = functools.pa... | [
"0.6565294",
"0.651697",
"0.651697",
"0.65023226",
"0.63790023",
"0.6378946",
"0.63446945",
"0.6307241",
"0.63039196",
"0.62907183",
"0.6284443",
"0.6284443",
"0.6284443",
"0.62749475",
"0.6261079",
"0.6261079",
"0.625689",
"0.62215006",
"0.61801684",
"0.61801684",
"0.6164610... | 0.0 | -1 |
Implementation of backward System operation in parallel MRI or SFP(.) In | def A_H(y,mask,S):
y_zf = np.zeros(S.shape,dtype='complex128')
y_zf[:,mask] = y
x_zf = fft.fftshift(fft.ifft2(fft.ifftshift(y_zf)))*(mask.size)
x_zf_sum = ( x_zf*(S.conj()) ).sum(axis=0)
return x_zf_sum | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _poputil_recompute_backward(op, grads):\n return grads",
"def backward(self):\n raise NotImplementedError",
"def backward(self, *output_grads):\n raise NotImplementedError",
"def _poputil_block_recompute_backward(op, grads):\n return grads",
"def backward(self,input,grads):\n\t\traise R... | [
"0.6908455",
"0.69024163",
"0.68750006",
"0.6860696",
"0.66619337",
"0.66508573",
"0.6564414",
"0.6558091",
"0.6501835",
"0.6501835",
"0.6501835",
"0.6491457",
"0.6469847",
"0.6469847",
"0.6469847",
"0.6428603",
"0.6383331",
"0.6368481",
"0.63591284",
"0.63530004",
"0.63241",... | 0.0 | -1 |
This function uses CG to perform the multicoil data update on the input image using the undersampled measurements, the coil sensitivities and knowedge of the samplimg pattern. In | def multicoil_cg(x_in,y,nu,x0,mask,S,n,niter):
x = x0
x_zf_sum = A_H(y,mask,S)
# [:,mask.flatten()]
r = (nu*x_zf_sum) + x_in - (nu*A_H(A(x,mask,S),mask,S)) - (n*x)
p = r
rtr_old = np.vdot(r.flatten(),r.flatten())
for i in range(0,niter):
Ap = (nu*A_H(A(p,mask,S),mask,S)) + (... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sweep_image_model():\n for c1 in [4, 8, 16]:\n for c2 in [2, 4]:\n for c3 in [2, 4]:\n for c4 in [1, 2]:\n flags = flag_reader.read_flag()\n print(c1)\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\n ... | [
"0.6060822",
"0.60263777",
"0.59473807",
"0.5750547",
"0.5673431",
"0.563594",
"0.5591974",
"0.5587233",
"0.5580261",
"0.5544796",
"0.5538529",
"0.55316883",
"0.5512721",
"0.54656625",
"0.5457929",
"0.5441305",
"0.54357713",
"0.5429274",
"0.54067105",
"0.5392447",
"0.5390518"... | 0.56422526 | 5 |
check if given args are new | def __is_args_new(self, *args, **kwargs):
# if input size is different
if len(args) != len(self.__cached_args) or len(kwargs) != len(self.__cached_kwargs):
return True
# check args and kwargs
for a, ca in zip(args, self.__cached_args):
if a != (ca() if isinstance(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_args(self, args_):\n\n pass",
"def _check_args(self, args):\n if len(args) == 0:\n print(\"No parameters provided.\")\n return False\n else:\n return True",
"def __check_args(self):\n self.__check_args_type()\n self.__check_args_val... | [
"0.7180964",
"0.67476994",
"0.6550825",
"0.64482",
"0.61821944",
"0.6121256",
"0.6078874",
"0.60775244",
"0.5957351",
"0.59326947",
"0.59292126",
"0.585978",
"0.5825051",
"0.57995284",
"0.57905746",
"0.5777149",
"0.57604843",
"0.5759606",
"0.5752128",
"0.5742403",
"0.5735094"... | 0.76295835 | 0 |
reset cache accessible via `self.__class__.(arg_name).reset(self)` pattern | def reset(self, instance):
self.__flags[instance] = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(*args):",
"def reset(*args):",
"def reset(*args):",
"def reset(self, *args, **kwargs):",
"def reset(self, *args, **kwargs):\n ...",
"def reset(self, *args):\n raise NotImplementedError",
"def reset_cache(self, *args, **kwargs):\n value = self._fn(*self._inject_obj(args), ... | [
"0.7257476",
"0.7257476",
"0.7257476",
"0.71849614",
"0.71691287",
"0.71223843",
"0.69622254",
"0.68289167",
"0.66945654",
"0.66581154",
"0.6626647",
"0.6614927",
"0.6592734",
"0.6586193",
"0.65507424",
"0.65431076",
"0.6490789",
"0.64488316",
"0.6410432",
"0.6410432",
"0.640... | 0.0 | -1 |
decorator for cache reset reset to calculate | def resetter(self, func):
def __wrapper(instance, *args, **kwargs):
func(instance, *args, **kwargs)
self.__flags[instance] = True
return __wrapper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_cache(self, *args, **kwargs):\n value = self._fn(*self._inject_obj(args), **kwargs)\n\n if self._cache:\n key = self.get_cache_key(*args, **kwargs)\n cache_backend.set(key, value, timeout=self._timeout)\n\n if self._memoize:\n memoization_key = self._... | [
"0.72918427",
"0.6668384",
"0.66570526",
"0.64618593",
"0.64618593",
"0.63801813",
"0.63740206",
"0.6288314",
"0.6280954",
"0.6258521",
"0.6232449",
"0.62095875",
"0.6208023",
"0.61574566",
"0.6136212",
"0.61135143",
"0.6102016",
"0.6100977",
"0.60796076",
"0.6073473",
"0.606... | 0.0 | -1 |
Return the two base images needed to create a lighthouse animation. base_img is either A full/relative path from the run context The name of a directory under lighthouses here | def load_base_images(base_img):
if base_img is not None:
if not os.path.exists(base_img):
base_img = os.path.join(LIGHTHOUSES_DIR, base_img)
return (
Image.open(os.path.join(base_img, 'on.gif')).convert('RGBA'),
Image.open(os.path.join(base_img, 'off.gif'))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_imagebase(self):\n pass",
"def get_random_base():\n\n n_base = count_raw_img('base')\n img = \"{}.jpg\".format(random.randint(1, n_base + 1))\n return Image.open(RAW_DIR_PATH['base'] + img)",
"def propose_image_path():\n image_name = \"image_{}.png\".format(''.join(random.choice('abc... | [
"0.62116516",
"0.6163408",
"0.5916963",
"0.57784426",
"0.5775673",
"0.5691343",
"0.5683936",
"0.5591003",
"0.5576489",
"0.55682087",
"0.5541228",
"0.548597",
"0.5453294",
"0.54221994",
"0.54105973",
"0.5399216",
"0.535957",
"0.5359305",
"0.5342906",
"0.531411",
"0.52954346",
... | 0.7206143 | 0 |
Given a light characteristic, return a list of 2tuples representing the state of light at any given time. A fixed light is the given colour, permanently >>> characteristic_to_light_states('F. R') [('R', 1)] | def characteristic_to_light_states(description):
fragments = description.split()
pattern_type, groups = parse_pattern(fragments.pop(0))
colour, fragments = get_colour_code(fragments)
try:
period = parse_period(fragments)
except IndexError:
if must_have_period(pattern_type, groups):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_states(crime):\n statelist = []\n for i in range(len(crime)-1):\n statelist.append(crime[i][0])\n return statelist",
"def get_rgb_light():\n return list(light.rgb())",
"def lights(self):\n return list(self.GetLights())",
"def lights_on(self) -> list:\n return [\n ... | [
"0.5880032",
"0.5774206",
"0.5655911",
"0.55833024",
"0.5447408",
"0.5406236",
"0.54036015",
"0.537056",
"0.53520906",
"0.5329592",
"0.5319485",
"0.5250559",
"0.5245645",
"0.5213831",
"0.51771307",
"0.51550233",
"0.50853217",
"0.507346",
"0.50687844",
"0.50391555",
"0.5013721... | 0.6722805 | 0 |
Given the split up characteristic, return the period in milliseconds The period is specified in seconds >>> parse_period(['2']) 2000 The letter 's' to mark the units may be present >>> parse_period(['3s']) 3000 It may be separated from the number by a space >>> parse_period(['4','s']) 4000 A Quick flash can only have a... | def parse_period(fragments):
period_spec = fragments[-1]
# The last term is the cycle period,
# it may or may not have 's' for seconds
# The 's' may or may not be attached to the number
if period_spec == 's':
period_spec = fragments[-2]
if period_spec[-1] == 's':
period_spec = pe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def period(self):\n period_ns = int(utils.readstr_all(os.path.join(_CHANNEL_PATH(self._chip,\n self._channel),\n 'period')))\n return int(period_ns / 1000)",
"def get_period_sec... | [
"0.6479936",
"0.644268",
"0.6255988",
"0.6126181",
"0.59293336",
"0.5887166",
"0.5848696",
"0.581168",
"0.5801859",
"0.57852525",
"0.57155305",
"0.57155305",
"0.56989634",
"0.5696296",
"0.55982697",
"0.55982697",
"0.5581507",
"0.55336004",
"0.5522052",
"0.55193275",
"0.551443... | 0.75614196 | 0 |
Crack a pattern definition into its type and any grouping. A pattern consists of the pattern type (e.g. flashing, occulting) and optionally a group designation in parentheses. The pattern definition could just be the type >>> parse_pattern('Fl') ('fl', [1]) It could have optional dots marking the abbreviation, these ca... | def parse_pattern(pattern):
pattern_type, _, group_spec = pattern.partition('(')
# Groups are separated by '+' in a composite pattern.
groups = [
int(group) for group in group_spec[:-1].split('+')
] if group_spec else [1]
# Some light lists use dots, some don't, just throw them away
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_pattern(pattern: NumberPattern | str) -> NumberPattern:\n if isinstance(pattern, NumberPattern):\n return pattern\n\n def _match_number(pattern):\n rv = number_re.search(pattern)\n if rv is None:\n raise ValueError(f\"Invalid number pattern {pattern!r}\")\n re... | [
"0.6776147",
"0.61842924",
"0.6145672",
"0.60469675",
"0.582925",
"0.576661",
"0.5751908",
"0.5672661",
"0.564937",
"0.55928665",
"0.5582709",
"0.54133475",
"0.5398375",
"0.53610086",
"0.5338687",
"0.5337617",
"0.53008944",
"0.5261952",
"0.5254372",
"0.52399373",
"0.5239051",... | 0.7442205 | 0 |
Given a list of light states, collapse any adjacent entries that have the same state. If there are no adjacent matching states, there is no change to the output >>> collapse_states([('R',1), ('Y', 1), ('R', 1)]) [('R', 1), ('Y', 1), ('R', 1)] Adjacent states are collapsed, summing their durations >>> collapse_states([(... | def collapse_states(states):
new_states = states[:1]
for state in states[1:]:
last_state = new_states[-1]
if state[0] == last_state[0]:
new_states[-1] = (state[0], last_state[1] + state[1])
else:
new_states.append(state)
return new_states | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def states_filter(state):\n if state.count(0) < state.count(1) or state.count(1) < state.count(0) - 1:\n return False\n\n rows = [[i, i+1, i+2] for i in [0, 3, 6]]\n cols = [[i, i+3, i+6] for i in [0, 1, 2]]\n\n winners = set()\n\n for row_indexes in rows:\n row = [state[ind] for ind i... | [
"0.52173054",
"0.5162994",
"0.50791174",
"0.50559324",
"0.4989781",
"0.4952426",
"0.4899571",
"0.48871356",
"0.48810527",
"0.48748165",
"0.48466158",
"0.47453317",
"0.47329503",
"0.47069013",
"0.46448886",
"0.46182868",
"0.4606048",
"0.4591518",
"0.45846918",
"0.45573312",
"0... | 0.7746325 | 0 |
The Fixed pattern is simply an alwayson light in the given colour. groups and period are irrelevant. | def fixed(_groups, colour, _period):
return [(colour, 1)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_pattern(colors=('green', 'blue', 'red')): # (10)\n for i in range(0, int(ceil(float(NUM_LEDS)/float(len(colors))))):\n for color in colors:\n push_color(color)",
"def fill(self, color):",
"def fill(self, colour: int, /) -> None:",
"def occult... | [
"0.57946724",
"0.57644004",
"0.5761895",
"0.5750514",
"0.5239501",
"0.52209616",
"0.5144774",
"0.51025516",
"0.5077008",
"0.50707483",
"0.50707483",
"0.5058601",
"0.5058601",
"0.5058601",
"0.50353426",
"0.5011609",
"0.50076145",
"0.50035447",
"0.49892506",
"0.49738902",
"0.49... | 0.72213733 | 0 |
A flash is a single colour displayed for a short period, followed by a longer period of darkness A single flash of a given colour is a 1 second flash >>> flash([1], 'R', 5000) [('R', 1000), ('Off', 4000)] Grouped flashes have a shorter duration >>> flash([3], 'R', 10000) [('R', 500), ('Off', 1000), ('R', 500), ('Off', ... | def flash(groups, colour, period):
if groups == [1]:
if period <= 2000:
raise ValueError(
"The cycle period for a flash must be longer than 2 seconds"
)
return [
(colour, 1000),
('Off', period-1000)
]
return light_sequenc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def long_flash(groups, colour, period):\n if groups == [1]:\n return [\n (colour, 2000),\n ('Off', period - 2000)\n ]\n return light_sequence(groups, colour, 'Off', period, 2000, 3000)",
"def quick(groups, colour, period):\n # The cycle period cannot be longer than 1.... | [
"0.6906268",
"0.63640183",
"0.53384686",
"0.5311426",
"0.52867997",
"0.5262986",
"0.5233251",
"0.52132744",
"0.5064614",
"0.50232327",
"0.4976142",
"0.49747515",
"0.49659762",
"0.49345678",
"0.4889537",
"0.4873445",
"0.4861576",
"0.48529956",
"0.48520216",
"0.48484832",
"0.48... | 0.730446 | 0 |
A Long flash is at least 2 seconds | def long_flash(groups, colour, period):
if groups == [1]:
return [
(colour, 2000),
('Off', period - 2000)
]
return light_sequence(groups, colour, 'Off', period, 2000, 3000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_flash_timer(self):\r\n self.flashMillisecs = 1000\r\n self.flashTimer.start(50)",
"def _flash(self,id,msg,duration=30.0):\n if duration>0:\n pass #gtk.timeout_add(duration,'')\n return self.statusbar.push(id,msg)",
"def delay():\r\n time.sleep(2)",
"def fla... | [
"0.74898815",
"0.6975104",
"0.67044026",
"0.65149236",
"0.6494031",
"0.6478555",
"0.6331387",
"0.6299343",
"0.62820214",
"0.61999464",
"0.6144084",
"0.6137599",
"0.59895545",
"0.598306",
"0.5923389",
"0.5922658",
"0.5920993",
"0.59137625",
"0.59004384",
"0.5891849",
"0.587960... | 0.593689 | 14 |
isophase is a pattern with equal dark and light. There are no groups. | def isophase(_groups, colour, period):
# Whole numbers are required, so odd numbers are dealt with by loading
# the spare into the off period.
# As this is in milliseconds, this will be imperceptible.
# It is also unlikely, as the top-level input is in seconds
# and has been multiplied up to millise... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_monochromatic(self):\n return equal(s.color for s in self.iter_states())",
"def keep_measures(mosaiced_img, pattern):\n h, w = mosaiced_img.shape\n imout = np.zeros((h, w, 3))\n mask = np.zeros((h, w, 3))\n for i in range(2):\n for j in range(2):\n imout[i::2, j::2, pa... | [
"0.54219186",
"0.52342373",
"0.51545143",
"0.5147554",
"0.512688",
"0.493742",
"0.49075535",
"0.48455277",
"0.48435876",
"0.48435876",
"0.48414382",
"0.48366624",
"0.48366624",
"0.48366624",
"0.48335874",
"0.4826204",
"0.4740178",
"0.47373027",
"0.47355133",
"0.4724675",
"0.4... | 0.5926785 | 0 |
An occulting pattern is the opposite of a flash dark with longer light | def occulting(groups, colour, period):
if groups == [1]:
return [
('Off', 1000),
(colour, period - 1000)
]
return light_sequence(groups, 'Off', colour, period, 500, 1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dark(r, d):\n return d * 1.0 / (r + d) + d * r * 1.0 / ((r + d) ** 2)",
"def long_flash(groups, colour, period):\n if groups == [1]:\n return [\n (colour, 2000),\n ('Off', period - 2000)\n ]\n return light_sequence(groups, colour, 'Off', period, 2000, 3000)",
"d... | [
"0.6700004",
"0.63176876",
"0.6290823",
"0.62734985",
"0.60783553",
"0.6075236",
"0.6039119",
"0.60094136",
"0.59764445",
"0.5948906",
"0.5927794",
"0.5921896",
"0.5916064",
"0.58963686",
"0.5874015",
"0.58716214",
"0.58551055",
"0.58461297",
"0.5830117",
"0.582028",
"0.58135... | 0.0 | -1 |
A Quick flash is more than 50 per minute. | def quick(groups, colour, period):
# The cycle period cannot be longer than 1.2s (60/50)
# or shorter than 0.5s
if groups == [1]:
if period is not None:
raise ValueError(
"Quick Flash cycle periods must be longer than 0.5 seconds"
)
return [
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_flash_timer(self):\r\n self.flashMillisecs = 1000\r\n self.flashTimer.start(50)",
"def giveFlash(self, amount):\n self.fb = amount\n if amount > 0:\n es.give(self.userid, \"weapon_flashbang\")",
"def brief_led_flash(self):\n self._ubx.send('CFG-TP5', puls... | [
"0.7274421",
"0.6186878",
"0.6086867",
"0.59733325",
"0.58153445",
"0.58117354",
"0.5774111",
"0.57247484",
"0.5715428",
"0.569542",
"0.5694873",
"0.5687403",
"0.56838447",
"0.5658738",
"0.56574625",
"0.5635628",
"0.5612565",
"0.5605468",
"0.5590237",
"0.55884016",
"0.5575568... | 0.61882275 | 1 |
Handle set of files .u, .v, and .w containing a fullfield formatted time series output from TurbSim. Tested with TurbSim v2.00.05cbjj, 25Feb2016 | def __init__(self,prefix,verbose=False):
self.prefix = prefix
self.hub = dict() #hub-height wind speeds
self.field = dict() #full NY x NZ field
self._readTurbSimScalar(prefix,'u',verbose=verbose)
self._readTurbSimScalar(prefix,'v',verbose=verbose)
self._readTurbSimScalar(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entries_from_goes_ts_files(*files, default_waveunit=None, source=None):\n\n\n \"\"\"\n ts_goes = ts.TimeSeries(file)\n statinfo = os.stat(file)\n entry = DatabaseEntry(path=file)\n entry.size = statinfo.st_size\n\n #header['INSTRUME'] = header['TELESCOP']# So E.G. 'GOES 6' instead 'X-ray Dete... | [
"0.634698",
"0.5964177",
"0.5961929",
"0.59244645",
"0.59130234",
"0.5876912",
"0.584045",
"0.58363456",
"0.58036953",
"0.5788206",
"0.5774949",
"0.5697151",
"0.56815135",
"0.5672769",
"0.5671861",
"0.5652185",
"0.5577706",
"0.5569258",
"0.5545952",
"0.55439484",
"0.55428064"... | 0.0 | -1 |
Write out binary VTK file with a single vector field. Can specify time index or output time. | def writeVTK(self,fname,itime=None,output_time=None):
if output_time:
itime = int(output_time / self.dt)
if not itime:
print 'Need to specify itime or output_time'
return
print 'Writing out time step',itime,': t=',self.t[itime]
u = np.zeros((self.NY,1,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveVelocityAndPressureVTK_binary(pressure,u,v,w,x,y,z,filename,dims):\n numEl_size = u.size; numEl = np.prod(numEl_size);\n # open the file and write the ASCII header:\n file = open(filename,'w')\n file.write('# vtk DataFile Version 3.0\\n')\n file.write('VTK file for data post-processed with P... | [
"0.6757693",
"0.66369015",
"0.6426294",
"0.63140506",
"0.626889",
"0.6226187",
"0.607385",
"0.604287",
"0.6018301",
"0.6018301",
"0.5969815",
"0.5968377",
"0.594419",
"0.5942577",
"0.58605295",
"0.5848289",
"0.5788712",
"0.5758208",
"0.5744678",
"0.5741473",
"0.5739878",
"0... | 0.7530258 | 0 |
Call writeVTK for a range of times | def writeVTKSeries(self,prefix=None,step=1):
if not prefix: prefix = self.prefix
for i in range(0,self.N,step):
fname = prefix + '_' + str(i) + '.vtk'
self.writeVTK(fname,itime=i) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def writeVTK(self,fname,itime=None,output_time=None):\n if output_time:\n itime = int(output_time / self.dt)\n if not itime:\n print 'Need to specify itime or output_time'\n return\n print 'Writing out time step',itime,': t=',self.t[itime]\n u = np.zeros... | [
"0.67234313",
"0.65439826",
"0.61956275",
"0.6171551",
"0.584729",
"0.58062536",
"0.5772773",
"0.5763361",
"0.5762426",
"0.56863654",
"0.5424772",
"0.5380682",
"0.5364221",
"0.53386146",
"0.53386146",
"0.5328883",
"0.5259615",
"0.5244934",
"0.52399683",
"0.5105576",
"0.507751... | 0.6567778 | 1 |
Manages the auto_anchor object creation, and the data required to set up the object. Also creates the data that the different functions need. | def data_manager_fixture():
class DataManager:
def __init__(self):
self.gen = 1000
self.cfg = get_cfg_defaults()
mode = "test_inference"
self.dataset = Dataset(None, self.cfg, mode)
self.auto_anchors = AutoAnchors(self.dataset, self.cfg.model, sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_anchors(self):\n self.anchors_dic = {}\n meta = self.get_metadata()\n lines = meta.split(\"|\")\n for line in lines:\n data= line.split()\n anchor_name = data[0]\n # appending anchor in dictionary with its coordinates \n self.anchors_... | [
"0.61813956",
"0.5960812",
"0.5898869",
"0.580805",
"0.56519794",
"0.5590929",
"0.5538197",
"0.5498526",
"0.5492101",
"0.54861665",
"0.54561716",
"0.5454788",
"0.5441797",
"0.54283077",
"0.54270804",
"0.5386624",
"0.53783137",
"0.5377474",
"0.5370247",
"0.5364523",
"0.5360114... | 0.0 | -1 |
Creates a minimal configuration for the user. | def create_default_user_config(server, port, user, api_key, whitelist_tags=[], ignore_proxy=True, verify_ssl=False):
config = {}
config_path = DEFAULT_CONFIG_PATH
config['default'] = {'server': server,
'port': port,
'user': user,
'ap... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_config(self) -> None:\n pass",
"def create_config(self) -> None:\n pass",
"def create_empty_config_file():\n config = {\n \"config\": [\n {\n \"site\": {\n \"username\": \"\",\n \"name\": ... | [
"0.6830326",
"0.6830326",
"0.68101245",
"0.67205757",
"0.66883713",
"0.6676231",
"0.6484155",
"0.6468319",
"0.64551955",
"0.63014174",
"0.626041",
"0.6171588",
"0.61103344",
"0.60650027",
"0.6061568",
"0.6031424",
"0.5996078",
"0.592579",
"0.59251434",
"0.59190315",
"0.590579... | 0.68759596 | 0 |
Dict with indicator_type keys, and list of (thing, whitelist_indicator_value) results. | def print_whitelist_results(results):
if results:
print("WHITELISTED:")
for result in results:
print("\t{}:".format(result))
for whitelist_match in results[result]:
indicator_id = sip_client.get('indicators?exact_value={}'.format(whitelist_match[1]))[0]['id']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_indicator(indicator: Dict[str, str]) -> Dict[str, Any]:\n indicator_obj = {\n \"value\": indicator.get('summary'),\n \"type\": INDICATOR_MAPPING_NAMES.get(indicator.get('type', '')),\n \"rawJSON\": indicator,\n \"score\": calculate_dbot_score(indicator.get(\"threatAssessSco... | [
"0.6396432",
"0.60345435",
"0.597668",
"0.5744823",
"0.5410479",
"0.53097385",
"0.52731967",
"0.5235319",
"0.5152018",
"0.51344997",
"0.5108702",
"0.50672305",
"0.5050555",
"0.5023829",
"0.49648893",
"0.4906767",
"0.48939675",
"0.48489004",
"0.48249677",
"0.47569257",
"0.4750... | 0.4578551 | 45 |
rebuilds elements of flat_li to match list structure of original_li (or tuple if given as args) | def deflatten(flat_li, *original_li):
if len(original_li) == 1:
original_li = original_li[0]
deflatten_li = []
i = 0
for el in original_li:
if isinstance(el, Sequence):
deflatten_li.append(flat_li[i:i+len(el)])
i += len(el)
else:
deflatten_li.a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten(self, l, ltypes=(list, tuple)):\n i = 0\n while i < len(l):\n while isinstance(l[i], ltypes):\n if not l[i]:\n l.pop(i)\n if not len(l):\n break\n else:\n l[i:i + 1] = ... | [
"0.6270293",
"0.6178351",
"0.61386776",
"0.60761553",
"0.58953786",
"0.5860441",
"0.5845089",
"0.57745105",
"0.5755302",
"0.5732161",
"0.56978935",
"0.566958",
"0.566346",
"0.56503826",
"0.5627321",
"0.5624456",
"0.5575356",
"0.5567329",
"0.5556008",
"0.5543179",
"0.55420625"... | 0.7833961 | 0 |
generator decorator which executes the generator and returns results as list | def as_list(gen):
return list(gen()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generator(func):\n\n @fn\n @wraps(func)\n def gen(*args, **kwargs):\n return Iter(func(*args, **kwargs))\n\n return gen",
"def _for_each_generator(self,\n func: Callable[..., Any],\n *args: Iterable[Any]) -> List[Any]:\n return [func(gen... | [
"0.7420649",
"0.72913647",
"0.69836473",
"0.67607874",
"0.6716293",
"0.66058916",
"0.65415895",
"0.64996743",
"0.64882916",
"0.6475754",
"0.64716166",
"0.64409065",
"0.6438427",
"0.63554263",
"0.63165545",
"0.6290795",
"0.6278667",
"0.626935",
"0.6235086",
"0.62313914",
"0.62... | 0.6480012 | 9 |
find all indices from list ``l`` where entries match specific object ``o`` | def findall(l, o):
return [i for i, u in enumerate(l) if u==o] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAllIndex(ldata, fldata):\n\treturn list(map(lambda e : fldata.index(e), ldata))",
"def matchloc(alist,val): \n return [ilc for ilc,jlc in enumerate(alist) if jlc==val]",
"def get_indexes(from_list, find_list):\n\n df_find = pd.DataFrame(find_list, columns=['value'])\n df_from = pd.DataFrame(li... | [
"0.63037544",
"0.6193546",
"0.6087121",
"0.6016721",
"0.59283173",
"0.5781884",
"0.57606155",
"0.5718999",
"0.5709015",
"0.56931007",
"0.5680674",
"0.5623687",
"0.5537491",
"0.551839",
"0.5506623",
"0.5459669",
"0.5450619",
"0.54497373",
"0.53892154",
"0.53692645",
"0.5348893... | 0.7872293 | 0 |
get all entries of list ``l`` at positions ``idx`` | def getall(l, idx):
return [l[i] for i in idx] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multiListSlice(lol, index):\n divisor = 1\n values = []\n for i in range(0, len(lol)):\n index = (index / divisor) % len(lol[i])\n values[i] = lol[i][index]\n divisor *= len(lol[i])\n return values",
"def extract_sub_list(mylist, indices):\n return [mylist[ii] for ii in in... | [
"0.6098279",
"0.59349114",
"0.58925664",
"0.58031976",
"0.5779936",
"0.5718426",
"0.56653845",
"0.56569105",
"0.5654663",
"0.5648731",
"0.5606806",
"0.55991054",
"0.55896133",
"0.550258",
"0.5500482",
"0.54870623",
"0.54548275",
"0.54517424",
"0.5408129",
"0.54024506",
"0.529... | 0.82942766 | 0 |
removes duplicates in place by using del call | def remove_duplicates(l):
unique = set() # we use a set because ``elem in set`` is much faster than ``elem in list``
i = 0
while i < len(l):
elem = l[i]
if elem in unique:
del l[i]
else:
unique.add(elem)
i += 1
return l | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rm_duplicates(self):\n # get uniq representation of existing detection documents\n existing = set(ed.uniq_data for ed in self.existing_detections)\n # remove duplicates\n for idx in xrange(len(self.new_detections)-1, -1, -1):\n nd = self.new_detections[idx]\n i... | [
"0.70536613",
"0.6878427",
"0.6793208",
"0.6721995",
"0.66623056",
"0.6567927",
"0.65093476",
"0.64818907",
"0.6457876",
"0.6446315",
"0.6445583",
"0.64083076",
"0.6384284",
"0.6376325",
"0.63333505",
"0.63100076",
"0.6299175",
"0.6282895",
"0.6246026",
"0.6243735",
"0.622440... | 0.6000665 | 46 |
Split '1225,11' to array | def convert_tto(tto):
return sum([range(int(b), int(e or b) + 1) for b, e in tto_regexp.findall(tto)], []) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ExtractNumbers(s):\n\n t = s.strip('[]\\n')\n comma_space = r', '\n re_comma_space = re.compile(comma_space)\n z = re_comma_space.split(t)\n #print z\n return z",
"def split(a):\r\n compos = [-1] # compos stores the positions of the relevant commas in the argument string\r\n compos.ex... | [
"0.67174935",
"0.65931076",
"0.6341449",
"0.63282",
"0.62715924",
"0.6268796",
"0.6265045",
"0.62486094",
"0.61843127",
"0.61589974",
"0.61200494",
"0.61004627",
"0.6082922",
"0.60798216",
"0.6016594",
"0.60149527",
"0.5994863",
"0.5956473",
"0.5947249",
"0.5928228",
"0.59224... | 0.0 | -1 |
Extract tweet feature vector as NumPy array. | def make_tweet_nparr( txt ):
# result storage
fvec = numpy.empty( len(testFeatures) )
# search for each feature
txtLow = ' ' + txt.lower() + ' '
for i in range( 0, len(testFeatures) ):
key = testFeatures[i][0]
fvec[i] = False
for tstr in testFeatures[i][1]:
fve... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_feature_array(tweets):\n feats=[]\n for t in tweets:\n feats.append(sent_features(t))\n return np.array(feats)",
"def get_features_test(tweets):\n feats = get_feature_array(tweets)\n tfidf = vectorizer.transform(tweets).toarray()\n M = np.concatenate([tfidf,feats],axis=1)\n re... | [
"0.80908656",
"0.700307",
"0.6958721",
"0.69240814",
"0.67279756",
"0.66883886",
"0.6607619",
"0.65651304",
"0.6547444",
"0.64348966",
"0.6290983",
"0.6258462",
"0.6181728",
"0.6144161",
"0.61283016",
"0.6070738",
"0.6050265",
"0.6045746",
"0.60242474",
"0.6001382",
"0.599525... | 0.54418045 | 91 |
Extract tweet feature vector as dictionary. | def make_tweet_dict( txt ):
txtLow = ' ' + txt.lower() + ' '
# result storage
fvec = {}
# search for each feature
for test in testFeatures:
key = test[0]
fvec[key] = False;
for tstr in test[1]:
fvec[key] = fvec[key] or (txtLow.find(tstr) != -1)
return fve... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tweet2features(tweet):\r\n features = {\r\n 'len(tweet)': len(tweet),\r\n 'avg_word_length': get_avg_word_len(tweet)\r\n }\r\n return features",
"def tweets_features(tweet):\n tweet = remove_stop_words(tweet)\n return {'TWEET': tweet}",
"def get_feature_set_SA(tweet):\n feat... | [
"0.7318314",
"0.72936505",
"0.70175284",
"0.6987621",
"0.6677231",
"0.66433674",
"0.6634793",
"0.6374446",
"0.6298803",
"0.62520707",
"0.62181693",
"0.6170607",
"0.61336696",
"0.6114916",
"0.61006075",
"0.6086418",
"0.6078208",
"0.6054301",
"0.60526454",
"0.6035818",
"0.60035... | 0.61875975 | 11 |
Convert dictionary feature vector to numpy array | def tweet_dict_to_nparr( dict ):
fvec = numpy.empty( len(testFeatures) )
for i in range( 0, len(testFeatures) ):
fvec[i] = dict[ testFeatures[i][0] ]
return fvec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_to_vector(self, dictionary):\n vector = []\n for key in dictionary:\n vector = np.concatenate((vector,dictionary[f'{key}'].flatten()))\n return vector",
"def _dict2arr(self, key):\r\n # Prepare the matrix for the output:\r\n arr = np.empty((self._n_process,\... | [
"0.7267182",
"0.6759521",
"0.6714084",
"0.65538764",
"0.6532126",
"0.6398057",
"0.6383626",
"0.63344187",
"0.6267018",
"0.6249601",
"0.6215344",
"0.6138086",
"0.60986435",
"0.60888034",
"0.60870045",
"0.60716164",
"0.6066192",
"0.60525304",
"0.604994",
"0.59986705",
"0.599280... | 0.6318512 | 8 |
Convert NumPy array to dictionary | def tweet_nparr_to_dict( nparr, use_standard_features=False ):
fvec = {}
if use_standard_features:
assert len(nparr) == len(testFeatures)
fvec = {}
for i in range( 0, len(nparr) ):
fvec[ testFeatures[i][0] ] = nparr[i]
else:
for i in range( 0, len(nparr) ):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rec_to_dict(arr):\n\n return dict(zip(arr.dtype.names, arr))",
"def todict(self):\n return dict(self.array)",
"def array_to_dict(arr: np.ndarray, domain: Optional[np.ndarray] = None) -> DictStrNum:\n\n if domain is None:\n keys, counts = np.unique(numpy_array(arr), return_counts=True)\n... | [
"0.77771544",
"0.7065067",
"0.69639283",
"0.6936445",
"0.66949195",
"0.6554356",
"0.62642986",
"0.62447995",
"0.62447995",
"0.62447995",
"0.62242985",
"0.62224233",
"0.62043583",
"0.62043583",
"0.6199028",
"0.6120777",
"0.61071545",
"0.61017853",
"0.60987467",
"0.6083384",
"0... | 0.0 | -1 |
Identifies empty feature vectors | def is_zero_dict( dict ):
has_any_features = False
for key in dict:
has_any_features = has_any_features or dict[key]
return not has_any_features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def irrelevant_features(features):\n irrelevant = []\n for vec in set(features):\n if (features[vec].count(0)/len(indtf_features[vec])) < 0.1:\n irrelevant.append(vec)\n return irrelevant",
"def empty(self):\n return _uhd_swig.uhd_size_vector_t_empty(self)",
"def __len__(self)... | [
"0.6569177",
"0.6282958",
"0.6276785",
"0.6192717",
"0.6157447",
"0.61539346",
"0.61179924",
"0.60928863",
"0.60695285",
"0.6041442",
"0.60379803",
"0.6028977",
"0.60289145",
"0.60216546",
"0.5998104",
"0.5947502",
"0.5947502",
"0.59333825",
"0.59324276",
"0.59223014",
"0.591... | 0.5867847 | 22 |
Preprocess a single image of layout [height, width, depth]. | def preprocess_image(image, is_training):
if is_training:
# Resize the image to add four extra pixels on each side.
image = tf.image.resize_image_with_crop_or_pad(
image, _IMAGE_SIZE + 8, _IMAGE_SIZE + 8)
# Randomly crop a [_HEIGHT, _WIDTH] section of the image.
image = tf.random_crop(image, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(image):\n return image - MEAN_PIXEL",
"def image_preprocessing(img):\n\n # Removing parasite data (sky, trees and front of the car)\n return img[60:-20, :, :]",
"def preprocess(self, img):\n img_ = image.load_img(img, target_size=(299, 299))\n img_ = image.img_to_array(img... | [
"0.7163514",
"0.7148098",
"0.70862305",
"0.68458503",
"0.6814179",
"0.6797915",
"0.6732928",
"0.67209995",
"0.671532",
"0.6702475",
"0.6694466",
"0.6693217",
"0.6673145",
"0.66544497",
"0.66286415",
"0.65898776",
"0.6576983",
"0.65552187",
"0.6524786",
"0.65217966",
"0.651925... | 0.59542423 | 93 |
These are the parameters that work for CIFAR10 data. | def __init__(self, resnet_size, data_format=None, num_classes=_NUM_CLASSES,
resnet_version=resnet_model.DEFAULT_VERSION,
dtype=resnet_model.DEFAULT_DTYPE):
if resnet_size % 6 != 2:
raise ValueError('resnet_size must be 6n + 2:', resnet_size)
num_blocks = (resnet_size - 2) //... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cifar10(self):\n\t\t# Get the data.\n\t\tself.x_train = self.x_train.reshape(self.nb_train, self.input_dim)\n\t\tself.x_test = self.x_test.reshape(self.nb_test, self.input_dim)\n\t\tself.x_train = self.x_train.astype('float32')\n\t\tself.x_test = self.x_test.astype('float32')\n\t\tself.x_train /= 255\n\t\t... | [
"0.65884995",
"0.620409",
"0.60628486",
"0.59556997",
"0.5827081",
"0.5796021",
"0.57901245",
"0.57782847",
"0.57458854",
"0.5738722",
"0.57135123",
"0.5708363",
"0.5680949",
"0.56369066",
"0.5576975",
"0.55761087",
"0.5503329",
"0.547142",
"0.546797",
"0.54473364",
"0.542363... | 0.0 | -1 |
Model function for CIFAR10. | def cifar10_model_fn(features, labels, mode, params):
features = tf.reshape(features, [-1, _IMAGE_SIZE, _IMAGE_SIZE, _NUM_CHANNELS])
learning_rate_fn = resnet_run_loop.learning_rate_with_decay(
batch_size=params['batch_size'], batch_denom=128,
num_images=_NUM_IMAGES['train'], boundary_epochs=[10, 20, 3... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cifar10(self):\n\t\t# Get the data.\n\t\tself.x_train = self.x_train.reshape(self.nb_train, self.input_dim)\n\t\tself.x_test = self.x_test.reshape(self.nb_test, self.input_dim)\n\t\tself.x_train = self.x_train.astype('float32')\n\t\tself.x_test = self.x_test.astype('float32')\n\t\tself.x_train /= 255\n\t\t... | [
"0.6843386",
"0.650111",
"0.609306",
"0.60163224",
"0.5996454",
"0.59331244",
"0.588775",
"0.58561015",
"0.5830527",
"0.57808924",
"0.57354146",
"0.5720595",
"0.5690742",
"0.56661737",
"0.5664544",
"0.5653322",
"0.56082076",
"0.55979353",
"0.5551245",
"0.5541251",
"0.5541251"... | 0.6535784 | 1 |
Run ResNet CIFAR10 training and eval loop. | def run_flower(flags_obj):
input_function = input_fn
resnet_run_loop.resnet_main(
flags_obj,
cifar10_model_fn,
input_function,
DATASET_NAME,
shape=[_IMAGE_SIZE, _IMAGE_SIZE, _NUM_CHANNELS]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cifar10_model_fn(features, labels, mode, params):\n features = tf.reshape(features, [-1, _IMAGE_SIZE, _IMAGE_SIZE, _NUM_CHANNELS])\n\n learning_rate_fn = resnet_run_loop.learning_rate_with_decay(\n batch_size=params['batch_size'], batch_denom=128,\n num_images=_NUM_IMAGES['train'], boundary_epochs=... | [
"0.68692064",
"0.68146634",
"0.67452115",
"0.6699857",
"0.6683113",
"0.6682839",
"0.6632425",
"0.6484482",
"0.6415731",
"0.64139616",
"0.6357005",
"0.63551235",
"0.631291",
"0.6257653",
"0.6231015",
"0.6218077",
"0.62155414",
"0.6197411",
"0.6194097",
"0.6192405",
"0.6187572"... | 0.6743016 | 3 |
This is the main prediction adding function. It starts by grabbing a file to open from standard in, which contains one message board page. It processes each message contained in the page. | def main():
# db_user = raw_input('DB username: ')
db_user = 'oraclech'
pw = getpass.getpass()
odb = oracle_db.OracleDb(db_user, pw, database='oraclech_new')
contest_id = raw_input('Current Contest ID? ')
round_num = raw_input('Current Round Number? ')
round_nums = round_num.split(',')
topic_num = ra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_poems(self):\n file = open(self.name, \"r\")\n content = file.readlines()\n for i in content:\n self.add_msg_and_index(i.strip())",
"def process_input_file(sess, char_dict, model_settings, model_vars, input_file):\n \n with open(input_file, 'r') as f:\n for s... | [
"0.5945443",
"0.5409753",
"0.5362085",
"0.5329677",
"0.52767473",
"0.5266814",
"0.5265608",
"0.52539533",
"0.5241925",
"0.5217411",
"0.5205404",
"0.51909417",
"0.5187099",
"0.51860255",
"0.5160676",
"0.5133867",
"0.5133248",
"0.51240563",
"0.5112366",
"0.51108074",
"0.5107463... | 0.6416924 | 0 |
This function parses the predictions in one individual message. If the message contains predictions, they will be inserted into the oracle database. | def ParsePredictions(odb, message, contest, round_nums):
duel = 0
if contest['CompetitorsPerMatch'] == 2:
duel = 1
user_id = odb.GetUserId(message['User'])
if user_id is None:
user_id = GetUserId(odb, message['User'], add_alt=1)
# This enables admins to enter predictions for other users.
# TODO: M... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_raw_predictions(self, raw_predictions):\n result = []\n for line in raw_predictions.split(\"\\n\"):\n line_parts = line.split(\"|\")\n type = line_parts[0]\n assert type.lstrip(\"*\") in (\n \"FP\", \"TP\", \"TN\", \"FN\"), 'Expected {} to be... | [
"0.61501306",
"0.6139516",
"0.60400605",
"0.5975302",
"0.5914858",
"0.5826979",
"0.582425",
"0.57627505",
"0.5746949",
"0.5707061",
"0.56706715",
"0.5667077",
"0.5660581",
"0.5609151",
"0.56070286",
"0.5595583",
"0.55625534",
"0.5559505",
"0.5535425",
"0.55325687",
"0.5504344... | 0.6788969 | 0 |
Get the user id of an unrecognized user. | def GetUserId(odb, username, add_alt=0):
print 'Unrecognized user %s.' % (username)
alt = raw_input('Is this user in our DB (y/n)? ')
if alt == 'y':
main_name = raw_input('What is their primary username? ')
user_id = odb.GetUserId(main_name)
if user_id is None:
user_id = GetUserId(odb, main_nam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_unknown_userid(self):\n cursor = self.conn.cursor()\n unknown_user_str = dbtypes.User.null\n cursor.execute(\"select id from users where uniqueid='%s'\" % unknown_user_str)\n return cursor.fetchone()[0]",
"def _get_user_id(self, user: Optional[Dict[str, Any]]) -> Optional[str... | [
"0.80115664",
"0.7302841",
"0.7226531",
"0.7225523",
"0.7225523",
"0.7088756",
"0.7004554",
"0.6994547",
"0.6994547",
"0.6994547",
"0.6941295",
"0.6934723",
"0.68709123",
"0.68640584",
"0.6849172",
"0.67509985",
"0.6687582",
"0.66480327",
"0.66480327",
"0.66307473",
"0.659805... | 0.6174131 | 58 |
Figure out a competitor id based on a userinput name. | def DecipherName(odb, winner_name, line, type, contest, round_nums):
competitor_id = None
competitors = odb.GetCompetitors(winner_name, type=type)
if competitors and len(competitors) > 1:
comps_in_round = []
for comp in competitors:
if odb.IsCompetitorInRounds(comp['CompetitorId'], contest, round_n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_id(cls, name):\n assert name, 'name is empty'\n if name in cls._ids:\n return cls._ids[name]\n sql = \"SELECT id FROM hive_communities WHERE name = :name\"\n cid = DB.query_one(sql, name=name)\n if cid:\n cls._ids[name] = cid\n cls._names[... | [
"0.6559644",
"0.65396285",
"0.65396285",
"0.63410085",
"0.5949359",
"0.5924379",
"0.58869797",
"0.5779381",
"0.5747495",
"0.5730306",
"0.5696639",
"0.5695518",
"0.56872874",
"0.5674879",
"0.5640459",
"0.5591031",
"0.5586947",
"0.5575347",
"0.5573894",
"0.5563811",
"0.5533301"... | 0.5925194 | 5 |
Prompt for user input to figure out who predictions are for. This function is written so that the Oracle host can post predictions in the topic for other users. | def PromptForId(odb, message, orig_id=1):
print 'Is this prediction for someone other than the poster?\n\n%s\n\n' % \
(message['Text'])
diff_user = raw_input('(y/n): ')
if diff_user == 'n':
return orig_id
user_name = raw_input('Username this prediction is for? ')
user_id = odb.GetUserId(user_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_prompt(self):\n # we need _something_ in the dictionary even if the user decides to use all defaults\n # otherwise for some unknown reason it won't work\n user_in = {'__meta__': '__user_input__'}\n\n print('Please enter the information asked for in the following prompts in order ... | [
"0.64296",
"0.6354998",
"0.63514704",
"0.6275108",
"0.6199466",
"0.6192252",
"0.6019146",
"0.59782445",
"0.5917745",
"0.590989",
"0.584681",
"0.58215415",
"0.5810385",
"0.579001",
"0.5771973",
"0.576907",
"0.5767045",
"0.5765213",
"0.5736743",
"0.5734095",
"0.57227224",
"0.... | 0.67718136 | 0 |
Implement the closure here. | def _define_objective(self, inputs, labels, targets, intended_classes=None, true_classes=None):
def closure(model, criterion, optimizer, target_grad, target_gnorm):
"""This function will be evaluated on all GPUs.""" # noqa: D401
outputs = model(inputs)
if self.args.target_cr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closure(self, t):\n raise NotImplementedError",
"def callback(self):\n pass # pragma: no cover",
"def __call__(self):\n\t\treturn",
"def __call__( self ):\n pass",
"def apply(self):",
"def apply(self) -> None:",
"def apply(self) -> None:",
"def closure(self):\n return... | [
"0.72084713",
"0.67918205",
"0.66439474",
"0.6594649",
"0.6570198",
"0.65522903",
"0.65522903",
"0.6530278",
"0.6526465",
"0.6436523",
"0.64173025",
"0.64173025",
"0.64173025",
"0.64173025",
"0.64173025",
"0.6416854",
"0.64145666",
"0.6391834",
"0.63399154",
"0.63399154",
"0.... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.