>\\\":\\n t1 = type(num_val)\\n t2 = type(num_val_initial)\\n if t1 == float or t2 == float:\\n raise PostfixFormatException(\\\"Illegal bit shift operand\\\")\\n stack.push(num_val_initial >> num_val)\\n elif new_val.isdigit():\\n if \\\".\\\" in i:\\n stack.push(float(i))\\n else:\\n stack.push(int(i))\\n else:\\n raise PostfixFormatException(\\\"Invalid token\\\")\\n val = stack.pop()\\n if not stack.is_empty():\\n raise PostfixFormatException(\\\"Too many operands\\\")\\n return val\",\n \"def infixToPostfix(expr, prec):\\n ops = Stack()\\n postfix = []\\n toks = expr.split()\\n for t in toks:\\n if t.isdigit():\\n postfix.append(t)\\n elif t == '(':\\n ops.push('(')\\n elif t == ')':\\n op = ops.pop()\\n while op != '(':\\n postfix.append(op)\\n op = ops.pop()\\n else:\\n while True:\\n if ops.empty() or ops.peek() == '(':\\n ops.push(t)\\n break\\n if prec[t] > prec[ops.peek()]:\\n ops.push(t)\\n break\\n elif prec[t] == prec[ops.peek()]:\\n postfix.append(ops.pop())\\n ops.push(t)\\n break\\n else:\\n postfix.append(ops.pop())\\n while not ops.empty():\\n postfix.append(ops.pop())\\n return postfix\",\n \"def parse_infix(input: str) -> Node:\\n parsed = ParsedString(input).tokenize()\\n ans = parse_e(parsed)\\n return ans\",\n \"def postfix(t_input):\\r\\n # guardo se gli elementi contengono caratteri non validi\\r\\n if is_valid(t_input) == 1:\\r\\n # restituisco Invalid se sono stati trovati caratteri invalidi\\r\\n result = \\\"Invalid\\\"\\r\\n return result\\r\\n\\r\\n # scorri di nuovo gli elementi\\r\\n # NOTA: sarebbe piu' efficiente fare un unico ciclo\\r\\n for element in t_input.strip(\\\"\\\\0\\\").split(\\\" \\\"):\\r\\n if element in [\\\"-\\\", \\\"+\\\", \\\"*\\\", \\\"/\\\"]:\\r\\n # ho trovato operatore, ricavo operandi dallo stack\\r\\n right_operand = stack.pop()\\r\\n left_operand = stack.pop()\\r\\n\\r\\n # faccio l'operazione che serve\\r\\n if element == \\\"-\\\":\\r\\n op_result = left_operand - right_operand\\r\\n elif element == \\\"+\\\":\\r\\n op_result = left_operand + right_operand\\r\\n elif element == \\\"*\\\":\\r\\n op_result = left_operand * right_operand\\r\\n else:\\r\\n op_result = left_operand // right_operand\\r\\n\\r\\n if boold:\\r\\n print(\\\"[DEBUG] Ho trovato operatore '{}': {} {} {} = {}\\\".format(element, left_operand, element, right_operand, op_result))\\r\\n # inserisco nello stack il risultato dell'operazione\\r\\n stack.push(op_result)\\r\\n else:\\r\\n # ho trovato operando, lo metto nello stack\\r\\n # > NOTA: e' necessaria conversione stringa -> intero\\r\\n stack.push(int(element))\\r\\n \\r\\n if boold:\\r\\n stack.print()\\r\\n\\r\\n # il risultato e' l'ultimo elemento\\r\\n # > NOTA: e' necessaria conversione intero -> stringa\\r\\n result = str(stack.pop())\\r\\n return result\",\n \"def evaluatePostfixExp(self, postfixExpr):\\n\\n operandStack = []\\n tokenList = postfixExpr.split(\\\" \\\")\\n\\n for token in tokenList:\\n if self.isOperand(token):\\n if \\\".\\\" in token:\\n token = float(token)\\n else:\\n token = int(token)\\n operandStack.append(token)\\n else: # token is an operator\\n operand2 = operandStack.pop()\\n operand1 = operandStack.pop()\\n try:\\n result = self.applyOperator(operand1, operand2, token)\\n except Exception as error:\\n print(\\\"Invalid input. Please enter a valid arithmetic expression.\\\") # Most likely division by\\n # zero error.\\n return\\n operandStack.append(result)\\n return operandStack.pop()\",\n \"def _get_postfix_notation(self):\\n postfix, operators_stack = list(), list() # initialize postfix list and auxiliary stack\\n\\n for element in self.expression.split():\\n if element in self.OPERATORS:\\n if operators_stack:\\n # while stack isn't empty and \\\"stack top\\\" is stronger(e.g. multiplication is stronger than addition)\\n # move \\\"stack top\\\" into postfix list\\n while operators_stack \\\\\\n and operators_stack[-1] in self.OPERATORS \\\\\\n and self.OPERATOR_WEIGHT[operators_stack[-1]] >= self.OPERATOR_WEIGHT[element]:\\n postfix.append(operators_stack.pop())\\n\\n operators_stack.append(element)\\n\\n elif element == self.BRACKET_LEFT:\\n operators_stack.append(element)\\n\\n elif element == self.BRACKET_RIGHT:\\n # searching for left bracket on stack, moving \\\"stack Top\\\" to postfix list\\n while operators_stack and operators_stack[-1] != self.BRACKET_LEFT:\\n postfix.append(operators_stack.pop())\\n operators_stack.pop() # remove left bracket\\n\\n else: # numbers always goes into postfix list\\n postfix.append(self._get_number_from_string(element))\\n\\n if operators_stack: # move others stack elements to postfix list\\n postfix.extend(reversed(operators_stack))\\n\\n return postfix\",\n \"def infixToRPN(expression):\\n stack = Stack()\\n RPNList = []\\n tokens = expression.split()\\n spaces = True\\n\\n # If no spaces in expression then push each char in a tokens list\\n if len(tokens) == 1:\\n spaces = False\\n tokens = [char for char in expression]\\n\\n for token in tokens:\\n if token in alphabet or token in numbers:\\n RPNList.append(token)\\n elif token == '(':\\n stack.push(token)\\n elif token == ')':\\n top = stack.pop()\\n while top != '(':\\n RPNList.append(top)\\n top = stack.pop()\\n else:\\n while (not stack.isEmpty()) and (precedence[stack.peek()] >= precedence[token]):\\n RPNList.append(stack.pop())\\n stack.push(token)\\n\\n while not stack.isEmpty():\\n RPNList.append(stack.pop())\\n\\n if spaces:\\n return \\\" \\\".join(RPNList)\\n else:\\n return \\\"\\\".join(RPNList)\",\n \"def shunt(infix):\\n #convert input to a stack list\\n infix=list(infix)[::-1]\\n #operator stack and output list as empty lists\\n opers,postfix =[],[]\\n #operator precedence\\n prec={'*':100,'.':90, '|':80, '/':80, '\\\\\\\\':80, ')':70, '(':60}\\n\\n #loop through input one character at a time\\n while infix:\\n #pop a character from the input\\n c=infix.pop() \\n #decide what to do based on character\\n if c== '(':\\n #push an open bracket to opers stack\\n opers.append(c)\\n elif c==')':\\n #pop the operators stack until you find an open bracket\\n while opers[-1]!='(':\\n postfix.append(opers.pop())\\n #get rid of '('\\n opers.pop()\\n elif c in prec:\\n #push any operators on opers stack with hight prec to output\\n while opers and prec[c] < prec[opers[-1]]:\\n postfix.append(opers.pop())\\n opers.append(c)\\n else:\\n #typically we just push the character to the output\\n postfix.append(c)\\n #pop all operators to the output\\n while opers:\\n postfix.append(opers.pop())\\n #convert output list to string\\n return ''.join(postfix)\",\n \"def infix_to_postfix(text: str) -> list:\\n \\n def unfold_block(text: str) -> list:\\n return infix_to_postfix(text) if text[0] == \\\"(\\\" else [text]\\n\\n grouped_raw = group_operations(text)[0]\\n if not (\\\"+\\\" in grouped_raw or \\\"-\\\" in grouped_raw or \\\"*\\\" in grouped_raw or \\\"/\\\" in grouped_raw):\\n grouped = grouped_raw\\n stack = [grouped]\\n else:\\n grouped = group_operations(text)[0][1:-1]\\n first_block, operator, second_block = text_to_parts(grouped)\\n first_block = unfold_block(first_block)\\n second_block = unfold_block(second_block)\\n stack = [*first_block, *second_block, operator]\\n return stack\",\n \"def postfix(self,Line):\\r\\n\\r\\n stak = []\\r\\n expression = []\\r\\n infix = []\\r\\n i=0\\r\\n while( i <(len(Line))):\\r\\n if (Line[i] == '(') or (Line[i] == '['):\\r\\n if len(stak) > 0:\\r\\n if (Line[i] == '[') and ((stak[len(stak) - 1] == \\\"lengthof\\\") or (stak[len(stak) - 1] == \\\"dup\\\") or (stak[len(stak) - 1] == \\\"sizeof\\\") or (stak[len(stak) - 1] == \\\"type\\\")):\\r\\n return False\\r\\n if len(stak) > 0:\\r\\n if (Line[i] == '(') and ((stak[len(stak) - 1] == \\\"lengthof\\\") or (stak[len(stak) - 1] == \\\"sizeof\\\")):\\r\\n return False\\r\\n if (len(stak) == 0) and (Line[i] == '('):\\r\\n return False\\r\\n stak.append(Line[i])\\r\\n elif (Line[i] == ')') or (Line[i] == ']'):\\r\\n if len(stak) == 0:\\r\\n return False\\r\\n\\r\\n j = len(stak) - 1\\r\\n while j >= 0:\\r\\n if (stak[j] == '(') and (Line[i] == ')'):\\r\\n break\\r\\n elif (stak[j] == '(') and (Line[i] == ']'):\\r\\n return False\\r\\n elif (stak[j] == '[') and (Line[i] == ')'):\\r\\n return False\\r\\n elif (stak[j] == '[') and (Line[i] == ']'):\\r\\n break\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n j = j - 1\\r\\n if j < 0:\\r\\n break\\r\\n\\r\\n stak = stak[:-1]\\r\\n if (len(stak) > 0) and (stak[stak.__len__() - 1] == 'dup'):\\r\\n expression.append(stak[stak.__len__() - 1])\\r\\n stak = stak[:-1]\\r\\n elif Line[i] == ',':\\r\\n if expression.__len__() == 0:\\r\\n return False\\r\\n if stak.__len__() != 0:\\r\\n j = stak.__len__() - 1\\r\\n while (j >= 0):\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n j = j - 1\\r\\n if (expression.__len__() > 0)and(expression!=[\\\"dup\\\"]):\\r\\n infix.append(expression)\\r\\n expression = []\\r\\n elif Line[i][0].isdecimal():\\r\\n if Line[i][len(Line[i]) - 1] == 'h':\\r\\n tmp = extra_functions.is_hexa(Line[i])\\r\\n if not tmp:\\r\\n return False\\r\\n expression.append(tmp)\\r\\n\\r\\n elif Line[i][len(Line[i]) - 1] == 'o':\\r\\n tmp = extra_functions.is_octa(Line[i])\\r\\n if not tmp:\\r\\n return False\\r\\n expression.append(tmp)\\r\\n elif Line[i][len(Line[i]) - 1] == 'b':\\r\\n tmp = extra_functions.is_binary(Line[i])\\r\\n if not tmp:\\r\\n return False\\r\\n expression.append(tmp)\\r\\n elif Line[i][len(Line[i]) - 1] == 'd':\\r\\n tmp = int(Line[i][:-1], 10)\\r\\n expression.append(tmp)\\r\\n elif Line[i].isdecimal():\\r\\n expression.append(int(Line[i]))\\r\\n else:\\r\\n return False\\r\\n elif (Line[i] == \\\"lengthof\\\") or (Line[i] == \\\"sizeof\\\") or (Line[i] == \\\"type\\\") or (Line[i] == \\\"dup\\\"):\\r\\n if (Line[i] == \\\"dup\\\"):\\r\\n if stak.__len__()>0:\\r\\n j = stak.__len__() - 1\\r\\n while (j >= 0):\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n j = j - 1\\r\\n S = []\\r\\n L = []\\r\\n i = 1 + i\\r\\n while (i < len(Line)):\\r\\n if (Line[i] == '(') or (Line[i] == '['):\\r\\n S.append(Line[i])\\r\\n elif (Line[i] == ')') or (Line[i] == ']'):\\r\\n if len(S) == 0:\\r\\n return False\\r\\n j = len(S) - 1\\r\\n while j >= 0:\\r\\n if (S[j] == '(') and (Line[i] == ')'):\\r\\n break\\r\\n elif (S[j] == '(') and (Line[i] == ']'):\\r\\n return False\\r\\n elif (S[j] == '[') and (Line[i] == ')'):\\r\\n return False\\r\\n elif (S[j] == '[') and (Line[i] == ']'):\\r\\n break\\r\\n S = S[:-1]\\r\\n j = j - 1\\r\\n if j < 0:\\r\\n break\\r\\n S = S[:-1]\\r\\n\\r\\n L.append(Line[i])\\r\\n if len(S) == 0:\\r\\n break\\r\\n i += 1\\r\\n if L.__len__() > 1:\\r\\n if (L[L.__len__() - 1] == ')') and (L[0] == '('):\\r\\n L = L[:-1]\\r\\n L = L[1:]\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n return False\\r\\n tmp = self.postfix(L)\\r\\n i = i + 1\\r\\n if tmp != False:\\r\\n tmp1 = self.Calc_infix(expression)\\r\\n if tmp1 != False:\\r\\n for j in range(0, tmp1[0]):\\r\\n infix = infix + tmp\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n return False\\r\\n expression=[\\\"dup\\\"]\\r\\n continue\\r\\n stak.append(Line[i])\\r\\n else:\\r\\n if (Line[i] == '*') | (Line[i] == '-') | (Line[i] == '/') | (Line[i] == '+'):\\r\\n if len(stak) > 0:\\r\\n j = len(stak) - 1\\r\\n while (j >= 0):\\r\\n if ((stak[j] == '+') | (stak[j] == '-')) & ((Line[i] == '+') | (Line[i] == '-')):\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n elif ((stak[j] == '+') | (stak[j] == '-')) & ((Line[i] == '*') | (Line[i] == '/')):\\r\\n break\\r\\n elif ((stak[j] == '*') | (stak[j] == '/')) & ((Line[i] == '*') | (Line[i] == '/')):\\r\\n\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n elif ((stak[j] == '*') | (stak[j] == '/')) & ((Line[i] == '+') | (Line[i] == '-')):\\r\\n\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n elif (stak[j] == 'dup') | (stak[j] == 'lengthof') | (stak[j] == 'type') | (stak[j] == 'sizeof'):\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n else:\\r\\n break\\r\\n j = j - 1\\r\\n stak.append(Line[i])\\r\\n else:\\r\\n expression.append(Line[i])\\r\\n i += 1\\r\\n\\r\\n j = len(stak) - 1\\r\\n while j >= 0:\\r\\n if (stak[j] == '(') or (stak[j] == '['):\\r\\n return False\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n j = j - 1\\r\\n\\r\\n if (expression.__len__() > 0)and(expression!=[\\\"dup\\\"]):\\r\\n infix.append(expression)\\r\\n return infix\",\n \"def evaluate_postfix(list_input):\\n stack_values = []\\n\\n for item in list_input:\\n # debug stuff\\n # print \\\"item\\\", item\\n try:\\n item_value = float(item)\\n has_value = True\\n except ValueError:\\n has_value = False\\n\\n # value, operand, put on stack\\n if has_value:\\n stack_values.append(item_value)\\n has_value = False\\n\\n # operator, pull two operands from stack\\n elif (has_value == False\\n and len(stack_values) >= 2):\\n second_value = stack_values.pop()\\n first_value = stack_values.pop()\\n result = evaluate_op(item,\\n first_value,\\n second_value)\\n stack_values.append(result)\\n # debug stuff\\n # print \\\"midstep\\\", result\\n\\n return stack_values.pop()\",\n \"def calculator(infix_expr):\\n\\n # Assign precedence values to operators\\n prec = {}\\n prec['^'] = 4\\n prec['*'] = 3\\n prec['/'] = 3\\n prec['+'] = 2\\n prec['-'] = 2\\n prec['('] = 1\\n\\n # Instantiate stacks\\n operand_stack = Stack()\\n operator_stack = Stack()\\n\\n try:\\n token_list = infix_expr.split()\\n logging.debug(\\\"token_list = {}\\\".format(token_list))\\n except:\\n sys.exit(1)\\n\\n for token in token_list:\\n logging.debug(\\\"token = {}\\\".format(token))\\n if token in '0123456789':\\n operand_stack.push(int(token))\\n logging.debug(\\\"operand_stack.push = {}\\\".format(token))\\n elif token == '(':\\n operator_stack.push(token)\\n logging.debug(\\\"operator_stack.push = {}\\\".format(token))\\n elif token == ')':\\n logging.debug(\\\"token = {}\\\".format(token))\\n operator_token = operator_stack.pop()\\n logging.debug(\\\"operator_stack.pop = {}\\\".format(operator_token))\\n while operator_token != '(':\\n operand2 = operand_stack.pop()\\n operand1 = operand_stack.pop()\\n result = do_math(operator_token, operand1, operand2)\\n operand_stack.push(result)\\n logging.debug(\\\"while operator_token != '(':\\\\noperand1 = {} | operand2 = {} | token = {} | result = {}\\\".format(\\n operand1, operand2, operator_token, result))\\n operator_token = operator_stack.pop()\\n logging.debug(\\\"new operator_token = {}\\\".format(operator_token))\\n elif token in '^*/+-':\\n while (not operator_stack.isEmpty()) and \\\\\\n (prec[operator_stack.peek()] >= prec[token]):\\n operand2 = operand_stack.pop()\\n operand1 = operand_stack.pop()\\n operator_token = operator_stack.pop()\\n result = do_math(operator_token, operand1, operand2)\\n operand_stack.push(result)\\n logging.debug(\\\"Operator - While:\\\\noperand1 = {} | operand2 = {} | token = {} | result = {}\\\".format(\\n operand1, operand2, operator_token, result))\\n operator_stack.push(token)\\n logging.debug(\\\"operator_stack.push(): {}\\\".format(token))\\n else:\\n logging.debug(\\\"else.... exiting....\\\")\\n sys.exit(1)\\n\\n # Use all remaining operators\\n if not operator_stack.isEmpty():\\n operand2 = operand_stack.pop()\\n operand1 = operand_stack.pop()\\n operator_token = operator_stack.pop()\\n result = do_math(operator_token, operand1, operand2)\\n logging.debug(\\\"Remaining Operators:\\\\noperand1 = {} | operand2 = {} | token = {} | result = {}\\\".format(\\n operand1, operand2, operator_token, result))\\n operand_stack.push(result)\\n\\n return operand_stack.pop()\",\n \"def calculate_infix_expression(cls, expression):\\n\\t\\tlogger.info(f\\\"in the calculate infix expression {expression}\\\")\\n\\t\\telements = expression.split()\\n\\t\\tstack = []\\n\\t\\ttry:\\n\\t\\t\\tfor e in elements:\\n\\t\\t\\t\\tif not e.isdigit() and e != \\\")\\\":\\n\\t\\t\\t\\t\\tstack.append(e)\\n\\t\\t\\t\\tif e.isdigit() and not cls.is_operator(stack[-1]):\\n\\t\\t\\t\\t\\tstack.append(e)\\n\\t\\t\\t\\tif e.isdigit() and cls.is_operator(stack[-1]):\\n\\t\\t\\t\\t\\toperator = stack.pop()\\n\\t\\t\\t\\t\\toperand1 = stack.pop()\\n\\t\\t\\t\\t\\tresult = cls.apply_math_operations(float(operand1), float(e), operator)\\n\\t\\t\\t\\t\\tif stack[-1] == \\\"(\\\":\\n\\t\\t\\t\\t\\t\\tstack.append(str(result))\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\traise Exception(\\\"invalid input\\\")\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\tif e == \\\")\\\":\\n\\t\\t\\t\\t\\tvalue = stack.pop()\\n\\t\\t\\t\\t\\tob = stack.pop()\\n\\t\\t\\t\\t\\tif (ob == \\\"(\\\"):\\n\\t\\t\\t\\t\\t\\tstack.append(str(value))\\n\\t\\t\\t\\t\\telif (cls.is_operator(ob)):\\n\\t\\t\\t\\t\\t\\toperand1 = stack.pop()\\n\\t\\t\\t\\t\\t\\tstack.pop()\\n\\t\\t\\t\\t\\t\\tresult = cls.apply_math_operations(float(operand1), float(value), ob)\\n\\t\\t\\t\\t\\t\\tstack.append(str(result))\\n\\n\\t\\t\\tanswer = float(stack[0])\\n\\t\\t\\tlogger.info(f\\\"the answe is {answer}\\\")\\n\\t\\t\\treturn answer\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise Exception(\\\"Exception from the infix function\\\")\",\n \"def postfixCalc(self,tokens):\\n if len(tokens) == 0:\\n return 0\\n stack = []\\n # while expr is not empty\\n while len(tokens)>0:\\n toke = tokens.pop(0)\\n # if token is a number push it onto the stack\\n if isFloat(toke):\\n stack.append(float(toke))\\n # if token is a special number push it onto the stack\\n elif toke in Calculator.specialNumbers:\\n stack.append(Calculator.specialNumbers[toke])\\n else:\\n # Operators take 2 inputs, functions take 1 input except root which takes 2\\n if toke in Calculator.operators or toke == 'root':\\n n = 2\\n elif toke in Calculator.functions:\\n n = 1\\n # If the length of the stack is less than the required number of operators the user has not \\n # input enough values.\\n if len(stack)<n:\\n return \\\"Too Few Error\\\"\\n # Pop the top n numbers from the stack\\n popedVals = []\\n for i in range(n):\\n popedVals.append(stack.pop())\\n # Evaluate the operator using the number(s) that were popped, and push back onto the stack\\n if n == 2 and toke in Calculator.operators:\\n stack.append(Calculator.operators[toke][0](popedVals[1], popedVals[0]))\\n elif n == 2:\\n stack.append(Calculator.functions[toke](popedVals[1], popedVals[0]))\\n elif n == 1:\\n stack.append(Calculator.functions[toke](popedVals[0]))\\n # If there is more than one value left on the stack the user has input too many values\\n if len(stack) > 1:\\n return \\\"Too Many Error\\\"\\n # Return the value on the stack (should only be 1 value left)\\n return stack[-1]\",\n \"def infix_to_prefix(self, expr: str) -> str:\\n\\n # Reverse expr\\n expr = reversed(expr)\\n\\n # Convert expr to list\\n expr = list(expr)\\n\\n # Reverse all parantheses\\n for i, e in enumerate(expr):\\n if e == \\\"(\\\":\\n expr[i] = \\\")\\\"\\n elif e == \\\")\\\":\\n expr[i] = \\\"(\\\"\\n \\n # Convert expr back to string\\n expr = ''.join(expr)\\n\\n # Convert expr to postfix\\n expr = self.infix_to_postfix(expr)\\n\\n # Reverse expr again\\n expr = reversed(expr)\\n\\n # Convert expr to string again\\n expr = ''.join(expr)\\n\\n # Return expr\\n return expr\",\n \"def evaluatePostfix(postfix, variableList, variableLocation, methodVariables, output):\\n\\n stack = [] # Stack that will contain our pushed operands from the postfix expression\\n immediateCount = 0 # Keeps count of how many immediate values are being expressed (not variables)\\n sourceRegister = 1 # Source register starts at 1: \\\"B\\\", and increments as needed\\n destRegister = 0 # Destination register starts at 0: 'A\\\" and increments as needed\\n immFlag = 0 # Used to determine whether source or destination register holds an immediate\\n\\n for element in postfix:\\n # Evaluate each postfix element one by one to determine appropriate action\\n\\n if sourceRegister > 6 or destRegister > 6:\\n # We cap the total amount of registers used to 7 (0-6)\\n raise ValueError(\\\"Too many operands in formula.\\\")\\n\\n if element in OPERATIONS:\\n # Here, our element is an operator. This means we need to pop the top two values from the stack and\\n # execute the given operation.\\n operand1, operand2 = stack.pop(), stack.pop()\\n\\n if operand1 in variableList:\\n # The operand is in the list of local variables, so we read the value from memory\\n output.write(\\\" MEMR [4] #\\\" + str(variableLocation[operand1]) + \\\" $\\\" + REGISTERS[sourceRegister] + \\\"\\\\n\\\")\\n operand1 = REGISTERS[sourceRegister]\\n\\n elif operand1 in methodVariables:\\n # The operand is in the list of arguments passed into the method. We consult the methodVariables list\\n # to determine the appropriate offset from the stack pointer register S2.\\n output.write(\\\" MOV $A2 $S2\\\\n\\\")\\n output.write(\\\" ADD #\\\" + str(int(methodVariables[operand1][1]) * 4) + \\\" $A2\\\\n\\\")\\n output.write(\\\" MEMR [4] $A2 $\\\" + REGISTERS[sourceRegister] + \\\"\\\\n\\\")\\n operand1 = REGISTERS[sourceRegister]\\n\\n elif operand1 in REGISTER_NAMES:\\n # This is simply a register that was pushed onto the stack. We can keep it as is\\n pass\\n\\n else:\\n # The operand is an immediate value. We test to see if it's a valid integer\\n try:\\n isinstance(operand1, int)\\n immediateCount += 1\\n immFlag = 1\\n except ValueError as e:\\n raise ValueError(\\\"Invalid operand\\\")\\n\\n if operand2 in variableList:\\n # The operand is in the list of local variables, so we read the value from memory\\n output.write(\\\" MEMR [4] #\\\" + str(variableLocation[operand2]) + \\\" $\\\" + REGISTERS[destRegister] + \\\"\\\\n\\\")\\n operand2 = REGISTERS[destRegister]\\n\\n elif operand2 in methodVariables:\\n # The operand is in the list of arguments passed into the method. We consult the methodVariables list\\n # to determine the appropriate offset from the stack pointer register S2.\\n output.write(\\\" MOV $B2 $S2\\\\n\\\")\\n output.write(\\\" ADD #\\\" + str(int(methodVariables[operand2][1]) * 4) + \\\" $B2\\\\n\\\")\\n output.write(\\\" MEMR [4] $B2 $\\\" + REGISTERS[destRegister] + \\\"\\\\n\\\")\\n operand2 = REGISTERS[destRegister]\\n\\n elif operand2 in REGISTER_NAMES:\\n # This is simply a register that was pushed onto the stack. We can keep it as is\\n pass\\n\\n else:\\n # The operand is an immediate value. We test to see if it's a valid integer\\n try:\\n isinstance(operand2, int)\\n immediateCount += 1\\n immFlag = 2\\n except ValueError as e:\\n raise ValueError(\\\"Invalid operand\\\")\\n\\n if immediateCount == 2:\\n # If we have two immediate values, we don't really need to calculate the arithmetic in Capua ASM.\\n # We discretely do the calculations in the background and push the value to the stack. This avoids\\n # unnecessary processing.\\n try:\\n stack.append(int(OPERATIONS[element]['function'](float(operand2), float(operand1))))\\n\\n except ZeroDivisionError:\\n raise ValueError(\\\"Error: Division by zero! - {} {} {}\\\".format(operand2, element, operand1))\\n\\n else:\\n if immediateCount == 1:\\n # only one of the operands was an immediate value. We determine which one is the immediate value,\\n # as the correct instruction output depends on it.\\n if immFlag == 1:\\n output.write(\\\" MOV #\\\" + str(int(operand1)) + \\\" $\\\" + REGISTERS[sourceRegister] + \\\"\\\\n\\\")\\n operand1 = REGISTERS[sourceRegister]\\n\\n elif immFlag == 2:\\n output.write(\\\" MOV #\\\" + str(int(operand2)) + \\\" $\\\" + REGISTERS[destRegister] + \\\"\\\\n\\\")\\n operand2 = REGISTERS[destRegister]\\n\\n else:\\n # No operands were immediate values. We can do the arithmetic operation as is.\\n # We move the source and destination registers up one letter for the next operation\\n sourceRegister += 1\\n destRegister += 1\\n\\n output.write(\\\" \\\" + INSTRUCTIONS[element] + \\\" $\\\" + str(operand1) + \\\" $\\\" + str(operand2) + \\\"\\\\n\\\")\\n stack.append(operand2)\\n\\n immediateCount = 0\\n\\n else:\\n # We have an operand to push onto the stack\\n stack.append(element)\\n\\n if len(stack) != 1:\\n # If the stack has more than or less than one element, the expression is incorrect.\\n raise ValueError(\\\"invalid expression.\\\")\\n\\n # our result is then \\\"saved\\\" into register A. The assignment can now be completed.\\n result = stack.pop()\\n\\n if result in REGISTER_NAMES:\\n # If we just have a register at the bottom of the stack, we assume the result is already in register A\\n pass\\n\\n else:\\n try:\\n isinstance(int(result), int)\\n output.write(\\\" MOV #\\\" + str(result) + \\\" $A\\\\n\\\")\\n except ValueError as e:\\n raise ValueError(\\\"Invalid mathematical expression\\\")\",\n \"def post_fix(expr):\\n if expr[:3] == \\\"8 4\\\":\\n return 54\\n elif expr[:3] == \\\"5 6\\\":\\n return 32\\n elif expr[:3] == \\\"1 1\\\":\\n return 2\\n \\\"\\\"\\\"normal solution\\\"\\\"\\\"\\n lst = expr.split()\\n stack = []\\n for e in lst:\\n if e in \\\"+-*/\\\":\\n b = stack.pop()\\n a = stack.pop()\\n stack.append(str(eval(\\\"{}{}{}\\\".format(a, e, b))))\\n else:\\n stack.append(e)\\n return round(float(stack.pop()))\",\n \"def expression_tree(postfix:str) -> Node:\\n stack = deque()\\n for ch in postfix:\\n if ch not in {'+', '-', '*', '/', '^'}:\\n stack.append(Node(ch))\\n else:\\n middle_node = Node(ch)\\n right_node = stack.pop()\\n left_node = stack.pop()\\n middle_node ._right = right_node\\n middle_node._left = left_node\\n stack.append(middle_node)\\n return stack.pop()\",\n \"def evaluate_post_fix(input_list):\\n\\n stack = Stack()\\n\\n # Iterate over elements\\n for char in input_list:\\n if char in [\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"]:\\n n_2, n_1 = int(stack.pop()), int(stack.pop())\\n result = ops.get(char)(n_1, n_2)\\n stack.push(result)\\n else:\\n stack.push(char)\\n\\n return stack.head.data\",\n \"def resolve_expression(self):\\n stack = list()\\n\\n for element in self._get_postfix_notation():\\n if element in self.OPERATORS: # get two elements from top of stack, push result of operation on stack\\n operand_a = stack.pop()\\n operand_b = stack.pop()\\n value = self._calculate(operand_b, operand_a, element)\\n stack.append(value)\\n else: # push to stack if number\\n stack.append(element)\\n\\n return stack.pop()\",\n \"def preprocess(expression_string: str):\\n return expression_string.replace(\\\"(\\\", \\\"(X\\\")\",\n \"def validate(string):\\n \\n tokens = string.split()\\n \\n # Remembers if the previous token was an operator\\n opflag = True\\n \\n ## Highly inefficient validity checking begins here ##\\n \\n # List of operators as they would appear in the infix expression\\n operators = ['+', '-', '*', '/', '^', 'sqrt']\\n \\n # First and foremost, detect all unary minus signs and mark them as such\\n for i in xrange(len(tokens)):\\n # A unary minus is a minus operator which occurs after another operator\\n # or after an open parenthesis.\\n if tokens[i] in operators or tokens[i] == '(':\\n if opflag:\\n if tokens[i] == '-':\\n tokens[i] = 'u-'\\n # Leave opflag true to allow cascading of unary minuses\\n elif tokens[i] in ['sqrt', '(']:\\n # These operators can be cascaded, so leave them alone\\n # Also, leave opflag true to handle a subsequent u-\\n pass\\n else:\\n # Any other operator must be caught\\n raise ExpressionError('Operators cannot be cascaded!')\\n # We found an operator, but opflag isn't true. Set it.\\n else:\\n opflag = True\\n else:\\n # We found something other than an operator, or a ')'. If opflag is\\n # false, and the token is not ')', then we have two adjacent\\n # variables/numbers. This is also an invalid combination\\n if not opflag and tokens[i] != ')':\\n raise ExpressionError('Adjacent operands with no operator!')\\n # Otherwise, unset opflag\\n else:\\n opflag = False\\n \\n # Check whether parentheses match\\n s = Stack()\\n for token in tokens:\\n if token == '(':\\n s.push(token)\\n elif token == ')':\\n if s.pop() != '(':\\n raise ExpressionError('Parentheses do not match')\\n if not s.is_empty():\\n raise ExpressionError('Parentheses do not match')\\n \\n return tokens\",\n \"def expr(s):\\n if isinstance(s, Expr): return s\\n if isnumber(s): return Expr(s)\\n ## Replace the alternative spellings of operators with canonical spellings\\n s = s.replace('==>', '>>').replace('<==', '<<')\\n s = s.replace('<=>', '%').replace('=/=', '^')\\n ## Replace a symbol or number, such as 'P' with 'Expr(\\\"P\\\")'\\n s = re.sub(r'([a-zA-Z0-9_.]+)', r'Expr(\\\"\\\\1\\\")', s)\\n ## Now eval the string. (A security hole; do not use with an adversary.)\\n return eval(s, {'Expr':Expr})\",\n \"def postfix(self):\\n return self.leftOperand.postfix() + \\\" \\\" + self.rightOperand.postfix() + \\\" \\\" + str(self.operator)\",\n \"def create_nfa_from_postfix(regex: str):\\n\\n nfa_stack = []\\n\\n for char in regex:\\n if char == '.':\\n # to concat two nfas, add an epsilon arrow from every accepting state\\n # of the first to the start state of the second and turn all accepting states\\n # of the first into non accepting states\\n\\n if len(nfa_stack) < 2:\\n raise InvalidRegexException()\\n\\n nfa2 = nfa_stack.pop()\\n nfa1 = nfa_stack.pop()\\n\\n if nfa2.is_one_character_nfa:\\n nfa2_matched_character, nfa2_accept_state = nfa2.start_state.transitions[0]\\n for accept_state in nfa1.accept_states:\\n accept_state.add_transition(nfa2_matched_character, nfa2_accept_state)\\n accept_state.is_accepting = False\\n\\n else:\\n for accept_state in nfa1.accept_states:\\n accept_state.add_transition('eps', nfa2.start_state)\\n accept_state.is_accepting = False\\n\\n\\n nfa1.accept_states = nfa2.accept_states\\n nfa1.is_one_character_nfa = False\\n nfa_stack.append(nfa1)\\n\\n # for garbage collection\\n nfa2.start_state = None\\n nfa2.accept_states = None\\n elif char == '*':\\n # to apply a kleene star to an nfa, add a new start state, which is also an accept state,\\n # to the nfa with an epsilon arrow going into the original start state.\\n # add epsilon arrows from every accept state to the original start state\\n\\n if len(nfa_stack) < 1:\\n raise InvalidRegexException()\\n\\n nfa = nfa_stack.pop()\\n new_start_state = State([('eps', nfa.start_state)], True)\\n for accept_state in nfa.accept_states:\\n accept_state.add_transition('eps', nfa.start_state)\\n\\n nfa.accept_states.append(new_start_state)\\n nfa.start_state = new_start_state\\n nfa.is_one_character_nfa = False\\n nfa_stack.append(nfa)\\n\\n elif char == '+':\\n # TODO try this out on paper\\n # we add epsilon arrows from every accept state to the start state\\n\\n if len(nfa_stack) < 1:\\n raise InvalidRegexException()\\n\\n nfa = nfa_stack.pop()\\n for accept_state in nfa.accept_states:\\n accept_state.add_transition('eps', nfa.start_state)\\n\\n nfa.is_one_character_nfa = False\\n nfa_stack.append(nfa)\\n elif char == '|':\\n # we apply the union operation by adding a new non accepting start state with\\n # epsilon arrows going into the start state of each operand nfa\\n\\n if len(nfa_stack) < 2:\\n raise InvalidRegexException()\\n\\n nfa2 = nfa_stack.pop()\\n nfa1 = nfa_stack.pop()\\n\\n new_start_state = State([('eps', nfa1.start_state), ('eps', nfa2.start_state)], False)\\n\\n nfa1.start_state = new_start_state\\n nfa1.accept_states.extend(nfa2.accept_states)\\n nfa1.is_one_character_nfa = False\\n nfa_stack.append(nfa1)\\n\\n # for garbage collection\\n nfa2.start_state = None\\n nfa2.accept_states = None\\n else:\\n # character from the alphabet\\n accept_state = State([], True)\\n start_state = State([(char, accept_state)], False)\\n nfa_stack.append(NFA(start_state, [accept_state], True))\\n\\n if len(nfa_stack) != 1:\\n raise InvalidRegexException()\\n\\n return nfa_stack[0]\",\n \"def isPostfixOp(tokens):\\n stop = SwiftSupport.getLastOpTokenIndex(tokens)\\n if stop == -1:\\n return False\\n\\n start = tokens.index\\n prevToken = tokens.get(start - 1)\\n nextToken = tokens.get(stop + 1)\\n prevIsWS = SwiftSupport.isLeftOperatorWS(prevToken)\\n nextIsWS = SwiftSupport.isRightOperatorWS(nextToken)\\n result = not prevIsWS and nextIsWS or not prevIsWS and nextToken.type == DOT\\n text = tokens.getText(start, stop)\\n return result\",\n \"def evaluate1(expr):\\n operators = '*/+-'\\n operator_stack = []\\n operand_stack = []\\n\\n def parse_operand(s, i):\\n \\\"\\\"\\\"\\n parse the location of the string until I find an\\n operator\\n parse \\\"12\\\" to 12\\n \\\"12.12\\\" to 12.12\\n returns a float\\n \\\"\\\"\\\"\\n value = ''\\n while (s[i] not in operators):\\n value += s[i]\\n i += 1\\n if s[i] == ')':\\n break\\n return float(value), i-1\\n\\n def do_operation(operand1, operand2, operator):\\n if operator == '+':\\n return operand1 + operand2 \\n elif operator == '*':\\n return operand1 * operand2\\n elif operator == '/':\\n return operand1 / operand2\\n elif operator == '-':\\n return operand1 - operand2\\n\\n i = 0\\n s = expr\\n length = len(s)\\n numbers = '0123456789'\\n while i < length:\\n data = s[i]\\n if data == '(':\\n operand_stack.append(data)\\n elif data in numbers:\\n # parse the operand number and modifies the index i\\n number, i = parse_operand(s, i)\\n operand_stack.append(number)\\n elif data in operators:\\n operator_stack.append(data)\\n elif data is ')':\\n operand2 = operand_stack.pop()\\n operand1 = operand_stack.pop()\\n operator = operator_stack.pop()\\n operand_stack.pop() # remove (\\n operand_stack.append(do_operation(operand1, operand2, operator))\\n i += 1\\n return operand_stack.pop()\",\n \"def postfix_valid(postfix_expr):\\n expr = postfix_expr.split()\\n count = 0\\n if postfix_expr == \\\"\\\":\\n return False\\n for token in expr:\\n if token[0] in '0123456789':\\n count += 1\\n elif token == '~':\\n pass\\n else: # all other binary operators\\n count -= 1\\n if count < 0:\\n return False\\n if count == 1:\\n return True\\n return False\",\n \"def infix_to_tree(self, expr: str, delimeter: str = None, node_name: str = \\\"base\\\") -> Tree:\\n\\n # Convert expr to prefix\\n prefix = self.infix_to_prefix(expr)\\n\\n # Return prefix_to_tree of this expr\\n return self.prefix_to_tree(prefix, delimeter, node_name)\",\n \"def evaluate(self, inputString):\\n # parse string so that it is broken up into the individual pieces\\n parsedString = self.parseInput(inputString)\\n if parsedString == \\\"Error\\\":\\n return \\\"Please enter a valid input!\\\"\\n # convert the input to postfix notation\\n postfix = self.toPostfix(parsedString)\\n if postfix == \\\"Unmatched Error\\\":\\n return \\\"Your input has unmatched brackets!\\\"\\n# print(postfix)\\n # Then perform the calculation and return the answer\\n answer = self.postfixCalc(postfix)\\n if answer == \\\"Too Many Error\\\":\\n return \\\"Your input has too many numbers!\\\"\\n if answer == \\\"Too Few Error\\\":\\n return \\\"Your input has too few numbers!\\\"\\n return round(answer,10)\",\n \"def eval(self, string):\\n tokens = string.split()\\n op1 = int(tokens.pop(0))\\n operator = tokens.pop(0)\\n op2 = int(tokens.pop(0))\\n if operator == '+':\\n return op1 + op2\\n elif operator == '-':\\n return op1 - op2\\n elif operator == '*':\\n return op1 * op2\\n elif operator == '/':\\n return op1 * op2\\n else:\\n raise CalculatorException(\\\"Unknown operator %s\\\" % operator)\",\n \"def parse_operand(s, i):\\n value = ''\\n while (s[i] not in operators):\\n value += s[i]\\n i += 1\\n if s[i] == ')':\\n break\\n return float(value), i-1\",\n \"def infix_to_assembly(formula: str) -> str:\\n asm = \\\"\\\"\\n postfix = infix_to_postfix(formula)\\n for value in postfix:\\n if value == \\\"+\\\":\\n asm += \\\"\\\\npop bx\\\"\\n asm += \\\"\\\\npop ax\\\"\\n asm += \\\"\\\\nadd ax, bx\\\"\\n asm += \\\"\\\\npush ax\\\"\\n elif value == \\\"-\\\":\\n asm += \\\"\\\\npop bx\\\"\\n asm += \\\"\\\\npop ax\\\"\\n asm += \\\"\\\\nsub ax, bx\\\"\\n asm += \\\"\\\\npush ax\\\"\\n elif value == \\\"*\\\":\\n asm += \\\"\\\\npop bx\\\"\\n asm += \\\"\\\\npop ax\\\"\\n asm += \\\"\\\\nmul bx\\\"\\n asm += \\\"\\\\npush ax\\\"\\n elif value == \\\"/\\\":\\n asm += \\\"\\\\nmov dx, 0h\\\"\\n asm += \\\"\\\\npop bx\\\"\\n asm += \\\"\\\\npop ax\\\"\\n asm += \\\"\\\\ndiv bx\\\"\\n asm += \\\"\\\\npush ax\\\"\\n else:\\n # asm += \\\"\\\\npush 0\\\" + value + \\\"h\\\"\\n # the line above is commented out as the emulator has a bug\\n # which pushes immediate 0bbh as 0ffbbh to the stack\\n asm += \\\"\\\\nmov cx, 0\\\" + value + \\\"h\\\"\\n asm += \\\"\\\\npush cx\\\"\\n return asm\",\n \"def infix(self):\\n return \\\"(\\\" + self.leftOperand.infix() + \\\" \\\" + str(self.operator) + \\\" \\\" + self.rightOperand.infix() + \\\")\\\"\",\n \"def eval_expr2(expression):\\n\\n output = []\\n stack = []\\n tokens = list(tokenize(expression))\\n\\n precedence = {\\n \\\"*\\\": 10,\\n \\\"+\\\": 20,\\n }\\n\\n for token in tokens:\\n if token == \\\"(\\\":\\n stack.append(token)\\n elif token == \\\")\\\":\\n while stack and stack[-1] != \\\"(\\\":\\n op = stack.pop(-1)\\n output.append(op)\\n op = stack.pop(-1)\\n assert op == \\\"(\\\"\\n elif token in [\\\"+\\\", \\\"*\\\"]:\\n while (\\n stack\\n and stack[-1] in [\\\"+\\\", \\\"*\\\"]\\n and precedence[token] < precedence[stack[-1]]\\n ):\\n op = stack.pop(-1)\\n output.append(op)\\n\\n stack.append(token)\\n elif isinstance(token, int):\\n output.append(token)\\n else:\\n raise NotImplementedError(token)\\n\\n # print(token, output, stack)\\n\\n while stack and stack[-1] in [\\\"+\\\", \\\"*\\\"]:\\n op = stack.pop(-1)\\n output.append(op)\\n\\n assert not stack\\n\\n return eval_ops(output)\",\n \"def expression_to_tree(expression):\\n\\n # break string into tokens, parsing parenthesized sub-expressions\\n\\n tokens = []\\n current_token = \\\"\\\"\\n in_quotes = False\\n paren_count = 0\\n paren_start = None\\n\\n for i, c in enumerate(expression):\\n\\n if c in QUOTES and paren_count == 0:\\n if in_quotes:\\n tokens.append(current_token + c)\\n current_token = \\\"\\\"\\n in_quotes = False\\n else:\\n in_quotes = True\\n if current_token:\\n tokens.append(current_token)\\n current_token = c\\n elif c == \\\" \\\" and not in_quotes and paren_count == 0:\\n if current_token:\\n tokens.append(current_token)\\n current_token = \\\"\\\"\\n elif c == \\\"(\\\":\\n paren_count += 1\\n if paren_count == 1:\\n paren_start = i\\n elif c == \\\")\\\":\\n paren_count -= 1\\n if paren_count == -1:\\n raise RuntimeError(\\\"Unbalanced right parenthesis in expression\\\")\\n if paren_count == 0:\\n tokens.append(expression_to_tree(expression[paren_start + 1:i]))\\n current_token = \\\"\\\"\\n elif paren_count == 0:\\n current_token += c\\n\\n if current_token:\\n tokens.append(current_token)\\n\\n if paren_count > 0:\\n raise RuntimeError(\\\"Unbalanced left parenthesis in expression\\\")\\n\\n # convert string tokens to ASTNodes\\n\\n nodes = []\\n\\n for token in tokens:\\n\\n if isinstance(token, ASTNode):\\n nodes.append(token)\\n continue\\n\\n # noinspection PyTypeChecker\\n match = QUOTE_PATTERN.match(token)\\n\\n if token.upper() in OPERATOR_TOKENS:\\n nodes.append(OPERATOR_TOKENS[token.upper()]())\\n elif match:\\n nodes.append(TextNode(match.group(\\\"text\\\")))\\n else:\\n raise RuntimeError(\\n \\\"Invalid token `{}` in expression string\\\".format(token))\\n\\n # parse NOT tokens\\n\\n infix_nodes = []\\n\\n nodes.reverse()\\n\\n while nodes:\\n node = nodes.pop()\\n if isinstance(node, NotNode):\\n node.left_child = nodes.pop()\\n infix_nodes.append(node)\\n\\n # set up nodes as a stack\\n\\n infix_nodes.reverse()\\n\\n # shunting-yard\\n\\n operator_stack = []\\n operand_stack = []\\n\\n while infix_nodes:\\n node = infix_nodes.pop()\\n if isinstance(node, OperatorNode):\\n if operator_stack and operator_stack[-1] >= node:\\n operand_stack.append(operator_stack.pop())\\n operator_stack.append(node)\\n else:\\n operand_stack.append(node)\\n\\n operand_stack.extend(operator_stack[::-1])\\n\\n operand_stack.reverse()\\n\\n output_stack = []\\n\\n while operand_stack:\\n node = operand_stack.pop()\\n if isinstance(node, OperatorNode):\\n node.left_child = output_stack.pop()\\n node.right_child = output_stack.pop()\\n output_stack.append(node)\\n\\n return output_stack.pop()\",\n \"def infix2prefix(self, lst):\\n stk = []\\n pre = []\\n for elt in reversed(lst):\\n if elt.isdigit():\\n pre.append(elt)\\n elif elt == \\\")\\\":\\n stk.append(elt)\\n elif elt == \\\"(\\\":\\n while stk and stk[-1] != \\\")\\\":\\n pre.append(stk.pop())\\n stk.pop()\\n else:\\n while stk and self.precedence(elt) < self.precedence(stk[-1]): # < rather than <=\\n pre.append(stk.pop())\\n stk.append(elt)\\n\\n while stk:\\n pre.append(stk.pop())\\n\\n pre.reverse()\\n return pre\",\n \"def evaluateExpression(self, userExpression):\\n return self.evaluatePostfixExp(userExpression)\",\n \"def set_postfix_expression(self, expression, clear_args = True):\\n if expression and type(expression) is not str:\\n raise TypeError('expression should be either string or None or False')\\n if clear_args:\\n self._prefix_kwargs = {}\\n self._postfix_expression = expression\",\n \"def evaluate(expr: str) -> float:\\n\\n expr = ''.join(filter(lambda ch: ch in valid_characters, expr))\\n if not expr:\\n return float('NaN') # raise error instead?\\n\\n # 'Stacks'\\n operators = []\\n operands = []\\n\\n try:\\n for t in tokenizer(expr):\\n\\n if isinstance(t, float):\\n operands.append(t)\\n elif t in openers:\\n operators.append(t)\\n\\n elif t in binary_operators:\\n while operators and precedence[operators[-1]] >= precedence[t]:\\n operands.append(binary_operators[operators.pop()](operands.pop(), operands.pop()))\\n operators.append(t)\\n else:\\n corresponding_opener = openers[closers.index(t)]\\n while (op := operators.pop()) != corresponding_opener:\\n operands.append(binary_operators[op](operands.pop(), operands.pop()))\\n\\n while operators:\\n operands.append(binary_operators[operators.pop()](operands.pop(), operands.pop()))\\n\\n except ArithmeticError as e:\\n raise e\\n except (ValueError, IndexError): # One of the stacks runs out, i.e. invalid expression structure.\\n raise InvalidExpressionError()\\n\\n # assert (len(operands) == 1)\\n return operands.pop()\",\n \"def funcOpExchange(expstr):\\n funcOpDict = expr.getFuncOpDict() \\n for funcstr in funcOpDict:\\n idx = expstr.find(funcstr)\\n if idx >= 0:\\n #if we find a function string at idx\\n if (idx == 0 or not expstr[idx-1].isalpha()) and expstr[idx+len(funcstr)] == '(':\\n fstart = idx\\n fstop = 0\\n rest = expstr[idx:]\\n pdepth = 0\\n for i,c in enumerate(rest):\\n if c == '(':\\n pdepth += 1\\n if c == ')':\\n pdepth -= 1\\n if pdepth == 0:\\n fstop = idx+i+1\\n break\\n start = expstr[:fstart]\\n middle = expstr[fstart:fstop]\\n end = expstr[fstop:]\\n args = ['('+funcOpExchange(exp)+')' for exp in funcargs(middle)]\\n if len(args) == 1:\\n args.append('0')\\n expstr = start+funcOpDict[funcstr].join(args)+funcOpExchange(end)\\n return expstr\",\n \"def Calc_infix(self,infix):\\r\\n\\r\\n stak=[]\\r\\n for i in range(0, len(infix)):\\r\\n if (infix[i] == '+') or (infix[i] == '-') or (infix[i] == '*') or (infix[i] == '/'):\\r\\n if len(stak) > 1:\\r\\n tmp = self.Check_is_valid_data(stak[len(stak) - 1])\\r\\n tmp1 = self.Check_is_valid_data(stak[len(stak) - 2])\\r\\n if (tmp == -1) or (tmp1 == -1):\\r\\n return False\\r\\n if tmp == -2:\\r\\n tmp = stak[len(stak) - 1]\\r\\n elif tmp == -3:\\r\\n tmp = extra_functions.convert_string(stak[len(stak) - 1])\\r\\n\\r\\n else:\\r\\n tmp = tmp[0]\\r\\n\\r\\n if tmp1 == -2:\\r\\n tmp1 = stak[len(stak) - 2]\\r\\n elif tmp1 == -3:\\r\\n\\r\\n tmp1 = extra_functions.convert_string(stak[len(stak) - 2])\\r\\n\\r\\n else:\\r\\n tmp1 = tmp1[0]\\r\\n\\r\\n stak = stak[:-1]\\r\\n if infix[i] == '-':\\r\\n stak[len(stak) - 1] = tmp - tmp1\\r\\n elif infix[i] == '+':\\r\\n stak[len(stak) - 1] = tmp + tmp1\\r\\n elif infix[i] == '*':\\r\\n stak[len(stak) - 1] = tmp * tmp1\\r\\n elif infix[i]== '/':\\r\\n if tmp1 != 0:\\r\\n stak[len(stak) - 1] = int(tmp / tmp1)\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n if (infix[i] == '+') or (infix[i] == '-'):\\r\\n\\r\\n tmp = self.Check_is_valid_data(stak[len(stak) - 1])\\r\\n if tmp == -1:\\r\\n return False\\r\\n elif tmp == -2:\\r\\n tmp = stak[len(stak) - 1]\\r\\n elif tmp == -3:\\r\\n\\r\\n tmp = extra_functions.convert_string(stak[len(stak) - 1])\\r\\n\\r\\n else:\\r\\n tmp = tmp[0]\\r\\n if infix[i] == '-':\\r\\n stak[0] = tmp * -1\\r\\n else:\\r\\n stak[0] = tmp\\r\\n else:\\r\\n return False\\r\\n elif (infix[i] == 'lengthof') or (infix[i]== 'sizeof') or (infix[i] == 'type'):\\r\\n if len(stak) > 0:\\r\\n tmp = self.Check_is_valid_data(stak[len(stak) - 1])\\r\\n if (((tmp == 0) or (tmp == -1) or (tmp == -2) or (tmp == -3)) and ((infix[i]== 'lengthof') or (infix[i] == 'sizeof'))):\\r\\n return False\\r\\n elif ((tmp == 0) or (tmp == -1) or (tmp == -2) or (tmp == -3)) and (infix[i] == 'type'):\\r\\n stak[len(stak) - 1] = 0\\r\\n else:\\r\\n stak = stak[:-1]\\r\\n tmp1 = self.Type(tmp[1])\\r\\n\\r\\n if infix[i] == 'lengthof':\\r\\n stak.append(int(tmp[2] / tmp1))\\r\\n elif infix[i] == 'sizeof':\\r\\n stak.append(tmp[2])\\r\\n else:\\r\\n stak.append(tmp[0])\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n if infix[i] == '?':\\r\\n stak.append(0)\\r\\n else:\\r\\n tmp = self.Check_is_valid_data(infix[i])\\r\\n if self.Data_types.__contains__(infix[i]):\\r\\n stak.append(self.Type(infix[i]))\\r\\n continue\\r\\n if tmp == -1:\\r\\n return False\\r\\n else:\\r\\n stak.append(infix[i])\\r\\n\\r\\n if stak.__len__() == 1:\\r\\n return stak\\r\\n return False\",\n \"def parse(expr, whitelist):\\n # remove all whitespace\\n expr = re.sub(r'\\\\s+', '', expr)\\n\\n seq = []\\n parsed = []\\n for ch in expr:\\n if ch in valid_chars:\\n seq.append(ch)\\n elif ch in operators or ch.isdigit():\\n if seq:\\n sym = process_sequence(seq, whitelist)\\n parsed.append(sym)\\n seq = []\\n\\n # power operator\\n if ch == '^':\\n ch = '**'\\n\\n parsed.append(ch)\\n else:\\n raise ValueError('Illegal character: \\\"{}\\\"'.format(ch))\\n\\n if seq:\\n parsed.append(process_sequence(seq, whitelist))\\n return ''.join(parsed)\",\n \"def eval_with_pFunc(string):\\n return eval(string)\",\n \"def parse_single_op_string(opstring) :\\n ops = {'+' : \\\"plus\\\",\\n '?' : \\\"opt\\\" , \\n '*' : \\\"star\\\"}\\n return '('.join(ops[c] for c in reversed(opstring)) + '('\",\n \"def eval_expr1(expression):\\n\\n output = []\\n stack = []\\n tokens = list(tokenize(expression))\\n\\n for token in tokens:\\n if token == \\\"(\\\":\\n stack.append(token)\\n elif token == \\\")\\\":\\n while stack and stack[-1] != \\\"(\\\":\\n op = stack.pop(-1)\\n output.append(op)\\n op = stack.pop(-1)\\n assert op == \\\"(\\\"\\n elif token in [\\\"+\\\", \\\"*\\\"]:\\n if stack and stack[-1] in [\\\"+\\\", \\\"*\\\"]:\\n op = stack.pop(-1)\\n output.append(op)\\n\\n stack.append(token)\\n elif isinstance(token, int):\\n output.append(token)\\n else:\\n raise NotImplementedError(token)\\n\\n # print(token, output, stack)\\n\\n while stack and stack[-1] in [\\\"+\\\", \\\"*\\\"]:\\n op = stack.pop(-1)\\n output.append(op)\\n\\n assert not stack\\n\\n return eval_ops(output)\",\n \"def simplify(expression):\\n q = []\\n for x in expression:\\n if x != \\\")\\\":\\n q.append(x)\\n else:\\n subexp = \\\"\\\"\\n while q:\\n #print(q)\\n c = q.pop()\\n if c == \\\"(\\\":\\n if len(q) and (q[-1] == \\\"+\\\" or q[-1] == \\\"-\\\"):\\n sign = q.pop()\\n else:\\n sign = \\\"+\\\"\\n subexp = signExp(subexp, sign)\\n q.append(subexp)\\n break\\n else:\\n subexp = c + subexp\\n exp = \\\"\\\"\\n while q:\\n c = q.pop()\\n exp = c + exp\\n \\n if len(exp) and exp[0] != \\\"+\\\" and exp[0] != \\\"-\\\":\\n # Again if the first character is not a 'sign' make it a \\\"+\\\"\\n exp = \\\"+\\\" + exp\\n \\n return exp\",\n \"def validate_expression(str):\\n stack = []\\n pushChars, popChars = \\\"([\\\", \\\")]\\\"\\n for c in str:\\n if c in pushChars:\\n stack.append(c)\\n elif c in popChars:\\n if not len(stack):\\n raise ValidationError('La expresion tiene corchetes \\\\'[ ]\\\\' o parentesis \\\\'( )\\\\' sin cerrar')\\n else:\\n stackTop = stack.pop()\\n balancingBracket = pushChars[popChars.index(c)]\\n if stackTop != balancingBracket:\\n raise ValidationError('La expresion tiene corchetes \\\\'[ ]\\\\' o parentesis \\\\'( )\\\\' sin cerrar')\\n\\n if len(stack):\\n raise ValidationError('La expresion tiene corchetes \\\\'[ ]\\\\' o parentesis \\\\'( )\\\\' sin cerrar')\",\n \"def _parse_expr(self, expr, tokens):\\n tree = []\\n stack = []\\n\\n for tok in tokens:\\n if tok.type == TokenType.Integer:\\n expr = NumericExpression(tok)\\n tree.append(expr)\\n self._add_to_queue(expr)\\n elif tok.type == TokenType.LeftParen:\\n stack.append(tok)\\n elif tok.type == TokenType.RightParen:\\n found = False\\n while len(stack) > 0:\\n top = stack[-1]\\n if top.type != TokenType.LeftParen:\\n op = stack.pop()\\n Parser._reduce_expr(tree, op)\\n self._add_to_queue(op)\\n else:\\n found = True\\n stack.pop()\\n break\\n if not found:\\n raise ParserError(expr, \\\"Mismatched parentheses\\\")\\n else:\\n try:\\n if len(stack) > 0 and Parser._should_pop_op(stack, tok):\\n old = stack.pop()\\n Parser._reduce_expr(tree, old)\\n self._add_to_queue(old)\\n stack.append(tok)\\n except KeyError as e:\\n raise ParserError(expr, str(e))\\n\\n while len(stack) > 0:\\n top = stack[-1]\\n if top.type == TokenType.RightParen or top.type == TokenType.LeftParen:\\n raise ParserError(expr, \\\"Mismatched parentheses\\\")\\n Parser._reduce_expr(tree, top)\\n self._add_to_queue(top)\\n stack.pop()\\n\\n if len(tree) != 1:\\n raise ParserError(expr, \\\"An internal parser error has occurred.\\\")\\n\\n return tree.pop()\",\n \"def replace_operators(self, instr):\\n # change ++, -- to add(1), sub(1)\\n instr = re.sub(r\\\"\\\\+\\\\+\\\", \\\".add(1)\\\", instr)\\n instr = re.sub(r\\\"--\\\", \\\".sub(1)\\\", instr)\\n\\n m1 = re.search(r\\\"[+\\\\-*/]=\\\", instr)\\n result = \\\"\\\"\\n if m1:\\n # handle the string with +=, -=, *=. /=\\n v = instr[: m1.start()].rstrip(\\\" \\\")\\n v1 = v.strip(\\\" \\\")\\n expressions = [v1, m1.group()[: 1], \\\"(\\\", instr[m1.end():].strip().strip(\\\";\\\"), \\\");\\\"]\\n instr = v + \\\"= \\\" + \\\" \\\".join(expressions)\\n\\n # split by !, &&, ||\\n equations = re.split(r\\\"(!|&&|\\\\|\\\\||)\\\", instr)\\n for equation in equations:\\n # split by <=, >=, ==, !=, =\\n expressions = re.split(r\\\"([<>=!]*=)\\\", equation)\\n if len(expressions) == 1:\\n result += equation\\n else:\\n for expression in expressions:\\n if re.search(r\\\"[+\\\\-*/]\\\", expression):\\n # with math operators\\n # 0.exclude ;\\n rc = \\\"\\\"\\n pos = expression.find(';')\\n if pos != -1:\\n rc = expression[pos:]\\n expression = expression[:pos]\\n\\n # 1.exclude independent ( or )\\n lbc = expression.count(\\\"(\\\")\\n rbc = expression.count(\\\")\\\")\\n lc = \\\"\\\"\\n if lbc > rbc:\\n # ( is more than )\\n pos = expression.replace('(', 'X', lbc - rbc - 1).find('(')\\n lc = expression[: pos + 1]\\n expression = expression[pos + 1:]\\n else:\\n if lbc < rbc:\\n # ( is less than )\\n pos = 'X'.join(expression.rsplit(')', rbc - lbc - 1)).rfind(')')\\n rc = expression[pos:] + rc\\n expression = expression[:pos]\\n\\n # 2.change normal notation to RPN, in order to change math operators to SafeMath operators\\n # 3.change RPN to normal notation\\n result += lc + self.rpn_to_nn(self.nn_to_rpn(expression)) + rc\\n else:\\n result += expression\\n\\n return result\",\n \"def stringToSymModWithExpr(string):\\n parser = Parser()\\n string = string.strip() #delete all surrounding whitespaces\\n i = 0\\n symbol = \\\"\\\"\\n # read the symbol\\n while i < len(string) and string[i] != \\\"(\\\":\\n symbol = symbol + string[i]\\n i = i + 1\\n # if parameters are present, get them\\n if i < len(string) and string[i] == \\\"(\\\": # If true then parameters will follow, else we are done\\n i = i + 1 # skip the opening bracket\\n params = string[i:(len(string) - 1)].split(\\\",\\\")\\n for i in range(0,len(params)):\\n params[i] = parser.parse(params[i].strip())\\n return(Module(symbol,params))\\n else:\\n return(Module(symbol,[]))\",\n \"def Xchg(self, String, infix):\\r\\n\\r\\n tmp1 = self.Check_code_operand(infix[0])\\r\\n tmp2 = self.Check_code_operand(infix[1])\\r\\n if (tmp1 == False) or (tmp2 == False):\\r\\n return False\\r\\n if (tmp1[0] == 'imm') or (tmp1[2] == 0) or ((tmp1[0] == 'imm') and (tmp2[0] == 'imm')):\\r\\n if (tmp1[2]==0)and(tmp2[2]!=0)and (tmp2[0] != 'imm'):\\r\\n tmp1[2]=tmp2[2]\\r\\n else:\\r\\n return False\\r\\n if ((tmp1[0] == 'add') and (tmp2[0] == 'add')) or ((tmp1[0] == 'imm') and (tmp2[0] == 'imm')) or ((tmp1[2] != tmp2[2]) and (tmp2[2] != 0)):\\r\\n return False\\r\\n\\r\\n a = 0\\r\\n if (tmp1[0] != 'add'):\\r\\n a = tmp1[1]\\r\\n else:\\r\\n a = self.Get_value_from_memory(tmp1[1], tmp1[2])\\r\\n b = 0\\r\\n if (tmp2[0] != 'add'):\\r\\n b = tmp2[1]\\r\\n else:\\r\\n b = self.Get_value_from_memory(tmp2[1], tmp1[2])\\r\\n\\r\\n if tmp1[0] == 'reg':\\r\\n if len(infix[0][0]) == 3:\\r\\n self.Registers[infix[0][0]] = b\\r\\n else:\\r\\n self.Save_value_in_reg_X(infix[0][0], b)\\r\\n else:\\r\\n if not self.Save_value_in_memory(tmp1[1], b, tmp1[2]):\\r\\n return False\\r\\n\\r\\n if tmp2[0] == 'reg':\\r\\n if len(infix[1][0]) == 3:\\r\\n self.Registers[infix[1][0]] = a\\r\\n else:\\r\\n self.Save_value_in_reg_X(infix[1][0], a)\\r\\n else:\\r\\n if not self.Save_value_in_memory(tmp2[1], a, tmp1[2]):\\r\\n return False\\r\\n return True\",\n \"def postfix_code_line(self, Line):\\r\\n\\r\\n stak = []\\r\\n expression = []\\r\\n infix = []\\r\\n for i in range(0, len(Line)):\\r\\n\\r\\n reg_32 = [\\\"eax\\\", \\\"ebx\\\", \\\"ecx\\\", \\\"edx\\\", \\\"ebp\\\", \\\"esp\\\", \\\"esi\\\", \\\"edi\\\"]\\r\\n reg_16 = [\\\"ax\\\", \\\"bx\\\", \\\"cx\\\", \\\"dx\\\"]\\r\\n if (Line[i] == '(') or (Line[i] == '['):\\r\\n if len(stak) > 0:\\r\\n if (Line[i] == '[') and ((stak[len(stak) - 1] == \\\"lengthof\\\") or (stak[len(stak) - 1] == \\\"sizeof\\\") or (stak[len(stak) - 1] == \\\"type\\\") or (stak[len(stak) - 1] == \\\"offset\\\")):\\r\\n return False\\r\\n if (Line[i] == '(') and ((stak[len(stak) - 1] == \\\"lengthof\\\") or (stak[len(stak) - 1] == \\\"sizeof\\\") or (stak[len(stak) - 1] == \\\"offset\\\")):\\r\\n return False\\r\\n if (len(stak) == 0) and (Line[i] == '(') and (expression.__len__() != 0):\\r\\n return False\\r\\n if expression.__len__() > 0:\\r\\n if (Line[i] == '[') and ((expression[expression.__len__() - 1]) != \\\"ptr\\\") and ((reg_32.__contains__(expression[expression.__len__() - 1]) == False) and (self.Data_variables.__contains__(expression[expression.__len__() - 1]) == False)):\\r\\n return False\\r\\n elif (Line[i] == '[') and ((expression[expression.__len__() - 1]) != \\\"ptr\\\") and ((reg_32.__contains__(expression[expression.__len__() - 1]) == False)):\\r\\n tmp = expression[expression.__len__() - 1]\\r\\n expression[expression.__len__() - 1] = \\\"ptr_X_\\\"\\r\\n expression.append(tmp)\\r\\n elif (Line[i] == '[') and ((expression[expression.__len__() - 1]) == \\\"ptr\\\"):\\r\\n # continue\\r\\n 1 == 1\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n if Line[i] == '[':\\r\\n expression.append(\\\"ptr_\\\")\\r\\n stak.append(Line[i])\\r\\n elif (Line[i] == ')') or (Line[i] == ']'):\\r\\n if len(stak) == 0:\\r\\n return False\\r\\n\\r\\n j = len(stak) - 1\\r\\n while j >= 0:\\r\\n if (stak[j] == '(') and (Line[i] == ')'):\\r\\n break\\r\\n elif (stak[j] == '(') and (Line[i] == ']'):\\r\\n return False\\r\\n elif (stak[j] == '[') and (Line[i] == ')'):\\r\\n return False\\r\\n elif (stak[j] == '[') and (Line[i] == ']'):\\r\\n break\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n j = j - 1\\r\\n if j < 0:\\r\\n break\\r\\n\\r\\n stak = stak[:-1]\\r\\n elif Line[i] == ',':\\r\\n if expression.__len__() == 0:\\r\\n return False\\r\\n if len(stak) != 0:\\r\\n j = len(stak) - 1\\r\\n while j >= 0:\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n j = j - 1\\r\\n if expression.__len__() > 0:\\r\\n infix.append(expression)\\r\\n expression = []\\r\\n elif Line[i][0].isdecimal():\\r\\n if Line[i][len(Line[i]) - 1] == 'h':\\r\\n tmp = extra_functions.is_hexa(Line[i])\\r\\n if not tmp:\\r\\n return False\\r\\n expression.append(tmp)\\r\\n elif Line[i][len(Line[i]) - 1] == 'o':\\r\\n tmp = extra_functions.is_octa(Line[i])\\r\\n if not tmp:\\r\\n return False\\r\\n expression.append(tmp)\\r\\n elif Line[i][len(Line[i]) - 1] == 'b':\\r\\n tmp = extra_functions.is_binary(Line[i])\\r\\n if not tmp:\\r\\n return False\\r\\n expression.append(tmp)\\r\\n elif Line[i][len(Line[i]) - 1] == 'd':\\r\\n tmp = int(Line[i][:-1], 10)\\r\\n expression.append(tmp)\\r\\n elif Line[i].isdecimal():\\r\\n expression.append(int(Line[i]))\\r\\n else:\\r\\n return False\\r\\n elif (Line[i] == \\\"lengthof\\\") or (Line[i] == \\\"sizeof\\\") or (Line[i] == \\\"type\\\") or (Line[i] == \\\"offset\\\"):\\r\\n stak.append(Line[i])\\r\\n else:\\r\\n if (Line[i] == '*') or (Line[i] == '-') or (Line[i] == '/') or (Line[i] == '+'):\\r\\n if len(stak) > 0:\\r\\n j = len(stak) - 1\\r\\n while j >= 0:\\r\\n if ((stak[j] == '+') or (stak[j] == '-')) and ((Line[i] == '+') or (Line[i] == '-')):\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n elif ((stak[j] == '+') or (stak[j] == '-')) and ((Line[i] == '*') or (Line[i] == '/')):\\r\\n break\\r\\n elif ((stak[j] == '*') or (stak[j] == '/')) and ((Line[i] == '*') or (Line[i] == '/')):\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n elif ((stak[j] == '*') or (stak[j] == '/')) and ((Line[i] == '+') or (Line[i] == '-')):\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n elif ((stak[j] == 'dup') or (stak[j] == 'lengthof') or (stak[j] == 'type') or (stak[j] == 'sizeof')):\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n else:\\r\\n break\\r\\n j = j - 1\\r\\n\\r\\n stak.append(Line[i])\\r\\n else:\\r\\n try:\\r\\n if ((Line[i][0] == Line[i][len(Line[i]) - 1]) and (Line[i][0] == '\\\"')) or ((Line[i][0] == Line[i][len(Line[i]) - 1]) and (Line[i][0] == \\\"\\\\'\\\")):\\r\\n tmp = extra_functions.convert_string(Line[i])\\r\\n expression.append(tmp)\\r\\n continue\\r\\n raise Exception(\\\"NotString\\\")\\r\\n except Exception:\\r\\n expression.append(Line[i])\\r\\n\\r\\n j = len(stak) - 1\\r\\n while j >= 0:\\r\\n if (stak[j] == '(') or (stak[j] == '['):\\r\\n return False\\r\\n expression.append(stak[j])\\r\\n stak = stak[:-1]\\r\\n j = j - 1\\r\\n\\r\\n if expression.__len__() > 0:\\r\\n infix.append(expression)\\r\\n\\r\\n return infix\",\n \"def parse(s):\\n return expr.parseString(s, parseAll=True)\",\n \"def sans_parens(s):\\n s = prep_simple_str(s)\\n \\n total = s[0]\\n \\n for c in s[1:]:\\n if c == \\\")\\\":\\n return total\\n elif c == \\\"*\\\":\\n op = lambda a,b: a * b\\n elif c == \\\"+\\\":\\n op = lambda a,b: a + b\\n else:\\n total = op(total, c)\\n return total\",\n \"def arithmetic_eval(expr):\\n tokens = tokenize(expr)\\n\\n operands = []\\n operators = []\\n\\n def apply_operator(op, left, right):\\n if op == '+':\\n return left + right\\n elif op == '-':\\n return left - right\\n elif op == '*':\\n return left * right\\n elif op == '/':\\n return left / right\\n else:\\n raise ValueError('Invalid operator: %s' % op)\\n\\n def pop_operator():\\n right = operands.pop()\\n left = operands.pop()\\n op = operators.pop()\\n result = apply_operator(op, left, right)\\n operands.append(result)\\n\\n for token in tokens:\\n if token.isdigit():\\n operands.append(int(token))\\n elif token == '(':\\n operators.append(token)\\n elif token == ')':\\n while operators[-1] != '(':\\n pop_operator()\\n operators.pop()\\n else:\\n op_precedence = OPERATOR_TO_PRECEDENCE[token]\\n while operators and op_precedence >= OPERATOR_TO_PRECEDENCE[operators[-1]]:\\n pop_operator()\\n operators.append(token)\\n while operators:\\n pop_operator()\\n return operands[0]\",\n \"def parse_input(self, instructions):\\r\\n\\r\\n input_ = instructions\\r\\n input_list = input_.strip().split()\\r\\n\\r\\n if input_list[0] == 'push':\\r\\n self.push(input_list[1])\\r\\n\\r\\n elif input_list[0] == 'pop':\\r\\n self.pop()\\r\\n\\r\\n elif input_list[0] == 'top':\\r\\n self.top()\\r\\n\\r\\n elif input_list[0] == 'replace':\\r\\n self.replace(input_list[1], input_list[2])\\r\\n\\r\\n else:\\r\\n pass\",\n \"def convert(inp, *, expression, precision):\\n try:\\n source, destination = expression.split(' to ')\\n source_value = source.split(' ')[0]\\n float(source_value)\\n except (IndexError, ValueError):\\n return lex.convert.syntax_error\\n try:\\n result = UREG(source).to(destination)\\n except Exception as e:\\n return lex.convert.conversion_error(text=str(e))\\n\\n if precision is False:\\n if '.' not in source_value:\\n sigfig = len(source_value.rstrip('0')) - len(source_value)\\n else:\\n sigfig = len(source_value.split('.')[-1])\\n value = round(result.magnitude, int(sigfig))\\n if value == 0:\\n value = round(result.magnitude, int(sigfig + 1))\\n if sigfig <= 0:\\n value = int(value)\\n elif precision is True:\\n value = result.magnitude\\n else:\\n value = round(result.magnitude, precision)\\n if precision <= 0:\\n value = int(value)\\n\\n return lex.convert.result(\\n source=source,\\n value=value,\\n dimensionality=result.dimensionality,\\n units=result.units)\",\n \"def nn_to_rpn(self, nn):\\n expression = []\\n ops = []\\n\\n # handle +-*/) to add a space before and after the operator\\n nn = nn.strip()\\n nn = re.sub(r\\\"(?P<operator>[+\\\\-*/])\\\", add_spaces_operator, nn)\\n # handle the wrongly replaced \\\" * * \\\"(maybe many spaces around *) to \\\"**\\\"\\n nn = re.sub(r\\\" *\\\\* {2}\\\\* *\\\", \\\"**\\\", nn)\\n nn = re.sub(r\\\"(?P<operator>[(])\\\", add_spaces_left_bracket, nn)\\n nn = re.sub(r\\\"(?P<operator>[)])\\\", add_spaces_right_bracket, nn)\\n items = re.split(r\\\"\\\\s+\\\", nn)\\n for item in items:\\n if item in [\\\"+\\\", \\\"-\\\", \\\"*\\\", \\\"/\\\"]:\\n while len(ops) >= 0:\\n if len(ops) == 0:\\n ops.append(item)\\n break\\n op = ops.pop()\\n if op == \\\"(\\\" or self.ops_rule[item] > self.ops_rule[op]:\\n ops.append(op)\\n ops.append(item)\\n break\\n else:\\n expression.append(op)\\n elif item == \\\"(\\\":\\n ops.append(item)\\n elif item == \\\")\\\":\\n while len(ops) > 0:\\n op = ops.pop()\\n if op == \\\"(\\\":\\n break\\n else:\\n expression.append(op)\\n else:\\n expression.append(item)\\n\\n while len(ops) > 0:\\n expression.append(ops.pop())\\n\\n return expression\",\n \"def evaluate(s:str)->str:\\n t = s.split()\\n res = ''\\n\\n # Check valid operator \\n if t[1] not in ['+','-']:\\n return \\\"Error: Operator must be '+' or '-'.\\\"\\n\\n # check valid number \\n try:\\n t1 = int(t[0])\\n t2 = int(t[2])\\n \\n except ValueError:\\n return \\\"Error: Numbers must only contain digits.\\\"\\n\\n # check if numbers are 4 digits \\n if (t1>9999 or t1 < -9999 or t2>9999 or t2<-9999):\\n return \\\"Error: Numbers cannot be more than four digits.\\\"\\n \\n # addition \\n if t[1] == '+':\\n res = t1 + t2\\n return str(res)\\n \\n # subtraction \\n elif t[1] == '-':\\n res = t1 -t2\\n return str(res)\",\n \"def calculate_expression(expression, debug_output=False):\\n if debug_output:\\n print('{:<14}'.format('Calculating:'), '\\\"', expression, '\\\"', sep='')\\n\\n parser_tree = Calculator.parse_expression(expression)\\n\\n if debug_output:\\n print('{:<14}'.format('Postfix:'), '\\\"', parser_tree.to_string(), '\\\"', sep='')\\n\\n if parser_tree.get_root() is not None:\\n Calculator._simplify(parser_tree, parser_tree.get_root())\\n\\n if debug_output:\\n print('{:<14}'.format('Result:'), '\\\"', parser_tree.to_string(), '\\\"', sep='')\\n print()\\n\\n return parser_tree\",\n \"def main():\\n\\n args = parser.parse_args()\\n try:\\n converter = RPN(args.modules)\\n postfix_expression = converter.convert(args.expr)\\n\\n if args.show_postfix:\\n print(postfix_expression)\\n\\n print(converter.calculate(postfix_expression))\\n except Exception as exception:\\n if str(exception) == 'brackets are not balanced':\\n print('ERROR: ' + str(exception))\\n exit(1)\\n elif str(exception).startswith('No module named'):\\n print('ERROR: ' + str(exception))\\n exit(2)\\n else:\\n print('ERROR: ' + str(exception))\\n exit(3)\",\n \"def parse_expression(str_expression):\\n expression = convert_to_postfix(str_expression)\\n var_count = count_arguments(str_expression)\\n table = init_table(var_count)\\n parsed_table = [[] for i in range(len(table))]\\n\\n for token in expression:\\n for i, row in enumerate(table):\\n if token in string.ascii_uppercase:\\n parsed_table[i].append(row[ord(token) - 65])\\n else:\\n parsed_table[i].append(token)\\n\\n for i, row in enumerate(parsed_table):\\n table[i].append(solve(row))\\n\\n return table\",\n \"def parse(s: str):\\n Term.str = s\\n new_Formula = None\\n while Term.str != '':\\n new_Formula, Term.str = Formula.parse_prefix(Term.str)\\n return new_Formula\\n # Task 7.4.2\",\n \"def clear_and_convert(string_math_expression):\\n # clear the expression of spaces and convert it to the list\\n cleared_expression = list(filter(lambda x: x != ' ', string_math_expression))\\n # check characters in the expression for correctness\\n check_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '-', '*', '/', '(', ')', '.']\\n for element in cleared_expression:\\n if element not in check_list:\\n raise ValueError(f'Houston, we have a problem. Element \\\"{element}\\\" in expression is not correct.')\\n # find multi-digit numbers and create new list num_exp with int\\n num_exp = []\\n number = ''\\n len_cleared_expression = len(cleared_expression)\\n for i, element in enumerate(cleared_expression):\\n if element.isdigit():\\n number += element\\n if i == len_cleared_expression - 1 or not cleared_expression[i+1].isdigit():\\n num_exp.append(int(number))\\n number = ''\\n else:\\n num_exp.append(element)\\n # find float numbers and update list num_exp\\n while '.' in num_exp:\\n i = num_exp.index('.')\\n if (i != 0 and i != len(num_exp) - 1\\n and isinstance(num_exp[i-1], int)\\n and isinstance(num_exp[i+1], int)):\\n float_number = float(str(num_exp[i-1]) + num_exp[i] + str(num_exp[i+1]))\\n num_exp[i+1] = float_number\\n del num_exp[i-1:i+1]\\n else:\\n raise ValueError('Something wrong with \\\".\\\".')\\n # find negative numbers and create new list with negative numbers\\n neg_exp = []\\n excluded_index = None\\n neg_check_list = ['+', '-', '*', '/', '(']\\n len_num_exp = len(num_exp)\\n for i, element in enumerate(num_exp):\\n if element == '-':\\n if i == len_num_exp - 1:\\n raise ValueError('Something wrong with \\\"-\\\".')\\n elif isinstance(num_exp[i+1], int) and (i == 0 or num_exp[i-1] in neg_check_list):\\n n_number = int('-' + str(num_exp[i+1]))\\n neg_exp.append(n_number)\\n excluded_index = i + 1\\n elif isinstance(num_exp[i+1], float) and (i == 0 or num_exp[i-1] in neg_check_list):\\n n_number = float('-' + str(num_exp[i+1]))\\n neg_exp.append(n_number)\\n excluded_index = i + 1\\n else:\\n neg_exp.append(element)\\n elif i != excluded_index:\\n neg_exp.append(element)\\n # find exponent operator and create new list with final converted expression\\n converted_expression = []\\n i = 0\\n len_neg_exp = len(neg_exp)\\n while i < len_neg_exp:\\n if (i == 0 or i == len_neg_exp - 1) and neg_exp[i] == '*':\\n raise ValueError('Something wrong with \\\"*\\\".')\\n elif neg_exp[i] == '*' and neg_exp[i+1] == '*':\\n converted_expression.append('**')\\n i += 2\\n else:\\n converted_expression.append(neg_exp[i])\\n i += 1\\n return converted_expression\",\n \"def _consume_number(infix_string:str,index:int,output:list) -> int:\\r\\n if not (infix_string[index].isdigit() or infix_string[index]==Roll._minus): # handle integers and dice rolls ('XdY')\\r\\n raise ValueError(f\\\"Unexpected value in number token '{infix_string[index]}'\\\")\\r\\n digit = \\\"\\\"\\r\\n has_mandatory_segment=False\\r\\n if infix_string[index]==Roll._minus:\\r\\n sign=1\\r\\n while index<len(infix_string) and infix_string[index]==Roll._minus:\\r\\n sign*=-1\\r\\n index+=1\\r\\n if sign<0:\\r\\n digit+=Roll._minus\\r\\n while index<len(infix_string) and infix_string[index].isdigit():\\r\\n has_mandatory_segment=True\\r\\n digit+=infix_string[index]\\r\\n index+=1\\r\\n if index<len(infix_string) and infix_string[index].lower()==Roll._dice_sep:\\r\\n digit+=infix_string[index].lower()\\r\\n index+=1\\r\\n has_mandatory_segment = False\\r\\n while index<len(infix_string) and infix_string[index].isdigit():\\r\\n has_mandatory_segment=True\\r\\n digit+=infix_string[index]\\r\\n index+=1\\r\\n if not has_mandatory_segment:\\r\\n raise ValueError(\\\"Dice rolls must be supplied with a fixed number of sides (format: 'XdY')\\\")\\r\\n output.append(digit)\\r\\n return index\",\n \"def input_parser(input_string: str) -> str: \\n if is_int(input_string):\\n return input_string\\n #he is int, give back plz.\\n else:\\n try:\\n modified_input: str = input_string.strip()\\n\\n evaluatable_pairs: str = regex_splitter(modified_input)\\n\\n while not (is_int(evaluatable_pairs)):\\n evaluatable_pairs = regex_splitter(evaluatable_pairs)\\n\\n return (evaluatable_pairs)\\n\\n except:\\n raise Exception(\\\"Invalid Input\\\")\",\n \"def evaluate(expr: str) -> int:\\n output = []\\n operators = []\\n for token in expr.replace(\\\" \\\", \\\"\\\"):\\n if token.isdigit(): # we assume that there isn't any number > 9 in expr\\n output.append(int(token))\\n elif token == \\\"(\\\":\\n operators.append(\\\"(\\\")\\n elif token in [\\\")\\\", \\\"+\\\", \\\"*\\\"]:\\n while operators and operators[-1] != \\\"(\\\":\\n op = operators.pop()\\n if op == \\\"+\\\":\\n output.append(output.pop() + output.pop())\\n elif op == \\\"*\\\":\\n output.append(output.pop() * output.pop())\\n if token != \\\")\\\":\\n operators.append(token)\\n elif operators:\\n operators.pop()\\n\\n while operators:\\n op = operators.pop()\\n if op == \\\"+\\\":\\n output.append(output.pop() + output.pop())\\n elif op == \\\"*\\\":\\n output.append(output.pop() * output.pop())\\n\\n return output[0]\",\n \"def parse(self, input_string):\\n print(\\\"----------- Syntax analysis -----------\\\")\\n table = self.generate_table()\\n self.workingStack = ['0']\\n self.inputStack = [char for char in input_string]\\n self.output = []\\n try:\\n print(\\\"--------- Parsing ---------\\\")\\n while len(self.workingStack) != 0:\\n state = int(self.workingStack[-1]) # which dict from parsing table, index of state\\n if len(self.inputStack) > 0:\\n char = self.inputStack.pop(0)\\n else:\\n char = None\\n if table[state]['action'] == 'shift':\\n # Shift operation on the stack\\n if char not in table[state]:\\n raise (Exception(\\\"Syntax error! Expected \\\" + str(table[state]) +\\n \\\"!\\\\nCannot parse shift. Character: \\\" + char))\\n self.workingStack.append(char)\\n self.workingStack.append(table[state][char])\\n elif table[state]['action'] == 'acc':\\n # Accept operation, sequence is accepted\\n if len(self.inputStack) != 0:\\n raise (Exception(\\\"Syntax error! Expected \\\" + str(table[state]) +\\n \\\"!\\\\nCannot parse accept. Character: \\\" + char))\\n self.workingStack.clear()\\n else:\\n # Reduce operation on the stack\\n reduce_state = int(table[state]['action'].split(' ')[1])\\n reduce_production = self.grammar.P[reduce_state]\\n to_remove_from_working_stack = [symbol for symbol in reduce_production[1]]\\n while len(to_remove_from_working_stack) > 0 and len(self.workingStack) > 0:\\n if self.workingStack[-1] == to_remove_from_working_stack[-1]:\\n to_remove_from_working_stack.pop()\\n self.workingStack.pop()\\n if len(to_remove_from_working_stack) != 0:\\n raise (Exception('Syntax error!' +\\n '!\\\\nCannot parse reduce. Character: ', char))\\n self.inputStack.insert(0, char)\\n self.inputStack.insert(0, reduce_production[0])\\n self.output.insert(0, reduce_state)\\n print('Syntax analysis successfully. Yay!')\\n except Exception as ex:\\n raise Exception(ex)\\n print()\\n return self.output\",\n \"def Mul_X(self, String, infix):\\r\\n tmp1 = self.Check_code_operand(infix[0])\\r\\n if (tmp1 == False):\\r\\n return False\\r\\n if (tmp1[0] == 'imm') | (tmp1[2] == 0):\\r\\n return False\\r\\n\\r\\n if String == 'mul':\\r\\n a = 0\\r\\n if (tmp1[0] != 'add'):\\r\\n a = tmp1[1]\\r\\n else:\\r\\n a = self.Get_value_from_memory(tmp1[1], tmp1[2])\\r\\n\\r\\n if tmp1[2] == 1:\\r\\n a = a * self.Get_value_from_reg_X(\\\"al\\\")\\r\\n\\r\\n if a >= pow(2, 2 * 8):\\r\\n a = a & (pow(2, 2 * 8) - 1)\\r\\n self.Save_value_in_reg_X(\\\"ax\\\",a)\\r\\n\\r\\n a = a & (pow(2, 8) - 1)\\r\\n if bool(self.Get_value_from_reg_X(\\\"ah\\\")):\\r\\n self.Flags[\\\"cf\\\"] = 1\\r\\n self.Flags[\\\"of\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"cf\\\"] = 0\\r\\n self.Flags[\\\"of\\\"] = 0\\r\\n\\r\\n if bool(a & pow(2, ( 8) - 1)):\\r\\n self.Flags[\\\"sf\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"sf\\\"] = 0\\r\\n\\r\\n v = a\\r\\n one = 0\\r\\n for i in range(0, 8):\\r\\n if bool(v & 1):\\r\\n one += 1\\r\\n v = v.__rshift__(1)\\r\\n if bool(one & 1):\\r\\n self.Flags[\\\"pf\\\"] = 0\\r\\n else:\\r\\n self.Flags[\\\"pf\\\"] = 1\\r\\n\\r\\n self.Flags[\\\"zf\\\"] = 0\\r\\n elif tmp1[2] == 2:\\r\\n a = a * self.Get_value_from_reg_X(\\\"ax\\\")\\r\\n b=a\\r\\n if a >= pow(2, 2 * 8):\\r\\n a = a & (pow(2, 2 * 8) - 1)\\r\\n self.Save_value_in_reg_X(\\\"ax\\\", a)\\r\\n\\r\\n b = b.__rshift__(16)\\r\\n if b >= pow(2, 2 * 8):\\r\\n b = b & (pow(2, 2 * 8) - 1)\\r\\n self.Save_value_in_reg_X(\\\"dx\\\", b)\\r\\n\\r\\n if bool(self.Get_value_from_reg_X(\\\"dx\\\")):\\r\\n self.Flags[\\\"cf\\\"] = 1\\r\\n self.Flags[\\\"of\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"cf\\\"] = 0\\r\\n self.Flags[\\\"of\\\"] = 0\\r\\n\\r\\n if bool(a & pow(2, (2*8) - 1)):\\r\\n self.Flags[\\\"sf\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"sf\\\"] = 0\\r\\n\\r\\n v = a\\r\\n one = 0\\r\\n for i in range(0, 8):\\r\\n if bool(v & 1):\\r\\n one += 1\\r\\n v = v.__rshift__(1)\\r\\n if bool(one & 1):\\r\\n self.Flags[\\\"pf\\\"] = 0\\r\\n else:\\r\\n self.Flags[\\\"pf\\\"] = 1\\r\\n\\r\\n\\r\\n self.Flags[\\\"zf\\\"] = 0\\r\\n elif tmp1[2] == 4:\\r\\n a = a * self.Registers[\\\"eax\\\"]\\r\\n b = a\\r\\n if a >= pow(2, 4 * 8):\\r\\n a = a & (pow(2, 4 * 8) - 1)\\r\\n self.Registers[\\\"eax\\\"] = a\\r\\n\\r\\n b = b.__rshift__(32)\\r\\n if b >= pow(2, 4 * 8):\\r\\n b = b & (pow(2, 4 * 8) - 1)\\r\\n self.Registers[\\\"edx\\\"] = b\\r\\n if b != 0:\\r\\n self.Flags[\\\"cf\\\"] = 1\\r\\n self.Flags[\\\"of\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"cf\\\"] = 0\\r\\n self.Flags[\\\"of\\\"] = 0\\r\\n\\r\\n if bool(a & pow(2, (4*8) - 1)):\\r\\n self.Flags[\\\"sf\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"sf\\\"] = 0\\r\\n\\r\\n v = a\\r\\n one = 0\\r\\n for i in range(0, 8):\\r\\n if bool(v & 1):\\r\\n one += 1\\r\\n v = v.__rshift__(1)\\r\\n if bool(one & 1):\\r\\n self.Flags[\\\"pf\\\"] = 0\\r\\n else:\\r\\n self.Flags[\\\"pf\\\"] = 1\\r\\n\\r\\n self.Flags[\\\"zf\\\"] = 0\\r\\n elif String == 'imul':\\r\\n a = 0\\r\\n if (tmp1[0] != 'add'):\\r\\n a = tmp1[1]\\r\\n else:\\r\\n a = self.Get_value_from_memory(tmp1[1], tmp1[2])\\r\\n\\r\\n if tmp1[2] == 1:\\r\\n a = a * self.Get_value_from_reg_X(\\\"al\\\")\\r\\n\\r\\n if a >= pow(2, 2 * 8):\\r\\n a = a & (pow(2, 2 * 8) - 1)\\r\\n self.Save_value_in_reg_X(\\\"ax\\\", a)\\r\\n\\r\\n a=a&(pow(2, 8)-1)\\r\\n if bool(a & pow(2, (8) - 1)):\\r\\n self.Flags[\\\"sf\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"sf\\\"] = 0\\r\\n\\r\\n\\r\\n if (bool(self.Get_value_from_reg_X(\\\"ah\\\"))!= bool(self.Flags[\\\"sf\\\"])):\\r\\n self.Flags[\\\"cf\\\"] = 1\\r\\n self.Flags[\\\"of\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"cf\\\"] = 0\\r\\n self.Flags[\\\"of\\\"] = 0\\r\\n\\r\\n\\r\\n\\r\\n v = a\\r\\n one = 0\\r\\n for i in range(0, 8):\\r\\n if bool(v & 1):\\r\\n one += 1\\r\\n v = v.__rshift__(1)\\r\\n if bool(one & 1):\\r\\n self.Flags[\\\"pf\\\"] = 0\\r\\n else:\\r\\n self.Flags[\\\"pf\\\"] = 1\\r\\n\\r\\n\\r\\n self.Flags[\\\"zf\\\"] = 0\\r\\n elif tmp1[2] == 2:\\r\\n\\r\\n a = a * self.Get_value_from_reg_X(\\\"ax\\\")\\r\\n b = a\\r\\n if a >= pow(2, 2 * 8):\\r\\n a = a & (pow(2, 2 * 8) - 1)\\r\\n self.Save_value_in_reg_X(\\\"ax\\\", a)\\r\\n\\r\\n b = b.__rshift__(16)\\r\\n if b >= pow(2, 2 * 8):\\r\\n b = b & (pow(2, 2 * 8) - 1)\\r\\n self.Save_value_in_reg_X(\\\"dx\\\", b)\\r\\n\\r\\n if bool(a & pow(2, (2*8) - 1)):\\r\\n self.Flags[\\\"sf\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"sf\\\"] = 0\\r\\n\\r\\n\\r\\n if (bool(self.Get_value_from_reg_X(\\\"dx\\\")) != bool(self.Flags[\\\"sf\\\"])):\\r\\n self.Flags[\\\"cf\\\"] = 1\\r\\n self.Flags[\\\"of\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"cf\\\"] = 0\\r\\n self.Flags[\\\"of\\\"] = 0\\r\\n\\r\\n\\r\\n\\r\\n v = a\\r\\n one = 0\\r\\n for i in range(0, 8):\\r\\n if bool(v & 1):\\r\\n one += 1\\r\\n v = v.__rshift__(1)\\r\\n if bool(one & 1):\\r\\n self.Flags[\\\"pf\\\"] = 0\\r\\n else:\\r\\n self.Flags[\\\"pf\\\"] = 1\\r\\n\\r\\n\\r\\n self.Flags[\\\"zf\\\"] = 0\\r\\n elif tmp1[2] == 4:\\r\\n a = a * self.Registers[\\\"eax\\\"]\\r\\n b = a\\r\\n if a >= pow(2, 4 * 8):\\r\\n a = a & (pow(2, 4 * 8) - 1)\\r\\n self.Registers[\\\"eax\\\"] = a\\r\\n\\r\\n b = b.__rshift__(32)\\r\\n if b >= pow(2, 4 * 8):\\r\\n b = b & (pow(2, 4 * 8) - 1)\\r\\n self.Registers[\\\"edx\\\"] = b\\r\\n\\r\\n if bool(a & pow(2, (4*8) - 1)):\\r\\n self.Flags[\\\"sf\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"sf\\\"] = 0\\r\\n\\r\\n if (bool(b) != bool(self.Flags[\\\"sf\\\"])):\\r\\n self.Flags[\\\"cf\\\"] = 1\\r\\n self.Flags[\\\"of\\\"] = 1\\r\\n else:\\r\\n self.Flags[\\\"cf\\\"] = 0\\r\\n self.Flags[\\\"of\\\"] = 0\\r\\n\\r\\n\\r\\n\\r\\n v = a\\r\\n one = 0\\r\\n for i in range(0, 8):\\r\\n if bool(v & 1):\\r\\n one += 1\\r\\n v = v.__rshift__(1)\\r\\n if bool(one & 1):\\r\\n self.Flags[\\\"pf\\\"] = 0\\r\\n else:\\r\\n self.Flags[\\\"pf\\\"] = 1\\r\\n\\r\\n\\r\\n self.Flags[\\\"zf\\\"] = 0\\r\\n\\r\\n return True\",\n \"def exeval(expression): \\n if len(expression) <= 3: #Assuming no spaces (\\\" \\\") between each value given in the expression\\n if expression[0] == \\\"+\\\":\\n return float(expression[1]) + float(expression[2])\\n elif expression[0] == \\\"-\\\":\\n return float(expression[1]) - float(expression[2])\\n else:\\n if expression[0] == \\\"+\\\":\\n return float(expression[1]) + exeval(expression[2:])\\n elif expression[0] == \\\"-\\\":\\n return float(expression[1]) - exeval(expression[2:])\",\n \"def calculate_prefix_expression(cls, expression):\\n\\t\\tlogger.info(f\\\"in the calculate prefix expression {expression}\\\")\\n\\t\\telements = expression.split()\\n\\t\\tstack = []\\n\\t\\tfor e in reversed(elements):\\n\\t\\t\\tif e.isdigit():\\n\\t\\t\\t\\tstack.append(int(e))\\n\\t\\t\\telse:\\n\\t\\t\\t\\t# this is an operator\\n\\t\\t\\t\\tif (len(stack) < 2):\\n\\t\\t\\t\\t\\tlogger.info(\\\"invalid input\\\")\\n\\t\\t\\t\\t\\traise Exception(\\\"invalid input\\\")\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\toperand1 = stack.pop()\\n\\t\\t\\t\\t\\toperand2 = stack.pop()\\n\\t\\t\\t\\t\\tif e == \\\"+\\\":\\n\\t\\t\\t\\t\\t\\tresult = operand1 + operand2\\n\\t\\t\\t\\t\\t\\tstack.append(int(result))\\n\\n\\t\\t\\t\\t\\telif e == \\\"-\\\":\\n\\t\\t\\t\\t\\t\\tresult = operand1 - operand2\\n\\t\\t\\t\\t\\t\\tstack.append(int(result))\\n\\n\\t\\t\\t\\t\\telif e == \\\"*\\\":\\n\\t\\t\\t\\t\\t\\tresult = operand1 * operand2\\n\\t\\t\\t\\t\\t\\tstack.append(int(result))\\n\\n\\t\\t\\t\\t\\telif e == \\\"/\\\":\\n\\t\\t\\t\\t\\t\\tresult = operand1 / operand2\\n\\t\\t\\t\\t\\t\\tstack.append(int(result))\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tlogger.exception(\\\"Unrecognized operator\\\")\\n\\t\\t\\t\\t\\t\\traise Exception(\\\"Not a valid operator\\\")\\n\\t\\treturn float(stack[0])\",\n \"def evaluate_RPN(RPN_expression: str):\\n\\tintermediate_results = []\\n\\tfor token in RPN_expression.split(DELIMITER):\\n\\t\\ttry:\\n\\t\\t\\tintermediate_results.append(\\n\\t\\t\\t\\tOPERATORS[token](intermediate_results.pop(),\\n\\t\\t\\t\\t\\t\\t\\t\\tintermediate_results.pop())\\n\\t\\t\\t)\\n\\t\\texcept:\\n\\t\\t\\tintermediate_results.append(int(token))\\n\\treturn intermediate_results[-1]\",\n \"def _reverse_input_einsum_eq(equation: str) -> str:\\n input_output_strings = equation.split('->')\\n assert len(input_output_strings) == 2, \\\"invalid equation\\\"\\n input_strings = input_output_strings[0].split(',')\\n assert len(input_strings) == 2, \\\"invalid equation\\\"\\n equation = input_strings[1] + ',' + input_strings[0] + '->' + input_output_strings[1]\\n return equation\",\n \"def parse(self, expr: str, namespace: str = \\\"base\\\") -> ParseResult:\\n\\n # Convert infix to tree\\n tree = self.infix_to_tree(expr)\\n\\n # Convert tree to list\\n tree_list = self._tree_to_list(tree, tree[0], [[],[]], namespace)\\n\\n if self.optimize:\\n # If we should optimize, do that now\\n tree_list = self.optimize_tree_list(tree_list, namespace)\\n \\n if self.sort:\\n # If we should sort it, do that now as well\\n tree_list = self.sort_tree_list(tree_list, namespace)\\n \\n # Lets generate the result\\n results = ParseResult()\\n\\n # Set the tree list\\n results.tree_list = tree_list[0]\\n\\n # Set the infix value\\n results.infix = expr\\n \\n # Generate and set the prefix value\\n results.prefix = self.infix_to_prefix(expr)\\n\\n # Generate and set the postfix value\\n results.postfix = self.infix_to_postfix(expr)\\n\\n # Set the tree value\\n results.tree = tree\\n # Return results\\n return results\",\n \"def parse_prefix(s):\\n\\n Term.str = replace_string(s) # replace operators with more than one letter to be one letter\\n second = None\\n\\n # if there is a left parentheses it means that we are having an operator that is enclosed by parenthesis\\n if is_left_parenthese(Term.str[0]):\\n Term.eat() # eat left parentheses\\n first, Term.str = Formula.parse_prefix(Term.str) # take first formula of the operator\\n root = switch_root_to_str(Term.str[0]) # take the root\\n Term.eat() # eat the root\\n second, Term.str = Formula.parse_prefix(Term.str) # take second formula of the operator\\n Term.eat() # eat right parentheses\\n\\n # if first letter is a quantifier ('A' or 'E')\\n elif is_quantifier(Term.str[0]):\\n root = Term.str[0] # take the quantifier as root\\n Term.eat() # eat the root ( quantifier)\\n first = Term.get_whole_name() # take the name of the variable\\n Term.eat() # eat the left bracket\\n second, Term.str = Formula.parse_prefix(Term.str) # take the formula\\n Term.eat() # eat the right bracket\\n\\n # if first letter is a relation (starts with capital letter)\\n elif is_relation(Term.str[0]):\\n root = Term.get_whole_name() # take the name of the relation\\n first = []\\n Term.eat() # eat left parentheses\\n\\n # if we didn't find closing parenthesis - than there must be at least one Term inside the parenthesis.\\n # take it.\\n if not is_right_parenthese(Term.str[0]):\\n term_obj, Term.str = Term.parse_prefix(Term.str)\\n first.append(term_obj)\\n\\n # while there is a comma, take the next term\\n while is_comma(Term.str[0]):\\n Term.eat() # eat left parentheses\\n term_obj, Term.str = Term.parse_prefix(Term.str)\\n first.append(term_obj)\\n Term.eat() # eat right parentheses\\n\\n # else , it is an operator\\n else:\\n\\n # if it's an unary operator\\n if is_unary(Term.str[0]):\\n root = Term.str[0]\\n Term.eat()\\n first, Term.str = Formula.parse_prefix(Term.str)\\n\\n # else , the operator is binary or equaluty\\n else:\\n first, Term.str = Term.parse_prefix(Term.str)\\n # if it's a binary operator\\n if is_binary(Term.str[0]):\\n root = Term.str[0:2]\\n Term.eat()\\n\\n # if it's an equal operator\\n else:\\n root = Term.str[0]\\n Term.eat()\\n second, Term.str = Term.parse_prefix(Term.str)\\n returned_formula = Formula(root, first, second)\\n return returned_formula, Term.str\",\n \"def evaluate_expression(in_str):\\n answer = 0\\n # key-value pairs keys are the mathematical expressions and the values are the weights that represents the order of oeprations\\n # higher weights represnts the expressions to evaluate first, while keys with value 0 are not used yet, they are modifiable\\n expression = {\\\"+\\\" : 5, \\\"-\\\" : 5,\\n \\\"/\\\" : 10, \\\"*\\\" : 10,\\n \\\"**\\\" : 15,\\n \\\"%\\\" : 20, \\\"//\\\": 20,\\n \\\"&\\\" : 0, \\\"#\\\" : 0, \\\"!\\\" : 0, \\\"|\\\" : 0, \\\":\\\" : 0, \\\";\\\" : 0, \\\"?\\\": 0\\n }\\n\\n return answer\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82886326","0.8267429","0.8116412","0.80532104","0.79317456","0.7838054","0.78235006","0.7815421","0.77934223","0.7734474","0.7727248","0.7694409","0.7610501","0.7605938","0.75745595","0.75698835","0.74956685","0.7477651","0.7460197","0.7417434","0.73968863","0.7382072","0.73350304","0.7015013","0.69895655","0.6788633","0.67736226","0.6769735","0.6647032","0.65605223","0.64370733","0.6388065","0.6173041","0.6166815","0.61600906","0.61440814","0.60014606","0.5904017","0.59012467","0.5862473","0.5854214","0.56408626","0.56211835","0.56026185","0.54971474","0.54522747","0.5420201","0.539426","0.53523153","0.53419065","0.532793","0.5319582","0.5278003","0.5264761","0.5259503","0.52557385","0.52343583","0.5180136","0.512589","0.50558823","0.5043862","0.50205433","0.4998608","0.4974556","0.49669623","0.49550584","0.49471426","0.4946244","0.49087983","0.48718312","0.48595828","0.48448765","0.4783186","0.47830343","0.4775416","0.4771661","0.47660542","0.4760401","0.47550744","0.4753325","0.47497004","0.47251713","0.47140887","0.4711996","0.469428","0.4675505","0.46719518","0.46664557","0.46554285","0.46519974","0.46484274","0.4639687","0.46145415","0.46059126","0.46058747","0.45949087","0.45640022","0.4560092","0.45370877","0.4536739"],"string":"[\n \"0.82886326\",\n \"0.8267429\",\n \"0.8116412\",\n \"0.80532104\",\n \"0.79317456\",\n \"0.7838054\",\n \"0.78235006\",\n \"0.7815421\",\n \"0.77934223\",\n \"0.7734474\",\n \"0.7727248\",\n \"0.7694409\",\n \"0.7610501\",\n \"0.7605938\",\n \"0.75745595\",\n \"0.75698835\",\n \"0.74956685\",\n \"0.7477651\",\n \"0.7460197\",\n \"0.7417434\",\n \"0.73968863\",\n \"0.7382072\",\n \"0.73350304\",\n \"0.7015013\",\n \"0.69895655\",\n \"0.6788633\",\n \"0.67736226\",\n \"0.6769735\",\n \"0.6647032\",\n \"0.65605223\",\n \"0.64370733\",\n \"0.6388065\",\n \"0.6173041\",\n \"0.6166815\",\n \"0.61600906\",\n \"0.61440814\",\n \"0.60014606\",\n \"0.5904017\",\n \"0.59012467\",\n \"0.5862473\",\n \"0.5854214\",\n \"0.56408626\",\n \"0.56211835\",\n \"0.56026185\",\n \"0.54971474\",\n \"0.54522747\",\n \"0.5420201\",\n \"0.539426\",\n \"0.53523153\",\n \"0.53419065\",\n \"0.532793\",\n \"0.5319582\",\n \"0.5278003\",\n \"0.5264761\",\n \"0.5259503\",\n \"0.52557385\",\n \"0.52343583\",\n \"0.5180136\",\n \"0.512589\",\n \"0.50558823\",\n \"0.5043862\",\n \"0.50205433\",\n \"0.4998608\",\n \"0.4974556\",\n \"0.49669623\",\n \"0.49550584\",\n \"0.49471426\",\n \"0.4946244\",\n \"0.49087983\",\n \"0.48718312\",\n \"0.48595828\",\n \"0.48448765\",\n \"0.4783186\",\n \"0.47830343\",\n \"0.4775416\",\n \"0.4771661\",\n \"0.47660542\",\n \"0.4760401\",\n \"0.47550744\",\n \"0.4753325\",\n \"0.47497004\",\n \"0.47251713\",\n \"0.47140887\",\n \"0.4711996\",\n \"0.469428\",\n \"0.4675505\",\n \"0.46719518\",\n \"0.46664557\",\n \"0.46554285\",\n \"0.46519974\",\n \"0.46484274\",\n \"0.4639687\",\n \"0.46145415\",\n \"0.46059126\",\n \"0.46058747\",\n \"0.45949087\",\n \"0.45640022\",\n \"0.4560092\",\n \"0.45370877\",\n \"0.4536739\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8161909"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":84887,"cells":{"query":{"kind":"string","value":"Take in as input a list The function multiply_list() will multiply all of the numbers in the list. If any item in the list is invalid return False."},"document":{"kind":"string","value":"def multiply_list(input):\n result = 1\n #if there is no numbers in list return False\n if not input:\n return False\n #if the list contains strings or 0 return False\n else: \n for x in input:\n if type(x) == str or x == 0:\n return False \n else:\n result = result*x\n return result"},"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 test_mul():\n l = [1, 2, 3, 4]\n assert s7.mul(*l) == 1 * 2 * 3 * 4\n assert s7.mul(10, 20) == 200\n assert s7.mul(1.0, 2.0, 100.0) == 200.0","def multiply_list(lst):\n if lst == []:\n return 1\n else:\n return lst[0] * multiply_list(lst[1:])","def listMul(l):\n \n # initialization for variable prod\n prod = 1.0\n \n for element in l:\n prod *= element # a *= b is equivalent to a = a * b\n \n return prod","def MyMUlt( l ):\n\n #checking if arg is a list\n if isinstance(l, list):\n\n #myltiplying all numbs\n result = 1\n\n for numb in l:\n result = result * numb\n\n return result\n\n else:\n return \"Argument is not a list\"","def test_list_int(self):\n result = mul(2, 4)\n self.assertEqual(result, 8)","def multiplication_total_of(num_list):","def multiply(numbers):\n prod = 1\n for i in numbers:\n prod = prod*i\n return prod","def product(mylist):\r\n temp = 1\r\n for num in mylist:\r\n temp *= num\r\n return temp","def list_product(lst):\n prod = 1\n for val in lst:\n prod *= val\n return prod","def prod(lst):\n res = 1.\n for x in lst: res *= x\n return res","def multiply(numbers):\n \n result = numbers[0]\n for n in numbers[1:]:\n result = n * result\n return result","def main():\n \n # test list\n lis = [10, 20, 30]\n \n # product of the elements in the list\n product = listMul(lis)\n \n # Print section\n print(\"List = {} - Product of its elements = {}\".format(lis, product))","def prod(lst):\n return reduce(mul, lst, 1)","def mult_numbers(numbers):\n product = 1\n for number in numbers:\n product = product * number\n\n return product","def multiply_matrices(list):\n # Section 1: Start matrix product using 1st matrix in list\n matrix_product = list[0]\n\n # Section 2: Loop thru list to create product\n for matrix in list[1:]:\n matrix_product = matrix_multiply(matrix_product, matrix)\n\n return matrix_product","def prod(lst):\n if len(lst) == 0:\n return 0\n x = lst[0]\n for v in lst[1:]:\n x *= v\n return x","def prod(lst):\n if len(lst) == 0:\n return 0\n x = lst[0]\n for v in lst[1:]:\n x *= v\n return x","def multiply_ints(list_of_ints):\n\n products_of_all_ints_except_ind = [None] * len(list_of_ints)\n postproduct = 1\n\n for idx in xrange(len(list_of_ints) - 1, -1, -1):\n products_of_all_ints_except_ind[idx] = postproduct\n postproduct *= list_of_ints[idx]\n\n preproduct = 1\n \n for idx, num in enumerate(list_of_ints):\n products_of_all_ints_except_ind[idx] *= preproduct\n preproduct *= num\n\n return products_of_all_ints_except_ind","def product(numbers):\n p = 1\n for x in numbers:\n p *= x\n return p","def product(numbers):\n p = 1\n for x in numbers:\n p *= x\n return p","def check_list(self,list_input):\n if not isinstance(list_input,list):\n raise ValueError('input is not in list type')\n for i in list_input:\n if isinstance(i,list) and len(i) != 0:\n for j in i:\n if not isinstance(j,(float,int)):\n print(j)\n raise ValueError('cannot convert')\n else:\n print(i)\n raise ValueError('wrong defined')","def product(nbs):\n try:\n prod = 0\n for nb in nbs:\n prod *= float(nb)\n except TypeError:\n print(\"Hmmm, I guess you haven't only entered valid numbers\")\n return\n print(\"And the product is.... : {0} \".format(prod))","def __mul__(self,l):\r\n\t\t\r\n\t\t# multiply\r\n\t\tm = self.multiply(l)\r\n\t\t\r\n\t\treturn m","def __multiply(self, listA, listB):\n if len(listA) != len(listB):\n raise ValueError('List should be of same lengths')\n\n return [listA[i]*listB[i] for i in range(len(listA))]","def prod(L):\n res = 1\n for e in L:\n res *= e\n return res","def prod(l):\n r = 1\n for x in l:\n r *= x\n return r","def check_if_number(list):\n for item in list:\n try:\n float(item)\n except ValueError as e:\n print WrongTypePointError(item)\n sys.exit()","def scalar_mult(scalar, lista):\n return [scalar * element for element in lista]","def list_validate_number(lst, target):\n elements = set(lst)\n for element in elements:\n if target - element in elements:\n return True\n return False","def product(it):\n prod = 1\n for x in it:\n prod *= x\n return prod","def checkInput(Matrix,List):\r\n \r\n if type(Matrix) != list or type(List) != list:\r\n \r\n raise RuntimeError('malformed')\r\n for k in Matrix:\r\n if type(k) != list:\r\n \r\n raise RuntimeError('malformed')\r\n if len(k) != len(List):\r\n \r\n raise RuntimeError('malformed')\r\n for j in k:\r\n if type(j) != int and type(j) != float:\r\n \r\n raise RuntimeError('malformed')\r\n if j > 30:\r\n \r\n raise RuntimeError('malformed')\r\n for p in List:\r\n if type(p) != str:\r\n \r\n raise RuntimeError('malformed')\r\n\r\n if len(Matrix) != len(List):\r\n \r\n raise RuntimeError('malformed')\r\n return","def is_multiple(n, m):\n # Check the given numbers are integer\n if m%n:\n # print('%d is NOT a multiple of %d' % (n, m))\n return False\n # print('%d is a multiple of %d' % (n, m))\n return True","def multiply(numbers):\n counter = 0\n for num in numbers:\n counter *= num\n return counter","def test_multiply(self):\n self.assertEqual(work_file.multiply(10, 5), 50)\n self.assertEqual(work_file.multiply(-1, 1), -1)\n self.assertEqual(work_file.multiply(-1, -1), 1)","def matrixElementMultiply (self, value, list):\n\t\tnumRows = len(list)\n\t\tnumCols = len(list[0])\n\t\n\t\treturn [[value * list[j][i] for i in range(numCols)] for j in range(numRows)]","def validate(s):\n\n # base case: square is 1 or 0\n if s == 1 or s == 0:\n return True\n\n # list of length 4\n if isinstance(s, list) and len(s) == 4:\n\n # idea one: fail fast\n for i in s:\n if not validate(i):\n return False\n return True\n\n # idea 2: \"and\" the results ALSO fail fast\n # return (validate(s[0]) and \n # validate(s[1]) and \n # validate(s[2]) and \n # validate(s[3]))\n # OR\n # return all([validate(i) for i in s])\n\n # idea 3: multiply the results: will not return boolean\n # return (validate(s[0]) * \n # validate(s[1]) * \n # validate(s[2]) * \n # validate(s[3]))\n\n # not one of our numbers or list of length 4\n # another base case\n return False","def multiplication(self):\r\n global answer\r\n while True:\r\n try:\r\n easy_random1 = int(random.choice(string.digits))\r\n easy_random2 = int(random.choice(string.digits))\r\n easy_random3 = int(random.choice(string.digits))\r\n easy_random4 = int(random.choice(string.digits))\r\n print(f\"{easy_random1} * {easy_random2} * {easy_random3} * {easy_random4} = ?\")\r\n real_answer = easy_random1 * easy_random2 * easy_random3 * easy_random4\r\n answer = input(\"Enter answer: \")\r\n if answer.lower() == \"stop\":\r\n print(\"okay\")\r\n if int(answer) == real_answer:\r\n print(\"CORRECT ANSWER\")\r\n else:\r\n print(\"WRONG ANSWER\")\r\n print(f\"the answer is {real_answer} sorry! try again\")\r\n except ValueError:\r\n return f'\"{answer}\" is not a valid number, only the string stop is allowed'","def isList(memoryManager, paramsList):\n if isEmptyList(paramsList):\n return [1.0]\n A = paramsList[0]\n if validateList(A):\n return [0.0] if len(A) <= 1 else [1.0]\n return [0.0]","def square_nums(number_list):","def add_product_list(self, prod_list):\n success = True\n for item in prod_list:\n success &= self.add(item[0], item[1], item[2])\n if success: print('add_product_list: succeeded')\n else: print('add_product_list: failed')\n \n return success","def do_multiply(self, mul: int, *nums: int):\n for num in nums:\n print(mul * num, file=self.stdout)","def prod(l):\n return reduce(lambda a, b: a*b, l)","def test_if_it_accepts_lists(self):\n with self.assertRaises(TypeError):\n prime_numbers(56.58)","def test_list_type(self):\n\n expected = TypeError\n input_ = []\n with self.assertRaises(expected):\n math.factorial(input_)","def test_many_positive(self):\n\n # pairs (input, result)\n pairs = [\n ([3, 4, 6, 8, 0], 192),\n ([1, -1, 1, -1, 1], 1),\n ([0, 0, 0, 0, -1], 0),\n ([6, 5, 4, 3, 2], 120),\n ([6, 5, 4, 3, -2], 120),\n ([6, 5, 4, -3, -2], 120),\n ([-6, -5, 4, 3, 0], 120),\n ([-6, 5, 4, 3, 2], 60),\n ([5, 6, -100, -1, 10], 1000)\n ]\n\n for lst, result in pairs:\n self.assertEqual(max_triple_mul(lst), result)","def multiply(*args):\n #convert args to floats so we can do the maths\n values = list(args)\n for x in range(len(values)):\n values[x] = float(values[x])\n product = str(ft.reduce(oper.mul,values))\n\n return product","def brute_multiply(numbers):\n result = []\n for a in range(len(numbers)):\n product = 1\n for index, b in enumerate(numbers):\n if index != a:\n product *= b\n result.append(product)\n return result","def multiply(t):\n return mul(*t)","def are_all_numbers(values: List[Union[str, int, float]]):\n for value in values:\n if not is_number(value):\n return False\n return True","def multiply(self,*datas):\n\t\tresult = 1\n\t\tfor data in datas:\n\t\t\tresult *=data\n\t\treturn result","def _check_nested_floats(thelist):\n result = True\n for item in thelist:\n if type(item) in [list,tuple]:\n result = result and _check_nested_floats(item)\n else:\n result = result and type(item) in [int,float]\n return result","def multiply_numbers(first_number, second_number):","def is_multiple(m, n):\r\n return is_factor(n, m)","def _mul_op(value, sample_args, rationals_allowed):\n if sample_args.count >= 3:\n _, op_args, sample_args = _div_op(value, sample_args, rationals_allowed)\n op_args = [op_args[0], sympy.Integer(1) / op_args[1]]\n elif sample_args.count == 1:\n entropy, sample_args = sample_args.peel()\n assert _entropy_of_factor_split(value) >= entropy\n op_args = _split_factors(value)\n else:\n assert sample_args.count == 2\n entropy, sample_args = sample_args.peel()\n numer = sympy.numer(value)\n denom = sympy.denom(value)\n p1, p2 = _split_factors(numer)\n entropy -= _entropy_of_factor_split(numer)\n mult = number.integer(entropy, signed=True, min_abs=1, coprime_to=p1)\n op_args = [p1 / (mult * denom), p2 * mult]\n\n if random.choice([False, True]):\n op_args = list(reversed(op_args))\n\n return ops.Mul, op_args, sample_args","def test_multiplying(self):\n multiplier = Multiplier()\n\n for i in range(-10, 10):\n for j in range(-10, 10):\n self.assertEqual(i*j, multiplier.calc(j, i))","def test_list(self):\n self.assertEqual(max_integer([1, 5, -7, 6, -4 , 10]), 10)\n self.assertEqual(max_integer([0]), 0)\n self.assertEqual(max_integer([0, 3 + 2, 7, 9 * 8, 35, 12]), 72)","def mul_numbers(a: int, b: int) -> int:\n return a * b","def multiply(*args):\n body = ['<h1>Multiplication Calculator</h1>']\n product = reduce(lambda x,y: x * y, map(int,args))\n body.append(f'Total equals: {product}')\n return '\\n'.join(body)","def is_multiplicative(*args):\n return _ida_hexrays.is_multiplicative(*args)","def multiplied(*values):\n values = [_normalize(v) for v in values]\n def _product(it):\n p = 1\n for n in it:\n p *= n\n return p\n for v in zip(*values):\n yield _product(v)","def test_multiplication():\n assert calculator.multiply(7, 3) == 21\n assert calculator.multiply(7.0, 3.0) == 21.0\n assert calculator.multiply(7, -3) == -21\n assert calculator.multiply(7.0, -3.0) == -21.0","def test_micrometers_validate_list(self):\n micrometer = inches_to.micrometers([1.0, 2.0, 3.0, 4.0])\n comparison = np.array([2.54e4, 2*2.54e4, 3*2.54e4, 4*2.54e4])\n\n try:\n for i in range(len(comparison)):\n self.assertTrue(math.isclose(micrometer[i], comparison[i], rel_tol=self.accepted_error))\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.passed))\n except AssertionError:\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.failed))","def empty_list(input_list):\n for item in input_list:\n if not isinstance(item, list) or not empty_list(item):\n return False\n return True","def test_cross_multiply_from_list():\n array_1 = np.ones((1, 3)).tolist()\n array_out = utils.cross_multiply_array(array_1, axis=1)\n assert (1, 3, 3) == array_out.shape","def mul(a: int, b: int, c: int, memory: List) -> NoReturn:\n memory[c] = memory[a] * memory[b]","def check_correct_numbers(puzzle_size: int, puzzle_list: list) -> None:\n for number in range(puzzle_size * puzzle_size):\n if number not in puzzle_list:\n raise ParsingError(\"Puzzle does not contain expected numbers.\")","def square(numbers):\n\n # Needs only one argument\n newlist = []\n for num in numbers:\n newlist.append(num*num)\n return newlist","def multiplier(*args):\n if not args:\n return 0\n product = args[0]\n for a in args[1:]:\n print('a is: ',a)\n product *= a\n return product,args","def test_pauls_misery(list, result):\n from pauls_misery import paul\n assert paul(list) == result","def validate_requirements(self, list_of_animals):\n if not any(\n [\n validation_func(list_of_animals)\n for validation_func in [\n self.exceeds_capacity,\n self.exceeds_space_required,\n self.incompatible_animals,\n ]\n ]\n ):\n return True","def test_if_it_accepts_lists(self):\n with self.assertRaises(TypeError):\n prime_numbers([])","def is_valid_integer_list(any_list):\n list_object = json.loads(any_list)\n return not any(not is_valid_integer(str(listing_id)) for listing_id in\n list_object)","def test_float_list(self):\n f_list = [3.2, 5.6, 7.3, 9.9, 12.7]\n self.assertEqual(max_integer(f_list), 12.7)","def toate_elementele_prime(lst):\n for x in lst:\n if nr_prim(x) is False:\n return False\n return True","def validate_list(types,val,allowed,tname):\n if not len(types): return TYPE_MISMATCH\n if type(val) not in TYPES[tname]: raise Exception('unknown type')\n for v in val:\n result=VALIDATORS[types[-1]](types[:-1],v,allowed,types[-1])\n if not result: return result\n return True","def _validate_internal_value_list(self, value: Any):\n # Make sure the value is a list\n if not isinstance(value, list):\n raise TypeError(f\"Value must be a list\")\n\n # Make sure the list has the correct number of values in it\n length = len(value)\n if isinstance(self._nargs, int):\n if self._action == \"store\":\n if length != self._nargs:\n raise ValueError(f\"Requires list of length {self._nargs}\")\n else:\n if length == 0 or length % self._nargs != 0:\n raise ValueError(f\"Requires list of length a multiple of {self._nargs}\")\n elif self._nargs == \"+\":\n if length == 0:\n raise ValueError(f\"Requires at least one item\")\n\n if any(not isinstance(element, self._type) for element in value):\n raise TypeError(f\"All values must be of the declared type {self._type.__name__}\")","def test_miles_validate_list(self):\n mile = inches_to.miles([1.0, 2.0, 3.0, 4.0])\n comparison = np.array([1.57828e-5, 2*1.57828e-5, 3*1.57828e-5, 4*1.57828e-5])\n\n try:\n for i in range(len(comparison)):\n self.assertTrue(math.isclose(mile[i], comparison[i], rel_tol=self.accepted_error))\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.passed))\n except AssertionError:\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.failed))","def mul(a,b):\n return [a[0]*b[0],a[1]*b[1],a[2]*b[2],1.0]","def kkMul(*args):\n if (None in args):\n return None\n product = 1\n for arg in args:\n product *= arg\n return product","def double_nums(num_list):","def multiply(value, multiplier):\n return value*multiplier","def product(*nums):\n\treturn reduce((lambda x, y: x * y), nums)","def test_one_number_list(self):\n lst = [98]\n self.assertEqual(max_integer(lst), 98)","def eval_list(self, value):\n\n okay = True\n count = 0\n for v in value.elts:\n if not self.eval_value(v):\n okay = False\n break\n count += 1\n return okay","def prod(arg):\n ret = 1\n for i in range(0, len(arg)):\n ret = ret * arg[i]\n return ret","def simplify_mul(tree):\r\n neg, inputs = tree\r\n if isinstance(inputs, list):\r\n # Recurse through inputs.\r\n s_inputs = []\r\n for s_i in imap(simplify_mul, inputs):\r\n if s_i[1] is None:\r\n # Multiplication by +/-1.\r\n neg ^= s_i[0]\r\n else:\r\n s_inputs.append(s_i)\r\n if not s_inputs:\r\n # The multiplication is empty.\r\n rval = [neg, None]\r\n elif len(s_inputs) == 1:\r\n # The multiplication has a single input.\r\n s_inputs[0][0] ^= neg\r\n rval = s_inputs[0]\r\n else:\r\n rval = [neg, s_inputs]\r\n else:\r\n rval = tree\r\n #print 'simplify_mul: %s -> %s' % (tree, rval)\r\n return rval","def test_simtk_list_of_quantities_to_pint():\n list_of_quantities = [val * omm_unit.meter for val in range(10)]\n quantity_list = omm_unit.meter * [val for val in range(10)]\n\n assert list_of_quantities != quantity_list\n assert all(simtk_to_pint(list_of_quantities) == simtk_to_pint(quantity_list))","def __is_multiple(self, current):\n for prime in self.primes:\n if current % prime == 0:\n return True\n return False","def lsummult (list1,list2):\r\n if len(list1) <> len(list2):\r\n raise ValueError, \"Lists not equal length in summult.\"\r\n s = 0\r\n for item1,item2 in pstats.abut(list1,list2):\r\n s = s + item1*item2\r\n return s","def test_millimeters_validate_list(self):\n millimeter = inches_to.millimeters([1.0, 2.0, 3.0, 4.0])\n comparison = np.array([25.4, 2*25.4, 3*25.4, 4*25.4])\n\n try:\n for i in range(len(comparison)):\n self.assertTrue(math.isclose(millimeter[i], comparison[i], rel_tol=self.accepted_error))\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.passed))\n except AssertionError:\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.failed))","def _perform_metrics_update_list(self, examples_list: List[Any]) -> None:\n try:\n self._perform_metrics_update_fn(*[examples_list])\n\n except (RuntimeError, TypeError, ValueError,\n tf.errors.OpError) as exception:\n general_util.reraise_augmented(exception,\n 'raw_input = %s' % examples_list)","def multiply_nums(n1, n2):\n\n result = n1 * n2\n return result","def test_calculator_multiply():\n assert Calculator.multiply_numbers(1, 2) == 2","def multiply(num1, num2):\n return num1 * num2","def isProductOfNumbersInSeq(number, seq1):\n\tseq = deepcopy(seq1)\n\n\twhile number != 1:\t\n\t\tif not seq:\n\t\t\treturn False\n\n\t\tnext_divisor = min(seq)\n\n\t\tif not number % next_divisor:\n\t\t\tnumber /= next_divisor\n\t\t\n\t\tseq.remove(next_divisor)\n\n\treturn True","def list_check(lst):\n for item in lst:\n if type(item) != list:\n return False\n return True","def div_by(n, list_of_num):\n for num in list_of_num:\n if not n % num:\n return True\n return False","def multiply(value, arg):\n return value * arg","def test_our_multiply(self):\n\n self.assertEqual(self.our_module.multiply(3, 4), 12)","def multiply(num1, num2):\n return num1 * num2"],"string":"[\n \"def test_mul():\\n l = [1, 2, 3, 4]\\n assert s7.mul(*l) == 1 * 2 * 3 * 4\\n assert s7.mul(10, 20) == 200\\n assert s7.mul(1.0, 2.0, 100.0) == 200.0\",\n \"def multiply_list(lst):\\n if lst == []:\\n return 1\\n else:\\n return lst[0] * multiply_list(lst[1:])\",\n \"def listMul(l):\\n \\n # initialization for variable prod\\n prod = 1.0\\n \\n for element in l:\\n prod *= element # a *= b is equivalent to a = a * b\\n \\n return prod\",\n \"def MyMUlt( l ):\\n\\n #checking if arg is a list\\n if isinstance(l, list):\\n\\n #myltiplying all numbs\\n result = 1\\n\\n for numb in l:\\n result = result * numb\\n\\n return result\\n\\n else:\\n return \\\"Argument is not a list\\\"\",\n \"def test_list_int(self):\\n result = mul(2, 4)\\n self.assertEqual(result, 8)\",\n \"def multiplication_total_of(num_list):\",\n \"def multiply(numbers):\\n prod = 1\\n for i in numbers:\\n prod = prod*i\\n return prod\",\n \"def product(mylist):\\r\\n temp = 1\\r\\n for num in mylist:\\r\\n temp *= num\\r\\n return temp\",\n \"def list_product(lst):\\n prod = 1\\n for val in lst:\\n prod *= val\\n return prod\",\n \"def prod(lst):\\n res = 1.\\n for x in lst: res *= x\\n return res\",\n \"def multiply(numbers):\\n \\n result = numbers[0]\\n for n in numbers[1:]:\\n result = n * result\\n return result\",\n \"def main():\\n \\n # test list\\n lis = [10, 20, 30]\\n \\n # product of the elements in the list\\n product = listMul(lis)\\n \\n # Print section\\n print(\\\"List = {} - Product of its elements = {}\\\".format(lis, product))\",\n \"def prod(lst):\\n return reduce(mul, lst, 1)\",\n \"def mult_numbers(numbers):\\n product = 1\\n for number in numbers:\\n product = product * number\\n\\n return product\",\n \"def multiply_matrices(list):\\n # Section 1: Start matrix product using 1st matrix in list\\n matrix_product = list[0]\\n\\n # Section 2: Loop thru list to create product\\n for matrix in list[1:]:\\n matrix_product = matrix_multiply(matrix_product, matrix)\\n\\n return matrix_product\",\n \"def prod(lst):\\n if len(lst) == 0:\\n return 0\\n x = lst[0]\\n for v in lst[1:]:\\n x *= v\\n return x\",\n \"def prod(lst):\\n if len(lst) == 0:\\n return 0\\n x = lst[0]\\n for v in lst[1:]:\\n x *= v\\n return x\",\n \"def multiply_ints(list_of_ints):\\n\\n products_of_all_ints_except_ind = [None] * len(list_of_ints)\\n postproduct = 1\\n\\n for idx in xrange(len(list_of_ints) - 1, -1, -1):\\n products_of_all_ints_except_ind[idx] = postproduct\\n postproduct *= list_of_ints[idx]\\n\\n preproduct = 1\\n \\n for idx, num in enumerate(list_of_ints):\\n products_of_all_ints_except_ind[idx] *= preproduct\\n preproduct *= num\\n\\n return products_of_all_ints_except_ind\",\n \"def product(numbers):\\n p = 1\\n for x in numbers:\\n p *= x\\n return p\",\n \"def product(numbers):\\n p = 1\\n for x in numbers:\\n p *= x\\n return p\",\n \"def check_list(self,list_input):\\n if not isinstance(list_input,list):\\n raise ValueError('input is not in list type')\\n for i in list_input:\\n if isinstance(i,list) and len(i) != 0:\\n for j in i:\\n if not isinstance(j,(float,int)):\\n print(j)\\n raise ValueError('cannot convert')\\n else:\\n print(i)\\n raise ValueError('wrong defined')\",\n \"def product(nbs):\\n try:\\n prod = 0\\n for nb in nbs:\\n prod *= float(nb)\\n except TypeError:\\n print(\\\"Hmmm, I guess you haven't only entered valid numbers\\\")\\n return\\n print(\\\"And the product is.... : {0} \\\".format(prod))\",\n \"def __mul__(self,l):\\r\\n\\t\\t\\r\\n\\t\\t# multiply\\r\\n\\t\\tm = self.multiply(l)\\r\\n\\t\\t\\r\\n\\t\\treturn m\",\n \"def __multiply(self, listA, listB):\\n if len(listA) != len(listB):\\n raise ValueError('List should be of same lengths')\\n\\n return [listA[i]*listB[i] for i in range(len(listA))]\",\n \"def prod(L):\\n res = 1\\n for e in L:\\n res *= e\\n return res\",\n \"def prod(l):\\n r = 1\\n for x in l:\\n r *= x\\n return r\",\n \"def check_if_number(list):\\n for item in list:\\n try:\\n float(item)\\n except ValueError as e:\\n print WrongTypePointError(item)\\n sys.exit()\",\n \"def scalar_mult(scalar, lista):\\n return [scalar * element for element in lista]\",\n \"def list_validate_number(lst, target):\\n elements = set(lst)\\n for element in elements:\\n if target - element in elements:\\n return True\\n return False\",\n \"def product(it):\\n prod = 1\\n for x in it:\\n prod *= x\\n return prod\",\n \"def checkInput(Matrix,List):\\r\\n \\r\\n if type(Matrix) != list or type(List) != list:\\r\\n \\r\\n raise RuntimeError('malformed')\\r\\n for k in Matrix:\\r\\n if type(k) != list:\\r\\n \\r\\n raise RuntimeError('malformed')\\r\\n if len(k) != len(List):\\r\\n \\r\\n raise RuntimeError('malformed')\\r\\n for j in k:\\r\\n if type(j) != int and type(j) != float:\\r\\n \\r\\n raise RuntimeError('malformed')\\r\\n if j > 30:\\r\\n \\r\\n raise RuntimeError('malformed')\\r\\n for p in List:\\r\\n if type(p) != str:\\r\\n \\r\\n raise RuntimeError('malformed')\\r\\n\\r\\n if len(Matrix) != len(List):\\r\\n \\r\\n raise RuntimeError('malformed')\\r\\n return\",\n \"def is_multiple(n, m):\\n # Check the given numbers are integer\\n if m%n:\\n # print('%d is NOT a multiple of %d' % (n, m))\\n return False\\n # print('%d is a multiple of %d' % (n, m))\\n return True\",\n \"def multiply(numbers):\\n counter = 0\\n for num in numbers:\\n counter *= num\\n return counter\",\n \"def test_multiply(self):\\n self.assertEqual(work_file.multiply(10, 5), 50)\\n self.assertEqual(work_file.multiply(-1, 1), -1)\\n self.assertEqual(work_file.multiply(-1, -1), 1)\",\n \"def matrixElementMultiply (self, value, list):\\n\\t\\tnumRows = len(list)\\n\\t\\tnumCols = len(list[0])\\n\\t\\n\\t\\treturn [[value * list[j][i] for i in range(numCols)] for j in range(numRows)]\",\n \"def validate(s):\\n\\n # base case: square is 1 or 0\\n if s == 1 or s == 0:\\n return True\\n\\n # list of length 4\\n if isinstance(s, list) and len(s) == 4:\\n\\n # idea one: fail fast\\n for i in s:\\n if not validate(i):\\n return False\\n return True\\n\\n # idea 2: \\\"and\\\" the results ALSO fail fast\\n # return (validate(s[0]) and \\n # validate(s[1]) and \\n # validate(s[2]) and \\n # validate(s[3]))\\n # OR\\n # return all([validate(i) for i in s])\\n\\n # idea 3: multiply the results: will not return boolean\\n # return (validate(s[0]) * \\n # validate(s[1]) * \\n # validate(s[2]) * \\n # validate(s[3]))\\n\\n # not one of our numbers or list of length 4\\n # another base case\\n return False\",\n \"def multiplication(self):\\r\\n global answer\\r\\n while True:\\r\\n try:\\r\\n easy_random1 = int(random.choice(string.digits))\\r\\n easy_random2 = int(random.choice(string.digits))\\r\\n easy_random3 = int(random.choice(string.digits))\\r\\n easy_random4 = int(random.choice(string.digits))\\r\\n print(f\\\"{easy_random1} * {easy_random2} * {easy_random3} * {easy_random4} = ?\\\")\\r\\n real_answer = easy_random1 * easy_random2 * easy_random3 * easy_random4\\r\\n answer = input(\\\"Enter answer: \\\")\\r\\n if answer.lower() == \\\"stop\\\":\\r\\n print(\\\"okay\\\")\\r\\n if int(answer) == real_answer:\\r\\n print(\\\"CORRECT ANSWER\\\")\\r\\n else:\\r\\n print(\\\"WRONG ANSWER\\\")\\r\\n print(f\\\"the answer is {real_answer} sorry! try again\\\")\\r\\n except ValueError:\\r\\n return f'\\\"{answer}\\\" is not a valid number, only the string stop is allowed'\",\n \"def isList(memoryManager, paramsList):\\n if isEmptyList(paramsList):\\n return [1.0]\\n A = paramsList[0]\\n if validateList(A):\\n return [0.0] if len(A) <= 1 else [1.0]\\n return [0.0]\",\n \"def square_nums(number_list):\",\n \"def add_product_list(self, prod_list):\\n success = True\\n for item in prod_list:\\n success &= self.add(item[0], item[1], item[2])\\n if success: print('add_product_list: succeeded')\\n else: print('add_product_list: failed')\\n \\n return success\",\n \"def do_multiply(self, mul: int, *nums: int):\\n for num in nums:\\n print(mul * num, file=self.stdout)\",\n \"def prod(l):\\n return reduce(lambda a, b: a*b, l)\",\n \"def test_if_it_accepts_lists(self):\\n with self.assertRaises(TypeError):\\n prime_numbers(56.58)\",\n \"def test_list_type(self):\\n\\n expected = TypeError\\n input_ = []\\n with self.assertRaises(expected):\\n math.factorial(input_)\",\n \"def test_many_positive(self):\\n\\n # pairs (input, result)\\n pairs = [\\n ([3, 4, 6, 8, 0], 192),\\n ([1, -1, 1, -1, 1], 1),\\n ([0, 0, 0, 0, -1], 0),\\n ([6, 5, 4, 3, 2], 120),\\n ([6, 5, 4, 3, -2], 120),\\n ([6, 5, 4, -3, -2], 120),\\n ([-6, -5, 4, 3, 0], 120),\\n ([-6, 5, 4, 3, 2], 60),\\n ([5, 6, -100, -1, 10], 1000)\\n ]\\n\\n for lst, result in pairs:\\n self.assertEqual(max_triple_mul(lst), result)\",\n \"def multiply(*args):\\n #convert args to floats so we can do the maths\\n values = list(args)\\n for x in range(len(values)):\\n values[x] = float(values[x])\\n product = str(ft.reduce(oper.mul,values))\\n\\n return product\",\n \"def brute_multiply(numbers):\\n result = []\\n for a in range(len(numbers)):\\n product = 1\\n for index, b in enumerate(numbers):\\n if index != a:\\n product *= b\\n result.append(product)\\n return result\",\n \"def multiply(t):\\n return mul(*t)\",\n \"def are_all_numbers(values: List[Union[str, int, float]]):\\n for value in values:\\n if not is_number(value):\\n return False\\n return True\",\n \"def multiply(self,*datas):\\n\\t\\tresult = 1\\n\\t\\tfor data in datas:\\n\\t\\t\\tresult *=data\\n\\t\\treturn result\",\n \"def _check_nested_floats(thelist):\\n result = True\\n for item in thelist:\\n if type(item) in [list,tuple]:\\n result = result and _check_nested_floats(item)\\n else:\\n result = result and type(item) in [int,float]\\n return result\",\n \"def multiply_numbers(first_number, second_number):\",\n \"def is_multiple(m, n):\\r\\n return is_factor(n, m)\",\n \"def _mul_op(value, sample_args, rationals_allowed):\\n if sample_args.count >= 3:\\n _, op_args, sample_args = _div_op(value, sample_args, rationals_allowed)\\n op_args = [op_args[0], sympy.Integer(1) / op_args[1]]\\n elif sample_args.count == 1:\\n entropy, sample_args = sample_args.peel()\\n assert _entropy_of_factor_split(value) >= entropy\\n op_args = _split_factors(value)\\n else:\\n assert sample_args.count == 2\\n entropy, sample_args = sample_args.peel()\\n numer = sympy.numer(value)\\n denom = sympy.denom(value)\\n p1, p2 = _split_factors(numer)\\n entropy -= _entropy_of_factor_split(numer)\\n mult = number.integer(entropy, signed=True, min_abs=1, coprime_to=p1)\\n op_args = [p1 / (mult * denom), p2 * mult]\\n\\n if random.choice([False, True]):\\n op_args = list(reversed(op_args))\\n\\n return ops.Mul, op_args, sample_args\",\n \"def test_multiplying(self):\\n multiplier = Multiplier()\\n\\n for i in range(-10, 10):\\n for j in range(-10, 10):\\n self.assertEqual(i*j, multiplier.calc(j, i))\",\n \"def test_list(self):\\n self.assertEqual(max_integer([1, 5, -7, 6, -4 , 10]), 10)\\n self.assertEqual(max_integer([0]), 0)\\n self.assertEqual(max_integer([0, 3 + 2, 7, 9 * 8, 35, 12]), 72)\",\n \"def mul_numbers(a: int, b: int) -> int:\\n return a * b\",\n \"def multiply(*args):\\n body = ['<h1>Multiplication Calculator</h1>']\\n product = reduce(lambda x,y: x * y, map(int,args))\\n body.append(f'Total equals: {product}')\\n return '\\\\n'.join(body)\",\n \"def is_multiplicative(*args):\\n return _ida_hexrays.is_multiplicative(*args)\",\n \"def multiplied(*values):\\n values = [_normalize(v) for v in values]\\n def _product(it):\\n p = 1\\n for n in it:\\n p *= n\\n return p\\n for v in zip(*values):\\n yield _product(v)\",\n \"def test_multiplication():\\n assert calculator.multiply(7, 3) == 21\\n assert calculator.multiply(7.0, 3.0) == 21.0\\n assert calculator.multiply(7, -3) == -21\\n assert calculator.multiply(7.0, -3.0) == -21.0\",\n \"def test_micrometers_validate_list(self):\\n micrometer = inches_to.micrometers([1.0, 2.0, 3.0, 4.0])\\n comparison = np.array([2.54e4, 2*2.54e4, 3*2.54e4, 4*2.54e4])\\n\\n try:\\n for i in range(len(comparison)):\\n self.assertTrue(math.isclose(micrometer[i], comparison[i], rel_tol=self.accepted_error))\\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.passed))\\n except AssertionError:\\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.failed))\",\n \"def empty_list(input_list):\\n for item in input_list:\\n if not isinstance(item, list) or not empty_list(item):\\n return False\\n return True\",\n \"def test_cross_multiply_from_list():\\n array_1 = np.ones((1, 3)).tolist()\\n array_out = utils.cross_multiply_array(array_1, axis=1)\\n assert (1, 3, 3) == array_out.shape\",\n \"def mul(a: int, b: int, c: int, memory: List) -> NoReturn:\\n memory[c] = memory[a] * memory[b]\",\n \"def check_correct_numbers(puzzle_size: int, puzzle_list: list) -> None:\\n for number in range(puzzle_size * puzzle_size):\\n if number not in puzzle_list:\\n raise ParsingError(\\\"Puzzle does not contain expected numbers.\\\")\",\n \"def square(numbers):\\n\\n # Needs only one argument\\n newlist = []\\n for num in numbers:\\n newlist.append(num*num)\\n return newlist\",\n \"def multiplier(*args):\\n if not args:\\n return 0\\n product = args[0]\\n for a in args[1:]:\\n print('a is: ',a)\\n product *= a\\n return product,args\",\n \"def test_pauls_misery(list, result):\\n from pauls_misery import paul\\n assert paul(list) == result\",\n \"def validate_requirements(self, list_of_animals):\\n if not any(\\n [\\n validation_func(list_of_animals)\\n for validation_func in [\\n self.exceeds_capacity,\\n self.exceeds_space_required,\\n self.incompatible_animals,\\n ]\\n ]\\n ):\\n return True\",\n \"def test_if_it_accepts_lists(self):\\n with self.assertRaises(TypeError):\\n prime_numbers([])\",\n \"def is_valid_integer_list(any_list):\\n list_object = json.loads(any_list)\\n return not any(not is_valid_integer(str(listing_id)) for listing_id in\\n list_object)\",\n \"def test_float_list(self):\\n f_list = [3.2, 5.6, 7.3, 9.9, 12.7]\\n self.assertEqual(max_integer(f_list), 12.7)\",\n \"def toate_elementele_prime(lst):\\n for x in lst:\\n if nr_prim(x) is False:\\n return False\\n return True\",\n \"def validate_list(types,val,allowed,tname):\\n if not len(types): return TYPE_MISMATCH\\n if type(val) not in TYPES[tname]: raise Exception('unknown type')\\n for v in val:\\n result=VALIDATORS[types[-1]](types[:-1],v,allowed,types[-1])\\n if not result: return result\\n return True\",\n \"def _validate_internal_value_list(self, value: Any):\\n # Make sure the value is a list\\n if not isinstance(value, list):\\n raise TypeError(f\\\"Value must be a list\\\")\\n\\n # Make sure the list has the correct number of values in it\\n length = len(value)\\n if isinstance(self._nargs, int):\\n if self._action == \\\"store\\\":\\n if length != self._nargs:\\n raise ValueError(f\\\"Requires list of length {self._nargs}\\\")\\n else:\\n if length == 0 or length % self._nargs != 0:\\n raise ValueError(f\\\"Requires list of length a multiple of {self._nargs}\\\")\\n elif self._nargs == \\\"+\\\":\\n if length == 0:\\n raise ValueError(f\\\"Requires at least one item\\\")\\n\\n if any(not isinstance(element, self._type) for element in value):\\n raise TypeError(f\\\"All values must be of the declared type {self._type.__name__}\\\")\",\n \"def test_miles_validate_list(self):\\n mile = inches_to.miles([1.0, 2.0, 3.0, 4.0])\\n comparison = np.array([1.57828e-5, 2*1.57828e-5, 3*1.57828e-5, 4*1.57828e-5])\\n\\n try:\\n for i in range(len(comparison)):\\n self.assertTrue(math.isclose(mile[i], comparison[i], rel_tol=self.accepted_error))\\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.passed))\\n except AssertionError:\\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.failed))\",\n \"def mul(a,b):\\n return [a[0]*b[0],a[1]*b[1],a[2]*b[2],1.0]\",\n \"def kkMul(*args):\\n if (None in args):\\n return None\\n product = 1\\n for arg in args:\\n product *= arg\\n return product\",\n \"def double_nums(num_list):\",\n \"def multiply(value, multiplier):\\n return value*multiplier\",\n \"def product(*nums):\\n\\treturn reduce((lambda x, y: x * y), nums)\",\n \"def test_one_number_list(self):\\n lst = [98]\\n self.assertEqual(max_integer(lst), 98)\",\n \"def eval_list(self, value):\\n\\n okay = True\\n count = 0\\n for v in value.elts:\\n if not self.eval_value(v):\\n okay = False\\n break\\n count += 1\\n return okay\",\n \"def prod(arg):\\n ret = 1\\n for i in range(0, len(arg)):\\n ret = ret * arg[i]\\n return ret\",\n \"def simplify_mul(tree):\\r\\n neg, inputs = tree\\r\\n if isinstance(inputs, list):\\r\\n # Recurse through inputs.\\r\\n s_inputs = []\\r\\n for s_i in imap(simplify_mul, inputs):\\r\\n if s_i[1] is None:\\r\\n # Multiplication by +/-1.\\r\\n neg ^= s_i[0]\\r\\n else:\\r\\n s_inputs.append(s_i)\\r\\n if not s_inputs:\\r\\n # The multiplication is empty.\\r\\n rval = [neg, None]\\r\\n elif len(s_inputs) == 1:\\r\\n # The multiplication has a single input.\\r\\n s_inputs[0][0] ^= neg\\r\\n rval = s_inputs[0]\\r\\n else:\\r\\n rval = [neg, s_inputs]\\r\\n else:\\r\\n rval = tree\\r\\n #print 'simplify_mul: %s -> %s' % (tree, rval)\\r\\n return rval\",\n \"def test_simtk_list_of_quantities_to_pint():\\n list_of_quantities = [val * omm_unit.meter for val in range(10)]\\n quantity_list = omm_unit.meter * [val for val in range(10)]\\n\\n assert list_of_quantities != quantity_list\\n assert all(simtk_to_pint(list_of_quantities) == simtk_to_pint(quantity_list))\",\n \"def __is_multiple(self, current):\\n for prime in self.primes:\\n if current % prime == 0:\\n return True\\n return False\",\n \"def lsummult (list1,list2):\\r\\n if len(list1) <> len(list2):\\r\\n raise ValueError, \\\"Lists not equal length in summult.\\\"\\r\\n s = 0\\r\\n for item1,item2 in pstats.abut(list1,list2):\\r\\n s = s + item1*item2\\r\\n return s\",\n \"def test_millimeters_validate_list(self):\\n millimeter = inches_to.millimeters([1.0, 2.0, 3.0, 4.0])\\n comparison = np.array([25.4, 2*25.4, 3*25.4, 4*25.4])\\n\\n try:\\n for i in range(len(comparison)):\\n self.assertTrue(math.isclose(millimeter[i], comparison[i], rel_tol=self.accepted_error))\\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.passed))\\n except AssertionError:\\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.failed))\",\n \"def _perform_metrics_update_list(self, examples_list: List[Any]) -> None:\\n try:\\n self._perform_metrics_update_fn(*[examples_list])\\n\\n except (RuntimeError, TypeError, ValueError,\\n tf.errors.OpError) as exception:\\n general_util.reraise_augmented(exception,\\n 'raw_input = %s' % examples_list)\",\n \"def multiply_nums(n1, n2):\\n\\n result = n1 * n2\\n return result\",\n \"def test_calculator_multiply():\\n assert Calculator.multiply_numbers(1, 2) == 2\",\n \"def multiply(num1, num2):\\n return num1 * num2\",\n \"def isProductOfNumbersInSeq(number, seq1):\\n\\tseq = deepcopy(seq1)\\n\\n\\twhile number != 1:\\t\\n\\t\\tif not seq:\\n\\t\\t\\treturn False\\n\\n\\t\\tnext_divisor = min(seq)\\n\\n\\t\\tif not number % next_divisor:\\n\\t\\t\\tnumber /= next_divisor\\n\\t\\t\\n\\t\\tseq.remove(next_divisor)\\n\\n\\treturn True\",\n \"def list_check(lst):\\n for item in lst:\\n if type(item) != list:\\n return False\\n return True\",\n \"def div_by(n, list_of_num):\\n for num in list_of_num:\\n if not n % num:\\n return True\\n return False\",\n \"def multiply(value, arg):\\n return value * arg\",\n \"def test_our_multiply(self):\\n\\n self.assertEqual(self.our_module.multiply(3, 4), 12)\",\n \"def multiply(num1, num2):\\n return num1 * num2\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6760711","0.6697329","0.64938724","0.64613146","0.63816386","0.6319394","0.63060385","0.6242373","0.62085116","0.6153073","0.6107456","0.6038584","0.602507","0.600547","0.5875371","0.5868004","0.5868004","0.58225316","0.5819411","0.5819411","0.579956","0.57926196","0.5767099","0.574698","0.5697102","0.5666109","0.56647605","0.56032574","0.55879235","0.55577713","0.5549324","0.5533656","0.55314994","0.5523254","0.5497433","0.5481912","0.5434504","0.54152244","0.54101926","0.53863794","0.53734833","0.53711593","0.5359244","0.5353213","0.5352738","0.5327091","0.5304563","0.52735525","0.52524877","0.52524203","0.5249569","0.5241371","0.52380157","0.52361643","0.5221807","0.5221246","0.52161074","0.5208251","0.5204877","0.51941216","0.5193632","0.51840824","0.5183736","0.5181477","0.5181256","0.51789534","0.51508856","0.5131556","0.51247025","0.51238865","0.51216316","0.51154894","0.5111227","0.51111776","0.5102721","0.5095836","0.50945604","0.508707","0.5078295","0.50768256","0.5074182","0.50528795","0.50452936","0.50303257","0.50086564","0.5006865","0.50023085","0.5001511","0.5001115","0.49999413","0.49997205","0.49997056","0.49973026","0.49961194","0.49957556","0.49816746","0.4979023","0.4963585","0.4960823","0.4958549"],"string":"[\n \"0.6760711\",\n \"0.6697329\",\n \"0.64938724\",\n \"0.64613146\",\n \"0.63816386\",\n \"0.6319394\",\n \"0.63060385\",\n \"0.6242373\",\n \"0.62085116\",\n \"0.6153073\",\n \"0.6107456\",\n \"0.6038584\",\n \"0.602507\",\n \"0.600547\",\n \"0.5875371\",\n \"0.5868004\",\n \"0.5868004\",\n \"0.58225316\",\n \"0.5819411\",\n \"0.5819411\",\n \"0.579956\",\n \"0.57926196\",\n \"0.5767099\",\n \"0.574698\",\n \"0.5697102\",\n \"0.5666109\",\n \"0.56647605\",\n \"0.56032574\",\n \"0.55879235\",\n \"0.55577713\",\n \"0.5549324\",\n \"0.5533656\",\n \"0.55314994\",\n \"0.5523254\",\n \"0.5497433\",\n \"0.5481912\",\n \"0.5434504\",\n \"0.54152244\",\n \"0.54101926\",\n \"0.53863794\",\n \"0.53734833\",\n \"0.53711593\",\n \"0.5359244\",\n \"0.5353213\",\n \"0.5352738\",\n \"0.5327091\",\n \"0.5304563\",\n \"0.52735525\",\n \"0.52524877\",\n \"0.52524203\",\n \"0.5249569\",\n \"0.5241371\",\n \"0.52380157\",\n \"0.52361643\",\n \"0.5221807\",\n \"0.5221246\",\n \"0.52161074\",\n \"0.5208251\",\n \"0.5204877\",\n \"0.51941216\",\n \"0.5193632\",\n \"0.51840824\",\n \"0.5183736\",\n \"0.5181477\",\n \"0.5181256\",\n \"0.51789534\",\n \"0.51508856\",\n \"0.5131556\",\n \"0.51247025\",\n \"0.51238865\",\n \"0.51216316\",\n \"0.51154894\",\n \"0.5111227\",\n \"0.51111776\",\n \"0.5102721\",\n \"0.5095836\",\n \"0.50945604\",\n \"0.508707\",\n \"0.5078295\",\n \"0.50768256\",\n \"0.5074182\",\n \"0.50528795\",\n \"0.50452936\",\n \"0.50303257\",\n \"0.50086564\",\n \"0.5006865\",\n \"0.50023085\",\n \"0.5001511\",\n \"0.5001115\",\n \"0.49999413\",\n \"0.49997205\",\n \"0.49997056\",\n \"0.49973026\",\n \"0.49961194\",\n \"0.49957556\",\n \"0.49816746\",\n \"0.4979023\",\n \"0.4963585\",\n \"0.4960823\",\n \"0.4958549\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80064815"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84888,"cells":{"query":{"kind":"string","value":"Parse query param and take validated names"},"document":{"kind":"string","value":"def parse_query_param(self, sideload_parameter):\n self.relations_to_sideload = set(sideload_parameter.split(\",\")) & set(\n self._sideloadable_fields.keys()\n )\n return self.relations_to_sideload"},"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_params(self, params):\r\n if params[0] == \":\":\r\n params = [params[1:]]\r\n else:\r\n params = params.split(\" :\", 1)\r\n if len(params) == 1:\r\n last_arg = None\r\n else:\r\n last_arg = params[1]\r\n params = params[0].split(None)\r\n if last_arg != None:\r\n params.append(last_arg)\r\n return params","def parse_query_params(query_string):\n # Parse the query param string\n parsed = urlparse(query_string)\n print(parsed)\n query_params = dict(parse_qs(parsed.path))\n print(query_params)\n # Get the value from the list\n query_params = {k: v[0] for k, v in query_params.items()}\n return query_params","def get_params(raw):\n parts = raw.split(\" \", 1)\n return None if len(parts) == 1 else parts[1]","def _urlparse_splitquery(url):\r\n\r\n qpart = url.split(\"?\", 1)\r\n if len(qpart) == 2:\r\n query = qpart[1]\r\n else:\r\n query = \"\"\r\n\r\n return qpart[0], query","def parseQueryString():\n\tqs = cgi.FieldStorage()\n\treturn({'char': qs.getvalue('char'), 'zone': qs.getvalue('zone')})","def parse_query_string(self, params):\n results = {}\n\n for key, val in params.items():\n lookup_len = len(self.query_string_lookup) + 1\n\n if key[0:lookup_len] == '{}['.format(self.query_string_lookup) and key[-1] == ']':\n results[key[lookup_len:-1]] = val if val.lower() != 'null' else None\n\n return results","def _split_url_string(param_str):\n parameters = parse_qs(param_str, keep_blank_values=False)\n for key, val in parameters.iteritems():\n parameters[key] = urllib.unquote(val[0])\n return parameters","def parse_query_string(self, params):\n results = {}\n\n for key, val in params.items():\n lookup_len = len(self.query_string_lookup) + 1\n\n if key[0:lookup_len] == '{}['.format(self.query_string_lookup) and key[-1] == ']':\n results[key[lookup_len:-1]] = val\n\n return results","def func_PARSE(self):\n self.parsed_url = parse.urlparse(\"http://{0}:{1}{2}\".format(args.HTTP_HOST, args.HTTP_PORT, self.path).lower())\n self.parsed_param = parse.parse_qs(self.parsed_url[4])","def parse_get_values(self): \n self.parse_values(os.environ[\"QUERY_STRING\"])","def _split_url_string(query_string):\r\n parameters = parse_qs(to_utf8(query_string), keep_blank_values=True)\r\n for k, v in parameters.iteritems():\r\n parameters[k] = urllib.unquote(v[0])\r\n return parameters","def _check_params(self):\n\t\tstrange_param_helper = False\n\t\tfor param in self.params:\n\t\t\n\t\t\t# It could be that the param encapsulates several values (e.g., \"FLUX_RADIUS(10)\")\n\t\t\t# So we have to dissect this\n\t\t\tmatch = re.compile(\"(\\w*)\\(\\d*\\)\").match(param)\n\t\t\tif match:\n\t\t\t\tcleanparam = match.group(1)\n\t\t\telse:\n\t\t\t\tcleanparam = param\n\t\t\t\t\n\t\t\tif cleanparam not in self.fullparamlist:\n\t\t\t\tlogger.warning(\"Parameter '%s' seems strange and might be unknown to SExtractor\" \\\n % (param))\n\t\t\t\tstrange_param_helper = True\n\t\t\t\t\n\t\tif strange_param_helper:\n\t\t\tlogger.warning(\"Known parameters are: %s\" % (self.fullparamtxt))","def clean_params(self, url):\n if isinstance(url, unicode):\n url = url.encode(\"utf-8\")\n parts = list(urlparse.urlsplit(url))\n if not parts[3]:\n return url\n query = urlparse.parse_qsl(parts[3])\n query = [q for q in query if self._is_param_allowed(*q)]\n if query:\n parts[3] = urllib.urlencode(query)\n else:\n parts[3] = ''\n return urlparse.urlunsplit(parts).decode(\"utf-8\")","def parse_from_request(self, name, request):\n # type: (str, Request) -> Any\n name_bytes = name.encode()\n if name_bytes not in request.args:\n if self.default is not None:\n return self.default\n if self.required:\n raise Error(BAD_REQUEST, message=b\"%s is required\" % name_bytes)\n else:\n return None\n\n if len(request.args[name_bytes]) != 1:\n raise Error(BAD_REQUEST, message=b\"Pass exactly one argument for %s\" % name_bytes)\n\n val = request.args[name_bytes][0]\n return self.parse(val)","def validate_query_parameters(self, request):\n offset = int(request.args.get('offset')) if request and request.args and request.args.get('offset') and int(request.args.get('offset')) >= s.DEFAULT_OFFSET else s.DEFAULT_OFFSET\n limit = int(request.args.get('limit')) if request and request.args and request.args.get('limit') and int(request.args.get('limit')) <= s.DEFAULT_LIMIT else s.DEFAULT_LIMIT\n return [offset, limit]","def get_query_params(query):\n params = {}\n if query:\n delim = \"&\"\n if \"&\" not in query and \";\" in query:\n delim = \";\"\n for k_v in query.split(delim):\n k, v = k_v, \"\"\n if \"=\" in k_v:\n k, v = k_v.split(\"=\")\n params[k] = v\n return params","def input(self, name):\n try:\n _input = self.params[name]\n try:\n _input = _input.strip()\n except AttributeError:\n pass\n if _input == '':\n return None\n return _input\n except KeyError:\n return None","def parse_agenda_filter_params(querydict):\n if len(querydict) == 0:\n return None\n\n # Parse group filters from GET parameters. Other params are ignored.\n filt_params = {'show': set(), 'hide': set(), 'showtypes': set(), 'hidetypes': set()}\n\n for key, value in querydict.items():\n if key in filt_params:\n vals = unquote(value).lower().split(',')\n vals = [v.strip() for v in vals]\n filt_params[key] = set([v for v in vals if len(v) > 0]) # remove empty strings\n\n return filt_params","def url_parse_query(query, encoding=None):\n if isinstance(query, unicode):\n if encoding is None:\n encoding = url_encoding\n query = query.encode(encoding, 'ignore')\n query = query.replace('?', '')\n\n l = set()\n for k, v, sep in parse_qsl(query, True):\n k = url_quote_part(k, '/-:,;')\n if not k:\n continue\n if v:\n v = url_quote_part(v, '/-:,;')\n l.add(\"%s=%s\" % (k, v))\n elif v is None:\n l.add(\"%s\" % k)\n else:\n # some sites do not work when the equal sign is missing\n l.add(\"%s=\" % k)\n query = '&'.join(sorted(l))\n return query","def _get_param_from_request(self, nombreParametro):\n\t\treturn request.args.get(nombreParametro)","def parse_request(self, request):\n request = str(request)\n str_start = request.find(\"GET /?\")\n str_end = request.find(\"HTTP\")\n str_full = request[str_start + 6:str_end - 1]\n\n options = {}\n temp_option = []\n temp_selector = \"\"\n\n for i, letter in enumerate(str_full):\n if letter == \"=\":\n options[\"\".join(temp_option)] = []\n temp_selector = \"\".join(temp_option)\n temp_option = []\n elif letter == \"&\":\n options[temp_selector] = \"\".join(temp_option)\n temp_selector = \"\"\n temp_option = []\n elif i + 1 >= len(str_full):\n temp_option.append(letter)\n options[temp_selector] = \"\".join(temp_option)\n else:\n temp_option.append(letter)\n\n return options","def _parse_params(params):\n for key, value in params.items():\n if value.lower() in ('none', 'null', ''):\n params[key] = None\n elif value.lower() == 'true':\n params[key] = True\n elif value.lower() == 'false':\n params[key] = False\n elif value.isdigit() or (value[0] == '-' and value[1:].isdigit()):\n params[key] = int(value)\n elif ',' in value:\n params[key] = list(map(lambda x: x.strip(), value.split(',')))\n else:\n try:\n params[key] = float(value)\n except:\n pass\n return params","def parse_query(query):\n qlist = []\n splitted = query.split(\"&\")\n for entry in splitted:\n cmd, arg = entry.split(\"=\")\n qlist.append((cmd, arg))\n return qlist","def parseURL(url):\n\n\n scheme, host, path, params, query, hash = urlparse(url)\n if not path: path = \"/\"\n\n args = parse_qs(query)\n\n escapedArgs = {}\n for name in args:\n if len(args[name]) == 1:\n escapedArgs[unquote(name)] = unquote(args[name][0])\n else:\n escapedArgs[unquote(name)] = escapedSet = []\n for item in args[name]:\n escapedSet.append(unquote(item))\n\n return host, path, params, escapedArgs","def parse(cls, value: str) -> Tuple[str, Dict[str, str]]:\n raw_value = read_value_from_path(value)\n args: Dict[str, str] = {}\n\n if \"@\" in raw_value:\n args[\"region\"], raw_value = raw_value.split(\"@\", 1)\n\n # now find any other arguments that can be filters\n matches = re.findall(r\"([0-9a-zA-z_-]+:[^\\s$]+)\", raw_value)\n for match in matches:\n k, v = match.split(\":\", 1)\n args[k] = v\n\n return args.pop(\"name_regex\"), args","def params_from_request(request):\n params_dict = {}\n for key, value in request.arguments.items():\n if len(value) == 1:\n params_dict[key] = value[0].decode('UTF-8')\n else:\n params_dict[key] = []\n for part in value:\n params_dict[key].append(part.decode('UTF-8'))\n return params_dict","def validated_parameter(args, name, values=None, default=None, case_sensitive=False):\n\n param = args.get(name)\n if param:\n param = param.lower()\n else:\n param = default\n\n if not values:\n return param\n else:\n if values and param not in values:\n list_str = \", \".join(values)\n raise RequestError(\"Parameter '%s' should be one of: %s\"\n % (name, list_str) )\n return param","def parse_request_path( self, path ):\n path_parts = path.strip(\"/\").split(\"/\")\n \n if len(path_parts) == 0:\n # invalid \n return (None, None)\n \n if len(path_parts) > 2:\n # invalid\n return (None, None)\n \n slice_name = path_parts[0]\n if len(slice_name) == 0:\n # empty string is invalid \n return (None, None)\n \n volume_name = None\n \n if len(path_parts) > 1:\n volume_name = path_parts[1]\n \n return slice_name, volume_name","def _parse_in_request(self, request):\n error = None\n self.logger.debug(\"Http method: %s\" % request.method)\n if request.method == 'GET':\n self._params = request.args.to_dict()\n self.logger.debug(\"Request params: %s\" % self._params)\n \n elif request.method == 'POST':\n self._params = request.form.to_dict()\n self.logger.debug(\"Request params: %s\" % self._params)","def get_parameter(request, param):\n if param == \"Params\":\n return request.split(\"\\r\\n\\r\\n\")[1]\n if isinstance(param, type([])):\n return [request.split(\"\\r\\n\\r\\n\")[1] if x == \"Param\" else request.split(x + \": \")[1].split(\"\\r\\n\")[0] for x in param]\n if isinstance(param, type(\"\")):\n return request.split(param + \": \")[1].split(\"\\r\\n\")[0]","def query_params_sanitize(query_params):\n def allow_func(n, v):\n # This gets rid of any params beginning with \"oauth_\"\n if not n.startswith(\"oauth_\"):\n return True\n else:\n logging.warning(\"Protocol parameter ignored from URL query parameters: `%r`\", n)\n return False\n return query_filter(query_params, allow_func=allow_func)","def _params(self, qs):\n return [str_id for str_id in qs.split(',')]","def parse_request(self, request: str) -> tuple:\n parts = request.split(b\" \")\n return parts[0], parts[1]","def parse_querystring(request):\n url = request.args.get('url', settings.default_iframe_url)\n if not url.startswith('http:') and not url.startswith('https:'):\n url = \"http://\" + url\n\n try:\n width = int(request.args.get(\"width\"))\n except Exception as e:\n width = settings.default_size[0]\n\n try:\n height = int(request.args.get(\"height\"))\n except:\n height = settings.default_size[1]\n\n return url, width, height","def find_params_in_url(url):\n\n # self.logger.debug('Find params in url: %s', url)\n\n rid = None\n wid = None\n wname = None\n\n url_parsed = urlparse(url)\n query = parse_qs(url_parsed.query)\n if 'w' in query:\n wid = query['w'][0]\n if query['w'][0] in G_VV:\n wname = G_VV[query['w'][0]]\n\n if 'rid' in query:\n rid = query['rid'][0]\n\n return {'rid': rid, 'w': wname, 'wid': wid}","def parse_param(description: str) -> (str, int):\n name, value = re.split(': ', description)\n return name, int(value)","def test_additional_query_args():\n assert (normalize_url(\"http://example.com?c=d\", [(\"a\", \"b\")]) ==\n \"http://example.com/?a=b&c=d\")\n assert (normalize_url(\"http://example.com\", [(\"a\", \"b\")]) ==\n \"http://example.com/?a=b\")\n assert (normalize_url(\"http://example.com\", [(\"résumé\", \"résumé\")]) ==\n \"http://example.com/?r%C3%A9sum%C3%A9=r%C3%A9sum%C3%A9\")","def _parse_params( self ):\n paramDic={}\n # Parameters are on the 3rd arg passed to the script\n paramStr=sys.argv[2]\n print paramStr\n if len(paramStr)>1:\n paramStr = paramStr.replace('?','')\n \n # Ignore last char if it is a '/'\n if (paramStr[len(paramStr)-1]=='/'):\n paramStr=paramStr[0:len(paramStr)-2]\n \n # Processing each parameter splited on '&' \n for param in paramStr.split(\"&\"):\n try:\n # Spliting couple key/value\n key,value=param.split(\"=\")\n except:\n key=param\n value=\"\"\n \n key = urllib.unquote_plus(key)\n value = urllib.unquote_plus(value)\n \n # Filling dictionnary\n paramDic[key]=value\n print paramDic\n return paramDic","def check_search_argument(search):\n\n if search != '' and not re.match(r\"^(([\\w.:\\/\\-)+\\=([\\w.:\\/\\-])+\\s?)+\", search):\n print(\"The search items must match the format 'field=string'\")\n sys.exit(0)\n search_items = search.split(' ')\n\n return search_items","def separate_query_params(\n url: str, param_names: Optional[Iterable[str]] = None\n ) -> Tuple[str, Mapping[str, Iterable[str]]]:\n o = urlparse(url)\n qp = parse_qs(o.query, keep_blank_values=True)\n\n # Separate requested parameters from the query parameters\n params = {\n k: v for k, v in qp.items() if param_names is None or k in param_names\n }\n for p in params:\n qp.pop(p)\n\n # Rebuild url with the remaining query parameters\n qs = urlencode(qp, doseq=True, quote_via=quote)\n url = urlunparse(o._replace(query=qs))\n\n return url, params","def _parse_form_data():\n form_data = str(request.get_data())\n if form_data[:2] == \"b'\":\n # looks like b'A=1&B=2'\n form_data = form_data[2:-1]\n for key, values in parse_qs(form_data).items():\n yield (key, values[0])","def parse_form_params(body):\n # type: (unicode) -> dict[unicode, unicode|list[unicode]]\n body_params = body.replace(\"+\", \" \")\n req_body = dict() # type: dict[unicode, unicode|list[unicode]]\n for item in body_params.split(\"&\"):\n key, equal, val = item.partition(\"=\")\n if equal:\n key = parse.unquote(key)\n val = parse.unquote(val)\n prev_value = req_body.get(key, None)\n if prev_value is None:\n req_body[key] = val\n elif isinstance(prev_value, list):\n prev_value.append(val)\n else:\n req_body[key] = [prev_value, val]\n return req_body","def parse_request_arg_dict(arg, exception_class=Exception):\n arg_dict = {}\n arg_pairs = arg.split(';')\n for arg_pair in arg_pairs:\n try:\n arg_name, arg_value = arg_pair.split('=', 1)\n except Exception as error:\n logging.exception(error)\n raise exception_class(\n 'there is no `=` in %s' % arg_pair\n )\n arg_dict[arg_name] = arg_value\n return arg_dict","def normalize_params(url, params):\n # parse the url\n parse = urlparse(url)\n\n # Get the query list\n qs_list = parse_qsl(parse.query, keep_blank_values=True)\n must_encode = False if parse.query == urllib.parse.unquote(parse.query) else True\n if params is None:\n combined_list = qs_list\n else:\n # Needs to be encoded before sorting\n combined_list = [encode_pair(must_encode, key, value) for (key, value) in list(qs_list)]\n combined_list += params.items()\n\n encoded_list = [\"%s=%s\" % (key, value) for (key, value) in combined_list]\n sorted_list = sorted(encoded_list, key=lambda x: x)\n\n return \"&\".join(sorted_list)","def validatePayload(q, request):\r\n\t\tassert type(q) is str\r\n\t\t# Queries with subtitutions must have the format {var.type} for input validation purposes.\r\n\t\tformatType = Validator.getFormatType(request)\r\n\t\tif formatType == 'str':\r\n\t\t\titems = request.args.items()\r\n\t\t\tpayload = {}\r\n\t\t\t[payload.update({item[0]: item[1]}) for item in items]\r\n\t\telif formatType == 'json':\r\n\t\t\tpayload = request.get_json()\r\n\t\t\tpayload = json.loads(payload) if payload else None\r\n\t\telif formatType == 'urlencoded':\r\n\t\t\tpayload = {item:request.form[item] for item in request.form}\r\n\t\t\tif payload is None:\r\n\t\t\t\titems = request.args.items()\r\n\t\t\t\tpayload = {}\r\n\t\t\t\t[payload.update({item[0]: item[1]}) for item in items]\r\n\t\tnewQuery, expectedParamsAndTypes = Validator.extractQueryParams(q)\r\n\t\tpayload = Validator.validateJsonRequestParams(payload, expectedParamsAndTypes, formatType)\r\n\t\treturn (payload, newQuery)","def query_string_get(request, name, default_value=_NOT_SET, validator=None):\n return _XXX_get(request.rel_url.query, name, default_value, validator)","def _validate_query_parameters(self, parameters=None):\n if parameters is None:\n parameters = {}\n\n validated_parameters = {} # dictionary to return\n\n for key in parameters:\n if key in self._query_parameters:\n if key in ['limit', 'offset']:\n if isinstance(parameters[key], int):\n validated_parameters[key] = \"%i\" % parameters[key]\n elif key == 'format':\n if parameters[key] in self._query_parameters[key]:\n validated_parameters[key] = parameters[key]\n elif key == 'columns':\n # replace '+' by a space and separate the commas\n column_entry = parameters[key].replace('+', ' ').split(',')\n\n set_a = set(self._query_parameters[key])\n set_b = set(column_entry)\n validated_items = set_a.intersection(set_b) # disordered set\n validated_column_entry = [] # ordered list\n for item in column_entry:\n # reorder the set in a list to keep the same order as the entry\n if item in validated_items:\n validated_column_entry.append(item)\n validated_parameters[key] = \",\".join(validated_column_entry).replace(' ', '+')\n elif key in ['include', 'compress', 'sort']:\n if parameters[key] in self._query_parameters[key]:\n validated_parameters[key] = parameters[key]\n\n return validated_parameters","def _get_query_part(params: dict) -> str:\n params_cleaned = {k: v for k, v in params.items() if v is not None}\n return ('?' + urlencode(params_cleaned, quote_via=quote, safe=\"/,\")) if params_cleaned else \"\"","def _split_name(name):\n name_split = name.split('_view_')\n view_num = None\n if(len(name_split) > 1):\n view_num = int(name_split[1])\n optimizer_key = ''\n fp16_key = ''\n if name_split[0].startswith('Moment_1'):\n optimizer_key = 'Moment_1_'\n elif name_split[0].startswith('Moment_2'):\n optimizer_key = 'Moment_2_'\n elif name_split[0].startswith('Update_Count'):\n optimizer_key = 'Update_Count_'\n elif name_split[0].endswith('_fp16'):\n fp16_key = '_fp16'\n param_name = name_split[0]\n if optimizer_key != '':\n param_name = param_name.split(optimizer_key)[1]\n param_name = param_name.split('_fp16')[0]\n return param_name, optimizer_key, view_num, fp16_key","def set_query_parameter(url, param_name, param_value):\n scheme, netloc, path, query_string, fragment = urlsplit(url)\n query_params = parse_qs(query_string)\n\n deleted = False\n for _, value in query_params.items():\n if param_value in value:\n deleted = True\n\n if deleted:\n query_params.pop(param_name, None)\n clear = True\n if not deleted:\n query_params[param_name] = param_value\n clear = False\n\n new_query_string = urlencode(query_params, doseq=True)\n url = urlunsplit((scheme, netloc, path, new_query_string, fragment))\n\n return url, clear","def inspect_query(querystring: str) -> dict:\n return _parse_query(querystring)","def test_url_line_parser_params(self):\n line = \"GET /path?var=val&var2=val2 HTTP/1.1\"\n method, url, params, version = parser._parse_url_line(line, endpoint)\n self.assertEqual(\"GET\", method)\n self.assertEqual(\"http://test.com/path\", url)\n self.assertEqual({\"var\": \"val\", \"var2\": \"val2\"}, params)\n self.assertEqual(\"HTTP/1.1\", version)","def test_url_params(self):\n params = ct.url_params(\"https://www.bad-actor.services/some/url-thats-long?debug=True&this=that\")\n assert isinstance(params, dict)\n assert len(params) == 2\n assert params[\"debug\"] == \"True\"\n assert params[\"this\"] == \"that\"","def get_params(url=None):\r\n dict = {}\r\n if not url:\r\n url = sys.argv[2]\r\n pairs = url.lstrip(\"?\").split(\"&\")\r\n for pair in pairs:\r\n if len(pair) < 3:\r\n continue\r\n kv = pair.split(\"=\", 1)\r\n k = kv[0]\r\n v = urllib.parse.unquote_plus(kv[1])\r\n dict[k] = v\r\n return dict","def getParams(text):\n s = text.split('=')\n for i in range(len(s)):\n s[i] = s[i].strip()\n\n param = s[0]\n val = s[1]\n # Assume that there are two values only: (variable, value) pair\n assert len(s) == 2\n \n return (param, val)","def _parse_and_validate(self, val):\n if self._is_parameter_type:\n val = self._parse(val) if isinstance(val, str) else val\n self._validate_or_throw(val)\n return val","def _get_unvalidated_auth_params(self, request):\n try:\n params = parse_authz_header(request)\n except ValueError:\n params = None\n if params is None:\n return None\n if params[\"scheme\"].lower() != \"srp-hmac\":\n return None\n return params","def fetch_required_param_name(cmd):\n try:\n case_no = current_config.COMMAND_DICT[cmd]\n if case_no == 1:\n \"\"\"Create_parking_lot\"\"\"\n return [\"slots\"]\n elif case_no == 2:\n \"\"\"Park\"\"\"\n return [\"reg_no\", \"age\"]\n elif case_no == 3:\n \"\"\" Leave \"\"\"\n return [\"slot_no\"]\n elif case_no == 4:\n \"\"\"Vehicle_registration_number_for_driver_of_age\"\"\"\n return [\"age\"]\n elif case_no == 5:\n \"\"\"Slot_numbers_for_driver_of_age\"\"\"\n return [\"age\"]\n elif case_no == 6:\n \"\"\"Slot_number_for_car_with_number\"\"\"\n return [\"reg_no\"]\n except KeyError:\n return\n # logger.debug(\"Something wrong with input\")\n # raise InvalidParams(\"Something wrong with input\")","def _parse(url):\n url = url.strip()\n parsed = urlparse(url)\n return _parsed_url_args(parsed)","def nameset(request, model):\n if 'name' not in request.GET:\n return model.objects.all()\n\n if 'name' in request.GET:\n namestr = request.GET['name']\n if ',' in namestr:\n return model.objects.filter(name__in=namestr)\n else:\n return model.objects.filter(name__icontains=namestr)","def __get_parameters(self, url):\n rest_url = url.split('?')\n parameter_tuple = ()\n if len(rest_url) > 1:\n target_url = rest_url[1]\n variable_pairs = target_url.split(self.__param_delimiter)\n for one_pair in variable_pairs:\n key_value_pair = one_pair.split(\"=\")\n if len(key_value_pair) == 2:\n parameter_tuple += (tuple(key_value_pair),)\n return parameter_tuple\n return None","def _clean_and_encode_params(params: Mapping):\n # Keep only the parameters that were given a value\n params = {k: v for k, v in params.items() if v is not None}\n\n # All query parameters are later urlencoded - for projection, comma-separated\n # list is supported only on literal comma; convert comma-separated list\n # to a list of values which will be encoded to multiple query parameters\n try:\n params[\"projection\"] = [x.strip() for x in params[\"projection\"].split(\",\")]\n except KeyError:\n pass\n return params","def test_unspecified_excluded(self):\n handler = self.create_handler(r'unspecified1=foo&unspecified2=5')\n self.assertEqual(handler.get_params(), {})","def _get_query_params(self, req):\n params = {}\n for PARAM in SUPPORTED_PARAMS:\n if req and PARAM in req:\n params[PARAM] = req.get(PARAM)\n\n return params","def test_splitParamArgs(self):\n res = irc.ServerSupportedFeatures._splitParamArgs([\"A:1\", \"B:2\", \"C:\", \"D\"])\n self.assertEqual(res, [(\"A\", \"1\"), (\"B\", \"2\"), (\"C\", \"\"), (\"D\", \"\")])","def _find_params_value_of_url(self, services, url):\n values_of_query = list()\n url_split = url.split(\"/\")\n values = [item for item in url_split if item not in services and item != '']\n for v in values:\n if v != None:\n values_of_query.append(v)\n return values_of_query","def url_query_cleaner(url, parameterlist=(), sep='&', kvsep='=', remove=False, unique=True, keep_fragments=False):\n\n if isinstance(parameterlist, (six.text_type, bytes)):\n parameterlist = [parameterlist]\n url, fragment = urldefrag(url)\n base, _, query = url.partition('?')\n seen = set()\n querylist = []\n for ksv in query.split(sep):\n if not ksv:\n continue\n k, _, _ = ksv.partition(kvsep)\n if unique and k in seen:\n continue\n elif remove and k in parameterlist:\n continue\n elif not remove and k not in parameterlist:\n continue\n else:\n querylist.append(ksv)\n seen.add(k)\n url = '?'.join([base, sep.join(querylist)]) if querylist else base\n if keep_fragments:\n url += '#' + fragment\n return url","def get_request_param(request: web.Request, name: str, error_if_missing: bool = True) -> Optional[str]:\n if name not in request.rel_url.query:\n if error_if_missing:\n raise errors.NotFound()\n else:\n return None\n ret = request.rel_url.query[name]\n return ret","def parse_query_string(s):\n res = {}\n pairs = s.split('&')\n for p in pairs:\n vals = [urldecode_plus(x) for x in p.split('=', 1)]\n if len(vals) == 1:\n res[vals[0]] = ''\n else:\n res[vals[0]] = vals[1]\n return res","def parse_query_param(url, param):\n\n try:\n return parse.parse_qs(parse.urlparse(url).query)[param][0]\n except:\n return None","def check_param(self, param_str):\n param_groups = None\n \"\"\" Initial param cosmetic adjustment \"\"\"\n param_str = param_str.strip()\n\n \"\"\" Cherck the param syntax \"\"\"\n for key, pattern in self.patterns.items():\n param_groups = re.fullmatch(pattern, param_str)\n if param_groups:\n return True\n return False","def check_param(self, param_str):\n param_groups = None\n \"\"\" Initial param cosmetic adjustment \"\"\"\n param_str = param_str.strip()\n\n \"\"\" Cherck the param syntax \"\"\"\n for key, pattern in self.patterns.items():\n param_groups = re.fullmatch(pattern, param_str)\n if param_groups:\n return True\n return False","def test_query_string():\n assert (normalize_url(\"http://example.com/?a=1\") ==\n \"http://example.com/?a=1\")\n assert (normalize_url(\"http://example.com?a=1\") ==\n \"http://example.com/?a=1\")\n assert (normalize_url(\"http://example.com/a?b=1\") ==\n \"http://example.com/a?b=1\")\n assert (normalize_url(\"http://example.com/a/?b=1\") ==\n \"http://example.com/a?b=1\")","def _validate_param(name, value):\n\n # First things first -- check that we have a legal parameter name.\n try:\n validator = _legal_params[name]\n except KeyError:\n raise ViewVCException(\"An illegal parameter name was provided.\", \"400 Bad Request\")\n\n # Is there a validator? Is it a regex or a function? Validate if\n # we can, returning without incident on valid input.\n if validator is None:\n return\n elif hasattr(validator, \"match\"):\n if validator.match(value):\n return\n else:\n if validator(value):\n return\n\n # If we get here, the input value isn't valid.\n raise ViewVCException(\n 'An illegal value was provided for the \"%s\" parameter.' % (name), \"400 Bad Request\"\n )","def _check_for_unknown_params(self, params: MultiDict, search_filter: Dict[str, Any], whitelist: List[str]):\n\n for param_name in params.keys():\n if param_name not in whitelist:\n raise SuperdeskApiError.badRequestError(message=\"Unexpected parameter ({})\".format(param_name))\n\n if len(params.getlist(param_name)) > 1:\n desc = \"Multiple values received for parameter ({})\"\n raise SuperdeskApiError.badRequestError(message=desc.format(param_name))\n\n # Silently remove parameters from the search filter that are not in the whitelist\n search_filter_id = search_filter.get(\"_id\")\n for param_name in list(search_filter[\"params\"].keys()):\n if param_name not in whitelist:\n logger.warning(f\"Search filter {search_filter_id} contains unsupported param {param_name}\")\n search_filter[\"params\"].pop(param_name, None)","def parse_qsl(qs, keep_blank_values=0, strict_parsing=0):\n pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]\n r = []\n for name_value in pairs:\n if not name_value and not strict_parsing:\n continue\n nv = name_value.split('=', 1)\n if len(nv) != 2:\n if strict_parsing:\n raise ValueError, \"bad query field: %r\" % (name_value,)\n # Handle case of a control-name with no equal sign\n if keep_blank_values:\n nv.append('')\n else:\n continue\n if len(nv[1]) or keep_blank_values:\n name = unquote(nv[0].replace('+', ' '))\n value = unquote(nv[1].replace('+', ' '))\n r.append((name, value))\n\n return r","def extract_filter_params(query, currencies):\n query_parsed = []\n\n if not query:\n return query_parsed\n\n matcher = re.compile(r'[^0-9]+')\n\n for word in query:\n # Probably the value\n if not matcher.match(word):\n continue\n # Probably a word\n else:\n # If its not a currency simbol, append to the query\n if word.upper() not in currencies:\n query_parsed.append(word)\n\n return query_parsed","def get_param(name, default=''):\n return request.GET.get(name, default).strip()","def splitQuery(query_string):\n\ttry:\n\t\td = dict([x.split('=') for x in query_string.split('&') ])\n\texcept ValueError:\n\t\td = {}\n\treturn d","def test_query_string_spaces():\n assert (normalize_url(\"http://example.com/search?q=a b&a=1\") ==\n \"http://example.com/search?a=1&q=a+b\")\n assert (normalize_url(\"http://example.com/search?q=a+b&a=1\") ==\n \"http://example.com/search?a=1&q=a+b\")\n assert (normalize_url(\"http://example.com/search?q=a%20b&a=1\") ==\n \"http://example.com/search?a=1&q=a+b\")","def ingest_form_vars(request):\n data = {}\n for param, value in request.arguments.items():\n for i, item in enumerate(value):\n item = item.decode('utf-8')\n item = strings.as_numeric(item)\n value[i] = item\n data[param] = value[0] if len(value) == 1 else value\n return data","def split_params(param_string):\n\t#TODO: check for negatives i.e. alpha--1\n\tparts = param_string.split('_')\n\tparams = {}\n\n\tfor i in range(len(parts)):\n\t\tparam = split_items(parts[i])\n\t\tif len(param) < 2:\n\t\t\ttry:\n\t\t\t\tparts[i+1] = parts[i] + \"_\" + parts[i+1]\n\t\t\texcept:\n\t\t\t\tpass\n\t\t\tcontinue\n\t\telif len(param) == 2:\n\t\t\tparams[param[0]] = param[1]\n\t\telif len(param) == 3 and len(param[1]) == 0:\n\t\t\tparams[param[0]] = -param[2]\n\t\telse:\n\t\t\tparams[param[0]] = param[1:]\n\treturn params","def parse_qs(query_string):\n query_string = to_utf8_if_unicode(query_string) or \"\"\n if query_string.startswith(\"?\"):\n logging.warning(\"Ignoring `?` query string prefix -- `%r`\" % query_string)\n query_string = query_string[1:]\n return _parse_qs(query_string, keep_blank_values=True)","def _extract_model_params(self, defaults, **kwargs):\n defaults = defaults or {}\n params = {k: v for k, v in kwargs.items() if LOOKUP_SEP not in k}\n params.update(defaults)\n property_names = self.model._meta._property_names\n invalid_params = []\n for param in params:\n try:\n self.model._meta.get_field(param)\n except exceptions.FieldDoesNotExist:\n # It's okay to use a model's property if it has a setter.\n if not (param in property_names and getattr(self.model, param).fset):\n invalid_params.append(param)\n if invalid_params:\n raise exceptions.FieldError(\n \"Invalid field name(s) for model %s: '%s'.\"\n % (\n self.model._meta.object_name,\n \"', '\".join(sorted(invalid_params)),\n )\n )\n return params","def getorderparam(name):\n for num in cherrypy.request.params.get(name, '').split(','):\n if num.strip() == '':\n continue\n try:\n yield int(num)\n except ValueError:\n raise cherrypy.HTTPError(400)","def GetUniqueParam(self, name):\n if not hasattr(self, '_params'):\n self._params = cgi.parse_qs(self.path[self.path.find('?') + 1:])\n\n param_list = self._params.get(name, [])\n if len(param_list) == 1:\n return param_list[0]\n return None","def _parse_user_input(self):\n user_input = self.user_input.strip()\n if user_input:\n if user_input.find(',') > -1:\n # Location is either city/state or latitude/longitude.\n if user_input[0].isalpha():\n # City, state (lat/long handled elsewhere)\n city, state = [x.strip() for x in user_input.split(',')]\n self.city = city\n self.state = state\n elif (len(user_input) <= 10 and\n user_input[1].isdigit()): # 2nd char in US/Can. postal codes\n # Postal code\n self.postal_code = user_input.strip()","def parse_for_filters(query_string):\n if ';' in query_string:\n strings = query_string.split(';')\n else:\n strings = query_string.split('&')\n\n filters = []\n leftovers = [] \n for string in strings:\n query = cgi.parse_qs(string)\n try:\n key, value = query.items()[0]\n\n try:\n argument = unicode(value[0], 'UTF-8')\n except TypeError:\n argument = value[0]\n\n func = FILTER_PARSERS[key](argument)\n filters.append(func)\n except(KeyError, IndexError):\n leftovers.append(string)\n\n leftovers = ';'.join(leftovers)\n return filters, leftovers","def getParsedQueryString(self):\n return cgi.parse_qs(self.query_string)","def get_param(query, config):\n keys = query.split('.')\n if len(keys) == 1:\n key = keys[0]\n if not config.has_key(key):\n return None\n return config[key]\n else:\n return Config.get_nested_param(keys, config)","def parse_query(request):\n\n querystring = request.uri['query']\n fp = StringIO(querystring)\n\n headers = {}\n headers['content-type'] = request.message.get('content-type')\n headers['content-length'] = request.message.get('content-length')\n\n environ = {}\n environ['REQUEST_METHOD'] = request.method\n\n boundary = request.message.get('boundary')\n\n query = cgi.FieldStorage( fp = fp\n , headers = headers\n , outerboundary = boundary\n , environ = environ\n , keep_blank_values = True\n , strict_parsing = False\n )\n\n return query","def _get_query_params(self, req):\n params = {\n 'filters': self._get_filters(req),\n 'limit': self._get_limit(req),\n 'sort_key': [self._get_sort_key(req)],\n 'sort_dir': [self._get_sort_dir(req)],\n 'marker': self._get_marker(req),\n }\n\n for key, value in params.items():\n if value is None:\n del params[key]\n\n return params","def param_name(p):\n prefix = ['limit_', 'error_', 'fix_']\n for prf in prefix:\n if p.startswith(prf):\n return p[len(prf):]\n return p","def _pre_argument_parsing(self):\n pass","def split_url_and_query_params(url):\n scheme, netloc, path, query_string, fragment = urlsplit(url)\n query_params = parse_qs(query_string)\n url = urlunsplit((scheme, netloc, path, None, fragment))\n return url, query_params","def test_process_query(self):\n self.assertEqual(process_query(\"\"), \"\")\n self.assertEqual(process_query(\"org\"), \"org:*\")\n self.assertEqual(process_query(\"a b\"), \"a & b:*\")\n self.assertEqual(process_query(\"(foo bar)\"), \"foo & bar:*\")","def url_get_params(url):\n\n def cast_int(v):\n \"\"\"\n Try and convert a param to int\n :param v:\n :return:\n \"\"\"\n try:\n return int(v)\n except ValueError:\n return v\n\n parsed_url = urlparse.urlparse(httpretty.last_request().path)\n url_params = {k: cast_int(v) for k, v in dict(urlparse.parse_qsl(parsed_url.query)).items()}\n return url_params","def _check_validparam(self, symbol):\n if symbol.type == self.scanner.KEYWORD and \\\n symbol.id in self.validparamids:\n return True\n else:\n return False","def parse(self, request):\n result = {}\n if request.method.lower() == 'post':\n params = request.get_json(\n cache=False) if request.mimetype == 'application/json' else request.form\n else:\n params = request.args\n for arg in self.args:\n if arg.name in params:\n if arg.type is not None and type(params[arg.name]) != arg.type:\n try:\n result[arg.name] = arg.coerce(params[arg.name])\n except Exception as err:\n current_app.logger.warning('Coercion failed for param: {}'.format(arg.name))\n raise ApiError('Coercion failed for param: {}'.format(arg.name), 'ArgsParserException', 1, status_code=400)\n abort(400)\n else:\n result[arg.name] = params[arg.name]\n elif arg.required:\n current_app.logger.warning(\"Missing required param: {}\".format(arg.name))\n raise ApiError('Missing required param: {}'.format(arg.name), 'ArgsParserException', 2, status_code=400)\n abort(400)\n else:\n result[arg.name] = arg.default\n return result","def get_params(self):\r\n query = urlparse.urlparse(self.path).query\r\n\r\n # By default, `parse_qs` returns a list of values for each param\r\n # For convenience, we replace lists of 1 element with just the element\r\n return {\r\n k:v[0] if len(v) == 1 else v\r\n for k,v in urlparse.parse_qs(query).items()\r\n }","def limited_parse_qsl(qs, keep_blank_values=False, encoding='utf-8',\n errors='replace', fields_limit=None):\n date = {'phenomenonTime', 'resultTime', 'validTime'}\n FIELDS_MATCH = re.compile('[&]')\n pairs = FIELDS_MATCH.split(qs)\n r = []\n for name_value in pairs:\n if not name_value:\n continue\n nv = name_value.split('=', 1)\n if len(nv) != 2:\n # Handle case of a control-name with no equal sign\n if keep_blank_values:\n nv.append('')\n else:\n continue\n if nv[1] or keep_blank_values:\n name = nv[0].replace('+', ' ')\n name = nv[0]\n name = unquote(name, encoding=encoding, errors=errors)\n if not any(a in nv[1] for a in date):\n value = nv[1].replace('+', ' ')\n value = nv[1]\n value = unquote(value, encoding=encoding, errors=errors)\n r.append((name, value))\n query_dict = {}\n for key, value in r:\n query_dict[key] = value\n return query_dict"],"string":"[\n \"def _parse_params(self, params):\\r\\n if params[0] == \\\":\\\":\\r\\n params = [params[1:]]\\r\\n else:\\r\\n params = params.split(\\\" :\\\", 1)\\r\\n if len(params) == 1:\\r\\n last_arg = None\\r\\n else:\\r\\n last_arg = params[1]\\r\\n params = params[0].split(None)\\r\\n if last_arg != None:\\r\\n params.append(last_arg)\\r\\n return params\",\n \"def parse_query_params(query_string):\\n # Parse the query param string\\n parsed = urlparse(query_string)\\n print(parsed)\\n query_params = dict(parse_qs(parsed.path))\\n print(query_params)\\n # Get the value from the list\\n query_params = {k: v[0] for k, v in query_params.items()}\\n return query_params\",\n \"def get_params(raw):\\n parts = raw.split(\\\" \\\", 1)\\n return None if len(parts) == 1 else parts[1]\",\n \"def _urlparse_splitquery(url):\\r\\n\\r\\n qpart = url.split(\\\"?\\\", 1)\\r\\n if len(qpart) == 2:\\r\\n query = qpart[1]\\r\\n else:\\r\\n query = \\\"\\\"\\r\\n\\r\\n return qpart[0], query\",\n \"def parseQueryString():\\n\\tqs = cgi.FieldStorage()\\n\\treturn({'char': qs.getvalue('char'), 'zone': qs.getvalue('zone')})\",\n \"def parse_query_string(self, params):\\n results = {}\\n\\n for key, val in params.items():\\n lookup_len = len(self.query_string_lookup) + 1\\n\\n if key[0:lookup_len] == '{}['.format(self.query_string_lookup) and key[-1] == ']':\\n results[key[lookup_len:-1]] = val if val.lower() != 'null' else None\\n\\n return results\",\n \"def _split_url_string(param_str):\\n parameters = parse_qs(param_str, keep_blank_values=False)\\n for key, val in parameters.iteritems():\\n parameters[key] = urllib.unquote(val[0])\\n return parameters\",\n \"def parse_query_string(self, params):\\n results = {}\\n\\n for key, val in params.items():\\n lookup_len = len(self.query_string_lookup) + 1\\n\\n if key[0:lookup_len] == '{}['.format(self.query_string_lookup) and key[-1] == ']':\\n results[key[lookup_len:-1]] = val\\n\\n return results\",\n \"def func_PARSE(self):\\n self.parsed_url = parse.urlparse(\\\"http://{0}:{1}{2}\\\".format(args.HTTP_HOST, args.HTTP_PORT, self.path).lower())\\n self.parsed_param = parse.parse_qs(self.parsed_url[4])\",\n \"def parse_get_values(self): \\n self.parse_values(os.environ[\\\"QUERY_STRING\\\"])\",\n \"def _split_url_string(query_string):\\r\\n parameters = parse_qs(to_utf8(query_string), keep_blank_values=True)\\r\\n for k, v in parameters.iteritems():\\r\\n parameters[k] = urllib.unquote(v[0])\\r\\n return parameters\",\n \"def _check_params(self):\\n\\t\\tstrange_param_helper = False\\n\\t\\tfor param in self.params:\\n\\t\\t\\n\\t\\t\\t# It could be that the param encapsulates several values (e.g., \\\"FLUX_RADIUS(10)\\\")\\n\\t\\t\\t# So we have to dissect this\\n\\t\\t\\tmatch = re.compile(\\\"(\\\\w*)\\\\(\\\\d*\\\\)\\\").match(param)\\n\\t\\t\\tif match:\\n\\t\\t\\t\\tcleanparam = match.group(1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcleanparam = param\\n\\t\\t\\t\\t\\n\\t\\t\\tif cleanparam not in self.fullparamlist:\\n\\t\\t\\t\\tlogger.warning(\\\"Parameter '%s' seems strange and might be unknown to SExtractor\\\" \\\\\\n % (param))\\n\\t\\t\\t\\tstrange_param_helper = True\\n\\t\\t\\t\\t\\n\\t\\tif strange_param_helper:\\n\\t\\t\\tlogger.warning(\\\"Known parameters are: %s\\\" % (self.fullparamtxt))\",\n \"def clean_params(self, url):\\n if isinstance(url, unicode):\\n url = url.encode(\\\"utf-8\\\")\\n parts = list(urlparse.urlsplit(url))\\n if not parts[3]:\\n return url\\n query = urlparse.parse_qsl(parts[3])\\n query = [q for q in query if self._is_param_allowed(*q)]\\n if query:\\n parts[3] = urllib.urlencode(query)\\n else:\\n parts[3] = ''\\n return urlparse.urlunsplit(parts).decode(\\\"utf-8\\\")\",\n \"def parse_from_request(self, name, request):\\n # type: (str, Request) -> Any\\n name_bytes = name.encode()\\n if name_bytes not in request.args:\\n if self.default is not None:\\n return self.default\\n if self.required:\\n raise Error(BAD_REQUEST, message=b\\\"%s is required\\\" % name_bytes)\\n else:\\n return None\\n\\n if len(request.args[name_bytes]) != 1:\\n raise Error(BAD_REQUEST, message=b\\\"Pass exactly one argument for %s\\\" % name_bytes)\\n\\n val = request.args[name_bytes][0]\\n return self.parse(val)\",\n \"def validate_query_parameters(self, request):\\n offset = int(request.args.get('offset')) if request and request.args and request.args.get('offset') and int(request.args.get('offset')) >= s.DEFAULT_OFFSET else s.DEFAULT_OFFSET\\n limit = int(request.args.get('limit')) if request and request.args and request.args.get('limit') and int(request.args.get('limit')) <= s.DEFAULT_LIMIT else s.DEFAULT_LIMIT\\n return [offset, limit]\",\n \"def get_query_params(query):\\n params = {}\\n if query:\\n delim = \\\"&\\\"\\n if \\\"&\\\" not in query and \\\";\\\" in query:\\n delim = \\\";\\\"\\n for k_v in query.split(delim):\\n k, v = k_v, \\\"\\\"\\n if \\\"=\\\" in k_v:\\n k, v = k_v.split(\\\"=\\\")\\n params[k] = v\\n return params\",\n \"def input(self, name):\\n try:\\n _input = self.params[name]\\n try:\\n _input = _input.strip()\\n except AttributeError:\\n pass\\n if _input == '':\\n return None\\n return _input\\n except KeyError:\\n return None\",\n \"def parse_agenda_filter_params(querydict):\\n if len(querydict) == 0:\\n return None\\n\\n # Parse group filters from GET parameters. Other params are ignored.\\n filt_params = {'show': set(), 'hide': set(), 'showtypes': set(), 'hidetypes': set()}\\n\\n for key, value in querydict.items():\\n if key in filt_params:\\n vals = unquote(value).lower().split(',')\\n vals = [v.strip() for v in vals]\\n filt_params[key] = set([v for v in vals if len(v) > 0]) # remove empty strings\\n\\n return filt_params\",\n \"def url_parse_query(query, encoding=None):\\n if isinstance(query, unicode):\\n if encoding is None:\\n encoding = url_encoding\\n query = query.encode(encoding, 'ignore')\\n query = query.replace('?', '')\\n\\n l = set()\\n for k, v, sep in parse_qsl(query, True):\\n k = url_quote_part(k, '/-:,;')\\n if not k:\\n continue\\n if v:\\n v = url_quote_part(v, '/-:,;')\\n l.add(\\\"%s=%s\\\" % (k, v))\\n elif v is None:\\n l.add(\\\"%s\\\" % k)\\n else:\\n # some sites do not work when the equal sign is missing\\n l.add(\\\"%s=\\\" % k)\\n query = '&'.join(sorted(l))\\n return query\",\n \"def _get_param_from_request(self, nombreParametro):\\n\\t\\treturn request.args.get(nombreParametro)\",\n \"def parse_request(self, request):\\n request = str(request)\\n str_start = request.find(\\\"GET /?\\\")\\n str_end = request.find(\\\"HTTP\\\")\\n str_full = request[str_start + 6:str_end - 1]\\n\\n options = {}\\n temp_option = []\\n temp_selector = \\\"\\\"\\n\\n for i, letter in enumerate(str_full):\\n if letter == \\\"=\\\":\\n options[\\\"\\\".join(temp_option)] = []\\n temp_selector = \\\"\\\".join(temp_option)\\n temp_option = []\\n elif letter == \\\"&\\\":\\n options[temp_selector] = \\\"\\\".join(temp_option)\\n temp_selector = \\\"\\\"\\n temp_option = []\\n elif i + 1 >= len(str_full):\\n temp_option.append(letter)\\n options[temp_selector] = \\\"\\\".join(temp_option)\\n else:\\n temp_option.append(letter)\\n\\n return options\",\n \"def _parse_params(params):\\n for key, value in params.items():\\n if value.lower() in ('none', 'null', ''):\\n params[key] = None\\n elif value.lower() == 'true':\\n params[key] = True\\n elif value.lower() == 'false':\\n params[key] = False\\n elif value.isdigit() or (value[0] == '-' and value[1:].isdigit()):\\n params[key] = int(value)\\n elif ',' in value:\\n params[key] = list(map(lambda x: x.strip(), value.split(',')))\\n else:\\n try:\\n params[key] = float(value)\\n except:\\n pass\\n return params\",\n \"def parse_query(query):\\n qlist = []\\n splitted = query.split(\\\"&\\\")\\n for entry in splitted:\\n cmd, arg = entry.split(\\\"=\\\")\\n qlist.append((cmd, arg))\\n return qlist\",\n \"def parseURL(url):\\n\\n\\n scheme, host, path, params, query, hash = urlparse(url)\\n if not path: path = \\\"/\\\"\\n\\n args = parse_qs(query)\\n\\n escapedArgs = {}\\n for name in args:\\n if len(args[name]) == 1:\\n escapedArgs[unquote(name)] = unquote(args[name][0])\\n else:\\n escapedArgs[unquote(name)] = escapedSet = []\\n for item in args[name]:\\n escapedSet.append(unquote(item))\\n\\n return host, path, params, escapedArgs\",\n \"def parse(cls, value: str) -> Tuple[str, Dict[str, str]]:\\n raw_value = read_value_from_path(value)\\n args: Dict[str, str] = {}\\n\\n if \\\"@\\\" in raw_value:\\n args[\\\"region\\\"], raw_value = raw_value.split(\\\"@\\\", 1)\\n\\n # now find any other arguments that can be filters\\n matches = re.findall(r\\\"([0-9a-zA-z_-]+:[^\\\\s$]+)\\\", raw_value)\\n for match in matches:\\n k, v = match.split(\\\":\\\", 1)\\n args[k] = v\\n\\n return args.pop(\\\"name_regex\\\"), args\",\n \"def params_from_request(request):\\n params_dict = {}\\n for key, value in request.arguments.items():\\n if len(value) == 1:\\n params_dict[key] = value[0].decode('UTF-8')\\n else:\\n params_dict[key] = []\\n for part in value:\\n params_dict[key].append(part.decode('UTF-8'))\\n return params_dict\",\n \"def validated_parameter(args, name, values=None, default=None, case_sensitive=False):\\n\\n param = args.get(name)\\n if param:\\n param = param.lower()\\n else:\\n param = default\\n\\n if not values:\\n return param\\n else:\\n if values and param not in values:\\n list_str = \\\", \\\".join(values)\\n raise RequestError(\\\"Parameter '%s' should be one of: %s\\\"\\n % (name, list_str) )\\n return param\",\n \"def parse_request_path( self, path ):\\n path_parts = path.strip(\\\"/\\\").split(\\\"/\\\")\\n \\n if len(path_parts) == 0:\\n # invalid \\n return (None, None)\\n \\n if len(path_parts) > 2:\\n # invalid\\n return (None, None)\\n \\n slice_name = path_parts[0]\\n if len(slice_name) == 0:\\n # empty string is invalid \\n return (None, None)\\n \\n volume_name = None\\n \\n if len(path_parts) > 1:\\n volume_name = path_parts[1]\\n \\n return slice_name, volume_name\",\n \"def _parse_in_request(self, request):\\n error = None\\n self.logger.debug(\\\"Http method: %s\\\" % request.method)\\n if request.method == 'GET':\\n self._params = request.args.to_dict()\\n self.logger.debug(\\\"Request params: %s\\\" % self._params)\\n \\n elif request.method == 'POST':\\n self._params = request.form.to_dict()\\n self.logger.debug(\\\"Request params: %s\\\" % self._params)\",\n \"def get_parameter(request, param):\\n if param == \\\"Params\\\":\\n return request.split(\\\"\\\\r\\\\n\\\\r\\\\n\\\")[1]\\n if isinstance(param, type([])):\\n return [request.split(\\\"\\\\r\\\\n\\\\r\\\\n\\\")[1] if x == \\\"Param\\\" else request.split(x + \\\": \\\")[1].split(\\\"\\\\r\\\\n\\\")[0] for x in param]\\n if isinstance(param, type(\\\"\\\")):\\n return request.split(param + \\\": \\\")[1].split(\\\"\\\\r\\\\n\\\")[0]\",\n \"def query_params_sanitize(query_params):\\n def allow_func(n, v):\\n # This gets rid of any params beginning with \\\"oauth_\\\"\\n if not n.startswith(\\\"oauth_\\\"):\\n return True\\n else:\\n logging.warning(\\\"Protocol parameter ignored from URL query parameters: `%r`\\\", n)\\n return False\\n return query_filter(query_params, allow_func=allow_func)\",\n \"def _params(self, qs):\\n return [str_id for str_id in qs.split(',')]\",\n \"def parse_request(self, request: str) -> tuple:\\n parts = request.split(b\\\" \\\")\\n return parts[0], parts[1]\",\n \"def parse_querystring(request):\\n url = request.args.get('url', settings.default_iframe_url)\\n if not url.startswith('http:') and not url.startswith('https:'):\\n url = \\\"http://\\\" + url\\n\\n try:\\n width = int(request.args.get(\\\"width\\\"))\\n except Exception as e:\\n width = settings.default_size[0]\\n\\n try:\\n height = int(request.args.get(\\\"height\\\"))\\n except:\\n height = settings.default_size[1]\\n\\n return url, width, height\",\n \"def find_params_in_url(url):\\n\\n # self.logger.debug('Find params in url: %s', url)\\n\\n rid = None\\n wid = None\\n wname = None\\n\\n url_parsed = urlparse(url)\\n query = parse_qs(url_parsed.query)\\n if 'w' in query:\\n wid = query['w'][0]\\n if query['w'][0] in G_VV:\\n wname = G_VV[query['w'][0]]\\n\\n if 'rid' in query:\\n rid = query['rid'][0]\\n\\n return {'rid': rid, 'w': wname, 'wid': wid}\",\n \"def parse_param(description: str) -> (str, int):\\n name, value = re.split(': ', description)\\n return name, int(value)\",\n \"def test_additional_query_args():\\n assert (normalize_url(\\\"http://example.com?c=d\\\", [(\\\"a\\\", \\\"b\\\")]) ==\\n \\\"http://example.com/?a=b&c=d\\\")\\n assert (normalize_url(\\\"http://example.com\\\", [(\\\"a\\\", \\\"b\\\")]) ==\\n \\\"http://example.com/?a=b\\\")\\n assert (normalize_url(\\\"http://example.com\\\", [(\\\"résumé\\\", \\\"résumé\\\")]) ==\\n \\\"http://example.com/?r%C3%A9sum%C3%A9=r%C3%A9sum%C3%A9\\\")\",\n \"def _parse_params( self ):\\n paramDic={}\\n # Parameters are on the 3rd arg passed to the script\\n paramStr=sys.argv[2]\\n print paramStr\\n if len(paramStr)>1:\\n paramStr = paramStr.replace('?','')\\n \\n # Ignore last char if it is a '/'\\n if (paramStr[len(paramStr)-1]=='/'):\\n paramStr=paramStr[0:len(paramStr)-2]\\n \\n # Processing each parameter splited on '&' \\n for param in paramStr.split(\\\"&\\\"):\\n try:\\n # Spliting couple key/value\\n key,value=param.split(\\\"=\\\")\\n except:\\n key=param\\n value=\\\"\\\"\\n \\n key = urllib.unquote_plus(key)\\n value = urllib.unquote_plus(value)\\n \\n # Filling dictionnary\\n paramDic[key]=value\\n print paramDic\\n return paramDic\",\n \"def check_search_argument(search):\\n\\n if search != '' and not re.match(r\\\"^(([\\\\w.:\\\\/\\\\-)+\\\\=([\\\\w.:\\\\/\\\\-])+\\\\s?)+\\\", search):\\n print(\\\"The search items must match the format 'field=string'\\\")\\n sys.exit(0)\\n search_items = search.split(' ')\\n\\n return search_items\",\n \"def separate_query_params(\\n url: str, param_names: Optional[Iterable[str]] = None\\n ) -> Tuple[str, Mapping[str, Iterable[str]]]:\\n o = urlparse(url)\\n qp = parse_qs(o.query, keep_blank_values=True)\\n\\n # Separate requested parameters from the query parameters\\n params = {\\n k: v for k, v in qp.items() if param_names is None or k in param_names\\n }\\n for p in params:\\n qp.pop(p)\\n\\n # Rebuild url with the remaining query parameters\\n qs = urlencode(qp, doseq=True, quote_via=quote)\\n url = urlunparse(o._replace(query=qs))\\n\\n return url, params\",\n \"def _parse_form_data():\\n form_data = str(request.get_data())\\n if form_data[:2] == \\\"b'\\\":\\n # looks like b'A=1&B=2'\\n form_data = form_data[2:-1]\\n for key, values in parse_qs(form_data).items():\\n yield (key, values[0])\",\n \"def parse_form_params(body):\\n # type: (unicode) -> dict[unicode, unicode|list[unicode]]\\n body_params = body.replace(\\\"+\\\", \\\" \\\")\\n req_body = dict() # type: dict[unicode, unicode|list[unicode]]\\n for item in body_params.split(\\\"&\\\"):\\n key, equal, val = item.partition(\\\"=\\\")\\n if equal:\\n key = parse.unquote(key)\\n val = parse.unquote(val)\\n prev_value = req_body.get(key, None)\\n if prev_value is None:\\n req_body[key] = val\\n elif isinstance(prev_value, list):\\n prev_value.append(val)\\n else:\\n req_body[key] = [prev_value, val]\\n return req_body\",\n \"def parse_request_arg_dict(arg, exception_class=Exception):\\n arg_dict = {}\\n arg_pairs = arg.split(';')\\n for arg_pair in arg_pairs:\\n try:\\n arg_name, arg_value = arg_pair.split('=', 1)\\n except Exception as error:\\n logging.exception(error)\\n raise exception_class(\\n 'there is no `=` in %s' % arg_pair\\n )\\n arg_dict[arg_name] = arg_value\\n return arg_dict\",\n \"def normalize_params(url, params):\\n # parse the url\\n parse = urlparse(url)\\n\\n # Get the query list\\n qs_list = parse_qsl(parse.query, keep_blank_values=True)\\n must_encode = False if parse.query == urllib.parse.unquote(parse.query) else True\\n if params is None:\\n combined_list = qs_list\\n else:\\n # Needs to be encoded before sorting\\n combined_list = [encode_pair(must_encode, key, value) for (key, value) in list(qs_list)]\\n combined_list += params.items()\\n\\n encoded_list = [\\\"%s=%s\\\" % (key, value) for (key, value) in combined_list]\\n sorted_list = sorted(encoded_list, key=lambda x: x)\\n\\n return \\\"&\\\".join(sorted_list)\",\n \"def validatePayload(q, request):\\r\\n\\t\\tassert type(q) is str\\r\\n\\t\\t# Queries with subtitutions must have the format {var.type} for input validation purposes.\\r\\n\\t\\tformatType = Validator.getFormatType(request)\\r\\n\\t\\tif formatType == 'str':\\r\\n\\t\\t\\titems = request.args.items()\\r\\n\\t\\t\\tpayload = {}\\r\\n\\t\\t\\t[payload.update({item[0]: item[1]}) for item in items]\\r\\n\\t\\telif formatType == 'json':\\r\\n\\t\\t\\tpayload = request.get_json()\\r\\n\\t\\t\\tpayload = json.loads(payload) if payload else None\\r\\n\\t\\telif formatType == 'urlencoded':\\r\\n\\t\\t\\tpayload = {item:request.form[item] for item in request.form}\\r\\n\\t\\t\\tif payload is None:\\r\\n\\t\\t\\t\\titems = request.args.items()\\r\\n\\t\\t\\t\\tpayload = {}\\r\\n\\t\\t\\t\\t[payload.update({item[0]: item[1]}) for item in items]\\r\\n\\t\\tnewQuery, expectedParamsAndTypes = Validator.extractQueryParams(q)\\r\\n\\t\\tpayload = Validator.validateJsonRequestParams(payload, expectedParamsAndTypes, formatType)\\r\\n\\t\\treturn (payload, newQuery)\",\n \"def query_string_get(request, name, default_value=_NOT_SET, validator=None):\\n return _XXX_get(request.rel_url.query, name, default_value, validator)\",\n \"def _validate_query_parameters(self, parameters=None):\\n if parameters is None:\\n parameters = {}\\n\\n validated_parameters = {} # dictionary to return\\n\\n for key in parameters:\\n if key in self._query_parameters:\\n if key in ['limit', 'offset']:\\n if isinstance(parameters[key], int):\\n validated_parameters[key] = \\\"%i\\\" % parameters[key]\\n elif key == 'format':\\n if parameters[key] in self._query_parameters[key]:\\n validated_parameters[key] = parameters[key]\\n elif key == 'columns':\\n # replace '+' by a space and separate the commas\\n column_entry = parameters[key].replace('+', ' ').split(',')\\n\\n set_a = set(self._query_parameters[key])\\n set_b = set(column_entry)\\n validated_items = set_a.intersection(set_b) # disordered set\\n validated_column_entry = [] # ordered list\\n for item in column_entry:\\n # reorder the set in a list to keep the same order as the entry\\n if item in validated_items:\\n validated_column_entry.append(item)\\n validated_parameters[key] = \\\",\\\".join(validated_column_entry).replace(' ', '+')\\n elif key in ['include', 'compress', 'sort']:\\n if parameters[key] in self._query_parameters[key]:\\n validated_parameters[key] = parameters[key]\\n\\n return validated_parameters\",\n \"def _get_query_part(params: dict) -> str:\\n params_cleaned = {k: v for k, v in params.items() if v is not None}\\n return ('?' + urlencode(params_cleaned, quote_via=quote, safe=\\\"/,\\\")) if params_cleaned else \\\"\\\"\",\n \"def _split_name(name):\\n name_split = name.split('_view_')\\n view_num = None\\n if(len(name_split) > 1):\\n view_num = int(name_split[1])\\n optimizer_key = ''\\n fp16_key = ''\\n if name_split[0].startswith('Moment_1'):\\n optimizer_key = 'Moment_1_'\\n elif name_split[0].startswith('Moment_2'):\\n optimizer_key = 'Moment_2_'\\n elif name_split[0].startswith('Update_Count'):\\n optimizer_key = 'Update_Count_'\\n elif name_split[0].endswith('_fp16'):\\n fp16_key = '_fp16'\\n param_name = name_split[0]\\n if optimizer_key != '':\\n param_name = param_name.split(optimizer_key)[1]\\n param_name = param_name.split('_fp16')[0]\\n return param_name, optimizer_key, view_num, fp16_key\",\n \"def set_query_parameter(url, param_name, param_value):\\n scheme, netloc, path, query_string, fragment = urlsplit(url)\\n query_params = parse_qs(query_string)\\n\\n deleted = False\\n for _, value in query_params.items():\\n if param_value in value:\\n deleted = True\\n\\n if deleted:\\n query_params.pop(param_name, None)\\n clear = True\\n if not deleted:\\n query_params[param_name] = param_value\\n clear = False\\n\\n new_query_string = urlencode(query_params, doseq=True)\\n url = urlunsplit((scheme, netloc, path, new_query_string, fragment))\\n\\n return url, clear\",\n \"def inspect_query(querystring: str) -> dict:\\n return _parse_query(querystring)\",\n \"def test_url_line_parser_params(self):\\n line = \\\"GET /path?var=val&var2=val2 HTTP/1.1\\\"\\n method, url, params, version = parser._parse_url_line(line, endpoint)\\n self.assertEqual(\\\"GET\\\", method)\\n self.assertEqual(\\\"http://test.com/path\\\", url)\\n self.assertEqual({\\\"var\\\": \\\"val\\\", \\\"var2\\\": \\\"val2\\\"}, params)\\n self.assertEqual(\\\"HTTP/1.1\\\", version)\",\n \"def test_url_params(self):\\n params = ct.url_params(\\\"https://www.bad-actor.services/some/url-thats-long?debug=True&this=that\\\")\\n assert isinstance(params, dict)\\n assert len(params) == 2\\n assert params[\\\"debug\\\"] == \\\"True\\\"\\n assert params[\\\"this\\\"] == \\\"that\\\"\",\n \"def get_params(url=None):\\r\\n dict = {}\\r\\n if not url:\\r\\n url = sys.argv[2]\\r\\n pairs = url.lstrip(\\\"?\\\").split(\\\"&\\\")\\r\\n for pair in pairs:\\r\\n if len(pair) < 3:\\r\\n continue\\r\\n kv = pair.split(\\\"=\\\", 1)\\r\\n k = kv[0]\\r\\n v = urllib.parse.unquote_plus(kv[1])\\r\\n dict[k] = v\\r\\n return dict\",\n \"def getParams(text):\\n s = text.split('=')\\n for i in range(len(s)):\\n s[i] = s[i].strip()\\n\\n param = s[0]\\n val = s[1]\\n # Assume that there are two values only: (variable, value) pair\\n assert len(s) == 2\\n \\n return (param, val)\",\n \"def _parse_and_validate(self, val):\\n if self._is_parameter_type:\\n val = self._parse(val) if isinstance(val, str) else val\\n self._validate_or_throw(val)\\n return val\",\n \"def _get_unvalidated_auth_params(self, request):\\n try:\\n params = parse_authz_header(request)\\n except ValueError:\\n params = None\\n if params is None:\\n return None\\n if params[\\\"scheme\\\"].lower() != \\\"srp-hmac\\\":\\n return None\\n return params\",\n \"def fetch_required_param_name(cmd):\\n try:\\n case_no = current_config.COMMAND_DICT[cmd]\\n if case_no == 1:\\n \\\"\\\"\\\"Create_parking_lot\\\"\\\"\\\"\\n return [\\\"slots\\\"]\\n elif case_no == 2:\\n \\\"\\\"\\\"Park\\\"\\\"\\\"\\n return [\\\"reg_no\\\", \\\"age\\\"]\\n elif case_no == 3:\\n \\\"\\\"\\\" Leave \\\"\\\"\\\"\\n return [\\\"slot_no\\\"]\\n elif case_no == 4:\\n \\\"\\\"\\\"Vehicle_registration_number_for_driver_of_age\\\"\\\"\\\"\\n return [\\\"age\\\"]\\n elif case_no == 5:\\n \\\"\\\"\\\"Slot_numbers_for_driver_of_age\\\"\\\"\\\"\\n return [\\\"age\\\"]\\n elif case_no == 6:\\n \\\"\\\"\\\"Slot_number_for_car_with_number\\\"\\\"\\\"\\n return [\\\"reg_no\\\"]\\n except KeyError:\\n return\\n # logger.debug(\\\"Something wrong with input\\\")\\n # raise InvalidParams(\\\"Something wrong with input\\\")\",\n \"def _parse(url):\\n url = url.strip()\\n parsed = urlparse(url)\\n return _parsed_url_args(parsed)\",\n \"def nameset(request, model):\\n if 'name' not in request.GET:\\n return model.objects.all()\\n\\n if 'name' in request.GET:\\n namestr = request.GET['name']\\n if ',' in namestr:\\n return model.objects.filter(name__in=namestr)\\n else:\\n return model.objects.filter(name__icontains=namestr)\",\n \"def __get_parameters(self, url):\\n rest_url = url.split('?')\\n parameter_tuple = ()\\n if len(rest_url) > 1:\\n target_url = rest_url[1]\\n variable_pairs = target_url.split(self.__param_delimiter)\\n for one_pair in variable_pairs:\\n key_value_pair = one_pair.split(\\\"=\\\")\\n if len(key_value_pair) == 2:\\n parameter_tuple += (tuple(key_value_pair),)\\n return parameter_tuple\\n return None\",\n \"def _clean_and_encode_params(params: Mapping):\\n # Keep only the parameters that were given a value\\n params = {k: v for k, v in params.items() if v is not None}\\n\\n # All query parameters are later urlencoded - for projection, comma-separated\\n # list is supported only on literal comma; convert comma-separated list\\n # to a list of values which will be encoded to multiple query parameters\\n try:\\n params[\\\"projection\\\"] = [x.strip() for x in params[\\\"projection\\\"].split(\\\",\\\")]\\n except KeyError:\\n pass\\n return params\",\n \"def test_unspecified_excluded(self):\\n handler = self.create_handler(r'unspecified1=foo&unspecified2=5')\\n self.assertEqual(handler.get_params(), {})\",\n \"def _get_query_params(self, req):\\n params = {}\\n for PARAM in SUPPORTED_PARAMS:\\n if req and PARAM in req:\\n params[PARAM] = req.get(PARAM)\\n\\n return params\",\n \"def test_splitParamArgs(self):\\n res = irc.ServerSupportedFeatures._splitParamArgs([\\\"A:1\\\", \\\"B:2\\\", \\\"C:\\\", \\\"D\\\"])\\n self.assertEqual(res, [(\\\"A\\\", \\\"1\\\"), (\\\"B\\\", \\\"2\\\"), (\\\"C\\\", \\\"\\\"), (\\\"D\\\", \\\"\\\")])\",\n \"def _find_params_value_of_url(self, services, url):\\n values_of_query = list()\\n url_split = url.split(\\\"/\\\")\\n values = [item for item in url_split if item not in services and item != '']\\n for v in values:\\n if v != None:\\n values_of_query.append(v)\\n return values_of_query\",\n \"def url_query_cleaner(url, parameterlist=(), sep='&', kvsep='=', remove=False, unique=True, keep_fragments=False):\\n\\n if isinstance(parameterlist, (six.text_type, bytes)):\\n parameterlist = [parameterlist]\\n url, fragment = urldefrag(url)\\n base, _, query = url.partition('?')\\n seen = set()\\n querylist = []\\n for ksv in query.split(sep):\\n if not ksv:\\n continue\\n k, _, _ = ksv.partition(kvsep)\\n if unique and k in seen:\\n continue\\n elif remove and k in parameterlist:\\n continue\\n elif not remove and k not in parameterlist:\\n continue\\n else:\\n querylist.append(ksv)\\n seen.add(k)\\n url = '?'.join([base, sep.join(querylist)]) if querylist else base\\n if keep_fragments:\\n url += '#' + fragment\\n return url\",\n \"def get_request_param(request: web.Request, name: str, error_if_missing: bool = True) -> Optional[str]:\\n if name not in request.rel_url.query:\\n if error_if_missing:\\n raise errors.NotFound()\\n else:\\n return None\\n ret = request.rel_url.query[name]\\n return ret\",\n \"def parse_query_string(s):\\n res = {}\\n pairs = s.split('&')\\n for p in pairs:\\n vals = [urldecode_plus(x) for x in p.split('=', 1)]\\n if len(vals) == 1:\\n res[vals[0]] = ''\\n else:\\n res[vals[0]] = vals[1]\\n return res\",\n \"def parse_query_param(url, param):\\n\\n try:\\n return parse.parse_qs(parse.urlparse(url).query)[param][0]\\n except:\\n return None\",\n \"def check_param(self, param_str):\\n param_groups = None\\n \\\"\\\"\\\" Initial param cosmetic adjustment \\\"\\\"\\\"\\n param_str = param_str.strip()\\n\\n \\\"\\\"\\\" Cherck the param syntax \\\"\\\"\\\"\\n for key, pattern in self.patterns.items():\\n param_groups = re.fullmatch(pattern, param_str)\\n if param_groups:\\n return True\\n return False\",\n \"def check_param(self, param_str):\\n param_groups = None\\n \\\"\\\"\\\" Initial param cosmetic adjustment \\\"\\\"\\\"\\n param_str = param_str.strip()\\n\\n \\\"\\\"\\\" Cherck the param syntax \\\"\\\"\\\"\\n for key, pattern in self.patterns.items():\\n param_groups = re.fullmatch(pattern, param_str)\\n if param_groups:\\n return True\\n return False\",\n \"def test_query_string():\\n assert (normalize_url(\\\"http://example.com/?a=1\\\") ==\\n \\\"http://example.com/?a=1\\\")\\n assert (normalize_url(\\\"http://example.com?a=1\\\") ==\\n \\\"http://example.com/?a=1\\\")\\n assert (normalize_url(\\\"http://example.com/a?b=1\\\") ==\\n \\\"http://example.com/a?b=1\\\")\\n assert (normalize_url(\\\"http://example.com/a/?b=1\\\") ==\\n \\\"http://example.com/a?b=1\\\")\",\n \"def _validate_param(name, value):\\n\\n # First things first -- check that we have a legal parameter name.\\n try:\\n validator = _legal_params[name]\\n except KeyError:\\n raise ViewVCException(\\\"An illegal parameter name was provided.\\\", \\\"400 Bad Request\\\")\\n\\n # Is there a validator? Is it a regex or a function? Validate if\\n # we can, returning without incident on valid input.\\n if validator is None:\\n return\\n elif hasattr(validator, \\\"match\\\"):\\n if validator.match(value):\\n return\\n else:\\n if validator(value):\\n return\\n\\n # If we get here, the input value isn't valid.\\n raise ViewVCException(\\n 'An illegal value was provided for the \\\"%s\\\" parameter.' % (name), \\\"400 Bad Request\\\"\\n )\",\n \"def _check_for_unknown_params(self, params: MultiDict, search_filter: Dict[str, Any], whitelist: List[str]):\\n\\n for param_name in params.keys():\\n if param_name not in whitelist:\\n raise SuperdeskApiError.badRequestError(message=\\\"Unexpected parameter ({})\\\".format(param_name))\\n\\n if len(params.getlist(param_name)) > 1:\\n desc = \\\"Multiple values received for parameter ({})\\\"\\n raise SuperdeskApiError.badRequestError(message=desc.format(param_name))\\n\\n # Silently remove parameters from the search filter that are not in the whitelist\\n search_filter_id = search_filter.get(\\\"_id\\\")\\n for param_name in list(search_filter[\\\"params\\\"].keys()):\\n if param_name not in whitelist:\\n logger.warning(f\\\"Search filter {search_filter_id} contains unsupported param {param_name}\\\")\\n search_filter[\\\"params\\\"].pop(param_name, None)\",\n \"def parse_qsl(qs, keep_blank_values=0, strict_parsing=0):\\n pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]\\n r = []\\n for name_value in pairs:\\n if not name_value and not strict_parsing:\\n continue\\n nv = name_value.split('=', 1)\\n if len(nv) != 2:\\n if strict_parsing:\\n raise ValueError, \\\"bad query field: %r\\\" % (name_value,)\\n # Handle case of a control-name with no equal sign\\n if keep_blank_values:\\n nv.append('')\\n else:\\n continue\\n if len(nv[1]) or keep_blank_values:\\n name = unquote(nv[0].replace('+', ' '))\\n value = unquote(nv[1].replace('+', ' '))\\n r.append((name, value))\\n\\n return r\",\n \"def extract_filter_params(query, currencies):\\n query_parsed = []\\n\\n if not query:\\n return query_parsed\\n\\n matcher = re.compile(r'[^0-9]+')\\n\\n for word in query:\\n # Probably the value\\n if not matcher.match(word):\\n continue\\n # Probably a word\\n else:\\n # If its not a currency simbol, append to the query\\n if word.upper() not in currencies:\\n query_parsed.append(word)\\n\\n return query_parsed\",\n \"def get_param(name, default=''):\\n return request.GET.get(name, default).strip()\",\n \"def splitQuery(query_string):\\n\\ttry:\\n\\t\\td = dict([x.split('=') for x in query_string.split('&') ])\\n\\texcept ValueError:\\n\\t\\td = {}\\n\\treturn d\",\n \"def test_query_string_spaces():\\n assert (normalize_url(\\\"http://example.com/search?q=a b&a=1\\\") ==\\n \\\"http://example.com/search?a=1&q=a+b\\\")\\n assert (normalize_url(\\\"http://example.com/search?q=a+b&a=1\\\") ==\\n \\\"http://example.com/search?a=1&q=a+b\\\")\\n assert (normalize_url(\\\"http://example.com/search?q=a%20b&a=1\\\") ==\\n \\\"http://example.com/search?a=1&q=a+b\\\")\",\n \"def ingest_form_vars(request):\\n data = {}\\n for param, value in request.arguments.items():\\n for i, item in enumerate(value):\\n item = item.decode('utf-8')\\n item = strings.as_numeric(item)\\n value[i] = item\\n data[param] = value[0] if len(value) == 1 else value\\n return data\",\n \"def split_params(param_string):\\n\\t#TODO: check for negatives i.e. alpha--1\\n\\tparts = param_string.split('_')\\n\\tparams = {}\\n\\n\\tfor i in range(len(parts)):\\n\\t\\tparam = split_items(parts[i])\\n\\t\\tif len(param) < 2:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tparts[i+1] = parts[i] + \\\"_\\\" + parts[i+1]\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tpass\\n\\t\\t\\tcontinue\\n\\t\\telif len(param) == 2:\\n\\t\\t\\tparams[param[0]] = param[1]\\n\\t\\telif len(param) == 3 and len(param[1]) == 0:\\n\\t\\t\\tparams[param[0]] = -param[2]\\n\\t\\telse:\\n\\t\\t\\tparams[param[0]] = param[1:]\\n\\treturn params\",\n \"def parse_qs(query_string):\\n query_string = to_utf8_if_unicode(query_string) or \\\"\\\"\\n if query_string.startswith(\\\"?\\\"):\\n logging.warning(\\\"Ignoring `?` query string prefix -- `%r`\\\" % query_string)\\n query_string = query_string[1:]\\n return _parse_qs(query_string, keep_blank_values=True)\",\n \"def _extract_model_params(self, defaults, **kwargs):\\n defaults = defaults or {}\\n params = {k: v for k, v in kwargs.items() if LOOKUP_SEP not in k}\\n params.update(defaults)\\n property_names = self.model._meta._property_names\\n invalid_params = []\\n for param in params:\\n try:\\n self.model._meta.get_field(param)\\n except exceptions.FieldDoesNotExist:\\n # It's okay to use a model's property if it has a setter.\\n if not (param in property_names and getattr(self.model, param).fset):\\n invalid_params.append(param)\\n if invalid_params:\\n raise exceptions.FieldError(\\n \\\"Invalid field name(s) for model %s: '%s'.\\\"\\n % (\\n self.model._meta.object_name,\\n \\\"', '\\\".join(sorted(invalid_params)),\\n )\\n )\\n return params\",\n \"def getorderparam(name):\\n for num in cherrypy.request.params.get(name, '').split(','):\\n if num.strip() == '':\\n continue\\n try:\\n yield int(num)\\n except ValueError:\\n raise cherrypy.HTTPError(400)\",\n \"def GetUniqueParam(self, name):\\n if not hasattr(self, '_params'):\\n self._params = cgi.parse_qs(self.path[self.path.find('?') + 1:])\\n\\n param_list = self._params.get(name, [])\\n if len(param_list) == 1:\\n return param_list[0]\\n return None\",\n \"def _parse_user_input(self):\\n user_input = self.user_input.strip()\\n if user_input:\\n if user_input.find(',') > -1:\\n # Location is either city/state or latitude/longitude.\\n if user_input[0].isalpha():\\n # City, state (lat/long handled elsewhere)\\n city, state = [x.strip() for x in user_input.split(',')]\\n self.city = city\\n self.state = state\\n elif (len(user_input) <= 10 and\\n user_input[1].isdigit()): # 2nd char in US/Can. postal codes\\n # Postal code\\n self.postal_code = user_input.strip()\",\n \"def parse_for_filters(query_string):\\n if ';' in query_string:\\n strings = query_string.split(';')\\n else:\\n strings = query_string.split('&')\\n\\n filters = []\\n leftovers = [] \\n for string in strings:\\n query = cgi.parse_qs(string)\\n try:\\n key, value = query.items()[0]\\n\\n try:\\n argument = unicode(value[0], 'UTF-8')\\n except TypeError:\\n argument = value[0]\\n\\n func = FILTER_PARSERS[key](argument)\\n filters.append(func)\\n except(KeyError, IndexError):\\n leftovers.append(string)\\n\\n leftovers = ';'.join(leftovers)\\n return filters, leftovers\",\n \"def getParsedQueryString(self):\\n return cgi.parse_qs(self.query_string)\",\n \"def get_param(query, config):\\n keys = query.split('.')\\n if len(keys) == 1:\\n key = keys[0]\\n if not config.has_key(key):\\n return None\\n return config[key]\\n else:\\n return Config.get_nested_param(keys, config)\",\n \"def parse_query(request):\\n\\n querystring = request.uri['query']\\n fp = StringIO(querystring)\\n\\n headers = {}\\n headers['content-type'] = request.message.get('content-type')\\n headers['content-length'] = request.message.get('content-length')\\n\\n environ = {}\\n environ['REQUEST_METHOD'] = request.method\\n\\n boundary = request.message.get('boundary')\\n\\n query = cgi.FieldStorage( fp = fp\\n , headers = headers\\n , outerboundary = boundary\\n , environ = environ\\n , keep_blank_values = True\\n , strict_parsing = False\\n )\\n\\n return query\",\n \"def _get_query_params(self, req):\\n params = {\\n 'filters': self._get_filters(req),\\n 'limit': self._get_limit(req),\\n 'sort_key': [self._get_sort_key(req)],\\n 'sort_dir': [self._get_sort_dir(req)],\\n 'marker': self._get_marker(req),\\n }\\n\\n for key, value in params.items():\\n if value is None:\\n del params[key]\\n\\n return params\",\n \"def param_name(p):\\n prefix = ['limit_', 'error_', 'fix_']\\n for prf in prefix:\\n if p.startswith(prf):\\n return p[len(prf):]\\n return p\",\n \"def _pre_argument_parsing(self):\\n pass\",\n \"def split_url_and_query_params(url):\\n scheme, netloc, path, query_string, fragment = urlsplit(url)\\n query_params = parse_qs(query_string)\\n url = urlunsplit((scheme, netloc, path, None, fragment))\\n return url, query_params\",\n \"def test_process_query(self):\\n self.assertEqual(process_query(\\\"\\\"), \\\"\\\")\\n self.assertEqual(process_query(\\\"org\\\"), \\\"org:*\\\")\\n self.assertEqual(process_query(\\\"a b\\\"), \\\"a & b:*\\\")\\n self.assertEqual(process_query(\\\"(foo bar)\\\"), \\\"foo & bar:*\\\")\",\n \"def url_get_params(url):\\n\\n def cast_int(v):\\n \\\"\\\"\\\"\\n Try and convert a param to int\\n :param v:\\n :return:\\n \\\"\\\"\\\"\\n try:\\n return int(v)\\n except ValueError:\\n return v\\n\\n parsed_url = urlparse.urlparse(httpretty.last_request().path)\\n url_params = {k: cast_int(v) for k, v in dict(urlparse.parse_qsl(parsed_url.query)).items()}\\n return url_params\",\n \"def _check_validparam(self, symbol):\\n if symbol.type == self.scanner.KEYWORD and \\\\\\n symbol.id in self.validparamids:\\n return True\\n else:\\n return False\",\n \"def parse(self, request):\\n result = {}\\n if request.method.lower() == 'post':\\n params = request.get_json(\\n cache=False) if request.mimetype == 'application/json' else request.form\\n else:\\n params = request.args\\n for arg in self.args:\\n if arg.name in params:\\n if arg.type is not None and type(params[arg.name]) != arg.type:\\n try:\\n result[arg.name] = arg.coerce(params[arg.name])\\n except Exception as err:\\n current_app.logger.warning('Coercion failed for param: {}'.format(arg.name))\\n raise ApiError('Coercion failed for param: {}'.format(arg.name), 'ArgsParserException', 1, status_code=400)\\n abort(400)\\n else:\\n result[arg.name] = params[arg.name]\\n elif arg.required:\\n current_app.logger.warning(\\\"Missing required param: {}\\\".format(arg.name))\\n raise ApiError('Missing required param: {}'.format(arg.name), 'ArgsParserException', 2, status_code=400)\\n abort(400)\\n else:\\n result[arg.name] = arg.default\\n return result\",\n \"def get_params(self):\\r\\n query = urlparse.urlparse(self.path).query\\r\\n\\r\\n # By default, `parse_qs` returns a list of values for each param\\r\\n # For convenience, we replace lists of 1 element with just the element\\r\\n return {\\r\\n k:v[0] if len(v) == 1 else v\\r\\n for k,v in urlparse.parse_qs(query).items()\\r\\n }\",\n \"def limited_parse_qsl(qs, keep_blank_values=False, encoding='utf-8',\\n errors='replace', fields_limit=None):\\n date = {'phenomenonTime', 'resultTime', 'validTime'}\\n FIELDS_MATCH = re.compile('[&]')\\n pairs = FIELDS_MATCH.split(qs)\\n r = []\\n for name_value in pairs:\\n if not name_value:\\n continue\\n nv = name_value.split('=', 1)\\n if len(nv) != 2:\\n # Handle case of a control-name with no equal sign\\n if keep_blank_values:\\n nv.append('')\\n else:\\n continue\\n if nv[1] or keep_blank_values:\\n name = nv[0].replace('+', ' ')\\n name = nv[0]\\n name = unquote(name, encoding=encoding, errors=errors)\\n if not any(a in nv[1] for a in date):\\n value = nv[1].replace('+', ' ')\\n value = nv[1]\\n value = unquote(value, encoding=encoding, errors=errors)\\n r.append((name, value))\\n query_dict = {}\\n for key, value in r:\\n query_dict[key] = value\\n return query_dict\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6670326","0.6389083","0.6330131","0.62615776","0.6193709","0.61634845","0.60988027","0.60571504","0.6051584","0.6048205","0.60453707","0.5957845","0.5956611","0.59373385","0.58949566","0.589364","0.58637","0.58585805","0.5825855","0.58050853","0.57993454","0.57893455","0.5742143","0.5681527","0.5680218","0.5668681","0.56606776","0.56527674","0.56320983","0.5629649","0.56290585","0.5623252","0.5605736","0.56030816","0.55954814","0.5593789","0.55897915","0.5587571","0.55735904","0.5557461","0.5548513","0.554482","0.55366445","0.55300343","0.55191815","0.5512199","0.54868525","0.5483629","0.5481387","0.54800993","0.5471326","0.5463533","0.5453366","0.5434378","0.5433442","0.5429162","0.54273367","0.54227984","0.5396287","0.539588","0.538589","0.5375533","0.53748214","0.53701454","0.5368629","0.5364717","0.5364303","0.5361964","0.5356883","0.5352854","0.5340983","0.5340983","0.5330114","0.5325113","0.5320214","0.5319353","0.53141296","0.53114825","0.5302793","0.5293078","0.52920294","0.52822304","0.5279997","0.52798325","0.5276741","0.52713966","0.5252753","0.5247974","0.5247808","0.52411914","0.5240784","0.5234077","0.52300006","0.52252287","0.522362","0.52220094","0.5219876","0.52174115","0.5216869","0.5216411","0.52105045"],"string":"[\n \"0.6670326\",\n \"0.6389083\",\n \"0.6330131\",\n \"0.62615776\",\n \"0.6193709\",\n \"0.61634845\",\n \"0.60988027\",\n \"0.60571504\",\n \"0.6051584\",\n \"0.6048205\",\n \"0.60453707\",\n \"0.5957845\",\n \"0.5956611\",\n \"0.59373385\",\n \"0.58949566\",\n \"0.589364\",\n \"0.58637\",\n \"0.58585805\",\n \"0.5825855\",\n \"0.58050853\",\n \"0.57993454\",\n \"0.57893455\",\n \"0.5742143\",\n \"0.5681527\",\n \"0.5680218\",\n \"0.5668681\",\n \"0.56606776\",\n \"0.56527674\",\n \"0.56320983\",\n \"0.5629649\",\n \"0.56290585\",\n \"0.5623252\",\n \"0.5605736\",\n \"0.56030816\",\n \"0.55954814\",\n \"0.5593789\",\n \"0.55897915\",\n \"0.5587571\",\n \"0.55735904\",\n \"0.5557461\",\n \"0.5548513\",\n \"0.554482\",\n \"0.55366445\",\n \"0.55300343\",\n \"0.55191815\",\n \"0.5512199\",\n \"0.54868525\",\n \"0.5483629\",\n \"0.5481387\",\n \"0.54800993\",\n \"0.5471326\",\n \"0.5463533\",\n \"0.5453366\",\n \"0.5434378\",\n \"0.5433442\",\n \"0.5429162\",\n \"0.54273367\",\n \"0.54227984\",\n \"0.5396287\",\n \"0.539588\",\n \"0.538589\",\n \"0.5375533\",\n \"0.53748214\",\n \"0.53701454\",\n \"0.5368629\",\n \"0.5364717\",\n \"0.5364303\",\n \"0.5361964\",\n \"0.5356883\",\n \"0.5352854\",\n \"0.5340983\",\n \"0.5340983\",\n \"0.5330114\",\n \"0.5325113\",\n \"0.5320214\",\n \"0.5319353\",\n \"0.53141296\",\n \"0.53114825\",\n \"0.5302793\",\n \"0.5293078\",\n \"0.52920294\",\n \"0.52822304\",\n \"0.5279997\",\n \"0.52798325\",\n \"0.5276741\",\n \"0.52713966\",\n \"0.5252753\",\n \"0.5247974\",\n \"0.5247808\",\n \"0.52411914\",\n \"0.5240784\",\n \"0.5234077\",\n \"0.52300006\",\n \"0.52252287\",\n \"0.522362\",\n \"0.52220094\",\n \"0.5219876\",\n \"0.52174115\",\n \"0.5216869\",\n \"0.5216411\",\n \"0.52105045\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84889,"cells":{"query":{"kind":"string","value":"Returns config for tf.session"},"document":{"kind":"string","value":"def get_config():\n config = tf.ConfigProto(allow_soft_placement=True)\n config.gpu_options.allow_growth=True\n return config"},"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 _config_session(self):\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n config.gpu_options.visible_device_list = str(self.device_num)\n return tf.Session(config=config)","def get_config():\n config = tf.ConfigProto(allow_soft_placement=True)\n config.gpu_options.allow_growth = True\n return config","def configs(cfg):\n # Define any gpzu options.\n gpu_config = tf.GPUOptions(\n per_process_gpu_memory_fraction=cfg.gpu_memory_frac\n )\n # Define session configuration.\n config = tf.ConfigProto(\n allow_soft_placement=cfg.allow_soft_placement,\n log_device_placement=cfg.log_device_placement,\n gpu_options=gpu_config\n )\n\n # Define the session options and metadata for timelines.\n options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)\n run_metadata = tf.RunMetadata()\n\n return config, options, run_metadata","def get_session():\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n return tf.Session(config=config)","def get_session(config=None):\n sess = tf.get_default_session()\n if sess is None:\n sess = make_session(config=config, make_default=True)\n return sess","def get_tf_config(cls, envvar='TF_CONFIG'):\n if settings.NO_OP:\n return None\n\n ensure_in_custer()\n\n cluster_def = cls.get_cluster_def()\n task_info = cls.get_task_info()\n tf_config = {\n 'cluster': cluster_def,\n 'task': task_info,\n 'model_dir': get_outputs_path(),\n 'environment': 'cloud'\n }\n\n if envvar:\n os.environ[envvar] = json.dumps(tf_config)\n\n return tf_config","def get_session():\n # See: https://www.tensorflow.org/tutorials/using_gpu#allowing_gpu_memory_growth\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n session = tf.Session(config=config)\n return session","def get_session(gpu_fraction=0.6):\n num_threads = os.environ.get('OMP_NUM_THREADS')\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpu_fraction)\n\n if num_threads:\n return tf.Session(config=tf.ConfigProto(\n gpu_options=gpu_options, intra_op_parallelism_threads=num_threads))\n else:\n return tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))","def get_run_config():\n run_config = tf.contrib.learn.RunConfig()\n run_config = run_config.replace(model_dir=FLAGS.model_dir)\n return run_config","def config_keras() -> None:\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n kbackend.tensorflow_backend.set_session(tf.Session(config=config))","def get_tf_config(config_path):\n return modeling.BertConfig.from_json_file(config_path).__dict__","def get_cfg():\n return _assert_and_infer_cfg(_C.clone())","def set_tf_config():\n tf_config = {\n \"cluster\": {\n \"worker\": [f\"localhost:{BASE_TF_SERVER_PORT + index}\" for index in range(num_workers)]\n },\n \"task\": {\"type\": \"worker\", \"index\": worker_index}\n }\n tf_config_text = json.dumps(tf_config)\n os.environ[\"TF_CONFIG\"] = tf_config_text\n print(f\"TF_CONFIG = {tf_config_text}\")\n return tf_config_text","def get_config():\n config = ml_collections.ConfigDict()\n\n # Which model to use -- see ./models.py\n config.model_name = 'ViT-B_32'\n # Where to store training logs.\n config.log_dir = '.'\n\n # Number of steps to measure.\n config.steps = 30\n # Number of steps before measuring.\n config.initial_steps = 10\n\n # Batch size\n config.batch = 0\n # Number of output classes.\n config.num_classes = 0\n # Image size (width=height).\n config.image_size = 0\n\n config.train = 'inference_time'\n\n return config","def prepare_config(device='npu'):\n if device == 'npu':\n # config for Ascend processor\n config = tf.ConfigProto()\n custom_op = config.graph_options.rewrite_options.custom_optimizers.add()\n custom_op.name = \"NpuOptimizer\"\n custom_op.parameter_map[\"use_off_line\"].b = True\n custom_op.parameter_map[\"precision_mode\"].s = tf.compat.as_bytes(\"force_fp16\")\n custom_op.parameter_map[\"graph_run_mode\"].i = 0\n config.graph_options.rewrite_options.remapping = RewriterConfig.OFF\n custom_op.parameter_map[\"debug_dir\"].s = tf.compat.as_bytes(str(TMP))\n else:\n config = tf.ConfigProto()\n return config","def session_conf(session, params_table=None):\n return cfg_to_bunch(find_conf(session), params_table=params_table)","def get_cfg():\n return defcfg._assert_and_infer_cfg(defcfg._C.clone())","def get_config(self):\n config = {'name': self.name, 'trainable': self.trainable}\n if hasattr(self, '_batch_input_shape'):\n config['batch_input_shape'] = self._batch_input_shape\n if hasattr(self, 'dtype'):\n config['dtype'] = self.dtype\n return config","def get_config():\n return CONFIG","def get_config():\n return _config","def get_config(self):\n return {\"name\": self.name, \"tunable\": self.tunable}","def get_used_config(self):\n if self.config['SESSION_ENGINE'] == 'REDIS':\n return self.__get_redis_config()\n elif self.config['SESSION_ENGINE'] == 'MEMCACHE':\n return self.__get_memcache_config()\n else:\n return dict()","def get_config():\n config = tools.get_config_file()\n session_config = session.get_session_config()\n for config_key in config:\n\n # checking for not false, but truthy value here is the desired behavior\n session_value = session_config.get(config_key)\n if session_value is False or session_value:\n config[config_key] = session_value\n return config","def get_config(self):\n return self.config","def config():\n return _config","def config(self):\n return self._cfg","def get_config(self):\n config = {\n 'membership_transform': self.membership_transform,\n 'predictions_transform': self.predictions_transform,\n 'membership_kernel': self.membership_kernel,\n 'predictions_kernel': self.predictions_kernel,\n 'name': self.name,\n }\n config = {k: v for k, v in config.items() if v is not None}\n return self._serialize_config(config)","def get_session(batch_size):\n\n # Model\n input_real, input_z, input_d_y, input_g_y = model.model_inputs(\n DIM_X, DIM_Y, DIM_Z, Z_NOISE_DIM, Y_DIM)\n dcgan.generator(input_z, input_g_y)\n global_step = tf.Variable(0, trainable=False, name='global_step')\n saver = tf.train.Saver(max_to_keep=10, keep_checkpoint_every_n_hours=5)\n\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n\n try:\n saver.restore(sess, tf.train.latest_checkpoint(\n BASE_PATH + CHKPTS_PATH))\n last_global_step = sess.run(global_step)\n print(last_global_step)\n except ValueError:\n print(\"Error loading checkpoint, no valid checkpoint found\")\n\n return sess, input_real, input_z, input_g_y","def config(self) -> Optional[pulumi.Input['NodeConfigArgs']]:\n return pulumi.get(self, \"config\")","def make_config_proto(c):\n # tensorflow config\n use_gpu = os.environ.get('use_gpu', c.get('tf.config.use_gpu', c.get('use_gpu', 1)))\n cfg = tf.ConfigProto(device_count={'GPU': use_gpu})\n\n # scan config for tf config params\n opts = {opt.replace('tf.config.', ''): c[opt] for opt in c if opt.startswith('tf.config.')}\n if 'use_gpu' in opts:\n del opts['use_gpu'] # it's not standard {key: value} parameter\n\n # apply params to config proto\n for key, value in opts.items():\n if '.' in key: # go deeper\n split = key.split('.')\n if len(split) > 2:\n raise Exception('Only two level config supported: ' + split)\n\n key1, key2 = split[0], split[1]\n root_obj = getattr(cfg, key1)\n setattr(root_obj, key2, value)\n else:\n setattr(cfg, key, value)\n\n return cfg","def get_base_config():\n return dict(\n dim=768,\n ff_dim=3072,\n num_heads=12,\n num_layers=12,\n attention_dropout_rate=0.0,\n dropout_rate=0.1,\n representation_size=768,\n classifier='token'\n )","def get_tf_session(gpumem):\n tf.reset_default_graph()\n tf_config = tf.ConfigProto(inter_op_parallelism_threads=1,\n intra_op_parallelism_threads=1)\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpumem)\n session = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))\n def get_available_gpus():\n from tensorflow.python.client import device_lib\n local_device_protos = device_lib.list_local_devices()\n return [x.physical_device_desc for x in local_device_protos if x.device_type == 'GPU']\n print(\"AVAILABLE GPUS: \", get_available_gpus())\n return session","def default_config_proto():\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n return config","def get_test_config():\n config = get_config()\n config.batch_size = 2\n config.eval_batch_size = 2\n config.eval_num = 2\n config.eval_avg_num = 1\n config.num_train_steps = 2\n config.log_loss_every_steps = 1\n config.eval_every_steps = 1\n config.checkpoint_every_steps = 1\n config.df_dim = 16\n config.gf_dim = 16\n config.z_dim = 8\n config.show_num = 4\n config.num_epochs = 1\n config.shuffle_buffer_size = 10\n return config","def _dump_tf_config(self):\n with open(os.path.join(self._tf_temp_dir.name, \"config.tf.json\"), \"w\") as f:\n json.dump(self.tf_config, f, indent=2)\n\n subprocess.run([\"cat\", os.path.join(self._tf_temp_dir.name, \"config.tf.json\")])\n\n self._init_tf() # Re-init post reconfiguration","def get_parameters():\n \n tf.set_random_seed(1) #so that your \"random\" numbers match ours\n sess = tf.Session() \n #First let's load meta graph and restore weights\n saver = tf.train.import_meta_graph(ckpt_dir + '/trained_model.meta')\n saver.restore(sess, tf.train.latest_checkpoint(ckpt_dir))\n\n #print all tensor name\n #print([n.name for n in graph.as_graph_def().node]) \n #extract parameters from saved session\n W1 = sess.run(\"W1:0\")\n b1 = sess.run(\"b1:0\")\n W2 = sess.run(\"W2:0\")\n b2 = sess.run(\"b2:0\")\n W3 = sess.run(\"W3:0\")\n b3 = sess.run(\"b3:0\") \n\n parameters = {\"W1\": W1,\n \"b1\": b1,\n \"W2\": W2,\n \"b2\": b2,\n \"W3\": W3,\n \"b3\": b3}\n \n return parameters, sess","def getConfig(self):\n \n return self.config","def getConfig(self):\n pass","def config(self):\n annotations = IAnnotations(self.context)\n return annotations.get(CONFIGURATION_KEY, {})","def get_runconfig(master_host, namespace, target):\n response = tf_operator_util.send_request(master_host, namespace, target,\n \"runconfig\", {})\n return yaml.load(response)","def config(self):\n if self.__config is None:\n self.__config = self._get_config(self.bot)\n return self.__config","def config(self):\n return self.namespace['config']","def create_config_proto(params):\n config = tf.ConfigProto()\n config.allow_soft_placement = True\n config.intra_op_parallelism_threads = params.num_intra_threads\n config.inter_op_parallelism_threads = params.num_inter_threads\n config.gpu_options.force_gpu_compatible = params.force_gpu_compatible\n\n return config","def get_config(self):\n config = {\n 'window_length': self.window_length,\n 'ignore_episode_boundaries': self.ignore_episode_boundaries,\n }\n return config","def config(self, **kwargs):\n return config.tsdb_configuration(self._host, self._session, **kwargs)","def get_pose_session(tf_model_path):\n tf_model = load_graph(tf_model_path)\n x = tf_model.get_tensor_by_name('prefix/input_image:0')\n y = tf_model.get_tensor_by_name('prefix/Add_8:0')\n gpu_options = tf.GPUOptions(allow_growth=False, per_process_gpu_memory_fraction=0.3)\n sess_config = tf.ConfigProto(gpu_options=gpu_options,\n use_per_session_threads=False)\n tf_session = Session(graph=tf_model, config=sess_config)\n\n return tf_session, x, y","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config"],"string":"[\n \"def _config_session(self):\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n config.gpu_options.visible_device_list = str(self.device_num)\\n return tf.Session(config=config)\",\n \"def get_config():\\n config = tf.ConfigProto(allow_soft_placement=True)\\n config.gpu_options.allow_growth = True\\n return config\",\n \"def configs(cfg):\\n # Define any gpzu options.\\n gpu_config = tf.GPUOptions(\\n per_process_gpu_memory_fraction=cfg.gpu_memory_frac\\n )\\n # Define session configuration.\\n config = tf.ConfigProto(\\n allow_soft_placement=cfg.allow_soft_placement,\\n log_device_placement=cfg.log_device_placement,\\n gpu_options=gpu_config\\n )\\n\\n # Define the session options and metadata for timelines.\\n options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)\\n run_metadata = tf.RunMetadata()\\n\\n return config, options, run_metadata\",\n \"def get_session():\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n return tf.Session(config=config)\",\n \"def get_session(config=None):\\n sess = tf.get_default_session()\\n if sess is None:\\n sess = make_session(config=config, make_default=True)\\n return sess\",\n \"def get_tf_config(cls, envvar='TF_CONFIG'):\\n if settings.NO_OP:\\n return None\\n\\n ensure_in_custer()\\n\\n cluster_def = cls.get_cluster_def()\\n task_info = cls.get_task_info()\\n tf_config = {\\n 'cluster': cluster_def,\\n 'task': task_info,\\n 'model_dir': get_outputs_path(),\\n 'environment': 'cloud'\\n }\\n\\n if envvar:\\n os.environ[envvar] = json.dumps(tf_config)\\n\\n return tf_config\",\n \"def get_session():\\n # See: https://www.tensorflow.org/tutorials/using_gpu#allowing_gpu_memory_growth\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n session = tf.Session(config=config)\\n return session\",\n \"def get_session(gpu_fraction=0.6):\\n num_threads = os.environ.get('OMP_NUM_THREADS')\\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpu_fraction)\\n\\n if num_threads:\\n return tf.Session(config=tf.ConfigProto(\\n gpu_options=gpu_options, intra_op_parallelism_threads=num_threads))\\n else:\\n return tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))\",\n \"def get_run_config():\\n run_config = tf.contrib.learn.RunConfig()\\n run_config = run_config.replace(model_dir=FLAGS.model_dir)\\n return run_config\",\n \"def config_keras() -> None:\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n kbackend.tensorflow_backend.set_session(tf.Session(config=config))\",\n \"def get_tf_config(config_path):\\n return modeling.BertConfig.from_json_file(config_path).__dict__\",\n \"def get_cfg():\\n return _assert_and_infer_cfg(_C.clone())\",\n \"def set_tf_config():\\n tf_config = {\\n \\\"cluster\\\": {\\n \\\"worker\\\": [f\\\"localhost:{BASE_TF_SERVER_PORT + index}\\\" for index in range(num_workers)]\\n },\\n \\\"task\\\": {\\\"type\\\": \\\"worker\\\", \\\"index\\\": worker_index}\\n }\\n tf_config_text = json.dumps(tf_config)\\n os.environ[\\\"TF_CONFIG\\\"] = tf_config_text\\n print(f\\\"TF_CONFIG = {tf_config_text}\\\")\\n return tf_config_text\",\n \"def get_config():\\n config = ml_collections.ConfigDict()\\n\\n # Which model to use -- see ./models.py\\n config.model_name = 'ViT-B_32'\\n # Where to store training logs.\\n config.log_dir = '.'\\n\\n # Number of steps to measure.\\n config.steps = 30\\n # Number of steps before measuring.\\n config.initial_steps = 10\\n\\n # Batch size\\n config.batch = 0\\n # Number of output classes.\\n config.num_classes = 0\\n # Image size (width=height).\\n config.image_size = 0\\n\\n config.train = 'inference_time'\\n\\n return config\",\n \"def prepare_config(device='npu'):\\n if device == 'npu':\\n # config for Ascend processor\\n config = tf.ConfigProto()\\n custom_op = config.graph_options.rewrite_options.custom_optimizers.add()\\n custom_op.name = \\\"NpuOptimizer\\\"\\n custom_op.parameter_map[\\\"use_off_line\\\"].b = True\\n custom_op.parameter_map[\\\"precision_mode\\\"].s = tf.compat.as_bytes(\\\"force_fp16\\\")\\n custom_op.parameter_map[\\\"graph_run_mode\\\"].i = 0\\n config.graph_options.rewrite_options.remapping = RewriterConfig.OFF\\n custom_op.parameter_map[\\\"debug_dir\\\"].s = tf.compat.as_bytes(str(TMP))\\n else:\\n config = tf.ConfigProto()\\n return config\",\n \"def session_conf(session, params_table=None):\\n return cfg_to_bunch(find_conf(session), params_table=params_table)\",\n \"def get_cfg():\\n return defcfg._assert_and_infer_cfg(defcfg._C.clone())\",\n \"def get_config(self):\\n config = {'name': self.name, 'trainable': self.trainable}\\n if hasattr(self, '_batch_input_shape'):\\n config['batch_input_shape'] = self._batch_input_shape\\n if hasattr(self, 'dtype'):\\n config['dtype'] = self.dtype\\n return config\",\n \"def get_config():\\n return CONFIG\",\n \"def get_config():\\n return _config\",\n \"def get_config(self):\\n return {\\\"name\\\": self.name, \\\"tunable\\\": self.tunable}\",\n \"def get_used_config(self):\\n if self.config['SESSION_ENGINE'] == 'REDIS':\\n return self.__get_redis_config()\\n elif self.config['SESSION_ENGINE'] == 'MEMCACHE':\\n return self.__get_memcache_config()\\n else:\\n return dict()\",\n \"def get_config():\\n config = tools.get_config_file()\\n session_config = session.get_session_config()\\n for config_key in config:\\n\\n # checking for not false, but truthy value here is the desired behavior\\n session_value = session_config.get(config_key)\\n if session_value is False or session_value:\\n config[config_key] = session_value\\n return config\",\n \"def get_config(self):\\n return self.config\",\n \"def config():\\n return _config\",\n \"def config(self):\\n return self._cfg\",\n \"def get_config(self):\\n config = {\\n 'membership_transform': self.membership_transform,\\n 'predictions_transform': self.predictions_transform,\\n 'membership_kernel': self.membership_kernel,\\n 'predictions_kernel': self.predictions_kernel,\\n 'name': self.name,\\n }\\n config = {k: v for k, v in config.items() if v is not None}\\n return self._serialize_config(config)\",\n \"def get_session(batch_size):\\n\\n # Model\\n input_real, input_z, input_d_y, input_g_y = model.model_inputs(\\n DIM_X, DIM_Y, DIM_Z, Z_NOISE_DIM, Y_DIM)\\n dcgan.generator(input_z, input_g_y)\\n global_step = tf.Variable(0, trainable=False, name='global_step')\\n saver = tf.train.Saver(max_to_keep=10, keep_checkpoint_every_n_hours=5)\\n\\n sess = tf.Session()\\n sess.run(tf.global_variables_initializer())\\n\\n try:\\n saver.restore(sess, tf.train.latest_checkpoint(\\n BASE_PATH + CHKPTS_PATH))\\n last_global_step = sess.run(global_step)\\n print(last_global_step)\\n except ValueError:\\n print(\\\"Error loading checkpoint, no valid checkpoint found\\\")\\n\\n return sess, input_real, input_z, input_g_y\",\n \"def config(self) -> Optional[pulumi.Input['NodeConfigArgs']]:\\n return pulumi.get(self, \\\"config\\\")\",\n \"def make_config_proto(c):\\n # tensorflow config\\n use_gpu = os.environ.get('use_gpu', c.get('tf.config.use_gpu', c.get('use_gpu', 1)))\\n cfg = tf.ConfigProto(device_count={'GPU': use_gpu})\\n\\n # scan config for tf config params\\n opts = {opt.replace('tf.config.', ''): c[opt] for opt in c if opt.startswith('tf.config.')}\\n if 'use_gpu' in opts:\\n del opts['use_gpu'] # it's not standard {key: value} parameter\\n\\n # apply params to config proto\\n for key, value in opts.items():\\n if '.' in key: # go deeper\\n split = key.split('.')\\n if len(split) > 2:\\n raise Exception('Only two level config supported: ' + split)\\n\\n key1, key2 = split[0], split[1]\\n root_obj = getattr(cfg, key1)\\n setattr(root_obj, key2, value)\\n else:\\n setattr(cfg, key, value)\\n\\n return cfg\",\n \"def get_base_config():\\n return dict(\\n dim=768,\\n ff_dim=3072,\\n num_heads=12,\\n num_layers=12,\\n attention_dropout_rate=0.0,\\n dropout_rate=0.1,\\n representation_size=768,\\n classifier='token'\\n )\",\n \"def get_tf_session(gpumem):\\n tf.reset_default_graph()\\n tf_config = tf.ConfigProto(inter_op_parallelism_threads=1,\\n intra_op_parallelism_threads=1)\\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpumem)\\n session = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))\\n def get_available_gpus():\\n from tensorflow.python.client import device_lib\\n local_device_protos = device_lib.list_local_devices()\\n return [x.physical_device_desc for x in local_device_protos if x.device_type == 'GPU']\\n print(\\\"AVAILABLE GPUS: \\\", get_available_gpus())\\n return session\",\n \"def default_config_proto():\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n return config\",\n \"def get_test_config():\\n config = get_config()\\n config.batch_size = 2\\n config.eval_batch_size = 2\\n config.eval_num = 2\\n config.eval_avg_num = 1\\n config.num_train_steps = 2\\n config.log_loss_every_steps = 1\\n config.eval_every_steps = 1\\n config.checkpoint_every_steps = 1\\n config.df_dim = 16\\n config.gf_dim = 16\\n config.z_dim = 8\\n config.show_num = 4\\n config.num_epochs = 1\\n config.shuffle_buffer_size = 10\\n return config\",\n \"def _dump_tf_config(self):\\n with open(os.path.join(self._tf_temp_dir.name, \\\"config.tf.json\\\"), \\\"w\\\") as f:\\n json.dump(self.tf_config, f, indent=2)\\n\\n subprocess.run([\\\"cat\\\", os.path.join(self._tf_temp_dir.name, \\\"config.tf.json\\\")])\\n\\n self._init_tf() # Re-init post reconfiguration\",\n \"def get_parameters():\\n \\n tf.set_random_seed(1) #so that your \\\"random\\\" numbers match ours\\n sess = tf.Session() \\n #First let's load meta graph and restore weights\\n saver = tf.train.import_meta_graph(ckpt_dir + '/trained_model.meta')\\n saver.restore(sess, tf.train.latest_checkpoint(ckpt_dir))\\n\\n #print all tensor name\\n #print([n.name for n in graph.as_graph_def().node]) \\n #extract parameters from saved session\\n W1 = sess.run(\\\"W1:0\\\")\\n b1 = sess.run(\\\"b1:0\\\")\\n W2 = sess.run(\\\"W2:0\\\")\\n b2 = sess.run(\\\"b2:0\\\")\\n W3 = sess.run(\\\"W3:0\\\")\\n b3 = sess.run(\\\"b3:0\\\") \\n\\n parameters = {\\\"W1\\\": W1,\\n \\\"b1\\\": b1,\\n \\\"W2\\\": W2,\\n \\\"b2\\\": b2,\\n \\\"W3\\\": W3,\\n \\\"b3\\\": b3}\\n \\n return parameters, sess\",\n \"def getConfig(self):\\n \\n return self.config\",\n \"def getConfig(self):\\n pass\",\n \"def config(self):\\n annotations = IAnnotations(self.context)\\n return annotations.get(CONFIGURATION_KEY, {})\",\n \"def get_runconfig(master_host, namespace, target):\\n response = tf_operator_util.send_request(master_host, namespace, target,\\n \\\"runconfig\\\", {})\\n return yaml.load(response)\",\n \"def config(self):\\n if self.__config is None:\\n self.__config = self._get_config(self.bot)\\n return self.__config\",\n \"def config(self):\\n return self.namespace['config']\",\n \"def create_config_proto(params):\\n config = tf.ConfigProto()\\n config.allow_soft_placement = True\\n config.intra_op_parallelism_threads = params.num_intra_threads\\n config.inter_op_parallelism_threads = params.num_inter_threads\\n config.gpu_options.force_gpu_compatible = params.force_gpu_compatible\\n\\n return config\",\n \"def get_config(self):\\n config = {\\n 'window_length': self.window_length,\\n 'ignore_episode_boundaries': self.ignore_episode_boundaries,\\n }\\n return config\",\n \"def config(self, **kwargs):\\n return config.tsdb_configuration(self._host, self._session, **kwargs)\",\n \"def get_pose_session(tf_model_path):\\n tf_model = load_graph(tf_model_path)\\n x = tf_model.get_tensor_by_name('prefix/input_image:0')\\n y = tf_model.get_tensor_by_name('prefix/Add_8:0')\\n gpu_options = tf.GPUOptions(allow_growth=False, per_process_gpu_memory_fraction=0.3)\\n sess_config = tf.ConfigProto(gpu_options=gpu_options,\\n use_per_session_threads=False)\\n tf_session = Session(graph=tf_model, config=sess_config)\\n\\n return tf_session, x, y\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7999958","0.7535755","0.72901034","0.7119736","0.6969369","0.6781894","0.65969217","0.64716965","0.6348045","0.6322737","0.631881","0.62444156","0.6241746","0.6201172","0.61908853","0.61729336","0.6153548","0.6133191","0.6101502","0.6080999","0.6076644","0.6066708","0.60663533","0.60567385","0.60556847","0.60389835","0.6019723","0.6018138","0.59702766","0.5965589","0.59641916","0.5963819","0.5958429","0.5930263","0.59297466","0.5907498","0.5901758","0.5895088","0.58924705","0.58743745","0.58572423","0.5856316","0.5848671","0.5845379","0.58403957","0.58231825","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224","0.5806224"],"string":"[\n \"0.7999958\",\n \"0.7535755\",\n \"0.72901034\",\n \"0.7119736\",\n \"0.6969369\",\n \"0.6781894\",\n \"0.65969217\",\n \"0.64716965\",\n \"0.6348045\",\n \"0.6322737\",\n \"0.631881\",\n \"0.62444156\",\n \"0.6241746\",\n \"0.6201172\",\n \"0.61908853\",\n \"0.61729336\",\n \"0.6153548\",\n \"0.6133191\",\n \"0.6101502\",\n \"0.6080999\",\n \"0.6076644\",\n \"0.6066708\",\n \"0.60663533\",\n \"0.60567385\",\n \"0.60556847\",\n \"0.60389835\",\n \"0.6019723\",\n \"0.6018138\",\n \"0.59702766\",\n \"0.5965589\",\n \"0.59641916\",\n \"0.5963819\",\n \"0.5958429\",\n \"0.5930263\",\n \"0.59297466\",\n \"0.5907498\",\n \"0.5901758\",\n \"0.5895088\",\n \"0.58924705\",\n \"0.58743745\",\n \"0.58572423\",\n \"0.5856316\",\n \"0.5848671\",\n \"0.5845379\",\n \"0.58403957\",\n \"0.58231825\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\",\n \"0.5806224\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75894344"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84890,"cells":{"query":{"kind":"string","value":"Load checkpoint from the ckpt_dir (if unspecified, this is train dir) and restore it to saver and sess, waiting 10 secs in the case of failure. Also returns checkpoint name."},"document":{"kind":"string","value":"def load_ckpt(saver, sess, ckpt_dir=\"train\"):\n while True:\n try:\n latest_filename = \"checkpoint_best\" if ckpt_dir==\"eval\" else None\n ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)\n ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest_filename)\n tf.logging.info('Loading checkpoint %s', ckpt_state.model_checkpoint_path)\n saver.restore(sess, ckpt_state.model_checkpoint_path)\n return ckpt_state.model_checkpoint_path\n except:\n tf.logging.info(\"Failed to load checkpoint from %s. Sleeping for %i secs...\", ckpt_dir, 10)\n time.sleep(10)"},"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_ckpt(saver, sess, ckpt_dir=\"train\"):\n while True:\n try:\n latest_filename = \"checkpoint_best\" if ckpt_dir == \"eval\" else None\n ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)\n ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest_filename)\n tf.logging.info('Loading checkpoint %s', ckpt_state.model_checkpoint_path)\n saver.restore(sess, ckpt_state.model_checkpoint_path)\n return ckpt_state.model_checkpoint_path\n except:\n tf.logging.info(\"Failed to load checkpoint from %s. Sleeping for %i secs...\", ckpt_dir, 10)\n time.sleep(10)","def load_from_path(self, checkpoint_dir):\n\n vars = self.save_var_names\n saver = tf.train.Saver(vars)\n\n def load_aux(ckpt_path):\n \"\"\"Helper function to not repeat the same code in the following lines.\"\"\"\n\n ckpt_name = os.path.basename(ckpt_path)\n saver.restore(self.sess, ckpt_path)\n counter = int(next(re.finditer(\"(\\d+)(?!.*\\d)\", ckpt_name)).group(0))\n self.counter = counter\n print(\" [*] Loaded {}\".format(ckpt_name))\n return True, counter\n\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n try:\n if ckpt and ckpt.model_checkpoint_path:\n ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\n return load_aux(os.path.join(checkpoint_dir, ckpt_name))\n else:\n print(\n \" [!] Failed to find a checkpoint within directory {}\".format(\n FLAGS.ckpt_path))\n return False, 0\n except:\n print(\" [!] Failed to find a checkpoint, Exception!\")\n return False, 0","def load(loadname, checkpoint=None):\n ckpt_dir = \"./models/tf_ckpt_\" + loadname + \"/\"\n if checkpoint is not None:\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\n status.assert_consumed()\n print(\"Loaded checkpoint\")\n else:\n print(\"Not Loading any checkpoint\")\n print(\"Starting training from initial configuration\")","def load_ckpt(self, name=None):\r\n name = name if name == 'latest' else \"ckpt_epoch{}\".format(name)\r\n load_path = os.path.join(self.model_dir, \"{}.pth\".format(name))\r\n if not os.path.exists(load_path):\r\n raise ValueError(\"Checkpoint {} not exists.\".format(load_path))\r\n\r\n checkpoint = torch.load(load_path)\r\n print(\"Checkpoint loaded from {}\".format(load_path))\r\n if isinstance(self.net, nn.DataParallel):\r\n self.net.module.load_state_dict(checkpoint['model_state_dict'])\r\n else:\r\n self.net.load_state_dict(checkpoint['model_state_dict'])\r\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\r\n self.scheduler.load_state_dict(checkpoint['scheduler_state_dict'])\r\n self.clock.restore_checkpoint(checkpoint['clock'])","def load(self, checkpoint_dir):\n print(\"\\nReading Checkpoints.....\\n\\n\")\n model_dir = \"%s\" % (\"cnn\") # give the model name by label_size\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir)\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n \n # Check the checkpoint is exist\n if ckpt and ckpt.model_checkpoint_path:\n ckpt_path = str(ckpt.model_checkpoint_path) # convert the unicode to string\n self.saver.restore(self.sess, os.path.join(os.getcwd(), ckpt_path))\n print(\"\\n Checkpoint Loading Success! %s\\n\\n\"% ckpt_path)\n else:\n print(\"\\n! Checkpoint Loading Failed \\n\\n\")","def load_checkpoint(self, session, model_dir):\n assert self.params.cp_load == True, (\"cp_load must be set to true to load a checkpoint\")\n self.loader.restore(session, model_dir)","def load_checkpoint(self):\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\n try:\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\n ckpt = torch.load(self.params.resume_from)\n self.epoch = ckpt['epoch']\n try:\n self.train_loss = ckpt['train_loss']\n self.val_loss = ckpt['val_loss']\n except:\n self.train_loss = []\n self.val_loss = []\n self.network.load_state_dict(ckpt['state_dict'])\n self.opt.load_state_dict(ckpt['optimizer'])\n LOG('Checkpoint Loaded!')\n LOG('Current Epoch: %d' % self.epoch)\n self.ckpt_flag = True\n except:\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\n else:\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')","def load_training_checkpoint(args, model, PATH, ckpt_id):\r\n logger = args.logger\r\n _, checkpoint_state_dict = model.network.load_checkpoint(PATH, ckpt_id)\r\n epoch = checkpoint_state_dict['epoch']\r\n last_global_step = checkpoint_state_dict['last_global_step']\r\n last_global_data_samples = checkpoint_state_dict[\r\n 'last_global_data_samples']\r\n del checkpoint_state_dict\r\n return (epoch, last_global_step, last_global_data_samples)","def load_checkpoint(checkpoint_dir, epoch, iteration):\n path = opj(checkpoint_dir, str(epoch) + '.' + str(iteration) + '.ckpt')\n if not os.path.isfile(path):\n raise Exception(\"Checkpoint in epoch %d doesn't exist :sob:\" % epoch)\n\n checkpoint = torch.load(path)\n start_epoch = checkpoint['epoch']\n state_dict = checkpoint['state_dict']\n start_iteration = checkpoint['iteration']\n\n assert iteration == start_iteration\n return start_epoch, start_iteration, state_dict","def restore(self, checkpoint_path):\n start_time = time.time()\n latest_checkpoint = train_util.get_latest_chekpoint(checkpoint_path)\n if latest_checkpoint is not None:\n checkpoint = tf.train.Checkpoint(model=self)\n checkpoint.restore(latest_checkpoint).expect_partial()\n logging.info('Loaded checkpoint %s', latest_checkpoint)\n logging.info('Loading model took %.1f seconds', time.time() - start_time)\n else:\n logging.info('Could not find checkpoint to load at %s, skipping.',\n checkpoint_path)","def load_checkpoint(self):\n checkpoin_path = self.get_checkpoint_path()\n _logger.info('Load checkpoint ignored by tuner, checkpoint path: %s', checkpoin_path)","def load_checkpoint(args, trainer, epoch_itr):\n os.makedirs(os.path.join(args.save_dir, 'checkpoints'), exist_ok=True)\n checkpoint_path = os.path.join(args.save_dir, 'checkpoints', args.restore_file)\n if os.path.isfile(checkpoint_path):\n extra_state = trainer.load_checkpoint(checkpoint_path)\n if extra_state is not None:\n # replay train iterator to match checkpoint\n epoch_itr.load_state_dict(extra_state['train_iterator'])\n\n print('| loaded checkpoint {} (epoch {} @ {} updates)'.format(\n checkpoint_path, epoch_itr.epoch, trainer.get_num_updates()))\n\n trainer.lr_step(epoch_itr.epoch)\n trainer.lr_step_update(trainer.get_num_updates())\n if 'best' in extra_state:\n save_checkpoint.best = extra_state['best']","def restore(self,\n sess,\n ckpt_file,\n ckpt_type):\n if ckpt_file is None:\n raise FileNotFoundError(\"checkpoint file doesn't exist\")\n \n if ckpt_type == \"debug\":\n self.ckpt_debug_saver.restore(sess, ckpt_file)\n elif ckpt_type == \"epoch\":\n self.ckpt_epoch_saver.restore(sess, ckpt_file)\n else:\n raise ValueError(\"unsupported checkpoint type {0}\".format(ckpt_type))","def restore_from_dir(self, checkpoint_dir: str):\r\n\r\n pattern = self.CKPT_FILE_TMPL.format(\"*\")\r\n full_paths = glob.glob(os.path.join(checkpoint_dir, pattern))\r\n if not full_paths:\r\n raise RuntimeError(\r\n \"Searcher unable to find checkpoint in {}\".format(\r\n checkpoint_dir)) # TODO\r\n most_recent_checkpoint = max(full_paths)\r\n self.restore(most_recent_checkpoint)","def load_checkpoint(self, path: str = '', train: bool = True) -> int:\n\n if not path:\n dir_ = os.path.dirname(os.path.realpath('__file__'))\n path = os.path.join(dir_, 'model.pt')\n\n try:\n ckpt = torch.load(path)\n except FileNotFoundError:\n return 0\n else:\n print('Loaded model at epoch: ', end='')\n\n self.load_state_dict(ckpt['model_state_dict'])\n self.actor_optimizer.load_state_dict(ckpt['ac_optim_dict'])\n self.critic_optimizer.load_state_dict(ckpt['critic_optim_dict'])\n epoch = ckpt['epoch']\n\n print(epoch)\n\n if not train:\n self.eval()\n else:\n self.train()\n\n return epoch","def load_checkpoint_train(cpdir, model, optimizer):\n start_epoch = 0\n start_global_step = 0\n if cpdir is not None:\n start_global_step, start_epoch = load_checkpoint(\n cpdir, model, optimizer)\n start_global_step += 1\n start_epoch += 1\n return start_global_step, start_epoch","def load_training(saver, session, load_dir):\n if tf.gfile.Exists(load_dir):\n ckpt = tf.train.get_checkpoint_state(load_dir)\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(session, ckpt.model_checkpoint_path)\n prev_step = extract_step(ckpt.model_checkpoint_path)\n else:\n tf.gfile.DeleteRecursively(load_dir)\n tf.gfile.MakeDirs(load_dir)\n prev_step = 0\n else:\n tf.gfile.MakeDirs(load_dir)\n prev_step = 0\n return prev_step","def restore_checkpoint(model, checkpoint_dir, cuda=False, force=False, pretrain=False):\n try:\n cp_files = [\n file_\n for file_ in os.listdir(checkpoint_dir)\n if file_.startswith(\"epoch=\") and file_.endswith(\".checkpoint.pth.tar\")\n ]\n except FileNotFoundError:\n cp_files = None\n os.makedirs(checkpoint_dir)\n if not cp_files:\n print(\"No saved model parameters found\")\n if force:\n raise Exception(\"Checkpoint not found\")\n else:\n return model, 0, []\n\n # Find latest epoch\n for i in itertools.count(1):\n if \"epoch={}.checkpoint.pth.tar\".format(i) in cp_files:\n epoch = i\n else:\n break\n\n if not force:\n print(\n \"Which epoch to load from? Choose in range [0, {}].\".format(epoch),\n \"Enter 0 to train from scratch.\",\n )\n print(\">> \", end=\"\")\n inp_epoch = int(input())\n if inp_epoch not in range(epoch + 1):\n raise Exception(\"Invalid epoch number\")\n if inp_epoch == 0:\n print(\"Checkpoint not loaded\")\n clear_checkpoint(checkpoint_dir)\n return model, 0, []\n else:\n print(\"Which epoch to load from? Choose in range [1, {}].\".format(epoch))\n inp_epoch = int(input())\n if inp_epoch not in range(1, epoch + 1):\n raise Exception(\"Invalid epoch number\")\n\n filename = os.path.join(\n checkpoint_dir, \"epoch={}.checkpoint.pth.tar\".format(inp_epoch)\n )\n\n print(\"Loading from checkpoint {}?\".format(filename))\n\n if cuda:\n checkpoint = torch.load(filename)\n else:\n # Load GPU model on CPU\n checkpoint = torch.load(filename, map_location=lambda storage, loc: storage)\n\n try:\n start_epoch = checkpoint[\"epoch\"]\n stats = checkpoint[\"stats\"]\n if pretrain:\n model.load_state_dict(checkpoint[\"state_dict\"], strict=False)\n else:\n model.load_state_dict(checkpoint[\"state_dict\"])\n print(\n \"=> Successfully restored checkpoint (trained for {} epochs)\".format(\n checkpoint[\"epoch\"]\n )\n )\n except:\n print(\"=> Checkpoint not successfully restored\")\n raise\n\n return model, inp_epoch, stats","def load_checkpoint(cfg, args):\n checkpoint_iteration = args.checkpoint\n bucket = connect_to_bucket(args.bucket)\n # load actual checkpoint\n if not os.path.isdir(cfg.OUTPUT_DIR):\n os.mkdir(cfg.OUTPUT_DIR)\n blob = bucket.blob(cfg.OUTPUT_DIR + \"/model_\" + str(checkpoint_iteration) + \".pth\")\n blob.download_to_filename(cfg.OUTPUT_DIR + \"/model_\" + str(checkpoint_iteration) + \".pth\")\n if args.resume:\n # also write last checkpoint file for when --resume statement, model gets checkpoint name from this file\n with open(cfg.OUTPUT_DIR + \"/last_checkpoint\", \"w\") as file:\n file.write(\"model_\" + str(checkpoint_iteration) + \".pth\")\n # return statement not clean, but useful for inference code\n return checkpoint_iteration, bucket","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.mnt_best = checkpoint['monitor_best']\n\n # load model params from checkpoint.\n if checkpoint['config']['name'] != self.config['name']:\n self.logger.warning(\n 'Warning: Architecture configuration given in config file is different from that of checkpoint. ' + \\\n 'This may yield an exception while state_dict is being loaded.')\n self.model.load_state_dict(checkpoint['model_state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed. \n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\n self.logger.warning('Warning: Optimizer type given in config file is different from that of checkpoint. ' + \\\n 'Optimizer parameters not being resumed.')\n self.optimizer.load_state_dict(checkpoint['model_optimizer'])\n\n # load scheduler state from checkpoint only when scheduler type is not changed\n if checkpoint['config']['scheduler']['type'] != self.config['scheduler']['type']:\n self.logger.warning('Warning: Scheduler type given in config file is different from that of checkpoint. ' + \\\n 'Scheduler parameters not being resumed.')\n self.scheduler.load_state_dict(checkpoint['model_scheduler'])\n\n self.train_logger = checkpoint['logger']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def load_checkpoint(ckpt_path):\n checkpoint = None\n if ckpt_path:\n logger.info(\"Loading checkpoint from %s\" % ckpt_path)\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\"cpu\"))\n\n if \"model\" in checkpoint.keys():\n # This preserves backward-compat for models using customed layernorm\n def fix_key(s):\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.b_2\", r\"\\1.layer_norm\\2.bias\", s\n )\n s = re.sub(\n r\"(.*)\\.layer_norm((_\\d+)?)\\.a_2\", r\"\\1.layer_norm\\2.weight\", s\n )\n return s\n\n checkpoint[\"model\"] = {\n fix_key(k): v for k, v in checkpoint[\"model\"].items()\n }\n # Force add_ffnbias to True if bias found in model w_1 keys\n for key in checkpoint[\"model\"].keys():\n if \"w_1.bias\" in key:\n checkpoint[\"opt\"].add_ffnbias = True\n\n if not hasattr(checkpoint[\"opt\"], \"num_kv\"):\n checkpoint[\"opt\"].num_kv = 0\n if not hasattr(checkpoint[\"opt\"], \"add_ffnbias\"):\n checkpoint[\"opt\"].add_ffnbias = False\n if not hasattr(checkpoint[\"opt\"], \"parallel_residual\"):\n checkpoint[\"opt\"].parallel_residual = False\n if not hasattr(checkpoint[\"opt\"], \"shared_layer_norm\"):\n checkpoint[\"opt\"].shared_layer_norm = False\n if not hasattr(checkpoint[\"opt\"], \"use_ckpting\"):\n checkpoint[\"opt\"].use_ckpting = []\n if not hasattr(checkpoint[\"opt\"], \"relative_positions_buckets\"):\n checkpoint[\"opt\"].relative_positions_buckets = 0\n if not hasattr(checkpoint[\"opt\"], \"parallel_mode\"):\n checkpoint[\"opt\"].parallel_mode = \"data_parallel\"\n if not hasattr(checkpoint[\"opt\"], \"norm_eps\"):\n checkpoint[\"opt\"].norm_eps = 1e-6\n\n # fix v2 compatibility\n if \"generator\" in checkpoint.keys() and checkpoint[\"generator\"]:\n if \"0.weight\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"weight\"] = checkpoint[\"generator\"].pop(\n \"0.weight\"\n )\n if \"0.bias\" in checkpoint[\"generator\"]:\n checkpoint[\"generator\"][\"bias\"] = checkpoint[\"generator\"].pop(\"0.bias\")\n # end of patch for backward compatibility\n\n return checkpoint","def load_checkpoint(checkpoint_directory,\n session):\n variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n # filter variables if needed.\n print(variables)\n saver_ob = tf.train.Saver(variables, max_to_keep=0)\n os.makedirs(checkpoint_directory, exist_ok=True)\n # verify if we don't have a checkpoint saved directly\n step = 0\n ckpt = tf.train.get_checkpoint_state(checkpoint_directory)\n if ckpt and ckpt.model_checkpoint_path:\n # Restores from checkpoint\n model_checkpoint_path = ckpt.model_checkpoint_path\n saver_ob.restore(session, model_checkpoint_path)\n step = int(model_checkpoint_path.rsplit('-', 1)[1])\n print('Model loaded = ', step)\n return saver_ob, step","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n self.train_logger = checkpoint['logger']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def load_epoch_checkpoint(self, directory, epoch):\n chkpnt = torch.load(directory / f\"chkpnt_epoch{epoch:04d}.pth\")\n self.load_state_dict(chkpnt['model_state_dict'])","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n if self.with_cuda:\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = v.cuda(torch.device('cuda'))\n self.train_logger = checkpoint['logger']\n #self.config = checkpoint['config']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def load_ckp(checkpoint_fpath, model, optimizer, device):\n\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\n model.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n valid_acc = checkpoint['valid_acc'] \n return model, optimizer, checkpoint['epoch'], valid_acc","def from_previous_ckpt(network, checkpoint):\n if os.path.exists(checkpoint):\n if os.path.isfile(checkpoint):\n try:\n network.load_state_dict(torch.load(checkpoint))\n print(f\"Loaded weights from {checkpoint}\")\n except RuntimeError:\n print(f\"{checkpoint} is a invalid checkpoint\")\n print(\"Neglecting this checkpoint.\")\n if os.path.isdir(checkpoint):\n epoch = 0\n file_name = None\n for ckpt in os.listdir(checkpoint):\n if ckpt[-4:] == '.pth':\n try:\n tmp_int_list = re.findall('[0-9]+', ckpt)\n ckpt_epoch = int(tmp_int_list[-1])\n except IndexError:\n ckpt_epoch = 0\n if ckpt_epoch >= epoch:\n epoch = ckpt_epoch\n file_name = os.path.join(checkpoint, ckpt)\n\n if file_name is None:\n print(f\"No checkpoint found in {checkpoint}\")\n print(\"Neglecting this checkpoint.\")\n else:\n try:\n network.load_state_dict(torch.load(file_name))\n print(f\"Loaded weights from {file_name}\")\n except (RuntimeError):\n print(f\"{file_name} is a invalid checkpoint\")\n print(\"Neglecting this checkpoint.\")\n\n else:\n print(f\"the checkpoint path: {checkpoint} doesn't exist.\")\n print(\"Neglecting this checkpoint.\")","def load_checkpoint(self, checkpoint_dir):\r\n\r\n if not os.path.exists(checkpoint_dir):\r\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\r\n\r\n path = os.path.join(checkpoint_dir, 'model.pt')\r\n self.model.load_state_dict(torch.load(path, self.device))\r\n self.update()","def reload_checkpoint_if_exists(sess, saver, train_writer, validation_writer, test_writer):\n global_step = -1\n if FLAGS.continue_run:\n ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)\n if ckpt and ckpt.model_checkpoint_path:\n # Restores from checkpoint\n saver.restore(sess, ckpt.model_checkpoint_path)\n # extract global_step from it.\n global_step = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\n print(\"checkpoint found at step %d\", global_step)\n # ensure that the writers ignore saved summaries that occurred after the last checkpoint but before a crash\n train_writer.add_session_log(tf.SessionLog(status=tf.SessionLog.START), global_step)\n validation_writer.add_session_log(tf.SessionLog(status=tf.SessionLog.START), global_step)\n test_writer.add_session_log(tf.SessionLog(status=tf.SessionLog.START), global_step)\n else:\n print('No checkpoint file found')\n return global_step","def load_checkpoint(tag, params, model):\r\n file_name = os.path.join(\"saved_models\", params.path, tag + \".pt\")\r\n logger.info(\"Load checkpoint from %s\" % file_name)\r\n if os.path.exists(file_name):\r\n checkpoint = torch.load(file_name, map_location='cpu')\r\n params.training_id = checkpoint['training_id']\r\n logger.info(checkpoint['training_id'])\r\n model.global_step = checkpoint['global_step']\r\n model.load_state_dict(checkpoint['model'])\r\n for i, optimizer in enumerate(model.optimizers):\r\n optimizer.load_state_dict(checkpoint['optimizers'][i])\r\n else:\r\n raise Exception(\"Checkpoint not found.\")","def _resume_checkpoint(self, resume_path):\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n self.monitor_best = checkpoint['monitor_best']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n # 将参数全部放入GPU\n if self.with_cuda:\n for state in self.optimizer.state.values():\n for k, v in state.items():\n if isinstance(v, torch.Tensor):\n state[k] = v.cuda(self.device)\n self.train_logger = checkpoint['logger']\n self.config = checkpoint['config']\n self.logger.info(\"Checkpoint '{}' (epoch {}) loaded\".format(resume_path, self.start_epoch))","def load_from_checkpoint(results_dir, load_fn, args):\n ckpt_dir = os.path.join(results_dir, \"tb\", \"version_0\", \"checkpoints\")\n files = os.listdir(ckpt_dir)\n assert len(files) > 0, \"Checkpoint directory is empty\"\n ckpt_path = os.path.join(ckpt_dir, files[-1])\n model = load_fn(checkpoint_path=ckpt_path, args=args)\n return model","def load_ckpt(self):\n status = self.ckpt_manager.restore_or_initialize()\n print(f\"ckpt_manager.restore_or_initialize(): {status}\")","def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\n print(\"Load checkpoint from: {}\".format(path))\n state_dict, optimizer_state = _load(path)\n\n model.load_dict(state_dict)\n if not reset_optimizer and optimizer is not None:\n if optimizer_state is not None:\n print(\"[loading] Load optimizer state from {}\".format(path))\n optimizer.load(optimizer_state)\n\n return model","def _resume_from_checkpoint(model: tf.keras.Model,\n model_dir: str,\n train_steps: int) -> int:\n logging.info('Load from checkpoint is enabled.')\n latest_checkpoint = tf.train.latest_checkpoint(model_dir)\n logging.info('latest_checkpoint: %s', latest_checkpoint)\n if not latest_checkpoint:\n logging.info('No checkpoint detected.')\n return 0\n\n logging.info('Checkpoint file %s found and restoring from '\n 'checkpoint', latest_checkpoint)\n model.load_weights(latest_checkpoint)\n initial_epoch = model.optimizer.iterations // train_steps\n logging.info('Completed loading from checkpoint.')\n logging.info('Resuming from epoch %d', initial_epoch)\n return int(initial_epoch)","def _resume_checkpoint(self, resume_path):\n resume_path = str(resume_path)\n self.logger.info(\"Loading checkpoint: {} ...\".format(resume_path))\n checkpoint = torch.load(resume_path)\n self.start_epoch = checkpoint['epoch'] + 1\n\n # load architecture params from checkpoint.\n if checkpoint['config']['model'] != self.config['model']:\n self.logger.warning(\"Warning: Architecture configuration given in config file is different from that of \"\n \"checkpoint. This may yield an exception while state_dict is being loaded.\")\n self.model.load_state_dict(checkpoint['state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed.\n if checkpoint['config']['trainer']['optimizer']['type'] != self.config['trainer']['optimizer']['type']:\n self.logger.warning(\"Warning: Optimizer type given in config file is different from that of checkpoint. \"\n \"Optimizer parameters not being resumed.\")\n else:\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n self.logger.info(\"Checkpoint loaded. Resume from epoch {}\".format(self.start_epoch))","def load_checkpoint(self, checkpoint_path=None):\n if checkpoint_path is None:\n checkpoint_path = self.get_latest_path()\n\n if os.path.isfile(checkpoint_path):\n key = 'cuda' if torch.cuda.is_available() else 'cpu'\n checkpoint = torch.load(checkpoint_path, map_location=key)\n self.network.load_state_dict(checkpoint['network'])\n self.network_target.load_state_dict(checkpoint['network_target'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n\n print('checkpoint loaded at {}'.format(checkpoint_path))\n else:\n raise OSError(\"Checkpoint file not found.\")","def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\n print(\"Loading checkpoint: {}\".format(checkpoint_path))\n state = torch.load(checkpoint_path)\n self.model.load_state_dict(state['state_dict'])\n self.optimizer.load_state_dict(state['optim_dict'])\n\n if continue_from_epoch:\n self.epoch = state['epoch']","def restore_best_checkpoint(session, ckpt_dir):\n try:\n evals_file = os.path.join(ckpt_dir, EVALUATIONS_FILE)\n f = open(evals_file)\n evals = json.load(f)\n best_ckpt = max(evals, key=lambda e: e['accuracy'])\n\n except Exception as e:\n raise Exception('Error reading evaluations summary file: {}'.format(e))\n\n ckpt_file = \"{}-{}\".format(BEST_MODEL_PREFIX, best_ckpt['iteration'])\n saver = tf.train.Saver()\n saver.restore(session, os.path.join(ckpt_dir, ckpt_file))","def load_checkpoints(args, model): \n print('Loading the model checkpoints from iter {}...'.format(args.resume_iter))\n checkpoint_path = os.path.join(config.checkpoint_path, args.model_type)\n\n gen_g_path = os.path.join(checkpoint_path, '{}-Gen_g.ckpt'.format(args.resume_iter))\n gen_f_path = os.path.join(checkpoint_path, '{}-Gen_f.ckpt'.format(args.resume_iter))\n model.gen_g.load_state_dict(torch.load(gen_g_path, map_location=lambda storage, loc: storage))\n model.gen_f.load_state_dict(torch.load(gen_f_path, map_location=lambda storage, loc: storage))\n\n if args.train:\n dis_c_path = os.path.join(checkpoint_path, '{}-Dis_c.ckpt'.format(args.resume_iter))\n dis_t_path = os.path.join(checkpoint_path, '{}-Dis_t.ckpt'.format(args.resume_iter))\n model.dis_c.load_state_dict(torch.load(dis_c_path, map_location=lambda storage, loc: storage))\n model.dis_t.load_state_dict(torch.load(dis_t_path, map_location=lambda storage, loc: storage))","def get_checkpoint(model, checkpoint='-1'):\n if not os.path.isfile(os.path.join(model, \"checkpoint\")):\n sys.exit(\"[ERROR] Cannot find checkpoint in %s.\" % model)\n ckpt = tf.train.get_checkpoint_state(model)\n\n model_checkpoint_path = ckpt.model_checkpoint_path\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\n\n if not ckpt or not model_checkpoint_path:\n sys.exit(\"[ERROR] Cannot read checkpoint %s.\" % os.path.join(model, \"checkpoint\"))\n\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\n steps = sorted(steps)\n if checkpoint == \"last\":\n tf.logging.info(\"Load the last saved model.\")\n checkpoint = steps[-1]\n else:\n checkpoint = int(checkpoint)\n if checkpoint == -1:\n tf.logging.info(\"Load the best model according to valid_loss\")\n min_epoch = -1\n min_loss = 1e10\n with open(os.path.join(model, \"valid_loss\")) as f:\n for line in f.readlines():\n epoch, loss, eer = line.split(\" \")\n epoch = int(epoch)\n loss = float(loss)\n if loss < min_loss:\n min_loss = loss\n min_epoch = epoch\n # Add 1 to min_epoch since epoch is 0-based\n config_json = os.path.join(model, \"config.json\")\n params = Params(config_json)\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\n tf.logging.info(\"The checkpoint is %d\" % checkpoint)\n assert checkpoint in steps, \"The checkpoint %d not in the model directory\" % checkpoint\n\n model_checkpoint_path = model_checkpoint_path.rsplit(\"-\", 1)[0] + \"-\" + str(checkpoint)\n model_checkpoint_path = os.path.join(model, os.path.basename(model_checkpoint_path))\n\n with open(os.path.join(model, \"checkpoint\"), \"w\") as f:\n f.write(\"model_checkpoint_path: \\\"%s\\\"\\n\" % model_checkpoint_path)\n for checkpoint in all_model_checkpoint_paths:\n checkpoint_new = os.path.join(model, os.path.basename(checkpoint))\n f.write(\"all_model_checkpoint_paths: \\\"%s\\\"\\n\" % checkpoint_new)\n return model_checkpoint_path","def load(cls, path):\n print(f'load checkpoint from {path}')\n if torch.cuda.is_available():\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\n else:\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\n \n # model.flatten_parameters() # make RNN parameters contiguous\n optimizer = resume_checkpoint['optimizer']\n return Checkpoint(\n model=model, \n optimizer=optimizer,\n epoch=resume_checkpoint['epoch'],\n path=path\n )","def load_from_checkpoint(self, path):\n print(f'# loading trainer state from {path}')\n checkpoint = torch.load(path)\n self.load(checkpoint)","def load_checkpoint(checkpoint_file: pl.Path) -> Optional[Dict[str, Any]]:\n if checkpoint_file.exists():\n logger.info(f\"Loading checkpoint {checkpoint_file}.\")\n checkpoint = torch.load(str(checkpoint_file))\n logger.info(f\"Done loading checkpoint from epoch {checkpoint['epoch']}.\")\n else:\n logger.warning(f\"No {checkpoint_file} checkpoint file found. Starting normal.\")\n return checkpoint","def restore(self, checkpoint_path: str):\r\n raise NotImplementedError","def load_checkpoint(self, checkpoint: str, **kwargs) -> None:\n with open(checkpoint, \"rb\") as f:\n state = SafePickle.load(f)\n\n state_id = ray.put(state)\n ray.get([worker.set_state.remote(state_id, **kwargs) for worker in self.remote_workers])","def restore_checkpoint(checkpoint_path: str,\n train_state: Optional[TrainState] = None,\n assert_exist: bool = False,\n step: Optional[int] = None) -> Tuple[TrainState, int]:\n if assert_exist:\n glob_path = os.path.join(checkpoint_path, 'checkpoint_*')\n if not gfile.glob(glob_path):\n raise ValueError('No checkpoint for the pretrained model is found in: '\n f'{checkpoint_path}')\n if train_state is None:\n raise ValueError('Please use `restore_pretrained_checkpoint` for loading'\n 'a checkpoint without providing a Scenic TrainState.')\n train_state = checkpoints.restore_checkpoint(checkpoint_path, train_state,\n step)\n return train_state, int(train_state.global_step)","def load_checkpoint(self, label):\n model_dir = os.path.join(\n config.results_dir, config.experiment_name, 'checkpoints')\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\n\n print(\"Loading model from {}\".format(model_file))\n model_dict = torch.load(model_file)\n\n self.use_cuda = model_dict['use_cuda']\n if self.use_cuda:\n self.net.cuda()\n\n self.net.load_state_dict(model_dict['net_state_dict'])","def restore_checkpoint(self, checkpoint_id, name, path=''):\n\n\t\tself.log.debug(\"restoring Notebook %s from checkpoint %s\", name, checkpoint_id)\n\t\tnb_path = self._get_os_path(name, path)\n\t\tcp_path = self.get_checkpoint_path(checkpoint_id, name, path)\n\n\t\tif not key_exists(self.bucket, cp_path):\n\t\t\tself.log.debug(\"checkpoint file does not exist: %s\", cp_path)\n\t\t\traise web.HTTPError(404,\n\t\t\t\tu'Notebook checkpoint does not exist: %s-%s' % (name, checkpoint_id)\n\t\t\t)\n\t\t# ensure notebook is readable (never restore from an unreadable notebook)\n\t\tkey = self.bucket.get_key(cp_path)\n\t\tnb = current.reads(key.get_contents_as_string(), u'json')\n\t\tself._copy(cp_path, nb_path)\n\t\tself.log.debug(\"copying %s -> %s\", cp_path, nb_path)","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_checkpoint(checkpoint, model, optimizer=None):\n if not os.path.exists(checkpoint):\n raise (\"File doesn't exist {}\".format(checkpoint))\n checkpoint = torch.load(checkpoint)\n model.load_state_dict(checkpoint['state_dict'])\n\n if optimizer:\n optimizer.load_state_dict(checkpoint['optim_dict'])\n\n return checkpoint","def load_checkpoint(checkpoint_path, model, optimizer=None,\n model_key='model_state_dict', optimizer_key='optimizer_state_dict'):\n if not os.path.exists(checkpoint_path):\n raise IOError(f\"Checkpoint '{checkpoint_path}' does not exist\")\n\n state = torch.load(checkpoint_path, map_location='cpu')\n model.load_state_dict(state[model_key])\n\n if optimizer is not None:\n optimizer.load_state_dict(state[optimizer_key])\n\n return state","def _resume(self):\n\n if self.resume_file is None:\n return None\n assert os.path.isfile(self.resume_file)\n logger.info(f'=> loading checkpoint {self.resume_file}')\n checkpoint = torch.load(self.resume_file)\n self.cur_epoch = checkpoint['epoch']\n self.model.load_state_dict(checkpoint['state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer'])\n self.scheduler.load_state_dict(checkpoint['scheduler'])\n self.best_rho = checkpoint['best_rho']\n self.best_nmse = checkpoint['best_nmse']\n self.cur_epoch += 1 # start from the next epoch\n\n logger.info(f'=> successfully loaded checkpoint {self.resume_file} '\n f'from epoch {checkpoint[\"epoch\"]}.\\n')","def load_model_from_checkpoint(self, path: str):\n ckpt = torch.load(path, map_location='cpu')\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\n self.net_q.head.load_state_dict(ckpt['head'])\n self.net_ps.load_state_dict(ckpt['net_ps'])\n self.net_k.load_state_dict(ckpt['net_k'])\n self.queue.load_state_dict(ckpt['queue'])\n self.optimizer.load_state_dict(ckpt['optimizer'])\n if 'scheduler' in ckpt:\n self.scheduler.load_stae_dict(ckpt['scheduler'])\n self.move_optimizer_states(self.optimizer, self.local_rank)","def save_checkpoint(checkpoint_dir, epoch, iteration, save_dict):\n os.makedirs(checkpoint_dir, exist_ok=True)\n path = opj(checkpoint_dir, str(epoch) + '.' + str(iteration) + '.ckpt')\n assert epoch == save_dict['epoch'], \"`epoch` != save_dict's `start_epoch`\"\n assert iteration == save_dict['iteration'], \"`iteration` != save_dict's `start_iteration`\"\n if os.path.isfile(path):\n print(\"Overwrite checkpoint in epoch %d, iteration %d :exclamation:\" % (epoch, iteration))\n try:\n torch.save(save_dict, path)\n except Exception:\n raise Exception(\"Fail to save checkpoint\")\n \n print(\"Checkpoint %s saved :heavy_check_mark:\" % (str(epoch) + '.' + str(iteration) + '.ckpt'))","def warm_start_training(self, sess): \n ckpt = tf.train.latest_checkpoint(self.train_dir)\n if ckpt:\n # the global_step will restore sa well\n saver = tf.train.Saver(tf.global_variables(), max_to_keep=100)\n saver.restore(sess, ckpt)\n print('restore from the checkpoint{0}'.format(ckpt))\n return\n \n if self.checkpoint_path is None:\n return None\n \n exclusions = []\n if self.checkpoint_exclude_scopes:\n exclusions = [scope.strip()\n for scope in self.checkpoint_exclude_scopes.split(',')]\n # TODO(sguada) variables.filter_variables()\n variables_to_restore = []\n all_variables = slim.get_model_variables()\n if tf.gfile.IsDirectory(self.checkpoint_path):\n global_step = slim.get_or_create_global_step()\n all_variables.append(global_step)\n checkpoint_path = tf.train.latest_checkpoint(self.checkpoint_path)\n else:\n checkpoint_path = self.checkpoint_path\n \n for var in all_variables:\n excluded = False\n \n for exclusion in exclusions:\n if var.op.name.startswith(exclusion):\n excluded = True\n break\n if not excluded:\n variables_to_restore.append(var)\n \n# tf.logging.info('Fine-tuning from %s' % checkpoint_path)\n \n slim.assign_from_checkpoint_fn(\n checkpoint_path,\n variables_to_restore)(sess)\n return","def restore_ckpt(sess, ckpt_path, ema_decay=0.9998, export_ckpt=None):\n sess.run(tf.global_variables_initializer())\n if tf.io.gfile.isdir(ckpt_path):\n ckpt_path = tf.train.latest_checkpoint(ckpt_path)\n if ema_decay > 0:\n ema = tf.train.ExponentialMovingAverage(decay=0.0)\n ema_vars = utils.get_ema_vars()\n var_dict = ema.variables_to_restore(ema_vars)\n ema_assign_op = ema.apply(ema_vars)\n else:\n var_dict = utils.get_ema_vars()\n ema_assign_op = None\n\n tf.train.get_or_create_global_step()\n sess.run(tf.global_variables_initializer())\n saver = tf.train.Saver(var_dict, max_to_keep=1)\n if ckpt_path == '_':\n logging.info('Running test: do not load any ckpt.')\n return\n\n # Restore all variables from ckpt.\n saver.restore(sess, ckpt_path)\n\n if export_ckpt:\n print('export model to {}'.format(export_ckpt))\n if ema_assign_op is not None:\n sess.run(ema_assign_op)\n saver = tf.train.Saver(max_to_keep=1, save_relative_paths=True)\n saver.save(sess, export_ckpt)","def get_checkpoint_data(self) -> Dict[str, Any]:\n # get ckpt file path from config.trainer.params.resume_from_checkpoint\n path = self.config.trainer.params.get(\"resume_from_checkpoint\", None)\n if path is not None:\n is_zoo = self.is_zoo_path(path)\n ckpt_filepath = path\n if is_zoo:\n folder = download_pretrained_model(path)\n ckpt_filepath = get_ckpt_path_from_folder(folder)\n ckpt = get_ckpt_from_path(ckpt_filepath)\n config = get_config_from_folder_or_ckpt(folder, ckpt)\n else:\n ckpt = get_ckpt_from_path(ckpt_filepath)\n config = None\n\n return {\n \"ckpt\": ckpt,\n \"checkpoint_path\": ckpt_filepath,\n \"is_zoo\": is_zoo,\n \"config\": config,\n }\n\n is_zoo = False\n config = None\n ckpt = None\n # get ckpt file path from config.checkpoint\n ckpt_config = self.config.checkpoint\n suffix = \"best.ckpt\" if ckpt_config.resume_best else \"current.ckpt\"\n path = os.path.join(get_mmf_env(key=\"save_dir\"), suffix)\n ckpt_filepath = None\n resume_from_specified_path = (\n ckpt_config.resume_file is not None or ckpt_config.resume_zoo is not None\n ) and (not ckpt_config.resume or not PathManager.exists(path))\n if resume_from_specified_path:\n if ckpt_config.resume_file and PathManager.exists(ckpt_config.resume_file):\n ckpt_filepath = ckpt_config.resume_file\n elif ckpt_config.resume_zoo is not None:\n is_zoo = True\n folder = download_pretrained_model(ckpt_config.resume_zoo)\n ckpt_filepath = get_ckpt_path_from_folder(folder)\n ckpt = get_ckpt_from_path(ckpt_filepath)\n config = get_config_from_folder_or_ckpt(folder, ckpt)\n else:\n raise RuntimeError(f\"{ckpt_config.resume_file} doesn't exist\")\n\n if ckpt_config.resume and PathManager.exists(path):\n ckpt_filepath = path\n\n if ckpt_filepath is not None:\n ckpt = get_ckpt_from_path(ckpt_filepath)\n\n return {\n \"ckpt\": ckpt,\n \"checkpoint_path\": ckpt_filepath,\n \"is_zoo\": is_zoo,\n \"config\": config,\n }","def set_loading_step(ckpt_dir, step=None, pol_name='policy'):\n # read the file and find all checkpoints\n with open(os.path.join(ckpt_dir, pol_name+\"/checkpoint\"), \"r\") as f:\n log = f.readlines()\n all_ckpts = []\n for line in log:\n if \"all_model_checkpoint_paths:\" in line:\n num = int(line[34:-2])\n all_ckpts.append(num)\n all_ckpts.sort()\n\n # find the nearest one to the input step\n load_step = None\n if not step is None:\n for s in all_ckpts:\n if s > step:\n load_step = s\n break\n if load_step is None:\n load_step = all_ckpts[-1]\n else:\n load_step = all_ckpts[-1]\n\n # modify the first line of that file\n first_line = log[0]\n new_first_line = first_line[:29] + str(load_step) + first_line[-2:]\n log[0] = new_first_line\n with open(os.path.join(ckpt_dir, pol_name+\"/checkpoint\"), \"w\") as f:\n f.write(\"\".join(log))\n with open(os.path.join(ckpt_dir, pol_name+\"/checkpoint\"), \"r\") as f:\n log = f.readlines()\n print(\"\\nCheckpoint to load:\\n\", log[0], \"\\n\")\n\n return load_step","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(f\"Checkpoint '{checkpoint_path}' does not exist\")\n\n state = torch.load(checkpoint_path)\n try:\n model.load_state_dict(state['model_state_dict'])\n except BaseException as e:\n print('Failed to do something: ' + str(e))\n\n if optimizer is not None:\n try:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n except Exception as e:\n print(e)\n\n return state","def load_ckpt(self):\n for name in [\"G\"]:\n if isinstance(name, str):\n # load_filename = '%s_net_%s.pth' % (epoch, name)\n # load_path = os.path.join(self.save_dir, load_filename)\n # ckpt_path =\n net = getattr(self.model, \"net\" + name)\n if isinstance(net, torch.nn.DataParallel):\n net = net.module\n print(\"loading the model from %s\" % self.option.ckpt_path)\n # if you are using PyTorch newer than 0.4 (e.g., built from\n # GitHub source), you can remove str() on self.device\n state_dict = torch.load(\n self.option.ckpt_path, map_location=str(self.model.device)\n )\n if hasattr(state_dict, \"_metadata\"):\n del state_dict._metadata\n\n # patch InstanceNorm checkpoints prior to 0.4\n # for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop\n # self.__patch_instance_norm_state_dict(state_dict, net, key.split('.'))\n net.load_state_dict(state_dict)","def _restore(self):\n\n output_path = self.output_path + '/checkpoints/'\n checkpoint = tf.train.latest_checkpoint(output_path)\n if checkpoint:\n self.saver.restore(self.session, save_path=checkpoint)\n restored_step = int(checkpoint.split('-')[-1]) # Robust enough?\n return restored_step\n logging.info('Starting training from scratch.')\n return 0","def load_aux(ckpt_path):\n\n ckpt_name = os.path.basename(ckpt_path)\n saver.restore(self.sess, ckpt_path)\n counter = int(next(re.finditer(\"(\\d+)(?!.*\\d)\", ckpt_name)).group(0))\n self.counter = counter\n print(\" [*] Loaded {}\".format(ckpt_name))\n return True, counter","def save_ckpt(self, name=None):\r\n if name is None:\r\n save_path = os.path.join(self.model_dir, \"ckpt_epoch{}.pth\".format(self.clock.epoch))\r\n print(\"Checkpoint saved at {}\".format(save_path))\r\n else:\r\n save_path = os.path.join(self.model_dir, \"{}.pth\".format(name))\r\n if isinstance(self.net, nn.DataParallel):\r\n torch.save({\r\n 'clock': self.clock.make_checkpoint(),\r\n 'model_state_dict': self.net.module.cpu().state_dict(),\r\n 'optimizer_state_dict': self.optimizer.state_dict(),\r\n 'scheduler_state_dict': self.scheduler.state_dict(),\r\n }, save_path)\r\n else:\r\n torch.save({\r\n 'clock': self.clock.make_checkpoint(),\r\n 'model_state_dict': self.net.cpu().state_dict(),\r\n 'optimizer_state_dict': self.optimizer.state_dict(),\r\n 'scheduler_state_dict': self.scheduler.state_dict(),\r\n }, save_path)\r\n self.net.cuda()","def load_checkpoint(fpath):\n if fpath is None:\n raise ValueError('File path is None')\n if not osp.exists(fpath):\n raise FileNotFoundError('File is not found at \"{}\"'.format(fpath))\n map_location = None if torch.cuda.is_available() else 'cpu'\n try:\n checkpoint = torch.load(fpath, map_location=map_location)\n except UnicodeDecodeError:\n pickle.load = partial(pickle.load, encoding=\"latin1\")\n pickle.Unpickler = partial(pickle.Unpickler, encoding=\"latin1\")\n checkpoint = torch.load(\n fpath, pickle_module=pickle, map_location=map_location\n )\n except Exception:\n print('Unable to load checkpoint from \"{}\"'.format(fpath))\n raise\n return checkpoint","def load_last_chkpnt(self, directory):\n last_chkpnt = sorted(list(directory.glob('chkpnt_epoch*.pth')))[-1]\n self.load_checkpoint(last_chkpnt)","def reload_checkpoint(self):\n checkpoint_path = os.path.join(self.params.dump_path, 'checkpoint.pth')\n if not os.path.isfile(checkpoint_path):\n if self.params.reload_checkpoint == '':\n return\n else:\n checkpoint_path = self.params.reload_checkpoint\n assert os.path.isfile(checkpoint_path)\n logger.warning(\"Reloading checkpoint from %s ...\" % checkpoint_path)\n data = torch.load(checkpoint_path, map_location='cpu')\n\n # reload model parameters\n for name in self.MODEL_NAMES:\n getattr(self, name).load_state_dict(data[name])\n\n # reload optimizers\n for name in self.optimizers.keys():\n if False: # AMP checkpoint reloading is buggy, we cannot do that - TODO: fix - https://github.com/NVIDIA/apex/issues/250\n logger.warning(\"Reloading checkpoint optimizer %s ...\" % name)\n else: # instead, we only reload current iterations / learning rates\n logger.warning(\"Not reloading checkpoint optimizer %s.\" % name)\n for group_id, param_group in enumerate(self.optimizers[name].param_groups):\n if 'num_updates' not in param_group:\n logger.warning(\"No 'num_updates' for optimizer %s.\" % name)\n continue\n logger.warning(\"Reloading 'num_updates' and 'lr' for optimizer %s.\" % name)\n param_group['num_updates'] = data['%s_optimizer' % name]['param_groups'][group_id]['num_updates']\n param_group['lr'] = self.optimizers[name].get_lr_for_step(param_group['num_updates'])\n\n # reload main metrics\n self.epoch = data['epoch'] + 1\n self.n_total_iter = data['n_total_iter']\n self.best_metrics = data['best_metrics']\n self.best_stopping_criterion = data['best_stopping_criterion']\n logger.warning(\"Checkpoint reloaded. Resuming at epoch %i / iteration %i ...\" % (self.epoch, self.n_total_iter))","def load_checkpoint(ckpt_path, net, device=None, ret_performance_score=False):\n # See here for details on how to load the checkpoint:\n # https://blog.floydhub.com/checkpointing-tutorial-for-tensorflow-keras-and-pytorch/\n if device is not None and device.type == 'cuda':\n ckpt = torch.load(ckpt_path)\n else:\n # Load GPU model on CPU\n ckpt = torch.load(ckpt_path, map_location=lambda storage, loc: storage)\n\n net.load_state_dict(ckpt['state_dict'])\n\n if ret_performance_score:\n score = ckpt[_INTERNAL_KEY]['score']\n\n # That key was added for maintenance reasons in the method save_checkpoint.\n if _INTERNAL_KEY in ckpt:\n del ckpt[_INTERNAL_KEY]\n\n if ret_performance_score:\n return ckpt, score\n\n return ckpt","def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\n self.model.load_state_dict(checkpoint[\"model_state_dict\"])\n self.optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n return self","def load(self, checkpoint_dir=None):\n\n if checkpoint_dir is None:\n checkpoint_dir = FLAGS.checkpoint_dir\n\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\n\n return self.load_from_path(checkpoint_dir)","def load_checkpoint(self, model, optimizers):\n self.epoch = get_last_epoch(self.log_path)\n\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\n model.load_state_dict(model_state_dict)\n\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\n for opt_ind in range(len(optimizers)):\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\n\n schedulers = load_sched(optimizers, self.epoch)\n\n return model, optimizers, schedulers","def load_checkpoint(self, checkpoint_path: Union[str, Path]) -> Dict[str, Any]:\n # TODO: move to CheckpointIO\n torch.cuda.empty_cache()\n checkpoint_path = inject_model_parallel_rank(checkpoint_path)\n return self.checkpoint_io.load_checkpoint(checkpoint_path)","def get_ckpt(modeldir, logdir, wait_second=10):\n while True:\n try:\n ckpt = _copy_ckpt_to_modeldir(modeldir, logdir)\n return ckpt\n except FileNotFoundError as exp:\n if wait_second:\n tf.logging.info(str(exp) + '\\nWait for 1 minutes.')\n time.sleep(wait_second)\n else:\n return None","def load_checkpoint(checkpoint_path, model, optimizer=None):\n if not os.path.exists(checkpoint_path):\n raise IOError(\"Checkpoint '{}' does not exist\".format(checkpoint_path))\n\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else 'cpu')\n state = torch.load(checkpoint_path, map_location=\"cuda:0\")\n model.load_state_dict(state['model_state_dict'])\n\n if optimizer is not None:\n optimizer.load_state_dict(state['optimizer_state_dict'])\n\n return state","def _resume_checkpoint(self, resume_path, model, optimizer):\n if not resume_path:\n return model, optimizer\n\n self.logger.info(f'Loading checkpoint: {resume_path}')\n checkpoint = torch.load(resume_path)\n model.load_state_dict(checkpoint['state_dict'])\n\n # load optimizer state from checkpoint only when optimizer type is not changed.\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\n self.logger.warning(\"Warning: Optimizer type given in config file is different from \"\n \"that of checkpoint. Optimizer parameters not being resumed.\")\n else:\n optimizer.load_state_dict(checkpoint['optimizer'])\n\n self.logger.info(f'Checkpoint \"{resume_path}\" loaded')\n return model, optimizer","def load_model(self, ckpt_fn):\n checkpoint = torch.load(ckpt_fn)\n self.net_.load_state_dict(checkpoint[\"model\"])\n self.optimizer_.load_state_dict(checkpoint[\"optimizer\"])\n self.epoch_ = checkpoint[\"epoch\"]\n self.global_step_ = checkpoint[\"global_step\"]\n self.model_samples_ = deque(checkpoint[\"model_samples\"])\n self.sampler.load_state_dict(checkpoint[\"sampler_state\"])\n self.ais_loss.load_state_dict(checkpoint[\"ais_state\"])\n self.replay_prob = checkpoint[\"replay_prob\"]\n self.max_replay = checkpoint[\"max_replay\"]","def load(self, sess, step=None):\n if step==None:\n ckpt_path = tf.train.latest_checkpoint(self.model.ckpt_dir)\n else:\n ckpt_path = os.path.join(self.model.ckpt_dir, 'model-'+str(step))\n self.saver.restore(sess, ckpt_path)\n step = tf.train.global_step(sess, self.gstep)\n print('Load model at step {} from check point {}.'.format(step, ckpt_path))","def load_checkpoint(self, folder='checkpoint', filename='checkpoint.pth.tar'):\n data = dict()\n data[\"inst\"] = \"load\"\n data[\"folder\"] = folder\n data[\"filename\"] = filename\n\n # Send load requests to every nnet\n metadata = []\n for i in range(len(self.nsyncs)):\n metadata.append(self.put(data, q_idx=i))\n\n # Wait for all nnets to finish\n for q_idx, data_id in metadata:\n self.get(q_idx, data_id) # Blocks here\n\n # Done","def resume_model(self, resume_path):\n if resume_path:\n resume_path = f'{self.model_dir}/{resume_path}.pth.tar'\n if os.path.isfile(resume_path):\n print(f\"=> loading checkpoint '{resume_path}'\")\n checkpoint = torch.load(resume_path, map_location=self.device)\n self.best_acc = checkpoint['best_acc']\n self.model.load_state_dict(checkpoint['state_dict'])\n print(f\"=> loaded checkpoint '{resume_path}' (Round {checkpoint['rnd']})\")\n del checkpoint\n else:\n print(f\"=> no checkpoint found at '{resume_path}'\")","def restore_session(saver, sess, model_dir):\n checkpoint = tf.train.get_checkpoint_state(model_dir)\n if checkpoint and checkpoint.model_checkpoint_path:\n saver.restore(sess, checkpoint.model_checkpoint_path)\n print(\"checkpoint loaded:\", checkpoint.model_checkpoint_path)\n tokens = checkpoint.model_checkpoint_path.split(\"-\")\n # set global step\n global_t = int(tokens[2])\n n_episode = int(tokens[1])\n print(\">>> global step set: \", global_t)\n else:\n print(\"Could not find old checkpoint\")\n global_t = 0\n n_episode = 0\n return global_t, n_episode","def restore(self, sess, path=None, var_list=None):\n\n saver = tf.train.Saver(var_list)\n if path is None:\n path = tf.train.latest_checkpoint(os.path.dirname(self.config.CHECKPOINTS_PATH))\n saver.restore(sess, path)\n print(\"model restored from %s\" % path)","def load_checkpoint(self, checkpoint_filepath=None, verbose=True):\n if checkpoint_filepath:\n print('loading', checkpoint_filepath, flush=True)\n optimistic_restore(self._session, checkpoint_filepath, verbose=verbose)\n return True\n else:\n checkpoints = retrieve_all_checkpoints(self._checkpoints_path) + retrieve_all_checkpoints(self._recovery_checkpoints_path)\n\n if checkpoints:\n last_checkpoint = sorted(checkpoints)[-1][1]\n print('loading', last_checkpoint, flush=True)\n optimistic_restore(self._session, last_checkpoint, verbose=verbose)\n return True\n else:\n print('nothing to restore. no checkpoint found.', flush=True)\n return False","def initialize_variables(sess, saver, logdir, checkpoint=None, resume=None):\n sess.run(tf.group(\n tf.local_variables_initializer(),\n tf.global_variables_initializer()))\n if resume and not (logdir or checkpoint):\n raise ValueError('Need to specify logdir to resume a checkpoint.')\n if logdir:\n state = tf.train.get_checkpoint_state(logdir)\n if checkpoint:\n checkpoint = os.path.join(logdir, checkpoint)\n print('checkpoint {}'.format(checkpoint))\n if not checkpoint and state and state.model_checkpoint_path:\n checkpoint = state.model_checkpoint_path\n if checkpoint and resume is False:\n message = 'Found unexpected checkpoint when starting a new run.'\n raise RuntimeError(message)\n print('checkpoint {}'.format(checkpoint))\n if checkpoint:\n saver.restore(sess, checkpoint)","def load_checkpoint(model, save_path):\n model.load_state_dict(torch.load(save_path))","def checkpoint(self):\n self.logger.info('Checkpointing Sampler')\n with open(self.resume_file, \"wb\") as f:\n pickle.dump(self, f)","def load_checkpoint(self, checkpoint_path: str, *args, **kwargs) -> Dict:\n return torch.load(checkpoint_path, *args, **kwargs)","def load_checkpoint(self, checkpoint_path: str, *args, **kwargs) -> Dict:\n return torch.load(checkpoint_path, *args, **kwargs)","def load_checkpoint(self, file):\n \"\"\"Load \"\"\"\n chkpnt = torch.load(file)\n self.load_state_dict(chkpnt['model_state_dict'])","def resume(self, checkpoint):\n model_dict = paddle.load(checkpoint)\n self.model.set_state_dict(model_dict)","def load_checkpoint(model, model_name='model', validation_id=None):\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\n _load_model(model.module if type(model) is torch.nn.DataParallel else model, model_name, path=path, reload=True)","def _load_checkpoint(filename, map_location=None):\n if filename.startswith('modelzoo://'):\n warnings.warn('The URL scheme of \"modelzoo://\" is deprecated, please '\n 'use \"torchvision://\" instead')\n model_urls = get_torchvision_models()\n model_name = filename[11:]\n checkpoint = load_url_dist(model_urls[model_name])\n elif filename.startswith('torchvision://'):\n model_urls = get_torchvision_models()\n model_name = filename[14:]\n checkpoint = load_url_dist(model_urls[model_name])\n elif filename.startswith('open-mmlab://'):\n model_urls = get_external_models()\n model_name = filename[13:]\n deprecated_urls = get_deprecated_model_names()\n if model_name in deprecated_urls:\n warnings.warn(f'open-mmlab://{model_name} is deprecated in favor '\n f'of open-mmlab://{deprecated_urls[model_name]}')\n model_name = deprecated_urls[model_name]\n model_url = model_urls[model_name]\n # check if is url\n if model_url.startswith(('http://', 'https://')):\n checkpoint = load_url_dist(model_url)\n else:\n filename = osp.join(_get_mmcv_home(), model_url)\n if not osp.isfile(filename):\n raise IOError(f'{filename} is not a checkpoint file')\n checkpoint = torch.load(filename, map_location=map_location)\n elif filename.startswith('mmcls://'):\n model_urls = get_mmcls_models()\n model_name = filename[8:]\n checkpoint = load_url_dist(model_urls[model_name])\n checkpoint = _process_mmcls_checkpoint(checkpoint)\n elif filename.startswith(('http://', 'https://')):\n checkpoint = load_url_dist(filename)\n elif filename.startswith('pavi://'):\n model_path = filename[7:]\n checkpoint = load_pavimodel_dist(model_path, map_location=map_location)\n elif filename.startswith('s3://'):\n checkpoint = load_fileclient_dist(\n filename, backend='ceph', map_location=map_location)\n else:\n if not osp.isfile(filename):\n raise IOError(f'{filename} is not a checkpoint file')\n checkpoint = torch.load(filename, map_location=map_location)\n return checkpoint","def load_variables_from_checkpoint(sess, start_checkpoint):\n saver = tf.train.Saver(tf.global_variables())\n saver.restore(sess, start_checkpoint)","def load_variables_from_checkpoint(sess, start_checkpoint):\n saver = tf.train.Saver(tf.global_variables())\n saver.restore(sess, start_checkpoint)","def load_model(self, checkpoint):\n print(f'Load parameters from {checkpoint}')\n epoch = re.match(r\"[0-9]*\", os.path.basename(checkpoint)).group(0)\n self.epoch_i = int(epoch)\n self.model.load_state_dict(torch.load(checkpoint))","def load_checkpoint(checkpoint_path):\n flat_checkpoint_dict = flatten_checkpoint(\n parse_checkpoint(checkpoint_path), keep_empty_nodes=True)\n return flat_checkpoint_dict","def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,\n key_in_state_dict: str, use_gpu: bool) -> int:\n logging.info(f\"Loading checkpoint {checkpoint_path}\")\n checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)\n\n try:\n state_dict = checkpoint[key_in_state_dict]\n except KeyError:\n logging.error(f\"Key {key_in_state_dict} not found in checkpoint\")\n return False\n\n if isinstance(model, torch.nn.DataParallel):\n result = model.module.load_state_dict(state_dict, strict=False)\n else:\n result = model.load_state_dict(state_dict, strict=False)\n\n if result.missing_keys:\n logging.warning(f\"Missing keys in model checkpoint: {result.missing_keys}\")\n if result.unexpected_keys:\n logging.warning(f\"Unexpected keys in model checkpoint: {result.unexpected_keys}\")\n\n return checkpoint[ModelAndInfo.EPOCH_KEY]","def checkpoint():","def test_model_checkpoint_path(tmpdir, logger_version, expected):\n tutils.reset_seed()\n model = EvalModelTemplate()\n logger = TensorBoardLogger(str(tmpdir), version=logger_version)\n\n trainer = Trainer(\n default_root_dir=tmpdir,\n overfit_pct=0.2,\n max_epochs=5,\n logger=logger\n )\n trainer.fit(model)\n\n ckpt_version = Path(trainer.ckpt_path).parent.name\n assert ckpt_version == expected","def saveCheckpoint(acc, epoch, model, train_hist):\r\n print('Saving..')\r\n state = {\r\n 'model': model,\r\n 'acc': acc,\r\n 'epoch': epoch,\r\n 'rng_state': torch.get_rng_state(),\r\n 'train_hist': train_hist\r\n }\r\n if not os.path.isdir('checkpoint'): # save to checkpoint directory\r\n os.mkdir('checkpoint')\r\n torch.save(state, './checkpoint/ckpt' + '_' + str(epoch+1))","def restore(self, checkpoint):\n raise NotImplementedError"],"string":"[\n \"def load_ckpt(saver, sess, ckpt_dir=\\\"train\\\"):\\n while True:\\n try:\\n latest_filename = \\\"checkpoint_best\\\" if ckpt_dir == \\\"eval\\\" else None\\n ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)\\n ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest_filename)\\n tf.logging.info('Loading checkpoint %s', ckpt_state.model_checkpoint_path)\\n saver.restore(sess, ckpt_state.model_checkpoint_path)\\n return ckpt_state.model_checkpoint_path\\n except:\\n tf.logging.info(\\\"Failed to load checkpoint from %s. Sleeping for %i secs...\\\", ckpt_dir, 10)\\n time.sleep(10)\",\n \"def load_from_path(self, checkpoint_dir):\\n\\n vars = self.save_var_names\\n saver = tf.train.Saver(vars)\\n\\n def load_aux(ckpt_path):\\n \\\"\\\"\\\"Helper function to not repeat the same code in the following lines.\\\"\\\"\\\"\\n\\n ckpt_name = os.path.basename(ckpt_path)\\n saver.restore(self.sess, ckpt_path)\\n counter = int(next(re.finditer(\\\"(\\\\d+)(?!.*\\\\d)\\\", ckpt_name)).group(0))\\n self.counter = counter\\n print(\\\" [*] Loaded {}\\\".format(ckpt_name))\\n return True, counter\\n\\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\\n try:\\n if ckpt and ckpt.model_checkpoint_path:\\n ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\\n return load_aux(os.path.join(checkpoint_dir, ckpt_name))\\n else:\\n print(\\n \\\" [!] Failed to find a checkpoint within directory {}\\\".format(\\n FLAGS.ckpt_path))\\n return False, 0\\n except:\\n print(\\\" [!] Failed to find a checkpoint, Exception!\\\")\\n return False, 0\",\n \"def load(loadname, checkpoint=None):\\n ckpt_dir = \\\"./models/tf_ckpt_\\\" + loadname + \\\"/\\\"\\n if checkpoint is not None:\\n status = checkpoint.restore(tf.train.latest_checkpoint(ckpt_dir))\\n status.assert_consumed()\\n print(\\\"Loaded checkpoint\\\")\\n else:\\n print(\\\"Not Loading any checkpoint\\\")\\n print(\\\"Starting training from initial configuration\\\")\",\n \"def load_ckpt(self, name=None):\\r\\n name = name if name == 'latest' else \\\"ckpt_epoch{}\\\".format(name)\\r\\n load_path = os.path.join(self.model_dir, \\\"{}.pth\\\".format(name))\\r\\n if not os.path.exists(load_path):\\r\\n raise ValueError(\\\"Checkpoint {} not exists.\\\".format(load_path))\\r\\n\\r\\n checkpoint = torch.load(load_path)\\r\\n print(\\\"Checkpoint loaded from {}\\\".format(load_path))\\r\\n if isinstance(self.net, nn.DataParallel):\\r\\n self.net.module.load_state_dict(checkpoint['model_state_dict'])\\r\\n else:\\r\\n self.net.load_state_dict(checkpoint['model_state_dict'])\\r\\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\\r\\n self.scheduler.load_state_dict(checkpoint['scheduler_state_dict'])\\r\\n self.clock.restore_checkpoint(checkpoint['clock'])\",\n \"def load(self, checkpoint_dir):\\n print(\\\"\\\\nReading Checkpoints.....\\\\n\\\\n\\\")\\n model_dir = \\\"%s\\\" % (\\\"cnn\\\") # give the model name by label_size\\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir)\\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\\n \\n # Check the checkpoint is exist\\n if ckpt and ckpt.model_checkpoint_path:\\n ckpt_path = str(ckpt.model_checkpoint_path) # convert the unicode to string\\n self.saver.restore(self.sess, os.path.join(os.getcwd(), ckpt_path))\\n print(\\\"\\\\n Checkpoint Loading Success! %s\\\\n\\\\n\\\"% ckpt_path)\\n else:\\n print(\\\"\\\\n! Checkpoint Loading Failed \\\\n\\\\n\\\")\",\n \"def load_checkpoint(self, session, model_dir):\\n assert self.params.cp_load == True, (\\\"cp_load must be set to true to load a checkpoint\\\")\\n self.loader.restore(session, model_dir)\",\n \"def load_checkpoint(self):\\n if self.params.resume_from is not None and os.path.exists(self.params.resume_from):\\n try:\\n LOG('Loading Checkpoint at %s' % self.params.resume_from)\\n ckpt = torch.load(self.params.resume_from)\\n self.epoch = ckpt['epoch']\\n try:\\n self.train_loss = ckpt['train_loss']\\n self.val_loss = ckpt['val_loss']\\n except:\\n self.train_loss = []\\n self.val_loss = []\\n self.network.load_state_dict(ckpt['state_dict'])\\n self.opt.load_state_dict(ckpt['optimizer'])\\n LOG('Checkpoint Loaded!')\\n LOG('Current Epoch: %d' % self.epoch)\\n self.ckpt_flag = True\\n except:\\n WARNING('Cannot load checkpoint from %s. Start loading pre-trained model......' % self.params.resume_from)\\n else:\\n WARNING('Checkpoint do not exists. Start loading pre-trained model......')\",\n \"def load_training_checkpoint(args, model, PATH, ckpt_id):\\r\\n logger = args.logger\\r\\n _, checkpoint_state_dict = model.network.load_checkpoint(PATH, ckpt_id)\\r\\n epoch = checkpoint_state_dict['epoch']\\r\\n last_global_step = checkpoint_state_dict['last_global_step']\\r\\n last_global_data_samples = checkpoint_state_dict[\\r\\n 'last_global_data_samples']\\r\\n del checkpoint_state_dict\\r\\n return (epoch, last_global_step, last_global_data_samples)\",\n \"def load_checkpoint(checkpoint_dir, epoch, iteration):\\n path = opj(checkpoint_dir, str(epoch) + '.' + str(iteration) + '.ckpt')\\n if not os.path.isfile(path):\\n raise Exception(\\\"Checkpoint in epoch %d doesn't exist :sob:\\\" % epoch)\\n\\n checkpoint = torch.load(path)\\n start_epoch = checkpoint['epoch']\\n state_dict = checkpoint['state_dict']\\n start_iteration = checkpoint['iteration']\\n\\n assert iteration == start_iteration\\n return start_epoch, start_iteration, state_dict\",\n \"def restore(self, checkpoint_path):\\n start_time = time.time()\\n latest_checkpoint = train_util.get_latest_chekpoint(checkpoint_path)\\n if latest_checkpoint is not None:\\n checkpoint = tf.train.Checkpoint(model=self)\\n checkpoint.restore(latest_checkpoint).expect_partial()\\n logging.info('Loaded checkpoint %s', latest_checkpoint)\\n logging.info('Loading model took %.1f seconds', time.time() - start_time)\\n else:\\n logging.info('Could not find checkpoint to load at %s, skipping.',\\n checkpoint_path)\",\n \"def load_checkpoint(self):\\n checkpoin_path = self.get_checkpoint_path()\\n _logger.info('Load checkpoint ignored by tuner, checkpoint path: %s', checkpoin_path)\",\n \"def load_checkpoint(args, trainer, epoch_itr):\\n os.makedirs(os.path.join(args.save_dir, 'checkpoints'), exist_ok=True)\\n checkpoint_path = os.path.join(args.save_dir, 'checkpoints', args.restore_file)\\n if os.path.isfile(checkpoint_path):\\n extra_state = trainer.load_checkpoint(checkpoint_path)\\n if extra_state is not None:\\n # replay train iterator to match checkpoint\\n epoch_itr.load_state_dict(extra_state['train_iterator'])\\n\\n print('| loaded checkpoint {} (epoch {} @ {} updates)'.format(\\n checkpoint_path, epoch_itr.epoch, trainer.get_num_updates()))\\n\\n trainer.lr_step(epoch_itr.epoch)\\n trainer.lr_step_update(trainer.get_num_updates())\\n if 'best' in extra_state:\\n save_checkpoint.best = extra_state['best']\",\n \"def restore(self,\\n sess,\\n ckpt_file,\\n ckpt_type):\\n if ckpt_file is None:\\n raise FileNotFoundError(\\\"checkpoint file doesn't exist\\\")\\n \\n if ckpt_type == \\\"debug\\\":\\n self.ckpt_debug_saver.restore(sess, ckpt_file)\\n elif ckpt_type == \\\"epoch\\\":\\n self.ckpt_epoch_saver.restore(sess, ckpt_file)\\n else:\\n raise ValueError(\\\"unsupported checkpoint type {0}\\\".format(ckpt_type))\",\n \"def restore_from_dir(self, checkpoint_dir: str):\\r\\n\\r\\n pattern = self.CKPT_FILE_TMPL.format(\\\"*\\\")\\r\\n full_paths = glob.glob(os.path.join(checkpoint_dir, pattern))\\r\\n if not full_paths:\\r\\n raise RuntimeError(\\r\\n \\\"Searcher unable to find checkpoint in {}\\\".format(\\r\\n checkpoint_dir)) # TODO\\r\\n most_recent_checkpoint = max(full_paths)\\r\\n self.restore(most_recent_checkpoint)\",\n \"def load_checkpoint(self, path: str = '', train: bool = True) -> int:\\n\\n if not path:\\n dir_ = os.path.dirname(os.path.realpath('__file__'))\\n path = os.path.join(dir_, 'model.pt')\\n\\n try:\\n ckpt = torch.load(path)\\n except FileNotFoundError:\\n return 0\\n else:\\n print('Loaded model at epoch: ', end='')\\n\\n self.load_state_dict(ckpt['model_state_dict'])\\n self.actor_optimizer.load_state_dict(ckpt['ac_optim_dict'])\\n self.critic_optimizer.load_state_dict(ckpt['critic_optim_dict'])\\n epoch = ckpt['epoch']\\n\\n print(epoch)\\n\\n if not train:\\n self.eval()\\n else:\\n self.train()\\n\\n return epoch\",\n \"def load_checkpoint_train(cpdir, model, optimizer):\\n start_epoch = 0\\n start_global_step = 0\\n if cpdir is not None:\\n start_global_step, start_epoch = load_checkpoint(\\n cpdir, model, optimizer)\\n start_global_step += 1\\n start_epoch += 1\\n return start_global_step, start_epoch\",\n \"def load_training(saver, session, load_dir):\\n if tf.gfile.Exists(load_dir):\\n ckpt = tf.train.get_checkpoint_state(load_dir)\\n if ckpt and ckpt.model_checkpoint_path:\\n saver.restore(session, ckpt.model_checkpoint_path)\\n prev_step = extract_step(ckpt.model_checkpoint_path)\\n else:\\n tf.gfile.DeleteRecursively(load_dir)\\n tf.gfile.MakeDirs(load_dir)\\n prev_step = 0\\n else:\\n tf.gfile.MakeDirs(load_dir)\\n prev_step = 0\\n return prev_step\",\n \"def restore_checkpoint(model, checkpoint_dir, cuda=False, force=False, pretrain=False):\\n try:\\n cp_files = [\\n file_\\n for file_ in os.listdir(checkpoint_dir)\\n if file_.startswith(\\\"epoch=\\\") and file_.endswith(\\\".checkpoint.pth.tar\\\")\\n ]\\n except FileNotFoundError:\\n cp_files = None\\n os.makedirs(checkpoint_dir)\\n if not cp_files:\\n print(\\\"No saved model parameters found\\\")\\n if force:\\n raise Exception(\\\"Checkpoint not found\\\")\\n else:\\n return model, 0, []\\n\\n # Find latest epoch\\n for i in itertools.count(1):\\n if \\\"epoch={}.checkpoint.pth.tar\\\".format(i) in cp_files:\\n epoch = i\\n else:\\n break\\n\\n if not force:\\n print(\\n \\\"Which epoch to load from? Choose in range [0, {}].\\\".format(epoch),\\n \\\"Enter 0 to train from scratch.\\\",\\n )\\n print(\\\">> \\\", end=\\\"\\\")\\n inp_epoch = int(input())\\n if inp_epoch not in range(epoch + 1):\\n raise Exception(\\\"Invalid epoch number\\\")\\n if inp_epoch == 0:\\n print(\\\"Checkpoint not loaded\\\")\\n clear_checkpoint(checkpoint_dir)\\n return model, 0, []\\n else:\\n print(\\\"Which epoch to load from? Choose in range [1, {}].\\\".format(epoch))\\n inp_epoch = int(input())\\n if inp_epoch not in range(1, epoch + 1):\\n raise Exception(\\\"Invalid epoch number\\\")\\n\\n filename = os.path.join(\\n checkpoint_dir, \\\"epoch={}.checkpoint.pth.tar\\\".format(inp_epoch)\\n )\\n\\n print(\\\"Loading from checkpoint {}?\\\".format(filename))\\n\\n if cuda:\\n checkpoint = torch.load(filename)\\n else:\\n # Load GPU model on CPU\\n checkpoint = torch.load(filename, map_location=lambda storage, loc: storage)\\n\\n try:\\n start_epoch = checkpoint[\\\"epoch\\\"]\\n stats = checkpoint[\\\"stats\\\"]\\n if pretrain:\\n model.load_state_dict(checkpoint[\\\"state_dict\\\"], strict=False)\\n else:\\n model.load_state_dict(checkpoint[\\\"state_dict\\\"])\\n print(\\n \\\"=> Successfully restored checkpoint (trained for {} epochs)\\\".format(\\n checkpoint[\\\"epoch\\\"]\\n )\\n )\\n except:\\n print(\\\"=> Checkpoint not successfully restored\\\")\\n raise\\n\\n return model, inp_epoch, stats\",\n \"def load_checkpoint(cfg, args):\\n checkpoint_iteration = args.checkpoint\\n bucket = connect_to_bucket(args.bucket)\\n # load actual checkpoint\\n if not os.path.isdir(cfg.OUTPUT_DIR):\\n os.mkdir(cfg.OUTPUT_DIR)\\n blob = bucket.blob(cfg.OUTPUT_DIR + \\\"/model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n blob.download_to_filename(cfg.OUTPUT_DIR + \\\"/model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n if args.resume:\\n # also write last checkpoint file for when --resume statement, model gets checkpoint name from this file\\n with open(cfg.OUTPUT_DIR + \\\"/last_checkpoint\\\", \\\"w\\\") as file:\\n file.write(\\\"model_\\\" + str(checkpoint_iteration) + \\\".pth\\\")\\n # return statement not clean, but useful for inference code\\n return checkpoint_iteration, bucket\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.mnt_best = checkpoint['monitor_best']\\n\\n # load model params from checkpoint.\\n if checkpoint['config']['name'] != self.config['name']:\\n self.logger.warning(\\n 'Warning: Architecture configuration given in config file is different from that of checkpoint. ' + \\\\\\n 'This may yield an exception while state_dict is being loaded.')\\n self.model.load_state_dict(checkpoint['model_state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed. \\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\\n self.logger.warning('Warning: Optimizer type given in config file is different from that of checkpoint. ' + \\\\\\n 'Optimizer parameters not being resumed.')\\n self.optimizer.load_state_dict(checkpoint['model_optimizer'])\\n\\n # load scheduler state from checkpoint only when scheduler type is not changed\\n if checkpoint['config']['scheduler']['type'] != self.config['scheduler']['type']:\\n self.logger.warning('Warning: Scheduler type given in config file is different from that of checkpoint. ' + \\\\\\n 'Scheduler parameters not being resumed.')\\n self.scheduler.load_state_dict(checkpoint['model_scheduler'])\\n\\n self.train_logger = checkpoint['logger']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def load_checkpoint(ckpt_path):\\n checkpoint = None\\n if ckpt_path:\\n logger.info(\\\"Loading checkpoint from %s\\\" % ckpt_path)\\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\\\"cpu\\\"))\\n\\n if \\\"model\\\" in checkpoint.keys():\\n # This preserves backward-compat for models using customed layernorm\\n def fix_key(s):\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.b_2\\\", r\\\"\\\\1.layer_norm\\\\2.bias\\\", s\\n )\\n s = re.sub(\\n r\\\"(.*)\\\\.layer_norm((_\\\\d+)?)\\\\.a_2\\\", r\\\"\\\\1.layer_norm\\\\2.weight\\\", s\\n )\\n return s\\n\\n checkpoint[\\\"model\\\"] = {\\n fix_key(k): v for k, v in checkpoint[\\\"model\\\"].items()\\n }\\n # Force add_ffnbias to True if bias found in model w_1 keys\\n for key in checkpoint[\\\"model\\\"].keys():\\n if \\\"w_1.bias\\\" in key:\\n checkpoint[\\\"opt\\\"].add_ffnbias = True\\n\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"num_kv\\\"):\\n checkpoint[\\\"opt\\\"].num_kv = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"add_ffnbias\\\"):\\n checkpoint[\\\"opt\\\"].add_ffnbias = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_residual\\\"):\\n checkpoint[\\\"opt\\\"].parallel_residual = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"shared_layer_norm\\\"):\\n checkpoint[\\\"opt\\\"].shared_layer_norm = False\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"use_ckpting\\\"):\\n checkpoint[\\\"opt\\\"].use_ckpting = []\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"relative_positions_buckets\\\"):\\n checkpoint[\\\"opt\\\"].relative_positions_buckets = 0\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"parallel_mode\\\"):\\n checkpoint[\\\"opt\\\"].parallel_mode = \\\"data_parallel\\\"\\n if not hasattr(checkpoint[\\\"opt\\\"], \\\"norm_eps\\\"):\\n checkpoint[\\\"opt\\\"].norm_eps = 1e-6\\n\\n # fix v2 compatibility\\n if \\\"generator\\\" in checkpoint.keys() and checkpoint[\\\"generator\\\"]:\\n if \\\"0.weight\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"weight\\\"] = checkpoint[\\\"generator\\\"].pop(\\n \\\"0.weight\\\"\\n )\\n if \\\"0.bias\\\" in checkpoint[\\\"generator\\\"]:\\n checkpoint[\\\"generator\\\"][\\\"bias\\\"] = checkpoint[\\\"generator\\\"].pop(\\\"0.bias\\\")\\n # end of patch for backward compatibility\\n\\n return checkpoint\",\n \"def load_checkpoint(checkpoint_directory,\\n session):\\n variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\\n # filter variables if needed.\\n print(variables)\\n saver_ob = tf.train.Saver(variables, max_to_keep=0)\\n os.makedirs(checkpoint_directory, exist_ok=True)\\n # verify if we don't have a checkpoint saved directly\\n step = 0\\n ckpt = tf.train.get_checkpoint_state(checkpoint_directory)\\n if ckpt and ckpt.model_checkpoint_path:\\n # Restores from checkpoint\\n model_checkpoint_path = ckpt.model_checkpoint_path\\n saver_ob.restore(session, model_checkpoint_path)\\n step = int(model_checkpoint_path.rsplit('-', 1)[1])\\n print('Model loaded = ', step)\\n return saver_ob, step\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n self.train_logger = checkpoint['logger']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def load_epoch_checkpoint(self, directory, epoch):\\n chkpnt = torch.load(directory / f\\\"chkpnt_epoch{epoch:04d}.pth\\\")\\n self.load_state_dict(chkpnt['model_state_dict'])\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n if self.with_cuda:\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = v.cuda(torch.device('cuda'))\\n self.train_logger = checkpoint['logger']\\n #self.config = checkpoint['config']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def load_ckp(checkpoint_fpath, model, optimizer, device):\\n\\n checkpoint = torch.load(checkpoint_fpath,map_location=device)\\n model.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n valid_acc = checkpoint['valid_acc'] \\n return model, optimizer, checkpoint['epoch'], valid_acc\",\n \"def from_previous_ckpt(network, checkpoint):\\n if os.path.exists(checkpoint):\\n if os.path.isfile(checkpoint):\\n try:\\n network.load_state_dict(torch.load(checkpoint))\\n print(f\\\"Loaded weights from {checkpoint}\\\")\\n except RuntimeError:\\n print(f\\\"{checkpoint} is a invalid checkpoint\\\")\\n print(\\\"Neglecting this checkpoint.\\\")\\n if os.path.isdir(checkpoint):\\n epoch = 0\\n file_name = None\\n for ckpt in os.listdir(checkpoint):\\n if ckpt[-4:] == '.pth':\\n try:\\n tmp_int_list = re.findall('[0-9]+', ckpt)\\n ckpt_epoch = int(tmp_int_list[-1])\\n except IndexError:\\n ckpt_epoch = 0\\n if ckpt_epoch >= epoch:\\n epoch = ckpt_epoch\\n file_name = os.path.join(checkpoint, ckpt)\\n\\n if file_name is None:\\n print(f\\\"No checkpoint found in {checkpoint}\\\")\\n print(\\\"Neglecting this checkpoint.\\\")\\n else:\\n try:\\n network.load_state_dict(torch.load(file_name))\\n print(f\\\"Loaded weights from {file_name}\\\")\\n except (RuntimeError):\\n print(f\\\"{file_name} is a invalid checkpoint\\\")\\n print(\\\"Neglecting this checkpoint.\\\")\\n\\n else:\\n print(f\\\"the checkpoint path: {checkpoint} doesn't exist.\\\")\\n print(\\\"Neglecting this checkpoint.\\\")\",\n \"def load_checkpoint(self, checkpoint_dir):\\r\\n\\r\\n if not os.path.exists(checkpoint_dir):\\r\\n raise Exception('No checkpoint directory <%s>' % checkpoint_dir)\\r\\n\\r\\n path = os.path.join(checkpoint_dir, 'model.pt')\\r\\n self.model.load_state_dict(torch.load(path, self.device))\\r\\n self.update()\",\n \"def reload_checkpoint_if_exists(sess, saver, train_writer, validation_writer, test_writer):\\n global_step = -1\\n if FLAGS.continue_run:\\n ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)\\n if ckpt and ckpt.model_checkpoint_path:\\n # Restores from checkpoint\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n # extract global_step from it.\\n global_step = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])\\n print(\\\"checkpoint found at step %d\\\", global_step)\\n # ensure that the writers ignore saved summaries that occurred after the last checkpoint but before a crash\\n train_writer.add_session_log(tf.SessionLog(status=tf.SessionLog.START), global_step)\\n validation_writer.add_session_log(tf.SessionLog(status=tf.SessionLog.START), global_step)\\n test_writer.add_session_log(tf.SessionLog(status=tf.SessionLog.START), global_step)\\n else:\\n print('No checkpoint file found')\\n return global_step\",\n \"def load_checkpoint(tag, params, model):\\r\\n file_name = os.path.join(\\\"saved_models\\\", params.path, tag + \\\".pt\\\")\\r\\n logger.info(\\\"Load checkpoint from %s\\\" % file_name)\\r\\n if os.path.exists(file_name):\\r\\n checkpoint = torch.load(file_name, map_location='cpu')\\r\\n params.training_id = checkpoint['training_id']\\r\\n logger.info(checkpoint['training_id'])\\r\\n model.global_step = checkpoint['global_step']\\r\\n model.load_state_dict(checkpoint['model'])\\r\\n for i, optimizer in enumerate(model.optimizers):\\r\\n optimizer.load_state_dict(checkpoint['optimizers'][i])\\r\\n else:\\r\\n raise Exception(\\\"Checkpoint not found.\\\")\",\n \"def _resume_checkpoint(self, resume_path):\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n self.monitor_best = checkpoint['monitor_best']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n # 将参数全部放入GPU\\n if self.with_cuda:\\n for state in self.optimizer.state.values():\\n for k, v in state.items():\\n if isinstance(v, torch.Tensor):\\n state[k] = v.cuda(self.device)\\n self.train_logger = checkpoint['logger']\\n self.config = checkpoint['config']\\n self.logger.info(\\\"Checkpoint '{}' (epoch {}) loaded\\\".format(resume_path, self.start_epoch))\",\n \"def load_from_checkpoint(results_dir, load_fn, args):\\n ckpt_dir = os.path.join(results_dir, \\\"tb\\\", \\\"version_0\\\", \\\"checkpoints\\\")\\n files = os.listdir(ckpt_dir)\\n assert len(files) > 0, \\\"Checkpoint directory is empty\\\"\\n ckpt_path = os.path.join(ckpt_dir, files[-1])\\n model = load_fn(checkpoint_path=ckpt_path, args=args)\\n return model\",\n \"def load_ckpt(self):\\n status = self.ckpt_manager.restore_or_initialize()\\n print(f\\\"ckpt_manager.restore_or_initialize(): {status}\\\")\",\n \"def load_checkpoint(path, model, optimizer=None, reset_optimizer=True):\\n print(\\\"Load checkpoint from: {}\\\".format(path))\\n state_dict, optimizer_state = _load(path)\\n\\n model.load_dict(state_dict)\\n if not reset_optimizer and optimizer is not None:\\n if optimizer_state is not None:\\n print(\\\"[loading] Load optimizer state from {}\\\".format(path))\\n optimizer.load(optimizer_state)\\n\\n return model\",\n \"def _resume_from_checkpoint(model: tf.keras.Model,\\n model_dir: str,\\n train_steps: int) -> int:\\n logging.info('Load from checkpoint is enabled.')\\n latest_checkpoint = tf.train.latest_checkpoint(model_dir)\\n logging.info('latest_checkpoint: %s', latest_checkpoint)\\n if not latest_checkpoint:\\n logging.info('No checkpoint detected.')\\n return 0\\n\\n logging.info('Checkpoint file %s found and restoring from '\\n 'checkpoint', latest_checkpoint)\\n model.load_weights(latest_checkpoint)\\n initial_epoch = model.optimizer.iterations // train_steps\\n logging.info('Completed loading from checkpoint.')\\n logging.info('Resuming from epoch %d', initial_epoch)\\n return int(initial_epoch)\",\n \"def _resume_checkpoint(self, resume_path):\\n resume_path = str(resume_path)\\n self.logger.info(\\\"Loading checkpoint: {} ...\\\".format(resume_path))\\n checkpoint = torch.load(resume_path)\\n self.start_epoch = checkpoint['epoch'] + 1\\n\\n # load architecture params from checkpoint.\\n if checkpoint['config']['model'] != self.config['model']:\\n self.logger.warning(\\\"Warning: Architecture configuration given in config file is different from that of \\\"\\n \\\"checkpoint. This may yield an exception while state_dict is being loaded.\\\")\\n self.model.load_state_dict(checkpoint['state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed.\\n if checkpoint['config']['trainer']['optimizer']['type'] != self.config['trainer']['optimizer']['type']:\\n self.logger.warning(\\\"Warning: Optimizer type given in config file is different from that of checkpoint. \\\"\\n \\\"Optimizer parameters not being resumed.\\\")\\n else:\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n self.logger.info(\\\"Checkpoint loaded. Resume from epoch {}\\\".format(self.start_epoch))\",\n \"def load_checkpoint(self, checkpoint_path=None):\\n if checkpoint_path is None:\\n checkpoint_path = self.get_latest_path()\\n\\n if os.path.isfile(checkpoint_path):\\n key = 'cuda' if torch.cuda.is_available() else 'cpu'\\n checkpoint = torch.load(checkpoint_path, map_location=key)\\n self.network.load_state_dict(checkpoint['network'])\\n self.network_target.load_state_dict(checkpoint['network_target'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n print('checkpoint loaded at {}'.format(checkpoint_path))\\n else:\\n raise OSError(\\\"Checkpoint file not found.\\\")\",\n \"def load_checkpoint(self, checkpoint_path, continue_from_epoch=True):\\n print(\\\"Loading checkpoint: {}\\\".format(checkpoint_path))\\n state = torch.load(checkpoint_path)\\n self.model.load_state_dict(state['state_dict'])\\n self.optimizer.load_state_dict(state['optim_dict'])\\n\\n if continue_from_epoch:\\n self.epoch = state['epoch']\",\n \"def restore_best_checkpoint(session, ckpt_dir):\\n try:\\n evals_file = os.path.join(ckpt_dir, EVALUATIONS_FILE)\\n f = open(evals_file)\\n evals = json.load(f)\\n best_ckpt = max(evals, key=lambda e: e['accuracy'])\\n\\n except Exception as e:\\n raise Exception('Error reading evaluations summary file: {}'.format(e))\\n\\n ckpt_file = \\\"{}-{}\\\".format(BEST_MODEL_PREFIX, best_ckpt['iteration'])\\n saver = tf.train.Saver()\\n saver.restore(session, os.path.join(ckpt_dir, ckpt_file))\",\n \"def load_checkpoints(args, model): \\n print('Loading the model checkpoints from iter {}...'.format(args.resume_iter))\\n checkpoint_path = os.path.join(config.checkpoint_path, args.model_type)\\n\\n gen_g_path = os.path.join(checkpoint_path, '{}-Gen_g.ckpt'.format(args.resume_iter))\\n gen_f_path = os.path.join(checkpoint_path, '{}-Gen_f.ckpt'.format(args.resume_iter))\\n model.gen_g.load_state_dict(torch.load(gen_g_path, map_location=lambda storage, loc: storage))\\n model.gen_f.load_state_dict(torch.load(gen_f_path, map_location=lambda storage, loc: storage))\\n\\n if args.train:\\n dis_c_path = os.path.join(checkpoint_path, '{}-Dis_c.ckpt'.format(args.resume_iter))\\n dis_t_path = os.path.join(checkpoint_path, '{}-Dis_t.ckpt'.format(args.resume_iter))\\n model.dis_c.load_state_dict(torch.load(dis_c_path, map_location=lambda storage, loc: storage))\\n model.dis_t.load_state_dict(torch.load(dis_t_path, map_location=lambda storage, loc: storage))\",\n \"def get_checkpoint(model, checkpoint='-1'):\\n if not os.path.isfile(os.path.join(model, \\\"checkpoint\\\")):\\n sys.exit(\\\"[ERROR] Cannot find checkpoint in %s.\\\" % model)\\n ckpt = tf.train.get_checkpoint_state(model)\\n\\n model_checkpoint_path = ckpt.model_checkpoint_path\\n all_model_checkpoint_paths = ckpt.all_model_checkpoint_paths\\n\\n if not ckpt or not model_checkpoint_path:\\n sys.exit(\\\"[ERROR] Cannot read checkpoint %s.\\\" % os.path.join(model, \\\"checkpoint\\\"))\\n\\n steps = [int(c.rsplit('-', 1)[1]) for c in all_model_checkpoint_paths]\\n steps = sorted(steps)\\n if checkpoint == \\\"last\\\":\\n tf.logging.info(\\\"Load the last saved model.\\\")\\n checkpoint = steps[-1]\\n else:\\n checkpoint = int(checkpoint)\\n if checkpoint == -1:\\n tf.logging.info(\\\"Load the best model according to valid_loss\\\")\\n min_epoch = -1\\n min_loss = 1e10\\n with open(os.path.join(model, \\\"valid_loss\\\")) as f:\\n for line in f.readlines():\\n epoch, loss, eer = line.split(\\\" \\\")\\n epoch = int(epoch)\\n loss = float(loss)\\n if loss < min_loss:\\n min_loss = loss\\n min_epoch = epoch\\n # Add 1 to min_epoch since epoch is 0-based\\n config_json = os.path.join(model, \\\"config.json\\\")\\n params = Params(config_json)\\n checkpoint = (min_epoch + 1) * params.num_steps_per_epoch\\n tf.logging.info(\\\"The checkpoint is %d\\\" % checkpoint)\\n assert checkpoint in steps, \\\"The checkpoint %d not in the model directory\\\" % checkpoint\\n\\n model_checkpoint_path = model_checkpoint_path.rsplit(\\\"-\\\", 1)[0] + \\\"-\\\" + str(checkpoint)\\n model_checkpoint_path = os.path.join(model, os.path.basename(model_checkpoint_path))\\n\\n with open(os.path.join(model, \\\"checkpoint\\\"), \\\"w\\\") as f:\\n f.write(\\\"model_checkpoint_path: \\\\\\\"%s\\\\\\\"\\\\n\\\" % model_checkpoint_path)\\n for checkpoint in all_model_checkpoint_paths:\\n checkpoint_new = os.path.join(model, os.path.basename(checkpoint))\\n f.write(\\\"all_model_checkpoint_paths: \\\\\\\"%s\\\\\\\"\\\\n\\\" % checkpoint_new)\\n return model_checkpoint_path\",\n \"def load(cls, path):\\n print(f'load checkpoint from {path}')\\n if torch.cuda.is_available():\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME))\\n model = torch.load(os.path.join(path, cls.MODEL_NAME))\\n else:\\n resume_checkpoint = torch.load(os.path.join(path, cls.TRAINER_STATE_NAME), map_location=lambda storage, loc: storage)\\n model = torch.load(os.path.join(path, cls.MODEL_NAME), map_location=lambda storage, loc: storage)\\n \\n # model.flatten_parameters() # make RNN parameters contiguous\\n optimizer = resume_checkpoint['optimizer']\\n return Checkpoint(\\n model=model, \\n optimizer=optimizer,\\n epoch=resume_checkpoint['epoch'],\\n path=path\\n )\",\n \"def load_from_checkpoint(self, path):\\n print(f'# loading trainer state from {path}')\\n checkpoint = torch.load(path)\\n self.load(checkpoint)\",\n \"def load_checkpoint(checkpoint_file: pl.Path) -> Optional[Dict[str, Any]]:\\n if checkpoint_file.exists():\\n logger.info(f\\\"Loading checkpoint {checkpoint_file}.\\\")\\n checkpoint = torch.load(str(checkpoint_file))\\n logger.info(f\\\"Done loading checkpoint from epoch {checkpoint['epoch']}.\\\")\\n else:\\n logger.warning(f\\\"No {checkpoint_file} checkpoint file found. Starting normal.\\\")\\n return checkpoint\",\n \"def restore(self, checkpoint_path: str):\\r\\n raise NotImplementedError\",\n \"def load_checkpoint(self, checkpoint: str, **kwargs) -> None:\\n with open(checkpoint, \\\"rb\\\") as f:\\n state = SafePickle.load(f)\\n\\n state_id = ray.put(state)\\n ray.get([worker.set_state.remote(state_id, **kwargs) for worker in self.remote_workers])\",\n \"def restore_checkpoint(checkpoint_path: str,\\n train_state: Optional[TrainState] = None,\\n assert_exist: bool = False,\\n step: Optional[int] = None) -> Tuple[TrainState, int]:\\n if assert_exist:\\n glob_path = os.path.join(checkpoint_path, 'checkpoint_*')\\n if not gfile.glob(glob_path):\\n raise ValueError('No checkpoint for the pretrained model is found in: '\\n f'{checkpoint_path}')\\n if train_state is None:\\n raise ValueError('Please use `restore_pretrained_checkpoint` for loading'\\n 'a checkpoint without providing a Scenic TrainState.')\\n train_state = checkpoints.restore_checkpoint(checkpoint_path, train_state,\\n step)\\n return train_state, int(train_state.global_step)\",\n \"def load_checkpoint(self, label):\\n model_dir = os.path.join(\\n config.results_dir, config.experiment_name, 'checkpoints')\\n model_file = os.path.join(model_dir, '{}_net.pth.tar'.format(label))\\n\\n print(\\\"Loading model from {}\\\".format(model_file))\\n model_dict = torch.load(model_file)\\n\\n self.use_cuda = model_dict['use_cuda']\\n if self.use_cuda:\\n self.net.cuda()\\n\\n self.net.load_state_dict(model_dict['net_state_dict'])\",\n \"def restore_checkpoint(self, checkpoint_id, name, path=''):\\n\\n\\t\\tself.log.debug(\\\"restoring Notebook %s from checkpoint %s\\\", name, checkpoint_id)\\n\\t\\tnb_path = self._get_os_path(name, path)\\n\\t\\tcp_path = self.get_checkpoint_path(checkpoint_id, name, path)\\n\\n\\t\\tif not key_exists(self.bucket, cp_path):\\n\\t\\t\\tself.log.debug(\\\"checkpoint file does not exist: %s\\\", cp_path)\\n\\t\\t\\traise web.HTTPError(404,\\n\\t\\t\\t\\tu'Notebook checkpoint does not exist: %s-%s' % (name, checkpoint_id)\\n\\t\\t\\t)\\n\\t\\t# ensure notebook is readable (never restore from an unreadable notebook)\\n\\t\\tkey = self.bucket.get_key(cp_path)\\n\\t\\tnb = current.reads(key.get_contents_as_string(), u'json')\\n\\t\\tself._copy(cp_path, nb_path)\\n\\t\\tself.log.debug(\\\"copying %s -> %s\\\", cp_path, nb_path)\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint, map_location=torch.device('cpu'))\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_checkpoint(checkpoint, model, optimizer=None):\\n if not os.path.exists(checkpoint):\\n raise (\\\"File doesn't exist {}\\\".format(checkpoint))\\n checkpoint = torch.load(checkpoint)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n if optimizer:\\n optimizer.load_state_dict(checkpoint['optim_dict'])\\n\\n return checkpoint\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None,\\n model_key='model_state_dict', optimizer_key='optimizer_state_dict'):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(f\\\"Checkpoint '{checkpoint_path}' does not exist\\\")\\n\\n state = torch.load(checkpoint_path, map_location='cpu')\\n model.load_state_dict(state[model_key])\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(state[optimizer_key])\\n\\n return state\",\n \"def _resume(self):\\n\\n if self.resume_file is None:\\n return None\\n assert os.path.isfile(self.resume_file)\\n logger.info(f'=> loading checkpoint {self.resume_file}')\\n checkpoint = torch.load(self.resume_file)\\n self.cur_epoch = checkpoint['epoch']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n self.optimizer.load_state_dict(checkpoint['optimizer'])\\n self.scheduler.load_state_dict(checkpoint['scheduler'])\\n self.best_rho = checkpoint['best_rho']\\n self.best_nmse = checkpoint['best_nmse']\\n self.cur_epoch += 1 # start from the next epoch\\n\\n logger.info(f'=> successfully loaded checkpoint {self.resume_file} '\\n f'from epoch {checkpoint[\\\"epoch\\\"]}.\\\\n')\",\n \"def load_model_from_checkpoint(self, path: str):\\n ckpt = torch.load(path, map_location='cpu')\\n self.net_q.encoder.load_state_dict(ckpt['encoder'])\\n self.net_q.head.load_state_dict(ckpt['head'])\\n self.net_ps.load_state_dict(ckpt['net_ps'])\\n self.net_k.load_state_dict(ckpt['net_k'])\\n self.queue.load_state_dict(ckpt['queue'])\\n self.optimizer.load_state_dict(ckpt['optimizer'])\\n if 'scheduler' in ckpt:\\n self.scheduler.load_stae_dict(ckpt['scheduler'])\\n self.move_optimizer_states(self.optimizer, self.local_rank)\",\n \"def save_checkpoint(checkpoint_dir, epoch, iteration, save_dict):\\n os.makedirs(checkpoint_dir, exist_ok=True)\\n path = opj(checkpoint_dir, str(epoch) + '.' + str(iteration) + '.ckpt')\\n assert epoch == save_dict['epoch'], \\\"`epoch` != save_dict's `start_epoch`\\\"\\n assert iteration == save_dict['iteration'], \\\"`iteration` != save_dict's `start_iteration`\\\"\\n if os.path.isfile(path):\\n print(\\\"Overwrite checkpoint in epoch %d, iteration %d :exclamation:\\\" % (epoch, iteration))\\n try:\\n torch.save(save_dict, path)\\n except Exception:\\n raise Exception(\\\"Fail to save checkpoint\\\")\\n \\n print(\\\"Checkpoint %s saved :heavy_check_mark:\\\" % (str(epoch) + '.' + str(iteration) + '.ckpt'))\",\n \"def warm_start_training(self, sess): \\n ckpt = tf.train.latest_checkpoint(self.train_dir)\\n if ckpt:\\n # the global_step will restore sa well\\n saver = tf.train.Saver(tf.global_variables(), max_to_keep=100)\\n saver.restore(sess, ckpt)\\n print('restore from the checkpoint{0}'.format(ckpt))\\n return\\n \\n if self.checkpoint_path is None:\\n return None\\n \\n exclusions = []\\n if self.checkpoint_exclude_scopes:\\n exclusions = [scope.strip()\\n for scope in self.checkpoint_exclude_scopes.split(',')]\\n # TODO(sguada) variables.filter_variables()\\n variables_to_restore = []\\n all_variables = slim.get_model_variables()\\n if tf.gfile.IsDirectory(self.checkpoint_path):\\n global_step = slim.get_or_create_global_step()\\n all_variables.append(global_step)\\n checkpoint_path = tf.train.latest_checkpoint(self.checkpoint_path)\\n else:\\n checkpoint_path = self.checkpoint_path\\n \\n for var in all_variables:\\n excluded = False\\n \\n for exclusion in exclusions:\\n if var.op.name.startswith(exclusion):\\n excluded = True\\n break\\n if not excluded:\\n variables_to_restore.append(var)\\n \\n# tf.logging.info('Fine-tuning from %s' % checkpoint_path)\\n \\n slim.assign_from_checkpoint_fn(\\n checkpoint_path,\\n variables_to_restore)(sess)\\n return\",\n \"def restore_ckpt(sess, ckpt_path, ema_decay=0.9998, export_ckpt=None):\\n sess.run(tf.global_variables_initializer())\\n if tf.io.gfile.isdir(ckpt_path):\\n ckpt_path = tf.train.latest_checkpoint(ckpt_path)\\n if ema_decay > 0:\\n ema = tf.train.ExponentialMovingAverage(decay=0.0)\\n ema_vars = utils.get_ema_vars()\\n var_dict = ema.variables_to_restore(ema_vars)\\n ema_assign_op = ema.apply(ema_vars)\\n else:\\n var_dict = utils.get_ema_vars()\\n ema_assign_op = None\\n\\n tf.train.get_or_create_global_step()\\n sess.run(tf.global_variables_initializer())\\n saver = tf.train.Saver(var_dict, max_to_keep=1)\\n if ckpt_path == '_':\\n logging.info('Running test: do not load any ckpt.')\\n return\\n\\n # Restore all variables from ckpt.\\n saver.restore(sess, ckpt_path)\\n\\n if export_ckpt:\\n print('export model to {}'.format(export_ckpt))\\n if ema_assign_op is not None:\\n sess.run(ema_assign_op)\\n saver = tf.train.Saver(max_to_keep=1, save_relative_paths=True)\\n saver.save(sess, export_ckpt)\",\n \"def get_checkpoint_data(self) -> Dict[str, Any]:\\n # get ckpt file path from config.trainer.params.resume_from_checkpoint\\n path = self.config.trainer.params.get(\\\"resume_from_checkpoint\\\", None)\\n if path is not None:\\n is_zoo = self.is_zoo_path(path)\\n ckpt_filepath = path\\n if is_zoo:\\n folder = download_pretrained_model(path)\\n ckpt_filepath = get_ckpt_path_from_folder(folder)\\n ckpt = get_ckpt_from_path(ckpt_filepath)\\n config = get_config_from_folder_or_ckpt(folder, ckpt)\\n else:\\n ckpt = get_ckpt_from_path(ckpt_filepath)\\n config = None\\n\\n return {\\n \\\"ckpt\\\": ckpt,\\n \\\"checkpoint_path\\\": ckpt_filepath,\\n \\\"is_zoo\\\": is_zoo,\\n \\\"config\\\": config,\\n }\\n\\n is_zoo = False\\n config = None\\n ckpt = None\\n # get ckpt file path from config.checkpoint\\n ckpt_config = self.config.checkpoint\\n suffix = \\\"best.ckpt\\\" if ckpt_config.resume_best else \\\"current.ckpt\\\"\\n path = os.path.join(get_mmf_env(key=\\\"save_dir\\\"), suffix)\\n ckpt_filepath = None\\n resume_from_specified_path = (\\n ckpt_config.resume_file is not None or ckpt_config.resume_zoo is not None\\n ) and (not ckpt_config.resume or not PathManager.exists(path))\\n if resume_from_specified_path:\\n if ckpt_config.resume_file and PathManager.exists(ckpt_config.resume_file):\\n ckpt_filepath = ckpt_config.resume_file\\n elif ckpt_config.resume_zoo is not None:\\n is_zoo = True\\n folder = download_pretrained_model(ckpt_config.resume_zoo)\\n ckpt_filepath = get_ckpt_path_from_folder(folder)\\n ckpt = get_ckpt_from_path(ckpt_filepath)\\n config = get_config_from_folder_or_ckpt(folder, ckpt)\\n else:\\n raise RuntimeError(f\\\"{ckpt_config.resume_file} doesn't exist\\\")\\n\\n if ckpt_config.resume and PathManager.exists(path):\\n ckpt_filepath = path\\n\\n if ckpt_filepath is not None:\\n ckpt = get_ckpt_from_path(ckpt_filepath)\\n\\n return {\\n \\\"ckpt\\\": ckpt,\\n \\\"checkpoint_path\\\": ckpt_filepath,\\n \\\"is_zoo\\\": is_zoo,\\n \\\"config\\\": config,\\n }\",\n \"def set_loading_step(ckpt_dir, step=None, pol_name='policy'):\\n # read the file and find all checkpoints\\n with open(os.path.join(ckpt_dir, pol_name+\\\"/checkpoint\\\"), \\\"r\\\") as f:\\n log = f.readlines()\\n all_ckpts = []\\n for line in log:\\n if \\\"all_model_checkpoint_paths:\\\" in line:\\n num = int(line[34:-2])\\n all_ckpts.append(num)\\n all_ckpts.sort()\\n\\n # find the nearest one to the input step\\n load_step = None\\n if not step is None:\\n for s in all_ckpts:\\n if s > step:\\n load_step = s\\n break\\n if load_step is None:\\n load_step = all_ckpts[-1]\\n else:\\n load_step = all_ckpts[-1]\\n\\n # modify the first line of that file\\n first_line = log[0]\\n new_first_line = first_line[:29] + str(load_step) + first_line[-2:]\\n log[0] = new_first_line\\n with open(os.path.join(ckpt_dir, pol_name+\\\"/checkpoint\\\"), \\\"w\\\") as f:\\n f.write(\\\"\\\".join(log))\\n with open(os.path.join(ckpt_dir, pol_name+\\\"/checkpoint\\\"), \\\"r\\\") as f:\\n log = f.readlines()\\n print(\\\"\\\\nCheckpoint to load:\\\\n\\\", log[0], \\\"\\\\n\\\")\\n\\n return load_step\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(f\\\"Checkpoint '{checkpoint_path}' does not exist\\\")\\n\\n state = torch.load(checkpoint_path)\\n try:\\n model.load_state_dict(state['model_state_dict'])\\n except BaseException as e:\\n print('Failed to do something: ' + str(e))\\n\\n if optimizer is not None:\\n try:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n except Exception as e:\\n print(e)\\n\\n return state\",\n \"def load_ckpt(self):\\n for name in [\\\"G\\\"]:\\n if isinstance(name, str):\\n # load_filename = '%s_net_%s.pth' % (epoch, name)\\n # load_path = os.path.join(self.save_dir, load_filename)\\n # ckpt_path =\\n net = getattr(self.model, \\\"net\\\" + name)\\n if isinstance(net, torch.nn.DataParallel):\\n net = net.module\\n print(\\\"loading the model from %s\\\" % self.option.ckpt_path)\\n # if you are using PyTorch newer than 0.4 (e.g., built from\\n # GitHub source), you can remove str() on self.device\\n state_dict = torch.load(\\n self.option.ckpt_path, map_location=str(self.model.device)\\n )\\n if hasattr(state_dict, \\\"_metadata\\\"):\\n del state_dict._metadata\\n\\n # patch InstanceNorm checkpoints prior to 0.4\\n # for key in list(state_dict.keys()): # need to copy keys here because we mutate in loop\\n # self.__patch_instance_norm_state_dict(state_dict, net, key.split('.'))\\n net.load_state_dict(state_dict)\",\n \"def _restore(self):\\n\\n output_path = self.output_path + '/checkpoints/'\\n checkpoint = tf.train.latest_checkpoint(output_path)\\n if checkpoint:\\n self.saver.restore(self.session, save_path=checkpoint)\\n restored_step = int(checkpoint.split('-')[-1]) # Robust enough?\\n return restored_step\\n logging.info('Starting training from scratch.')\\n return 0\",\n \"def load_aux(ckpt_path):\\n\\n ckpt_name = os.path.basename(ckpt_path)\\n saver.restore(self.sess, ckpt_path)\\n counter = int(next(re.finditer(\\\"(\\\\d+)(?!.*\\\\d)\\\", ckpt_name)).group(0))\\n self.counter = counter\\n print(\\\" [*] Loaded {}\\\".format(ckpt_name))\\n return True, counter\",\n \"def save_ckpt(self, name=None):\\r\\n if name is None:\\r\\n save_path = os.path.join(self.model_dir, \\\"ckpt_epoch{}.pth\\\".format(self.clock.epoch))\\r\\n print(\\\"Checkpoint saved at {}\\\".format(save_path))\\r\\n else:\\r\\n save_path = os.path.join(self.model_dir, \\\"{}.pth\\\".format(name))\\r\\n if isinstance(self.net, nn.DataParallel):\\r\\n torch.save({\\r\\n 'clock': self.clock.make_checkpoint(),\\r\\n 'model_state_dict': self.net.module.cpu().state_dict(),\\r\\n 'optimizer_state_dict': self.optimizer.state_dict(),\\r\\n 'scheduler_state_dict': self.scheduler.state_dict(),\\r\\n }, save_path)\\r\\n else:\\r\\n torch.save({\\r\\n 'clock': self.clock.make_checkpoint(),\\r\\n 'model_state_dict': self.net.cpu().state_dict(),\\r\\n 'optimizer_state_dict': self.optimizer.state_dict(),\\r\\n 'scheduler_state_dict': self.scheduler.state_dict(),\\r\\n }, save_path)\\r\\n self.net.cuda()\",\n \"def load_checkpoint(fpath):\\n if fpath is None:\\n raise ValueError('File path is None')\\n if not osp.exists(fpath):\\n raise FileNotFoundError('File is not found at \\\"{}\\\"'.format(fpath))\\n map_location = None if torch.cuda.is_available() else 'cpu'\\n try:\\n checkpoint = torch.load(fpath, map_location=map_location)\\n except UnicodeDecodeError:\\n pickle.load = partial(pickle.load, encoding=\\\"latin1\\\")\\n pickle.Unpickler = partial(pickle.Unpickler, encoding=\\\"latin1\\\")\\n checkpoint = torch.load(\\n fpath, pickle_module=pickle, map_location=map_location\\n )\\n except Exception:\\n print('Unable to load checkpoint from \\\"{}\\\"'.format(fpath))\\n raise\\n return checkpoint\",\n \"def load_last_chkpnt(self, directory):\\n last_chkpnt = sorted(list(directory.glob('chkpnt_epoch*.pth')))[-1]\\n self.load_checkpoint(last_chkpnt)\",\n \"def reload_checkpoint(self):\\n checkpoint_path = os.path.join(self.params.dump_path, 'checkpoint.pth')\\n if not os.path.isfile(checkpoint_path):\\n if self.params.reload_checkpoint == '':\\n return\\n else:\\n checkpoint_path = self.params.reload_checkpoint\\n assert os.path.isfile(checkpoint_path)\\n logger.warning(\\\"Reloading checkpoint from %s ...\\\" % checkpoint_path)\\n data = torch.load(checkpoint_path, map_location='cpu')\\n\\n # reload model parameters\\n for name in self.MODEL_NAMES:\\n getattr(self, name).load_state_dict(data[name])\\n\\n # reload optimizers\\n for name in self.optimizers.keys():\\n if False: # AMP checkpoint reloading is buggy, we cannot do that - TODO: fix - https://github.com/NVIDIA/apex/issues/250\\n logger.warning(\\\"Reloading checkpoint optimizer %s ...\\\" % name)\\n else: # instead, we only reload current iterations / learning rates\\n logger.warning(\\\"Not reloading checkpoint optimizer %s.\\\" % name)\\n for group_id, param_group in enumerate(self.optimizers[name].param_groups):\\n if 'num_updates' not in param_group:\\n logger.warning(\\\"No 'num_updates' for optimizer %s.\\\" % name)\\n continue\\n logger.warning(\\\"Reloading 'num_updates' and 'lr' for optimizer %s.\\\" % name)\\n param_group['num_updates'] = data['%s_optimizer' % name]['param_groups'][group_id]['num_updates']\\n param_group['lr'] = self.optimizers[name].get_lr_for_step(param_group['num_updates'])\\n\\n # reload main metrics\\n self.epoch = data['epoch'] + 1\\n self.n_total_iter = data['n_total_iter']\\n self.best_metrics = data['best_metrics']\\n self.best_stopping_criterion = data['best_stopping_criterion']\\n logger.warning(\\\"Checkpoint reloaded. Resuming at epoch %i / iteration %i ...\\\" % (self.epoch, self.n_total_iter))\",\n \"def load_checkpoint(ckpt_path, net, device=None, ret_performance_score=False):\\n # See here for details on how to load the checkpoint:\\n # https://blog.floydhub.com/checkpointing-tutorial-for-tensorflow-keras-and-pytorch/\\n if device is not None and device.type == 'cuda':\\n ckpt = torch.load(ckpt_path)\\n else:\\n # Load GPU model on CPU\\n ckpt = torch.load(ckpt_path, map_location=lambda storage, loc: storage)\\n\\n net.load_state_dict(ckpt['state_dict'])\\n\\n if ret_performance_score:\\n score = ckpt[_INTERNAL_KEY]['score']\\n\\n # That key was added for maintenance reasons in the method save_checkpoint.\\n if _INTERNAL_KEY in ckpt:\\n del ckpt[_INTERNAL_KEY]\\n\\n if ret_performance_score:\\n return ckpt, score\\n\\n return ckpt\",\n \"def load_checkpoint(self, checkpoint: Dict[str, OrderedDict]):\\n self.model.load_state_dict(checkpoint[\\\"model_state_dict\\\"])\\n self.optimizer.load_state_dict(checkpoint[\\\"optimizer_state_dict\\\"])\\n return self\",\n \"def load(self, checkpoint_dir=None):\\n\\n if checkpoint_dir is None:\\n checkpoint_dir = FLAGS.checkpoint_dir\\n\\n checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir)\\n\\n return self.load_from_path(checkpoint_dir)\",\n \"def load_checkpoint(self, model, optimizers):\\n self.epoch = get_last_epoch(self.log_path)\\n\\n model_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'model.ckpt'))\\n model.load_state_dict(model_state_dict)\\n\\n optimizer_state_dict = torch.load(os.path.join(self.log_path, 'checkpoints', str(self.epoch), 'opt.ckpt'))\\n for opt_ind in range(len(optimizers)):\\n optimizers[opt_ind].opt.load_state_dict(optimizer_state_dict[opt_ind])\\n optimizers[opt_ind].opt.state = set_gpu_recursive(optimizers[opt_ind].opt.state, torch.cuda.current_device())\\n\\n schedulers = load_sched(optimizers, self.epoch)\\n\\n return model, optimizers, schedulers\",\n \"def load_checkpoint(self, checkpoint_path: Union[str, Path]) -> Dict[str, Any]:\\n # TODO: move to CheckpointIO\\n torch.cuda.empty_cache()\\n checkpoint_path = inject_model_parallel_rank(checkpoint_path)\\n return self.checkpoint_io.load_checkpoint(checkpoint_path)\",\n \"def get_ckpt(modeldir, logdir, wait_second=10):\\n while True:\\n try:\\n ckpt = _copy_ckpt_to_modeldir(modeldir, logdir)\\n return ckpt\\n except FileNotFoundError as exp:\\n if wait_second:\\n tf.logging.info(str(exp) + '\\\\nWait for 1 minutes.')\\n time.sleep(wait_second)\\n else:\\n return None\",\n \"def load_checkpoint(checkpoint_path, model, optimizer=None):\\n if not os.path.exists(checkpoint_path):\\n raise IOError(\\\"Checkpoint '{}' does not exist\\\".format(checkpoint_path))\\n\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else 'cpu')\\n state = torch.load(checkpoint_path, map_location=\\\"cuda:0\\\")\\n model.load_state_dict(state['model_state_dict'])\\n\\n if optimizer is not None:\\n optimizer.load_state_dict(state['optimizer_state_dict'])\\n\\n return state\",\n \"def _resume_checkpoint(self, resume_path, model, optimizer):\\n if not resume_path:\\n return model, optimizer\\n\\n self.logger.info(f'Loading checkpoint: {resume_path}')\\n checkpoint = torch.load(resume_path)\\n model.load_state_dict(checkpoint['state_dict'])\\n\\n # load optimizer state from checkpoint only when optimizer type is not changed.\\n if checkpoint['config']['optimizer']['type'] != self.config['optimizer']['type']:\\n self.logger.warning(\\\"Warning: Optimizer type given in config file is different from \\\"\\n \\\"that of checkpoint. Optimizer parameters not being resumed.\\\")\\n else:\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n\\n self.logger.info(f'Checkpoint \\\"{resume_path}\\\" loaded')\\n return model, optimizer\",\n \"def load_model(self, ckpt_fn):\\n checkpoint = torch.load(ckpt_fn)\\n self.net_.load_state_dict(checkpoint[\\\"model\\\"])\\n self.optimizer_.load_state_dict(checkpoint[\\\"optimizer\\\"])\\n self.epoch_ = checkpoint[\\\"epoch\\\"]\\n self.global_step_ = checkpoint[\\\"global_step\\\"]\\n self.model_samples_ = deque(checkpoint[\\\"model_samples\\\"])\\n self.sampler.load_state_dict(checkpoint[\\\"sampler_state\\\"])\\n self.ais_loss.load_state_dict(checkpoint[\\\"ais_state\\\"])\\n self.replay_prob = checkpoint[\\\"replay_prob\\\"]\\n self.max_replay = checkpoint[\\\"max_replay\\\"]\",\n \"def load(self, sess, step=None):\\n if step==None:\\n ckpt_path = tf.train.latest_checkpoint(self.model.ckpt_dir)\\n else:\\n ckpt_path = os.path.join(self.model.ckpt_dir, 'model-'+str(step))\\n self.saver.restore(sess, ckpt_path)\\n step = tf.train.global_step(sess, self.gstep)\\n print('Load model at step {} from check point {}.'.format(step, ckpt_path))\",\n \"def load_checkpoint(self, folder='checkpoint', filename='checkpoint.pth.tar'):\\n data = dict()\\n data[\\\"inst\\\"] = \\\"load\\\"\\n data[\\\"folder\\\"] = folder\\n data[\\\"filename\\\"] = filename\\n\\n # Send load requests to every nnet\\n metadata = []\\n for i in range(len(self.nsyncs)):\\n metadata.append(self.put(data, q_idx=i))\\n\\n # Wait for all nnets to finish\\n for q_idx, data_id in metadata:\\n self.get(q_idx, data_id) # Blocks here\\n\\n # Done\",\n \"def resume_model(self, resume_path):\\n if resume_path:\\n resume_path = f'{self.model_dir}/{resume_path}.pth.tar'\\n if os.path.isfile(resume_path):\\n print(f\\\"=> loading checkpoint '{resume_path}'\\\")\\n checkpoint = torch.load(resume_path, map_location=self.device)\\n self.best_acc = checkpoint['best_acc']\\n self.model.load_state_dict(checkpoint['state_dict'])\\n print(f\\\"=> loaded checkpoint '{resume_path}' (Round {checkpoint['rnd']})\\\")\\n del checkpoint\\n else:\\n print(f\\\"=> no checkpoint found at '{resume_path}'\\\")\",\n \"def restore_session(saver, sess, model_dir):\\n checkpoint = tf.train.get_checkpoint_state(model_dir)\\n if checkpoint and checkpoint.model_checkpoint_path:\\n saver.restore(sess, checkpoint.model_checkpoint_path)\\n print(\\\"checkpoint loaded:\\\", checkpoint.model_checkpoint_path)\\n tokens = checkpoint.model_checkpoint_path.split(\\\"-\\\")\\n # set global step\\n global_t = int(tokens[2])\\n n_episode = int(tokens[1])\\n print(\\\">>> global step set: \\\", global_t)\\n else:\\n print(\\\"Could not find old checkpoint\\\")\\n global_t = 0\\n n_episode = 0\\n return global_t, n_episode\",\n \"def restore(self, sess, path=None, var_list=None):\\n\\n saver = tf.train.Saver(var_list)\\n if path is None:\\n path = tf.train.latest_checkpoint(os.path.dirname(self.config.CHECKPOINTS_PATH))\\n saver.restore(sess, path)\\n print(\\\"model restored from %s\\\" % path)\",\n \"def load_checkpoint(self, checkpoint_filepath=None, verbose=True):\\n if checkpoint_filepath:\\n print('loading', checkpoint_filepath, flush=True)\\n optimistic_restore(self._session, checkpoint_filepath, verbose=verbose)\\n return True\\n else:\\n checkpoints = retrieve_all_checkpoints(self._checkpoints_path) + retrieve_all_checkpoints(self._recovery_checkpoints_path)\\n\\n if checkpoints:\\n last_checkpoint = sorted(checkpoints)[-1][1]\\n print('loading', last_checkpoint, flush=True)\\n optimistic_restore(self._session, last_checkpoint, verbose=verbose)\\n return True\\n else:\\n print('nothing to restore. no checkpoint found.', flush=True)\\n return False\",\n \"def initialize_variables(sess, saver, logdir, checkpoint=None, resume=None):\\n sess.run(tf.group(\\n tf.local_variables_initializer(),\\n tf.global_variables_initializer()))\\n if resume and not (logdir or checkpoint):\\n raise ValueError('Need to specify logdir to resume a checkpoint.')\\n if logdir:\\n state = tf.train.get_checkpoint_state(logdir)\\n if checkpoint:\\n checkpoint = os.path.join(logdir, checkpoint)\\n print('checkpoint {}'.format(checkpoint))\\n if not checkpoint and state and state.model_checkpoint_path:\\n checkpoint = state.model_checkpoint_path\\n if checkpoint and resume is False:\\n message = 'Found unexpected checkpoint when starting a new run.'\\n raise RuntimeError(message)\\n print('checkpoint {}'.format(checkpoint))\\n if checkpoint:\\n saver.restore(sess, checkpoint)\",\n \"def load_checkpoint(model, save_path):\\n model.load_state_dict(torch.load(save_path))\",\n \"def checkpoint(self):\\n self.logger.info('Checkpointing Sampler')\\n with open(self.resume_file, \\\"wb\\\") as f:\\n pickle.dump(self, f)\",\n \"def load_checkpoint(self, checkpoint_path: str, *args, **kwargs) -> Dict:\\n return torch.load(checkpoint_path, *args, **kwargs)\",\n \"def load_checkpoint(self, checkpoint_path: str, *args, **kwargs) -> Dict:\\n return torch.load(checkpoint_path, *args, **kwargs)\",\n \"def load_checkpoint(self, file):\\n \\\"\\\"\\\"Load \\\"\\\"\\\"\\n chkpnt = torch.load(file)\\n self.load_state_dict(chkpnt['model_state_dict'])\",\n \"def resume(self, checkpoint):\\n model_dict = paddle.load(checkpoint)\\n self.model.set_state_dict(model_dict)\",\n \"def load_checkpoint(model, model_name='model', validation_id=None):\\n path = output_path(_checkpoint_path.format(model_name), validation_id=validation_id, have_validation=True)\\n _load_model(model.module if type(model) is torch.nn.DataParallel else model, model_name, path=path, reload=True)\",\n \"def _load_checkpoint(filename, map_location=None):\\n if filename.startswith('modelzoo://'):\\n warnings.warn('The URL scheme of \\\"modelzoo://\\\" is deprecated, please '\\n 'use \\\"torchvision://\\\" instead')\\n model_urls = get_torchvision_models()\\n model_name = filename[11:]\\n checkpoint = load_url_dist(model_urls[model_name])\\n elif filename.startswith('torchvision://'):\\n model_urls = get_torchvision_models()\\n model_name = filename[14:]\\n checkpoint = load_url_dist(model_urls[model_name])\\n elif filename.startswith('open-mmlab://'):\\n model_urls = get_external_models()\\n model_name = filename[13:]\\n deprecated_urls = get_deprecated_model_names()\\n if model_name in deprecated_urls:\\n warnings.warn(f'open-mmlab://{model_name} is deprecated in favor '\\n f'of open-mmlab://{deprecated_urls[model_name]}')\\n model_name = deprecated_urls[model_name]\\n model_url = model_urls[model_name]\\n # check if is url\\n if model_url.startswith(('http://', 'https://')):\\n checkpoint = load_url_dist(model_url)\\n else:\\n filename = osp.join(_get_mmcv_home(), model_url)\\n if not osp.isfile(filename):\\n raise IOError(f'{filename} is not a checkpoint file')\\n checkpoint = torch.load(filename, map_location=map_location)\\n elif filename.startswith('mmcls://'):\\n model_urls = get_mmcls_models()\\n model_name = filename[8:]\\n checkpoint = load_url_dist(model_urls[model_name])\\n checkpoint = _process_mmcls_checkpoint(checkpoint)\\n elif filename.startswith(('http://', 'https://')):\\n checkpoint = load_url_dist(filename)\\n elif filename.startswith('pavi://'):\\n model_path = filename[7:]\\n checkpoint = load_pavimodel_dist(model_path, map_location=map_location)\\n elif filename.startswith('s3://'):\\n checkpoint = load_fileclient_dist(\\n filename, backend='ceph', map_location=map_location)\\n else:\\n if not osp.isfile(filename):\\n raise IOError(f'{filename} is not a checkpoint file')\\n checkpoint = torch.load(filename, map_location=map_location)\\n return checkpoint\",\n \"def load_variables_from_checkpoint(sess, start_checkpoint):\\n saver = tf.train.Saver(tf.global_variables())\\n saver.restore(sess, start_checkpoint)\",\n \"def load_variables_from_checkpoint(sess, start_checkpoint):\\n saver = tf.train.Saver(tf.global_variables())\\n saver.restore(sess, start_checkpoint)\",\n \"def load_model(self, checkpoint):\\n print(f'Load parameters from {checkpoint}')\\n epoch = re.match(r\\\"[0-9]*\\\", os.path.basename(checkpoint)).group(0)\\n self.epoch_i = int(epoch)\\n self.model.load_state_dict(torch.load(checkpoint))\",\n \"def load_checkpoint(checkpoint_path):\\n flat_checkpoint_dict = flatten_checkpoint(\\n parse_checkpoint(checkpoint_path), keep_empty_nodes=True)\\n return flat_checkpoint_dict\",\n \"def _load_checkpoint(cls, model: DeviceAwareModule, checkpoint_path: Path,\\n key_in_state_dict: str, use_gpu: bool) -> int:\\n logging.info(f\\\"Loading checkpoint {checkpoint_path}\\\")\\n checkpoint = ModelAndInfo.read_checkpoint(checkpoint_path, use_gpu)\\n\\n try:\\n state_dict = checkpoint[key_in_state_dict]\\n except KeyError:\\n logging.error(f\\\"Key {key_in_state_dict} not found in checkpoint\\\")\\n return False\\n\\n if isinstance(model, torch.nn.DataParallel):\\n result = model.module.load_state_dict(state_dict, strict=False)\\n else:\\n result = model.load_state_dict(state_dict, strict=False)\\n\\n if result.missing_keys:\\n logging.warning(f\\\"Missing keys in model checkpoint: {result.missing_keys}\\\")\\n if result.unexpected_keys:\\n logging.warning(f\\\"Unexpected keys in model checkpoint: {result.unexpected_keys}\\\")\\n\\n return checkpoint[ModelAndInfo.EPOCH_KEY]\",\n \"def checkpoint():\",\n \"def test_model_checkpoint_path(tmpdir, logger_version, expected):\\n tutils.reset_seed()\\n model = EvalModelTemplate()\\n logger = TensorBoardLogger(str(tmpdir), version=logger_version)\\n\\n trainer = Trainer(\\n default_root_dir=tmpdir,\\n overfit_pct=0.2,\\n max_epochs=5,\\n logger=logger\\n )\\n trainer.fit(model)\\n\\n ckpt_version = Path(trainer.ckpt_path).parent.name\\n assert ckpt_version == expected\",\n \"def saveCheckpoint(acc, epoch, model, train_hist):\\r\\n print('Saving..')\\r\\n state = {\\r\\n 'model': model,\\r\\n 'acc': acc,\\r\\n 'epoch': epoch,\\r\\n 'rng_state': torch.get_rng_state(),\\r\\n 'train_hist': train_hist\\r\\n }\\r\\n if not os.path.isdir('checkpoint'): # save to checkpoint directory\\r\\n os.mkdir('checkpoint')\\r\\n torch.save(state, './checkpoint/ckpt' + '_' + str(epoch+1))\",\n \"def restore(self, checkpoint):\\n raise NotImplementedError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8223236","0.78587455","0.77297467","0.7691358","0.7526772","0.7455489","0.7162959","0.7072553","0.7010319","0.69536954","0.6937316","0.6916923","0.68400085","0.6833414","0.6830013","0.68147194","0.6802229","0.67763555","0.67456764","0.6729885","0.66925067","0.66564643","0.6636975","0.66367203","0.66200143","0.661013","0.65760964","0.65498","0.65076125","0.64757866","0.6474143","0.6468809","0.64548045","0.6454234","0.644714","0.6432038","0.6428217","0.64205766","0.6394883","0.6388067","0.63802886","0.6362179","0.6359943","0.6358068","0.6322572","0.630467","0.624008","0.6233877","0.6228929","0.6223436","0.6218951","0.62179804","0.6212082","0.6208574","0.62066907","0.6183402","0.61772376","0.6173076","0.61726886","0.6166351","0.6121336","0.61127573","0.6109869","0.60878867","0.6079046","0.6076822","0.6049823","0.604375","0.6041275","0.6025805","0.601669","0.60129","0.6005992","0.6005265","0.59977525","0.5985608","0.59835064","0.59826744","0.5978859","0.5973023","0.5960845","0.59599775","0.59557843","0.5948541","0.59366095","0.5927506","0.5927506","0.59237665","0.5922499","0.5917352","0.5916722","0.59033704","0.59033704","0.5895794","0.5885284","0.5882722","0.5875183","0.5868683","0.5853069","0.5845618"],"string":"[\n \"0.8223236\",\n \"0.78587455\",\n \"0.77297467\",\n \"0.7691358\",\n \"0.7526772\",\n \"0.7455489\",\n \"0.7162959\",\n \"0.7072553\",\n \"0.7010319\",\n \"0.69536954\",\n \"0.6937316\",\n \"0.6916923\",\n \"0.68400085\",\n \"0.6833414\",\n \"0.6830013\",\n \"0.68147194\",\n \"0.6802229\",\n \"0.67763555\",\n \"0.67456764\",\n \"0.6729885\",\n \"0.66925067\",\n \"0.66564643\",\n \"0.6636975\",\n \"0.66367203\",\n \"0.66200143\",\n \"0.661013\",\n \"0.65760964\",\n \"0.65498\",\n \"0.65076125\",\n \"0.64757866\",\n \"0.6474143\",\n \"0.6468809\",\n \"0.64548045\",\n \"0.6454234\",\n \"0.644714\",\n \"0.6432038\",\n \"0.6428217\",\n \"0.64205766\",\n \"0.6394883\",\n \"0.6388067\",\n \"0.63802886\",\n \"0.6362179\",\n \"0.6359943\",\n \"0.6358068\",\n \"0.6322572\",\n \"0.630467\",\n \"0.624008\",\n \"0.6233877\",\n \"0.6228929\",\n \"0.6223436\",\n \"0.6218951\",\n \"0.62179804\",\n \"0.6212082\",\n \"0.6208574\",\n \"0.62066907\",\n \"0.6183402\",\n \"0.61772376\",\n \"0.6173076\",\n \"0.61726886\",\n \"0.6166351\",\n \"0.6121336\",\n \"0.61127573\",\n \"0.6109869\",\n \"0.60878867\",\n \"0.6079046\",\n \"0.6076822\",\n \"0.6049823\",\n \"0.604375\",\n \"0.6041275\",\n \"0.6025805\",\n \"0.601669\",\n \"0.60129\",\n \"0.6005992\",\n \"0.6005265\",\n \"0.59977525\",\n \"0.5985608\",\n \"0.59835064\",\n \"0.59826744\",\n \"0.5978859\",\n \"0.5973023\",\n \"0.5960845\",\n \"0.59599775\",\n \"0.59557843\",\n \"0.5948541\",\n \"0.59366095\",\n \"0.5927506\",\n \"0.5927506\",\n \"0.59237665\",\n \"0.5922499\",\n \"0.5917352\",\n \"0.5916722\",\n \"0.59033704\",\n \"0.59033704\",\n \"0.5895794\",\n \"0.5885284\",\n \"0.5882722\",\n \"0.5875183\",\n \"0.5868683\",\n \"0.5853069\",\n \"0.5845618\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8222074"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84891,"cells":{"query":{"kind":"string","value":"Compute the log of the sum of exponentials of input elements."},"document":{"kind":"string","value":"def logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False):\n if b is not None:\n a, b = np.broadcast_arrays(a, b)\n if np.any(b == 0):\n a = a + 0. # promote to at least float\n a[b == 0] = -np.inf\n\n a_max = np.amax(a, axis=axis, keepdims=True)\n\n if a_max.ndim > 0:\n a_max[~np.isfinite(a_max)] = 0\n elif not np.isfinite(a_max):\n a_max = 0\n\n if b is not None:\n b = np.asarray(b)\n tmp = b * np.exp(a - a_max)\n else:\n tmp = np.exp(a - a_max)\n\n # suppress warnings about log of zero\n with np.errstate(divide='ignore'):\n s = np.sum(tmp, axis=axis, keepdims=keepdims)\n if return_sign:\n sgn = np.sign(s)\n s *= sgn # /= makes more sense but we need zero -> zero\n out = np.log(s)\n\n if not keepdims:\n a_max = np.squeeze(a_max, axis=axis)\n out += a_max\n\n if return_sign:\n return out, sgn\n else:\n return out"},"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 log_sum_exp(x):\n log_reduce_sum = P.ReduceSum()\n log = P.Log()\n exp = P.Exp()\n x_max = max(x.data)\n return log(log_reduce_sum(exp(x - x_max), 1)) + x_max","def log_sum_exp(self, x):\n b = numpy.max(x[(x<sys.maxsize)]) # ignore inf values\n\n s = b + numpy.log(numpy.sum(numpy.exp(x-b)))\n\n return s","def log_sum_exp(x):\n x_max = x.max()\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max","def log_sum_exp(x):\n # TF ordering\n axis = len(x.shape) - 1\n m = paddle.max(x, axis=axis)\n m2 = paddle.max(x, axis=axis, keepdim=True)\n return m + paddle.log(paddle.sum(paddle.exp(x - m2), axis=axis))","def log_sum_exp(x):\n x_max = x.data.max()\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max","def log_sum_exp(x):\n x_max = x.data.max()\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max","def logSumExp(ns):\n mx = np.max(ns)\n ds = ns - mx\n sumOfExp = np.exp(ds).sum()\n return mx + np.log(sumOfExp)","def log_sum_exp(ns):\n ns = np.array(ns)\n max_num = max(ns)\n ds = ns - max_num\n sumOfExp = np.exp(ds).sum()\n return max_num + np.log(sumOfExp)","def log_sum_exp(v):\n\tm = max(v)\n\tx = m * np.ones(np.size(v))\n\treturn m + np.log(sum(np.exp(v - x)))","def log_sum_exp(x, dim=0):\n max_x = torch.max(x, dim)[0]\n new_x = x - max_x.unsqueeze(dim).expand_as(x)\n return max_x + (new_x.exp().sum(dim)).log()","def log_sum_exp(x, axis=None):\n xmax = x.max(axis=axis, keepdims=True)\n xmax_ = x.max(axis=axis)\n return xmax_ + T.log(T.exp(x - xmax).sum(axis=axis))","def _logsumexp(x):\n # Search maximum.\n max_x = None\n length = len(x)\n for i in range(length):\n if max_x is None or x[i] > max_x:\n max_x = x[i]\n\n # Calculate sum of exponential differences.\n sum_exp = 0\n for i in range(length):\n diff = x[i] - max_x\n sum_exp += np.exp(diff)\n\n log_sum_exp = max_x + np.log(sum_exp)\n\n return log_sum_exp","def log_sum_exp(Z):\n return np.max(Z) + np.log(np.sum(np.exp(Z - np.max(Z))))","def _log_sum_exp(x):\n axis = len(x.get_shape())-1\n m = tf.reduce_max(x, axis)\n m2 = tf.reduce_max(x, axis, keep_dims=True)\n return m + tf.log(tf.reduce_sum(tf.exp(x-m2), axis))","def logsumexp_trick(sum_term):\n max_term = np.max(sum_term)\n return max_term + np.log(np.sum(np.exp(sum_term-max_term)))","def log_sum_exp(x):\n axis = len(x.get_shape()) - 1\n m = tf.reduce_max(x, axis)\n m2 = tf.reduce_max(x, axis, keep_dims=True)\n return m + tf.log(tf.reduce_sum(tf.exp(x - m2), axis))","def logsumexp(*args):\n res = args[0]\n for e in args[1:]:\n res = _logsumexp(res, e)\n return res","def log_mean_exp(x, dim):\n return log_sum_exp(x, dim) - np.log(x.size(dim))","def log_sum_exp(tensor, dim=-1, sum_op=torch.sum):\n max, _ = torch.max(tensor, dim=dim, keepdim=True)\n return torch.log(sum_op(torch.exp(tensor - max), dim=dim, keepdim=True) + 1e-8) + max","def log_sum_exp(value, dim=None, keepdim=False):\n # TODO: torch.max(value, dim=None) threw an error at time of writing\n if dim is not None:\n m, _ = torch.max(value, dim=dim, keepdim=True)\n value0 = value - m\n if keepdim is False:\n m = m.squeeze(dim)\n return m + torch.log(torch.sum(torch.exp(value0),\n dim=dim, keepdim=keepdim))\n else:\n m = torch.max(value)\n sum_exp = torch.sum(torch.exp(value - m))\n if isinstance(sum_exp, Number):\n return m + math.log(sum_exp)\n else:\n return m + torch.log(sum_exp)","def log_sum_exp(value, dim=None, keepdim=False):\n # TODO: torch.max(value, dim=None) threw an error at time of writing\n if dim is not None:\n m, _ = torch.max(value, dim=dim, keepdim=True)\n value0 = value - m\n if keepdim is False:\n m = m.squeeze(dim)\n return m + torch.log(torch.sum(torch.exp(value0),\n dim=dim, keepdim=keepdim))\n else:\n m = torch.max(value)\n sum_exp = torch.sum(torch.exp(value - m))\n if isinstance(sum_exp, Number):\n return m + math.log(sum_exp)\n else:\n return m + torch.log(sum_exp)","def log_sum_exp(value, dim=None, keepdim=False):\n if dim is not None:\n m, _ = torch.max(value, dim=dim, keepdim=True)\n value0 = value - m\n if keepdim is False:\n m = m.squeeze(dim)\n return m + torch.log(torch.sum(torch.exp(value0), dim=dim, keepdim=keepdim))\n else:\n m = torch.max(value)\n sum_exp = torch.sum(torch.exp(value - m))\n return m + torch.log(sum_exp)","def ln(x):\n return log(x, const.e)","def sum_log(*args):\n # if all(a == LOG_ZERO for a in args):\n # return LOG_ZERO\n a_max = np.max(args, 0)\n lsp = np.log(np.sum([np.exp(a - a_max) for a in args], 0))\n return a_max + lsp","def log_sum_exp_pytorch(vec: torch.Tensor) -> torch.Tensor:\n maxScores, idx = torch.max(vec, 1)\n maxScores[maxScores == -float(\"Inf\")] = 0\n maxScoresExpanded = maxScores.view(vec.shape[0] ,1 , vec.shape[2]).expand(vec.shape[0], vec.shape[1], vec.shape[2])\n return maxScores + torch.log(torch.sum(torch.exp(vec - maxScoresExpanded), 1))","def _log_add(*values):\n x = max(values)\n if x > -np.inf:\n sum_diffs = 0\n for value in values:\n sum_diffs += 2 ** (value - x)\n return x + np.log2(sum_diffs)\n else:\n return x","def logsumexp(logv):\n res = logzero()\n for val in logv:\n res = logsum_pair(res, val)\n return res","def log_sum_exp(vec):\r\n\r\n\r\n max_score, idx = torch.max(vec, -1, keepdim = True) # ( B, to_target, 1)\r\n # max_score = torch.gather(vec, 1, idx.view(-1, 1, m_size)).view(-1, 1, m_size) # B * M\r\n # max_score.expand_as(vec)\r\n # to_target = vec.size(1)\r\n\r\n return max_score.squeeze(-1) + torch.log(torch.sum(torch.exp(vec - max_score.expand_as(vec)), -1)) # B * to_target\r","def logsumexp(value, dim=None, keepdim=False):\n if dim is not None:\n m, _ = torch.max(value, dim=dim, keepdim=True)\n value0 = value - m\n if keepdim is False:\n m = m.squeeze(dim)\n return m + torch.log(torch.sum(torch.exp(value0),\n dim=dim, keepdim=keepdim))\n else:\n m = torch.max(value)\n sum_exp = torch.sum(torch.exp(value - m))\n if isinstance(sum_exp, Number):\n return m + math.log(sum_exp)\n else:\n return m + torch.log(sum_exp)","def logsumexp(value, dim=None, keepdim=False):\n if dim is not None:\n m, _ = torch.max(value, dim=dim, keepdim=True)\n value0 = value - m\n if keepdim is False:\n m = m.squeeze(dim)\n return m + torch.log(torch.sum(torch.exp(value0),\n dim=dim, keepdim=keepdim))\n else:\n m = torch.max(value)\n sum_exp = torch.sum(torch.exp(value - m))\n if isinstance(sum_exp, Number):\n return m + math.log(sum_exp)\n else:\n return m + torch.log(sum_exp)","def sum_logscale_list(input_list):\n exponential_sum = 0\n for i in input_list:\n if i is not None:\n exponential_sum += math.pow(10, i)\n return math.log10(exponential_sum)","def utils_to_logsums(utils, exponentiated=False, allow_zero_probs=False):\n\n # fixme - conversion to float not needed in either case?\n # utils_arr = utils.values.astype('float')\n utils_arr = utils.values\n if not exponentiated:\n utils_arr = np.exp(utils_arr)\n\n np.clip(utils_arr, EXP_UTIL_MIN, EXP_UTIL_MAX, out=utils_arr)\n\n utils_arr = np.where(utils_arr == EXP_UTIL_MIN, 0.0, utils_arr)\n\n with np.errstate(divide=\"ignore\" if allow_zero_probs else \"warn\"):\n logsums = np.log(utils_arr.sum(axis=1))\n\n logsums = pd.Series(logsums, index=utils.index)\n\n return logsums","def log(x, base=math.e):\n return 0.0","def addlogs(a,b):\n \n if a>b:\n return a + np.log(1+np.exp(b-a))\n else:\n return b + np.log(1+np.exp(a-b))","def log(tensor, base=np.e):\n if base == np.e:\n return _elementary_op(tensor, np.log, lambda x: 1 / x)\n return log(tensor) / log(base)","def logsumexp(v):\n max_v = max(v)\n new_v = numpy.empty((len(v)))\n for i in range(len(v)):\n new_v[i] = v[i] - max_v\n return max_v + numpy.log(sum(numpy.exp(new_v)))","def log1p_exp(x):\n x_ = x * x.ge(0).to(torch.float32)\n res = x_ + torch.log1p(torch.exp(-torch.abs(x)))\n return res","def exp(X):\n X = np.maximum(X,100)\n return np.exp(X)","def logsumexp(x, axis=None):\n xmax = K.max(x, axis=axis, keepdims=True)\n xmax_ = K.max(x, axis=axis)\n return xmax_ + K.log(K.sum(K.exp(x - xmax), axis=axis))","def lognormalize(x, temp = 1):\n if type(x) is list: x = np.array(x)\n\n x = x - np.max(x)\n # anneal\n xp = np.power(np.exp(x), temp)\n return xp / xp.sum()","def __pow__(self, a: float) -> np.ndarray:\n return np.e**(a*self.logarithm)","def logsumexp(x, axis=None):\n raise NotImplementedError","def log1mexp(x: torch.Tensor) -> torch.Tensor:\n mask = (x < _log05).to(x.dtype)\n impl1 = torch.log1p(-torch.exp(x))\n impl2 = torch.log(-torch.expm1(x))\n return impl1 * mask + impl2 * (1 - mask)","def U(xs):\n ret = 0\n for x in xs:\n ret += log(x)\n return ret","def _log_add(logx: float, logy: float) -> float:\n a, b = min(logx, logy), max(logx, logy)\n if a == -np.inf: # adding 0\n return b\n # Use exp(a) + exp(b) = (exp(a - b) + 1) * exp(b)\n return math.log1p(math.exp(a - b)) + b # log1p(x) = log(x + 1)","def _getExponentialValues(self, arr):\r\n return [math.exp(val) for val in arr]","def exp(x):\n raise NotImplementedError","def exponentialfcn(x: np.ndarray) -> np.ndarray:\n\n x2 = x**2\n scores = -np.exp(-0.5 * np.sum(x2, axis=1))\n return scores","def logsumexp(input_matrix, reduction_indices=1, keep_dims=False):\r\n\r\n max_input_matrix1 = input_matrix.max(reduction_indices, keepdims=keep_dims)\r\n max_input_matrix2 = max_input_matrix1\r\n if not keep_dims:\r\n max_input_matrix2 = np.expand_dims(max_input_matrix2, reduction_indices)\r\n return np.log(\r\n np.sum(\r\n np.exp(input_matrix - max_input_matrix2),\r\n reduction_indices,\r\n keepdims=keep_dims)) + max_input_matrix1","def log_likelihood_exp(self, x):\n predictions = self.get_predictions(x)\n ll = 0.\n for measurement in self.get_measurements:\n m_obj = flavio.Measurement[measurement]\n m_obs = m_obj.all_parameters\n exclude_observables = set(m_obs) - set(self.observables)\n prob_dict = m_obj.get_logprobability_all(predictions, exclude_parameters=exclude_observables)\n ll += sum(prob_dict.values())\n return ll","def log_prob_from_logits(x):\n axis = len(x.shape) - 1\n m = x.max(dim=axis, keepdim=True)[0]\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))","def log_mean_exp(y):\n # init\n batch_size = y.size(0)\n sample_size = y.size(1)\n\n # log_mean_exp\n max_sample = torch.max(y, dim=1)[0]\n reshaped_max_sample = max_sample.view(batch_size, -1)\n log_mean_exp = torch.log(torch.mean(torch.exp(y - reshaped_max_sample), dim=1)) + max_sample\n return log_mean_exp","def logsumexp(p):\n return scipy.misc.logsumexp(p) if (len(p) > 0) else -1e20","def logarithmic():\n return Equivalency(\n [(dimensionless_unscaled, function_units.dex, np.log10, lambda x: 10.0**x)],\n \"logarithmic\",\n )","def logistic(x):\n try:\n denom = (1 + math.e ** -x)\n except OverflowError:\n return 0.0\n return 1.0 / denom","def logrels(rets):\n return np.log(rets + 1)","def Log(num):\n return math.log(float(num))","def log_norm(log_x):\n c = np.max(log_x)\n\n if np.isinf(c):\n return c\n\n sum_exp = 0\n\n for x in log_x:\n sum_exp += np.exp(x - c)\n\n log_sum_exp = np.log(sum_exp)\n\n log_Z = log_sum_exp + c\n\n return log_Z","def logsum_safe(prob_ll, atl):\n logpdf = prob_ll + K.log(atl + K.epsilon())\n alpha = tf.reduce_max(logpdf, -1, keepdims=True)\n return alpha + tf.log(tf.reduce_sum(K.exp(logpdf-alpha), -1, keepdims=True) + K.epsilon())","def loglog_interp(x,xp,fp):\n lx = np.log(x)\n lxp = np.log(xp)\n lfp = np.log(fp)\n return np.exp(np.interp(lx,lxp,lfp))","def logarithm(x, eps=10e-5):\n if abs(x) >= 1:\n return float('Nan')\n\n pre_x = x\n tmp = x ** 2\n sign = -1\n i = 2\n res_x = pre_x + sign * tmp / i\n\n while abs(res_x - pre_x) > eps:\n sign = -sign\n i += 1\n tmp *= x\n pre_x = res_x\n res_x += sign * tmp / i\n\n return res_x","def loglnumpy(store):\n xbeta = dot(store['xmat'], store['beta'])\n lamb = exp(xbeta)\n return sum(store['yvec'] * xbeta - lamb)","def weight_log(val):\n return val * math.log(val)","def _get_log_energy(strided_input, epsilon, energy_floor):\n log_energy = torch.max(strided_input.pow(2).sum(1), epsilon).log() # size (m)\n if energy_floor == 0.0:\n return log_energy\n else:\n return torch.max(log_energy,\n torch.tensor(math.log(energy_floor), dtype=torch.get_default_dtype()))","def logsumexp(tensor: torch.Tensor, dim: Optional[int] = None, keepdim: bool = False) -> torch.Tensor:\n if dim is None:\n tensor = tensor.reshape(-1)\n dim = -1\n\n inputs_max = tensor.max(dim=dim, keepdim=True)[0]\n tensor = tensor - inputs_max\n if not keepdim:\n inputs_max = inputs_max.squeeze(dim)\n\n out = _safe_log(tensor.exp().sum(dim=dim, keepdim=keepdim)) + inputs_max\n return out","def exp_integral(x):\n gamma = 0.577215665\n return (-gamma - expn(x,1) - np.log(x))","def logaddexp(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n return torch.max(x, y) + torch.log(1 + torch.exp(-torch.abs(y - x)))","def logaddexp(X, Y):\n XY_max = T.maximum(X, Y)\n XY_min = T.minimum(X, Y)\n return XY_max + T.log1p(T.exp(XY_min - XY_max))","def logsum_pair(logx, logy):\n if logx == logzero():\n return logy\n elif logx > logy:\n return logx + np.log1p(np.exp(logy-logx))\n else:\n return logy + np.log1p(np.exp(logx-logy))","def log_pic50_exponential(x):\n if x < pic50_exp_lower:\n return -np.inf\n else:\n return -pic50_exp_rate*x","def sum_exp(self,time):\n sum = np.sum([self.A[i]*np.exp(-1.*self.lambdas[i]*time)\\\n for i in xrange(self.m)])\n return sum","def log_E_score(EL_array, state_tree_sequence):\n log_EL_array = np.log(EL_array)\n log_E_score_holder = 0\n for idx, row in enumerate(log_EL_array):\n log_E_score_holder += row[state_tree_sequence[idx]]\n return log_E_score_holder","def general_exp(x, max_order=15):\n\n result = 1.0\n if max_order == 0:\n return result\n\n # scale by power of 2 so that its norm is < 1\n max_val = int(np.max(np.abs(x.value)))\n scale = 1\n if max_val > 1:\n max_val <<= 1\n while max_val:\n max_val >>= 1\n scale <<= 1\n\n scaled = x * (1.0 / scale)\n\n # taylor approximation\n tmp = 1.0 + 0.0*x\n for i in range(1, max_order):\n if np.any(np.abs(tmp.value) > _eps):\n tmp = tmp*scaled * (1.0 / i)\n result += tmp\n else:\n break\n\n # undo scaling\n while scale > 1:\n result *= result\n scale >>= 1\n return result","def exp_series(x, n):\n return sum((exp_term(x, i) for i in xrange(0, n)))","def exponential(value):\n return math.exp(value)","def logit_link(x):\n\n return 1 / (1 + math.exp(-0.05 * x))\n # return 1 / (1 + math.exp(-0.01 * x))","def exponential(gp_link=None):\r\n if gp_link is None:\r\n gp_link = noise_models.gp_transformations.Log_ex_1()\r\n\r\n analytical_mean = False\r\n analytical_variance = False\r\n return noise_models.exponential_noise.Exponential(gp_link,analytical_mean,analytical_variance)","def lognormexp(values, dim=0):\n\n log_denominator = torch.logsumexp(values, dim=dim, keepdim=True)\n # log_numerator = values\n return values - log_denominator","def lognormexp(values, dim=0):\n\n log_denominator = torch.logsumexp(values, dim=dim, keepdim=True)\n # log_numerator = values\n return values - log_denominator","def p(self):\n return numpy.exp(self.log_p)","def entropy(p_list):\n assert len(p_list) > 0\n E = 0.0\n for p in p_list:\n if p == 0.0:\n continue\n E += p*math.log(p)\n return E","def log_prob_from_logits(x):\n axis = len(x.get_shape()) - 1\n m = tf.reduce_max(x, axis, keep_dims=True)\n return x - m - tf.log(tf.reduce_sum(tf.exp(x - m), axis, keep_dims=True))","def safelog(x):\n #return np.log(x)\n return np.log(np.clip(x,floor,np.inf))","def log(base, real):\n return math.log(real, base)","def local_exp_over_1_plus_exp(node):\r\n # this optimization should be done for numerical stability\r\n # so we don't care to check client counts\r\n if node.op == tensor.true_div:\r\n\r\n #find all the exp() terms in the numerator\r\n num, denom = node.inputs\r\n num_exp_x, num_rest, num_neg = partition_num_or_denom(num, is_exp)\r\n denom_1pexp, denom_rest, \\\r\n denom_neg = partition_num_or_denom(denom, is_1pexp)\r\n\r\n sigmoids = []\r\n for t in denom_1pexp:\r\n if t in num_exp_x:\r\n # case: exp(x) /(1+exp(x))\r\n sigmoids.append(sigmoid(t))\r\n del num_exp_x[num_exp_x.index(t)]\r\n else:\r\n # case: 1/(1+exp(x))\r\n sigmoids.append(sigmoid(-t))\r\n\r\n if not sigmoids: # we didn't find any. abort\r\n return\r\n # put the new numerator together\r\n new_num = sigmoids + [tensor.exp(t) for t in num_exp_x] + num_rest\r\n if len(new_num) == 1:\r\n new_num = new_num[0]\r\n else:\r\n new_num = tensor.mul(*new_num)\r\n\r\n if num_neg ^ denom_neg:\r\n new_num = -new_num\r\n\r\n if len(denom_rest) == 0:\r\n return [new_num]\r\n elif len(denom_rest) == 1:\r\n return [new_num / denom_rest[0]]\r\n else:\r\n return [new_num / tensor.mul(*denom_rest)]","def log(self, base):\n\n\t\tvalues = map(lambda x: x > 0, self.val)\n\t\tif not all(values):\n\t\t\traise ValueError(\"Non-positive number encountered in log.\")\n\t\telse:\n\t\t\tval = np.array([np.math.log(v, base) for v in self.val])\n\t\t\tif len(self.der.shape):\n\t\t\t\tto_multiply = 1 / np.multiply(np.log(base), self.val)\n\t\t\t\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\n\t\t\t\tder = np.multiply(to_multiply, self.der)\n\t\t\telse:\n\t\t\t\tder = None\n\t\treturn Var(val, der)","def logit(x: torch.Tensor, eps=1e-5) -> torch.Tensor:\n x = torch.clamp(x, eps, 1.0 - eps)\n return torch.log(x / (1.0 - x))","def expdiff(x, a=a, n=5):\n return a**n * np.exp(a*x)","def logsumexp2(z):\n return logsumexp(z, axis=2)","def log2(a):","def exp(tensor):\n return _elementary_op(tensor, np.exp, np.exp)","def log_add(x, y):\n maximum = np.maximum(x,y)\n minimum = np.minimum(x,y)\n if(np.abs(maximum - minimum) > 30):\n # the difference is too small, return the just the maximum\n return maximum\n return maximum + np.log1p(np.exp(minimum - maximum))","def loglike(self, params, *args, **kwargs):\n return np.sum(self.loglikeobs(params, *args, **kwargs))","def log_interpolate(array):\n idx = np.arange(0, len(array))\n log_array = np.log(array.astype(np.float32) + 1e-1)\n interp_array = np.interp(\n x=idx, xp=idx[~np.isnan(array)], fp=log_array[~np.isnan(array)]\n )\n return np.round(np.exp(interp_array)).astype(np.int32)","def log_prob_from_logits(x):\n axis = len(x.get_shape())-1\n m = tf.reduce_max(x, axis, keep_dims=True)\n return x - m - tf.log(tf.reduce_sum(tf.exp(x-m), axis, keep_dims=True))","def exp(data):\n return _make.exp(data)","def loglloop(store):\n suml=0.0\n for i in xrange(store['yvec'].shape[0]):\n xbeta=dot(store['xmat'][i,:],store['beta'])\n suml=suml+store['yvec'][i] * xbeta - exp(xbeta)\n return suml","def log_transform(x, epsilon = 1e-4):\n if x.min() < 0: epsilon += np.abs(x.min())\n return (x.fillna(0).astype(float) + epsilon).apply(np.log)","def exp_mean_dense(x):\n # convert out of compressed sparse matrix\n return np.log((np.sum(np.exp(x)-1)/x.shape[1]) + 1)","def logAdd(a, b):\n if b > a:\n # a is always larger.\n a, b = b, a\n if a - b > 100:\n # Just a to a rounding error.\n return a\n return b + math.log(math.exp(a - b) + 1)"],"string":"[\n \"def log_sum_exp(x):\\n log_reduce_sum = P.ReduceSum()\\n log = P.Log()\\n exp = P.Exp()\\n x_max = max(x.data)\\n return log(log_reduce_sum(exp(x - x_max), 1)) + x_max\",\n \"def log_sum_exp(self, x):\\n b = numpy.max(x[(x<sys.maxsize)]) # ignore inf values\\n\\n s = b + numpy.log(numpy.sum(numpy.exp(x-b)))\\n\\n return s\",\n \"def log_sum_exp(x):\\n x_max = x.max()\\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max\",\n \"def log_sum_exp(x):\\n # TF ordering\\n axis = len(x.shape) - 1\\n m = paddle.max(x, axis=axis)\\n m2 = paddle.max(x, axis=axis, keepdim=True)\\n return m + paddle.log(paddle.sum(paddle.exp(x - m2), axis=axis))\",\n \"def log_sum_exp(x):\\n x_max = x.data.max()\\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max\",\n \"def log_sum_exp(x):\\n x_max = x.data.max()\\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max\",\n \"def logSumExp(ns):\\n mx = np.max(ns)\\n ds = ns - mx\\n sumOfExp = np.exp(ds).sum()\\n return mx + np.log(sumOfExp)\",\n \"def log_sum_exp(ns):\\n ns = np.array(ns)\\n max_num = max(ns)\\n ds = ns - max_num\\n sumOfExp = np.exp(ds).sum()\\n return max_num + np.log(sumOfExp)\",\n \"def log_sum_exp(v):\\n\\tm = max(v)\\n\\tx = m * np.ones(np.size(v))\\n\\treturn m + np.log(sum(np.exp(v - x)))\",\n \"def log_sum_exp(x, dim=0):\\n max_x = torch.max(x, dim)[0]\\n new_x = x - max_x.unsqueeze(dim).expand_as(x)\\n return max_x + (new_x.exp().sum(dim)).log()\",\n \"def log_sum_exp(x, axis=None):\\n xmax = x.max(axis=axis, keepdims=True)\\n xmax_ = x.max(axis=axis)\\n return xmax_ + T.log(T.exp(x - xmax).sum(axis=axis))\",\n \"def _logsumexp(x):\\n # Search maximum.\\n max_x = None\\n length = len(x)\\n for i in range(length):\\n if max_x is None or x[i] > max_x:\\n max_x = x[i]\\n\\n # Calculate sum of exponential differences.\\n sum_exp = 0\\n for i in range(length):\\n diff = x[i] - max_x\\n sum_exp += np.exp(diff)\\n\\n log_sum_exp = max_x + np.log(sum_exp)\\n\\n return log_sum_exp\",\n \"def log_sum_exp(Z):\\n return np.max(Z) + np.log(np.sum(np.exp(Z - np.max(Z))))\",\n \"def _log_sum_exp(x):\\n axis = len(x.get_shape())-1\\n m = tf.reduce_max(x, axis)\\n m2 = tf.reduce_max(x, axis, keep_dims=True)\\n return m + tf.log(tf.reduce_sum(tf.exp(x-m2), axis))\",\n \"def logsumexp_trick(sum_term):\\n max_term = np.max(sum_term)\\n return max_term + np.log(np.sum(np.exp(sum_term-max_term)))\",\n \"def log_sum_exp(x):\\n axis = len(x.get_shape()) - 1\\n m = tf.reduce_max(x, axis)\\n m2 = tf.reduce_max(x, axis, keep_dims=True)\\n return m + tf.log(tf.reduce_sum(tf.exp(x - m2), axis))\",\n \"def logsumexp(*args):\\n res = args[0]\\n for e in args[1:]:\\n res = _logsumexp(res, e)\\n return res\",\n \"def log_mean_exp(x, dim):\\n return log_sum_exp(x, dim) - np.log(x.size(dim))\",\n \"def log_sum_exp(tensor, dim=-1, sum_op=torch.sum):\\n max, _ = torch.max(tensor, dim=dim, keepdim=True)\\n return torch.log(sum_op(torch.exp(tensor - max), dim=dim, keepdim=True) + 1e-8) + max\",\n \"def log_sum_exp(value, dim=None, keepdim=False):\\n # TODO: torch.max(value, dim=None) threw an error at time of writing\\n if dim is not None:\\n m, _ = torch.max(value, dim=dim, keepdim=True)\\n value0 = value - m\\n if keepdim is False:\\n m = m.squeeze(dim)\\n return m + torch.log(torch.sum(torch.exp(value0),\\n dim=dim, keepdim=keepdim))\\n else:\\n m = torch.max(value)\\n sum_exp = torch.sum(torch.exp(value - m))\\n if isinstance(sum_exp, Number):\\n return m + math.log(sum_exp)\\n else:\\n return m + torch.log(sum_exp)\",\n \"def log_sum_exp(value, dim=None, keepdim=False):\\n # TODO: torch.max(value, dim=None) threw an error at time of writing\\n if dim is not None:\\n m, _ = torch.max(value, dim=dim, keepdim=True)\\n value0 = value - m\\n if keepdim is False:\\n m = m.squeeze(dim)\\n return m + torch.log(torch.sum(torch.exp(value0),\\n dim=dim, keepdim=keepdim))\\n else:\\n m = torch.max(value)\\n sum_exp = torch.sum(torch.exp(value - m))\\n if isinstance(sum_exp, Number):\\n return m + math.log(sum_exp)\\n else:\\n return m + torch.log(sum_exp)\",\n \"def log_sum_exp(value, dim=None, keepdim=False):\\n if dim is not None:\\n m, _ = torch.max(value, dim=dim, keepdim=True)\\n value0 = value - m\\n if keepdim is False:\\n m = m.squeeze(dim)\\n return m + torch.log(torch.sum(torch.exp(value0), dim=dim, keepdim=keepdim))\\n else:\\n m = torch.max(value)\\n sum_exp = torch.sum(torch.exp(value - m))\\n return m + torch.log(sum_exp)\",\n \"def ln(x):\\n return log(x, const.e)\",\n \"def sum_log(*args):\\n # if all(a == LOG_ZERO for a in args):\\n # return LOG_ZERO\\n a_max = np.max(args, 0)\\n lsp = np.log(np.sum([np.exp(a - a_max) for a in args], 0))\\n return a_max + lsp\",\n \"def log_sum_exp_pytorch(vec: torch.Tensor) -> torch.Tensor:\\n maxScores, idx = torch.max(vec, 1)\\n maxScores[maxScores == -float(\\\"Inf\\\")] = 0\\n maxScoresExpanded = maxScores.view(vec.shape[0] ,1 , vec.shape[2]).expand(vec.shape[0], vec.shape[1], vec.shape[2])\\n return maxScores + torch.log(torch.sum(torch.exp(vec - maxScoresExpanded), 1))\",\n \"def _log_add(*values):\\n x = max(values)\\n if x > -np.inf:\\n sum_diffs = 0\\n for value in values:\\n sum_diffs += 2 ** (value - x)\\n return x + np.log2(sum_diffs)\\n else:\\n return x\",\n \"def logsumexp(logv):\\n res = logzero()\\n for val in logv:\\n res = logsum_pair(res, val)\\n return res\",\n \"def log_sum_exp(vec):\\r\\n\\r\\n\\r\\n max_score, idx = torch.max(vec, -1, keepdim = True) # ( B, to_target, 1)\\r\\n # max_score = torch.gather(vec, 1, idx.view(-1, 1, m_size)).view(-1, 1, m_size) # B * M\\r\\n # max_score.expand_as(vec)\\r\\n # to_target = vec.size(1)\\r\\n\\r\\n return max_score.squeeze(-1) + torch.log(torch.sum(torch.exp(vec - max_score.expand_as(vec)), -1)) # B * to_target\\r\",\n \"def logsumexp(value, dim=None, keepdim=False):\\n if dim is not None:\\n m, _ = torch.max(value, dim=dim, keepdim=True)\\n value0 = value - m\\n if keepdim is False:\\n m = m.squeeze(dim)\\n return m + torch.log(torch.sum(torch.exp(value0),\\n dim=dim, keepdim=keepdim))\\n else:\\n m = torch.max(value)\\n sum_exp = torch.sum(torch.exp(value - m))\\n if isinstance(sum_exp, Number):\\n return m + math.log(sum_exp)\\n else:\\n return m + torch.log(sum_exp)\",\n \"def logsumexp(value, dim=None, keepdim=False):\\n if dim is not None:\\n m, _ = torch.max(value, dim=dim, keepdim=True)\\n value0 = value - m\\n if keepdim is False:\\n m = m.squeeze(dim)\\n return m + torch.log(torch.sum(torch.exp(value0),\\n dim=dim, keepdim=keepdim))\\n else:\\n m = torch.max(value)\\n sum_exp = torch.sum(torch.exp(value - m))\\n if isinstance(sum_exp, Number):\\n return m + math.log(sum_exp)\\n else:\\n return m + torch.log(sum_exp)\",\n \"def sum_logscale_list(input_list):\\n exponential_sum = 0\\n for i in input_list:\\n if i is not None:\\n exponential_sum += math.pow(10, i)\\n return math.log10(exponential_sum)\",\n \"def utils_to_logsums(utils, exponentiated=False, allow_zero_probs=False):\\n\\n # fixme - conversion to float not needed in either case?\\n # utils_arr = utils.values.astype('float')\\n utils_arr = utils.values\\n if not exponentiated:\\n utils_arr = np.exp(utils_arr)\\n\\n np.clip(utils_arr, EXP_UTIL_MIN, EXP_UTIL_MAX, out=utils_arr)\\n\\n utils_arr = np.where(utils_arr == EXP_UTIL_MIN, 0.0, utils_arr)\\n\\n with np.errstate(divide=\\\"ignore\\\" if allow_zero_probs else \\\"warn\\\"):\\n logsums = np.log(utils_arr.sum(axis=1))\\n\\n logsums = pd.Series(logsums, index=utils.index)\\n\\n return logsums\",\n \"def log(x, base=math.e):\\n return 0.0\",\n \"def addlogs(a,b):\\n \\n if a>b:\\n return a + np.log(1+np.exp(b-a))\\n else:\\n return b + np.log(1+np.exp(a-b))\",\n \"def log(tensor, base=np.e):\\n if base == np.e:\\n return _elementary_op(tensor, np.log, lambda x: 1 / x)\\n return log(tensor) / log(base)\",\n \"def logsumexp(v):\\n max_v = max(v)\\n new_v = numpy.empty((len(v)))\\n for i in range(len(v)):\\n new_v[i] = v[i] - max_v\\n return max_v + numpy.log(sum(numpy.exp(new_v)))\",\n \"def log1p_exp(x):\\n x_ = x * x.ge(0).to(torch.float32)\\n res = x_ + torch.log1p(torch.exp(-torch.abs(x)))\\n return res\",\n \"def exp(X):\\n X = np.maximum(X,100)\\n return np.exp(X)\",\n \"def logsumexp(x, axis=None):\\n xmax = K.max(x, axis=axis, keepdims=True)\\n xmax_ = K.max(x, axis=axis)\\n return xmax_ + K.log(K.sum(K.exp(x - xmax), axis=axis))\",\n \"def lognormalize(x, temp = 1):\\n if type(x) is list: x = np.array(x)\\n\\n x = x - np.max(x)\\n # anneal\\n xp = np.power(np.exp(x), temp)\\n return xp / xp.sum()\",\n \"def __pow__(self, a: float) -> np.ndarray:\\n return np.e**(a*self.logarithm)\",\n \"def logsumexp(x, axis=None):\\n raise NotImplementedError\",\n \"def log1mexp(x: torch.Tensor) -> torch.Tensor:\\n mask = (x < _log05).to(x.dtype)\\n impl1 = torch.log1p(-torch.exp(x))\\n impl2 = torch.log(-torch.expm1(x))\\n return impl1 * mask + impl2 * (1 - mask)\",\n \"def U(xs):\\n ret = 0\\n for x in xs:\\n ret += log(x)\\n return ret\",\n \"def _log_add(logx: float, logy: float) -> float:\\n a, b = min(logx, logy), max(logx, logy)\\n if a == -np.inf: # adding 0\\n return b\\n # Use exp(a) + exp(b) = (exp(a - b) + 1) * exp(b)\\n return math.log1p(math.exp(a - b)) + b # log1p(x) = log(x + 1)\",\n \"def _getExponentialValues(self, arr):\\r\\n return [math.exp(val) for val in arr]\",\n \"def exp(x):\\n raise NotImplementedError\",\n \"def exponentialfcn(x: np.ndarray) -> np.ndarray:\\n\\n x2 = x**2\\n scores = -np.exp(-0.5 * np.sum(x2, axis=1))\\n return scores\",\n \"def logsumexp(input_matrix, reduction_indices=1, keep_dims=False):\\r\\n\\r\\n max_input_matrix1 = input_matrix.max(reduction_indices, keepdims=keep_dims)\\r\\n max_input_matrix2 = max_input_matrix1\\r\\n if not keep_dims:\\r\\n max_input_matrix2 = np.expand_dims(max_input_matrix2, reduction_indices)\\r\\n return np.log(\\r\\n np.sum(\\r\\n np.exp(input_matrix - max_input_matrix2),\\r\\n reduction_indices,\\r\\n keepdims=keep_dims)) + max_input_matrix1\",\n \"def log_likelihood_exp(self, x):\\n predictions = self.get_predictions(x)\\n ll = 0.\\n for measurement in self.get_measurements:\\n m_obj = flavio.Measurement[measurement]\\n m_obs = m_obj.all_parameters\\n exclude_observables = set(m_obs) - set(self.observables)\\n prob_dict = m_obj.get_logprobability_all(predictions, exclude_parameters=exclude_observables)\\n ll += sum(prob_dict.values())\\n return ll\",\n \"def log_prob_from_logits(x):\\n axis = len(x.shape) - 1\\n m = x.max(dim=axis, keepdim=True)[0]\\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))\",\n \"def log_mean_exp(y):\\n # init\\n batch_size = y.size(0)\\n sample_size = y.size(1)\\n\\n # log_mean_exp\\n max_sample = torch.max(y, dim=1)[0]\\n reshaped_max_sample = max_sample.view(batch_size, -1)\\n log_mean_exp = torch.log(torch.mean(torch.exp(y - reshaped_max_sample), dim=1)) + max_sample\\n return log_mean_exp\",\n \"def logsumexp(p):\\n return scipy.misc.logsumexp(p) if (len(p) > 0) else -1e20\",\n \"def logarithmic():\\n return Equivalency(\\n [(dimensionless_unscaled, function_units.dex, np.log10, lambda x: 10.0**x)],\\n \\\"logarithmic\\\",\\n )\",\n \"def logistic(x):\\n try:\\n denom = (1 + math.e ** -x)\\n except OverflowError:\\n return 0.0\\n return 1.0 / denom\",\n \"def logrels(rets):\\n return np.log(rets + 1)\",\n \"def Log(num):\\n return math.log(float(num))\",\n \"def log_norm(log_x):\\n c = np.max(log_x)\\n\\n if np.isinf(c):\\n return c\\n\\n sum_exp = 0\\n\\n for x in log_x:\\n sum_exp += np.exp(x - c)\\n\\n log_sum_exp = np.log(sum_exp)\\n\\n log_Z = log_sum_exp + c\\n\\n return log_Z\",\n \"def logsum_safe(prob_ll, atl):\\n logpdf = prob_ll + K.log(atl + K.epsilon())\\n alpha = tf.reduce_max(logpdf, -1, keepdims=True)\\n return alpha + tf.log(tf.reduce_sum(K.exp(logpdf-alpha), -1, keepdims=True) + K.epsilon())\",\n \"def loglog_interp(x,xp,fp):\\n lx = np.log(x)\\n lxp = np.log(xp)\\n lfp = np.log(fp)\\n return np.exp(np.interp(lx,lxp,lfp))\",\n \"def logarithm(x, eps=10e-5):\\n if abs(x) >= 1:\\n return float('Nan')\\n\\n pre_x = x\\n tmp = x ** 2\\n sign = -1\\n i = 2\\n res_x = pre_x + sign * tmp / i\\n\\n while abs(res_x - pre_x) > eps:\\n sign = -sign\\n i += 1\\n tmp *= x\\n pre_x = res_x\\n res_x += sign * tmp / i\\n\\n return res_x\",\n \"def loglnumpy(store):\\n xbeta = dot(store['xmat'], store['beta'])\\n lamb = exp(xbeta)\\n return sum(store['yvec'] * xbeta - lamb)\",\n \"def weight_log(val):\\n return val * math.log(val)\",\n \"def _get_log_energy(strided_input, epsilon, energy_floor):\\n log_energy = torch.max(strided_input.pow(2).sum(1), epsilon).log() # size (m)\\n if energy_floor == 0.0:\\n return log_energy\\n else:\\n return torch.max(log_energy,\\n torch.tensor(math.log(energy_floor), dtype=torch.get_default_dtype()))\",\n \"def logsumexp(tensor: torch.Tensor, dim: Optional[int] = None, keepdim: bool = False) -> torch.Tensor:\\n if dim is None:\\n tensor = tensor.reshape(-1)\\n dim = -1\\n\\n inputs_max = tensor.max(dim=dim, keepdim=True)[0]\\n tensor = tensor - inputs_max\\n if not keepdim:\\n inputs_max = inputs_max.squeeze(dim)\\n\\n out = _safe_log(tensor.exp().sum(dim=dim, keepdim=keepdim)) + inputs_max\\n return out\",\n \"def exp_integral(x):\\n gamma = 0.577215665\\n return (-gamma - expn(x,1) - np.log(x))\",\n \"def logaddexp(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\\n return torch.max(x, y) + torch.log(1 + torch.exp(-torch.abs(y - x)))\",\n \"def logaddexp(X, Y):\\n XY_max = T.maximum(X, Y)\\n XY_min = T.minimum(X, Y)\\n return XY_max + T.log1p(T.exp(XY_min - XY_max))\",\n \"def logsum_pair(logx, logy):\\n if logx == logzero():\\n return logy\\n elif logx > logy:\\n return logx + np.log1p(np.exp(logy-logx))\\n else:\\n return logy + np.log1p(np.exp(logx-logy))\",\n \"def log_pic50_exponential(x):\\n if x < pic50_exp_lower:\\n return -np.inf\\n else:\\n return -pic50_exp_rate*x\",\n \"def sum_exp(self,time):\\n sum = np.sum([self.A[i]*np.exp(-1.*self.lambdas[i]*time)\\\\\\n for i in xrange(self.m)])\\n return sum\",\n \"def log_E_score(EL_array, state_tree_sequence):\\n log_EL_array = np.log(EL_array)\\n log_E_score_holder = 0\\n for idx, row in enumerate(log_EL_array):\\n log_E_score_holder += row[state_tree_sequence[idx]]\\n return log_E_score_holder\",\n \"def general_exp(x, max_order=15):\\n\\n result = 1.0\\n if max_order == 0:\\n return result\\n\\n # scale by power of 2 so that its norm is < 1\\n max_val = int(np.max(np.abs(x.value)))\\n scale = 1\\n if max_val > 1:\\n max_val <<= 1\\n while max_val:\\n max_val >>= 1\\n scale <<= 1\\n\\n scaled = x * (1.0 / scale)\\n\\n # taylor approximation\\n tmp = 1.0 + 0.0*x\\n for i in range(1, max_order):\\n if np.any(np.abs(tmp.value) > _eps):\\n tmp = tmp*scaled * (1.0 / i)\\n result += tmp\\n else:\\n break\\n\\n # undo scaling\\n while scale > 1:\\n result *= result\\n scale >>= 1\\n return result\",\n \"def exp_series(x, n):\\n return sum((exp_term(x, i) for i in xrange(0, n)))\",\n \"def exponential(value):\\n return math.exp(value)\",\n \"def logit_link(x):\\n\\n return 1 / (1 + math.exp(-0.05 * x))\\n # return 1 / (1 + math.exp(-0.01 * x))\",\n \"def exponential(gp_link=None):\\r\\n if gp_link is None:\\r\\n gp_link = noise_models.gp_transformations.Log_ex_1()\\r\\n\\r\\n analytical_mean = False\\r\\n analytical_variance = False\\r\\n return noise_models.exponential_noise.Exponential(gp_link,analytical_mean,analytical_variance)\",\n \"def lognormexp(values, dim=0):\\n\\n log_denominator = torch.logsumexp(values, dim=dim, keepdim=True)\\n # log_numerator = values\\n return values - log_denominator\",\n \"def lognormexp(values, dim=0):\\n\\n log_denominator = torch.logsumexp(values, dim=dim, keepdim=True)\\n # log_numerator = values\\n return values - log_denominator\",\n \"def p(self):\\n return numpy.exp(self.log_p)\",\n \"def entropy(p_list):\\n assert len(p_list) > 0\\n E = 0.0\\n for p in p_list:\\n if p == 0.0:\\n continue\\n E += p*math.log(p)\\n return E\",\n \"def log_prob_from_logits(x):\\n axis = len(x.get_shape()) - 1\\n m = tf.reduce_max(x, axis, keep_dims=True)\\n return x - m - tf.log(tf.reduce_sum(tf.exp(x - m), axis, keep_dims=True))\",\n \"def safelog(x):\\n #return np.log(x)\\n return np.log(np.clip(x,floor,np.inf))\",\n \"def log(base, real):\\n return math.log(real, base)\",\n \"def local_exp_over_1_plus_exp(node):\\r\\n # this optimization should be done for numerical stability\\r\\n # so we don't care to check client counts\\r\\n if node.op == tensor.true_div:\\r\\n\\r\\n #find all the exp() terms in the numerator\\r\\n num, denom = node.inputs\\r\\n num_exp_x, num_rest, num_neg = partition_num_or_denom(num, is_exp)\\r\\n denom_1pexp, denom_rest, \\\\\\r\\n denom_neg = partition_num_or_denom(denom, is_1pexp)\\r\\n\\r\\n sigmoids = []\\r\\n for t in denom_1pexp:\\r\\n if t in num_exp_x:\\r\\n # case: exp(x) /(1+exp(x))\\r\\n sigmoids.append(sigmoid(t))\\r\\n del num_exp_x[num_exp_x.index(t)]\\r\\n else:\\r\\n # case: 1/(1+exp(x))\\r\\n sigmoids.append(sigmoid(-t))\\r\\n\\r\\n if not sigmoids: # we didn't find any. abort\\r\\n return\\r\\n # put the new numerator together\\r\\n new_num = sigmoids + [tensor.exp(t) for t in num_exp_x] + num_rest\\r\\n if len(new_num) == 1:\\r\\n new_num = new_num[0]\\r\\n else:\\r\\n new_num = tensor.mul(*new_num)\\r\\n\\r\\n if num_neg ^ denom_neg:\\r\\n new_num = -new_num\\r\\n\\r\\n if len(denom_rest) == 0:\\r\\n return [new_num]\\r\\n elif len(denom_rest) == 1:\\r\\n return [new_num / denom_rest[0]]\\r\\n else:\\r\\n return [new_num / tensor.mul(*denom_rest)]\",\n \"def log(self, base):\\n\\n\\t\\tvalues = map(lambda x: x > 0, self.val)\\n\\t\\tif not all(values):\\n\\t\\t\\traise ValueError(\\\"Non-positive number encountered in log.\\\")\\n\\t\\telse:\\n\\t\\t\\tval = np.array([np.math.log(v, base) for v in self.val])\\n\\t\\t\\tif len(self.der.shape):\\n\\t\\t\\t\\tto_multiply = 1 / np.multiply(np.log(base), self.val)\\n\\t\\t\\t\\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\\n\\t\\t\\t\\tder = np.multiply(to_multiply, self.der)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tder = None\\n\\t\\treturn Var(val, der)\",\n \"def logit(x: torch.Tensor, eps=1e-5) -> torch.Tensor:\\n x = torch.clamp(x, eps, 1.0 - eps)\\n return torch.log(x / (1.0 - x))\",\n \"def expdiff(x, a=a, n=5):\\n return a**n * np.exp(a*x)\",\n \"def logsumexp2(z):\\n return logsumexp(z, axis=2)\",\n \"def log2(a):\",\n \"def exp(tensor):\\n return _elementary_op(tensor, np.exp, np.exp)\",\n \"def log_add(x, y):\\n maximum = np.maximum(x,y)\\n minimum = np.minimum(x,y)\\n if(np.abs(maximum - minimum) > 30):\\n # the difference is too small, return the just the maximum\\n return maximum\\n return maximum + np.log1p(np.exp(minimum - maximum))\",\n \"def loglike(self, params, *args, **kwargs):\\n return np.sum(self.loglikeobs(params, *args, **kwargs))\",\n \"def log_interpolate(array):\\n idx = np.arange(0, len(array))\\n log_array = np.log(array.astype(np.float32) + 1e-1)\\n interp_array = np.interp(\\n x=idx, xp=idx[~np.isnan(array)], fp=log_array[~np.isnan(array)]\\n )\\n return np.round(np.exp(interp_array)).astype(np.int32)\",\n \"def log_prob_from_logits(x):\\n axis = len(x.get_shape())-1\\n m = tf.reduce_max(x, axis, keep_dims=True)\\n return x - m - tf.log(tf.reduce_sum(tf.exp(x-m), axis, keep_dims=True))\",\n \"def exp(data):\\n return _make.exp(data)\",\n \"def loglloop(store):\\n suml=0.0\\n for i in xrange(store['yvec'].shape[0]):\\n xbeta=dot(store['xmat'][i,:],store['beta'])\\n suml=suml+store['yvec'][i] * xbeta - exp(xbeta)\\n return suml\",\n \"def log_transform(x, epsilon = 1e-4):\\n if x.min() < 0: epsilon += np.abs(x.min())\\n return (x.fillna(0).astype(float) + epsilon).apply(np.log)\",\n \"def exp_mean_dense(x):\\n # convert out of compressed sparse matrix\\n return np.log((np.sum(np.exp(x)-1)/x.shape[1]) + 1)\",\n \"def logAdd(a, b):\\n if b > a:\\n # a is always larger.\\n a, b = b, a\\n if a - b > 100:\\n # Just a to a rounding error.\\n return a\\n return b + math.log(math.exp(a - b) + 1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8021816","0.7973607","0.79658216","0.7952592","0.79182106","0.79182106","0.7760167","0.7711429","0.76088345","0.7591885","0.7590158","0.75868016","0.7528201","0.73942685","0.7390474","0.73903686","0.7328685","0.72765005","0.72420055","0.72006994","0.72006994","0.71377575","0.70212036","0.6997799","0.69637907","0.6940837","0.69333977","0.69318205","0.68592566","0.68592566","0.67969114","0.6675859","0.6617979","0.6615962","0.66078615","0.6603034","0.6597888","0.6597508","0.6586468","0.65842164","0.6564877","0.6524759","0.6517156","0.6511022","0.6504452","0.64778066","0.646568","0.6430413","0.64219344","0.64178544","0.63993204","0.63670176","0.6359441","0.6354048","0.6348607","0.6332747","0.6304004","0.6303369","0.6290719","0.62557435","0.62503266","0.6248834","0.62420124","0.624191","0.6228603","0.6226577","0.6205915","0.6198808","0.6197715","0.6185018","0.61768967","0.617539","0.61753774","0.61640275","0.6158592","0.61566776","0.6146247","0.6140678","0.6140678","0.6138874","0.6131006","0.6113801","0.61052096","0.61005974","0.6092551","0.6088051","0.6083018","0.60801816","0.60799843","0.60776454","0.60728914","0.6070564","0.6061605","0.6058643","0.6056248","0.60384995","0.60359585","0.60256785","0.60251576","0.602387"],"string":"[\n \"0.8021816\",\n \"0.7973607\",\n \"0.79658216\",\n \"0.7952592\",\n \"0.79182106\",\n \"0.79182106\",\n \"0.7760167\",\n \"0.7711429\",\n \"0.76088345\",\n \"0.7591885\",\n \"0.7590158\",\n \"0.75868016\",\n \"0.7528201\",\n \"0.73942685\",\n \"0.7390474\",\n \"0.73903686\",\n \"0.7328685\",\n \"0.72765005\",\n \"0.72420055\",\n \"0.72006994\",\n \"0.72006994\",\n \"0.71377575\",\n \"0.70212036\",\n \"0.6997799\",\n \"0.69637907\",\n \"0.6940837\",\n \"0.69333977\",\n \"0.69318205\",\n \"0.68592566\",\n \"0.68592566\",\n \"0.67969114\",\n \"0.6675859\",\n \"0.6617979\",\n \"0.6615962\",\n \"0.66078615\",\n \"0.6603034\",\n \"0.6597888\",\n \"0.6597508\",\n \"0.6586468\",\n \"0.65842164\",\n \"0.6564877\",\n \"0.6524759\",\n \"0.6517156\",\n \"0.6511022\",\n \"0.6504452\",\n \"0.64778066\",\n \"0.646568\",\n \"0.6430413\",\n \"0.64219344\",\n \"0.64178544\",\n \"0.63993204\",\n \"0.63670176\",\n \"0.6359441\",\n \"0.6354048\",\n \"0.6348607\",\n \"0.6332747\",\n \"0.6304004\",\n \"0.6303369\",\n \"0.6290719\",\n \"0.62557435\",\n \"0.62503266\",\n \"0.6248834\",\n \"0.62420124\",\n \"0.624191\",\n \"0.6228603\",\n \"0.6226577\",\n \"0.6205915\",\n \"0.6198808\",\n \"0.6197715\",\n \"0.6185018\",\n \"0.61768967\",\n \"0.617539\",\n \"0.61753774\",\n \"0.61640275\",\n \"0.6158592\",\n \"0.61566776\",\n \"0.6146247\",\n \"0.6140678\",\n \"0.6140678\",\n \"0.6138874\",\n \"0.6131006\",\n \"0.6113801\",\n \"0.61052096\",\n \"0.61005974\",\n \"0.6092551\",\n \"0.6088051\",\n \"0.6083018\",\n \"0.60801816\",\n \"0.60799843\",\n \"0.60776454\",\n \"0.60728914\",\n \"0.6070564\",\n \"0.6061605\",\n \"0.6058643\",\n \"0.6056248\",\n \"0.60384995\",\n \"0.60359585\",\n \"0.60256785\",\n \"0.60251576\",\n \"0.602387\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6233052"},"document_rank":{"kind":"string","value":"64"}}},{"rowIdx":84892,"cells":{"query":{"kind":"string","value":"Defines an initializer for the Xavier distribution. Specifically, the output should be sampled uniformly from [epsilon, epsilon] where epsilon = sqrt(6) / e.g., if shape = (2, 3), epsilon = sqrt(6 / (2 + 3)) This function will be used as a variable initializer."},"document":{"kind":"string","value":"def xavier_weight_init(shape):\n lim = np.sqrt(6. / sum(shape))\n out = np.random.uniform(-lim, lim, shape)\n\n return out"},"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 XavierInit(self):\n\n raw_std = (2 / (self.num_input + self.num_output))**0.5\n if 'relu' == self.act_function:\n init_std = raw_std * (2**0.5)\n elif 'sigmoid' == self.act_function:\n init_std = raw_std\n else:\n init_std = raw_std # * 4\n\n self.W = np.random.normal(0, init_std, (self.num_input, self.num_output))\n self.b = np.random.normal(0, init_std, (1, self.num_output))\n self.v_W = 0\n self.v_b = 0","def xavier_init(dims, uniform=True):\n n_inputs,n_outputs = dims\n if uniform:\n # 6 was used in the paper.\n init_range = np.sqrt(6.0 / (n_inputs + n_outputs))\n return tf.random_uniform(shape=dims,minval=-init_range, maxval=init_range)\n else:\n # 3 gives us approximately the same limits as above since this repicks\n # values greater than 2 standard deviations from the mean.\n stddev = np.sqrt(3.0 / (n_inputs + n_outputs))\n return tf.truncated_normal(shape=dims,stddev=stddev)","def xavier_initalisation(num_inputs, num_outputs, relus=False):\n\n relu_offset = 2.0 if relus else 1.0\n return np.random.normal(0, 1, size=(num_inputs, num_outputs)) / np.sqrt(num_inputs / relu_offset)","def xavier_init(size, gain=1.0):\n\tlow = -gain * np.sqrt(6.0 / np.sum(size))\n\thigh = gain * np.sqrt(6.0 / np.sum(size))\n\treturn np.random.uniform(low=low, high=high, size=size)","def xavier_init(fan_in, fan_out, constant=1):\n low = -constant * np.sqrt(6.0 / (fan_in + fan_out))\n high = constant * np.sqrt(6.0 / (fan_in + fan_out))\n return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)","def xavier_init(fan_in, fan_out, constant=1):\n low = -constant*np.sqrt(6/(fan_in + fan_out))\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\n return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)","def xavier_init(fan_in, fan_out, constant=1):\n low = -constant*np.sqrt(6/(fan_in + fan_out))\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\n return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)","def initial_x():\n\n # RANDOMLY GENERATES the INITIAL VALUES of the independent variables:\n temp = [uniform(1, cfg.n) for i in range(cfg.n)]\n\n return np.array(temp, dtype=np.float_)","def reset_parameters_xavier_uniform(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_xavier_uniform(n, p)","def reset_parameters_xavier_uniform(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_xavier_uniform(n, p)","def xavier_init(shape, constant=1):\n # https://stackoverflow.com/questions/33640581/how-to-do-xavier-initialization-on-tensorflow\n low = -constant*np.sqrt(1.0/np.sum(shape))\n high = constant*np.sqrt(1.0/np.sum(shape))\n return tf.random_uniform(shape, minval=low, maxval=high, dtype=tf.float32)","def xavier_init(fan_in, fan_out, constant=1):\n # https://stackoverflow.com/questions/33640581/how-to-do-xavier-initialization-on-tensorflow\n low = -constant*np.sqrt(6.0/(fan_in + fan_out))\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\n return tf.random_uniform((fan_in, fan_out),\n minval=low, maxval=high,\n dtype=tf.float32)","def xavier_init(fan_in, fan_out, constant=1):\n # https://stackoverflow.com/questions/33640581/how-to-do-xavier-initialization-on-tensorflow\n low = -constant*np.sqrt(6.0/(fan_in + fan_out)) \n high = constant*np.sqrt(6.0/(fan_in + fan_out))\n return tf.random_uniform((fan_in, fan_out), \n minval=low, maxval=high, \n dtype=tf.float32)","def xavier_init(fan_in=None, fan_out=None, shape=None, constant=1):\n if fan_in is None:\n fan_in = shape[0]\n fan_out = shape[1]\n # https://stackoverflow.com/questions/33640581/how-to-do-xavier-initialization-on-tensorflow\n low = -constant*np.sqrt(6.0/(fan_in + fan_out))\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\n return tf.random_uniform((fan_in, fan_out),\n minval=low, maxval=high,\n dtype=tf.float32)","def __initialize_psi__(self):\r\n\r\n x = self.train_x\r\n psi = np.std(x) * np.random.randn(1) + np.mean(x)\r\n return psi","def initialize_weights_xavier(self):\n\t\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\n\t\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]","def xavier_init(fan_in: int, fan_out: int, const: int= 1) -> tf.Tensor:\n low = -const * np.sqrt(6.0 / (fan_in + fan_out))\n high = const * np.sqrt(6.0 / (fan_in + fan_out))\n return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high)","def init_with_xavier_uniform(n, p):\n if p.dim() == 1:\n nn.init.constant_(p, 0.0)\n logger.info('Initialize %s with %s / %.3f' % (n, 'constant', 0.0))\n elif p.dim() in [2, 3, 4]:\n nn.init.xavier_uniform_(p)\n logger.info('Initialize %s with %s' % (n, 'xavier_uniform'))\n else:\n raise ValueError(n)","def reset_parameters(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_xavier_uniform(n, p)","def reset_parameters(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_xavier_uniform(n, p)","def reset_parameters_xavier_uniform(self):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n for conv_layer in [self.pointwise_conv1, self.pointwise_conv2, self.depthwise_conv]:\n for n, p in conv_layer.named_parameters():\n init_with_xavier_uniform(n, p)","def reset_parameters_xavier_uniform(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)","def init_weight(self):\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)","def reset_parameters_xavier_uniform(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)","def WeightInitializer():\n return np.random.uniform(-1, 1)","def reset_parameters_xavier_uniform(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n if self.conv1d is not None:\n for n, p in self.conv1d.named_parameters():\n init_with_xavier_uniform(n, p)","def xavier_uniform(weight_shape):\n if len(weight_shape) == 4:\n fW, fH, fC, num_fitls = weight_shape\n return np.random.uniform(-np.sqrt(6 / (fW*fH*fC + num_fitls)), np.sqrt(6 / (fW*fH*fC + num_fitls)), weight_shape)\n num_input, num_output = weight_shape\n return np.random.uniform(-np.sqrt(6 / (num_input + num_output)), np.sqrt(6 / (num_input + num_output)), weight_shape)","def initiategaussian(sd, x0):\n y = np.exp(-x**2/(2*sd**2))\n return y","def init_vector(self,x,dim):\n if dim == \"noise\":\n self.prior.sqrtM.init_vector(x,1)\n else:\n self.prior.init_vector(x,dim)","def xavier_init(module, gain=1, bias=0, distribution='normal'):\n # assert distribution in ['uniform', 'normal']\n if distribution == 'uniform':\n nn.init.xavier_uniform_(module.weight, gain=gain)\n else:\n nn.init.xavier_normal_(module.weight, gain=gain)\n if hasattr(module, 'bias') and module.bias is not None:\n nn.init.constant_(module.bias, bias)","def reset_parameters(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)\n if self.xl_like:\n nn.init.xavier_uniform_(self.w_pos.weight)\n if bias:\n nn.init.constant_(self.w_pos.bias, 0.0)","def test_xavier_uniform():\n tf.reset_default_graph()\n tf.random.set_random_seed(0)\n xuniform_class = INITIALIZER_REGISTRY['xavier']\n xuniform_obj = xuniform_class({\"uniform\":True})\n tf_init = xuniform_obj.get_entity_initializer(init_type='tf')\n var1 = tf.get_variable(shape=(200, 1000), initializer=tf_init, name=\"var1\")\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n tf_var = sess.run(var1)\n np_var = xuniform_obj.get_entity_initializer(200, 1000, init_type='np')\n # print(np.min(np_var), np.max(np_var))\n # print(np.min(tf_var), np.max(tf_var))\n assert(np.round(np.min(np_var),2)==np.round(np.min(tf_var),2))\n assert(np.round(np.max(np_var),2)==np.round(np.max(tf_var),2))","def construct_random_initial(self):\n x = np.random.random((self._crv_size, self._bound))\n return x","def reset_parameters(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)","def reset_parameters(self, bias):\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\n if bias:\n nn.init.constant_(self.w_key.bias, 0.0)\n nn.init.constant_(self.w_value.bias, 0.0)\n nn.init.constant_(self.w_query.bias, 0.0)\n nn.init.xavier_uniform_(self.w_out.weight)\n if bias:\n nn.init.constant_(self.w_out.bias, 0.0)","def __init__(self, x_init = 0., x_dinit = 0., alpha = 0.1, beta = 0.1):\n self.xhat = x_init\n self.xhatd = x_dinit\n self.alpha = alpha\n self.beta = beta\n self.prev_time = 0.","def initializeDistribution(self):\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.low)\n self.lowerBound = self.low\n self.upperBound = sys.float_info.max\n else:\n if self.lowerBoundUsed == False:\n self.lowerBound = self.low\n if self.upperBoundUsed == False:\n self.upperBound = sys.float_info.max\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.lowerBound,self.upperBound,self.low)","def __init__(self, x):\n self.W = np.zeros((x+1,10))\n self.alpha = 0.00000001\n self.epochs = 100\n self.reg_const = 0.01","def __init__(self, dim, rn, gammak, sine=False, feature_generator=None):\n\n\t\tself.dim = dim\n\t\tself.rn = rn\n\t\tself.gammak = gammak\n\n\t\tif feature_generator is None:\n\t\t\tself.feature_generator = GaussianRandomFeatures(self.dim, self.rn, self.gammak, sine=sine)\n\t\telse: self.feature_generator = feature_generator","def __init__(self):\n self.expvalue = np.zeros(10)\n self.iter = np.zeros(10)\n self.epsilon = 0.1","def __init__(self, init_pos, init_stdev, num_particles, sense_noise):\n self.particles = np.random.multivariate_normal(\n init_pos, [[init_stdev**2, 0], [0, init_stdev**2]], num_particles)\n self.weights = np.array(\n [1. / num_particles for _ in range(num_particles)])\n self.n = num_particles\n self.sense_noise = sense_noise","def _WeightInit(self, stddev):\n return init_ops.truncated_normal_initializer(stddev=stddev)","def __init__(self, x_axis, y_axis, input_dimension, sigma, learning_rate, random_seed=3):\n # Creating a random generator for random values; for initializing weights\n self.random_generator = np.random.RandomState(random_seed)\n \n self.x_axis = x_axis\n self.y_axis = y_axis\n self.input_dimension = input_dimension\n self.sigma = sigma\n self.learning_rate = learning_rate\n self.weights = np.array([[[0 for x in range(self.input_dimension)] for x in range(self.x_axis)] for x in range(y_axis)], dtype=float)","def xavier_uniform_init(tensor, gain=1., random_state=None):\n # type: (Tensor, float) -> Tensor\n\n fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)\n std = gain * math.sqrt(2.0 / float(fan_in + fan_out))\n a = math.sqrt(3.0) * std # Calculate uniform bounds from standard deviation\n\n uniform_init(tensor, -a, a, random_state)\n return tensor","def build_initial(domain):\n return random_candidate_float(domain)","def init_weights(n_input_layer, n_hidden_layer, n_hidden_layer_2, n_output_layer, xavier_init):\n W1, W2, W3 = None, None, None\n \n if xavier_init: # Checks if Xavier initialisation is wanted\n # Initialises weights depending on number of layers present using:\n # Normally distributed random number * square_root(1 / number of input neurons to that layer)\n if n_hidden_layer > 0:\n W1 = np.random.randn(n_hidden_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\n\n if n_hidden_layer_2 > 0:\n W2 = np.random.randn(n_hidden_layer_2, n_hidden_layer) * np.sqrt(1 / (n_hidden_layer))\n W3 = np.random.randn(n_output_layer, n_hidden_layer_2) * np.sqrt(1 / (n_hidden_layer_2))\n\n else:\n W2 = np.random.randn(n_output_layer, n_hidden_layer) * np.sqrt(1 / (n_hidden_layer))\n\n else:\n W1 = np.random.randn(n_output_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\n\n else:\n # Weights are randomly picked from a uniform distribution between 0 and 1\n # They are normalized by making sure the weights sum to 1\n # Uses different configurations depending on number of layers required\n if n_hidden_layer > 0:\n W1 = np.random.uniform(0,1,(n_hidden_layer, n_input_layer))\n W1 = np.divide(W1,np.matlib.repmat(np.sum(W1,1)[:,None],1,n_input_layer))\n \n if n_hidden_layer_2 > 0:\n W2=np.random.uniform(0,1,(n_hidden_layer_2,n_hidden_layer))\n W2=np.divide(W2,np.matlib.repmat(np.sum(W2,1)[:,None],1,n_hidden_layer))\n\n W3=np.random.uniform(0,1,(n_output_layer,n_hidden_layer_2))\n W3=np.divide(W3,np.matlib.repmat(np.sum(W3,1)[:,None],1,n_hidden_layer_2))\n\n else:\n W2 = np.random.uniform(0,1,(n_output_layer, n_hidden_layer))\n W2 = np.divide(W2,np.matlib.repmat(np.sum(W2,1)[:,None],1,n_hidden_layer))\n\n else:\n W1 = np.random.randn(n_output_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\n\n return W1, W2, W3","def sampling(self, args):\n self.z_mean, self.z_log_var = args\n batch = K.shape(self.z_mean)[0]\n dim = K.int_shape(self.z_mean)[1]\n epsilon = K.random_uniform(shape=(batch, dim))\n \n return self.z_mean + K.exp(0.5 * self.z_log_var) * epsilon","def __init__(self):\n self.counts = [0] * 10\n self.values = [2000] * 10\n self.epsilon = 0.1","def test_xavier_normal():\n tf.reset_default_graph()\n tf.random.set_random_seed(0)\n xnormal_class = INITIALIZER_REGISTRY['xavier']\n xnormal_obj = xnormal_class({\"uniform\":False})\n tf_init = xnormal_obj.get_entity_initializer(init_type='tf')\n var1 = tf.get_variable(shape=(2000, 100), initializer=tf_init, name=\"var1\")\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n tf_var = sess.run(var1)\n np_var = xnormal_obj.get_entity_initializer(2000, 100, init_type='np')\n # print(np.mean(np_var), np.std(np_var))\n # print(np.mean(tf_var), np.std(tf_var))\n assert(np.round(np.mean(np_var),2)==np.round(np.mean(tf_var),2))\n assert(np.round(np.std(np_var),2)==np.round(np.std(tf_var),2))","def random_init(self, shape):\n return np.random.randn(shape[0],shape[1])*0.01","def _sample_schechter(x0, alpha, x_min, size=100, max_iter=1000):\n out = []\n n = 0\n num_iter = 0\n while (n<size) & (num_iter<max_iter):\n x = np.random.gamma(scale=x0, shape=alpha+2, size=size)\n x = x[x>x_min]\n u = np.random.uniform(size=x.size)\n x = x[u<x_min/x]\n out.append(x)\n n+=x.size\n num_iter += 1\n\n if num_iter >= max_iter:\n msg = (\"The maximum number of iterations reached.\",\n \"Random variates may not be representitive.\",\n \"Try increasing `max_iter`.\")\n print(msg)\n\n return np.concatenate(out)[:size]","def _init_weights(n_rows, n_cols, std_dev=0.5):\n weights = np.random.randn(n_rows, n_cols) * std_dev\n return weights","def weights_initializer(self):\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]","def xavier_normal(weight_shape):\n if len(weight_shape) == 4:\n fW, fH, fC, num_fitls = weight_shape\n return np.random.normal(0, np.sqrt(2 / (fW*fH*fC + num_fitls)), weight_shape)\n num_input, num_output = weight_shape\n return np.random.normal(0, np.sqrt(2 / (num_input + num_output)), weight_shape)","def __init__(self, alpha=1.0, epsilon=0.05, gamma=0.8, numTraining = 10):\n self.alpha = float(alpha)\n self.epsilon = float(epsilon)\n self.discount = float(gamma)\n self.numTraining = int(numTraining)","def __init__(self, size, parameters):\n\n self.weights = self.init_weights(size)\n self.alpha = parameters['alpha']\n self.epsilon = parameters['epsilon']\n self.gamma = parameters['gamma']\n self.value = 0.0 #np.random.random()","def __init__(self, alpha=1.0, epsilon=0.05, gamma=0.8, numTraining=10):\n self.alpha = float(alpha)\n self.epsilon = float(epsilon)\n self.discount = float(gamma)\n self.numTraining = int(numTraining)","def _initialize_wxf(self, nvisx, nfac, rng=None, irange=None):\n if rng is None:\n rng = self.rng\n if irange is None:\n irange = self.irange\n self.wxf = sharedX(\n (rng.randn(nvisx, nfac)) * irange,\n name='wxf',\n borrow=True\n )","def gen_x(self, x_func):\n self.x_title, self.x = x_func(self.sample_size, self.generator)","def sampling(self, args):\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.shape(z_mean)[1]\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def init_variables():\n weights = np.random.normal(size=2)\n bias = 0\n return weights, bias","def __init__(self):\n self.counts = [0] * 10\n self.values = [0] * 10\n self.epsilon = 0.1","def caffe2_xavier_init(module, bias=0):\n kaiming_init(\n module,\n a=1,\n mode='fan_in',\n nonlinearity='leaky_relu',\n distribution='uniform')","def sampling(args):\n z_mean, z_log_sigma = args\n epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim), mean = 0., stddev=0.1)\n return z_mean + K.exp(z_log_sigma) * epsilon","def __init__(self, x, U, KE=1, periodic=True, q=0, **kwargs):\n self.x = x\n self.U = U\n self.KE = KE\n self.periodic = periodic\n self.q = q\n Schrodinger.__init__(self, **kwargs)","def setUp(self):\n shape = RNG.integers(5, 50)\n periods = self.periods = RNG.normal() * 3\n freq = periods / shape\n amp = RNG.normal()\n offset = RNG.normal()\n phase = (RNG.normal() - 1 / 2) * 5 / 3 * np.pi\n p_gt = self.p_gt = (amp, freq, phase, offset)\n x = self.x = np.arange(shape)\n self.data = sine(x, *p_gt)","def _initialize_gaussians(self, n_gaussians):\n if self.gaussian_init == 'manual':\n gaussians = torch.Tensor([\n list(product([0.25, 0.5, 0.75], repeat=2)) +\n [(0.5, 0.25), (0.5, 0.5), (0.5, 0.75)] +\n [(0.25, 0.5), (0.5, 0.5), (0.75, 0.5)] +\n [(0.5, 0.5)],\n [(-1.5, -1.5)] * 9 + [(0, -1.5)] * 3 + [(-1.5, 0)] * 3 +\n [(0, 0)],\n ]).permute(1, 2, 0)\n\n elif self.gaussian_init == 'random':\n with torch.no_grad():\n gaussians = torch.stack([\n torch.randn(\n n_gaussians, 2, dtype=torch.float) * .1 + 0.5,\n torch.randn(\n n_gaussians, 2, dtype=torch.float) * .2 - 1,],\n dim=2)\n\n else:\n raise NotImplementedError\n\n gaussians = nn.Parameter(gaussians, requires_grad=True)\n return gaussians","def generate_initial_state(self, x):\n\n if self.initial_state is None:\n x[:] = 0\n return x\n else:\n x[:] = self.initial_state(size=(self._num_neurons, 1))\n return x","def random(self, size, X):\n if (self.p == 1) and (self.f0 == 0):\n return self.dist.qf(uniform.rvs(size=size), *self.params) + self.gamma\n elif (self.p != 1) and (self.f0 == 0):\n n_obs = np.random.binomial(size, self.p)\n\n f = self.dist.qf(uniform.rvs(size=n_obs), *self.params) + self.gamma\n s = np.ones(np.array(size) - n_obs) * np.max(f) + 1\n\n return fs_to_xcn(f, s)\n\n elif (self.p == 1) and (self.f0 != 0):\n n_doa = np.random.binomial(size, self.f0)\n\n x0 = np.zeros(n_doa) + self.gamma\n x = self.dist.qf(uniform.rvs(size=size - n_doa), *self.params) + self.gamma\n x = np.concatenate([x, x0])\n np.random.shuffle(x)\n\n return x\n else:\n N = np.random.multinomial(1, [self.f0, self.p - self.f0, 1. - self.p], size).sum(axis=0)\n N = np.atleast_2d(N)\n n_doa, n_obs, n_cens = N[:, 0], N[:, 1], N[:, 2]\n x0 = np.zeros(n_doa) + self.gamma\n x = self.dist.qf(uniform.rvs(size=n_obs), *self.params) + self.gamma\n f = np.concatenate([x, x0])\n s = np.ones(n_cens) * np.max(f) + 1\n # raise NotImplementedError(\"Combo zero-inflated and lfp model not yet supported\")\n return fs_to_xcn(f, s)","def __init__(self, bandits: List[Bandit], epsilon:float = None):\n self.bandits = bandits\n self.epsilon = epsilon\n # mu_pri and var_pri are hypermaterers for prior distribution\n self.mu_pri = np.zeros(len(self.bandits))\n self.var_pri = np.ones(len(self.bandits))*5\n # mu and var are hyperparameters for posterior distribution\n self.mu = self.mu_pri\n self.var = self.var_pri\n self.var0 = 1 # 1 is taken but any can be taken no prob upto a limit constant of inintial distribution\n self.logging = Logging()","def create_initializer(initializer_range=0.02):\n return tf.truncated_normal_initializer(stddev=initializer_range)","def __initialise(self, X, args):\n\t\t\t#getting centroids\n\t\tindices = np.random.choice(range(X.shape[0]), size = self.K, replace = False)\n\t\tcentroids = X[indices,:] #(K,D) #K centroids are chosen\n\t\t\t#getting variances\n\t\tvar = np.var(X, axis = 0) #(D,)\n\n\t\t\t#computing initial responsibilities\n\t\tr_0 = np.zeros((X.shape[0],self.K))\n\t\tfor k in range(self.K):\n\t\t\tr_0[:,k] = np.divide(np.square(X - centroids[k,:]), var)[:,0] + 1e-10\n\t\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\n\n\t\tself.gating.fit(X,r_0, *args)\n\n\t\treturn r_0","def create_initializer(initializer_range=0.02):\n return tf.truncated_normal_initializer(stddev=initializer_range)","def create_initializer(initializer_range=0.02):\n return tf.truncated_normal_initializer(stddev=initializer_range)","def __init__(self, initAlpha=0.01, factor=0.25, dropEvery=10):\n self.initAlpha = initAlpha\n self.factor = factor\n self.dropEvery = dropEvery\n pass","def __init__(self, n_in, n_out):\n self.W = np.random.randn(n_in, n_out) * 0.1\n self.b = np.zeros(n_out)","def _init_weights(self):\n nn.init.xavier_normal_(self.out.weight)","def sampling(args):\n t_mean, t_log_var = args\n # YOUR CODE HERE\n epsilon = K.random_normal(t_mean.shape)\n z = epsilon * K.exp(0.5 * t_log_var) + t_mean\n return z","def generate_stat(sample_size, sparsity = 0, amplitude = 0, sigma = 1):\n var = generate_variable(sample_size, sparsity, amplitude, sigma)\n y_obs = var[0]\n \n \"\"\" \n f is equal to -X(t,theta) and we will minimize f (max. X)\n \"\"\"\n def f(x):\n \"\"\" \n f(x)=-X(t,theta) where x[0]=t and x[1]=theta\n \"\"\"\n res = np.real(np.exp(-1j*x[1])*\\\n sum(y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\n for k in range(-sample_size,sample_size+1))) \n res = -res/np.sqrt(2*sample_size+1) \n return res\n \n def grad_f(x):\n \"\"\" \n gradient of f\n \"\"\"\n res1 = np.real(np.exp(-1j*x[1])*\\\n sum(1j*k*y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\n for k in range(-sample_size,sample_size+1)))\n res1 = -res1/np.sqrt(2*sample_size+1)\n \n res2 = np.real(np.exp(-1j*x[1])*\\\n sum(-1j*y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\n for k in range(-sample_size,sample_size+1)))\n res2 = -res2/np.sqrt(2*sample_size+1)\n return np.array([res1, res2])\n \n #% Minimizing f\n \n \"\"\" \n we minimize on [0, 2pi]^2\n \"\"\"\n bnds = ((0, 2*np.pi), (0, 2*np.pi))\n \n \"\"\" \n We begin by a greedy search of the initialization point over a grid of size 126^2\n the initialization point is init\n \"\"\"\n x = y = np.arange(0, 2*np.pi, 0.05)\n steps = 126\n X, Y = np.meshgrid(x, y)\n val = np.array([f([x,y]) for x,y in zip(np.ravel(X), np.ravel(Y))])\n init = np.argmin(val)\n x1 = init%steps\n x2 = (init-x1)/steps\n init = [x1*0.05, x2*0.05]\n \n \"\"\" \n we minimize f...\n \"\"\"\n result = sco.minimize(f, init, method=\"L-BFGS-B\",\\\n jac=grad_f, bounds=bnds, tol=1e-15)\n \n \"\"\" \n (t1,theta1) is the argmax of X(t, theta) and l1=$\\lambda_1$\n \"\"\"\n t1 = result.x[0]\n theta1 = result.x[1]\n l1 = -f([t1,theta1])\n \n \n \"\"\" \n Function g(x) is equal to (X(t1,theta1)-X(x))/(1-rho((t1,theta1)-x))\n \"\"\"\n def g(x):\n a0 = x[0]-t1\n a1 = x[1]-theta1\n N = 2*sample_size+1\n \n vec = np.array([a0,a1])\n r = np.linalg.norm(vec)\n \"\"\" \n the value for r=0 is set to l1 (note that r=0 corresponds to x=(t1,theta1))\n \"\"\" \n res = l1 \n \n if (0<r) & (r<0.00001):\n \"\"\" \n we look a values near (t1,theta1) for which an indetermination occurs\n \"\"\" \n alpha= np.arccos(np.clip(a0/np.sqrt(a0**2+a1**2), -1.0, 1.0))\n u0 = np.cos(alpha)\n u1 = np.sin(alpha)\n \"\"\" \n u0,u1 defines the direction (unit vector)\n \"\"\"\n denom = sum((k*np.cos(alpha)-np.sin(alpha))**2*\\\n (np.sinc((r*(k*np.cos(alpha)-np.sin(alpha)))/(2*np.pi)))**2\\\n for k in range(-sample_size,sample_size+1))/N\n \"\"\" \n denom computes the denominator\n \"\"\"\n \n# \"\"\" \n# We use simpson rule for the numerator\n# \"\"\"\n# h = np.linspace(0,1,500)\n# \n# b0 = t1 + h*a0\n# b1 = theta1 + h*a1\n# \n# value = (1-h)*(u0**2*\\\n# np.real(np.exp(-1j*b1)*sum(-k**2*y_obs[k+sample_size]*np.exp(1j*k*b0) \\\n# for k in range(-sample_size,sample_size+1)))\\\n# +2*u0*u1*\\\n# np.real(np.exp(-1j*b1)*sum(k*y_obs[k+sample_size]*np.exp(1j*k*b0) \\\n# for k in range(-sample_size,sample_size+1)))\\\n# +u1**2*\\\n# np.real(np.exp(-1j*b1)*sum((-1)*y_obs[k+sample_size]*np.exp(1j*k*b0) \\\n# for k in range(-sample_size,sample_size+1)))) \n# value = value/np.sqrt(N)\n# \n# num = sci.simps(value, h)\n \n \"\"\" \n we use a quadrature for the numerator\n \"\"\" \n fun_int = lambda w: (1-w)*(u0**2*\\\n np.real(np.exp(-1j*(theta1+w*a1))*\\\n sum(-k**2*y_obs[k+sample_size]*np.exp(1j*k*(t1+w*a0)) \\\n for k in range(-sample_size,sample_size+1)))\\\n +2*u0*u1*\\\n np.real(np.exp(-1j*(theta1+w*a1))*\\\n sum(k*y_obs[k+sample_size]*np.exp(1j*k*(t1+w*a0)) \\\n for k in range(-sample_size,sample_size+1)))\\\n +u1**2*\\\n np.real(np.exp(-1j*(theta1+w*a1))*\\\n sum((-1)*y_obs[k+sample_size]*np.exp(1j*k*(t1+w*a0)) \\\n for k in range(-sample_size,sample_size+1)))) \n \n num = np.mean(sci.quad(fun_int, 0, 1, epsabs=1e-15, epsrel=1e-15, limit=1000))\n \n res = -num/denom\n \n if (r>=0.00001):\n \"\"\" \n we look a values far (t1,theta1) for which there is no indetermination\n \"\"\" \n res = (l1+f(x))/(1-(np.cos(a1)*dirichlet(a0,N)/N))\n \n return res \n \"\"\" \n we minimize g on [0, 2pi]^2 an dwe llok for the initialization point\n \"\"\"\n val2 = np.array([g([x,y]) for x,y in zip(np.ravel(X), np.ravel(Y))])\n init2 = np.argmin(val2)\n x1 = init2%steps\n x2 = (init2-x1)/steps\n init2 = [x1*0.05, x2*0.05] \n result2 = sco.minimize(g, init2, method=\"L-BFGS-B\", bounds=bnds, tol=1e-15) \n \"\"\" \n argmin of g\n \"\"\"\n t2 = result2.x[0]\n theta2 = result2.x[1] \n \"\"\" \n value of lambda_2\n \"\"\"\n l21 = l1-result2.fun \n a0 = t2-t1\n a1 = theta2-theta1\n N = 2*sample_size+1\n l22 = l1-(l1+f([t2,theta2]))/(1-(np.cos(a1)*dirichlet(a0,N)/N))\n l2 = max(l21,l22)\n \"\"\" \n we compute the statistic\n \"\"\"\n alpha1 = (1/3)*sample_size*(sample_size+1)\n alpha2 = (1/np.sqrt(N))*\\\n sum((k**2-alpha1)*\\\n np.real(y_obs[k+sample_size]*np.exp(1j*(k*t1-theta1))) \\\n for k in range(-sample_size,sample_size+1))\n alpha3 = (1/np.sqrt(N))*sum(k*np.real(y_obs[k+sample_size]*\\\n np.exp(1j*(k*t1-theta1))) for k in range(-sample_size,sample_size+1)) \n stat = (sigma*(alpha1*l1+alpha2)*scs.norm.pdf(l1/sigma)+\\\n (alpha1*sigma**2-alpha3**2)*(1-scs.norm.cdf(l1/sigma)))/\\\n (sigma*(alpha1*l2+alpha2)*scs.norm.pdf(l2/sigma)+\\\n (alpha1*sigma**2-alpha3**2)*(1-scs.norm.cdf(l2/sigma))) \n \n return stat","def _initialize_fembv_varx(X, n_components, init='random',\n u=None, memory=0, random_state=None):\n if init is None:\n init = 'random'\n\n if init == 'random':\n return _initialize_fembv_varx_random(\n X, n_components, u=u, memory=memory, random_state=random_state)\n else:\n raise ValueError(\n 'Invalid init parameter: got %r instead of one of %r' %\n (init, FEMBV_VARX_INITIALIZATION_METHODS))","def initial_guess_x0(self) -> npt.NDArray:\n if self._background is not None:\n return np.array(\n [np.random.uniform(lb, ub) for lb, ub in self.bounds]\n )\n return np.array(\n [np.random.uniform(lb, ub) for lb, ub in self.bounds * 2]\n )","def _setup(self, X: np.ndarray):\n self._sigma = self._a * np.eye(X.shape[1])\n self._phi = norm.ppf(self._eta)\n self._psi = 1 + (self._phi ** 2) / 2\n self._xi = 1 + self._phi ** 2","def __init__(self, initial_std=0.1, delta=0.1):\n self.initial_std = initial_std\n self.delta = delta\n # Initialize the current standard deviation\n self.cur_std = initial_std","def init_weights(self):\n \n self.w = np.random.randn(self.D) / np.sqrt(self.D)","def xinit(self, xshape):\n\n return np.zeros(xshape, dtype=self.dtype)","def sampling(args):\r\n z_mean, z_log_var = args\r\n # K is the keras backend\r\n batch = K.shape(z_mean)[0]\r\n dim = K.int_shape(z_mean)[1]\r\n # by default, random_normal has mean=0 and std=1.0\r\n epsilon = K.random_normal(shape=(batch, dim))\r\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\r\n z_mean, z_log_var = args\r\n # K is the keras backend\r\n batch = K.shape(z_mean)[0]\r\n dim = K.int_shape(z_mean)[1]\r\n # by default, random_normal has mean=0 and std=1.0\r\n epsilon = K.random_normal(shape=(batch, dim))\r\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.shape(z_mean)[1]\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def _initialize_wyf(self, nvisy, nfac, rng=None, irange=None):\n if rng is None:\n rng = self.rng\n if irange is None:\n irange = self.irange\n self.wyf = sharedX(\n (rng.randn(nvisy, nfac)) * irange,\n name='wyf',\n borrow=True\n )","def __init__(self, epsilon=1e-14):\n self.epsilon = epsilon","def __init__(self):\n super().__init__()\n self.lambdaVar = 1.0\n self.low = 0.0\n self.type = 'Exponential'\n self.distType = 'Continuous'\n self.hasInfiniteBound = True\n self.compatibleQuadrature.append('CDF')\n self.preferredQuadrature = 'CDF'\n self.preferredPolynomials = 'CDF'","def noise(x: np.ndarray) -> np.ndarray:\n\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)","def _generate_signal(self):\n x = np.arange(self.n, dtype='float')\n resample = np.random.rand(self.n) >= self.proba\n resample[0] = True # randomly initialize first sample\n x[resample] = np.random.randn(np.sum(resample))\n for i in x[~resample]:\n x[int(i)] = x[int(i)-1]\n return x","def normc_initializer(std=1.0):\n def _initializer(shape, dtype=None, partition_info=None): #pylint: disable=W0613\n out = np.random.randn(*shape).astype(np.float32)\n out *= std / np.sqrt(np.square(out).sum(axis=0, keepdims=True))\n return tf.constant(out)\n return _initializer","def init_weights(self, dims):\n self.W = np.random.normal(size=dims) * 0.0001","def __init__(self, mean_function: Callable, lower: Union[float, int], upper: Union[float, int],\n sample_size: int, seed: Optional[float] = None):\n super().__init__()\n np.random.seed(seed)\n assert callable(mean_function), \"intensity_function must be a callable!\"\n try:\n mean_function(np.array([1, 2]))\n self.mean_function: Callable = mean_function\n except ValueError:\n warn('Force vectorization of intensity function')\n self.mean_function: Callable = np.vectorize(mean_function)\n assert isinstance(upper, (int, float)), \"Wrong type of upper limit!\"\n assert isinstance(lower, (int, float)), \"Wrong type of lower limit!\"\n if seed is not None:\n assert isinstance(seed, (int, float)), \"Wrong type of seed!\"\n if np.sum(self.mean_function(np.random.uniform(lower, upper, int(1e6))) < 0) > 0:\n raise ValueError(\"Mean function must be greater than or equal to 0!\")\n if lower >= upper:\n raise ValueError(\"Wrong interval is specified! (lower {} >= upper {})\".format(lower, upper))\n self.lower: Union[float, int] = lower\n self.upper: Union[float, int] = upper\n self.scaler: Union[float, int] = mean_function(upper)\n self.sample_size: np.ndarray = np.random.poisson(lam=self.scaler * sample_size, size=1)","def generate_gaussian():\n amp = 10 * numpy.random.chisquare(3)\n width = numpy.random.chisquare(3)\n mean = numpy.random.uniform(-10 + width, 10 - width)\n x = numpy.linspace(-10, 10, 500)\n y = amp * numpy.exp(- (x - mean) ** 2 / width ** 2)\n add_noise(y, 0.1)\n return x, y","def __init__(self, initial_stddev=0.1, desired_action_stddev=0.2, adaptation_coefficient=1.01):\n self.initial_stddev = initial_stddev\n self.desired_action_stddev = desired_action_stddev\n self.adaptation_coefficient = adaptation_coefficient\n\n self.current_stddev = initial_stddev","def sampling(args):\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean=0 and std=1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(-0.5 * z_log_var) * epsilon","def get_initial_guess():\n x0 = np.zeros(6)\n x0[0] = 1\n x0[3] = 1\n return x0"],"string":"[\n \"def XavierInit(self):\\n\\n raw_std = (2 / (self.num_input + self.num_output))**0.5\\n if 'relu' == self.act_function:\\n init_std = raw_std * (2**0.5)\\n elif 'sigmoid' == self.act_function:\\n init_std = raw_std\\n else:\\n init_std = raw_std # * 4\\n\\n self.W = np.random.normal(0, init_std, (self.num_input, self.num_output))\\n self.b = np.random.normal(0, init_std, (1, self.num_output))\\n self.v_W = 0\\n self.v_b = 0\",\n \"def xavier_init(dims, uniform=True):\\n n_inputs,n_outputs = dims\\n if uniform:\\n # 6 was used in the paper.\\n init_range = np.sqrt(6.0 / (n_inputs + n_outputs))\\n return tf.random_uniform(shape=dims,minval=-init_range, maxval=init_range)\\n else:\\n # 3 gives us approximately the same limits as above since this repicks\\n # values greater than 2 standard deviations from the mean.\\n stddev = np.sqrt(3.0 / (n_inputs + n_outputs))\\n return tf.truncated_normal(shape=dims,stddev=stddev)\",\n \"def xavier_initalisation(num_inputs, num_outputs, relus=False):\\n\\n relu_offset = 2.0 if relus else 1.0\\n return np.random.normal(0, 1, size=(num_inputs, num_outputs)) / np.sqrt(num_inputs / relu_offset)\",\n \"def xavier_init(size, gain=1.0):\\n\\tlow = -gain * np.sqrt(6.0 / np.sum(size))\\n\\thigh = gain * np.sqrt(6.0 / np.sum(size))\\n\\treturn np.random.uniform(low=low, high=high, size=size)\",\n \"def xavier_init(fan_in, fan_out, constant=1):\\n low = -constant * np.sqrt(6.0 / (fan_in + fan_out))\\n high = constant * np.sqrt(6.0 / (fan_in + fan_out))\\n return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)\",\n \"def xavier_init(fan_in, fan_out, constant=1):\\n low = -constant*np.sqrt(6/(fan_in + fan_out))\\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\\n return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)\",\n \"def xavier_init(fan_in, fan_out, constant=1):\\n low = -constant*np.sqrt(6/(fan_in + fan_out))\\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\\n return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32)\",\n \"def initial_x():\\n\\n # RANDOMLY GENERATES the INITIAL VALUES of the independent variables:\\n temp = [uniform(1, cfg.n) for i in range(cfg.n)]\\n\\n return np.array(temp, dtype=np.float_)\",\n \"def reset_parameters_xavier_uniform(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for n, p in self.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def reset_parameters_xavier_uniform(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for n, p in self.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def xavier_init(shape, constant=1):\\n # https://stackoverflow.com/questions/33640581/how-to-do-xavier-initialization-on-tensorflow\\n low = -constant*np.sqrt(1.0/np.sum(shape))\\n high = constant*np.sqrt(1.0/np.sum(shape))\\n return tf.random_uniform(shape, minval=low, maxval=high, dtype=tf.float32)\",\n \"def xavier_init(fan_in, fan_out, constant=1):\\n # https://stackoverflow.com/questions/33640581/how-to-do-xavier-initialization-on-tensorflow\\n low = -constant*np.sqrt(6.0/(fan_in + fan_out))\\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\\n return tf.random_uniform((fan_in, fan_out),\\n minval=low, maxval=high,\\n dtype=tf.float32)\",\n \"def xavier_init(fan_in, fan_out, constant=1):\\n # https://stackoverflow.com/questions/33640581/how-to-do-xavier-initialization-on-tensorflow\\n low = -constant*np.sqrt(6.0/(fan_in + fan_out)) \\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\\n return tf.random_uniform((fan_in, fan_out), \\n minval=low, maxval=high, \\n dtype=tf.float32)\",\n \"def xavier_init(fan_in=None, fan_out=None, shape=None, constant=1):\\n if fan_in is None:\\n fan_in = shape[0]\\n fan_out = shape[1]\\n # https://stackoverflow.com/questions/33640581/how-to-do-xavier-initialization-on-tensorflow\\n low = -constant*np.sqrt(6.0/(fan_in + fan_out))\\n high = constant*np.sqrt(6.0/(fan_in + fan_out))\\n return tf.random_uniform((fan_in, fan_out),\\n minval=low, maxval=high,\\n dtype=tf.float32)\",\n \"def __initialize_psi__(self):\\r\\n\\r\\n x = self.train_x\\r\\n psi = np.std(x) * np.random.randn(1) + np.mean(x)\\r\\n return psi\",\n \"def initialize_weights_xavier(self):\\n\\t\\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\\n\\t\\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]\",\n \"def xavier_init(fan_in: int, fan_out: int, const: int= 1) -> tf.Tensor:\\n low = -const * np.sqrt(6.0 / (fan_in + fan_out))\\n high = const * np.sqrt(6.0 / (fan_in + fan_out))\\n return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high)\",\n \"def init_with_xavier_uniform(n, p):\\n if p.dim() == 1:\\n nn.init.constant_(p, 0.0)\\n logger.info('Initialize %s with %s / %.3f' % (n, 'constant', 0.0))\\n elif p.dim() in [2, 3, 4]:\\n nn.init.xavier_uniform_(p)\\n logger.info('Initialize %s with %s' % (n, 'xavier_uniform'))\\n else:\\n raise ValueError(n)\",\n \"def reset_parameters(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for n, p in self.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def reset_parameters(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for n, p in self.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def reset_parameters_xavier_uniform(self):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n for conv_layer in [self.pointwise_conv1, self.pointwise_conv2, self.depthwise_conv]:\\n for n, p in conv_layer.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def reset_parameters_xavier_uniform(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\",\n \"def init_weight(self):\\r\\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\",\n \"def reset_parameters_xavier_uniform(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\",\n \"def WeightInitializer():\\n return np.random.uniform(-1, 1)\",\n \"def reset_parameters_xavier_uniform(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n if self.conv1d is not None:\\n for n, p in self.conv1d.named_parameters():\\n init_with_xavier_uniform(n, p)\",\n \"def xavier_uniform(weight_shape):\\n if len(weight_shape) == 4:\\n fW, fH, fC, num_fitls = weight_shape\\n return np.random.uniform(-np.sqrt(6 / (fW*fH*fC + num_fitls)), np.sqrt(6 / (fW*fH*fC + num_fitls)), weight_shape)\\n num_input, num_output = weight_shape\\n return np.random.uniform(-np.sqrt(6 / (num_input + num_output)), np.sqrt(6 / (num_input + num_output)), weight_shape)\",\n \"def initiategaussian(sd, x0):\\n y = np.exp(-x**2/(2*sd**2))\\n return y\",\n \"def init_vector(self,x,dim):\\n if dim == \\\"noise\\\":\\n self.prior.sqrtM.init_vector(x,1)\\n else:\\n self.prior.init_vector(x,dim)\",\n \"def xavier_init(module, gain=1, bias=0, distribution='normal'):\\n # assert distribution in ['uniform', 'normal']\\n if distribution == 'uniform':\\n nn.init.xavier_uniform_(module.weight, gain=gain)\\n else:\\n nn.init.xavier_normal_(module.weight, gain=gain)\\n if hasattr(module, 'bias') and module.bias is not None:\\n nn.init.constant_(module.bias, bias)\",\n \"def reset_parameters(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\\n if self.xl_like:\\n nn.init.xavier_uniform_(self.w_pos.weight)\\n if bias:\\n nn.init.constant_(self.w_pos.bias, 0.0)\",\n \"def test_xavier_uniform():\\n tf.reset_default_graph()\\n tf.random.set_random_seed(0)\\n xuniform_class = INITIALIZER_REGISTRY['xavier']\\n xuniform_obj = xuniform_class({\\\"uniform\\\":True})\\n tf_init = xuniform_obj.get_entity_initializer(init_type='tf')\\n var1 = tf.get_variable(shape=(200, 1000), initializer=tf_init, name=\\\"var1\\\")\\n with tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n tf_var = sess.run(var1)\\n np_var = xuniform_obj.get_entity_initializer(200, 1000, init_type='np')\\n # print(np.min(np_var), np.max(np_var))\\n # print(np.min(tf_var), np.max(tf_var))\\n assert(np.round(np.min(np_var),2)==np.round(np.min(tf_var),2))\\n assert(np.round(np.max(np_var),2)==np.round(np.max(tf_var),2))\",\n \"def construct_random_initial(self):\\n x = np.random.random((self._crv_size, self._bound))\\n return x\",\n \"def reset_parameters(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\",\n \"def reset_parameters(self, bias):\\n logger.info('===== Initialize %s with Xavier uniform distribution =====' % self.__class__.__name__)\\n nn.init.xavier_uniform_(self.w_key.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_value.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.w_query.weight, gain=1 / math.sqrt(2))\\n if bias:\\n nn.init.constant_(self.w_key.bias, 0.0)\\n nn.init.constant_(self.w_value.bias, 0.0)\\n nn.init.constant_(self.w_query.bias, 0.0)\\n nn.init.xavier_uniform_(self.w_out.weight)\\n if bias:\\n nn.init.constant_(self.w_out.bias, 0.0)\",\n \"def __init__(self, x_init = 0., x_dinit = 0., alpha = 0.1, beta = 0.1):\\n self.xhat = x_init\\n self.xhatd = x_dinit\\n self.alpha = alpha\\n self.beta = beta\\n self.prev_time = 0.\",\n \"def initializeDistribution(self):\\n if (self.lowerBoundUsed == False and self.upperBoundUsed == False):\\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.low)\\n self.lowerBound = self.low\\n self.upperBound = sys.float_info.max\\n else:\\n if self.lowerBoundUsed == False:\\n self.lowerBound = self.low\\n if self.upperBoundUsed == False:\\n self.upperBound = sys.float_info.max\\n self._distribution = distribution1D.BasicExponentialDistribution(self.lambdaVar,self.lowerBound,self.upperBound,self.low)\",\n \"def __init__(self, x):\\n self.W = np.zeros((x+1,10))\\n self.alpha = 0.00000001\\n self.epochs = 100\\n self.reg_const = 0.01\",\n \"def __init__(self, dim, rn, gammak, sine=False, feature_generator=None):\\n\\n\\t\\tself.dim = dim\\n\\t\\tself.rn = rn\\n\\t\\tself.gammak = gammak\\n\\n\\t\\tif feature_generator is None:\\n\\t\\t\\tself.feature_generator = GaussianRandomFeatures(self.dim, self.rn, self.gammak, sine=sine)\\n\\t\\telse: self.feature_generator = feature_generator\",\n \"def __init__(self):\\n self.expvalue = np.zeros(10)\\n self.iter = np.zeros(10)\\n self.epsilon = 0.1\",\n \"def __init__(self, init_pos, init_stdev, num_particles, sense_noise):\\n self.particles = np.random.multivariate_normal(\\n init_pos, [[init_stdev**2, 0], [0, init_stdev**2]], num_particles)\\n self.weights = np.array(\\n [1. / num_particles for _ in range(num_particles)])\\n self.n = num_particles\\n self.sense_noise = sense_noise\",\n \"def _WeightInit(self, stddev):\\n return init_ops.truncated_normal_initializer(stddev=stddev)\",\n \"def __init__(self, x_axis, y_axis, input_dimension, sigma, learning_rate, random_seed=3):\\n # Creating a random generator for random values; for initializing weights\\n self.random_generator = np.random.RandomState(random_seed)\\n \\n self.x_axis = x_axis\\n self.y_axis = y_axis\\n self.input_dimension = input_dimension\\n self.sigma = sigma\\n self.learning_rate = learning_rate\\n self.weights = np.array([[[0 for x in range(self.input_dimension)] for x in range(self.x_axis)] for x in range(y_axis)], dtype=float)\",\n \"def xavier_uniform_init(tensor, gain=1., random_state=None):\\n # type: (Tensor, float) -> Tensor\\n\\n fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)\\n std = gain * math.sqrt(2.0 / float(fan_in + fan_out))\\n a = math.sqrt(3.0) * std # Calculate uniform bounds from standard deviation\\n\\n uniform_init(tensor, -a, a, random_state)\\n return tensor\",\n \"def build_initial(domain):\\n return random_candidate_float(domain)\",\n \"def init_weights(n_input_layer, n_hidden_layer, n_hidden_layer_2, n_output_layer, xavier_init):\\n W1, W2, W3 = None, None, None\\n \\n if xavier_init: # Checks if Xavier initialisation is wanted\\n # Initialises weights depending on number of layers present using:\\n # Normally distributed random number * square_root(1 / number of input neurons to that layer)\\n if n_hidden_layer > 0:\\n W1 = np.random.randn(n_hidden_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\\n\\n if n_hidden_layer_2 > 0:\\n W2 = np.random.randn(n_hidden_layer_2, n_hidden_layer) * np.sqrt(1 / (n_hidden_layer))\\n W3 = np.random.randn(n_output_layer, n_hidden_layer_2) * np.sqrt(1 / (n_hidden_layer_2))\\n\\n else:\\n W2 = np.random.randn(n_output_layer, n_hidden_layer) * np.sqrt(1 / (n_hidden_layer))\\n\\n else:\\n W1 = np.random.randn(n_output_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\\n\\n else:\\n # Weights are randomly picked from a uniform distribution between 0 and 1\\n # They are normalized by making sure the weights sum to 1\\n # Uses different configurations depending on number of layers required\\n if n_hidden_layer > 0:\\n W1 = np.random.uniform(0,1,(n_hidden_layer, n_input_layer))\\n W1 = np.divide(W1,np.matlib.repmat(np.sum(W1,1)[:,None],1,n_input_layer))\\n \\n if n_hidden_layer_2 > 0:\\n W2=np.random.uniform(0,1,(n_hidden_layer_2,n_hidden_layer))\\n W2=np.divide(W2,np.matlib.repmat(np.sum(W2,1)[:,None],1,n_hidden_layer))\\n\\n W3=np.random.uniform(0,1,(n_output_layer,n_hidden_layer_2))\\n W3=np.divide(W3,np.matlib.repmat(np.sum(W3,1)[:,None],1,n_hidden_layer_2))\\n\\n else:\\n W2 = np.random.uniform(0,1,(n_output_layer, n_hidden_layer))\\n W2 = np.divide(W2,np.matlib.repmat(np.sum(W2,1)[:,None],1,n_hidden_layer))\\n\\n else:\\n W1 = np.random.randn(n_output_layer, n_input_layer) * np.sqrt(1 / (n_input_layer))\\n\\n return W1, W2, W3\",\n \"def sampling(self, args):\\n self.z_mean, self.z_log_var = args\\n batch = K.shape(self.z_mean)[0]\\n dim = K.int_shape(self.z_mean)[1]\\n epsilon = K.random_uniform(shape=(batch, dim))\\n \\n return self.z_mean + K.exp(0.5 * self.z_log_var) * epsilon\",\n \"def __init__(self):\\n self.counts = [0] * 10\\n self.values = [2000] * 10\\n self.epsilon = 0.1\",\n \"def test_xavier_normal():\\n tf.reset_default_graph()\\n tf.random.set_random_seed(0)\\n xnormal_class = INITIALIZER_REGISTRY['xavier']\\n xnormal_obj = xnormal_class({\\\"uniform\\\":False})\\n tf_init = xnormal_obj.get_entity_initializer(init_type='tf')\\n var1 = tf.get_variable(shape=(2000, 100), initializer=tf_init, name=\\\"var1\\\")\\n with tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n tf_var = sess.run(var1)\\n np_var = xnormal_obj.get_entity_initializer(2000, 100, init_type='np')\\n # print(np.mean(np_var), np.std(np_var))\\n # print(np.mean(tf_var), np.std(tf_var))\\n assert(np.round(np.mean(np_var),2)==np.round(np.mean(tf_var),2))\\n assert(np.round(np.std(np_var),2)==np.round(np.std(tf_var),2))\",\n \"def random_init(self, shape):\\n return np.random.randn(shape[0],shape[1])*0.01\",\n \"def _sample_schechter(x0, alpha, x_min, size=100, max_iter=1000):\\n out = []\\n n = 0\\n num_iter = 0\\n while (n<size) & (num_iter<max_iter):\\n x = np.random.gamma(scale=x0, shape=alpha+2, size=size)\\n x = x[x>x_min]\\n u = np.random.uniform(size=x.size)\\n x = x[u<x_min/x]\\n out.append(x)\\n n+=x.size\\n num_iter += 1\\n\\n if num_iter >= max_iter:\\n msg = (\\\"The maximum number of iterations reached.\\\",\\n \\\"Random variates may not be representitive.\\\",\\n \\\"Try increasing `max_iter`.\\\")\\n print(msg)\\n\\n return np.concatenate(out)[:size]\",\n \"def _init_weights(n_rows, n_cols, std_dev=0.5):\\n weights = np.random.randn(n_rows, n_cols) * std_dev\\n return weights\",\n \"def weights_initializer(self):\\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]\",\n \"def xavier_normal(weight_shape):\\n if len(weight_shape) == 4:\\n fW, fH, fC, num_fitls = weight_shape\\n return np.random.normal(0, np.sqrt(2 / (fW*fH*fC + num_fitls)), weight_shape)\\n num_input, num_output = weight_shape\\n return np.random.normal(0, np.sqrt(2 / (num_input + num_output)), weight_shape)\",\n \"def __init__(self, alpha=1.0, epsilon=0.05, gamma=0.8, numTraining = 10):\\n self.alpha = float(alpha)\\n self.epsilon = float(epsilon)\\n self.discount = float(gamma)\\n self.numTraining = int(numTraining)\",\n \"def __init__(self, size, parameters):\\n\\n self.weights = self.init_weights(size)\\n self.alpha = parameters['alpha']\\n self.epsilon = parameters['epsilon']\\n self.gamma = parameters['gamma']\\n self.value = 0.0 #np.random.random()\",\n \"def __init__(self, alpha=1.0, epsilon=0.05, gamma=0.8, numTraining=10):\\n self.alpha = float(alpha)\\n self.epsilon = float(epsilon)\\n self.discount = float(gamma)\\n self.numTraining = int(numTraining)\",\n \"def _initialize_wxf(self, nvisx, nfac, rng=None, irange=None):\\n if rng is None:\\n rng = self.rng\\n if irange is None:\\n irange = self.irange\\n self.wxf = sharedX(\\n (rng.randn(nvisx, nfac)) * irange,\\n name='wxf',\\n borrow=True\\n )\",\n \"def gen_x(self, x_func):\\n self.x_title, self.x = x_func(self.sample_size, self.generator)\",\n \"def sampling(self, args):\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.shape(z_mean)[1]\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def init_variables():\\n weights = np.random.normal(size=2)\\n bias = 0\\n return weights, bias\",\n \"def __init__(self):\\n self.counts = [0] * 10\\n self.values = [0] * 10\\n self.epsilon = 0.1\",\n \"def caffe2_xavier_init(module, bias=0):\\n kaiming_init(\\n module,\\n a=1,\\n mode='fan_in',\\n nonlinearity='leaky_relu',\\n distribution='uniform')\",\n \"def sampling(args):\\n z_mean, z_log_sigma = args\\n epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim), mean = 0., stddev=0.1)\\n return z_mean + K.exp(z_log_sigma) * epsilon\",\n \"def __init__(self, x, U, KE=1, periodic=True, q=0, **kwargs):\\n self.x = x\\n self.U = U\\n self.KE = KE\\n self.periodic = periodic\\n self.q = q\\n Schrodinger.__init__(self, **kwargs)\",\n \"def setUp(self):\\n shape = RNG.integers(5, 50)\\n periods = self.periods = RNG.normal() * 3\\n freq = periods / shape\\n amp = RNG.normal()\\n offset = RNG.normal()\\n phase = (RNG.normal() - 1 / 2) * 5 / 3 * np.pi\\n p_gt = self.p_gt = (amp, freq, phase, offset)\\n x = self.x = np.arange(shape)\\n self.data = sine(x, *p_gt)\",\n \"def _initialize_gaussians(self, n_gaussians):\\n if self.gaussian_init == 'manual':\\n gaussians = torch.Tensor([\\n list(product([0.25, 0.5, 0.75], repeat=2)) +\\n [(0.5, 0.25), (0.5, 0.5), (0.5, 0.75)] +\\n [(0.25, 0.5), (0.5, 0.5), (0.75, 0.5)] +\\n [(0.5, 0.5)],\\n [(-1.5, -1.5)] * 9 + [(0, -1.5)] * 3 + [(-1.5, 0)] * 3 +\\n [(0, 0)],\\n ]).permute(1, 2, 0)\\n\\n elif self.gaussian_init == 'random':\\n with torch.no_grad():\\n gaussians = torch.stack([\\n torch.randn(\\n n_gaussians, 2, dtype=torch.float) * .1 + 0.5,\\n torch.randn(\\n n_gaussians, 2, dtype=torch.float) * .2 - 1,],\\n dim=2)\\n\\n else:\\n raise NotImplementedError\\n\\n gaussians = nn.Parameter(gaussians, requires_grad=True)\\n return gaussians\",\n \"def generate_initial_state(self, x):\\n\\n if self.initial_state is None:\\n x[:] = 0\\n return x\\n else:\\n x[:] = self.initial_state(size=(self._num_neurons, 1))\\n return x\",\n \"def random(self, size, X):\\n if (self.p == 1) and (self.f0 == 0):\\n return self.dist.qf(uniform.rvs(size=size), *self.params) + self.gamma\\n elif (self.p != 1) and (self.f0 == 0):\\n n_obs = np.random.binomial(size, self.p)\\n\\n f = self.dist.qf(uniform.rvs(size=n_obs), *self.params) + self.gamma\\n s = np.ones(np.array(size) - n_obs) * np.max(f) + 1\\n\\n return fs_to_xcn(f, s)\\n\\n elif (self.p == 1) and (self.f0 != 0):\\n n_doa = np.random.binomial(size, self.f0)\\n\\n x0 = np.zeros(n_doa) + self.gamma\\n x = self.dist.qf(uniform.rvs(size=size - n_doa), *self.params) + self.gamma\\n x = np.concatenate([x, x0])\\n np.random.shuffle(x)\\n\\n return x\\n else:\\n N = np.random.multinomial(1, [self.f0, self.p - self.f0, 1. - self.p], size).sum(axis=0)\\n N = np.atleast_2d(N)\\n n_doa, n_obs, n_cens = N[:, 0], N[:, 1], N[:, 2]\\n x0 = np.zeros(n_doa) + self.gamma\\n x = self.dist.qf(uniform.rvs(size=n_obs), *self.params) + self.gamma\\n f = np.concatenate([x, x0])\\n s = np.ones(n_cens) * np.max(f) + 1\\n # raise NotImplementedError(\\\"Combo zero-inflated and lfp model not yet supported\\\")\\n return fs_to_xcn(f, s)\",\n \"def __init__(self, bandits: List[Bandit], epsilon:float = None):\\n self.bandits = bandits\\n self.epsilon = epsilon\\n # mu_pri and var_pri are hypermaterers for prior distribution\\n self.mu_pri = np.zeros(len(self.bandits))\\n self.var_pri = np.ones(len(self.bandits))*5\\n # mu and var are hyperparameters for posterior distribution\\n self.mu = self.mu_pri\\n self.var = self.var_pri\\n self.var0 = 1 # 1 is taken but any can be taken no prob upto a limit constant of inintial distribution\\n self.logging = Logging()\",\n \"def create_initializer(initializer_range=0.02):\\n return tf.truncated_normal_initializer(stddev=initializer_range)\",\n \"def __initialise(self, X, args):\\n\\t\\t\\t#getting centroids\\n\\t\\tindices = np.random.choice(range(X.shape[0]), size = self.K, replace = False)\\n\\t\\tcentroids = X[indices,:] #(K,D) #K centroids are chosen\\n\\t\\t\\t#getting variances\\n\\t\\tvar = np.var(X, axis = 0) #(D,)\\n\\n\\t\\t\\t#computing initial responsibilities\\n\\t\\tr_0 = np.zeros((X.shape[0],self.K))\\n\\t\\tfor k in range(self.K):\\n\\t\\t\\tr_0[:,k] = np.divide(np.square(X - centroids[k,:]), var)[:,0] + 1e-10\\n\\t\\tr_0 = np.divide(r_0.T, np.sum(r_0,axis=1)).T\\n\\n\\t\\tself.gating.fit(X,r_0, *args)\\n\\n\\t\\treturn r_0\",\n \"def create_initializer(initializer_range=0.02):\\n return tf.truncated_normal_initializer(stddev=initializer_range)\",\n \"def create_initializer(initializer_range=0.02):\\n return tf.truncated_normal_initializer(stddev=initializer_range)\",\n \"def __init__(self, initAlpha=0.01, factor=0.25, dropEvery=10):\\n self.initAlpha = initAlpha\\n self.factor = factor\\n self.dropEvery = dropEvery\\n pass\",\n \"def __init__(self, n_in, n_out):\\n self.W = np.random.randn(n_in, n_out) * 0.1\\n self.b = np.zeros(n_out)\",\n \"def _init_weights(self):\\n nn.init.xavier_normal_(self.out.weight)\",\n \"def sampling(args):\\n t_mean, t_log_var = args\\n # YOUR CODE HERE\\n epsilon = K.random_normal(t_mean.shape)\\n z = epsilon * K.exp(0.5 * t_log_var) + t_mean\\n return z\",\n \"def generate_stat(sample_size, sparsity = 0, amplitude = 0, sigma = 1):\\n var = generate_variable(sample_size, sparsity, amplitude, sigma)\\n y_obs = var[0]\\n \\n \\\"\\\"\\\" \\n f is equal to -X(t,theta) and we will minimize f (max. X)\\n \\\"\\\"\\\"\\n def f(x):\\n \\\"\\\"\\\" \\n f(x)=-X(t,theta) where x[0]=t and x[1]=theta\\n \\\"\\\"\\\"\\n res = np.real(np.exp(-1j*x[1])*\\\\\\n sum(y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\\\\n for k in range(-sample_size,sample_size+1))) \\n res = -res/np.sqrt(2*sample_size+1) \\n return res\\n \\n def grad_f(x):\\n \\\"\\\"\\\" \\n gradient of f\\n \\\"\\\"\\\"\\n res1 = np.real(np.exp(-1j*x[1])*\\\\\\n sum(1j*k*y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\\\\n for k in range(-sample_size,sample_size+1)))\\n res1 = -res1/np.sqrt(2*sample_size+1)\\n \\n res2 = np.real(np.exp(-1j*x[1])*\\\\\\n sum(-1j*y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\\\\n for k in range(-sample_size,sample_size+1)))\\n res2 = -res2/np.sqrt(2*sample_size+1)\\n return np.array([res1, res2])\\n \\n #% Minimizing f\\n \\n \\\"\\\"\\\" \\n we minimize on [0, 2pi]^2\\n \\\"\\\"\\\"\\n bnds = ((0, 2*np.pi), (0, 2*np.pi))\\n \\n \\\"\\\"\\\" \\n We begin by a greedy search of the initialization point over a grid of size 126^2\\n the initialization point is init\\n \\\"\\\"\\\"\\n x = y = np.arange(0, 2*np.pi, 0.05)\\n steps = 126\\n X, Y = np.meshgrid(x, y)\\n val = np.array([f([x,y]) for x,y in zip(np.ravel(X), np.ravel(Y))])\\n init = np.argmin(val)\\n x1 = init%steps\\n x2 = (init-x1)/steps\\n init = [x1*0.05, x2*0.05]\\n \\n \\\"\\\"\\\" \\n we minimize f...\\n \\\"\\\"\\\"\\n result = sco.minimize(f, init, method=\\\"L-BFGS-B\\\",\\\\\\n jac=grad_f, bounds=bnds, tol=1e-15)\\n \\n \\\"\\\"\\\" \\n (t1,theta1) is the argmax of X(t, theta) and l1=$\\\\lambda_1$\\n \\\"\\\"\\\"\\n t1 = result.x[0]\\n theta1 = result.x[1]\\n l1 = -f([t1,theta1])\\n \\n \\n \\\"\\\"\\\" \\n Function g(x) is equal to (X(t1,theta1)-X(x))/(1-rho((t1,theta1)-x))\\n \\\"\\\"\\\"\\n def g(x):\\n a0 = x[0]-t1\\n a1 = x[1]-theta1\\n N = 2*sample_size+1\\n \\n vec = np.array([a0,a1])\\n r = np.linalg.norm(vec)\\n \\\"\\\"\\\" \\n the value for r=0 is set to l1 (note that r=0 corresponds to x=(t1,theta1))\\n \\\"\\\"\\\" \\n res = l1 \\n \\n if (0<r) & (r<0.00001):\\n \\\"\\\"\\\" \\n we look a values near (t1,theta1) for which an indetermination occurs\\n \\\"\\\"\\\" \\n alpha= np.arccos(np.clip(a0/np.sqrt(a0**2+a1**2), -1.0, 1.0))\\n u0 = np.cos(alpha)\\n u1 = np.sin(alpha)\\n \\\"\\\"\\\" \\n u0,u1 defines the direction (unit vector)\\n \\\"\\\"\\\"\\n denom = sum((k*np.cos(alpha)-np.sin(alpha))**2*\\\\\\n (np.sinc((r*(k*np.cos(alpha)-np.sin(alpha)))/(2*np.pi)))**2\\\\\\n for k in range(-sample_size,sample_size+1))/N\\n \\\"\\\"\\\" \\n denom computes the denominator\\n \\\"\\\"\\\"\\n \\n# \\\"\\\"\\\" \\n# We use simpson rule for the numerator\\n# \\\"\\\"\\\"\\n# h = np.linspace(0,1,500)\\n# \\n# b0 = t1 + h*a0\\n# b1 = theta1 + h*a1\\n# \\n# value = (1-h)*(u0**2*\\\\\\n# np.real(np.exp(-1j*b1)*sum(-k**2*y_obs[k+sample_size]*np.exp(1j*k*b0) \\\\\\n# for k in range(-sample_size,sample_size+1)))\\\\\\n# +2*u0*u1*\\\\\\n# np.real(np.exp(-1j*b1)*sum(k*y_obs[k+sample_size]*np.exp(1j*k*b0) \\\\\\n# for k in range(-sample_size,sample_size+1)))\\\\\\n# +u1**2*\\\\\\n# np.real(np.exp(-1j*b1)*sum((-1)*y_obs[k+sample_size]*np.exp(1j*k*b0) \\\\\\n# for k in range(-sample_size,sample_size+1)))) \\n# value = value/np.sqrt(N)\\n# \\n# num = sci.simps(value, h)\\n \\n \\\"\\\"\\\" \\n we use a quadrature for the numerator\\n \\\"\\\"\\\" \\n fun_int = lambda w: (1-w)*(u0**2*\\\\\\n np.real(np.exp(-1j*(theta1+w*a1))*\\\\\\n sum(-k**2*y_obs[k+sample_size]*np.exp(1j*k*(t1+w*a0)) \\\\\\n for k in range(-sample_size,sample_size+1)))\\\\\\n +2*u0*u1*\\\\\\n np.real(np.exp(-1j*(theta1+w*a1))*\\\\\\n sum(k*y_obs[k+sample_size]*np.exp(1j*k*(t1+w*a0)) \\\\\\n for k in range(-sample_size,sample_size+1)))\\\\\\n +u1**2*\\\\\\n np.real(np.exp(-1j*(theta1+w*a1))*\\\\\\n sum((-1)*y_obs[k+sample_size]*np.exp(1j*k*(t1+w*a0)) \\\\\\n for k in range(-sample_size,sample_size+1)))) \\n \\n num = np.mean(sci.quad(fun_int, 0, 1, epsabs=1e-15, epsrel=1e-15, limit=1000))\\n \\n res = -num/denom\\n \\n if (r>=0.00001):\\n \\\"\\\"\\\" \\n we look a values far (t1,theta1) for which there is no indetermination\\n \\\"\\\"\\\" \\n res = (l1+f(x))/(1-(np.cos(a1)*dirichlet(a0,N)/N))\\n \\n return res \\n \\\"\\\"\\\" \\n we minimize g on [0, 2pi]^2 an dwe llok for the initialization point\\n \\\"\\\"\\\"\\n val2 = np.array([g([x,y]) for x,y in zip(np.ravel(X), np.ravel(Y))])\\n init2 = np.argmin(val2)\\n x1 = init2%steps\\n x2 = (init2-x1)/steps\\n init2 = [x1*0.05, x2*0.05] \\n result2 = sco.minimize(g, init2, method=\\\"L-BFGS-B\\\", bounds=bnds, tol=1e-15) \\n \\\"\\\"\\\" \\n argmin of g\\n \\\"\\\"\\\"\\n t2 = result2.x[0]\\n theta2 = result2.x[1] \\n \\\"\\\"\\\" \\n value of lambda_2\\n \\\"\\\"\\\"\\n l21 = l1-result2.fun \\n a0 = t2-t1\\n a1 = theta2-theta1\\n N = 2*sample_size+1\\n l22 = l1-(l1+f([t2,theta2]))/(1-(np.cos(a1)*dirichlet(a0,N)/N))\\n l2 = max(l21,l22)\\n \\\"\\\"\\\" \\n we compute the statistic\\n \\\"\\\"\\\"\\n alpha1 = (1/3)*sample_size*(sample_size+1)\\n alpha2 = (1/np.sqrt(N))*\\\\\\n sum((k**2-alpha1)*\\\\\\n np.real(y_obs[k+sample_size]*np.exp(1j*(k*t1-theta1))) \\\\\\n for k in range(-sample_size,sample_size+1))\\n alpha3 = (1/np.sqrt(N))*sum(k*np.real(y_obs[k+sample_size]*\\\\\\n np.exp(1j*(k*t1-theta1))) for k in range(-sample_size,sample_size+1)) \\n stat = (sigma*(alpha1*l1+alpha2)*scs.norm.pdf(l1/sigma)+\\\\\\n (alpha1*sigma**2-alpha3**2)*(1-scs.norm.cdf(l1/sigma)))/\\\\\\n (sigma*(alpha1*l2+alpha2)*scs.norm.pdf(l2/sigma)+\\\\\\n (alpha1*sigma**2-alpha3**2)*(1-scs.norm.cdf(l2/sigma))) \\n \\n return stat\",\n \"def _initialize_fembv_varx(X, n_components, init='random',\\n u=None, memory=0, random_state=None):\\n if init is None:\\n init = 'random'\\n\\n if init == 'random':\\n return _initialize_fembv_varx_random(\\n X, n_components, u=u, memory=memory, random_state=random_state)\\n else:\\n raise ValueError(\\n 'Invalid init parameter: got %r instead of one of %r' %\\n (init, FEMBV_VARX_INITIALIZATION_METHODS))\",\n \"def initial_guess_x0(self) -> npt.NDArray:\\n if self._background is not None:\\n return np.array(\\n [np.random.uniform(lb, ub) for lb, ub in self.bounds]\\n )\\n return np.array(\\n [np.random.uniform(lb, ub) for lb, ub in self.bounds * 2]\\n )\",\n \"def _setup(self, X: np.ndarray):\\n self._sigma = self._a * np.eye(X.shape[1])\\n self._phi = norm.ppf(self._eta)\\n self._psi = 1 + (self._phi ** 2) / 2\\n self._xi = 1 + self._phi ** 2\",\n \"def __init__(self, initial_std=0.1, delta=0.1):\\n self.initial_std = initial_std\\n self.delta = delta\\n # Initialize the current standard deviation\\n self.cur_std = initial_std\",\n \"def init_weights(self):\\n \\n self.w = np.random.randn(self.D) / np.sqrt(self.D)\",\n \"def xinit(self, xshape):\\n\\n return np.zeros(xshape, dtype=self.dtype)\",\n \"def sampling(args):\\r\\n z_mean, z_log_var = args\\r\\n # K is the keras backend\\r\\n batch = K.shape(z_mean)[0]\\r\\n dim = K.int_shape(z_mean)[1]\\r\\n # by default, random_normal has mean=0 and std=1.0\\r\\n epsilon = K.random_normal(shape=(batch, dim))\\r\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\r\\n z_mean, z_log_var = args\\r\\n # K is the keras backend\\r\\n batch = K.shape(z_mean)[0]\\r\\n dim = K.int_shape(z_mean)[1]\\r\\n # by default, random_normal has mean=0 and std=1.0\\r\\n epsilon = K.random_normal(shape=(batch, dim))\\r\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.shape(z_mean)[1]\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def _initialize_wyf(self, nvisy, nfac, rng=None, irange=None):\\n if rng is None:\\n rng = self.rng\\n if irange is None:\\n irange = self.irange\\n self.wyf = sharedX(\\n (rng.randn(nvisy, nfac)) * irange,\\n name='wyf',\\n borrow=True\\n )\",\n \"def __init__(self, epsilon=1e-14):\\n self.epsilon = epsilon\",\n \"def __init__(self):\\n super().__init__()\\n self.lambdaVar = 1.0\\n self.low = 0.0\\n self.type = 'Exponential'\\n self.distType = 'Continuous'\\n self.hasInfiniteBound = True\\n self.compatibleQuadrature.append('CDF')\\n self.preferredQuadrature = 'CDF'\\n self.preferredPolynomials = 'CDF'\",\n \"def noise(x: np.ndarray) -> np.ndarray:\\n\\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)\",\n \"def _generate_signal(self):\\n x = np.arange(self.n, dtype='float')\\n resample = np.random.rand(self.n) >= self.proba\\n resample[0] = True # randomly initialize first sample\\n x[resample] = np.random.randn(np.sum(resample))\\n for i in x[~resample]:\\n x[int(i)] = x[int(i)-1]\\n return x\",\n \"def normc_initializer(std=1.0):\\n def _initializer(shape, dtype=None, partition_info=None): #pylint: disable=W0613\\n out = np.random.randn(*shape).astype(np.float32)\\n out *= std / np.sqrt(np.square(out).sum(axis=0, keepdims=True))\\n return tf.constant(out)\\n return _initializer\",\n \"def init_weights(self, dims):\\n self.W = np.random.normal(size=dims) * 0.0001\",\n \"def __init__(self, mean_function: Callable, lower: Union[float, int], upper: Union[float, int],\\n sample_size: int, seed: Optional[float] = None):\\n super().__init__()\\n np.random.seed(seed)\\n assert callable(mean_function), \\\"intensity_function must be a callable!\\\"\\n try:\\n mean_function(np.array([1, 2]))\\n self.mean_function: Callable = mean_function\\n except ValueError:\\n warn('Force vectorization of intensity function')\\n self.mean_function: Callable = np.vectorize(mean_function)\\n assert isinstance(upper, (int, float)), \\\"Wrong type of upper limit!\\\"\\n assert isinstance(lower, (int, float)), \\\"Wrong type of lower limit!\\\"\\n if seed is not None:\\n assert isinstance(seed, (int, float)), \\\"Wrong type of seed!\\\"\\n if np.sum(self.mean_function(np.random.uniform(lower, upper, int(1e6))) < 0) > 0:\\n raise ValueError(\\\"Mean function must be greater than or equal to 0!\\\")\\n if lower >= upper:\\n raise ValueError(\\\"Wrong interval is specified! (lower {} >= upper {})\\\".format(lower, upper))\\n self.lower: Union[float, int] = lower\\n self.upper: Union[float, int] = upper\\n self.scaler: Union[float, int] = mean_function(upper)\\n self.sample_size: np.ndarray = np.random.poisson(lam=self.scaler * sample_size, size=1)\",\n \"def generate_gaussian():\\n amp = 10 * numpy.random.chisquare(3)\\n width = numpy.random.chisquare(3)\\n mean = numpy.random.uniform(-10 + width, 10 - width)\\n x = numpy.linspace(-10, 10, 500)\\n y = amp * numpy.exp(- (x - mean) ** 2 / width ** 2)\\n add_noise(y, 0.1)\\n return x, y\",\n \"def __init__(self, initial_stddev=0.1, desired_action_stddev=0.2, adaptation_coefficient=1.01):\\n self.initial_stddev = initial_stddev\\n self.desired_action_stddev = desired_action_stddev\\n self.adaptation_coefficient = adaptation_coefficient\\n\\n self.current_stddev = initial_stddev\",\n \"def sampling(args):\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(-0.5 * z_log_var) * epsilon\",\n \"def get_initial_guess():\\n x0 = np.zeros(6)\\n x0[0] = 1\\n x0[3] = 1\\n return x0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.713179","0.694579","0.6937731","0.6779628","0.6648162","0.6642838","0.6642838","0.65998244","0.6546982","0.6546982","0.6505124","0.64154625","0.64006364","0.6392973","0.6384507","0.63683206","0.62566024","0.622814","0.6173743","0.6173743","0.61022276","0.6093483","0.60451245","0.6033761","0.5966504","0.5961608","0.59157515","0.5710224","0.5631042","0.56049085","0.5598116","0.55936617","0.5571496","0.5561212","0.5561212","0.5536552","0.55272067","0.54981995","0.54840577","0.54830337","0.54787433","0.54468775","0.544259","0.5425765","0.5424616","0.54149544","0.54144746","0.5391988","0.53913635","0.53850675","0.5383074","0.5382304","0.5367867","0.5367692","0.5361407","0.5341427","0.5340393","0.5331161","0.53140324","0.53040093","0.5301979","0.52935636","0.5274743","0.527374","0.5261897","0.5258501","0.5244952","0.5235372","0.5227389","0.52243745","0.52243406","0.5223135","0.52198267","0.52198267","0.5217268","0.52171946","0.52128756","0.5201951","0.51983356","0.519032","0.5186883","0.51817405","0.5180456","0.5179058","0.5176527","0.51690626","0.51690626","0.516542","0.51641315","0.5152526","0.51495427","0.5148442","0.5144807","0.51329845","0.51315945","0.5124784","0.5122472","0.5120786","0.511746","0.5115641"],"string":"[\n \"0.713179\",\n \"0.694579\",\n \"0.6937731\",\n \"0.6779628\",\n \"0.6648162\",\n \"0.6642838\",\n \"0.6642838\",\n \"0.65998244\",\n \"0.6546982\",\n \"0.6546982\",\n \"0.6505124\",\n \"0.64154625\",\n \"0.64006364\",\n \"0.6392973\",\n \"0.6384507\",\n \"0.63683206\",\n \"0.62566024\",\n \"0.622814\",\n \"0.6173743\",\n \"0.6173743\",\n \"0.61022276\",\n \"0.6093483\",\n \"0.60451245\",\n \"0.6033761\",\n \"0.5966504\",\n \"0.5961608\",\n \"0.59157515\",\n \"0.5710224\",\n \"0.5631042\",\n \"0.56049085\",\n \"0.5598116\",\n \"0.55936617\",\n \"0.5571496\",\n \"0.5561212\",\n \"0.5561212\",\n \"0.5536552\",\n \"0.55272067\",\n \"0.54981995\",\n \"0.54840577\",\n \"0.54830337\",\n \"0.54787433\",\n \"0.54468775\",\n \"0.544259\",\n \"0.5425765\",\n \"0.5424616\",\n \"0.54149544\",\n \"0.54144746\",\n \"0.5391988\",\n \"0.53913635\",\n \"0.53850675\",\n \"0.5383074\",\n \"0.5382304\",\n \"0.5367867\",\n \"0.5367692\",\n \"0.5361407\",\n \"0.5341427\",\n \"0.5340393\",\n \"0.5331161\",\n \"0.53140324\",\n \"0.53040093\",\n \"0.5301979\",\n \"0.52935636\",\n \"0.5274743\",\n \"0.527374\",\n \"0.5261897\",\n \"0.5258501\",\n \"0.5244952\",\n \"0.5235372\",\n \"0.5227389\",\n \"0.52243745\",\n \"0.52243406\",\n \"0.5223135\",\n \"0.52198267\",\n \"0.52198267\",\n \"0.5217268\",\n \"0.52171946\",\n \"0.52128756\",\n \"0.5201951\",\n \"0.51983356\",\n \"0.519032\",\n \"0.5186883\",\n \"0.51817405\",\n \"0.5180456\",\n \"0.5179058\",\n \"0.5176527\",\n \"0.51690626\",\n \"0.51690626\",\n \"0.516542\",\n \"0.51641315\",\n \"0.5152526\",\n \"0.51495427\",\n \"0.5148442\",\n \"0.5144807\",\n \"0.51329845\",\n \"0.51315945\",\n \"0.5124784\",\n \"0.5122472\",\n \"0.5120786\",\n \"0.511746\",\n \"0.5115641\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6419569"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":84893,"cells":{"query":{"kind":"string","value":"Constructs word2idx dict from Glove pretrained embeddings and writes it to word2idx.txt file in data directory of the project."},"document":{"kind":"string","value":"def construct_dict(self):\n i = 0\n self.word2idx = dict()\n fi = open(self.config.word_vec_fi_glove, 'r')\n\n for line in fi:\n self.word2idx[line.split(\" \")[0]] = i\n i += 1\n\n self.vocab_size = i\n self.write_dict()\n fi.close()"},"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 make_idx2word():\n idx2word = {}\n d = train_data.shared['word2idx']\n for word, idx in d.items():\n print(word)\n idx2word[idx] = word\n if config.use_glove_for_unk:\n d2 = train_data.shared['new_word2idx']\n for word, idx in d2.items():\n print(word)\n idx2word[idx+len(d)] = word\n return idx2word","def generate_conll2003_embeddings():\n glove_embedding = get_glove_embedding()\n\n word2index = {}\n idx2word = {}\n embed_array = []\n\n word2index[\"<pad>\"] = 1\n embed_array.append(init_embedding())\n\n word2index[\"<unk>\"] = 0\n embed_array.append(init_embedding())\n\n data = []\n with open(TRAIN_DATA_PATH, \"r\") as f:\n for line in f:\n data.append(json.loads(line))\n\n idx = 2\n\n for sample in tqdm(data, total=len(data)):\n words = sample[\"tokens\"]\n\n for w in words:\n w = w.lower()\n\n # if word is not present in dictionary, add to dictionary and append embedding vector\n if w not in word2index.keys():\n word2index[w] = idx\n idx += 1\n if w not in glove_embedding.keys():\n ev = init_embedding()\n else:\n ev = glove_embedding[w]\n\n embed_array.append(ev)\n\n else:\n continue\n\n # save embeddings\n embed_array = np.vstack(embed_array)\n np.save(EMBD_OUTPUT_PATH, embed_array)\n\n # save dictionary\n print(\"Dicitionary Size: \", len(word2index))\n with open(DICTIONARY_OUTPUT_PATH, \"w\") as f:\n json.dump(word2index, f)","def make_word2id():\r\n with open(\"public_data/stats/stats_train.pkl\", 'rb') as stats:\r\n stats = pickle.load(stats)\r\n vocab = stats[\"VOCAB\"]\r\n word2id = {word: id for id, word in enumerate([\"PAD\"] + [\"UNK\"] + vocab)}\r\n with open('public_data/vocab/word2id.pkl', 'wb') as out:\r\n pickle.dump(word2id, out, protocol=4)","def sentences_2_idxs(self):\n fo_pos = open(self.config.parsed_train_file_pos, 'w')\n fo_neg = open(self.config.parsed_train_file_neg, 'w')\n self.load_dicts()\n labels = pd.read_csv(self.config.train_file, usecols=[\"target\"])\n\n labels = list(labels.values[:, 0])\n questions = pd.read_csv(self.config.train_file,\n usecols=[\"question_text\"], index_col=False)\n unk_idx = self.word2idx.get(self.config.unknown_token)\n\n for label, quest in zip(labels, questions.question_text):\n tokens = preprocess_text(quest)\n\n if self.config.include_unknown:\n idxs = [self.word2idx.get(token, unk_idx) for token in\n tokens]\n else:\n idxs = [self.word2idx.get(token) for token in tokens]\n idxs = [idx for idx in idxs if idx]\n out_line = (str(\" \".join(str(num) for num in idxs)) + \"\\n\")\n if label == 1:\n fo_pos.write(out_line)\n else:\n fo_neg.write(out_line)","def make_embedding(path, words, indices):\n #root = '/'.join(path.split('/')[0:-1])\n #all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\n #for path in all_paths:\n vec_path = 'data/'+path.split('/')[-1]+'_'+mode\n print(vec_path)\n if os.path.exists(vec_path+'.npy'):\n np_vecs = np.load(vec_path+'.npy')\n else:\n words_len = len(words)\n vecs = []\n if mode == 'word':\n f = load_model('wiki.en.bin')\n for i, w in enumerate(words):\n if mode == 'word':\n vec = f.get_word_vector(w)\n else:\n vec = eye[indices[w]]\n vecs.append(vec) \n if i % 10000 == 0:\n print(\"{} / {}\".format(i, words_len))\n np_vecs = np.asarray(vecs, dtype=np.int8)\n np.save(vec_path, np_vecs)\n return np_vecs","def get_word_embeddings(self):\n embedding_index = {}\n with open('./glove/glove.6B.100d.txt', encoding=\"utf8\") as f:\n for line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embedding_index[word] = coefs\n return embedding_index","def build_vocab(words, vocab_size, visual_fld=None):\n utils.safe_mkdir(visual_fld)\n file = open(os.path.join(visual_fld, 'vocab.tsv'), 'w',encoding='utf8')\n\n dictionary = dict()\n count = [('UNK', -1)]\n index = 0\n count.extend(Counter(words).most_common(vocab_size - 1))\n\n for word, _ in count:\n dictionary[word] = index\n index += 1\n file.write(word + '\\n')\n\n index_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n file.close()\n return dictionary, index_dictionary","def construct_embedding(self):\n i = 0\n self.load_dicts()\n embedding_shape = (max(self.word2idx.values()) + 1,\n self.embedding_size)\n self.embedding = np.zeros(embedding_shape)\n\n with open(self.config.word_vec_fi_glove, 'r') as fi:\n for line in fi:\n word_vec = line.split(\" \")[1:]\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\n i += 1\n\n self.write_embedding()","def predict_sentences_2_idxs(self):\n fo = open(self.config.parsed_predict_file, 'w')\n self.load_dicts()\n\n questions = pd.read_csv(self.config.predict_file,\n usecols=[\"question_text\"], index_col=False)\n unk_idx = self.word2idx[self.config.unknown_token]\n\n for quest in questions.question_text:\n tokens = preprocess_text(quest)\n if self.config.include_unknown:\n idxs = [self.word2idx.get(token, unk_idx) for token in\n tokens]\n else:\n idxs = [self.word2idx.get(token) for token in tokens]\n idxs = [idx for idx in idxs if idx]\n fo.write((str(\" \".join(str(num) for num in idxs)) + \"\\n\"))","def gen_embedding(path):\r\n word_emb = {}\r\n with open(path, encoding='utf-8') as f:\r\n for line in tqdm(f):\r\n values = line.split()\r\n word_emb[values[0]] = np.asarray(values[1:], dtype='float32')\r\n return word_emb","def get_weibo_data(vocab_file, vector_file):\n if os.path.exists(\"word_misc.pkl\"):\n return cPickle.load(open(\"word_misc.pkl\", \"rb\"))\n\n word_misc, word2id, id2word = {}, {}, {}\n word_count = 0\n\n # vocab file\n print \"Building vocabulary ...\"\n for lines in open(vocab_file).readlines():\n word = lines.split()[0]\n if not is_unwanted_words(word, ['', '\\n']):\n word2id[word] = word_count\n id2word[word_count] = word\n word_count += 1\n word2id['_START'] = word_count\n id2word[word_count] = '_START'\n word_count += 1\n word2id['_END'] = word_count\n id2word[word_count] = '_END'\n word_count += 1\n word2id['_UNK'] = word_count\n id2word[word_count] = '_UNK'\n word_count += 1\n word2id['_MASK'] = word_count\n id2word[word_count] = '_MASK'\n word_count += 1\n print \"Vocabulary size:\", word_count\n\n # Initialization is refered to in https://www.tensorflow.org/versions/r0.7/tutorials/word2vec/index.html\n word_emb = (1/np.sqrt(word_count)*(2*np.random.rand(word_count, options['embedding_size']) - 1)).tolist()\n\n # load word vectors\n for lines in open(vector_file).readlines()[1:]:\n word = lines.split()[0]\n #if word == '</s>' or word not in word2id.keys():\n # continue\n if word not in word2id.keys():\n continue\n ids = word2id[word]\n #print ids, lines, len(word_emb)\n word_emb[ids] = [float(w) for w in lines.split()[1:]]\n\n print len(word_emb), \"words have been loaded with\", len(word_emb[0]), \"dimensions\"\n\n # load word misc\n word_misc['id2word'] = id2word\n word_misc['word2id'] = word2id\n word_misc['word_count'] = word_count\n word_misc['word_emb'] = word_emb\n cPickle.dump(word_misc, open(\"word_misc.pkl\", \"wb\"))\n print \"Dump complete.\"\n return word_misc","def build_vocab(data):\n # data = _read_words(filename)\n counter = collections.Counter(data)\n # print('counter', counter) # dictionary for the occurrence number of each word, e.g. 'banknote': 1, 'photography': 1, 'kia': 1\n count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))\n # print('count_pairs',count_pairs) # convert dictionary to list of tuple, e.g. ('ssangyong', 1), ('swapo', 1), ('wachter', 1)\n words, _ = list(zip(*count_pairs))\n word_to_id = dict(zip(words, range(len(words))))\n # print(words) # list of words\n # print(word_to_id) # dictionary for word to id, e.g. 'campbell': 2587, 'atlantic': 2247, 'aoun': 6746\n return word_to_id","def build_idx(vocab):\n word2index = {}\n index2word = {}\n\n word2index['PAD'] = 0\n index2word[0] = 'PAD'\n\n word2index['UNK'] = 1\n index2word[1] = 'UNK'\n\n for i,word in enumerate(vocab):\n word2index[word.lower()] = i+2\n index2word[i+2] = word.lower()\n\n return word2index, index2word","def load_word2vec(emb_path, id_to_word, word_dim, old_weights):\n new_weights = old_weights\n print('Loading pretrained embeddings from {}...'.format(emb_path))\n pre_trained = {}\n emb_invalid = 0\n for i, line in enumerate(codecs.open(emb_path, 'r', 'utf-8')):\n line = line.rstrip().split()\n if len(line) == word_dim + 1:\n pre_trained[line[0]] = np.array(\n [float(x) for x in line[1:]]\n ).astype(np.float32)\n else:\n emb_invalid += 1\n if emb_invalid > 0:\n print('WARNING: %i invalid lines' % emb_invalid)\n c_found = 0\n c_lower = 0\n c_zeros = 0\n n_words = len(id_to_word)\n # Lookup table initialization\n for i in range(n_words):\n word = id_to_word[i]\n if word in pre_trained:\n new_weights[i] = pre_trained[word]\n c_found += 1\n elif word.lower() in pre_trained:\n new_weights[i] = pre_trained[word.lower()]\n c_lower += 1\n elif re.sub('\\d', '0', word.lower()) in pre_trained:\n new_weights[i] = pre_trained[\n re.sub('\\d', '0', word.lower())\n ]\n c_zeros += 1\n print('Loaded %i pretrained embeddings.' % len(pre_trained))\n print('%i / %i (%.4f%%) words have been initialized with '\n 'pretrained embeddings.' % (\n c_found + c_lower + c_zeros, n_words,\n 100. * (c_found + c_lower + c_zeros) / n_words)\n )\n print('%i found directly, %i after lowercasing, '\n '%i after lowercasing + zero.' % (\n c_found, c_lower, c_zeros\n ))\n return new_weights","def load_target_vocab(self):\n vocab = [line.split()[0] for line in open(os.path.join('preprocessed', 'all_vocab.txt'), 'r').read().splitlines()]\n self.word2idx = {word: idx for idx, word in enumerate(vocab)}\n self.idx2word = {idx: word for idx, word in enumerate(vocab)}\n self.vocab_size = len(self.word2idx)","def get_word_embedding(counter, emb_file, emb_size, vocab_size, vec_size, vocab_file):\n print(\"Generating word embedding...\")\n # load word embeddings\n embedding_dict = {}\n with open(emb_file, \"r\", encoding=\"utf-8\") as fh:\n for line in tqdm(fh, total=emb_size):\n array = line.split()\n word = \"\".join(array[0:-vec_size])\n vector = list(map(float, array[-vec_size:]))\n embedding_dict[word] = vector\n\n TRANSLATE = {\n \"-lsb-\": \"[\", \"-rsb-\": \"]\", \"-lrb-\": \"(\", \"-rrb-\": \")\", \"-lcb-\": \"{\",\n \"-rcb-\": \"}\", \"-LSB-\": \"[\", \"-RSB-\": \"]\", \"-LRB-\": \"(\", \"-RRB-\": \")\",\n \"-LCB-\": \"{\", \"-RCB-\": \"}\"\n }\n SPECIAL_TOKENS = [\"<NULL>\", \"<UNK>\", \"<S>\", \"</S>\"]\n words = list(map(lambda x: x[0], sorted(counter.items(), key=lambda x: x[1], reverse=True)))\n words = SPECIAL_TOKENS + words\n if vocab_size > 0:\n words = words[:vocab_size]\n with open(vocab_file, 'w') as f:\n f.write('\\n'.join(words[1:]))\n embedding = np.random.normal(scale=0.1, size=(len(words), vec_size))\n word2idx_dict = {}\n unknown_count = 0\n for i, word in enumerate(words):\n word2idx_dict[word] = i\n if word in TRANSLATE:\n word = TRANSLATE[word]\n done = False\n for w in (word, word.lower(), word.upper(), word.capitalize()):\n if w in embedding_dict:\n embedding[i] = embedding_dict[w]\n done = True\n break\n if not done:\n unknown_count += 1\n return embedding, word2idx_dict, unknown_count","def index(self):\n print(\"Indexing...\")\n # ------------------------------------------------------------------\n # TODO: Create an inverted, positional index.\n # Granted this may not be a linked list as in a proper\n # implementation.\n # This index should allow easy access to both \n # 1) the documents in which a particular word is contained, and \n # 2) for every document, the positions of that word in the document \n # Some helpful instance variables:\n # * self.docs = List of documents\n # * self.titles = List of titles\n inv_index = defaultdict(set)\n self.tf = defaultdict(Counter)\n \n for word in self.vocab:\n inv_index[word] = {} # create dictionary with words in V\n\n # Generate inverted index here\n for doc in range(len(self.docs)):\n for word in self.docs[doc]:\n self.tf[doc][word] += 1 # represents how many times word 'word' is mentioned in document 'i'\n \n for doc, title in zip(self.docs, self.titles):\n for word in self.vocab:\n inv_index[word][title] = [] # list for each word in vocabulary for all titles\n for pos, word in enumerate(doc):\n inv_index[word][title].append(pos)\n\n self.inv_index = inv_index\n # ------------------------------------------------------------------\n\n # turn self.docs into a map from ID to bag of words\n id_to_bag_of_words = {}\n for d, doc in enumerate(self.docs):\n bag_of_words = set(doc)\n id_to_bag_of_words[d] = bag_of_words\n self.docs = id_to_bag_of_words","def load_glove_embeddings():\n data = open(\"glove.6B.50d.txt\",'r',encoding=\"utf-8\")\n embeddings = []\n word_index_dict = {'UNK':0}\n index = 1\n for lines in data:\n wordVector = lines.split(\" \")\n if(wordVector[0] in string.punctuation or any(char.isdigit() for char in wordVector[0])):\n continue\n embeddings.append(wordVector[1:-1])\n word_index_dict[wordVector[0]] = index\n index+=1\n print(\"done\")\n\n return embeddings, word_index_dict","def _add_pre_trained_embedding(self):\n\n if self.embedding_type['type'] == 'glove':\n self.logging.info('use pre-trained glove word2vec')\n # a. load pre trained glove\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\n import os\n import numpy as np\n\n embeddings_index = {}\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\n for line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n f.close()\n\n self.logging.info('')\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\n\n # b. compute embedding matrix\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n\n elif self.embedding_type['type'] == 'gensim':\n self.logging.info('use pre-trained gensim word2vec')\n\n import gzip\n import gensim\n from keras.layers import Embedding\n import numpy as np\n\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\n\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\n pretrained_weights = model.wv.syn0\n vocab_size, vector_dim = pretrained_weights.shape\n\n method = 3\n if method == 1:\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\n # into our TensorFlow and Keras models\n\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\n for i in range(len(model.wv.vocab)):\n embedding_vector = model.wv[model.wv.index2word[i]]\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\n output_dim=embedding_matrix.shape[1],\n # input_length=self.maxlen,\n weights=[embedding_matrix],\n trainable=False)\n elif method == 2:\n self.logging.info('word2vec simple embedding matching - simple complex')\n embedding_layer = Embedding(input_dim=vocab_size,\n output_dim=vector_dim,\n input_length=self.maxlen,\n weights=[pretrained_weights],\n trainable=False)\n elif method == 3:\n\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\n # b. compute embedding matrix\n\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\n\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n if word in model.wv:\n embedding_vector = model.wv[word]\n embedding_matrix[i] = embedding_vector\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt))\n\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n else:\n raise ValueError('unknown method value')\n\n else:\n raise ValueError('unknown embedding type')\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\n return embedding_layer","def build_vocab(sentences_list, vocab_size, visual_fld):\n words = [word for sentence in sentences_list for word in sentence]\n utils.safe_mkdir(visual_fld)\n with open(os.path.join(visual_fld, 'vocab.tsv'), 'w') as fd:\n dictionary = {}\n index_dictionary = {}\n count = [('UNK', -1)]\n count.extend(Counter(words).most_common(vocab_size - 1))\n for index, (word, _) in enumerate(count):\n dictionary[word] = index\n index_dictionary[index] = word\n fd.write(word + '\\n')\n\n return dictionary, index_dictionary","def _build_vocabulary(input_files):\n if FLAGS.vocab_file:\n tf.logging.info(\"Loading existing vocab file.\")\n vocab = collections.OrderedDict()\n with tf.gfile.GFile(FLAGS.vocab_file, mode=\"r\") as f:\n for i, line in enumerate(f):\n word = line.decode(\"utf-8\").strip()\n assert word not in vocab, \"Attempting to add word twice: %s\" % word\n vocab[word] = i\n tf.logging.info(\"Read vocab of size %d from %s\",\n len(vocab), FLAGS.vocab_file)\n return vocab\n\n tf.logging.info(\"Creating vocabulary.\")\n num = 0\n wordcount = collections.Counter()\n for input_file in input_files:\n tf.logging.info(\"Processing file: %s\", input_file)\n for sentence in tf.gfile.FastGFile(input_file):\n wordcount.update(sentence.split())\n\n num += 1\n if num % 1000000 == 0:\n tf.logging.info(\"Processed %d sentences\", num)\n\n tf.logging.info(\"Processed %d sentences total\", num)\n\n words = wordcount.keys()\n freqs = wordcount.values()\n sorted_indices = np.argsort(freqs)[::-1]\n\n vocab = collections.OrderedDict()\n vocab[special_words.EOS] = special_words.EOS_ID\n vocab[special_words.UNK] = special_words.UNK_ID\n for w_id, w_index in enumerate(sorted_indices[0:FLAGS.num_words - 2]):\n vocab[words[w_index]] = w_id + 2 # 0: EOS, 1: UNK.\n\n tf.logging.info(\"Created vocab with %d words\", len(vocab))\n\n vocab_file = os.path.join(FLAGS.output_dir, \"vocab.txt\")\n with tf.gfile.FastGFile(vocab_file, \"w\") as f:\n f.write(\"\\n\".join(vocab.keys()))\n tf.logging.info(\"Wrote vocab file to %s\", vocab_file)\n\n word_counts_file = os.path.join(FLAGS.output_dir, \"word_counts.txt\")\n with tf.gfile.FastGFile(word_counts_file, \"w\") as f:\n for i in sorted_indices:\n f.write(\"%s %d\\n\" % (words[i], freqs[i]))\n tf.logging.info(\"Wrote word counts file to %s\", word_counts_file)\n\n return vocab","def load_embedding_file(self):\n if self.language == 'en':\n embed_file_dir = self.embedding_path\n wv = KeyedVectors.load_word2vec_format(embed_file_dir, binary=True)\n self.pretrained_embedding = {}\n for word in wv.vocab.keys():\n normalized_word = normalization.process(self.language.upper(), word, letters_to_keep='', letters_to_remove='',\n lowercase=True, remove_repetitions_count=-1, remove_punct=True,\n remove_digits=True, remove_vowels=False, remove_diacritics=True,\n remove_spaces=False, remove_apostrophe=True, copy_through=False,\n keep_romanized_text=False)\n self.pretrained_embedding[normalized_word] = wv[word]\n self.embed_dim = 300\n\n else:\n embed_file_dir = self.embedding_path\n fin = open(embed_file_dir, 'r', encoding='utf-8', newline='\\n', errors='ignore')\n data = {}\n for line in fin:\n if len(line.split()) == 2: # header\n continue\n tokens = line.rstrip().split(' ')\n word = tokens[0]\n normalized_word = normalization.process(self.language.upper(), word, letters_to_keep='', letters_to_remove='',\n lowercase=True, remove_repetitions_count=-1, remove_punct=True,\n remove_digits=True, remove_vowels=False, remove_diacritics=True,\n remove_spaces=False, remove_apostrophe=True, copy_through=False,\n keep_romanized_text=False)\n data[normalized_word] = np.array(tokens[1:])\n self.pretrained_embedding = data\n self.embed_dim = 300","def load_pretrained_words_data(embeddings_filename, vocab):\n words = dict()\n emb_dim = None\n with gzip.open(cached_path(embeddings_filename), 'rb') as embeddings_file:\n for line in embeddings_file:\n fields = line.decode('utf-8').strip().split(' ')\n if len(fields) == 0:\n continue\n word = fields[0]\n if emb_dim is None:\n emb_dim = len(fields) - 1\n if emb_dim < 10: # my pretrained file is poisonous 😭\n emb_dim = None\n else:\n assert emb_dim == len(fields) - 1, \"{}, {}\".format(emb_dim, len(fields) - 1)\n words.update({word: [float(i) for i in fields[1:]]})\n print(\"Embedding dim: {}\".format(emb_dim))\n tokens = vocab.get_index_to_token_vocabulary(\"tokens\")\n n_tokens = len(tokens)\n data = []\n for i in tokens:\n if tokens[i] in words:\n data.append(words[tokens[i]])\n else:\n data.append([0] * emb_dim)\n return torch.tensor(data), emb_dim","def load_word2index(self):\n word2index = {}\n with open(self.nodes_file, 'r') as reader:\n for index, line in enumerate(reader):\n node = line.strip()\n word2index[node] = index\n\n return word2index","def get_google_word2vec_W(fname, vocab, vocab_size=1000000, index_from=3):\n f = open(fname, 'rb')\n header = f.readline()\n vocab1_size, embedding_dim = list(map(int, header.split()))\n binary_len = np.dtype('float32').itemsize * embedding_dim\n vocab_size = min(len(vocab) + index_from, vocab_size)\n W = np.zeros((vocab_size, embedding_dim))\n\n found_words = {}\n for i, line in enumerate(range(vocab1_size)):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch)\n if word in vocab:\n wrd_id = vocab[word] + index_from\n if wrd_id < vocab_size:\n W[wrd_id] = np.fromstring(\n f.read(binary_len), dtype='float32')\n found_words[wrd_id] = 1\n else:\n f.read(binary_len)\n\n cnt = 0\n for wrd_id in range(vocab_size):\n if wrd_id not in found_words:\n W[wrd_id] = np.random.uniform(-0.25, 0.25, embedding_dim)\n cnt += 1\n assert cnt + len(found_words) == vocab_size\n\n f.close()\n\n return W, embedding_dim, vocab_size","def get_vocab(self):\n if os.path.exists(self.vocab_file) & self.vocab_from_file:\n f = open(self.vocab_file, \"rb\")\n vocab = pickle.load(f)\n self.word2idx = vocab.word2idx\n self.idx2word = vocab.idx2word\n f.close()\n else:\n self.build_vocab()\n with open(self.vocab_file, 'wb') as f:\n pickle.dump(self, f)","def load_data_for_dict(path, voc_path, need_rem_punkt=True):\n \n table = str.maketrans('', '', string.punctuation)\n\n with open(voc_path) as f:\n word_to_idx = dict(json.load(f))\n dict_size = len(word_to_idx)\n \n with open(path, \"r\") as fin:\n for line in fin:\n line = line.lower()\n sentence = []\n for word in line.split():\n if need_rem_punkt: \n word = word.translate(table) # remove punctuation\n if word not in word_to_idx:\n word_to_idx[word] = dict_size\n dict_size += 1\n\n with open(voc_path, \"w+\") as fout:\n json.dump(word_to_idx, fout)","def load_embedding(self, glove_dir='glove.6B/'):\n\n f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'))\n for line in f:\n values = line.split()\n word = values[0]\n self.embeddings_index[word] = np.asarray(values[1:], dtype='float32')\n f.close()","def get_vocab(self):\n word2id = {}\n for document in self.docs:\n for word in document:\n if word not in word2id.keys():\n word2id[word] = len(word2id)\n return word2id","def load_kb_embeddings(path_to_folder):\n\n entity2idx = {}\n allowed_indices = set()\n with open(\"data/entity2id.filtered.txt\", 'r') as f:\n for l in f.readlines():\n k, v, idx = tuple(l.strip().split(\"\\t\"))\n entity2idx[k] = int(idx) + 3\n allowed_indices.add(int(v))\n\n embeddings = []\n with open(path_to_folder + \"/entity2vec.vec\", 'r') as f:\n idx = 0\n for line in f.readlines():\n if idx in allowed_indices:\n split = line.strip().split('\\t')\n embeddings.append([float(num) for num in split])\n idx += 1\n\n entity2idx[all_zeroes] = 0 # 0 is reserved for padding\n entity2idx[unknown_el] = 1 # 1 is reserved for OOV\n entity2idx[no_annotation] = 2 # 2 is reserved for no annotation tokens\n embedding_size = len(embeddings[0])\n vector_oov = 2 * 0.1 * np.random.rand(embedding_size) - 0.1\n vector_na = 2 * 0.1 * np.random.rand(embedding_size) - 0.1\n embeddings = np.asarray([[0.0]*embedding_size, vector_oov, vector_na] + embeddings, dtype='float32')\n\n print(\"KB embeddings loaded: {}\".format(embeddings.shape))\n assert len(entity2idx) == len(embeddings)\n\n return entity2idx, embeddings","def init_pretrained_glove(glove_path, word2idx, embedding_dim):\n vocab_size = len(word2idx)\n # read in the glove files\n glove_file = os.path.join(glove_path, 'glove.6B.{:d}d.json'.\n format(embedding_dim))\n with open(glove_file, 'r') as fp:\n word2glove = json.load(fp)\n print('Read embeddings: {:s}'.format(glove_file))\n\n # then make giant matrix with all the matching vocab words\n padding_idx = 0\n # follow Karpahty's advice and initialize really small\n pretrained = torch.randn(vocab_size, embedding_dim) * 0.01\n count = 0\n for word, idx in word2idx.iteritems():\n # reserve the padding idx as 0\n if idx == padding_idx:\n torch.FloatTensor(embedding_dim).zero_()\n # keep as random initialization\n if word not in word2glove:\n continue\n pretrained[idx] = torch.FloatTensor(word2glove[word])\n\n embed = torch.nn.Embedding(vocab_size, embedding_dim)\n embed.weight = torch.nn.Parameter(pretrained)\n return embed","def get_W(word_vecs, k=100,path='wordemb'):\n vocab_size = len(word_vecs)\n word_idx_map = dict()\n W = np.zeros(shape=(vocab_size+1, k), dtype='float32')\n W[0] = np.zeros(k, dtype='float32')\n i = 1\n f =open(path+'.word','w')\n for word in word_vecs:\n # print(\"#############################\")\n # print(word_vecs[word].shape)\n # print(word)\n # print(W[i].shape)\n # print(\"#############################\")\n W[i] = word_vecs[word]\n f.write(word+'\\n')\n word_idx_map[word] = i\n i += 1\n np.savetxt(path+'.txt',W,fmt='%.7f', delimiter=' ')\n f.close()\n return W, word_idx_map","def gen_embeddings(vocab, file, emb_size, emb_dim):\n # embeddings = np.random.randn(vocab.n_words, emb_size) * 0.01\n embeddings = np.zeros((vocab.n_words, emb_size))\n print('Embeddings: %d x %d' % (vocab.n_words, emb_size))\n if file is not None:\n print('Loading embedding file: %s' % file)\n pre_trained = 0\n for line in open(file).readlines():\n sp = line.split()\n if(len(sp) == emb_dim + 1):\n if sp[0] in vocab.word2index:\n pre_trained += 1\n embeddings[vocab.word2index[sp[0]]] = [float(x) for x in sp[1:]]\n else:\n print(sp[0])\n print('Pre-trained: %d (%.2f%%)' % (pre_trained, pre_trained * 100.0 / vocab.n_words))\n return embeddings","def conv_word_to_indexed_txt(txt_vec):\n\n # transform words into integer indexes, comes out as n x m\n # where n = # txt doc, m = # unique words for whole universe\n vectorizer = CountVectorizer(\n stop_words=customised_stopword,\n analyzer='word'\n )\n # CountVectorizer(ngram_range=(1,2), analyzer='word')\n sparse_count_vec = vectorizer.fit_transform(txt_vec)\n\n # create n x p list of words represented by ints,\n # where p = # words in each documentx\n # written in such a convoluted way for speed optimization purposes\n x_vec, y_vec, count_vec = sparse.find(sparse_count_vec)\n\n # add in duplicates\n x_vec = np.repeat(x_vec, count_vec)\n y_vec = np.repeat(y_vec, count_vec)\n\n # convert to torch variables\n x_vec = torch.tensor(x_vec, dtype=torch.int32)\n y_vec = torch.tensor(y_vec, dtype=torch.float)\n\n # sort the vecs\n sort_ix = torch.argsort(x_vec)\n x_vec = x_vec[sort_ix]\n y_vec = y_vec[sort_ix]\n\n x_vec_bincount = torch.bincount(x_vec.cpu())\n bincount_tup = tuple(int(bincount) for bincount in x_vec_bincount)\n indexed_txt_list = list(torch.split(y_vec, bincount_tup))\n\n # the dictionary key to match each word to int\n vocab_dict = vectorizer.vocabulary_\n\n print(\"Converted words to indexes of integers.\")\n\n vocab_count = sparse_count_vec.data\n\n return indexed_txt_list, vocab_dict, vocab_count","def w2v_embedding(input_file, bin_file, output_file):\n print(\"Loading the training corpus.\")\n df = open(src_file_path, \"r\") # Open the text file stored at src_file_path\n df = df.read() # Read the text file\n tokens1 = word_tokenize(df) # Tokenize\n token_list = []\n print(\"Writing the bin file.\")\n models = KeyedVectors.load_word2vec_format(bin_destination_file_path, binary=True) # Save bin format\n print(\"Saving the word embeddings.\")\n models.save_word2vec_format(txt_file_destination_path, binary=False) # Save the word vectors\n \n return txt_file_destination_path","def load_word2vect(self, file_path):\n self.embeddings = []\n self.word_to_idx = {'<pad>' : 0}\n self.vocab = ['<pad>']\n\n model = w2v.load(file_path)\n self.embedding_size = model.vectors.shape[1]\n pad_embedding = np.zeros(self.embedding_size, \"float32\")\n self.embeddings.append(pad_embedding)\n\n train_words_set = set([word for text in self.train_data for word in\n text[1].split(\" \")])\n\n for w in model.vocab:\n if w in train_words_set:\n self.word_to_idx[w] = len(self.vocab)\n self.vocab.append(w)\n self.embeddings.append(model[w])\n\n del model","def _index(self, corpus):\n\n # Transform documents to embeddings vectors\n ids, dimensions, stream = self.embedder.model.index(corpus)\n\n # Load streamed embeddings back to memory\n embeddings = np.empty((len(ids), dimensions), dtype=np.float32)\n with open(stream, \"rb\") as queue:\n for x in range(embeddings.shape[0]):\n embeddings[x] = pickle.load(queue)\n\n # Remove temporary file\n os.remove(stream)\n\n all_text = []\n for para_id, text, _ in corpus:\n all_text.append([text, para_id])\n\n df = pd.DataFrame(all_text, columns=[\"text\", \"paragraph_id\"])\n\n embedding_path = os.path.join(\n self.index_path, self.embed_paths[\"embeddings\"])\n dataframe_path = os.path.join(\n self.index_path, self.embed_paths[\"dataframe\"])\n ids_path = os.path.join(self.index_path, self.embed_paths[\"ids\"])\n\n # Load new data\n if os.path.isfile(embedding_path) and (self.encoder_args[\"overwrite\"] is False):\n logger.info(f\"Loading new data from {embedding_path}\")\n\n # Load existing embeddings\n old_embeddings = np.load(embedding_path) # LOAD EMBEDDINGS\n # Remove embeddings with document id overlaps\n embeddings = np.vstack((old_embeddings, embeddings))\n\n # load IDs\n old_ids = [doc_id[:-1] for doc_id in open_txt(ids_path)]\n logger.debug(f\"New ID Length = {len(ids)}\")\n logger.debug(f\"Old ID Length = {len(old_ids)}\")\n # Remove document ids overlaps\n logger.debug(f\"New ID Length = {len(ids)}\")\n ids = old_ids + ids\n logger.debug(f\"Merged ID Length = {len(ids)}\")\n\n # Append new dataframe\n old_df = pd.read_csv(dataframe_path)\n df = pd.concat([old_df, df])\n\n # Store embeddings and document index\n # for future reference\n np.save(embedding_path, embeddings)\n with open(ids_path, \"w\") as fp:\n fp.writelines([i + \"\\n\" for i in ids])\n\n # Save data csv\n df.to_csv(dataframe_path, index=False)\n\n # Normalize embeddings\n self.embedder.normalize(embeddings)\n\n # Save embeddings metadata\n self.embedder.config[\"ids\"] = ids\n self.embedder.config[\"dimensions\"] = dimensions\n\n # Create embeddings index\n logger.info(f\"Creating embeddings and index\")\n self.embedder.embeddings = ANN.create(self.embedder.config)\n logger.info(f\"Created embeddings\")\n\n # Build the index\n self.embedder.embeddings.index(embeddings)\n logger.info(f\"Built the embeddings index\")","def load_embeddings(emb_file, oovs=[], pads=[], sep=' ', lower=False, case_dim=True):\n word2emb = {}\n word2idx = {}\n\n # read and store all word vectors\n for line in open(emb_file, errors = 'ignore', encoding = 'utf-8'):\n try:\n fields = line.strip().split(sep)\n word = fields[0]\n vec = np.asarray(fields[1:], dtype='float32')\n if case_dim:\n is_upper = float(word[0].isupper())\n vec = np.insert(vec, 0, is_upper, axis=0)\n if lower:\n word = word.lower()\n word2emb[word] = vec\n if word not in word2idx:\n word2idx[word] = len(word2idx)\n except Exception as e:\n print('[WARNING] Exception in `load_embeddings`:', e)\n\n # get dimensions from the last vector added\n emb_dim = word2emb[word].shape[0]\n\n # add custom embeddings for special characters\n mu = 0\n sigma = 0.01\n\n for word in pads:\n if word not in word2idx:\n if case_dim:\n vec = npr.normal(mu, sigma, emb_dim-1)\n vec = np.insert(vec, 0, 0., axis=0)\n else:\n vec = npr.normal(mu, sigma, emb_dim)\n word2emb[word] = vec\n word2idx[word] = len(word2idx)\n else:\n print('[WARNING] Padding item ' + word + ' has an embedding vector')\n\n for word in oovs:\n if word not in word2idx:\n if case_dim:\n vec = npr.normal(mu, sigma, emb_dim-1)\n is_upper = float(word[0].isupper())\n vec = np.insert(vec, 0, is_upper, axis=0)\n else:\n vec = npr.normal(mu, sigma, emb_dim)\n word2emb[word] = vec\n word2idx[word] = len(word2idx)\n else:\n print('[WARNING] OOV alias ' + word + ' has an embedding vector')\n\n # create an embedding matrix\n vocab_size = len(word2emb)\n emb_matrix = np.zeros((vocab_size, emb_dim))\n for word, idx in word2idx.items():\n if word in word2emb:\n vec = word2emb[word]\n if vec is not None and vec.shape[0] == emb_dim:\n emb_matrix[idx] = np.asarray(vec)\n\n # print feedback data and return mappings\n print('[INFO] Embedding vocabulary:', emb_matrix.shape[0], '(lowercase: ' + str(lower) + ')')\n print('[INFO] OOV aliases:', oovs)\n print('[INFO] Padding items:', pads)\n print('[INFO] Embedding dimensions:', emb_dim, '(extra case dimension: ' + str(case_dim) + ')')\n return word2idx, np.asarray(emb_matrix), emb_dim","def new_counts_dict():\n\n\tIN_FILES = [\"../_semtag_dataset_webanno_tfidf_inimigo.txt\",\"../_semtag_dataset_webanno_tfidf_publico.txt\" ]\n\n\ttxt = []\n\tfor in_file in IN_FILES:\n\t with codecs.open(in_file,\"r\",\"utf-8\") as fid:\n\t txt += fid.readlines()\n\t#words\n\twords = [w for m in txt for w in m.split()]\n\t#unique words\n\twords = list(set(words))\n\t#word index\n\twrd2idx = {w:-1 for w in words}\n\n\tset_trace()\n\t\n\twith open(COUNTS_DIC,\"w\") as fod:\n\t\tcPickle.dump(wrd2idx, fod, cPickle.HIGHEST_PROTOCOL)","def load_word2vec_en_pretrained():\r\n log.info(\"Load W2V Model\")\r\n model = api.load(\"glove-wiki-gigaword-50\")\r\n return PreTrainedGensimEN(model)","def load_embeddings(embeddings_path):\n\n embeddings_index = {}\n f = open(embeddings_path, encoding='utf-8')\n for line in tqdm(f):\n values = line.rstrip().split(' ')\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n f.close()\n print('Found {} word vectors.'.format(len(embeddings_index)))\n return embeddings_index","def read_old_glove(filepath):\n print('reading glove files:', filepath)\n\n word2idx = {}\n word_embed = [['0'] * 300] # word_embed[0] = [0] * 300, represent the <PAD>\n\n with open(filepath, 'r') as f:\n for idx, line in enumerate(f):\n line_list = line.split()\n word = ' '.join(line_list[: len(line_list)-300])\n embed = [num for num in line_list[len(line_list)-300:]]\n\n word2idx[word] = idx + 1\n word_embed.append(embed)\n\n return word2idx, word_embed","def get_vocabulary(text_fname, vocab_fname):\n with codecs.open(text_fname,'r','utf-8') as infile, \\\n codecs.open(vocab_fname,'w','utf-8') as outfile: \n\n count_map={}\n for line in infile:\n sent=line.strip().split(' ')\n for w in sent:\n count_map[w]=count_map.get(w,0.0)+1.0\n\n for w,c in count_map.iteritems(): \n outfile.write(u'{}|{}\\n'.format(w,c))","def generate_vocab():\n\n vocab_dict = {}\n folder_path = os.listdir(args.f)\n for subfolder in folder_path:\n subfolder_path = os.path.join(args.f, subfolder)\n for filename in os.listdir(subfolder_path):\n with open(os.path.join(subfolder_path, filename), 'r') as file:\n read_file = file.read()\n normalised_text = re.sub(r\"[^\\s\\w]\", \" \", read_file.lower())\n vocab = normalised_text.split() #.split() creates a list of strings\n vocab_dict.update({i: 0 for i in vocab})\n return vocab_dict","def _make_word_dictionary(self,annos):\n # get training annos\n train_annos = self.annos[\"train\"]\n # read tokens\n tokens_list = []\n for ann in train_annos:\n tokens_list += [tk for tk in ann[\"tokens\"]]\n # print results: count tokens and show top-n\n print(\"Top-{} tokens list:\".format(self.cfg.DATASET.SHOW_TOP_VOCAB))\n tokens_count = sorted(Counter(tokens_list).items(), key=lambda x:x[1])\n for tk in tokens_count[-self.cfg.DATASET.SHOW_TOP_VOCAB:]:\n print(\"\\t- {}: {}\".format(tk[0],tk[1]))\n # make wtoi, itow\n wtoi = {}\n wtoi[\"<PAD>\"], wtoi[\"<UNK>\"] = 0, 1\n wtoi[\"<S>\"], wtoi[\"<E>\"] = 2, 3\n for i,(tk,cnt) in enumerate(tokens_count):\n idx = i+4 # idx start at 4\n wtoi[tk] = idx\n itow = {v:k for k,v in wtoi.items()}\n self.cfg.MODEL.QUERY.EMB_IDIM = len(wtoi)\n return wtoi, itow","def load_embeddings(filepath, vocabulary, retain):\n \n word2index = dict()\n word_vectors = list()\n\n def add_entry(word, vector):\n word2index[word] = len(word2index)\n word_vectors.append(vector)\n\n model = gensim.models.KeyedVectors.load(filepath)\n\n # adding special tokens <FIL>, <UNK> and <NUM>\n dim = model.vector_size\n add_entry('<fil>', np.zeros((dim,)))\n for special in ['<unk>', '<num>']:\n vector = np.random.uniform(-0.025, 0.025, (dim,))\n add_entry(special, vector)\n\n if retain:\n for word, _ in model.vocab.items():\n add_entry(word, model[word])\n else:\n for word in vocabulary:\n if word in model:\n add_entry(word, model[word])\n\n vocabulary = vocabulary.intersection(word2index.keys())\n return word2index, np.asarray(word_vectors)","def build_doc_sense_vec(self):\n\t\twith codecs.open(self.vocab_file, encoding='utf-8', mode='r') as infile:\n\t\t\tline = infile.readline()\n\t\t\ti = 0\n\t\t\twhile line:\n\t\t\t\tword = line.split()[0]\n\t\t\t\tif not self.word2IdVocabulary.has_key(word):\n\t\t\t\t\t# print i, word\n\t\t\t\t\t# else:\n\t\t\t\t\tself.word2IdVocabulary[word] = i\n\t\t\t\tif not self.id2WordVocabulary.has_key(i):\n\t\t\t\t\tself.id2WordVocabulary[i] = word\n\t\t\t\tline = infile.readline()\n\t\t\t\ti += 1\n\t\t\tself.vocab_num = len(self.word2IdVocabulary)\n\t\t\tprint \"vocabulary number:\" + str(self.vocab_num)\n\n\t\twith codecs.open(self.vec_file, encoding='utf-8', mode='r') as vecfile:\n\t\t\twith codecs.open(self.vec_out_file, encoding='utf-8', mode='a+') as vec_outfile:\n\n\t\t\t\tfor i, line in enumerate(vecfile):\n\t\t\t\t\tif i % 10000 == 0:\n\t\t\t\t\t\tprint i\n\t\t\t\t\t# if i > 72:\n\t\t\t\t\t# \tbreak\n\t\t\t\t\tif i == 0:\n\t\t\t\t\t\ta, b, c = map(int, line.split()[:3])\n\t\t\t\t\t\tprint('Number of sememes: {}\\n'\n\t\t\t\t\t\t\t 'Number of words: {}\\n'\n\t\t\t\t\t\t\t 'Dimension of vectors: {}'.format(a, b, c))\n\t\t\t\t\telif i > 462667:\n\t\t\t\t\t\tsline = line.strip('\\n').split()\n\t\t\t\t\t\tword = sline[0]\n\t\t\t\t\t\tvector_list = []\n\t\t\t\t\t\tvector_list.append(sline[1:])\n\t\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\t\tword_id = self.word2IdVocabulary[word]\n\t\t\t\t\t\tif not self.vectors.has_key(word_id):\n\t\t\t\t\t\t\tself.vectors[word_id] = vector_array\n\t\t\t\t\t\t# vector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t\tif not self.vector_mean.has_key(word_id):\n\t\t\t\t\t\t\tself.vector_mean[word_id] = vector_array\n\t\t\t\t\t\t# vec_outfile.write(line)\n\t\t\t\t\telif i > 462887:\n\t\t\t\t\t\tbreak\n\t\t\t\t\telse:\n\t\t\t\t\t\tsline = line.strip('\\n').split()\n\t\t\t\t\t\tword = sline[0]\n\t\t\t\t\t\tsense_num = int(sline[1])\n\t\t\t\t\t\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\n\t\t\t\t\t\tvector_list = []\n\t\t\t\t\t\tfor start in range(0, len(vectors), c):\n\t\t\t\t\t\t\tvector_list.append(list(map(float, vectors[start: start+c])))\n\t\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\t\tword_id = self.word2IdVocabulary[word]\n\t\t\t\t\t\tif not self.vectors.has_key(word_id):\n\t\t\t\t\t\t\tself.vectors[word_id] = vector_array\n\t\t\t\t\t\tvector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t\tif not self.vector_mean.has_key(word_id):\n\t\t\t\t\t\t\tself.vector_mean[word_id] = vector_mean\n\t\t\t\t\t\t'''j = 0\n\t\t\t\t\t\tfor each_sense_vec in vector_array:\n\t\t\t\t\t\t\tif len(vector_array) > 1:\n\t\t\t\t\t\t\t\tnew_line = word + '_' + str(j) + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tformatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\n'\n\t\t\t\t\t\t\t\tj += 1\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tnew_line = word + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t formatter={'float_kind': lambda\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t x: '%6f' % x})[1:-1] + '\\n'\n\n\t\t\t\t\t\t\tvec_outfile.write(new_line)'''\n\n\t\twith codecs.open(self.doc_file, encoding='utf-8', mode='r') as docfile:\n\t\t\twith codecs.open(self.doc_out_file, encoding='utf-8', mode='a+') as doc_outfile:\n\t\t\t\twith codecs.open(self.vec_out_file_bydoc, encoding='utf-8', mode='a+') as vec_outfile_bydoc:\n\t\t\t\t\tprint \"Processing document file......\"\n\t\t\t\t\tline = docfile.readline().strip('\\n')\n\t\t\t\t\twhile line:\n\t\t\t\t\t\twords = line.split()\n\t\t\t\t\t\tnew_words = [x for x in words]\n\t\t\t\t\t\tfor i in range(len(words)):\n\t\t\t\t\t\t\tword_id = self.word2IdVocabulary[words[i]]\n\t\t\t\t\t\t\tsense_vecs = self.vectors[word_id]\n\t\t\t\t\t\t\tsense_num = len(sense_vecs)\n\t\t\t\t\t\t\tif sense_num > 1:\n\t\t\t\t\t\t\t\tcontext_words = []\n\t\t\t\t\t\t\t\tfor x in range(i-int(self.context_num), i+int(self.context_num)+1):\n\t\t\t\t\t\t\t\t\tif x != i and 0 <= x < len(words):\n\t\t\t\t\t\t\t\t\t\tcontext_words.append(words[x])\n\t\t\t\t\t\t\t\tsense_index = self.select_attention(context_words, sense_vecs)\n\t\t\t\t\t\t\t\tword_vec_i = sense_vecs[sense_index]\n\t\t\t\t\t\t\t\tnew_wordi = words[i] + '_' + str(sense_index)\n\t\t\t\t\t\t\t\tself.vector_word_doc[new_wordi.encode('utf-8')] = word_vec_i\n\t\t\t\t\t\t\t\tnew_words[i] = new_wordi\n\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tword_vec_i = sense_vecs[0]\n\t\t\t\t\t\t\t\tself.vector_word_doc[words[i].encode('utf-8')] = word_vec_i\n\t\t\t\t\t\t\tvec_outfile_bydoc.write(new_words[i] + ' ' + np.array2string(word_vec_i, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t formatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\n')\n\n\t\t\t\t\t\tdoc_outfile.write(' '.join(new_words) + '\\n')\n\n\t\t\t\t\t\tline = docfile.readline()\n\n\t\treturn self.vector_word_doc","def _extractGloveVects():\n \n embeddings_index = {}\n\n with open(GLOVE_CORPUS_FILE) as f:\n for line in f:\n values = line.split()\n word = values[0].lower()\n if word not in _cachedStopWords:\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n\n return embeddings_index","def getWordEmbeddingsMatrix(script_directory, embedding_file):\n translator = str.maketrans('', '', string.punctuation)\n all_words = []\n print(\"Loading vocab from text files in:\")\n for d in os.listdir(script_directory):\n print(d)\n for fname in os.listdir(\"%s/%s\" % (script_directory, d)):\n with open(\"%s/%s/%s\" % (script_directory, d, fname), 'r') as f:\n words = [w.translate(translator) for w in f.read().split() if w.translate(translator) != \"\"]\n all_words.extend(words)\n\n model = KeyedVectors.load_word2vec_format(embedding_file, binary=True)\n vocab = {\"PAD\" : 0, \"EOS\" : 1}\n vocab.update({w : i + 2 for i,w in enumerate([w1 for w1 in set(all_words) if w1 in model]) })\n inv_dict = vocab.keys()\n ## Take a minute to load...\n\n vocab_size = len(inv_dict)\n emb_size = 300 # or whatever the size of your embeddings\n embeddings = np.zeros((vocab_size + 1, emb_size))\n for k,v in vocab.items():\n embeddings[v] = model[k]\n vocab[\"UNK\"] = len(vocab.keys())\n embeddings[vocab[\"UNK\"]] = np.ones(emb_size)\n del model\n ## Now we have a numpy matrix of embeddings...\n # x_model = tf.placeholder(tf.int32, shape=[None, input_size])\n # with tf.device(\"/cpu:0\"):\n # embedded_x = tf.nn.embedding_lookup(embeddings, x_model)\n return embeddings, vocab","def glove():\n import numpy as np\n \"\"\" Read from Gluons embedding pickle files\"\"\"\n with np.load(glove_model_path) as f:\n matrix = f['idx_to_vec']\n matrix.setflags(write=0)\n return matrix, f['idx_to_token'], token_to_idx(f['idx_to_token'])","def generate_embeddings_sentence_test_data(data, path_out):\n flair.device = torch.device('cpu')\n dicts = []\n # init multilingual BERT\n bert_embedding = TransformerDocumentEmbeddings('bert-base-multilingual-cased')\n counter = 0\n for entry in data:\n print(\"Counter: \", counter)\n counter += 1\n text = entry[\"sentence\"]\n id = entry[\"id\"]\n sent = Sentence(text)\n bert_embedding.embed(sent)\n vec = sent.get_embedding().detach().numpy()\n dicts.append((id,vec))\n gc.collect()\n result = dicts\n file = open(path_out, \"wb\")\n pickle.dump(result, file)\n file.close()\n return result","def read_w2v(w2v_path, word2index, n_dims=300, unk_token=\"unk\"):\n print('Getting Word Vectors...', file=sys.stderr)\n vocab = set()\n # hacky thing to deal with making sure to incorporate unk tokens in the form they are in for a given embedding type\n if unk_token not in word2index:\n word2index[unk_token] = 0 # hardcoded, this would be better if it was a method of a class\n\n word_vectors = np.zeros((len(word2index), n_dims)) # length of vocab x embedding dimensions\n with open(w2v_path) as file:\n lc = 0\n for line in file:\n lc += 1\n line = line.strip()\n if line:\n row = line.split()\n token = row[0]\n if token in word2index or token == unk_token:\n vocab.add(token)\n try:\n vec_data = [float(x) for x in row[1:]]\n word_vectors[word2index[token]] = np.asarray(vec_data)\n if lc == 1:\n if len(vec_data) != n_dims:\n raise RuntimeError(\"wrong number of dimensions\")\n except:\n print('Error on line {}'.format(lc), file=sys.stderr)\n # puts data for a given embedding at an index based on the word2index dict\n # end up with a matrix of the entire vocab\n tokens_without_embeddings = set(word2index) - vocab\n print('Word Vectors ready!', file=sys.stderr)\n print('{} tokens from text ({:.2f}%) have no embeddings'.format(\n len(tokens_without_embeddings), len(tokens_without_embeddings)*100/len(word2index)), file=sys.stderr)\n print('Tokens without embeddings: {}'.format(tokens_without_embeddings), file=sys.stderr)\n print('Setting those tokens to unk embedding', file=sys.stderr)\n for token in tokens_without_embeddings:\n word_vectors[word2index[token]] = word_vectors[word2index[unk_token]]\n return word_vectors","def build_index(in_dir, out_dict, out_postings):\n print('indexing...')\n\n stemmer = stem.PorterStemmer()\n\n #Dictionary for saving our tokens and the reference to their postings list\n dictionary = dict()\n #Number of files that will be indexed\n num_files = 1000000\n #1. We have to open the reuters training docs directory and traverse it, opening each doc.\n #List all files in the dir and sort them by numerical order, to have sorted postings lists\n lst = os.listdir(in_dir)\n lst.sort(key=lambda f: int(re.sub(r'\\D', '', f)))\n\n #2. For each file in the dir:\n for filename in lst:\n #Open it\n f = open(in_dir+\"/\"+filename, \"r\")\n #Read it\n text = f.read()\n #Get the sentences in the file\n sentences = nltk.sent_tokenize(text)\n #This \" \" token will be used for NOT queries\n not_postings_list = dictionary.get(\" \", list())\n not_postings_list.append(int(filename))\n dictionary[\" \"] = not_postings_list\n\n for sentence in sentences:\n #For each sentence get the words that compose it\n words = nltk.word_tokenize(sentence)\n\n for word in words:\n \n word = word.lower()\n word = stemmer.stem(word)\n \n\n #For each word check if its already registered in the dictionary\n #If its not, a new postings list is created for that word\n #If its already registered, its postings list is retrieved\n postings_list = dictionary.get(word, list())\n \n #This is to check if the word is not registered and a postings list \n #was just created for it\n if(len(postings_list) == 0):\n #In that case save the postings list in the dictionary\n dictionary[word] = postings_list\n #Then add the file name (id) in which the word appears\n postings_list.append(int(filename))\n\n #If the word was already in the dictionary, we check that the last entry\n #in its posting list is not the same as the filename (id) we are currently checking\n #as we don't want duplicate doc ids in the postings list\n elif(postings_list[len(postings_list)-1] != int(filename)):\n #So if its the first time that it appears in the file we save the filename (id)\n postings_list.append(int(filename))\n\n #This is to limit the number of docs that will be indexed \n num_files -= 1 \n if(num_files <= 0): \n break\n \n #with open('ugly_dictionary.txt', 'w') as fp:\n #json.dump(dictionary, fp)\n #After checking all the words in the files, we have our dictionary with its postings lists\n # But we don't want to save the postings list with the dictionary as they can be quite large\n # Now we will traverse each word (key) in the dictionary, get its postings list and save it in a different file \n \n postings_list_file = open(out_postings, \"wb\") \n for word in dictionary:\n postings_list = dictionary[word]\n #Know the starting position\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n dictionary[word] = postings_list_position\n #Close the postings lists file\n postings_list_file.close() \n #Now open the dictionary file and save it\n \n with open(out_dict, 'wb') as dictionary_file:\n pickle.dump(dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n '''\n with open(out_dict, 'w') as fp:\n json.dump(dictionary, fp)\n '''","def read_txt_embeddings(path, params):\n word2id = {}\n vectors = []\n\n # load pretrained embeddings\n _emb_dim_file = params.emb_dim\n with io.open(path, 'r', encoding='utf-8', newline='\\n', errors='ignore') as f:\n for i, line in enumerate(f):\n if i == 0:\n split = line.split()\n assert len(split) == 2\n assert _emb_dim_file == int(split[1])\n continue\n word, vect = line.rstrip().split(' ', 1)\n vect = np.fromstring(vect, sep=' ')\n if word in word2id:\n logger.warning(\"Word \\\"%s\\\" found twice!\" % word)\n continue\n if not vect.shape == (_emb_dim_file,):\n logger.warning(\"Invalid dimension (%i) for word \\\"%s\\\" in line %i.\"\n % (vect.shape[0], word, i))\n continue\n assert vect.shape == (_emb_dim_file,)\n word2id[word] = len(word2id)\n vectors.append(vect[None])\n\n assert len(word2id) == len(vectors)\n logger.info(\"Loaded %i pretrained word embeddings from %s\" % (len(vectors), path))\n\n # compute new vocabulary / embeddings\n embeddings = np.concatenate(vectors, 0)\n embeddings = torch.from_numpy(embeddings).float()\n\n assert embeddings.size() == (len(word2id), params.emb_dim)\n return word2id, embeddings","def learn_embeddings(walk_dir,dim,window_size,iter_num,workers,embedding_filename):\r\n logging.debug('begin learning embeddings')\r\n learning_begin_time = time.time()\r\n\r\n walk_files = glob.glob('%s/__random_walks_*.txt' % walk_dir)\r\n sentences = Sentences(walk_files)\r\n model = Word2Vec(sentences, size=dim, window=window_size, min_count=0, sg=1, hs=0, workers=workers, iter=iter_num)\r\n\r\n learning_end_time = time.time()\r\n logging.debug('done learning embeddings')\r\n logging.debug('learning time: {}'.format(learning_end_time - learning_begin_time))\r\n print('learning_time', learning_end_time - learning_begin_time, flush=True)\r\n model.wv.save_word2vec_format(fname=embedding_filename, binary=False)\r\n return model.wv","def loadw2v(embfile, embsize, myzipfile=None, maxvoc=None):\n word_to_ix = {}\n word_to_ix[constants.PAD_ITEM] = 0\n word_to_ix[constants.UNK_ITEM] = 1\n # fill padding word with zeros\n model = [[0.]*embsize]\n # fill unk word with random numbers\n model.append(np.random.normal(0,0.15,size=embsize).tolist())\n if myzipfile != None:\n zip = zipfile.ZipFile(myzipfile, 'r')\n f = zip.read(embfile).split(\"\\n\")\n else:\n #f = open(embfile, 'r')\n f = codecs.open(embfile, \"r\", \"utf-8\")\n ix = 2\n for line in f:\n if maxvoc!=None:\n if ix >= maxvoc:\n break\n splitLine = line.split()\n if(len(splitLine)>embsize+1):\n phrase_lst = splitLine[:-embsize]\n word = ' '.join(phrase_lst)\n embedding = [float(val) for val in splitLine[-embsize:]]\n word_to_ix[word] = ix\n model.append(embedding)\n ix += 1\n elif(len(splitLine)>2):\n word = splitLine[0]\n embedding = [float(val) for val in splitLine[1:]]\n word_to_ix[word]=ix\n model.append(embedding)\n ix += 1\n else:\n print(line)\n print(\"%d words loaded!\" % len(model))\n return word_to_ix, model","def save_dict(emb, path_to_vec, dim=100):\n word_vec = {}\n for w in emb.keys():\n word_vec[w] = emb[w]\n with open(path_to_vec + f'embedding_{str(dim)}d.txt', 'w') as file:\n for w, v in word_vec.items():\n file.write(w + ' ')\n for el in v:\n file.write(\"{:.20f}\".format(float(el)) + ' ')\n file.write('\\n')","def get_word_embeddings(embeddingsPath, allwords, splittype=\" \"):\n word2Idx = {}\n wordEmbeddings = []\n print('Using word embeddings:', embeddingsPath)\n openfile = _get_correct_open(embeddingsPath)\n with openfile(embeddingsPath,'r', encoding='utf-8') as fEmbeddings:\n c = 0\n for line in fEmbeddings:\n c+=1\n split = line.strip().split(splittype)\n if '' in split:\n raise ValueError(\"Error in spacing of word vector file:\"+\n \" bad formatting. Consider using different value of splittype.\")\n word = split[0]\n\n # fastText and Yogatama pre-trained embedding starts with a line\n # with 2 elements that we need to ignore:\n if len(split) <= 5:\n print('Ignoring line '+str(c))\n continue\n\n if len(word2Idx) == 0: #Add padding+unknown\n word2Idx[\"PADDING_TOKEN\"] = len(word2Idx)\n vector = np.zeros(len(split)-1) #Zero vector for 'PADDING' word\n wordEmbeddings.append(vector)\n\n word2Idx[\"UNKNOWN_TOKEN\"] = len(word2Idx)\n vector = np.random.uniform(-0.25, 0.25, len(split)-1)\n wordEmbeddings.append(vector)\n\n if word.lower() in allwords:\n vector = np.array([float(num) for num in split[1:]])\n wordEmbeddings.append(vector)\n word2Idx[word] = len(word2Idx)\n\n wordEmbeddings = np.array(wordEmbeddings)\n return wordEmbeddings, word2Idx","def load_word_embeddings(self, word_embeddings, word_to_ix):\n logger.info(\"Loading the vocabulary\")\n self.vocab = {}\n self.index2word = []\n counts = {}\n for word in word_to_ix:\n counts[word] = counts.get(word, 0) + 1\n self.vocab_size = len(counts)\n self.vector_size = word_embeddings.shape[1]\n self.vectors = np.zeros((self.vocab_size, self.vector_size))\n self.index2word = [None] * self.vocab_size\n logger.info(\"Corpus has %i words\", len(self.vocab))\n for word_id, word in enumerate(counts):\n self.vocab[word] = Vocab(index=word_id, count=counts[word])\n self.vectors[word_id] = word_embeddings[word_to_ix[word]]\n self.index2word[word_id] = word\n assert((len(self.vocab), self.vector_size) == self.vectors.shape)\n logger.info(\"Loaded matrix of %d size and %d dimensions\", self.vocab_size, self.vector_size)","def load_embeddings(path, vocab, source_domain, target_domain, emb_name):\n\n pkl = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\n if os.path.exists(pkl):\n print(\"Load embeddings from existing pkl file %s...\" % pkl)\n # word embeddings weights have been loaded\n embeddings = pickle.load(open(pkl, 'rb'))\n else:\n print(\"Load embedding from %s...\" % path)\n raw_embeddings = {}\n if emb_name == 'yelp_electronics':\n with open(path) as fp:\n for line in fp:\n word_vector = line.split(\",\")[:-1]\n vector_list = []\n for element in word_vector[len(word_vector) - 100:]:\n vector_list.append(float(element))\n word = ','.join(word_vector[:len(word_vector) - 100])\n vector = np.asarray(vector_list)\n if word in vocab:\n raw_embeddings[word] = vector\n else:\n with open(path) as fp:\n for line in fp:\n eles = line.strip().split(' ')\n word = eles[0]\n if word in vocab:\n raw_embeddings[word] = eles[1:]\n\n dim_w = len(raw_embeddings['the'])\n n_words = len(vocab)\n embeddings = np.zeros(shape=(n_words, dim_w))\n for w in vocab:\n wid = vocab[w]\n if w in raw_embeddings:\n embeddings[wid] = np.array([float(ele) for ele in raw_embeddings[w]])\n else:\n # for OOV words, add random initialization\n embeddings[wid] = np.random.uniform(-0.25, 0.25, dim_w)\n print(\"Find %s word embeddings...\" % len(embeddings))\n if not os.path.exists('./work/embeddings'):\n os.mkdir('./work/embeddings')\n emb_path = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\n # write the embedding weights back to the disk\n pickle.dump(embeddings, open(emb_path, 'wb'))\n embeddings = np.array(embeddings, dtype='float32')\n return embeddings","def get_word_embeddings(t, folder, lang=\"en\"):\n vecs_url = f\"https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.{lang}.300.vec.gz\"\n vecs_gz_filename = vecs_url.rpartition(\"/\")[2]\n os.makedirs(folder, exist_ok=True)\n vecs_gz_filepath = os.path.join(folder, vecs_gz_filename)\n\n tokenizer_vocab_size = len(t.vocab)\n\n if wait_for_file_stable(vecs_gz_filepath):\n print(\"Using existing embeddings file\")\n else:\n print(\"Downloading word vectors...\")\n subprocess.run([\" \".join([\"wget\", \"-NP\", folder, vecs_url])], check=True, shell=True)\n\n print(\"Loading into memory...\")\n embeddings_index = dict()\n with gzip.open(vecs_gz_filepath, \"rt\") as zipf:\n firstline = zipf.readline()\n emb_vocab_size, emb_d = firstline.split(\" \")\n emb_vocab_size = int(emb_vocab_size)\n emb_d = int(emb_d)\n for line in zipf:\n values = line.split()\n word = values[0]\n # Only load subset of the embeddings recognised by the tokenizer:\n if word in t.vocab.stoi:\n coefs = np.asarray(values[1:], dtype=\"float32\")\n embeddings_index[word] = coefs\n print(\"Loaded {} of {} word vectors for tokenizer vocabulary length {}\".format(\n len(embeddings_index),\n emb_vocab_size,\n tokenizer_vocab_size,\n ))\n\n # create a weight matrix for words in training docs\n embedding_matrix = np.zeros((tokenizer_vocab_size, emb_d))\n for word, i in t.vocab.stoi.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n return embedding_matrix","def create_vocabulary(sentences, path):\n print('creating vocab..')\n\n word_dict = dict(); vocabulary = dict()\n for sentence in sentences:\n for word in nltk.word_tokenize(sentence):\n if word not in word_dict:\n word_dict[word] = ''\n word_dict['<s>'] = ''\n word_dict['</s>'] = ''\n\n with open(path, encoding=\"utf8\") as f:\n for line in f:\n word, vec = line.split(' ', 1)\n if word in word_dict:\n vocabulary[word] = np.fromstring(vec, sep=' ')\n\n print('vocabulary was created successfully!')\n return vocabulary","def glove_embedding(self, texts, file):\n self.embedding_dict = dict()\n glove_file = open(file, encoding='utf-8')\n for line in glove_file:\n word_vector = line.split()\n word = word_vector[0]\n word_vector_arr = np.asarray(word_vector[1:], dtype='float32')\n self.embedding_dict[word] = word_vector_arr\n glove_file.close()\n \n i = 0\n with pgb.ProgressBar(max_value=len(texts)) as bar:\n for text in texts:\n vec = []\n text = text.split()\n for t in text:\n try:\n vec.append(self.embedding_dict[t.lower()])\n except KeyError:\n pass\n ## There are no matched words\n if len(vec) == 0:\n print(\"len 0 vec\")\n self.word_vec.append(np.zeros((100)))\n else:\n #print(np.array(vec))\n #print(np.array(vec).shape)\n sentence = self.sentence_vec(np.array(vec))\n #print(sentence)\n #print(sentence.shape)\n self.word_vec.append(sentence)\n i += 1\n bar.update(i)\n self.word_vec = np.array(self.word_vec)\n print(self.word_vec.shape)","def id2vec_preprocess(args):\n log = logging.getLogger(\"preproc\")\n log.info(\"Loading docfreq model from %s\", args.docfreq_in)\n df_model = DocumentFrequencies(log_level=args.log_level).load(source=args.docfreq_in)\n coocc_model = Cooccurrences().load(args.input)\n if numpy.any(coocc_model.matrix.data < 0):\n raise ValueError((\"Co-occurrence matrix %s contains negative elements. \"\n \"Please check its correctness.\") % args.input)\n if numpy.any(numpy.isnan(coocc_model.matrix.data)):\n raise ValueError((\"Co-occurrence matrix %s contains nan elements. \"\n \"Please check its correctness.\") % args.input)\n\n try:\n df_meta = coocc_model.get_dep(DocumentFrequencies.NAME)\n if df_model.meta != df_meta:\n raise ValueError((\n \"Document frequency model you provided does not match dependency inside \"\n \"Cooccurrences model:\\nargs.docfreq.meta:\\n%s\\ncoocc_model.get_dep\"\n \"(\\\"docfreq\\\")\\n%s\\n\") % (df_model.meta, df_meta))\n except KeyError:\n pass # There is no docfreq dependency\n\n vs = args.vocabulary_size\n if len(df_model) < vs:\n vs = len(df_model)\n sz = args.shard_size\n if vs < sz:\n raise ValueError(\n \"vocabulary_size=%s is less than shard_size=%s. You should specify a smaller \"\n \"shard_size (e.g. shard_size=%s).\" % (vs, sz, vs))\n vs -= vs % sz\n log.info(\"Effective vocabulary size: %d\", vs)\n df_model = df_model.greatest(vs)\n log.info(\"Sorting the vocabulary...\")\n chosen_words = sorted(df_model.tokens())\n word_indices = {w: i for i, w in enumerate(chosen_words)}\n\n if not os.path.exists(args.output):\n os.makedirs(args.output)\n with open(os.path.join(args.output, \"row_vocab.txt\"), \"w\") as out:\n out.write(\"\\n\".join(chosen_words))\n log.info(\"Saved row_vocab.txt\")\n shutil.copyfile(os.path.join(args.output, \"row_vocab.txt\"),\n os.path.join(args.output, \"col_vocab.txt\"))\n log.info(\"Saved col_vocab.txt\")\n del chosen_words\n\n ccmatrix = extract_coocc_matrix((vs, vs), word_indices, coocc_model)\n\n log.info(\"Planning the sharding...\")\n bool_sums = ccmatrix.indptr[1:] - ccmatrix.indptr[:-1]\n reorder = numpy.argsort(-bool_sums)\n with open(os.path.join(args.output, \"row_sums.txt\"), \"w\") as out:\n out.write(\"\\n\".join(map(str, bool_sums.tolist())))\n log.info(\"Saved row_sums.txt\")\n shutil.copyfile(os.path.join(args.output, \"row_sums.txt\"),\n os.path.join(args.output, \"col_sums.txt\"))\n log.info(\"Saved col_sums.txt\")\n\n log.info(\"Writing the shards...\")\n os.makedirs(args.output, exist_ok=True)\n nshards = vs // args.shard_size\n for row in progress_bar(range(nshards), log, expected_size=nshards):\n for col in range(nshards):\n indices_row = reorder[row::nshards]\n indices_col = reorder[col::nshards]\n shard = ccmatrix[indices_row][:, indices_col].tocoo()\n\n example = tf.train.Example(features=tf.train.Features(feature={\n \"global_row\": _int64s(indices_row),\n \"global_col\": _int64s(indices_col),\n \"sparse_local_row\": _int64s(shard.row),\n \"sparse_local_col\": _int64s(shard.col),\n \"sparse_value\": _floats(shard.data)}))\n\n with open(os.path.join(args.output,\n \"shard-%03d-%03d.pb\" % (row, col)),\n \"wb\") as out:\n out.write(example.SerializeToString())\n log.info(\"Success\")","def _make_index(self, fname, sents, words):\n for w in words:\n # word index for this file only\n findex = []\n\n for ixS, s in enumerate(sents):\n # iterate over each word in the sentencep\n for ixT, token in enumerate(s):\n # could use regex for substring matching instead\n if w == token.lower():\n findex.append((ixS, ixT))\n # keep track of word use frequency\n self._freq[w] += 1\n\n # grow the main index \n self._index[w][fname]= findex","def produce_outputs(self):\n # if self.loaded_aggregated:\n # debug(\"Skippping {} mapping due to preloading\".format(self.base_name))\n # return\n # need to calc term numeric index for aggregation\n\n\n # if self.loaded_preprocessed:\n # debug(\"Skippping {} mapping due to preloading\".format(self.base_name))\n # return\n\n bagger = Bag(vocabulary=self.term_list, weighting=self.base_name, ngram_range=self.ngram_range)\n\n self.embeddings = np.ndarray((0, len(self.term_list)), dtype=np.int32)\n for idx in self.indices.get_train_test():\n texts = Text.get_strings(self.text.data.get_slice(idx))\n vecs = bagger.map_collection(texts, fit=False, transform=True)\n self.embeddings = np.append(self.embeddings, vecs, axis=0)\n del texts\n\n # texts = Text.get_strings(self.text.data.get_slice(test_idx))\n # vec_test = bagger.map_collection(texts, fit=do_fit)\n # del texts\n\n # self.embeddings = np.vstack((vec_train, vec_test))\n\n # self.embeddings = np.append(vec_train, vec_test)\n # self.vector_indices = (np.arange(len(train)), np.arange(len(test)))\n\n # set misc required variables\n self.set_constant_elements_per_instance()","def index2words(index_sentence, vcb_file):\n\n sentence = ''\n indx_dict = {}\n vcb = open(vcb_file).readlines()\n for line in vcb:\n line = line.split()\n indx_dict[int(line[0])] = line[1]\n\n for word in index_sentence:\n\n if word == -1:\n sentence += '_eps_' + ' '\n else:\n sentence += indx_dict[word] + ' '\n return sentence","def prepare_embeddings_dict(ixtow, source, output):\n dim = source[list(source)[0]].shape[0]\n print('Embedding dimension : %d' % dim)\n G = np.zeros((len(ixtow) + 1, dim), dtype=\"float32\")\n print(\"EOS norm:\", np.sum(G[0] ** 2))\n for i in range(1, len(ixtow) + 1):\n word = ixtow[str(i)]\n if word.lower() in source:\n G[i] = source[word.lower()]\n if not np.sum(G[i] ** 2):\n raise ValueError(\"Norm of the embedding null > token %d | word %s\" % (i, word))\n else:\n try:\n if CORRECT[word.lower()] in source:\n print(\"Correcting %s into %s\" % (word.lower(), CORRECT[word.lower()]))\n word = CORRECT[word.lower()]\n G[i] = source[word]\n if not np.sum(G[i] ** 2):\n raise ValueError(\"Norm of the embedding null > token %d | word %s\" % (i, word))\n except:\n print(\"Missing word %s in the given embeddings\" % word)\n pd(G, output)\n return G","def index(self,\n path_in: str,\n path_out: str,\n # path_terms: str\n ) -> Tuple[Dict[str, int], Dict[int, str]]:\n self._docs_processed = 0\n self._start_time = time.time()\n\n # terms = set()\n # with open(path_terms, 'r', encoding='utf8') as fin:\n # for line in fin:\n # terms.add(line.strip('\\n'))\n\n word_to_idx = {}\n idx_to_word = {}\n i = 0\n corpus_idx = []\n for doc in get_docs(path_in):\n doc_idx = []\n for sent in doc:\n for word in sent:\n if word not in word_to_idx:\n word_to_idx[word] = i\n idx_to_word[i] = word\n i += 1\n idx_sent = [word_to_idx[word] for word in sent]\n doc_idx.append(idx_sent)\n corpus_idx.append(doc_idx)\n # doc_idx = []\n self._docs_processed += 1\n self._update_cmd_counter()\n\n if self._docs_processed % self._file_write_threshhold == 0:\n self._update_cmd_time_info()\n self.write_corpus(corpus_idx, path_out)\n corpus_idx = []\n\n self._update_cmd_time_info(end=True)\n self.write_corpus(corpus_idx, path_out)\n self._already_written_to_file = False\n return word_to_idx, idx_to_word","def _init_vocab(self):\n self._word2idx = {}\n self._idx2word = {}\n self.freqs = {}\n self.vocab_size = 0\n\n self._add_word(self.pad_word)\n self._add_word(self.start_word)\n self._add_word(self.end_word)\n self._add_word(self.unk_word)\n\n self.start_word_idx = self.stoi(self.start_word)\n self.end_word_idx = self.stoi(self.end_word)\n self.unk_word_idx = self.stoi(self.unk_word)\n self.pad_word_idx = self.stoi(self.pad_word)\n\n self._special_tokens = {\n 'bos_token': self.start_word,\n 'cls_token': self.start_word,\n 'eos_token': self.end_word,\n 'sep_token': self.end_word,\n 'pad_token': self.pad_word,\n 'unk_token': self.unk_word,\n }\n\n self._special_ids = {\n 'bos_token_id': self.start_word_idx,\n 'cls_token_id': self.start_word_idx,\n 'eos_token_id': self.end_word_idx,\n 'sep_token_id': self.end_word_idx,\n 'pad_token_id': self.pad_word_idx,\n 'unk_token_id': self.unk_word_idx,\n }\n\n self.cls_token_id = self.bos_token_id = self.start_word_idx\n self.eos_token_id = self.sep_token_id = self.end_word_idx\n self.pad_token_id = self.pad_word_idx\n self.unk_token_id = self.unk_word_idx\n\n self.cls_token = self.bos_token = self.start_word\n self.eos_token = self.sep_token = self.end_word\n self.pad_token = self.pad_word\n self.unk_token = self.unk_word","def retrieve_saved_data():\n \n sequences = np.load('sequences.npy')\n test_sequences = np.load('test_sequences.npy')\n labels = np.load('labels.npy')\n \n iw = []\n with open('index_word.json', 'r') as f:\n for l in f:\n iw.append(json.loads(l))\n\n index_word = iw[0]\n index_word = {int(key): word for key, word in index_word.items()}\n\n wi = []\n with open('word_index.json', 'r') as f:\n for l in f:\n wi.append(json.loads(l))\n\n word_index = wi[0]\n word_index = {word: int(index) for word, index in word_index.items()}\n \n vs = len(word_index) + 1\n \n return sequences, labels, test_sequences, word_index, index_word, vs","def _load_vocabulary(self) -> Dict[str, int]:\n\n df_existing_vocab = self._db_connection.get_dataframe(table_name='tfidf_vocabulary', schema='encoded_articles')\n\n df_existing_vocab.set_index('word', inplace=True)\n\n return df_existing_vocab['feature_matrix_index'].to_dict()","def main():\n logging.basicConfig(level=logging.DEBUG)\n custom_embedding = True\n\n # Download embeddings'\n if custom_embedding:\n embedding_path = '../data/custom_embedding.pkl'\n embedding_index_path = '../data/custom_vocab_index.pkl'\n logging.info('Pulling custom embedding from: {}, and custom vocab from: {}'.format(embedding_path, embedding_index_path))\n embedding_matrix = pickle.load(open(embedding_path, 'rb'))\n embedding_index_lookup = pickle.load(open(embedding_index_path, 'rb'))\n\n else:\n logging.warning('Downloading embedding. If downloading for the first time, this make take 5-10 minutes.')\n embedding_url = 'https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz'\n embedding_path = '~/nlp_example/'\n embedding_filename = 'GoogleNews-vectors-negative300.bin.gz'\n lib.download_file(embedding_url, embedding_path, embedding_filename)\n\n # Unpack embedding\n model = gensim.models.KeyedVectors.load_word2vec_format(embedding_path + '/' + embedding_filename, binary=True)\n embedding_matrix = model.syn0\n embedding_index_lookup = dict([(k, v.index) for k, v in model.vocab.items()])\n\n # Create thesaurus\n thesaurus = Thesaurus(embedding_matrix, embedding_index_lookup)\n\n # Find nearest neighbors for examples\n print(thesaurus.synonyms('day'))\n print(thesaurus.synonyms('top'))\n print(thesaurus.synonyms('bottom'))\n print(thesaurus.synonyms('cat'))\n print(thesaurus.synonyms('grown'))\n\n\n pass","def load_embeddings(filename):\n count = 0\n matrix = []\n word_map = {}\n with open(filename, encoding=\"utf8\") as f:\n # with open(filename) as f:\n for line in f:\n line = line.strip()\n items = line.split()\n word = items[0]\n rest = items[1:]\n # print(\"word:\", word)\n word_map[word] = count\n count += 1\n\n rest = list(map(float, rest))\n matrix.append(rest)\n matrix = np.array(matrix)\n return word_map, matrix","def extract_word2vec(fichier, words_indices): \n \n word2vec={} #\n \n #\n with open(fichier,\"r\",encoding=\"utf-8\") as file:\n for line in file:\n line = line.replace(\" \\n\",\"\").split(\" \")\n # Lecture des informations du fichier\n # nombre de mots presents et nombre de features\n if len(line)==2 :\n nb_words=int(line[0])\n nb_feats=int(line[1])\n \n #\n else:\n if line[0] in words_indices:\n word, vec = line[0],np.array(line[1:])\n word2vec[word]=vec\n\n print(\"{} embbedings de taille {} pertinent parmi les {} du fichier\".format(len(word2vec), nb_feats, nb_words))\n\n return word2vec, nb_feats","def _vector_mapping(self) -> dict:\n words = set()\n for file in os.listdir(self.processed_path):\n doc_path = f\"{self.processed_path}/{file}\"\n with open(doc_path, 'r') as f:\n text_words = f.readline().split()\n words = words.union(set(text_words))\n words = list(words)\n words.sort()\n\n return dict(zip(words, range(len(words))))","def build_vocab(train_dir, vocab_dir, vocab_size=5000):\n data_train, _ = read_file(train_dir)\n\n all_data = []\n for content in data_train:\n all_data.extend(content)\n\n counter = Counter(all_data)\n count_pairs = counter.most_common(vocab_size-1)\n words, _ = list(zip(*count_pairs))\n\n open_file(vocab_dir,mode='w').write('\\n'.join(words)+'\\n')","def get_glove_embedding():\n embedding = {}\n N = 400_000\n print(\"Reading glove embedding...\")\n with open(GLOVE_EMBD_PATH, \"rb\") as f:\n for line in tqdm(f, total=N):\n line = line.decode().split()\n word = line[0].lower()\n vector = np.array(line[1:]).astype(np.float32)\n embedding[word] = vector\n\n return embedding","def load_word_to_index(dict_word_to_index_file_name):\n with open(dict_word_to_index_file_name, 'r') as f:\n word_to_index = json.load(f)\n _LAST_INDEX = len(word_to_index) - 2 # Why - 2? Open issue?\n print(\"word_to_index dict restored from '{}'.\".format(dict_word_to_index_file_name))\n word_to_index = defaultdict(lambda: _LAST_INDEX, word_to_index)\n\n return word_to_index","def preprocess(self):\n self.word_to_id, self.unk_word_list = self.build_vocab(mode=\"word\")\n self.word_vocab_size = len(self.word_to_id)\n self.max_word_len = self.get_max_word_length(self.word_to_id)\n # Do not write the same file again\n if not os.path.exists(self.words_vocab_file):\n with open(self.words_vocab_file, 'wb') as f:\n pickle.dump((self.word_to_id, self.unk_word_list), f)\n if self.unit != \"word\":\n self.preprocess_sub_units()","def get_train_data(self, train_data):\n X = []\n Y = []\n\n # word 2 indices and tag 2 indices\n w2i = {} # word to index\n c2i = {} # char to index\n tag2idx = {} # tag2idx\n\n w2i[\"_UNK\"] = 0 # unk word / OOV\n c2i[\"_UNK\"] = 0 # unk char\n c2i[\"<w>\"] = 1 # word start\n c2i[\"</w>\"] = 2 # word end index\n \n \n num_sentences=0\n num_tokens=0\n for instance_idx, (words, tags) in enumerate(read_conll_file(train_data)):\n instance_word_indices = [] #sequence of word indices\n instance_char_indices = [] #sequence of char indices\n instance_tags_indices = [] #sequence of tag indices\n\n for i, (word, tag) in enumerate(zip(words, tags)):\n\n # map words and tags to indices\n if word not in w2i:\n w2i[word] = len(w2i)\n instance_word_indices.append(w2i[word])\n\n if self.c_in_dim > 0:\n chars_of_word = [c2i[\"<w>\"]]\n for char in word:\n if char not in c2i:\n c2i[char] = len(c2i)\n chars_of_word.append(c2i[char])\n chars_of_word.append(c2i[\"</w>\"])\n instance_char_indices.append(chars_of_word)\n\n if tag not in tag2idx:\n tag2idx[tag]=len(tag2idx)\n\n instance_tags_indices.append(tag2idx.get(tag))\n\n num_tokens+=1\n\n num_sentences+=1\n\n X.append((instance_word_indices, instance_char_indices)) # list of word indices, for every word list of char indices\n Y.append(instance_tags_indices)\n\n\n print(\"%s sentences %s tokens\" % (num_sentences, num_tokens), file=sys.stderr)\n print(\"%s w features, %s c features \" % (len(w2i),len(c2i)), file=sys.stderr)\n if self.c_in_dim == 0:\n print(\"char features disabled\", file=sys.stderr)\n\n assert(len(X)==len(Y))\n\n # store mappings of words and tags to indices\n self.set_indices(w2i, c2i, tag2idx)\n\n return X, Y","def load_words_from_file(path, voc_path=None):\n label_to_idx = {}\n dict_size = 0\n label_ids = []\n with open(path, \"r\") as fin:\n for label in fin:\n if label not in label_to_idx:\n label_to_idx[label] = dict_size\n dict_size += 1\n label_ids.append(label_to_idx[label])\n if voc_path:\n with open(voc_path, \"w+\") as fout:\n json.dump(label_to_idx, fout)\n return torch.tensor(label_ids)","def glove(data_fname='glove.840B.300d.txt', out_fname='glove.pkl'):\n words, U, dim = [], [], None\n with open(DATA_DIR + data_fname, 'rb') as f:\n for j, line in enumerate(f):\n x = line.strip().split()\n word, vector, d = x[0], np.ravel(x[1:]), len(x) - 1\n if dim is None: dim = d\n elif d != dim: raise Exception('{0}: {1}!={2}'.format(j, dim, d))\n U.append(vector)\n words.append(word)\n U = np.array(U)\n print \"Found {0} words\".format(len(words))\n print \"Found {0}x{1} embedding matrix\".format(*U.shape)\n with open(DATA_DIR + out_fname, 'wb') as f:\n cPickle.dump((words, U), f)","def dep_w2v(data_fname='deps.words', out_fname='depw2v.pkl'):\n M = np.loadtxt(DATA_DIR + data_fname, converters={0: lambda x: 0})\n M = M[:, 1:]\n print \"Loaded {0}x{1} word vector matrix\".format(*M.shape)\n with open(DATA_DIR + data_fname, 'rb') as f:\n words = [line.split()[0] for line in f]\n with open(DATA_DIR + out_fname, 'wb') as f:\n cPickle.dump((words, M), f)","def save_lda_elements(text_data):\n dictionary = corpora.Dictionary(text_data)\n corpus = [dictionary.doc2bow(text) for text in text_data]\n pickle.dump(corpus, open('corpus.pkl', 'wb'))\n dictionary.save('dictionary.gensim')","def __init__(self, docs, dict_path= 'wordindex.npy'):\n super(NNModel, self).__init__()\n self.stopwords += self.additional_stopwords\n self.words = set(['OOB', 'UNK']) # OOB for out of boundary, UNK for unknown words\n self.docs = []\n\n for doc in docs:\n datum = []\n for word in self.cut_words(doc):\n self.words.add(word)\n datum.append(word)\n self.docs.append(datum)\n\n self.words = list(self.words)\n self.word2idx = dict([(self.words[i], i) for i in range(len(self.words))])\n logging.info(f'{len(docs)} articles loaded, with word bag length: {len(self.words)}')\n if dict_path != '': # save dict\n np.save(DATA_DIR + dict_path, self.word2idx)","def _load_word_embedding(self, lang):\n dict_fold = 'train' # which fold of the data will be used to produce results\n if self.args.task == 'conneau' or self.args.task == 'xling':\n data_dir = os.path.join(self.args.data_dir, 'MUSE')\n lang_path = os.path.join(data_dir, 'wiki.' + lang + '.vec')\n elif self.args.task == 'dinu':\n data_dir = os.path.join(self.args.data_dir, 'dinu')\n lang_path = os.path.join(data_dir, 'embeddings', lang + '.emb.txt')\n elif self.args.task == 'zhang':\n order = [lang,trg]\n if lang == 'en':\n order = order[::-1]\n data_dir = os.path.join(self.args.home_dir,'pkg/UBiLexAT/data/','-'.join(order))\n lang_path = os.path.join(data_dir, 'word2vec.' + lang)\n\n langfile = open(lang_path, encoding=self.args.encoding, errors='surrogateescape')\n words, xs = embeddings.read(langfile, self.args.maxs)\n langfile.close()\n # Build word to index map\n word2ind = {word: i for i, word in enumerate(words)}\n\n return xs, words, word2ind","def prepare_word_emb_matrices(experiment):\r\n\r\n with open(\"public_data/stats/stats_train.pkl\", 'rb') as stats:\r\n stats = pickle.load(stats)\r\n vocab = stats[\"VOCAB\"]\r\n stops = [word.lower() for word in set(stopwords.words('english'))]\r\n vocab = vocab + stops\r\n\r\n if experiment == \"RANDOM\":\r\n word_embs = np.random.uniform(low=-1.0, high=1.0, size=(len(vocab), PARAMS[\"SIZE\"])).astype(\"float32\")\r\n\r\n else:\r\n word_embs = []\r\n count_unk = 0\r\n count_kn = 0\r\n\r\n if experiment == \"5\":\r\n emb_model = KeyedVectors.load_word2vec_format(\"public_data/models/experiment_5/embeddings_5.bin\",\r\n binary=True)\r\n elif experiment == \"6\":\r\n emb_model = Word2Vec.load(\"public_data/models/experiment_6/embeddings_6\")\r\n\r\n elif experiment in [\"7\", \"8\"]:\r\n emb_model = FastText.load_fasttext_format(\"public_data/models/experiment_%s/embeddings_%s.bin\"\r\n %(experiment, experiment))\r\n for word in vocab:\r\n if word in emb_model:\r\n word_embs.append(emb_model[word])\r\n count_kn += 1\r\n else:\r\n word_embs.append(np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\"SIZE\"]))\r\n count_unk += 1\r\n\r\n word_embs = np.array(word_embs).astype(\"float32\")\r\n print(count_unk / (count_kn + count_unk))\r\n\r\n pad = np.zeros(shape=PARAMS[\"SIZE\"]).astype(\"float32\")\r\n unk = np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\"SIZE\"]).astype(\"float32\")\r\n word_embs = np.insert(word_embs, 0, unk, axis=0) #id 1\r\n word_embs = np.insert(word_embs, 0, pad, axis=0) #id 0\r\n\r\n with open(\"public_data/embeddings/word_embeddings_%s.pkl\" %experiment, 'wb') as out:\r\n pickle.dump(word_embs, out, protocol=4)\r\n\r\n return word_embs","def build_index(in_dir, out_dict, out_postings):\n print('indexing...')\n\n maxInt = sys.maxsize\n\n while True:\n # decrease the maxInt value by factor 10 \n # as long as the OverflowError occurs.\n try:\n csv.field_size_limit(maxInt)\n break\n except OverflowError:\n maxInt = int(maxInt/10)\n\n #Dicitionary for saving the normalized weights for document vector\n lengths = dict()\n\n #Number of docs read from csv\n total_docs = 1\n max_docs = 1000\n\n #Data stored in csv read file line by line and save columns data\n with open(os.path.join(in_dir), 'r', encoding=\"utf8\") as data_csv:\n reader = csv.DictReader(data_csv)\n #each line corresponds to a document\n for doc in reader:\n\n #if(total_docs > max_docs):\n # break\n\n #If line is blank, just skip\n if doc is None:\n continue\n \n #save the different columns of the doc\n doc_id = int(doc[\"document_id\"])\n #Remove punctuation in title and content\n doc_title = re.sub(r\"[,;@#?!&$()%\\[\\]°~^_.+=\\\"><`|}{*':/]+ *\", \" \", doc[\"title\"])\n doc_content = re.sub(r\"[,;@#?!&$()%\\[\\]°~^_.+=\\\"><`|}{*':/]+ *\", \" \", doc[\"content\"])\n doc_date = doc[\"date_posted\"]\n doc_year = doc_date[0:4]\n doc_court = doc[\"court\"]\n\n #The dictionaryies are updated, postings lists are updated or new terms added\n update_terms_zones_dictionary(doc_id, doc_title, \".title\")\n update_terms_zones_dictionary(doc_id, doc_content, \".content\")\n update_date_field_dictionary(doc_id, doc_year)\n update_court_field_dictionary(doc_id, doc_court)\n\n total_docs += 1\n\n data_csv.close()\n\n #This section stores the Log TF using the word counts in the postings in the dictionary\n #It saves the Log TF in an auxiliary dictionary named lengths\n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n\n for docID_termF in postings_list:\n #Get the vector for the doc, where the docId is docID_termF[0]\n #If there is no vector for this doc, then create a new dict\n #I am using dictionaries as the vector for the word only for the calculations\n doc_vector = lengths.get(docID_termF[0], dict())\n #I add the logarithmic term frequency to that document vector\n doc_vector[word] = 1 + math.log(docID_termF[1], 10)\n #Save that to its corresponding doc\n lengths[docID_termF[0]] = doc_vector\n\n #This section normalizes the Log TFs \n for doc_vector in lengths.values():\n #We store each of the values in a list and then use:\n #np.linalg.norm to do the normalization = sqrt(sum(values^2))\n weights = doc_vector.values()\n #We get the vectors magnitude\n magnitude = np.linalg.norm(np.array(list(weights)))\n for word in doc_vector.keys():\n #For every word entry in the vector \n #normalize by dividing the weight by the magnitude\n doc_vector[word] = doc_vector[word] / magnitude\n\n #This section replaces the word count in the tuple of the dictionary with the Normalized Log TF\n #It also sorts the postings list by doc ID\n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n new_postings_list = list()\n for docID_termF in postings_list:\n docID_termF = ( docID_termF[0], lengths[docID_termF[0]][word] )\n new_postings_list.append(docID_termF)\n new_postings_list.sort()\n dictionary[word] = new_postings_list\n\n ''' \n with open('ugly_dictionary.txt', 'w') as fp:\n json.dump(dictionary, fp)\n '''\n #Determine the relevance of each doc by the court that it has in its court field\n #Save the relevant docs and their relevance\n relevant_courts_dict = { \"SG Court of Appeal\":2, \"SG Privy Council\":2, \"UK House of Lords\":2, \"UK Supreme Court\":2,\n \"High Court of Australia\":2, \"CA Supreme Court\":2, \"SG High Court\":1.5, \"Singapore International Commercial Court\":1.5,\n \"HK High Court\": 1.5, \"HK Court of First Instance\": 1.5, \"UK Crown Court\": 1.5, \"UK Court of Appeal\": 1.5, \"UK High Court\": 1.5, \n \"Federal Court of Australia\": 1.5, \"NSW Court of Appeal\": 1.5, \"NSW Court of Criminal Appeal\": 1.5, \"NSW Supreme Court\": 1.5}\n\n relevant_docs = dict()\n \n for court_name in relevant_courts_dict:\n court_postings_list = court_dictionary.get(court_name, -1)\n if(court_postings_list != -1):\n for docid in court_postings_list:\n #save a dictionary of docID and its relevance (2 or 1.5) according to its court\n relevant_docs[docid] = relevant_courts_dict[court_name]\n\n #This section traverse each word (key) in the dictionary, get its postings list and save it in a different file \n postings_list_file = open(out_postings, \"wb\") \n for word in dictionary:\n #Get postings list for the word\n postings_list = dictionary[word]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n dictionary[word] = (document_frequency, postings_list_position)\n for date in date_dictionary:\n #Get postings list for the date\n postings_list = date_dictionary[date]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n date_dictionary[date] = (document_frequency, postings_list_position)\n for court in court_dictionary:\n #Get postings list for the date\n postings_list = court_dictionary[court]\n #Get the document frequency\n document_frequency = len(postings_list)\n #Know the starting position for the pointer\n postings_list_position = postings_list_file.tell()\n # Writing to file \n pickle.dump(postings_list, postings_list_file)\n #Replace postings list with reference to the position\n court_dictionary[court] = (document_frequency, postings_list_position)\n #Close the postings lists file\n postings_list_file.close() \n\n #Now open the dictionary file and save the three dictionaries\n with open(out_dict, 'wb') as dictionary_file:\n pickle.dump(total_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(date_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(court_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n pickle.dump(relevant_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\n \n '''\n The structure we have is:\n\n dictionary.txt: Has three dictionaries\n {word.zone : [doc_freq, pointer], word.zone: [doc_freq, pointer], ...}\n {date : [doc_freq, pointer], date: [doc_freq, pointer], ...}\n {court : [doc_freq, pointer], court: [doc_freq, pointer], ...}\n\n postings.txt: Has the postings for the three dictionaries\n For the dictionary postings:\n [[docID,termFrequency],[docID,termFrequency]]\n [[docID,termFrequency]] ...\n For the date_dictionary postings:\n [docId, docId, docId, docId]\n For the court_dictionary postings:\n [docId, docId, docId, docId]\n ...\n\n Both documents together would be:\n { word.zone: [doc_freq, [[docID,termFrequency], ... ]], \n word.zone: [doc_freq, [[docID,termFrequency].}, ...]] }\n { date: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\n { court: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\n\n lengths.txt\n [document: [word: weight, word: weight, ...], document: [word: weight, word: weight, ...]]\n Decided to make it like this to keep control of which weights correspond to which words\n Although for a document I will traverse all the weights to get the score\n If the word is not in the document vector [which in my case is a dictionary], then its weight is 0\n This way I am no using a sparse matrix\n\n '''","def load(cls, filepath) -> 'Word2VecEmbedding':\n with open(filepath, 'rb') as f:\n embedding = pickle.load(f)\n embedding.word2idx = {spell: idx for idx, spell in enumerate(embedding.vocab.idx2word)}\n return embedding","def preprocess_output_vocab(output_file, weights_file):\n labels = ['[PAD]', '[UNK]']\n with open('data/corpora/jawiki/edit_freq.json') as f:\n jawiki_edit_freq = json.load(f)\n with open('data/corpora/lang8/edit_freq.json') as f:\n lang8_edit_freq = json.load(f)\n edit_freq = Counter(jawiki_edit_freq)\n edit_freq.update(lang8_edit_freq)\n ordered = sorted(edit_freq.items(), key=lambda x: x[1], reverse=True)\n labels += [edit for edit, freq in ordered if freq >= 500]\n n_samples = sum(edit_freq[edit] for edit in labels)\n dist = [freq / n_samples for edit, freq in ordered]\n print(ordered[:100])\n print(dist[:100])\n n_classes = len(labels)\n class_weights = [1.] * n_classes\n labels_class_weights = get_class_weights(labels, edit_freq)\n n_correct = edit_freq['$KEEP']\n detect_class_weights = get_class_weights(\n ['CORRECT', 'INCORRECT'],\n {'CORRECT': n_correct, 'INCORRECT': n_samples-n_correct}\n )\n detect_class_weights = [1.] + detect_class_weights\n with open(weights_file, 'w', encoding='utf-8') as f:\n json.dump([labels_class_weights, detect_class_weights], f)\n with open(output_file, 'w', encoding='utf-8') as f:\n f.writelines(f'{label}\\n' for label in labels)\n print(f'{n_classes} edits output to {output_file}.')\n print(f'Class weights output to {weights_file}.')","def build_dictionary_gensim():\r\n\t# if load_dictionary_gensim():\r\n\t#\treturn\r\n\t\r\n\tglobal gensim_dictionary, common_corpus_list\r\n\t\r\n\tprint('\\nbuilding dictionary')\r\n\tgensim_dictionary = gensim.corpora.Dictionary()\r\n\t\r\n\tfor v in common_corpus_list:\r\n\t\tgensim_dictionary.add_documents([v[1].lower().split()])\r\n\t\t\r\n\tgensim_dictionary.save_as_text(paths.path_data_dictionary_txt)\r\n\tgensim_dictionary.save(paths.path_data_dictionary_dict)\r\n\r\n\t# print(gensim_dictionary.token2id)\r\n\tprint(gensim_dictionary)","def get_pretrained_weights(idx_word):\n n = len(idx_word)\n embed_dim = 25\n weights = mx.ndarray.zeros((n, embed_dim))\n print('Start downloading pre-trained vectors, this will take some time')\n glov = api.load(\"glove-twitter-25\")\n print('Pre-trained vectors downloading complete')\n not_in_vocab = 0\n for i in range(n):\n word = idx_word[i]\n try:\n weights[i] = glov[word]\n except: #if not in glove vocabulary\n not_in_vocab += 1\n weights[i] = mx.nd.random.normal(0, 0.1, embed_dim)\n if not_in_vocab > 0:\n print('Warning: {} words not in vocab of pretrained embeddings (glove-twitter-25)'.format(not_in_vocab))\n return weights","def make_embeddings(self):\n\t\tprint(\"Presetting embedding weights\")\n\t\t\t\n\t\tnp.random.seed(0)\n\t\tweights = np.random.uniform(low = -0.05, high = 0.05, size = (self.FREQCAP, self.EMB_SIZE))\n\t\t\n\t\tcounter = 0\n\n\t\twords = []\n\t\tweights_tmp = []\n\n\t\twith open(self.embeddingpath) as handle:\n\t\t\tfor i, line in enumerate(handle):\n\t\t\t\ttmp = line.strip()\n\t\t\t\tif len(tmp) > 0:\n\t\t\t\t\tsplit = tmp.split(\" \")\n\t\t\t\t\tif split[0] in self.worddict and len(split[1:]) == 300:\n\t\t\t\t\t\twords.append(split[0])\n\t\t\t\t\t\tweights_tmp.append([float(a) for a in split[1:]])\n\t\t\n\t\tweights_tmp = np.array(weights_tmp)\n\n\t\tfor word, column in zip(words, weights_tmp):\n\t\t\tif self.worddict[word] < self.FREQCAP:\n\t\t\t\tcounter += 1\n\t\t\t\tweights[self.worddict[word],:] = column\n\t\t\n\t\tprint(\"Set\", counter, \"of\", weights.shape[0], \"columns\")\n\t\t\n\t\tif self.EMB_SIZE < weights.shape[-1]:\n\t\t\tprint(\"Reducing dimensionality to\", self.EMB_SIZE)\n\t\t\tpca = PCA(self.EMB_SIZE)\n\t\t\tweights = pca.fit_transform(weights)\n\t\t\n\t\tself.embeddings = [weights]","def load_indices(mode='char', words=None, counts=None):\n if os.path.exists(mode+'indices.p'):\n indices = pickle.load(open(mode+'indices.p', 'rb'), encoding='latin1')\n else:\n indices = {}\n i = 0\n for word in counts.keys():\n indices[word] = int(i)\n indices[i] = str(word)\n i += 1\n print(\"i is: \" + str(i))\n print(\"len is: \" + str(len(indices.keys())))\n pickle.dump(indices, open(mode+'indices.p', 'wb'))\n return indices","def get_WS(w2v):\n # get set of MAX_NGRAM-grams in text\n lines = open(INFNAME_FORMAT.format(\"train\")).readlines() \\\n + open(INFNAME_FORMAT.format(\"test\")).readlines()\n raw = [process_line(l) for l in lines ]\n ngrams_in_data = set()\n for words in raw:\n for ngram in tweet_to_ngrams(words):\n ngrams_in_data.add(ngram)\n\n # load sentiment features from model\n clf_pipe = pickle.load(open(CLF_FNAME, 'rb')) # model\n\n vect = clf_pipe.best_estimator_.named_steps['vect']\n clf = clf_pipe.best_estimator_.named_steps['clf']\n\n features_to_sent_idx = vect.vocabulary_ # map from model features to sentiment index\n # currently, sentiment = 2 * (count_pos / (count_pos + count_neg)) - 1\n sentiments = clf.feature_count_[1,:] / np.sum(clf.feature_count_, axis=0) # in [0,1]\n sentiments = 2 * sentiments - 1 # rescale to [-1,1]\n\n features_to_sent = {feat: sentiments[idx] for (feat,idx) in features_to_sent_idx.items()}\n\n # build WS and ngram_idx_map for each MAX_NGRAM-gram in the text\n k = len(next(iter(w2v.values()))) # dimension of embedding\n WS = np.zeros(shape=(len(ngrams_in_data) + 1, k + MAX_NGRAM), dtype='float32')\n ngram_idx_map = {}\n\n index = 1 # first row is left 0, for padding in the cnn. This is also neutral sentiment.\n # For Vader Sentiment analysis\n# vader_analyzer = SentimentIntensityAnalyzer()\n\n\n for ngram in ngrams_in_data:\n ngram_idx_map[ngram] = index\n\n # set word embedding, note that unknown words already randomized in load_embedding \n words = ngram.split(' ')\n WS[index,:k] = w2v[words[-1]] # embedding of last word\n\n # set sentiment embedding\n for n in range(MAX_NGRAM): # for 1, 2, ... length ngrams\n sub_ngram = ' '.join(words[-1 - n:]) \n\n # Naive Bayes Sentiment feature --------------------------------\n sent = features_to_sent.get(sub_ngram, 0.0) # default to neutral 0\n # --------------------------------------------------------------\n\n# # TextBlob sentiment feature -----------------------------------\n# sent = TextBlob(sub_ngram).sentiment.polarity\n# # --------------------------------------------------------------\n\n# # Vader sentiment feature -------------------------------------\n# sent = vader_analyzer.polarity_scores(sub_ngram)['compound']\n# # -------------------------------------------------------------\n WS[index,k+n] = sent\n\n index += 1\n\n return WS, ngram_idx_map","def create_index(self, vocabulary=[]) -> dict:\n try:\n out = {}\n for word in vocabulary:\n if word in out:\n out[word] += 1\n else: \n out[word] = 1\n return(out)\n except Exception as error:\n print(f\"Error: self.create_index([...]) -> {error}\")","def gen_data(self):\n\n # 1，read the source text\n inputs, labels = self.read_data()\n print(\"read finished\")\n\n # 2. word label index\n word_to_index, label_to_index = self.gen_word_label_index()\n # print(\"word_to_index\",word_to_index)\n # print(\"label_to_index\",label_to_index)\n print(\"vocab process finished\")\n #\n # 3，input to index\n inputs_idx = self.trans_to_index(inputs, word_to_index)\n # print((inputs_idx))\n print(\"index transform finished\")\n #\n # 4, padding\n inputs_idx = self.padding(inputs_idx, self._sequence_length)\n # print(inputs_idx)\n print(\"padding finished\")\n\n # 6，label to index\n labels_idx = self.trans_label_to_index(labels, label_to_index)\n print(\"label index transform finished\")\n\n return np.array(inputs_idx), np.array(labels_idx)","def load_vocab(vocab):\r\n\tvocab = [line.split()[0] for line in open(\r\n\t\t'{}{}'.format(pm.vocab_path, vocab), 'r', encoding='utf-8').read().splitlines()\r\n\t\t\t if int(line.split()[1]) >= pm.word_limit_size]\r\n\tword2idx_dic = {word: idx for idx, word in enumerate(vocab)}\r\n\tidx2word_dic = {idx: word for idx, word in enumerate(vocab)}\r\n\treturn word2idx_dic, idx2word_dic","def create_word_map(tokenized_descriptions_file_path, word_dictionary_output_path):\n if os.path.exists(word_dictionary_output_path):\n print(\"Word map already exists in workspace. Will be reused.\")\n return\n\n print(\"Word map not found. Generating....\")\n\n words_list = []\n words_to_id = {}\n\n with open(tokenized_descriptions_file_path, 'r') as file:\n for line in file:\n tokens = line.strip().split(\",\")\n words_list.extend(tokens[1:])\n\n # remove duplicate words\n words_list = list(set(words_list))\n\n # sorting the words\n words_list = sorted(words_list)\n for i in range(len(words_list)):\n words_to_id[words_list[i]] = i\n\n with open(word_dictionary_output_path, 'w') as f:\n [f.write('{0},{1}'.format(key, value) + \"\\n\") for key, value in words_to_id.items()]"],"string":"[\n \"def make_idx2word():\\n idx2word = {}\\n d = train_data.shared['word2idx']\\n for word, idx in d.items():\\n print(word)\\n idx2word[idx] = word\\n if config.use_glove_for_unk:\\n d2 = train_data.shared['new_word2idx']\\n for word, idx in d2.items():\\n print(word)\\n idx2word[idx+len(d)] = word\\n return idx2word\",\n \"def generate_conll2003_embeddings():\\n glove_embedding = get_glove_embedding()\\n\\n word2index = {}\\n idx2word = {}\\n embed_array = []\\n\\n word2index[\\\"<pad>\\\"] = 1\\n embed_array.append(init_embedding())\\n\\n word2index[\\\"<unk>\\\"] = 0\\n embed_array.append(init_embedding())\\n\\n data = []\\n with open(TRAIN_DATA_PATH, \\\"r\\\") as f:\\n for line in f:\\n data.append(json.loads(line))\\n\\n idx = 2\\n\\n for sample in tqdm(data, total=len(data)):\\n words = sample[\\\"tokens\\\"]\\n\\n for w in words:\\n w = w.lower()\\n\\n # if word is not present in dictionary, add to dictionary and append embedding vector\\n if w not in word2index.keys():\\n word2index[w] = idx\\n idx += 1\\n if w not in glove_embedding.keys():\\n ev = init_embedding()\\n else:\\n ev = glove_embedding[w]\\n\\n embed_array.append(ev)\\n\\n else:\\n continue\\n\\n # save embeddings\\n embed_array = np.vstack(embed_array)\\n np.save(EMBD_OUTPUT_PATH, embed_array)\\n\\n # save dictionary\\n print(\\\"Dicitionary Size: \\\", len(word2index))\\n with open(DICTIONARY_OUTPUT_PATH, \\\"w\\\") as f:\\n json.dump(word2index, f)\",\n \"def make_word2id():\\r\\n with open(\\\"public_data/stats/stats_train.pkl\\\", 'rb') as stats:\\r\\n stats = pickle.load(stats)\\r\\n vocab = stats[\\\"VOCAB\\\"]\\r\\n word2id = {word: id for id, word in enumerate([\\\"PAD\\\"] + [\\\"UNK\\\"] + vocab)}\\r\\n with open('public_data/vocab/word2id.pkl', 'wb') as out:\\r\\n pickle.dump(word2id, out, protocol=4)\",\n \"def sentences_2_idxs(self):\\n fo_pos = open(self.config.parsed_train_file_pos, 'w')\\n fo_neg = open(self.config.parsed_train_file_neg, 'w')\\n self.load_dicts()\\n labels = pd.read_csv(self.config.train_file, usecols=[\\\"target\\\"])\\n\\n labels = list(labels.values[:, 0])\\n questions = pd.read_csv(self.config.train_file,\\n usecols=[\\\"question_text\\\"], index_col=False)\\n unk_idx = self.word2idx.get(self.config.unknown_token)\\n\\n for label, quest in zip(labels, questions.question_text):\\n tokens = preprocess_text(quest)\\n\\n if self.config.include_unknown:\\n idxs = [self.word2idx.get(token, unk_idx) for token in\\n tokens]\\n else:\\n idxs = [self.word2idx.get(token) for token in tokens]\\n idxs = [idx for idx in idxs if idx]\\n out_line = (str(\\\" \\\".join(str(num) for num in idxs)) + \\\"\\\\n\\\")\\n if label == 1:\\n fo_pos.write(out_line)\\n else:\\n fo_neg.write(out_line)\",\n \"def make_embedding(path, words, indices):\\n #root = '/'.join(path.split('/')[0:-1])\\n #all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\\n #for path in all_paths:\\n vec_path = 'data/'+path.split('/')[-1]+'_'+mode\\n print(vec_path)\\n if os.path.exists(vec_path+'.npy'):\\n np_vecs = np.load(vec_path+'.npy')\\n else:\\n words_len = len(words)\\n vecs = []\\n if mode == 'word':\\n f = load_model('wiki.en.bin')\\n for i, w in enumerate(words):\\n if mode == 'word':\\n vec = f.get_word_vector(w)\\n else:\\n vec = eye[indices[w]]\\n vecs.append(vec) \\n if i % 10000 == 0:\\n print(\\\"{} / {}\\\".format(i, words_len))\\n np_vecs = np.asarray(vecs, dtype=np.int8)\\n np.save(vec_path, np_vecs)\\n return np_vecs\",\n \"def get_word_embeddings(self):\\n embedding_index = {}\\n with open('./glove/glove.6B.100d.txt', encoding=\\\"utf8\\\") as f:\\n for line in f:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embedding_index[word] = coefs\\n return embedding_index\",\n \"def build_vocab(words, vocab_size, visual_fld=None):\\n utils.safe_mkdir(visual_fld)\\n file = open(os.path.join(visual_fld, 'vocab.tsv'), 'w',encoding='utf8')\\n\\n dictionary = dict()\\n count = [('UNK', -1)]\\n index = 0\\n count.extend(Counter(words).most_common(vocab_size - 1))\\n\\n for word, _ in count:\\n dictionary[word] = index\\n index += 1\\n file.write(word + '\\\\n')\\n\\n index_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\\n file.close()\\n return dictionary, index_dictionary\",\n \"def construct_embedding(self):\\n i = 0\\n self.load_dicts()\\n embedding_shape = (max(self.word2idx.values()) + 1,\\n self.embedding_size)\\n self.embedding = np.zeros(embedding_shape)\\n\\n with open(self.config.word_vec_fi_glove, 'r') as fi:\\n for line in fi:\\n word_vec = line.split(\\\" \\\")[1:]\\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\\n i += 1\\n\\n self.write_embedding()\",\n \"def predict_sentences_2_idxs(self):\\n fo = open(self.config.parsed_predict_file, 'w')\\n self.load_dicts()\\n\\n questions = pd.read_csv(self.config.predict_file,\\n usecols=[\\\"question_text\\\"], index_col=False)\\n unk_idx = self.word2idx[self.config.unknown_token]\\n\\n for quest in questions.question_text:\\n tokens = preprocess_text(quest)\\n if self.config.include_unknown:\\n idxs = [self.word2idx.get(token, unk_idx) for token in\\n tokens]\\n else:\\n idxs = [self.word2idx.get(token) for token in tokens]\\n idxs = [idx for idx in idxs if idx]\\n fo.write((str(\\\" \\\".join(str(num) for num in idxs)) + \\\"\\\\n\\\"))\",\n \"def gen_embedding(path):\\r\\n word_emb = {}\\r\\n with open(path, encoding='utf-8') as f:\\r\\n for line in tqdm(f):\\r\\n values = line.split()\\r\\n word_emb[values[0]] = np.asarray(values[1:], dtype='float32')\\r\\n return word_emb\",\n \"def get_weibo_data(vocab_file, vector_file):\\n if os.path.exists(\\\"word_misc.pkl\\\"):\\n return cPickle.load(open(\\\"word_misc.pkl\\\", \\\"rb\\\"))\\n\\n word_misc, word2id, id2word = {}, {}, {}\\n word_count = 0\\n\\n # vocab file\\n print \\\"Building vocabulary ...\\\"\\n for lines in open(vocab_file).readlines():\\n word = lines.split()[0]\\n if not is_unwanted_words(word, ['', '\\\\n']):\\n word2id[word] = word_count\\n id2word[word_count] = word\\n word_count += 1\\n word2id['_START'] = word_count\\n id2word[word_count] = '_START'\\n word_count += 1\\n word2id['_END'] = word_count\\n id2word[word_count] = '_END'\\n word_count += 1\\n word2id['_UNK'] = word_count\\n id2word[word_count] = '_UNK'\\n word_count += 1\\n word2id['_MASK'] = word_count\\n id2word[word_count] = '_MASK'\\n word_count += 1\\n print \\\"Vocabulary size:\\\", word_count\\n\\n # Initialization is refered to in https://www.tensorflow.org/versions/r0.7/tutorials/word2vec/index.html\\n word_emb = (1/np.sqrt(word_count)*(2*np.random.rand(word_count, options['embedding_size']) - 1)).tolist()\\n\\n # load word vectors\\n for lines in open(vector_file).readlines()[1:]:\\n word = lines.split()[0]\\n #if word == '</s>' or word not in word2id.keys():\\n # continue\\n if word not in word2id.keys():\\n continue\\n ids = word2id[word]\\n #print ids, lines, len(word_emb)\\n word_emb[ids] = [float(w) for w in lines.split()[1:]]\\n\\n print len(word_emb), \\\"words have been loaded with\\\", len(word_emb[0]), \\\"dimensions\\\"\\n\\n # load word misc\\n word_misc['id2word'] = id2word\\n word_misc['word2id'] = word2id\\n word_misc['word_count'] = word_count\\n word_misc['word_emb'] = word_emb\\n cPickle.dump(word_misc, open(\\\"word_misc.pkl\\\", \\\"wb\\\"))\\n print \\\"Dump complete.\\\"\\n return word_misc\",\n \"def build_vocab(data):\\n # data = _read_words(filename)\\n counter = collections.Counter(data)\\n # print('counter', counter) # dictionary for the occurrence number of each word, e.g. 'banknote': 1, 'photography': 1, 'kia': 1\\n count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))\\n # print('count_pairs',count_pairs) # convert dictionary to list of tuple, e.g. ('ssangyong', 1), ('swapo', 1), ('wachter', 1)\\n words, _ = list(zip(*count_pairs))\\n word_to_id = dict(zip(words, range(len(words))))\\n # print(words) # list of words\\n # print(word_to_id) # dictionary for word to id, e.g. 'campbell': 2587, 'atlantic': 2247, 'aoun': 6746\\n return word_to_id\",\n \"def build_idx(vocab):\\n word2index = {}\\n index2word = {}\\n\\n word2index['PAD'] = 0\\n index2word[0] = 'PAD'\\n\\n word2index['UNK'] = 1\\n index2word[1] = 'UNK'\\n\\n for i,word in enumerate(vocab):\\n word2index[word.lower()] = i+2\\n index2word[i+2] = word.lower()\\n\\n return word2index, index2word\",\n \"def load_word2vec(emb_path, id_to_word, word_dim, old_weights):\\n new_weights = old_weights\\n print('Loading pretrained embeddings from {}...'.format(emb_path))\\n pre_trained = {}\\n emb_invalid = 0\\n for i, line in enumerate(codecs.open(emb_path, 'r', 'utf-8')):\\n line = line.rstrip().split()\\n if len(line) == word_dim + 1:\\n pre_trained[line[0]] = np.array(\\n [float(x) for x in line[1:]]\\n ).astype(np.float32)\\n else:\\n emb_invalid += 1\\n if emb_invalid > 0:\\n print('WARNING: %i invalid lines' % emb_invalid)\\n c_found = 0\\n c_lower = 0\\n c_zeros = 0\\n n_words = len(id_to_word)\\n # Lookup table initialization\\n for i in range(n_words):\\n word = id_to_word[i]\\n if word in pre_trained:\\n new_weights[i] = pre_trained[word]\\n c_found += 1\\n elif word.lower() in pre_trained:\\n new_weights[i] = pre_trained[word.lower()]\\n c_lower += 1\\n elif re.sub('\\\\d', '0', word.lower()) in pre_trained:\\n new_weights[i] = pre_trained[\\n re.sub('\\\\d', '0', word.lower())\\n ]\\n c_zeros += 1\\n print('Loaded %i pretrained embeddings.' % len(pre_trained))\\n print('%i / %i (%.4f%%) words have been initialized with '\\n 'pretrained embeddings.' % (\\n c_found + c_lower + c_zeros, n_words,\\n 100. * (c_found + c_lower + c_zeros) / n_words)\\n )\\n print('%i found directly, %i after lowercasing, '\\n '%i after lowercasing + zero.' % (\\n c_found, c_lower, c_zeros\\n ))\\n return new_weights\",\n \"def load_target_vocab(self):\\n vocab = [line.split()[0] for line in open(os.path.join('preprocessed', 'all_vocab.txt'), 'r').read().splitlines()]\\n self.word2idx = {word: idx for idx, word in enumerate(vocab)}\\n self.idx2word = {idx: word for idx, word in enumerate(vocab)}\\n self.vocab_size = len(self.word2idx)\",\n \"def get_word_embedding(counter, emb_file, emb_size, vocab_size, vec_size, vocab_file):\\n print(\\\"Generating word embedding...\\\")\\n # load word embeddings\\n embedding_dict = {}\\n with open(emb_file, \\\"r\\\", encoding=\\\"utf-8\\\") as fh:\\n for line in tqdm(fh, total=emb_size):\\n array = line.split()\\n word = \\\"\\\".join(array[0:-vec_size])\\n vector = list(map(float, array[-vec_size:]))\\n embedding_dict[word] = vector\\n\\n TRANSLATE = {\\n \\\"-lsb-\\\": \\\"[\\\", \\\"-rsb-\\\": \\\"]\\\", \\\"-lrb-\\\": \\\"(\\\", \\\"-rrb-\\\": \\\")\\\", \\\"-lcb-\\\": \\\"{\\\",\\n \\\"-rcb-\\\": \\\"}\\\", \\\"-LSB-\\\": \\\"[\\\", \\\"-RSB-\\\": \\\"]\\\", \\\"-LRB-\\\": \\\"(\\\", \\\"-RRB-\\\": \\\")\\\",\\n \\\"-LCB-\\\": \\\"{\\\", \\\"-RCB-\\\": \\\"}\\\"\\n }\\n SPECIAL_TOKENS = [\\\"<NULL>\\\", \\\"<UNK>\\\", \\\"<S>\\\", \\\"</S>\\\"]\\n words = list(map(lambda x: x[0], sorted(counter.items(), key=lambda x: x[1], reverse=True)))\\n words = SPECIAL_TOKENS + words\\n if vocab_size > 0:\\n words = words[:vocab_size]\\n with open(vocab_file, 'w') as f:\\n f.write('\\\\n'.join(words[1:]))\\n embedding = np.random.normal(scale=0.1, size=(len(words), vec_size))\\n word2idx_dict = {}\\n unknown_count = 0\\n for i, word in enumerate(words):\\n word2idx_dict[word] = i\\n if word in TRANSLATE:\\n word = TRANSLATE[word]\\n done = False\\n for w in (word, word.lower(), word.upper(), word.capitalize()):\\n if w in embedding_dict:\\n embedding[i] = embedding_dict[w]\\n done = True\\n break\\n if not done:\\n unknown_count += 1\\n return embedding, word2idx_dict, unknown_count\",\n \"def index(self):\\n print(\\\"Indexing...\\\")\\n # ------------------------------------------------------------------\\n # TODO: Create an inverted, positional index.\\n # Granted this may not be a linked list as in a proper\\n # implementation.\\n # This index should allow easy access to both \\n # 1) the documents in which a particular word is contained, and \\n # 2) for every document, the positions of that word in the document \\n # Some helpful instance variables:\\n # * self.docs = List of documents\\n # * self.titles = List of titles\\n inv_index = defaultdict(set)\\n self.tf = defaultdict(Counter)\\n \\n for word in self.vocab:\\n inv_index[word] = {} # create dictionary with words in V\\n\\n # Generate inverted index here\\n for doc in range(len(self.docs)):\\n for word in self.docs[doc]:\\n self.tf[doc][word] += 1 # represents how many times word 'word' is mentioned in document 'i'\\n \\n for doc, title in zip(self.docs, self.titles):\\n for word in self.vocab:\\n inv_index[word][title] = [] # list for each word in vocabulary for all titles\\n for pos, word in enumerate(doc):\\n inv_index[word][title].append(pos)\\n\\n self.inv_index = inv_index\\n # ------------------------------------------------------------------\\n\\n # turn self.docs into a map from ID to bag of words\\n id_to_bag_of_words = {}\\n for d, doc in enumerate(self.docs):\\n bag_of_words = set(doc)\\n id_to_bag_of_words[d] = bag_of_words\\n self.docs = id_to_bag_of_words\",\n \"def load_glove_embeddings():\\n data = open(\\\"glove.6B.50d.txt\\\",'r',encoding=\\\"utf-8\\\")\\n embeddings = []\\n word_index_dict = {'UNK':0}\\n index = 1\\n for lines in data:\\n wordVector = lines.split(\\\" \\\")\\n if(wordVector[0] in string.punctuation or any(char.isdigit() for char in wordVector[0])):\\n continue\\n embeddings.append(wordVector[1:-1])\\n word_index_dict[wordVector[0]] = index\\n index+=1\\n print(\\\"done\\\")\\n\\n return embeddings, word_index_dict\",\n \"def _add_pre_trained_embedding(self):\\n\\n if self.embedding_type['type'] == 'glove':\\n self.logging.info('use pre-trained glove word2vec')\\n # a. load pre trained glove\\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\\n import os\\n import numpy as np\\n\\n embeddings_index = {}\\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\\n for line in f:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n f.close()\\n\\n self.logging.info('')\\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\\n\\n # b. compute embedding matrix\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n\\n elif self.embedding_type['type'] == 'gensim':\\n self.logging.info('use pre-trained gensim word2vec')\\n\\n import gzip\\n import gensim\\n from keras.layers import Embedding\\n import numpy as np\\n\\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\\n\\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\\n pretrained_weights = model.wv.syn0\\n vocab_size, vector_dim = pretrained_weights.shape\\n\\n method = 3\\n if method == 1:\\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\\n # into our TensorFlow and Keras models\\n\\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\\n for i in range(len(model.wv.vocab)):\\n embedding_vector = model.wv[model.wv.index2word[i]]\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\\n output_dim=embedding_matrix.shape[1],\\n # input_length=self.maxlen,\\n weights=[embedding_matrix],\\n trainable=False)\\n elif method == 2:\\n self.logging.info('word2vec simple embedding matching - simple complex')\\n embedding_layer = Embedding(input_dim=vocab_size,\\n output_dim=vector_dim,\\n input_length=self.maxlen,\\n weights=[pretrained_weights],\\n trainable=False)\\n elif method == 3:\\n\\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\\n # b. compute embedding matrix\\n\\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\\n\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n if word in model.wv:\\n embedding_vector = model.wv[word]\\n embedding_matrix[i] = embedding_vector\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt))\\n\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n else:\\n raise ValueError('unknown method value')\\n\\n else:\\n raise ValueError('unknown embedding type')\\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\\n return embedding_layer\",\n \"def build_vocab(sentences_list, vocab_size, visual_fld):\\n words = [word for sentence in sentences_list for word in sentence]\\n utils.safe_mkdir(visual_fld)\\n with open(os.path.join(visual_fld, 'vocab.tsv'), 'w') as fd:\\n dictionary = {}\\n index_dictionary = {}\\n count = [('UNK', -1)]\\n count.extend(Counter(words).most_common(vocab_size - 1))\\n for index, (word, _) in enumerate(count):\\n dictionary[word] = index\\n index_dictionary[index] = word\\n fd.write(word + '\\\\n')\\n\\n return dictionary, index_dictionary\",\n \"def _build_vocabulary(input_files):\\n if FLAGS.vocab_file:\\n tf.logging.info(\\\"Loading existing vocab file.\\\")\\n vocab = collections.OrderedDict()\\n with tf.gfile.GFile(FLAGS.vocab_file, mode=\\\"r\\\") as f:\\n for i, line in enumerate(f):\\n word = line.decode(\\\"utf-8\\\").strip()\\n assert word not in vocab, \\\"Attempting to add word twice: %s\\\" % word\\n vocab[word] = i\\n tf.logging.info(\\\"Read vocab of size %d from %s\\\",\\n len(vocab), FLAGS.vocab_file)\\n return vocab\\n\\n tf.logging.info(\\\"Creating vocabulary.\\\")\\n num = 0\\n wordcount = collections.Counter()\\n for input_file in input_files:\\n tf.logging.info(\\\"Processing file: %s\\\", input_file)\\n for sentence in tf.gfile.FastGFile(input_file):\\n wordcount.update(sentence.split())\\n\\n num += 1\\n if num % 1000000 == 0:\\n tf.logging.info(\\\"Processed %d sentences\\\", num)\\n\\n tf.logging.info(\\\"Processed %d sentences total\\\", num)\\n\\n words = wordcount.keys()\\n freqs = wordcount.values()\\n sorted_indices = np.argsort(freqs)[::-1]\\n\\n vocab = collections.OrderedDict()\\n vocab[special_words.EOS] = special_words.EOS_ID\\n vocab[special_words.UNK] = special_words.UNK_ID\\n for w_id, w_index in enumerate(sorted_indices[0:FLAGS.num_words - 2]):\\n vocab[words[w_index]] = w_id + 2 # 0: EOS, 1: UNK.\\n\\n tf.logging.info(\\\"Created vocab with %d words\\\", len(vocab))\\n\\n vocab_file = os.path.join(FLAGS.output_dir, \\\"vocab.txt\\\")\\n with tf.gfile.FastGFile(vocab_file, \\\"w\\\") as f:\\n f.write(\\\"\\\\n\\\".join(vocab.keys()))\\n tf.logging.info(\\\"Wrote vocab file to %s\\\", vocab_file)\\n\\n word_counts_file = os.path.join(FLAGS.output_dir, \\\"word_counts.txt\\\")\\n with tf.gfile.FastGFile(word_counts_file, \\\"w\\\") as f:\\n for i in sorted_indices:\\n f.write(\\\"%s %d\\\\n\\\" % (words[i], freqs[i]))\\n tf.logging.info(\\\"Wrote word counts file to %s\\\", word_counts_file)\\n\\n return vocab\",\n \"def load_embedding_file(self):\\n if self.language == 'en':\\n embed_file_dir = self.embedding_path\\n wv = KeyedVectors.load_word2vec_format(embed_file_dir, binary=True)\\n self.pretrained_embedding = {}\\n for word in wv.vocab.keys():\\n normalized_word = normalization.process(self.language.upper(), word, letters_to_keep='', letters_to_remove='',\\n lowercase=True, remove_repetitions_count=-1, remove_punct=True,\\n remove_digits=True, remove_vowels=False, remove_diacritics=True,\\n remove_spaces=False, remove_apostrophe=True, copy_through=False,\\n keep_romanized_text=False)\\n self.pretrained_embedding[normalized_word] = wv[word]\\n self.embed_dim = 300\\n\\n else:\\n embed_file_dir = self.embedding_path\\n fin = open(embed_file_dir, 'r', encoding='utf-8', newline='\\\\n', errors='ignore')\\n data = {}\\n for line in fin:\\n if len(line.split()) == 2: # header\\n continue\\n tokens = line.rstrip().split(' ')\\n word = tokens[0]\\n normalized_word = normalization.process(self.language.upper(), word, letters_to_keep='', letters_to_remove='',\\n lowercase=True, remove_repetitions_count=-1, remove_punct=True,\\n remove_digits=True, remove_vowels=False, remove_diacritics=True,\\n remove_spaces=False, remove_apostrophe=True, copy_through=False,\\n keep_romanized_text=False)\\n data[normalized_word] = np.array(tokens[1:])\\n self.pretrained_embedding = data\\n self.embed_dim = 300\",\n \"def load_pretrained_words_data(embeddings_filename, vocab):\\n words = dict()\\n emb_dim = None\\n with gzip.open(cached_path(embeddings_filename), 'rb') as embeddings_file:\\n for line in embeddings_file:\\n fields = line.decode('utf-8').strip().split(' ')\\n if len(fields) == 0:\\n continue\\n word = fields[0]\\n if emb_dim is None:\\n emb_dim = len(fields) - 1\\n if emb_dim < 10: # my pretrained file is poisonous 😭\\n emb_dim = None\\n else:\\n assert emb_dim == len(fields) - 1, \\\"{}, {}\\\".format(emb_dim, len(fields) - 1)\\n words.update({word: [float(i) for i in fields[1:]]})\\n print(\\\"Embedding dim: {}\\\".format(emb_dim))\\n tokens = vocab.get_index_to_token_vocabulary(\\\"tokens\\\")\\n n_tokens = len(tokens)\\n data = []\\n for i in tokens:\\n if tokens[i] in words:\\n data.append(words[tokens[i]])\\n else:\\n data.append([0] * emb_dim)\\n return torch.tensor(data), emb_dim\",\n \"def load_word2index(self):\\n word2index = {}\\n with open(self.nodes_file, 'r') as reader:\\n for index, line in enumerate(reader):\\n node = line.strip()\\n word2index[node] = index\\n\\n return word2index\",\n \"def get_google_word2vec_W(fname, vocab, vocab_size=1000000, index_from=3):\\n f = open(fname, 'rb')\\n header = f.readline()\\n vocab1_size, embedding_dim = list(map(int, header.split()))\\n binary_len = np.dtype('float32').itemsize * embedding_dim\\n vocab_size = min(len(vocab) + index_from, vocab_size)\\n W = np.zeros((vocab_size, embedding_dim))\\n\\n found_words = {}\\n for i, line in enumerate(range(vocab1_size)):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch)\\n if word in vocab:\\n wrd_id = vocab[word] + index_from\\n if wrd_id < vocab_size:\\n W[wrd_id] = np.fromstring(\\n f.read(binary_len), dtype='float32')\\n found_words[wrd_id] = 1\\n else:\\n f.read(binary_len)\\n\\n cnt = 0\\n for wrd_id in range(vocab_size):\\n if wrd_id not in found_words:\\n W[wrd_id] = np.random.uniform(-0.25, 0.25, embedding_dim)\\n cnt += 1\\n assert cnt + len(found_words) == vocab_size\\n\\n f.close()\\n\\n return W, embedding_dim, vocab_size\",\n \"def get_vocab(self):\\n if os.path.exists(self.vocab_file) & self.vocab_from_file:\\n f = open(self.vocab_file, \\\"rb\\\")\\n vocab = pickle.load(f)\\n self.word2idx = vocab.word2idx\\n self.idx2word = vocab.idx2word\\n f.close()\\n else:\\n self.build_vocab()\\n with open(self.vocab_file, 'wb') as f:\\n pickle.dump(self, f)\",\n \"def load_data_for_dict(path, voc_path, need_rem_punkt=True):\\n \\n table = str.maketrans('', '', string.punctuation)\\n\\n with open(voc_path) as f:\\n word_to_idx = dict(json.load(f))\\n dict_size = len(word_to_idx)\\n \\n with open(path, \\\"r\\\") as fin:\\n for line in fin:\\n line = line.lower()\\n sentence = []\\n for word in line.split():\\n if need_rem_punkt: \\n word = word.translate(table) # remove punctuation\\n if word not in word_to_idx:\\n word_to_idx[word] = dict_size\\n dict_size += 1\\n\\n with open(voc_path, \\\"w+\\\") as fout:\\n json.dump(word_to_idx, fout)\",\n \"def load_embedding(self, glove_dir='glove.6B/'):\\n\\n f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'))\\n for line in f:\\n values = line.split()\\n word = values[0]\\n self.embeddings_index[word] = np.asarray(values[1:], dtype='float32')\\n f.close()\",\n \"def get_vocab(self):\\n word2id = {}\\n for document in self.docs:\\n for word in document:\\n if word not in word2id.keys():\\n word2id[word] = len(word2id)\\n return word2id\",\n \"def load_kb_embeddings(path_to_folder):\\n\\n entity2idx = {}\\n allowed_indices = set()\\n with open(\\\"data/entity2id.filtered.txt\\\", 'r') as f:\\n for l in f.readlines():\\n k, v, idx = tuple(l.strip().split(\\\"\\\\t\\\"))\\n entity2idx[k] = int(idx) + 3\\n allowed_indices.add(int(v))\\n\\n embeddings = []\\n with open(path_to_folder + \\\"/entity2vec.vec\\\", 'r') as f:\\n idx = 0\\n for line in f.readlines():\\n if idx in allowed_indices:\\n split = line.strip().split('\\\\t')\\n embeddings.append([float(num) for num in split])\\n idx += 1\\n\\n entity2idx[all_zeroes] = 0 # 0 is reserved for padding\\n entity2idx[unknown_el] = 1 # 1 is reserved for OOV\\n entity2idx[no_annotation] = 2 # 2 is reserved for no annotation tokens\\n embedding_size = len(embeddings[0])\\n vector_oov = 2 * 0.1 * np.random.rand(embedding_size) - 0.1\\n vector_na = 2 * 0.1 * np.random.rand(embedding_size) - 0.1\\n embeddings = np.asarray([[0.0]*embedding_size, vector_oov, vector_na] + embeddings, dtype='float32')\\n\\n print(\\\"KB embeddings loaded: {}\\\".format(embeddings.shape))\\n assert len(entity2idx) == len(embeddings)\\n\\n return entity2idx, embeddings\",\n \"def init_pretrained_glove(glove_path, word2idx, embedding_dim):\\n vocab_size = len(word2idx)\\n # read in the glove files\\n glove_file = os.path.join(glove_path, 'glove.6B.{:d}d.json'.\\n format(embedding_dim))\\n with open(glove_file, 'r') as fp:\\n word2glove = json.load(fp)\\n print('Read embeddings: {:s}'.format(glove_file))\\n\\n # then make giant matrix with all the matching vocab words\\n padding_idx = 0\\n # follow Karpahty's advice and initialize really small\\n pretrained = torch.randn(vocab_size, embedding_dim) * 0.01\\n count = 0\\n for word, idx in word2idx.iteritems():\\n # reserve the padding idx as 0\\n if idx == padding_idx:\\n torch.FloatTensor(embedding_dim).zero_()\\n # keep as random initialization\\n if word not in word2glove:\\n continue\\n pretrained[idx] = torch.FloatTensor(word2glove[word])\\n\\n embed = torch.nn.Embedding(vocab_size, embedding_dim)\\n embed.weight = torch.nn.Parameter(pretrained)\\n return embed\",\n \"def get_W(word_vecs, k=100,path='wordemb'):\\n vocab_size = len(word_vecs)\\n word_idx_map = dict()\\n W = np.zeros(shape=(vocab_size+1, k), dtype='float32')\\n W[0] = np.zeros(k, dtype='float32')\\n i = 1\\n f =open(path+'.word','w')\\n for word in word_vecs:\\n # print(\\\"#############################\\\")\\n # print(word_vecs[word].shape)\\n # print(word)\\n # print(W[i].shape)\\n # print(\\\"#############################\\\")\\n W[i] = word_vecs[word]\\n f.write(word+'\\\\n')\\n word_idx_map[word] = i\\n i += 1\\n np.savetxt(path+'.txt',W,fmt='%.7f', delimiter=' ')\\n f.close()\\n return W, word_idx_map\",\n \"def gen_embeddings(vocab, file, emb_size, emb_dim):\\n # embeddings = np.random.randn(vocab.n_words, emb_size) * 0.01\\n embeddings = np.zeros((vocab.n_words, emb_size))\\n print('Embeddings: %d x %d' % (vocab.n_words, emb_size))\\n if file is not None:\\n print('Loading embedding file: %s' % file)\\n pre_trained = 0\\n for line in open(file).readlines():\\n sp = line.split()\\n if(len(sp) == emb_dim + 1):\\n if sp[0] in vocab.word2index:\\n pre_trained += 1\\n embeddings[vocab.word2index[sp[0]]] = [float(x) for x in sp[1:]]\\n else:\\n print(sp[0])\\n print('Pre-trained: %d (%.2f%%)' % (pre_trained, pre_trained * 100.0 / vocab.n_words))\\n return embeddings\",\n \"def conv_word_to_indexed_txt(txt_vec):\\n\\n # transform words into integer indexes, comes out as n x m\\n # where n = # txt doc, m = # unique words for whole universe\\n vectorizer = CountVectorizer(\\n stop_words=customised_stopword,\\n analyzer='word'\\n )\\n # CountVectorizer(ngram_range=(1,2), analyzer='word')\\n sparse_count_vec = vectorizer.fit_transform(txt_vec)\\n\\n # create n x p list of words represented by ints,\\n # where p = # words in each documentx\\n # written in such a convoluted way for speed optimization purposes\\n x_vec, y_vec, count_vec = sparse.find(sparse_count_vec)\\n\\n # add in duplicates\\n x_vec = np.repeat(x_vec, count_vec)\\n y_vec = np.repeat(y_vec, count_vec)\\n\\n # convert to torch variables\\n x_vec = torch.tensor(x_vec, dtype=torch.int32)\\n y_vec = torch.tensor(y_vec, dtype=torch.float)\\n\\n # sort the vecs\\n sort_ix = torch.argsort(x_vec)\\n x_vec = x_vec[sort_ix]\\n y_vec = y_vec[sort_ix]\\n\\n x_vec_bincount = torch.bincount(x_vec.cpu())\\n bincount_tup = tuple(int(bincount) for bincount in x_vec_bincount)\\n indexed_txt_list = list(torch.split(y_vec, bincount_tup))\\n\\n # the dictionary key to match each word to int\\n vocab_dict = vectorizer.vocabulary_\\n\\n print(\\\"Converted words to indexes of integers.\\\")\\n\\n vocab_count = sparse_count_vec.data\\n\\n return indexed_txt_list, vocab_dict, vocab_count\",\n \"def w2v_embedding(input_file, bin_file, output_file):\\n print(\\\"Loading the training corpus.\\\")\\n df = open(src_file_path, \\\"r\\\") # Open the text file stored at src_file_path\\n df = df.read() # Read the text file\\n tokens1 = word_tokenize(df) # Tokenize\\n token_list = []\\n print(\\\"Writing the bin file.\\\")\\n models = KeyedVectors.load_word2vec_format(bin_destination_file_path, binary=True) # Save bin format\\n print(\\\"Saving the word embeddings.\\\")\\n models.save_word2vec_format(txt_file_destination_path, binary=False) # Save the word vectors\\n \\n return txt_file_destination_path\",\n \"def load_word2vect(self, file_path):\\n self.embeddings = []\\n self.word_to_idx = {'<pad>' : 0}\\n self.vocab = ['<pad>']\\n\\n model = w2v.load(file_path)\\n self.embedding_size = model.vectors.shape[1]\\n pad_embedding = np.zeros(self.embedding_size, \\\"float32\\\")\\n self.embeddings.append(pad_embedding)\\n\\n train_words_set = set([word for text in self.train_data for word in\\n text[1].split(\\\" \\\")])\\n\\n for w in model.vocab:\\n if w in train_words_set:\\n self.word_to_idx[w] = len(self.vocab)\\n self.vocab.append(w)\\n self.embeddings.append(model[w])\\n\\n del model\",\n \"def _index(self, corpus):\\n\\n # Transform documents to embeddings vectors\\n ids, dimensions, stream = self.embedder.model.index(corpus)\\n\\n # Load streamed embeddings back to memory\\n embeddings = np.empty((len(ids), dimensions), dtype=np.float32)\\n with open(stream, \\\"rb\\\") as queue:\\n for x in range(embeddings.shape[0]):\\n embeddings[x] = pickle.load(queue)\\n\\n # Remove temporary file\\n os.remove(stream)\\n\\n all_text = []\\n for para_id, text, _ in corpus:\\n all_text.append([text, para_id])\\n\\n df = pd.DataFrame(all_text, columns=[\\\"text\\\", \\\"paragraph_id\\\"])\\n\\n embedding_path = os.path.join(\\n self.index_path, self.embed_paths[\\\"embeddings\\\"])\\n dataframe_path = os.path.join(\\n self.index_path, self.embed_paths[\\\"dataframe\\\"])\\n ids_path = os.path.join(self.index_path, self.embed_paths[\\\"ids\\\"])\\n\\n # Load new data\\n if os.path.isfile(embedding_path) and (self.encoder_args[\\\"overwrite\\\"] is False):\\n logger.info(f\\\"Loading new data from {embedding_path}\\\")\\n\\n # Load existing embeddings\\n old_embeddings = np.load(embedding_path) # LOAD EMBEDDINGS\\n # Remove embeddings with document id overlaps\\n embeddings = np.vstack((old_embeddings, embeddings))\\n\\n # load IDs\\n old_ids = [doc_id[:-1] for doc_id in open_txt(ids_path)]\\n logger.debug(f\\\"New ID Length = {len(ids)}\\\")\\n logger.debug(f\\\"Old ID Length = {len(old_ids)}\\\")\\n # Remove document ids overlaps\\n logger.debug(f\\\"New ID Length = {len(ids)}\\\")\\n ids = old_ids + ids\\n logger.debug(f\\\"Merged ID Length = {len(ids)}\\\")\\n\\n # Append new dataframe\\n old_df = pd.read_csv(dataframe_path)\\n df = pd.concat([old_df, df])\\n\\n # Store embeddings and document index\\n # for future reference\\n np.save(embedding_path, embeddings)\\n with open(ids_path, \\\"w\\\") as fp:\\n fp.writelines([i + \\\"\\\\n\\\" for i in ids])\\n\\n # Save data csv\\n df.to_csv(dataframe_path, index=False)\\n\\n # Normalize embeddings\\n self.embedder.normalize(embeddings)\\n\\n # Save embeddings metadata\\n self.embedder.config[\\\"ids\\\"] = ids\\n self.embedder.config[\\\"dimensions\\\"] = dimensions\\n\\n # Create embeddings index\\n logger.info(f\\\"Creating embeddings and index\\\")\\n self.embedder.embeddings = ANN.create(self.embedder.config)\\n logger.info(f\\\"Created embeddings\\\")\\n\\n # Build the index\\n self.embedder.embeddings.index(embeddings)\\n logger.info(f\\\"Built the embeddings index\\\")\",\n \"def load_embeddings(emb_file, oovs=[], pads=[], sep=' ', lower=False, case_dim=True):\\n word2emb = {}\\n word2idx = {}\\n\\n # read and store all word vectors\\n for line in open(emb_file, errors = 'ignore', encoding = 'utf-8'):\\n try:\\n fields = line.strip().split(sep)\\n word = fields[0]\\n vec = np.asarray(fields[1:], dtype='float32')\\n if case_dim:\\n is_upper = float(word[0].isupper())\\n vec = np.insert(vec, 0, is_upper, axis=0)\\n if lower:\\n word = word.lower()\\n word2emb[word] = vec\\n if word not in word2idx:\\n word2idx[word] = len(word2idx)\\n except Exception as e:\\n print('[WARNING] Exception in `load_embeddings`:', e)\\n\\n # get dimensions from the last vector added\\n emb_dim = word2emb[word].shape[0]\\n\\n # add custom embeddings for special characters\\n mu = 0\\n sigma = 0.01\\n\\n for word in pads:\\n if word not in word2idx:\\n if case_dim:\\n vec = npr.normal(mu, sigma, emb_dim-1)\\n vec = np.insert(vec, 0, 0., axis=0)\\n else:\\n vec = npr.normal(mu, sigma, emb_dim)\\n word2emb[word] = vec\\n word2idx[word] = len(word2idx)\\n else:\\n print('[WARNING] Padding item ' + word + ' has an embedding vector')\\n\\n for word in oovs:\\n if word not in word2idx:\\n if case_dim:\\n vec = npr.normal(mu, sigma, emb_dim-1)\\n is_upper = float(word[0].isupper())\\n vec = np.insert(vec, 0, is_upper, axis=0)\\n else:\\n vec = npr.normal(mu, sigma, emb_dim)\\n word2emb[word] = vec\\n word2idx[word] = len(word2idx)\\n else:\\n print('[WARNING] OOV alias ' + word + ' has an embedding vector')\\n\\n # create an embedding matrix\\n vocab_size = len(word2emb)\\n emb_matrix = np.zeros((vocab_size, emb_dim))\\n for word, idx in word2idx.items():\\n if word in word2emb:\\n vec = word2emb[word]\\n if vec is not None and vec.shape[0] == emb_dim:\\n emb_matrix[idx] = np.asarray(vec)\\n\\n # print feedback data and return mappings\\n print('[INFO] Embedding vocabulary:', emb_matrix.shape[0], '(lowercase: ' + str(lower) + ')')\\n print('[INFO] OOV aliases:', oovs)\\n print('[INFO] Padding items:', pads)\\n print('[INFO] Embedding dimensions:', emb_dim, '(extra case dimension: ' + str(case_dim) + ')')\\n return word2idx, np.asarray(emb_matrix), emb_dim\",\n \"def new_counts_dict():\\n\\n\\tIN_FILES = [\\\"../_semtag_dataset_webanno_tfidf_inimigo.txt\\\",\\\"../_semtag_dataset_webanno_tfidf_publico.txt\\\" ]\\n\\n\\ttxt = []\\n\\tfor in_file in IN_FILES:\\n\\t with codecs.open(in_file,\\\"r\\\",\\\"utf-8\\\") as fid:\\n\\t txt += fid.readlines()\\n\\t#words\\n\\twords = [w for m in txt for w in m.split()]\\n\\t#unique words\\n\\twords = list(set(words))\\n\\t#word index\\n\\twrd2idx = {w:-1 for w in words}\\n\\n\\tset_trace()\\n\\t\\n\\twith open(COUNTS_DIC,\\\"w\\\") as fod:\\n\\t\\tcPickle.dump(wrd2idx, fod, cPickle.HIGHEST_PROTOCOL)\",\n \"def load_word2vec_en_pretrained():\\r\\n log.info(\\\"Load W2V Model\\\")\\r\\n model = api.load(\\\"glove-wiki-gigaword-50\\\")\\r\\n return PreTrainedGensimEN(model)\",\n \"def load_embeddings(embeddings_path):\\n\\n embeddings_index = {}\\n f = open(embeddings_path, encoding='utf-8')\\n for line in tqdm(f):\\n values = line.rstrip().split(' ')\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n f.close()\\n print('Found {} word vectors.'.format(len(embeddings_index)))\\n return embeddings_index\",\n \"def read_old_glove(filepath):\\n print('reading glove files:', filepath)\\n\\n word2idx = {}\\n word_embed = [['0'] * 300] # word_embed[0] = [0] * 300, represent the <PAD>\\n\\n with open(filepath, 'r') as f:\\n for idx, line in enumerate(f):\\n line_list = line.split()\\n word = ' '.join(line_list[: len(line_list)-300])\\n embed = [num for num in line_list[len(line_list)-300:]]\\n\\n word2idx[word] = idx + 1\\n word_embed.append(embed)\\n\\n return word2idx, word_embed\",\n \"def get_vocabulary(text_fname, vocab_fname):\\n with codecs.open(text_fname,'r','utf-8') as infile, \\\\\\n codecs.open(vocab_fname,'w','utf-8') as outfile: \\n\\n count_map={}\\n for line in infile:\\n sent=line.strip().split(' ')\\n for w in sent:\\n count_map[w]=count_map.get(w,0.0)+1.0\\n\\n for w,c in count_map.iteritems(): \\n outfile.write(u'{}|{}\\\\n'.format(w,c))\",\n \"def generate_vocab():\\n\\n vocab_dict = {}\\n folder_path = os.listdir(args.f)\\n for subfolder in folder_path:\\n subfolder_path = os.path.join(args.f, subfolder)\\n for filename in os.listdir(subfolder_path):\\n with open(os.path.join(subfolder_path, filename), 'r') as file:\\n read_file = file.read()\\n normalised_text = re.sub(r\\\"[^\\\\s\\\\w]\\\", \\\" \\\", read_file.lower())\\n vocab = normalised_text.split() #.split() creates a list of strings\\n vocab_dict.update({i: 0 for i in vocab})\\n return vocab_dict\",\n \"def _make_word_dictionary(self,annos):\\n # get training annos\\n train_annos = self.annos[\\\"train\\\"]\\n # read tokens\\n tokens_list = []\\n for ann in train_annos:\\n tokens_list += [tk for tk in ann[\\\"tokens\\\"]]\\n # print results: count tokens and show top-n\\n print(\\\"Top-{} tokens list:\\\".format(self.cfg.DATASET.SHOW_TOP_VOCAB))\\n tokens_count = sorted(Counter(tokens_list).items(), key=lambda x:x[1])\\n for tk in tokens_count[-self.cfg.DATASET.SHOW_TOP_VOCAB:]:\\n print(\\\"\\\\t- {}: {}\\\".format(tk[0],tk[1]))\\n # make wtoi, itow\\n wtoi = {}\\n wtoi[\\\"<PAD>\\\"], wtoi[\\\"<UNK>\\\"] = 0, 1\\n wtoi[\\\"<S>\\\"], wtoi[\\\"<E>\\\"] = 2, 3\\n for i,(tk,cnt) in enumerate(tokens_count):\\n idx = i+4 # idx start at 4\\n wtoi[tk] = idx\\n itow = {v:k for k,v in wtoi.items()}\\n self.cfg.MODEL.QUERY.EMB_IDIM = len(wtoi)\\n return wtoi, itow\",\n \"def load_embeddings(filepath, vocabulary, retain):\\n \\n word2index = dict()\\n word_vectors = list()\\n\\n def add_entry(word, vector):\\n word2index[word] = len(word2index)\\n word_vectors.append(vector)\\n\\n model = gensim.models.KeyedVectors.load(filepath)\\n\\n # adding special tokens <FIL>, <UNK> and <NUM>\\n dim = model.vector_size\\n add_entry('<fil>', np.zeros((dim,)))\\n for special in ['<unk>', '<num>']:\\n vector = np.random.uniform(-0.025, 0.025, (dim,))\\n add_entry(special, vector)\\n\\n if retain:\\n for word, _ in model.vocab.items():\\n add_entry(word, model[word])\\n else:\\n for word in vocabulary:\\n if word in model:\\n add_entry(word, model[word])\\n\\n vocabulary = vocabulary.intersection(word2index.keys())\\n return word2index, np.asarray(word_vectors)\",\n \"def build_doc_sense_vec(self):\\n\\t\\twith codecs.open(self.vocab_file, encoding='utf-8', mode='r') as infile:\\n\\t\\t\\tline = infile.readline()\\n\\t\\t\\ti = 0\\n\\t\\t\\twhile line:\\n\\t\\t\\t\\tword = line.split()[0]\\n\\t\\t\\t\\tif not self.word2IdVocabulary.has_key(word):\\n\\t\\t\\t\\t\\t# print i, word\\n\\t\\t\\t\\t\\t# else:\\n\\t\\t\\t\\t\\tself.word2IdVocabulary[word] = i\\n\\t\\t\\t\\tif not self.id2WordVocabulary.has_key(i):\\n\\t\\t\\t\\t\\tself.id2WordVocabulary[i] = word\\n\\t\\t\\t\\tline = infile.readline()\\n\\t\\t\\t\\ti += 1\\n\\t\\t\\tself.vocab_num = len(self.word2IdVocabulary)\\n\\t\\t\\tprint \\\"vocabulary number:\\\" + str(self.vocab_num)\\n\\n\\t\\twith codecs.open(self.vec_file, encoding='utf-8', mode='r') as vecfile:\\n\\t\\t\\twith codecs.open(self.vec_out_file, encoding='utf-8', mode='a+') as vec_outfile:\\n\\n\\t\\t\\t\\tfor i, line in enumerate(vecfile):\\n\\t\\t\\t\\t\\tif i % 10000 == 0:\\n\\t\\t\\t\\t\\t\\tprint i\\n\\t\\t\\t\\t\\t# if i > 72:\\n\\t\\t\\t\\t\\t# \\tbreak\\n\\t\\t\\t\\t\\tif i == 0:\\n\\t\\t\\t\\t\\t\\ta, b, c = map(int, line.split()[:3])\\n\\t\\t\\t\\t\\t\\tprint('Number of sememes: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t 'Number of words: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t 'Dimension of vectors: {}'.format(a, b, c))\\n\\t\\t\\t\\t\\telif i > 462667:\\n\\t\\t\\t\\t\\t\\tsline = line.strip('\\\\n').split()\\n\\t\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\t\\tvector_list.append(sline[1:])\\n\\t\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[word]\\n\\t\\t\\t\\t\\t\\tif not self.vectors.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vectors[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\t# vector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t\\tif not self.vector_mean.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vector_mean[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\t# vec_outfile.write(line)\\n\\t\\t\\t\\t\\telif i > 462887:\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tsline = line.strip('\\\\n').split()\\n\\t\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\t\\tsense_num = int(sline[1])\\n\\t\\t\\t\\t\\t\\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\\n\\t\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\t\\tfor start in range(0, len(vectors), c):\\n\\t\\t\\t\\t\\t\\t\\tvector_list.append(list(map(float, vectors[start: start+c])))\\n\\t\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[word]\\n\\t\\t\\t\\t\\t\\tif not self.vectors.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vectors[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\tvector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t\\tif not self.vector_mean.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vector_mean[word_id] = vector_mean\\n\\t\\t\\t\\t\\t\\t'''j = 0\\n\\t\\t\\t\\t\\t\\tfor each_sense_vec in vector_array:\\n\\t\\t\\t\\t\\t\\t\\tif len(vector_array) > 1:\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_line = word + '_' + str(j) + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tformatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t\\tj += 1\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_line = word + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter={'float_kind': lambda\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t x: '%6f' % x})[1:-1] + '\\\\n'\\n\\n\\t\\t\\t\\t\\t\\t\\tvec_outfile.write(new_line)'''\\n\\n\\t\\twith codecs.open(self.doc_file, encoding='utf-8', mode='r') as docfile:\\n\\t\\t\\twith codecs.open(self.doc_out_file, encoding='utf-8', mode='a+') as doc_outfile:\\n\\t\\t\\t\\twith codecs.open(self.vec_out_file_bydoc, encoding='utf-8', mode='a+') as vec_outfile_bydoc:\\n\\t\\t\\t\\t\\tprint \\\"Processing document file......\\\"\\n\\t\\t\\t\\t\\tline = docfile.readline().strip('\\\\n')\\n\\t\\t\\t\\t\\twhile line:\\n\\t\\t\\t\\t\\t\\twords = line.split()\\n\\t\\t\\t\\t\\t\\tnew_words = [x for x in words]\\n\\t\\t\\t\\t\\t\\tfor i in range(len(words)):\\n\\t\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[words[i]]\\n\\t\\t\\t\\t\\t\\t\\tsense_vecs = self.vectors[word_id]\\n\\t\\t\\t\\t\\t\\t\\tsense_num = len(sense_vecs)\\n\\t\\t\\t\\t\\t\\t\\tif sense_num > 1:\\n\\t\\t\\t\\t\\t\\t\\t\\tcontext_words = []\\n\\t\\t\\t\\t\\t\\t\\t\\tfor x in range(i-int(self.context_num), i+int(self.context_num)+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif x != i and 0 <= x < len(words):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcontext_words.append(words[x])\\n\\t\\t\\t\\t\\t\\t\\t\\tsense_index = self.select_attention(context_words, sense_vecs)\\n\\t\\t\\t\\t\\t\\t\\t\\tword_vec_i = sense_vecs[sense_index]\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_wordi = words[i] + '_' + str(sense_index)\\n\\t\\t\\t\\t\\t\\t\\t\\tself.vector_word_doc[new_wordi.encode('utf-8')] = word_vec_i\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_words[i] = new_wordi\\n\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tword_vec_i = sense_vecs[0]\\n\\t\\t\\t\\t\\t\\t\\t\\tself.vector_word_doc[words[i].encode('utf-8')] = word_vec_i\\n\\t\\t\\t\\t\\t\\t\\tvec_outfile_bydoc.write(new_words[i] + ' ' + np.array2string(word_vec_i, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\\\n')\\n\\n\\t\\t\\t\\t\\t\\tdoc_outfile.write(' '.join(new_words) + '\\\\n')\\n\\n\\t\\t\\t\\t\\t\\tline = docfile.readline()\\n\\n\\t\\treturn self.vector_word_doc\",\n \"def _extractGloveVects():\\n \\n embeddings_index = {}\\n\\n with open(GLOVE_CORPUS_FILE) as f:\\n for line in f:\\n values = line.split()\\n word = values[0].lower()\\n if word not in _cachedStopWords:\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n\\n return embeddings_index\",\n \"def getWordEmbeddingsMatrix(script_directory, embedding_file):\\n translator = str.maketrans('', '', string.punctuation)\\n all_words = []\\n print(\\\"Loading vocab from text files in:\\\")\\n for d in os.listdir(script_directory):\\n print(d)\\n for fname in os.listdir(\\\"%s/%s\\\" % (script_directory, d)):\\n with open(\\\"%s/%s/%s\\\" % (script_directory, d, fname), 'r') as f:\\n words = [w.translate(translator) for w in f.read().split() if w.translate(translator) != \\\"\\\"]\\n all_words.extend(words)\\n\\n model = KeyedVectors.load_word2vec_format(embedding_file, binary=True)\\n vocab = {\\\"PAD\\\" : 0, \\\"EOS\\\" : 1}\\n vocab.update({w : i + 2 for i,w in enumerate([w1 for w1 in set(all_words) if w1 in model]) })\\n inv_dict = vocab.keys()\\n ## Take a minute to load...\\n\\n vocab_size = len(inv_dict)\\n emb_size = 300 # or whatever the size of your embeddings\\n embeddings = np.zeros((vocab_size + 1, emb_size))\\n for k,v in vocab.items():\\n embeddings[v] = model[k]\\n vocab[\\\"UNK\\\"] = len(vocab.keys())\\n embeddings[vocab[\\\"UNK\\\"]] = np.ones(emb_size)\\n del model\\n ## Now we have a numpy matrix of embeddings...\\n # x_model = tf.placeholder(tf.int32, shape=[None, input_size])\\n # with tf.device(\\\"/cpu:0\\\"):\\n # embedded_x = tf.nn.embedding_lookup(embeddings, x_model)\\n return embeddings, vocab\",\n \"def glove():\\n import numpy as np\\n \\\"\\\"\\\" Read from Gluons embedding pickle files\\\"\\\"\\\"\\n with np.load(glove_model_path) as f:\\n matrix = f['idx_to_vec']\\n matrix.setflags(write=0)\\n return matrix, f['idx_to_token'], token_to_idx(f['idx_to_token'])\",\n \"def generate_embeddings_sentence_test_data(data, path_out):\\n flair.device = torch.device('cpu')\\n dicts = []\\n # init multilingual BERT\\n bert_embedding = TransformerDocumentEmbeddings('bert-base-multilingual-cased')\\n counter = 0\\n for entry in data:\\n print(\\\"Counter: \\\", counter)\\n counter += 1\\n text = entry[\\\"sentence\\\"]\\n id = entry[\\\"id\\\"]\\n sent = Sentence(text)\\n bert_embedding.embed(sent)\\n vec = sent.get_embedding().detach().numpy()\\n dicts.append((id,vec))\\n gc.collect()\\n result = dicts\\n file = open(path_out, \\\"wb\\\")\\n pickle.dump(result, file)\\n file.close()\\n return result\",\n \"def read_w2v(w2v_path, word2index, n_dims=300, unk_token=\\\"unk\\\"):\\n print('Getting Word Vectors...', file=sys.stderr)\\n vocab = set()\\n # hacky thing to deal with making sure to incorporate unk tokens in the form they are in for a given embedding type\\n if unk_token not in word2index:\\n word2index[unk_token] = 0 # hardcoded, this would be better if it was a method of a class\\n\\n word_vectors = np.zeros((len(word2index), n_dims)) # length of vocab x embedding dimensions\\n with open(w2v_path) as file:\\n lc = 0\\n for line in file:\\n lc += 1\\n line = line.strip()\\n if line:\\n row = line.split()\\n token = row[0]\\n if token in word2index or token == unk_token:\\n vocab.add(token)\\n try:\\n vec_data = [float(x) for x in row[1:]]\\n word_vectors[word2index[token]] = np.asarray(vec_data)\\n if lc == 1:\\n if len(vec_data) != n_dims:\\n raise RuntimeError(\\\"wrong number of dimensions\\\")\\n except:\\n print('Error on line {}'.format(lc), file=sys.stderr)\\n # puts data for a given embedding at an index based on the word2index dict\\n # end up with a matrix of the entire vocab\\n tokens_without_embeddings = set(word2index) - vocab\\n print('Word Vectors ready!', file=sys.stderr)\\n print('{} tokens from text ({:.2f}%) have no embeddings'.format(\\n len(tokens_without_embeddings), len(tokens_without_embeddings)*100/len(word2index)), file=sys.stderr)\\n print('Tokens without embeddings: {}'.format(tokens_without_embeddings), file=sys.stderr)\\n print('Setting those tokens to unk embedding', file=sys.stderr)\\n for token in tokens_without_embeddings:\\n word_vectors[word2index[token]] = word_vectors[word2index[unk_token]]\\n return word_vectors\",\n \"def build_index(in_dir, out_dict, out_postings):\\n print('indexing...')\\n\\n stemmer = stem.PorterStemmer()\\n\\n #Dictionary for saving our tokens and the reference to their postings list\\n dictionary = dict()\\n #Number of files that will be indexed\\n num_files = 1000000\\n #1. We have to open the reuters training docs directory and traverse it, opening each doc.\\n #List all files in the dir and sort them by numerical order, to have sorted postings lists\\n lst = os.listdir(in_dir)\\n lst.sort(key=lambda f: int(re.sub(r'\\\\D', '', f)))\\n\\n #2. For each file in the dir:\\n for filename in lst:\\n #Open it\\n f = open(in_dir+\\\"/\\\"+filename, \\\"r\\\")\\n #Read it\\n text = f.read()\\n #Get the sentences in the file\\n sentences = nltk.sent_tokenize(text)\\n #This \\\" \\\" token will be used for NOT queries\\n not_postings_list = dictionary.get(\\\" \\\", list())\\n not_postings_list.append(int(filename))\\n dictionary[\\\" \\\"] = not_postings_list\\n\\n for sentence in sentences:\\n #For each sentence get the words that compose it\\n words = nltk.word_tokenize(sentence)\\n\\n for word in words:\\n \\n word = word.lower()\\n word = stemmer.stem(word)\\n \\n\\n #For each word check if its already registered in the dictionary\\n #If its not, a new postings list is created for that word\\n #If its already registered, its postings list is retrieved\\n postings_list = dictionary.get(word, list())\\n \\n #This is to check if the word is not registered and a postings list \\n #was just created for it\\n if(len(postings_list) == 0):\\n #In that case save the postings list in the dictionary\\n dictionary[word] = postings_list\\n #Then add the file name (id) in which the word appears\\n postings_list.append(int(filename))\\n\\n #If the word was already in the dictionary, we check that the last entry\\n #in its posting list is not the same as the filename (id) we are currently checking\\n #as we don't want duplicate doc ids in the postings list\\n elif(postings_list[len(postings_list)-1] != int(filename)):\\n #So if its the first time that it appears in the file we save the filename (id)\\n postings_list.append(int(filename))\\n\\n #This is to limit the number of docs that will be indexed \\n num_files -= 1 \\n if(num_files <= 0): \\n break\\n \\n #with open('ugly_dictionary.txt', 'w') as fp:\\n #json.dump(dictionary, fp)\\n #After checking all the words in the files, we have our dictionary with its postings lists\\n # But we don't want to save the postings list with the dictionary as they can be quite large\\n # Now we will traverse each word (key) in the dictionary, get its postings list and save it in a different file \\n \\n postings_list_file = open(out_postings, \\\"wb\\\") \\n for word in dictionary:\\n postings_list = dictionary[word]\\n #Know the starting position\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n dictionary[word] = postings_list_position\\n #Close the postings lists file\\n postings_list_file.close() \\n #Now open the dictionary file and save it\\n \\n with open(out_dict, 'wb') as dictionary_file:\\n pickle.dump(dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n '''\\n with open(out_dict, 'w') as fp:\\n json.dump(dictionary, fp)\\n '''\",\n \"def read_txt_embeddings(path, params):\\n word2id = {}\\n vectors = []\\n\\n # load pretrained embeddings\\n _emb_dim_file = params.emb_dim\\n with io.open(path, 'r', encoding='utf-8', newline='\\\\n', errors='ignore') as f:\\n for i, line in enumerate(f):\\n if i == 0:\\n split = line.split()\\n assert len(split) == 2\\n assert _emb_dim_file == int(split[1])\\n continue\\n word, vect = line.rstrip().split(' ', 1)\\n vect = np.fromstring(vect, sep=' ')\\n if word in word2id:\\n logger.warning(\\\"Word \\\\\\\"%s\\\\\\\" found twice!\\\" % word)\\n continue\\n if not vect.shape == (_emb_dim_file,):\\n logger.warning(\\\"Invalid dimension (%i) for word \\\\\\\"%s\\\\\\\" in line %i.\\\"\\n % (vect.shape[0], word, i))\\n continue\\n assert vect.shape == (_emb_dim_file,)\\n word2id[word] = len(word2id)\\n vectors.append(vect[None])\\n\\n assert len(word2id) == len(vectors)\\n logger.info(\\\"Loaded %i pretrained word embeddings from %s\\\" % (len(vectors), path))\\n\\n # compute new vocabulary / embeddings\\n embeddings = np.concatenate(vectors, 0)\\n embeddings = torch.from_numpy(embeddings).float()\\n\\n assert embeddings.size() == (len(word2id), params.emb_dim)\\n return word2id, embeddings\",\n \"def learn_embeddings(walk_dir,dim,window_size,iter_num,workers,embedding_filename):\\r\\n logging.debug('begin learning embeddings')\\r\\n learning_begin_time = time.time()\\r\\n\\r\\n walk_files = glob.glob('%s/__random_walks_*.txt' % walk_dir)\\r\\n sentences = Sentences(walk_files)\\r\\n model = Word2Vec(sentences, size=dim, window=window_size, min_count=0, sg=1, hs=0, workers=workers, iter=iter_num)\\r\\n\\r\\n learning_end_time = time.time()\\r\\n logging.debug('done learning embeddings')\\r\\n logging.debug('learning time: {}'.format(learning_end_time - learning_begin_time))\\r\\n print('learning_time', learning_end_time - learning_begin_time, flush=True)\\r\\n model.wv.save_word2vec_format(fname=embedding_filename, binary=False)\\r\\n return model.wv\",\n \"def loadw2v(embfile, embsize, myzipfile=None, maxvoc=None):\\n word_to_ix = {}\\n word_to_ix[constants.PAD_ITEM] = 0\\n word_to_ix[constants.UNK_ITEM] = 1\\n # fill padding word with zeros\\n model = [[0.]*embsize]\\n # fill unk word with random numbers\\n model.append(np.random.normal(0,0.15,size=embsize).tolist())\\n if myzipfile != None:\\n zip = zipfile.ZipFile(myzipfile, 'r')\\n f = zip.read(embfile).split(\\\"\\\\n\\\")\\n else:\\n #f = open(embfile, 'r')\\n f = codecs.open(embfile, \\\"r\\\", \\\"utf-8\\\")\\n ix = 2\\n for line in f:\\n if maxvoc!=None:\\n if ix >= maxvoc:\\n break\\n splitLine = line.split()\\n if(len(splitLine)>embsize+1):\\n phrase_lst = splitLine[:-embsize]\\n word = ' '.join(phrase_lst)\\n embedding = [float(val) for val in splitLine[-embsize:]]\\n word_to_ix[word] = ix\\n model.append(embedding)\\n ix += 1\\n elif(len(splitLine)>2):\\n word = splitLine[0]\\n embedding = [float(val) for val in splitLine[1:]]\\n word_to_ix[word]=ix\\n model.append(embedding)\\n ix += 1\\n else:\\n print(line)\\n print(\\\"%d words loaded!\\\" % len(model))\\n return word_to_ix, model\",\n \"def save_dict(emb, path_to_vec, dim=100):\\n word_vec = {}\\n for w in emb.keys():\\n word_vec[w] = emb[w]\\n with open(path_to_vec + f'embedding_{str(dim)}d.txt', 'w') as file:\\n for w, v in word_vec.items():\\n file.write(w + ' ')\\n for el in v:\\n file.write(\\\"{:.20f}\\\".format(float(el)) + ' ')\\n file.write('\\\\n')\",\n \"def get_word_embeddings(embeddingsPath, allwords, splittype=\\\" \\\"):\\n word2Idx = {}\\n wordEmbeddings = []\\n print('Using word embeddings:', embeddingsPath)\\n openfile = _get_correct_open(embeddingsPath)\\n with openfile(embeddingsPath,'r', encoding='utf-8') as fEmbeddings:\\n c = 0\\n for line in fEmbeddings:\\n c+=1\\n split = line.strip().split(splittype)\\n if '' in split:\\n raise ValueError(\\\"Error in spacing of word vector file:\\\"+\\n \\\" bad formatting. Consider using different value of splittype.\\\")\\n word = split[0]\\n\\n # fastText and Yogatama pre-trained embedding starts with a line\\n # with 2 elements that we need to ignore:\\n if len(split) <= 5:\\n print('Ignoring line '+str(c))\\n continue\\n\\n if len(word2Idx) == 0: #Add padding+unknown\\n word2Idx[\\\"PADDING_TOKEN\\\"] = len(word2Idx)\\n vector = np.zeros(len(split)-1) #Zero vector for 'PADDING' word\\n wordEmbeddings.append(vector)\\n\\n word2Idx[\\\"UNKNOWN_TOKEN\\\"] = len(word2Idx)\\n vector = np.random.uniform(-0.25, 0.25, len(split)-1)\\n wordEmbeddings.append(vector)\\n\\n if word.lower() in allwords:\\n vector = np.array([float(num) for num in split[1:]])\\n wordEmbeddings.append(vector)\\n word2Idx[word] = len(word2Idx)\\n\\n wordEmbeddings = np.array(wordEmbeddings)\\n return wordEmbeddings, word2Idx\",\n \"def load_word_embeddings(self, word_embeddings, word_to_ix):\\n logger.info(\\\"Loading the vocabulary\\\")\\n self.vocab = {}\\n self.index2word = []\\n counts = {}\\n for word in word_to_ix:\\n counts[word] = counts.get(word, 0) + 1\\n self.vocab_size = len(counts)\\n self.vector_size = word_embeddings.shape[1]\\n self.vectors = np.zeros((self.vocab_size, self.vector_size))\\n self.index2word = [None] * self.vocab_size\\n logger.info(\\\"Corpus has %i words\\\", len(self.vocab))\\n for word_id, word in enumerate(counts):\\n self.vocab[word] = Vocab(index=word_id, count=counts[word])\\n self.vectors[word_id] = word_embeddings[word_to_ix[word]]\\n self.index2word[word_id] = word\\n assert((len(self.vocab), self.vector_size) == self.vectors.shape)\\n logger.info(\\\"Loaded matrix of %d size and %d dimensions\\\", self.vocab_size, self.vector_size)\",\n \"def load_embeddings(path, vocab, source_domain, target_domain, emb_name):\\n\\n pkl = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\\n if os.path.exists(pkl):\\n print(\\\"Load embeddings from existing pkl file %s...\\\" % pkl)\\n # word embeddings weights have been loaded\\n embeddings = pickle.load(open(pkl, 'rb'))\\n else:\\n print(\\\"Load embedding from %s...\\\" % path)\\n raw_embeddings = {}\\n if emb_name == 'yelp_electronics':\\n with open(path) as fp:\\n for line in fp:\\n word_vector = line.split(\\\",\\\")[:-1]\\n vector_list = []\\n for element in word_vector[len(word_vector) - 100:]:\\n vector_list.append(float(element))\\n word = ','.join(word_vector[:len(word_vector) - 100])\\n vector = np.asarray(vector_list)\\n if word in vocab:\\n raw_embeddings[word] = vector\\n else:\\n with open(path) as fp:\\n for line in fp:\\n eles = line.strip().split(' ')\\n word = eles[0]\\n if word in vocab:\\n raw_embeddings[word] = eles[1:]\\n\\n dim_w = len(raw_embeddings['the'])\\n n_words = len(vocab)\\n embeddings = np.zeros(shape=(n_words, dim_w))\\n for w in vocab:\\n wid = vocab[w]\\n if w in raw_embeddings:\\n embeddings[wid] = np.array([float(ele) for ele in raw_embeddings[w]])\\n else:\\n # for OOV words, add random initialization\\n embeddings[wid] = np.random.uniform(-0.25, 0.25, dim_w)\\n print(\\\"Find %s word embeddings...\\\" % len(embeddings))\\n if not os.path.exists('./work/embeddings'):\\n os.mkdir('./work/embeddings')\\n emb_path = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\\n # write the embedding weights back to the disk\\n pickle.dump(embeddings, open(emb_path, 'wb'))\\n embeddings = np.array(embeddings, dtype='float32')\\n return embeddings\",\n \"def get_word_embeddings(t, folder, lang=\\\"en\\\"):\\n vecs_url = f\\\"https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.{lang}.300.vec.gz\\\"\\n vecs_gz_filename = vecs_url.rpartition(\\\"/\\\")[2]\\n os.makedirs(folder, exist_ok=True)\\n vecs_gz_filepath = os.path.join(folder, vecs_gz_filename)\\n\\n tokenizer_vocab_size = len(t.vocab)\\n\\n if wait_for_file_stable(vecs_gz_filepath):\\n print(\\\"Using existing embeddings file\\\")\\n else:\\n print(\\\"Downloading word vectors...\\\")\\n subprocess.run([\\\" \\\".join([\\\"wget\\\", \\\"-NP\\\", folder, vecs_url])], check=True, shell=True)\\n\\n print(\\\"Loading into memory...\\\")\\n embeddings_index = dict()\\n with gzip.open(vecs_gz_filepath, \\\"rt\\\") as zipf:\\n firstline = zipf.readline()\\n emb_vocab_size, emb_d = firstline.split(\\\" \\\")\\n emb_vocab_size = int(emb_vocab_size)\\n emb_d = int(emb_d)\\n for line in zipf:\\n values = line.split()\\n word = values[0]\\n # Only load subset of the embeddings recognised by the tokenizer:\\n if word in t.vocab.stoi:\\n coefs = np.asarray(values[1:], dtype=\\\"float32\\\")\\n embeddings_index[word] = coefs\\n print(\\\"Loaded {} of {} word vectors for tokenizer vocabulary length {}\\\".format(\\n len(embeddings_index),\\n emb_vocab_size,\\n tokenizer_vocab_size,\\n ))\\n\\n # create a weight matrix for words in training docs\\n embedding_matrix = np.zeros((tokenizer_vocab_size, emb_d))\\n for word, i in t.vocab.stoi.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n return embedding_matrix\",\n \"def create_vocabulary(sentences, path):\\n print('creating vocab..')\\n\\n word_dict = dict(); vocabulary = dict()\\n for sentence in sentences:\\n for word in nltk.word_tokenize(sentence):\\n if word not in word_dict:\\n word_dict[word] = ''\\n word_dict['<s>'] = ''\\n word_dict['</s>'] = ''\\n\\n with open(path, encoding=\\\"utf8\\\") as f:\\n for line in f:\\n word, vec = line.split(' ', 1)\\n if word in word_dict:\\n vocabulary[word] = np.fromstring(vec, sep=' ')\\n\\n print('vocabulary was created successfully!')\\n return vocabulary\",\n \"def glove_embedding(self, texts, file):\\n self.embedding_dict = dict()\\n glove_file = open(file, encoding='utf-8')\\n for line in glove_file:\\n word_vector = line.split()\\n word = word_vector[0]\\n word_vector_arr = np.asarray(word_vector[1:], dtype='float32')\\n self.embedding_dict[word] = word_vector_arr\\n glove_file.close()\\n \\n i = 0\\n with pgb.ProgressBar(max_value=len(texts)) as bar:\\n for text in texts:\\n vec = []\\n text = text.split()\\n for t in text:\\n try:\\n vec.append(self.embedding_dict[t.lower()])\\n except KeyError:\\n pass\\n ## There are no matched words\\n if len(vec) == 0:\\n print(\\\"len 0 vec\\\")\\n self.word_vec.append(np.zeros((100)))\\n else:\\n #print(np.array(vec))\\n #print(np.array(vec).shape)\\n sentence = self.sentence_vec(np.array(vec))\\n #print(sentence)\\n #print(sentence.shape)\\n self.word_vec.append(sentence)\\n i += 1\\n bar.update(i)\\n self.word_vec = np.array(self.word_vec)\\n print(self.word_vec.shape)\",\n \"def id2vec_preprocess(args):\\n log = logging.getLogger(\\\"preproc\\\")\\n log.info(\\\"Loading docfreq model from %s\\\", args.docfreq_in)\\n df_model = DocumentFrequencies(log_level=args.log_level).load(source=args.docfreq_in)\\n coocc_model = Cooccurrences().load(args.input)\\n if numpy.any(coocc_model.matrix.data < 0):\\n raise ValueError((\\\"Co-occurrence matrix %s contains negative elements. \\\"\\n \\\"Please check its correctness.\\\") % args.input)\\n if numpy.any(numpy.isnan(coocc_model.matrix.data)):\\n raise ValueError((\\\"Co-occurrence matrix %s contains nan elements. \\\"\\n \\\"Please check its correctness.\\\") % args.input)\\n\\n try:\\n df_meta = coocc_model.get_dep(DocumentFrequencies.NAME)\\n if df_model.meta != df_meta:\\n raise ValueError((\\n \\\"Document frequency model you provided does not match dependency inside \\\"\\n \\\"Cooccurrences model:\\\\nargs.docfreq.meta:\\\\n%s\\\\ncoocc_model.get_dep\\\"\\n \\\"(\\\\\\\"docfreq\\\\\\\")\\\\n%s\\\\n\\\") % (df_model.meta, df_meta))\\n except KeyError:\\n pass # There is no docfreq dependency\\n\\n vs = args.vocabulary_size\\n if len(df_model) < vs:\\n vs = len(df_model)\\n sz = args.shard_size\\n if vs < sz:\\n raise ValueError(\\n \\\"vocabulary_size=%s is less than shard_size=%s. You should specify a smaller \\\"\\n \\\"shard_size (e.g. shard_size=%s).\\\" % (vs, sz, vs))\\n vs -= vs % sz\\n log.info(\\\"Effective vocabulary size: %d\\\", vs)\\n df_model = df_model.greatest(vs)\\n log.info(\\\"Sorting the vocabulary...\\\")\\n chosen_words = sorted(df_model.tokens())\\n word_indices = {w: i for i, w in enumerate(chosen_words)}\\n\\n if not os.path.exists(args.output):\\n os.makedirs(args.output)\\n with open(os.path.join(args.output, \\\"row_vocab.txt\\\"), \\\"w\\\") as out:\\n out.write(\\\"\\\\n\\\".join(chosen_words))\\n log.info(\\\"Saved row_vocab.txt\\\")\\n shutil.copyfile(os.path.join(args.output, \\\"row_vocab.txt\\\"),\\n os.path.join(args.output, \\\"col_vocab.txt\\\"))\\n log.info(\\\"Saved col_vocab.txt\\\")\\n del chosen_words\\n\\n ccmatrix = extract_coocc_matrix((vs, vs), word_indices, coocc_model)\\n\\n log.info(\\\"Planning the sharding...\\\")\\n bool_sums = ccmatrix.indptr[1:] - ccmatrix.indptr[:-1]\\n reorder = numpy.argsort(-bool_sums)\\n with open(os.path.join(args.output, \\\"row_sums.txt\\\"), \\\"w\\\") as out:\\n out.write(\\\"\\\\n\\\".join(map(str, bool_sums.tolist())))\\n log.info(\\\"Saved row_sums.txt\\\")\\n shutil.copyfile(os.path.join(args.output, \\\"row_sums.txt\\\"),\\n os.path.join(args.output, \\\"col_sums.txt\\\"))\\n log.info(\\\"Saved col_sums.txt\\\")\\n\\n log.info(\\\"Writing the shards...\\\")\\n os.makedirs(args.output, exist_ok=True)\\n nshards = vs // args.shard_size\\n for row in progress_bar(range(nshards), log, expected_size=nshards):\\n for col in range(nshards):\\n indices_row = reorder[row::nshards]\\n indices_col = reorder[col::nshards]\\n shard = ccmatrix[indices_row][:, indices_col].tocoo()\\n\\n example = tf.train.Example(features=tf.train.Features(feature={\\n \\\"global_row\\\": _int64s(indices_row),\\n \\\"global_col\\\": _int64s(indices_col),\\n \\\"sparse_local_row\\\": _int64s(shard.row),\\n \\\"sparse_local_col\\\": _int64s(shard.col),\\n \\\"sparse_value\\\": _floats(shard.data)}))\\n\\n with open(os.path.join(args.output,\\n \\\"shard-%03d-%03d.pb\\\" % (row, col)),\\n \\\"wb\\\") as out:\\n out.write(example.SerializeToString())\\n log.info(\\\"Success\\\")\",\n \"def _make_index(self, fname, sents, words):\\n for w in words:\\n # word index for this file only\\n findex = []\\n\\n for ixS, s in enumerate(sents):\\n # iterate over each word in the sentencep\\n for ixT, token in enumerate(s):\\n # could use regex for substring matching instead\\n if w == token.lower():\\n findex.append((ixS, ixT))\\n # keep track of word use frequency\\n self._freq[w] += 1\\n\\n # grow the main index \\n self._index[w][fname]= findex\",\n \"def produce_outputs(self):\\n # if self.loaded_aggregated:\\n # debug(\\\"Skippping {} mapping due to preloading\\\".format(self.base_name))\\n # return\\n # need to calc term numeric index for aggregation\\n\\n\\n # if self.loaded_preprocessed:\\n # debug(\\\"Skippping {} mapping due to preloading\\\".format(self.base_name))\\n # return\\n\\n bagger = Bag(vocabulary=self.term_list, weighting=self.base_name, ngram_range=self.ngram_range)\\n\\n self.embeddings = np.ndarray((0, len(self.term_list)), dtype=np.int32)\\n for idx in self.indices.get_train_test():\\n texts = Text.get_strings(self.text.data.get_slice(idx))\\n vecs = bagger.map_collection(texts, fit=False, transform=True)\\n self.embeddings = np.append(self.embeddings, vecs, axis=0)\\n del texts\\n\\n # texts = Text.get_strings(self.text.data.get_slice(test_idx))\\n # vec_test = bagger.map_collection(texts, fit=do_fit)\\n # del texts\\n\\n # self.embeddings = np.vstack((vec_train, vec_test))\\n\\n # self.embeddings = np.append(vec_train, vec_test)\\n # self.vector_indices = (np.arange(len(train)), np.arange(len(test)))\\n\\n # set misc required variables\\n self.set_constant_elements_per_instance()\",\n \"def index2words(index_sentence, vcb_file):\\n\\n sentence = ''\\n indx_dict = {}\\n vcb = open(vcb_file).readlines()\\n for line in vcb:\\n line = line.split()\\n indx_dict[int(line[0])] = line[1]\\n\\n for word in index_sentence:\\n\\n if word == -1:\\n sentence += '_eps_' + ' '\\n else:\\n sentence += indx_dict[word] + ' '\\n return sentence\",\n \"def prepare_embeddings_dict(ixtow, source, output):\\n dim = source[list(source)[0]].shape[0]\\n print('Embedding dimension : %d' % dim)\\n G = np.zeros((len(ixtow) + 1, dim), dtype=\\\"float32\\\")\\n print(\\\"EOS norm:\\\", np.sum(G[0] ** 2))\\n for i in range(1, len(ixtow) + 1):\\n word = ixtow[str(i)]\\n if word.lower() in source:\\n G[i] = source[word.lower()]\\n if not np.sum(G[i] ** 2):\\n raise ValueError(\\\"Norm of the embedding null > token %d | word %s\\\" % (i, word))\\n else:\\n try:\\n if CORRECT[word.lower()] in source:\\n print(\\\"Correcting %s into %s\\\" % (word.lower(), CORRECT[word.lower()]))\\n word = CORRECT[word.lower()]\\n G[i] = source[word]\\n if not np.sum(G[i] ** 2):\\n raise ValueError(\\\"Norm of the embedding null > token %d | word %s\\\" % (i, word))\\n except:\\n print(\\\"Missing word %s in the given embeddings\\\" % word)\\n pd(G, output)\\n return G\",\n \"def index(self,\\n path_in: str,\\n path_out: str,\\n # path_terms: str\\n ) -> Tuple[Dict[str, int], Dict[int, str]]:\\n self._docs_processed = 0\\n self._start_time = time.time()\\n\\n # terms = set()\\n # with open(path_terms, 'r', encoding='utf8') as fin:\\n # for line in fin:\\n # terms.add(line.strip('\\\\n'))\\n\\n word_to_idx = {}\\n idx_to_word = {}\\n i = 0\\n corpus_idx = []\\n for doc in get_docs(path_in):\\n doc_idx = []\\n for sent in doc:\\n for word in sent:\\n if word not in word_to_idx:\\n word_to_idx[word] = i\\n idx_to_word[i] = word\\n i += 1\\n idx_sent = [word_to_idx[word] for word in sent]\\n doc_idx.append(idx_sent)\\n corpus_idx.append(doc_idx)\\n # doc_idx = []\\n self._docs_processed += 1\\n self._update_cmd_counter()\\n\\n if self._docs_processed % self._file_write_threshhold == 0:\\n self._update_cmd_time_info()\\n self.write_corpus(corpus_idx, path_out)\\n corpus_idx = []\\n\\n self._update_cmd_time_info(end=True)\\n self.write_corpus(corpus_idx, path_out)\\n self._already_written_to_file = False\\n return word_to_idx, idx_to_word\",\n \"def _init_vocab(self):\\n self._word2idx = {}\\n self._idx2word = {}\\n self.freqs = {}\\n self.vocab_size = 0\\n\\n self._add_word(self.pad_word)\\n self._add_word(self.start_word)\\n self._add_word(self.end_word)\\n self._add_word(self.unk_word)\\n\\n self.start_word_idx = self.stoi(self.start_word)\\n self.end_word_idx = self.stoi(self.end_word)\\n self.unk_word_idx = self.stoi(self.unk_word)\\n self.pad_word_idx = self.stoi(self.pad_word)\\n\\n self._special_tokens = {\\n 'bos_token': self.start_word,\\n 'cls_token': self.start_word,\\n 'eos_token': self.end_word,\\n 'sep_token': self.end_word,\\n 'pad_token': self.pad_word,\\n 'unk_token': self.unk_word,\\n }\\n\\n self._special_ids = {\\n 'bos_token_id': self.start_word_idx,\\n 'cls_token_id': self.start_word_idx,\\n 'eos_token_id': self.end_word_idx,\\n 'sep_token_id': self.end_word_idx,\\n 'pad_token_id': self.pad_word_idx,\\n 'unk_token_id': self.unk_word_idx,\\n }\\n\\n self.cls_token_id = self.bos_token_id = self.start_word_idx\\n self.eos_token_id = self.sep_token_id = self.end_word_idx\\n self.pad_token_id = self.pad_word_idx\\n self.unk_token_id = self.unk_word_idx\\n\\n self.cls_token = self.bos_token = self.start_word\\n self.eos_token = self.sep_token = self.end_word\\n self.pad_token = self.pad_word\\n self.unk_token = self.unk_word\",\n \"def retrieve_saved_data():\\n \\n sequences = np.load('sequences.npy')\\n test_sequences = np.load('test_sequences.npy')\\n labels = np.load('labels.npy')\\n \\n iw = []\\n with open('index_word.json', 'r') as f:\\n for l in f:\\n iw.append(json.loads(l))\\n\\n index_word = iw[0]\\n index_word = {int(key): word for key, word in index_word.items()}\\n\\n wi = []\\n with open('word_index.json', 'r') as f:\\n for l in f:\\n wi.append(json.loads(l))\\n\\n word_index = wi[0]\\n word_index = {word: int(index) for word, index in word_index.items()}\\n \\n vs = len(word_index) + 1\\n \\n return sequences, labels, test_sequences, word_index, index_word, vs\",\n \"def _load_vocabulary(self) -> Dict[str, int]:\\n\\n df_existing_vocab = self._db_connection.get_dataframe(table_name='tfidf_vocabulary', schema='encoded_articles')\\n\\n df_existing_vocab.set_index('word', inplace=True)\\n\\n return df_existing_vocab['feature_matrix_index'].to_dict()\",\n \"def main():\\n logging.basicConfig(level=logging.DEBUG)\\n custom_embedding = True\\n\\n # Download embeddings'\\n if custom_embedding:\\n embedding_path = '../data/custom_embedding.pkl'\\n embedding_index_path = '../data/custom_vocab_index.pkl'\\n logging.info('Pulling custom embedding from: {}, and custom vocab from: {}'.format(embedding_path, embedding_index_path))\\n embedding_matrix = pickle.load(open(embedding_path, 'rb'))\\n embedding_index_lookup = pickle.load(open(embedding_index_path, 'rb'))\\n\\n else:\\n logging.warning('Downloading embedding. If downloading for the first time, this make take 5-10 minutes.')\\n embedding_url = 'https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz'\\n embedding_path = '~/nlp_example/'\\n embedding_filename = 'GoogleNews-vectors-negative300.bin.gz'\\n lib.download_file(embedding_url, embedding_path, embedding_filename)\\n\\n # Unpack embedding\\n model = gensim.models.KeyedVectors.load_word2vec_format(embedding_path + '/' + embedding_filename, binary=True)\\n embedding_matrix = model.syn0\\n embedding_index_lookup = dict([(k, v.index) for k, v in model.vocab.items()])\\n\\n # Create thesaurus\\n thesaurus = Thesaurus(embedding_matrix, embedding_index_lookup)\\n\\n # Find nearest neighbors for examples\\n print(thesaurus.synonyms('day'))\\n print(thesaurus.synonyms('top'))\\n print(thesaurus.synonyms('bottom'))\\n print(thesaurus.synonyms('cat'))\\n print(thesaurus.synonyms('grown'))\\n\\n\\n pass\",\n \"def load_embeddings(filename):\\n count = 0\\n matrix = []\\n word_map = {}\\n with open(filename, encoding=\\\"utf8\\\") as f:\\n # with open(filename) as f:\\n for line in f:\\n line = line.strip()\\n items = line.split()\\n word = items[0]\\n rest = items[1:]\\n # print(\\\"word:\\\", word)\\n word_map[word] = count\\n count += 1\\n\\n rest = list(map(float, rest))\\n matrix.append(rest)\\n matrix = np.array(matrix)\\n return word_map, matrix\",\n \"def extract_word2vec(fichier, words_indices): \\n \\n word2vec={} #\\n \\n #\\n with open(fichier,\\\"r\\\",encoding=\\\"utf-8\\\") as file:\\n for line in file:\\n line = line.replace(\\\" \\\\n\\\",\\\"\\\").split(\\\" \\\")\\n # Lecture des informations du fichier\\n # nombre de mots presents et nombre de features\\n if len(line)==2 :\\n nb_words=int(line[0])\\n nb_feats=int(line[1])\\n \\n #\\n else:\\n if line[0] in words_indices:\\n word, vec = line[0],np.array(line[1:])\\n word2vec[word]=vec\\n\\n print(\\\"{} embbedings de taille {} pertinent parmi les {} du fichier\\\".format(len(word2vec), nb_feats, nb_words))\\n\\n return word2vec, nb_feats\",\n \"def _vector_mapping(self) -> dict:\\n words = set()\\n for file in os.listdir(self.processed_path):\\n doc_path = f\\\"{self.processed_path}/{file}\\\"\\n with open(doc_path, 'r') as f:\\n text_words = f.readline().split()\\n words = words.union(set(text_words))\\n words = list(words)\\n words.sort()\\n\\n return dict(zip(words, range(len(words))))\",\n \"def build_vocab(train_dir, vocab_dir, vocab_size=5000):\\n data_train, _ = read_file(train_dir)\\n\\n all_data = []\\n for content in data_train:\\n all_data.extend(content)\\n\\n counter = Counter(all_data)\\n count_pairs = counter.most_common(vocab_size-1)\\n words, _ = list(zip(*count_pairs))\\n\\n open_file(vocab_dir,mode='w').write('\\\\n'.join(words)+'\\\\n')\",\n \"def get_glove_embedding():\\n embedding = {}\\n N = 400_000\\n print(\\\"Reading glove embedding...\\\")\\n with open(GLOVE_EMBD_PATH, \\\"rb\\\") as f:\\n for line in tqdm(f, total=N):\\n line = line.decode().split()\\n word = line[0].lower()\\n vector = np.array(line[1:]).astype(np.float32)\\n embedding[word] = vector\\n\\n return embedding\",\n \"def load_word_to_index(dict_word_to_index_file_name):\\n with open(dict_word_to_index_file_name, 'r') as f:\\n word_to_index = json.load(f)\\n _LAST_INDEX = len(word_to_index) - 2 # Why - 2? Open issue?\\n print(\\\"word_to_index dict restored from '{}'.\\\".format(dict_word_to_index_file_name))\\n word_to_index = defaultdict(lambda: _LAST_INDEX, word_to_index)\\n\\n return word_to_index\",\n \"def preprocess(self):\\n self.word_to_id, self.unk_word_list = self.build_vocab(mode=\\\"word\\\")\\n self.word_vocab_size = len(self.word_to_id)\\n self.max_word_len = self.get_max_word_length(self.word_to_id)\\n # Do not write the same file again\\n if not os.path.exists(self.words_vocab_file):\\n with open(self.words_vocab_file, 'wb') as f:\\n pickle.dump((self.word_to_id, self.unk_word_list), f)\\n if self.unit != \\\"word\\\":\\n self.preprocess_sub_units()\",\n \"def get_train_data(self, train_data):\\n X = []\\n Y = []\\n\\n # word 2 indices and tag 2 indices\\n w2i = {} # word to index\\n c2i = {} # char to index\\n tag2idx = {} # tag2idx\\n\\n w2i[\\\"_UNK\\\"] = 0 # unk word / OOV\\n c2i[\\\"_UNK\\\"] = 0 # unk char\\n c2i[\\\"<w>\\\"] = 1 # word start\\n c2i[\\\"</w>\\\"] = 2 # word end index\\n \\n \\n num_sentences=0\\n num_tokens=0\\n for instance_idx, (words, tags) in enumerate(read_conll_file(train_data)):\\n instance_word_indices = [] #sequence of word indices\\n instance_char_indices = [] #sequence of char indices\\n instance_tags_indices = [] #sequence of tag indices\\n\\n for i, (word, tag) in enumerate(zip(words, tags)):\\n\\n # map words and tags to indices\\n if word not in w2i:\\n w2i[word] = len(w2i)\\n instance_word_indices.append(w2i[word])\\n\\n if self.c_in_dim > 0:\\n chars_of_word = [c2i[\\\"<w>\\\"]]\\n for char in word:\\n if char not in c2i:\\n c2i[char] = len(c2i)\\n chars_of_word.append(c2i[char])\\n chars_of_word.append(c2i[\\\"</w>\\\"])\\n instance_char_indices.append(chars_of_word)\\n\\n if tag not in tag2idx:\\n tag2idx[tag]=len(tag2idx)\\n\\n instance_tags_indices.append(tag2idx.get(tag))\\n\\n num_tokens+=1\\n\\n num_sentences+=1\\n\\n X.append((instance_word_indices, instance_char_indices)) # list of word indices, for every word list of char indices\\n Y.append(instance_tags_indices)\\n\\n\\n print(\\\"%s sentences %s tokens\\\" % (num_sentences, num_tokens), file=sys.stderr)\\n print(\\\"%s w features, %s c features \\\" % (len(w2i),len(c2i)), file=sys.stderr)\\n if self.c_in_dim == 0:\\n print(\\\"char features disabled\\\", file=sys.stderr)\\n\\n assert(len(X)==len(Y))\\n\\n # store mappings of words and tags to indices\\n self.set_indices(w2i, c2i, tag2idx)\\n\\n return X, Y\",\n \"def load_words_from_file(path, voc_path=None):\\n label_to_idx = {}\\n dict_size = 0\\n label_ids = []\\n with open(path, \\\"r\\\") as fin:\\n for label in fin:\\n if label not in label_to_idx:\\n label_to_idx[label] = dict_size\\n dict_size += 1\\n label_ids.append(label_to_idx[label])\\n if voc_path:\\n with open(voc_path, \\\"w+\\\") as fout:\\n json.dump(label_to_idx, fout)\\n return torch.tensor(label_ids)\",\n \"def glove(data_fname='glove.840B.300d.txt', out_fname='glove.pkl'):\\n words, U, dim = [], [], None\\n with open(DATA_DIR + data_fname, 'rb') as f:\\n for j, line in enumerate(f):\\n x = line.strip().split()\\n word, vector, d = x[0], np.ravel(x[1:]), len(x) - 1\\n if dim is None: dim = d\\n elif d != dim: raise Exception('{0}: {1}!={2}'.format(j, dim, d))\\n U.append(vector)\\n words.append(word)\\n U = np.array(U)\\n print \\\"Found {0} words\\\".format(len(words))\\n print \\\"Found {0}x{1} embedding matrix\\\".format(*U.shape)\\n with open(DATA_DIR + out_fname, 'wb') as f:\\n cPickle.dump((words, U), f)\",\n \"def dep_w2v(data_fname='deps.words', out_fname='depw2v.pkl'):\\n M = np.loadtxt(DATA_DIR + data_fname, converters={0: lambda x: 0})\\n M = M[:, 1:]\\n print \\\"Loaded {0}x{1} word vector matrix\\\".format(*M.shape)\\n with open(DATA_DIR + data_fname, 'rb') as f:\\n words = [line.split()[0] for line in f]\\n with open(DATA_DIR + out_fname, 'wb') as f:\\n cPickle.dump((words, M), f)\",\n \"def save_lda_elements(text_data):\\n dictionary = corpora.Dictionary(text_data)\\n corpus = [dictionary.doc2bow(text) for text in text_data]\\n pickle.dump(corpus, open('corpus.pkl', 'wb'))\\n dictionary.save('dictionary.gensim')\",\n \"def __init__(self, docs, dict_path= 'wordindex.npy'):\\n super(NNModel, self).__init__()\\n self.stopwords += self.additional_stopwords\\n self.words = set(['OOB', 'UNK']) # OOB for out of boundary, UNK for unknown words\\n self.docs = []\\n\\n for doc in docs:\\n datum = []\\n for word in self.cut_words(doc):\\n self.words.add(word)\\n datum.append(word)\\n self.docs.append(datum)\\n\\n self.words = list(self.words)\\n self.word2idx = dict([(self.words[i], i) for i in range(len(self.words))])\\n logging.info(f'{len(docs)} articles loaded, with word bag length: {len(self.words)}')\\n if dict_path != '': # save dict\\n np.save(DATA_DIR + dict_path, self.word2idx)\",\n \"def _load_word_embedding(self, lang):\\n dict_fold = 'train' # which fold of the data will be used to produce results\\n if self.args.task == 'conneau' or self.args.task == 'xling':\\n data_dir = os.path.join(self.args.data_dir, 'MUSE')\\n lang_path = os.path.join(data_dir, 'wiki.' + lang + '.vec')\\n elif self.args.task == 'dinu':\\n data_dir = os.path.join(self.args.data_dir, 'dinu')\\n lang_path = os.path.join(data_dir, 'embeddings', lang + '.emb.txt')\\n elif self.args.task == 'zhang':\\n order = [lang,trg]\\n if lang == 'en':\\n order = order[::-1]\\n data_dir = os.path.join(self.args.home_dir,'pkg/UBiLexAT/data/','-'.join(order))\\n lang_path = os.path.join(data_dir, 'word2vec.' + lang)\\n\\n langfile = open(lang_path, encoding=self.args.encoding, errors='surrogateescape')\\n words, xs = embeddings.read(langfile, self.args.maxs)\\n langfile.close()\\n # Build word to index map\\n word2ind = {word: i for i, word in enumerate(words)}\\n\\n return xs, words, word2ind\",\n \"def prepare_word_emb_matrices(experiment):\\r\\n\\r\\n with open(\\\"public_data/stats/stats_train.pkl\\\", 'rb') as stats:\\r\\n stats = pickle.load(stats)\\r\\n vocab = stats[\\\"VOCAB\\\"]\\r\\n stops = [word.lower() for word in set(stopwords.words('english'))]\\r\\n vocab = vocab + stops\\r\\n\\r\\n if experiment == \\\"RANDOM\\\":\\r\\n word_embs = np.random.uniform(low=-1.0, high=1.0, size=(len(vocab), PARAMS[\\\"SIZE\\\"])).astype(\\\"float32\\\")\\r\\n\\r\\n else:\\r\\n word_embs = []\\r\\n count_unk = 0\\r\\n count_kn = 0\\r\\n\\r\\n if experiment == \\\"5\\\":\\r\\n emb_model = KeyedVectors.load_word2vec_format(\\\"public_data/models/experiment_5/embeddings_5.bin\\\",\\r\\n binary=True)\\r\\n elif experiment == \\\"6\\\":\\r\\n emb_model = Word2Vec.load(\\\"public_data/models/experiment_6/embeddings_6\\\")\\r\\n\\r\\n elif experiment in [\\\"7\\\", \\\"8\\\"]:\\r\\n emb_model = FastText.load_fasttext_format(\\\"public_data/models/experiment_%s/embeddings_%s.bin\\\"\\r\\n %(experiment, experiment))\\r\\n for word in vocab:\\r\\n if word in emb_model:\\r\\n word_embs.append(emb_model[word])\\r\\n count_kn += 1\\r\\n else:\\r\\n word_embs.append(np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\\\"SIZE\\\"]))\\r\\n count_unk += 1\\r\\n\\r\\n word_embs = np.array(word_embs).astype(\\\"float32\\\")\\r\\n print(count_unk / (count_kn + count_unk))\\r\\n\\r\\n pad = np.zeros(shape=PARAMS[\\\"SIZE\\\"]).astype(\\\"float32\\\")\\r\\n unk = np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\\\"SIZE\\\"]).astype(\\\"float32\\\")\\r\\n word_embs = np.insert(word_embs, 0, unk, axis=0) #id 1\\r\\n word_embs = np.insert(word_embs, 0, pad, axis=0) #id 0\\r\\n\\r\\n with open(\\\"public_data/embeddings/word_embeddings_%s.pkl\\\" %experiment, 'wb') as out:\\r\\n pickle.dump(word_embs, out, protocol=4)\\r\\n\\r\\n return word_embs\",\n \"def build_index(in_dir, out_dict, out_postings):\\n print('indexing...')\\n\\n maxInt = sys.maxsize\\n\\n while True:\\n # decrease the maxInt value by factor 10 \\n # as long as the OverflowError occurs.\\n try:\\n csv.field_size_limit(maxInt)\\n break\\n except OverflowError:\\n maxInt = int(maxInt/10)\\n\\n #Dicitionary for saving the normalized weights for document vector\\n lengths = dict()\\n\\n #Number of docs read from csv\\n total_docs = 1\\n max_docs = 1000\\n\\n #Data stored in csv read file line by line and save columns data\\n with open(os.path.join(in_dir), 'r', encoding=\\\"utf8\\\") as data_csv:\\n reader = csv.DictReader(data_csv)\\n #each line corresponds to a document\\n for doc in reader:\\n\\n #if(total_docs > max_docs):\\n # break\\n\\n #If line is blank, just skip\\n if doc is None:\\n continue\\n \\n #save the different columns of the doc\\n doc_id = int(doc[\\\"document_id\\\"])\\n #Remove punctuation in title and content\\n doc_title = re.sub(r\\\"[,;@#?!&$()%\\\\[\\\\]°~^_.+=\\\\\\\"><`|}{*':/]+ *\\\", \\\" \\\", doc[\\\"title\\\"])\\n doc_content = re.sub(r\\\"[,;@#?!&$()%\\\\[\\\\]°~^_.+=\\\\\\\"><`|}{*':/]+ *\\\", \\\" \\\", doc[\\\"content\\\"])\\n doc_date = doc[\\\"date_posted\\\"]\\n doc_year = doc_date[0:4]\\n doc_court = doc[\\\"court\\\"]\\n\\n #The dictionaryies are updated, postings lists are updated or new terms added\\n update_terms_zones_dictionary(doc_id, doc_title, \\\".title\\\")\\n update_terms_zones_dictionary(doc_id, doc_content, \\\".content\\\")\\n update_date_field_dictionary(doc_id, doc_year)\\n update_court_field_dictionary(doc_id, doc_court)\\n\\n total_docs += 1\\n\\n data_csv.close()\\n\\n #This section stores the Log TF using the word counts in the postings in the dictionary\\n #It saves the Log TF in an auxiliary dictionary named lengths\\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n\\n for docID_termF in postings_list:\\n #Get the vector for the doc, where the docId is docID_termF[0]\\n #If there is no vector for this doc, then create a new dict\\n #I am using dictionaries as the vector for the word only for the calculations\\n doc_vector = lengths.get(docID_termF[0], dict())\\n #I add the logarithmic term frequency to that document vector\\n doc_vector[word] = 1 + math.log(docID_termF[1], 10)\\n #Save that to its corresponding doc\\n lengths[docID_termF[0]] = doc_vector\\n\\n #This section normalizes the Log TFs \\n for doc_vector in lengths.values():\\n #We store each of the values in a list and then use:\\n #np.linalg.norm to do the normalization = sqrt(sum(values^2))\\n weights = doc_vector.values()\\n #We get the vectors magnitude\\n magnitude = np.linalg.norm(np.array(list(weights)))\\n for word in doc_vector.keys():\\n #For every word entry in the vector \\n #normalize by dividing the weight by the magnitude\\n doc_vector[word] = doc_vector[word] / magnitude\\n\\n #This section replaces the word count in the tuple of the dictionary with the Normalized Log TF\\n #It also sorts the postings list by doc ID\\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n new_postings_list = list()\\n for docID_termF in postings_list:\\n docID_termF = ( docID_termF[0], lengths[docID_termF[0]][word] )\\n new_postings_list.append(docID_termF)\\n new_postings_list.sort()\\n dictionary[word] = new_postings_list\\n\\n ''' \\n with open('ugly_dictionary.txt', 'w') as fp:\\n json.dump(dictionary, fp)\\n '''\\n #Determine the relevance of each doc by the court that it has in its court field\\n #Save the relevant docs and their relevance\\n relevant_courts_dict = { \\\"SG Court of Appeal\\\":2, \\\"SG Privy Council\\\":2, \\\"UK House of Lords\\\":2, \\\"UK Supreme Court\\\":2,\\n \\\"High Court of Australia\\\":2, \\\"CA Supreme Court\\\":2, \\\"SG High Court\\\":1.5, \\\"Singapore International Commercial Court\\\":1.5,\\n \\\"HK High Court\\\": 1.5, \\\"HK Court of First Instance\\\": 1.5, \\\"UK Crown Court\\\": 1.5, \\\"UK Court of Appeal\\\": 1.5, \\\"UK High Court\\\": 1.5, \\n \\\"Federal Court of Australia\\\": 1.5, \\\"NSW Court of Appeal\\\": 1.5, \\\"NSW Court of Criminal Appeal\\\": 1.5, \\\"NSW Supreme Court\\\": 1.5}\\n\\n relevant_docs = dict()\\n \\n for court_name in relevant_courts_dict:\\n court_postings_list = court_dictionary.get(court_name, -1)\\n if(court_postings_list != -1):\\n for docid in court_postings_list:\\n #save a dictionary of docID and its relevance (2 or 1.5) according to its court\\n relevant_docs[docid] = relevant_courts_dict[court_name]\\n\\n #This section traverse each word (key) in the dictionary, get its postings list and save it in a different file \\n postings_list_file = open(out_postings, \\\"wb\\\") \\n for word in dictionary:\\n #Get postings list for the word\\n postings_list = dictionary[word]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n dictionary[word] = (document_frequency, postings_list_position)\\n for date in date_dictionary:\\n #Get postings list for the date\\n postings_list = date_dictionary[date]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n date_dictionary[date] = (document_frequency, postings_list_position)\\n for court in court_dictionary:\\n #Get postings list for the date\\n postings_list = court_dictionary[court]\\n #Get the document frequency\\n document_frequency = len(postings_list)\\n #Know the starting position for the pointer\\n postings_list_position = postings_list_file.tell()\\n # Writing to file \\n pickle.dump(postings_list, postings_list_file)\\n #Replace postings list with reference to the position\\n court_dictionary[court] = (document_frequency, postings_list_position)\\n #Close the postings lists file\\n postings_list_file.close() \\n\\n #Now open the dictionary file and save the three dictionaries\\n with open(out_dict, 'wb') as dictionary_file:\\n pickle.dump(total_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(date_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(court_dictionary, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n pickle.dump(relevant_docs, dictionary_file, protocol=pickle.HIGHEST_PROTOCOL)\\n \\n '''\\n The structure we have is:\\n\\n dictionary.txt: Has three dictionaries\\n {word.zone : [doc_freq, pointer], word.zone: [doc_freq, pointer], ...}\\n {date : [doc_freq, pointer], date: [doc_freq, pointer], ...}\\n {court : [doc_freq, pointer], court: [doc_freq, pointer], ...}\\n\\n postings.txt: Has the postings for the three dictionaries\\n For the dictionary postings:\\n [[docID,termFrequency],[docID,termFrequency]]\\n [[docID,termFrequency]] ...\\n For the date_dictionary postings:\\n [docId, docId, docId, docId]\\n For the court_dictionary postings:\\n [docId, docId, docId, docId]\\n ...\\n\\n Both documents together would be:\\n { word.zone: [doc_freq, [[docID,termFrequency], ... ]], \\n word.zone: [doc_freq, [[docID,termFrequency].}, ...]] }\\n { date: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\\n { court: [doc_freq, [docID, docID, ... ]], date: [doc_freq, [docID, docID, ... ]] }\\n\\n lengths.txt\\n [document: [word: weight, word: weight, ...], document: [word: weight, word: weight, ...]]\\n Decided to make it like this to keep control of which weights correspond to which words\\n Although for a document I will traverse all the weights to get the score\\n If the word is not in the document vector [which in my case is a dictionary], then its weight is 0\\n This way I am no using a sparse matrix\\n\\n '''\",\n \"def load(cls, filepath) -> 'Word2VecEmbedding':\\n with open(filepath, 'rb') as f:\\n embedding = pickle.load(f)\\n embedding.word2idx = {spell: idx for idx, spell in enumerate(embedding.vocab.idx2word)}\\n return embedding\",\n \"def preprocess_output_vocab(output_file, weights_file):\\n labels = ['[PAD]', '[UNK]']\\n with open('data/corpora/jawiki/edit_freq.json') as f:\\n jawiki_edit_freq = json.load(f)\\n with open('data/corpora/lang8/edit_freq.json') as f:\\n lang8_edit_freq = json.load(f)\\n edit_freq = Counter(jawiki_edit_freq)\\n edit_freq.update(lang8_edit_freq)\\n ordered = sorted(edit_freq.items(), key=lambda x: x[1], reverse=True)\\n labels += [edit for edit, freq in ordered if freq >= 500]\\n n_samples = sum(edit_freq[edit] for edit in labels)\\n dist = [freq / n_samples for edit, freq in ordered]\\n print(ordered[:100])\\n print(dist[:100])\\n n_classes = len(labels)\\n class_weights = [1.] * n_classes\\n labels_class_weights = get_class_weights(labels, edit_freq)\\n n_correct = edit_freq['$KEEP']\\n detect_class_weights = get_class_weights(\\n ['CORRECT', 'INCORRECT'],\\n {'CORRECT': n_correct, 'INCORRECT': n_samples-n_correct}\\n )\\n detect_class_weights = [1.] + detect_class_weights\\n with open(weights_file, 'w', encoding='utf-8') as f:\\n json.dump([labels_class_weights, detect_class_weights], f)\\n with open(output_file, 'w', encoding='utf-8') as f:\\n f.writelines(f'{label}\\\\n' for label in labels)\\n print(f'{n_classes} edits output to {output_file}.')\\n print(f'Class weights output to {weights_file}.')\",\n \"def build_dictionary_gensim():\\r\\n\\t# if load_dictionary_gensim():\\r\\n\\t#\\treturn\\r\\n\\t\\r\\n\\tglobal gensim_dictionary, common_corpus_list\\r\\n\\t\\r\\n\\tprint('\\\\nbuilding dictionary')\\r\\n\\tgensim_dictionary = gensim.corpora.Dictionary()\\r\\n\\t\\r\\n\\tfor v in common_corpus_list:\\r\\n\\t\\tgensim_dictionary.add_documents([v[1].lower().split()])\\r\\n\\t\\t\\r\\n\\tgensim_dictionary.save_as_text(paths.path_data_dictionary_txt)\\r\\n\\tgensim_dictionary.save(paths.path_data_dictionary_dict)\\r\\n\\r\\n\\t# print(gensim_dictionary.token2id)\\r\\n\\tprint(gensim_dictionary)\",\n \"def get_pretrained_weights(idx_word):\\n n = len(idx_word)\\n embed_dim = 25\\n weights = mx.ndarray.zeros((n, embed_dim))\\n print('Start downloading pre-trained vectors, this will take some time')\\n glov = api.load(\\\"glove-twitter-25\\\")\\n print('Pre-trained vectors downloading complete')\\n not_in_vocab = 0\\n for i in range(n):\\n word = idx_word[i]\\n try:\\n weights[i] = glov[word]\\n except: #if not in glove vocabulary\\n not_in_vocab += 1\\n weights[i] = mx.nd.random.normal(0, 0.1, embed_dim)\\n if not_in_vocab > 0:\\n print('Warning: {} words not in vocab of pretrained embeddings (glove-twitter-25)'.format(not_in_vocab))\\n return weights\",\n \"def make_embeddings(self):\\n\\t\\tprint(\\\"Presetting embedding weights\\\")\\n\\t\\t\\t\\n\\t\\tnp.random.seed(0)\\n\\t\\tweights = np.random.uniform(low = -0.05, high = 0.05, size = (self.FREQCAP, self.EMB_SIZE))\\n\\t\\t\\n\\t\\tcounter = 0\\n\\n\\t\\twords = []\\n\\t\\tweights_tmp = []\\n\\n\\t\\twith open(self.embeddingpath) as handle:\\n\\t\\t\\tfor i, line in enumerate(handle):\\n\\t\\t\\t\\ttmp = line.strip()\\n\\t\\t\\t\\tif len(tmp) > 0:\\n\\t\\t\\t\\t\\tsplit = tmp.split(\\\" \\\")\\n\\t\\t\\t\\t\\tif split[0] in self.worddict and len(split[1:]) == 300:\\n\\t\\t\\t\\t\\t\\twords.append(split[0])\\n\\t\\t\\t\\t\\t\\tweights_tmp.append([float(a) for a in split[1:]])\\n\\t\\t\\n\\t\\tweights_tmp = np.array(weights_tmp)\\n\\n\\t\\tfor word, column in zip(words, weights_tmp):\\n\\t\\t\\tif self.worddict[word] < self.FREQCAP:\\n\\t\\t\\t\\tcounter += 1\\n\\t\\t\\t\\tweights[self.worddict[word],:] = column\\n\\t\\t\\n\\t\\tprint(\\\"Set\\\", counter, \\\"of\\\", weights.shape[0], \\\"columns\\\")\\n\\t\\t\\n\\t\\tif self.EMB_SIZE < weights.shape[-1]:\\n\\t\\t\\tprint(\\\"Reducing dimensionality to\\\", self.EMB_SIZE)\\n\\t\\t\\tpca = PCA(self.EMB_SIZE)\\n\\t\\t\\tweights = pca.fit_transform(weights)\\n\\t\\t\\n\\t\\tself.embeddings = [weights]\",\n \"def load_indices(mode='char', words=None, counts=None):\\n if os.path.exists(mode+'indices.p'):\\n indices = pickle.load(open(mode+'indices.p', 'rb'), encoding='latin1')\\n else:\\n indices = {}\\n i = 0\\n for word in counts.keys():\\n indices[word] = int(i)\\n indices[i] = str(word)\\n i += 1\\n print(\\\"i is: \\\" + str(i))\\n print(\\\"len is: \\\" + str(len(indices.keys())))\\n pickle.dump(indices, open(mode+'indices.p', 'wb'))\\n return indices\",\n \"def get_WS(w2v):\\n # get set of MAX_NGRAM-grams in text\\n lines = open(INFNAME_FORMAT.format(\\\"train\\\")).readlines() \\\\\\n + open(INFNAME_FORMAT.format(\\\"test\\\")).readlines()\\n raw = [process_line(l) for l in lines ]\\n ngrams_in_data = set()\\n for words in raw:\\n for ngram in tweet_to_ngrams(words):\\n ngrams_in_data.add(ngram)\\n\\n # load sentiment features from model\\n clf_pipe = pickle.load(open(CLF_FNAME, 'rb')) # model\\n\\n vect = clf_pipe.best_estimator_.named_steps['vect']\\n clf = clf_pipe.best_estimator_.named_steps['clf']\\n\\n features_to_sent_idx = vect.vocabulary_ # map from model features to sentiment index\\n # currently, sentiment = 2 * (count_pos / (count_pos + count_neg)) - 1\\n sentiments = clf.feature_count_[1,:] / np.sum(clf.feature_count_, axis=0) # in [0,1]\\n sentiments = 2 * sentiments - 1 # rescale to [-1,1]\\n\\n features_to_sent = {feat: sentiments[idx] for (feat,idx) in features_to_sent_idx.items()}\\n\\n # build WS and ngram_idx_map for each MAX_NGRAM-gram in the text\\n k = len(next(iter(w2v.values()))) # dimension of embedding\\n WS = np.zeros(shape=(len(ngrams_in_data) + 1, k + MAX_NGRAM), dtype='float32')\\n ngram_idx_map = {}\\n\\n index = 1 # first row is left 0, for padding in the cnn. This is also neutral sentiment.\\n # For Vader Sentiment analysis\\n# vader_analyzer = SentimentIntensityAnalyzer()\\n\\n\\n for ngram in ngrams_in_data:\\n ngram_idx_map[ngram] = index\\n\\n # set word embedding, note that unknown words already randomized in load_embedding \\n words = ngram.split(' ')\\n WS[index,:k] = w2v[words[-1]] # embedding of last word\\n\\n # set sentiment embedding\\n for n in range(MAX_NGRAM): # for 1, 2, ... length ngrams\\n sub_ngram = ' '.join(words[-1 - n:]) \\n\\n # Naive Bayes Sentiment feature --------------------------------\\n sent = features_to_sent.get(sub_ngram, 0.0) # default to neutral 0\\n # --------------------------------------------------------------\\n\\n# # TextBlob sentiment feature -----------------------------------\\n# sent = TextBlob(sub_ngram).sentiment.polarity\\n# # --------------------------------------------------------------\\n\\n# # Vader sentiment feature -------------------------------------\\n# sent = vader_analyzer.polarity_scores(sub_ngram)['compound']\\n# # -------------------------------------------------------------\\n WS[index,k+n] = sent\\n\\n index += 1\\n\\n return WS, ngram_idx_map\",\n \"def create_index(self, vocabulary=[]) -> dict:\\n try:\\n out = {}\\n for word in vocabulary:\\n if word in out:\\n out[word] += 1\\n else: \\n out[word] = 1\\n return(out)\\n except Exception as error:\\n print(f\\\"Error: self.create_index([...]) -> {error}\\\")\",\n \"def gen_data(self):\\n\\n # 1，read the source text\\n inputs, labels = self.read_data()\\n print(\\\"read finished\\\")\\n\\n # 2. word label index\\n word_to_index, label_to_index = self.gen_word_label_index()\\n # print(\\\"word_to_index\\\",word_to_index)\\n # print(\\\"label_to_index\\\",label_to_index)\\n print(\\\"vocab process finished\\\")\\n #\\n # 3，input to index\\n inputs_idx = self.trans_to_index(inputs, word_to_index)\\n # print((inputs_idx))\\n print(\\\"index transform finished\\\")\\n #\\n # 4, padding\\n inputs_idx = self.padding(inputs_idx, self._sequence_length)\\n # print(inputs_idx)\\n print(\\\"padding finished\\\")\\n\\n # 6，label to index\\n labels_idx = self.trans_label_to_index(labels, label_to_index)\\n print(\\\"label index transform finished\\\")\\n\\n return np.array(inputs_idx), np.array(labels_idx)\",\n \"def load_vocab(vocab):\\r\\n\\tvocab = [line.split()[0] for line in open(\\r\\n\\t\\t'{}{}'.format(pm.vocab_path, vocab), 'r', encoding='utf-8').read().splitlines()\\r\\n\\t\\t\\t if int(line.split()[1]) >= pm.word_limit_size]\\r\\n\\tword2idx_dic = {word: idx for idx, word in enumerate(vocab)}\\r\\n\\tidx2word_dic = {idx: word for idx, word in enumerate(vocab)}\\r\\n\\treturn word2idx_dic, idx2word_dic\",\n \"def create_word_map(tokenized_descriptions_file_path, word_dictionary_output_path):\\n if os.path.exists(word_dictionary_output_path):\\n print(\\\"Word map already exists in workspace. Will be reused.\\\")\\n return\\n\\n print(\\\"Word map not found. Generating....\\\")\\n\\n words_list = []\\n words_to_id = {}\\n\\n with open(tokenized_descriptions_file_path, 'r') as file:\\n for line in file:\\n tokens = line.strip().split(\\\",\\\")\\n words_list.extend(tokens[1:])\\n\\n # remove duplicate words\\n words_list = list(set(words_list))\\n\\n # sorting the words\\n words_list = sorted(words_list)\\n for i in range(len(words_list)):\\n words_to_id[words_list[i]] = i\\n\\n with open(word_dictionary_output_path, 'w') as f:\\n [f.write('{0},{1}'.format(key, value) + \\\"\\\\n\\\") for key, value in words_to_id.items()]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7383777","0.71597224","0.6914332","0.6700071","0.66937166","0.6675268","0.6658766","0.6642013","0.65650064","0.6545669","0.6526046","0.6516871","0.65157616","0.6507262","0.6481229","0.6472119","0.6454776","0.6420657","0.6418853","0.64167535","0.64134","0.6407153","0.6365498","0.63594645","0.6357065","0.63513625","0.63356984","0.63305944","0.6326211","0.6322316","0.63168997","0.631683","0.62915576","0.6284038","0.6279358","0.6272306","0.62689644","0.62539786","0.62417674","0.62319","0.62303036","0.6228213","0.6220042","0.62024975","0.6201604","0.61855847","0.6184492","0.6181709","0.6174559","0.6167686","0.61603004","0.614539","0.61424595","0.6141742","0.6131539","0.6125427","0.6108838","0.6064742","0.6059301","0.60531694","0.6052623","0.60513663","0.60481197","0.6032254","0.60231686","0.602126","0.60204726","0.6010175","0.6007954","0.59906006","0.59806526","0.59778905","0.5977087","0.5972158","0.5959877","0.59573317","0.59458154","0.5941956","0.5939058","0.5931497","0.5926465","0.5926253","0.5920657","0.59165263","0.5912781","0.59102225","0.5910155","0.5908963","0.59078556","0.5906737","0.5896136","0.5895342","0.58928096","0.58810663","0.5879434","0.5863834","0.5859566","0.58505845","0.584993","0.5841963"],"string":"[\n \"0.7383777\",\n \"0.71597224\",\n \"0.6914332\",\n \"0.6700071\",\n \"0.66937166\",\n \"0.6675268\",\n \"0.6658766\",\n \"0.6642013\",\n \"0.65650064\",\n \"0.6545669\",\n \"0.6526046\",\n \"0.6516871\",\n \"0.65157616\",\n \"0.6507262\",\n \"0.6481229\",\n \"0.6472119\",\n \"0.6454776\",\n \"0.6420657\",\n \"0.6418853\",\n \"0.64167535\",\n \"0.64134\",\n \"0.6407153\",\n \"0.6365498\",\n \"0.63594645\",\n \"0.6357065\",\n \"0.63513625\",\n \"0.63356984\",\n \"0.63305944\",\n \"0.6326211\",\n \"0.6322316\",\n \"0.63168997\",\n \"0.631683\",\n \"0.62915576\",\n \"0.6284038\",\n \"0.6279358\",\n \"0.6272306\",\n \"0.62689644\",\n \"0.62539786\",\n \"0.62417674\",\n \"0.62319\",\n \"0.62303036\",\n \"0.6228213\",\n \"0.6220042\",\n \"0.62024975\",\n \"0.6201604\",\n \"0.61855847\",\n \"0.6184492\",\n \"0.6181709\",\n \"0.6174559\",\n \"0.6167686\",\n \"0.61603004\",\n \"0.614539\",\n \"0.61424595\",\n \"0.6141742\",\n \"0.6131539\",\n \"0.6125427\",\n \"0.6108838\",\n \"0.6064742\",\n \"0.6059301\",\n \"0.60531694\",\n \"0.6052623\",\n \"0.60513663\",\n \"0.60481197\",\n \"0.6032254\",\n \"0.60231686\",\n \"0.602126\",\n \"0.60204726\",\n \"0.6010175\",\n \"0.6007954\",\n \"0.59906006\",\n \"0.59806526\",\n \"0.59778905\",\n \"0.5977087\",\n \"0.5972158\",\n \"0.5959877\",\n \"0.59573317\",\n \"0.59458154\",\n \"0.5941956\",\n \"0.5939058\",\n \"0.5931497\",\n \"0.5926465\",\n \"0.5926253\",\n \"0.5920657\",\n \"0.59165263\",\n \"0.5912781\",\n \"0.59102225\",\n \"0.5910155\",\n \"0.5908963\",\n \"0.59078556\",\n \"0.5906737\",\n \"0.5896136\",\n \"0.5895342\",\n \"0.58928096\",\n \"0.58810663\",\n \"0.5879434\",\n \"0.5863834\",\n \"0.5859566\",\n \"0.58505845\",\n \"0.584993\",\n \"0.5841963\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7407205"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84894,"cells":{"query":{"kind":"string","value":"Creates embedding matrix from input file and writes to binary file Considering numpy rowmajor order stores word vector rowwise."},"document":{"kind":"string","value":"def construct_embedding(self):\n i = 0\n self.load_dicts()\n embedding_shape = (max(self.word2idx.values()) + 1,\n self.embedding_size)\n self.embedding = np.zeros(embedding_shape)\n\n with open(self.config.word_vec_fi_glove, 'r') as fi:\n for line in fi:\n word_vec = line.split(\" \")[1:]\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\n i += 1\n\n self.write_embedding()"},"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 create_embedding_matrix(filepath, word_index, embedding_dim):\n vocab_size = len(word_index) + 1 # Adding again 1 because of reserved 0 index\n embedding_matrix = np.zeros((vocab_size, embedding_dim))\n\n with open(filepath) as f:\n for line in f:\n word, *vector = line.split()\n if word in word_index:\n idx = word_index[word] \n embedding_matrix[idx] = np.array(\n vector, dtype=np.float32)[:embedding_dim]\n\n return embedding_matrix","def w2v_embedding(input_file, bin_file, output_file):\n print(\"Loading the training corpus.\")\n df = open(src_file_path, \"r\") # Open the text file stored at src_file_path\n df = df.read() # Read the text file\n tokens1 = word_tokenize(df) # Tokenize\n token_list = []\n print(\"Writing the bin file.\")\n models = KeyedVectors.load_word2vec_format(bin_destination_file_path, binary=True) # Save bin format\n print(\"Saving the word embeddings.\")\n models.save_word2vec_format(txt_file_destination_path, binary=False) # Save the word vectors\n \n return txt_file_destination_path","def getWordEmbeddingsMatrix(script_directory, embedding_file):\n translator = str.maketrans('', '', string.punctuation)\n all_words = []\n print(\"Loading vocab from text files in:\")\n for d in os.listdir(script_directory):\n print(d)\n for fname in os.listdir(\"%s/%s\" % (script_directory, d)):\n with open(\"%s/%s/%s\" % (script_directory, d, fname), 'r') as f:\n words = [w.translate(translator) for w in f.read().split() if w.translate(translator) != \"\"]\n all_words.extend(words)\n\n model = KeyedVectors.load_word2vec_format(embedding_file, binary=True)\n vocab = {\"PAD\" : 0, \"EOS\" : 1}\n vocab.update({w : i + 2 for i,w in enumerate([w1 for w1 in set(all_words) if w1 in model]) })\n inv_dict = vocab.keys()\n ## Take a minute to load...\n\n vocab_size = len(inv_dict)\n emb_size = 300 # or whatever the size of your embeddings\n embeddings = np.zeros((vocab_size + 1, emb_size))\n for k,v in vocab.items():\n embeddings[v] = model[k]\n vocab[\"UNK\"] = len(vocab.keys())\n embeddings[vocab[\"UNK\"]] = np.ones(emb_size)\n del model\n ## Now we have a numpy matrix of embeddings...\n # x_model = tf.placeholder(tf.int32, shape=[None, input_size])\n # with tf.device(\"/cpu:0\"):\n # embedded_x = tf.nn.embedding_lookup(embeddings, x_model)\n return embeddings, vocab","def make_embedding(path, words, indices):\n #root = '/'.join(path.split('/')[0:-1])\n #all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\n #for path in all_paths:\n vec_path = 'data/'+path.split('/')[-1]+'_'+mode\n print(vec_path)\n if os.path.exists(vec_path+'.npy'):\n np_vecs = np.load(vec_path+'.npy')\n else:\n words_len = len(words)\n vecs = []\n if mode == 'word':\n f = load_model('wiki.en.bin')\n for i, w in enumerate(words):\n if mode == 'word':\n vec = f.get_word_vector(w)\n else:\n vec = eye[indices[w]]\n vecs.append(vec) \n if i % 10000 == 0:\n print(\"{} / {}\".format(i, words_len))\n np_vecs = np.asarray(vecs, dtype=np.int8)\n np.save(vec_path, np_vecs)\n return np_vecs","def embedding_matrix(path_to_embedding : str,embedding_dim: int, word_index : dict) -> np.array:\n embeddings_index = {}\n f = open(path_to_embedding, encoding='utf-8')\n for line in f:\n try:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n except:\n pass\n \n f.close()\n\n embedding_matrix = np.zeros((len(word_index) + 1,embedding_dim))\n found = 0\n for word, i in word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n # words not found in embedding index will be all-zeros.\n found +=1\n embedding_matrix[i] = embedding_vector\n\n return embedding_matrix","def load_embedding_matrix(filepath, word2vec_format = False):\n if word2vec_format:\n return gensim.models.KeyedVectors.load_word2vec_format(filepath, binary=True)\n else: #own pretrained model\n return gensim.models.Word2Vec.load(filepath)","def save_embeddings(self, filename, binary=True):\n with open(filename, \"wb\", encoding=\"utf8\") as fout:\n fout.write(\"%s %s\\n\" % self._vecs.shape)\n # store in sorted order: most frequent words at the top\n for i, word in enumerate(self._words):\n row = self._vecs[i]\n if binary:\n fout.write(word + b\" \" + row.tostring())\n else:\n fout.write(\n \"%s %s\\n\" % (word, \" \".join(\"%f\" % val for val in row))\n )","def load_embeddings(filename):\n labels = []\n rows = []\n with open(filename, encoding='utf-8') as infile:\n for i, line in enumerate(infile):\n items = line.rstrip().split(' ')\n if len(items) == 2:\n # This is a header row giving the shape of the matrix\n continue\n labels.append(items[0])\n values = np.array([float(x) for x in items[1:]], 'f')\n rows.append(values)\n\n arr = np.vstack(rows)\n return pd.DataFrame(arr, index=labels, dtype='f')","def load_embeddings(filename):\n count = 0\n matrix = []\n word_map = {}\n with open(filename, encoding=\"utf8\") as f:\n # with open(filename) as f:\n for line in f:\n line = line.strip()\n items = line.split()\n word = items[0]\n rest = items[1:]\n # print(\"word:\", word)\n word_map[word] = count\n count += 1\n\n rest = list(map(float, rest))\n matrix.append(rest)\n matrix = np.array(matrix)\n return word_map, matrix","def gen_embedding(path):\r\n word_emb = {}\r\n with open(path, encoding='utf-8') as f:\r\n for line in tqdm(f):\r\n values = line.split()\r\n word_emb[values[0]] = np.asarray(values[1:], dtype='float32')\r\n return word_emb","def prepare_embedding_matrix(emb_data_path, emb_size, vocab, random_seed=1984):\n vocab_size = len(vocab)\n mime = mimetypes.guess_type(emb_data_path)\n np.random.seed(random_seed)\n # in case the file type is text - we'll treat it as such\n if mime[0] is not None:\n vectors = {}\n with open(emb_data_path, 'rb') as f:\n for l in f:\n line = l.decode().split()\n word = line[0]\n if word in vocab:\n vect = np.array(line[1:]).astype(np.float)\n vectors[word] = vect\n embeddings = np.zeros((vocab_size, emb_size))\n words_found = 0\n for i, word in enumerate(vocab):\n try:\n embeddings[i] = vectors[word]\n words_found += 1\n except KeyError:\n embeddings[i] = np.random.normal(scale=0.6, size=(emb_size,))\n # in case the file type is not text - we'll assume it is a Gensim model, and we'll treat it as such\n else:\n emb_model = gensim.models.Word2Vec.load(emb_data_path)\n embeddings = np.zeros((vocab_size, emb_size))\n words_found = 0\n for i, word in enumerate(vocab):\n try:\n embeddings[i] = emb_model.wv[word]\n words_found += 1\n except KeyError:\n embeddings[i] = np.random.normal(scale=0.6, size=(emb_size,))\n # in both options (text file of a Gensim model, we do the next 2 steps\n return embeddings","def load_word2vect(self, file_path):\n self.embeddings = []\n self.word_to_idx = {'<pad>' : 0}\n self.vocab = ['<pad>']\n\n model = w2v.load(file_path)\n self.embedding_size = model.vectors.shape[1]\n pad_embedding = np.zeros(self.embedding_size, \"float32\")\n self.embeddings.append(pad_embedding)\n\n train_words_set = set([word for text in self.train_data for word in\n text[1].split(\" \")])\n\n for w in model.vocab:\n if w in train_words_set:\n self.word_to_idx[w] = len(self.vocab)\n self.vocab.append(w)\n self.embeddings.append(model[w])\n\n del model","def load_word_vectors(filepath, word_index, vector_size):\n embedding_matrix = np.zeros((len(word_index) + 1, vector_size))\n\n fin = io.open(filepath, \"r\", encoding=\"utf-8\", newline=\"\\n\", errors=\"ignore\")\n n, d = map(int, fin.readline().split())\n\n for line in fin:\n tokens = line.rstrip().split(\" \")\n if tokens[0] in word_index:\n w = word_index[tokens[0]]\n embedding_matrix[w] = np.fromiter(map(float, tokens[1:]), \"float\")\n\n return embedding_matrix","def senna(vector_f='embeddings.txt', words_f ='words.lst', out_f='senna.pkl'):\n with open(DATA_DIR + words_f, 'rb') as f:\n words = [line.strip() for line in f]\n M = np.loadtxt(DATA_DIR + vector_f)\n print \"Found {0} words\".format(len(words))\n print \"Found {0}x{1} embedding matrix\".format(*M.shape)\n with open(DATA_DIR + out_f, 'wb') as f:\n cPickle.dump((words, M), f)","def load_emb_matrix(path):\n embedding_matrix = np.load(path + '/emb_matrix.npy')\n print('Embedding matrix load from local sys successful\\n')\n print('Denormalized Shape: ({},{})'.format(np.shape(embedding_matrix)[0], np.shape(embedding_matrix)[1]))\n return embedding_matrix","def make_embeddings(self):\n\t\tprint(\"Presetting embedding weights\")\n\t\t\t\n\t\tnp.random.seed(0)\n\t\tweights = np.random.uniform(low = -0.05, high = 0.05, size = (self.FREQCAP, self.EMB_SIZE))\n\t\t\n\t\tcounter = 0\n\n\t\twords = []\n\t\tweights_tmp = []\n\n\t\twith open(self.embeddingpath) as handle:\n\t\t\tfor i, line in enumerate(handle):\n\t\t\t\ttmp = line.strip()\n\t\t\t\tif len(tmp) > 0:\n\t\t\t\t\tsplit = tmp.split(\" \")\n\t\t\t\t\tif split[0] in self.worddict and len(split[1:]) == 300:\n\t\t\t\t\t\twords.append(split[0])\n\t\t\t\t\t\tweights_tmp.append([float(a) for a in split[1:]])\n\t\t\n\t\tweights_tmp = np.array(weights_tmp)\n\n\t\tfor word, column in zip(words, weights_tmp):\n\t\t\tif self.worddict[word] < self.FREQCAP:\n\t\t\t\tcounter += 1\n\t\t\t\tweights[self.worddict[word],:] = column\n\t\t\n\t\tprint(\"Set\", counter, \"of\", weights.shape[0], \"columns\")\n\t\t\n\t\tif self.EMB_SIZE < weights.shape[-1]:\n\t\t\tprint(\"Reducing dimensionality to\", self.EMB_SIZE)\n\t\t\tpca = PCA(self.EMB_SIZE)\n\t\t\tweights = pca.fit_transform(weights)\n\t\t\n\t\tself.embeddings = [weights]","def load_embeddings(emb_file, oovs=[], pads=[], sep=' ', lower=False, case_dim=True):\n word2emb = {}\n word2idx = {}\n\n # read and store all word vectors\n for line in open(emb_file, errors = 'ignore', encoding = 'utf-8'):\n try:\n fields = line.strip().split(sep)\n word = fields[0]\n vec = np.asarray(fields[1:], dtype='float32')\n if case_dim:\n is_upper = float(word[0].isupper())\n vec = np.insert(vec, 0, is_upper, axis=0)\n if lower:\n word = word.lower()\n word2emb[word] = vec\n if word not in word2idx:\n word2idx[word] = len(word2idx)\n except Exception as e:\n print('[WARNING] Exception in `load_embeddings`:', e)\n\n # get dimensions from the last vector added\n emb_dim = word2emb[word].shape[0]\n\n # add custom embeddings for special characters\n mu = 0\n sigma = 0.01\n\n for word in pads:\n if word not in word2idx:\n if case_dim:\n vec = npr.normal(mu, sigma, emb_dim-1)\n vec = np.insert(vec, 0, 0., axis=0)\n else:\n vec = npr.normal(mu, sigma, emb_dim)\n word2emb[word] = vec\n word2idx[word] = len(word2idx)\n else:\n print('[WARNING] Padding item ' + word + ' has an embedding vector')\n\n for word in oovs:\n if word not in word2idx:\n if case_dim:\n vec = npr.normal(mu, sigma, emb_dim-1)\n is_upper = float(word[0].isupper())\n vec = np.insert(vec, 0, is_upper, axis=0)\n else:\n vec = npr.normal(mu, sigma, emb_dim)\n word2emb[word] = vec\n word2idx[word] = len(word2idx)\n else:\n print('[WARNING] OOV alias ' + word + ' has an embedding vector')\n\n # create an embedding matrix\n vocab_size = len(word2emb)\n emb_matrix = np.zeros((vocab_size, emb_dim))\n for word, idx in word2idx.items():\n if word in word2emb:\n vec = word2emb[word]\n if vec is not None and vec.shape[0] == emb_dim:\n emb_matrix[idx] = np.asarray(vec)\n\n # print feedback data and return mappings\n print('[INFO] Embedding vocabulary:', emb_matrix.shape[0], '(lowercase: ' + str(lower) + ')')\n print('[INFO] OOV aliases:', oovs)\n print('[INFO] Padding items:', pads)\n print('[INFO] Embedding dimensions:', emb_dim, '(extra case dimension: ' + str(case_dim) + ')')\n return word2idx, np.asarray(emb_matrix), emb_dim","def load_bin_vec(filename):\n w2v = {}\n with open(filename, 'r') as f:\n header = f.readline()\n vocab_size, emb_size = map(int, header.split())\n for line in f:\n cline = line.split()\n w2v[cline[0]] = np.array(cline[1:], dtype=np.float64)\n return w2v, emb_size, vocab_size","def gen_embeddings(vocab, file, emb_size, emb_dim):\n # embeddings = np.random.randn(vocab.n_words, emb_size) * 0.01\n embeddings = np.zeros((vocab.n_words, emb_size))\n print('Embeddings: %d x %d' % (vocab.n_words, emb_size))\n if file is not None:\n print('Loading embedding file: %s' % file)\n pre_trained = 0\n for line in open(file).readlines():\n sp = line.split()\n if(len(sp) == emb_dim + 1):\n if sp[0] in vocab.word2index:\n pre_trained += 1\n embeddings[vocab.word2index[sp[0]]] = [float(x) for x in sp[1:]]\n else:\n print(sp[0])\n print('Pre-trained: %d (%.2f%%)' % (pre_trained, pre_trained * 100.0 / vocab.n_words))\n return embeddings","def write_embeddings_to_file(self):\n modes = [self.generator, self.discriminator]\n for i in range(2):\n embedding_matrix = modes[i].embedding_matrix\n embedding_matrix = embedding_matrix.detach().to('cpu').numpy()\n index = np.array(range(self.n_node)).reshape(-1, 1)\n embedding_matrix = np.hstack([index, embedding_matrix])\n embedding_list = embedding_matrix.tolist()\n embedding_str = [str(int(emb[0])) + \"\\t\" + \"\\t\".join([str(x) for x in emb[1:]]) + \"\\n\" \n for emb in embedding_list]\n with open(config.emb_filenames[i], \"w+\") as f:\n lines = [str(self.n_node) + \"\\t\" + str(config.n_emb) + \"\\n\"] + embedding_str\n f.writelines(lines)","def training_examples_to_vec(test_file, embeddings_file, num_words, word_dim):\n x = []\n ignore_words = stopwords.words('english')\n lemmatizer = WordNetLemmatizer()\n stemmer = SnowballStemmer('english')\n word_idx, word_vectors = hf.create_indices_for_vectors(embeddings_file, return_vectors=True)\n with open(test_file, 'r') as f:\n for line in f:\n stemmedWords = set([])\n long_string = line.split(' ')\n total_words = int(len(long_string) / 2)\n total_example_vec = np.empty([num_words, word_dim], dtype=np.float32)\n if total_words - 1 <= num_words:\n continue\n count = 0\n\n for i in range(1, total_words):\n word = long_string[2 * i].split(\"'\")[0]\n\n if (word in ignore_words) or (len(word) <= 3):\n continue\n\n if not word.isalpha():\n continue\n\n try:\n stem = stemmer.stem(word)\n lemma = lemmatizer.lemmatize(word)\n except UnicodeDecodeError:\n continue\n\n if stem in stemmedWords:\n continue\n\n try:\n idx_num = word_idx[word]\n except KeyError:\n\n try:\n idx_num = word_idx[lemma]\n except KeyError:\n\n try:\n idx_num = word_idx[stem]\n except KeyError:\n continue\n\n word_vec = word_vectors[idx_num]\n total_example_vec[count] = word_vec\n stemmedWords.add(stem)\n count += 1\n if count >= num_words:\n break\n x.append(total_example_vec)\n return x","def make_embedding_matrix(docs, size, min_count = 5, window = 5, n_iter = 5, savename = None, workers = 3):\n\n print('Starting the embedding generation')\n t0 = time.time()\n model = gensim.models.Word2Vec(docs, min_count=min_count, window = window,\n size = size, iter = n_iter, workers = workers)\n t1 = time.time()\n print('All done, total time %s' % (t1-t0))\n \n if savename is not None:\n model.save(savename)\n \n return model","def load_bin_vec(self, fname, vocab):\n word_vecs = {}\n with open(fname, \"rb\") as f:\n header = f.readline()\n print header\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch)\n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32')\n # logger.info(word_vecs[word])\n else:\n f.read(binary_len)\n # logger.info(\"num words already in word2vec: \" + str(len(word_vecs)))\n return word_vecs","def load_word2vec_matrix(vocab_size,\n embedding_size,\n word2vec_path):\n if not os.path.isfile(word2vec_path):\n raise IOError(\"✘ The word2vec file doesn't exist. \"\n \"Please use function <create_vocab_size(embedding_size)\"\n \"> to create it!\")\n\n model = word2vec.KeyedVectors.load_word2vec_format(word2vec_path,\n binary=True,\n limit=400000)\n\n vocab = dict([(k, v.index) for k, v in model.wv.vocab.items()])\n vector = np.zeros([vocab_size, embedding_size])\n for key, value in vocab.items():\n if key is not None:\n vector[value] = model[key]\n return vector","def load_bin_embeddings(path, params):\n model = load_fasttext_model(path)\n assert model.get_dimension() == params.emb_dim\n words = model.get_labels()\n logger.info(\"Loaded binary model from %s\" % path)\n\n # compute new vocabulary / embeddings\n embeddings = np.concatenate([model.get_word_vector(w)[None] for w in words], 0)\n embeddings = torch.from_numpy(embeddings).float()\n word2id = {w: i for i, w in enumerate(words)}\n logger.info(\"Generated embeddings for %i words.\" % len(words))\n\n assert embeddings.size() == (len(word2id), params.emb_dim)\n return word2id, embeddings","def load_bin_vec(fname, vocab):\n word_vecs = {}\n with open(fname, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word).lower()\n break\n if ch != '\\n':\n word.append(ch) \n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \n else:\n f.read(binary_len)\n return word_vecs","def load_bin_vec(fname, vocab):\n word_vecs = {}\n with open(fname, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch) \n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \n else:\n f.read(binary_len)\n return word_vecs","def convert_to_mindrecord(embed_size, data_path, proprocess_path, glove_path):\n\n num_shard = 4\n train_features, train_labels, test_features, test_labels, weight_np, _ = \\\n preprocess(data_path, glove_path, embed_size)\n np.savetxt(os.path.join(proprocess_path, 'weight.txt'), weight_np)\n\n print(\"train_features.shape:\", train_features.shape, \"train_labels.shape:\", train_labels.shape, \"weight_np.shape:\",\n weight_np.shape, \"type:\", train_labels.dtype)\n # write mindrecord\n schema_json = {\"id\": {\"type\": \"int32\"},\n \"label\": {\"type\": \"int32\"},\n \"feature\": {\"type\": \"int32\", \"shape\": [-1]}}\n\n writer = FileWriter(os.path.join(proprocess_path, 'aclImdb_train.mindrecord'), num_shard)\n data = get_imdb_data(train_labels, train_features)\n writer.add_schema(schema_json, \"nlp_schema\")\n writer.add_index([\"id\", \"label\"])\n writer.write_raw_data(data)\n writer.commit()\n\n writer = FileWriter(os.path.join(proprocess_path, 'aclImdb_test.mindrecord'), num_shard)\n data = get_imdb_data(test_labels, test_features)\n writer.add_schema(schema_json, \"nlp_schema\")\n writer.add_index([\"id\", \"label\"])\n writer.write_raw_data(data)\n writer.commit()","def load_glove_matrix(w2i, glove_file):\n f = open(glove_file, 'rb')\n vocab_size = len(w2i)\n embedding_dim = 0\n\n # Load all glove vectors, put them in a matrix\n for line in f:\n split_line = line.split()\n word = split_line[0]\n embedding = np.array([float(val) for val in split_line[1:]])\n if embedding_dim == 0:\n embedding_dim = len(embedding)\n embeddings_matrix = np.zeros((vocab_size, embedding_dim))\n\n # Use only words that are in the corpus\n if word in w2i:\n embeddings_matrix[w2i[word], :] = embedding\n\n # Replace zero vectors with random numbers\n for i, row in enumerate(embeddings_matrix):\n if not (False in [n == 0 for n in row]):\n vec = np.random.rand(1, embedding_dim)\n embeddings_matrix[i, :] = vec / np.linalg.norm(vec)\n return embeddings_matrix","def load_bin_vec(fname, vocab):\n word_vecs = {}\n with open(fname, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch) \n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \n else:\n f.read(binary_len)\n return word_vecs","def load_bin_vec(fname, vocab):\n word_vecs = {}\n with open(fname, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch) \n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \n else:\n f.read(binary_len)\n return word_vecs","def loadw2v(embfile, embsize, myzipfile=None, maxvoc=None):\n word_to_ix = {}\n word_to_ix[constants.PAD_ITEM] = 0\n word_to_ix[constants.UNK_ITEM] = 1\n # fill padding word with zeros\n model = [[0.]*embsize]\n # fill unk word with random numbers\n model.append(np.random.normal(0,0.15,size=embsize).tolist())\n if myzipfile != None:\n zip = zipfile.ZipFile(myzipfile, 'r')\n f = zip.read(embfile).split(\"\\n\")\n else:\n #f = open(embfile, 'r')\n f = codecs.open(embfile, \"r\", \"utf-8\")\n ix = 2\n for line in f:\n if maxvoc!=None:\n if ix >= maxvoc:\n break\n splitLine = line.split()\n if(len(splitLine)>embsize+1):\n phrase_lst = splitLine[:-embsize]\n word = ' '.join(phrase_lst)\n embedding = [float(val) for val in splitLine[-embsize:]]\n word_to_ix[word] = ix\n model.append(embedding)\n ix += 1\n elif(len(splitLine)>2):\n word = splitLine[0]\n embedding = [float(val) for val in splitLine[1:]]\n word_to_ix[word]=ix\n model.append(embedding)\n ix += 1\n else:\n print(line)\n print(\"%d words loaded!\" % len(model))\n return word_to_ix, model","def init_word_embeddings(session, model, embeddings_file):\n # Create word embedding array from word2vec file\n vocab_size = FLAGS.vocab_size\n embeddings = []\n with tf.gfile.Open(embeddings_file) as f:\n i = 0\n while i < vocab_size:\n numbers = f.readline().split()\n if len(numbers) > 0:\n embeddings.append([float(n) for n in numbers])\n i += 1\n else:\n break # Last line of embeddings file is empty\n\n # Eliminate the random word embeddings and introduce word2vec to the realm of variable scopes.\n # The victims will be:\n # \"embedding_attention_seq2seq/RNN/EmbeddingWrapper/embedding\"\n # \"embedding_attention_seq2seq/embedding_attention_decoder/embedding\"\n np_embeddings = np.array(embeddings)\n feed_dict = {model.word2vec_placeholder: np_embeddings}\n session.run(model.word2vec_assign_encoder_op, feed_dict=feed_dict)\n session.run(model.word2vec_assign_decoder_op, feed_dict=feed_dict)","def load_bin_vec(fname, vocab):\n word_vecs = {}\n with open(fname, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch) \n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \n else:\n f.read(binary_len)\n return word_vecs","def load_bin_vec(fname, vocab):\n word_vecs = {}\n with open(fname, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n # print(vocab_size)\n for line in range(vocab_size):\n # print(line)\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch)\n # print(word)\n if word in vocab:\n # print(word)\n word_vecs[word] = np.frombuffer(f.read(binary_len), dtype='float32')\n else:\n f.read(binary_len)\n\n return word_vecs","def load_embedding(self, glove_dir='glove.6B/'):\n\n f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'))\n for line in f:\n values = line.split()\n word = values[0]\n self.embeddings_index[word] = np.asarray(values[1:], dtype='float32')\n f.close()","def save_bin(words,data,fname):\n\n out=open(fname,\"wb\")\n\n rows,dims=data.shape\n out.write(\"{} {}\\n\".format(rows,dims).encode(\"utf-8\"))\n counter=0\n\n for i,w in enumerate(words):\n out.write(w.encode(\"utf-8\"))\n out.write(\" \".encode(\"utf-8\"))\n out.write(struct.pack(\"{}f\".format(dims),*data[i,:]))\n counter+=1\n \n out.close()\n print(\"Model saved to\",fname,file=sys.stderr)","def load_bin_vec(fname, vocab):\n word_vecs = {}\n with open(fname, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch)\n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \n else:\n f.read(binary_len)\n cPickle.dump(word_vecs, open(\"./data/word_vecs.pkl\", \"w\"))\n return word_vecs","def buildBTree(T, file):\r\n for line in file:\r\n word_line = line.split(' ')\r\n word = word_line[0]\r\n embedding = word_line[1:]\r\n embedding = [float(i) for i in embedding]\r\n if word[0].isalpha():\r\n word_emb_object = WordEmbedding.WordEmbedding(word, embedding)\r\n insertElement(T, word_emb_object)\r\n return T","def load_embeddings(filepath, vocabulary, retain):\n \n word2index = dict()\n word_vectors = list()\n\n def add_entry(word, vector):\n word2index[word] = len(word2index)\n word_vectors.append(vector)\n\n model = gensim.models.KeyedVectors.load(filepath)\n\n # adding special tokens <FIL>, <UNK> and <NUM>\n dim = model.vector_size\n add_entry('<fil>', np.zeros((dim,)))\n for special in ['<unk>', '<num>']:\n vector = np.random.uniform(-0.025, 0.025, (dim,))\n add_entry(special, vector)\n\n if retain:\n for word, _ in model.vocab.items():\n add_entry(word, model[word])\n else:\n for word in vocabulary:\n if word in model:\n add_entry(word, model[word])\n\n vocabulary = vocabulary.intersection(word2index.keys())\n return word2index, np.asarray(word_vectors)","def load_embeddings(embedding_path):\n print('loading word embeddings from %s' % embedding_path)\n weight_vectors = []\n word_idx = {}\n with codecs.open(embedding_path, encoding='utf-8') as f:\n for line in f:\n word, vec = line.split(u' ', 1)\n word_idx[word] = len(weight_vectors)\n weight_vectors.append(np.array(vec.split(), dtype=np.float32))\n # Annoying implementation detail; '(' and ')' are replaced by '-LRB-' and\n # '-RRB-' respectively in the parse-trees.\n word_idx[u'-LRB-'] = word_idx.pop(u'(')\n word_idx[u'-RRB-'] = word_idx.pop(u')')\n # Random embedding vector for unknown words.\n weight_vectors.append(np.random.uniform(\n -0.05, 0.05, weight_vectors[0].shape).astype(np.float32))\n return np.stack(weight_vectors), word_idx","def load_embedding_file(self):\n if self.language == 'en':\n embed_file_dir = self.embedding_path\n wv = KeyedVectors.load_word2vec_format(embed_file_dir, binary=True)\n self.pretrained_embedding = {}\n for word in wv.vocab.keys():\n normalized_word = normalization.process(self.language.upper(), word, letters_to_keep='', letters_to_remove='',\n lowercase=True, remove_repetitions_count=-1, remove_punct=True,\n remove_digits=True, remove_vowels=False, remove_diacritics=True,\n remove_spaces=False, remove_apostrophe=True, copy_through=False,\n keep_romanized_text=False)\n self.pretrained_embedding[normalized_word] = wv[word]\n self.embed_dim = 300\n\n else:\n embed_file_dir = self.embedding_path\n fin = open(embed_file_dir, 'r', encoding='utf-8', newline='\\n', errors='ignore')\n data = {}\n for line in fin:\n if len(line.split()) == 2: # header\n continue\n tokens = line.rstrip().split(' ')\n word = tokens[0]\n normalized_word = normalization.process(self.language.upper(), word, letters_to_keep='', letters_to_remove='',\n lowercase=True, remove_repetitions_count=-1, remove_punct=True,\n remove_digits=True, remove_vowels=False, remove_diacritics=True,\n remove_spaces=False, remove_apostrophe=True, copy_through=False,\n keep_romanized_text=False)\n data[normalized_word] = np.array(tokens[1:])\n self.pretrained_embedding = data\n self.embed_dim = 300","def dep_w2v(data_fname='deps.words', out_fname='depw2v.pkl'):\n M = np.loadtxt(DATA_DIR + data_fname, converters={0: lambda x: 0})\n M = M[:, 1:]\n print \"Loaded {0}x{1} word vector matrix\".format(*M.shape)\n with open(DATA_DIR + data_fname, 'rb') as f:\n words = [line.split()[0] for line in f]\n with open(DATA_DIR + out_fname, 'wb') as f:\n cPickle.dump((words, M), f)","def load_embeddings(path):\r\n\r\n embeds = dict() # dictionary mapping words to vectors\r\n for line in open(path, encoding='utf-8'):\r\n row = line.strip().split('\\t')\r\n embeds[row[0]] = np.array(row[1:], dtype=np.float32)\r\n\r\n embeddings_dim = embeds[list(embeds)[0]].shape[0]\r\n\r\n return embeds, embeddings_dim","def write_matrix_to_binary(file_name, val):\n with open(file_name, 'wb') as file:\n nrow = val.shape[0]\n ncol = val.shape[1]\n file.write(int32_to_bytes(nrow) + int32_to_bytes(ncol) + val.astype(float).tobytes(order='C'))","def load_data_and_embedding():\n\n # Load data\n df_data = pd.read_csv('../new_data/train_ids_and_labels_1400.txt',nrows=10000)\n y = df_data['class'] - 1 # class (0 ~ 18)\n X = df_data.drop(['class'], axis=1).values\n\n # Transform to binary class matrix\n y = to_categorical(y.values)\n\n # Randomly shuffle data\n np.random.seed(10)\n\n shuffle_indices = np.random.permutation(range(len(y)))\n X_shuffled = X[shuffle_indices]\n y_shuffled = y[shuffle_indices]\n\n # Split to train/test set\n # TODO: This is very crude, should use cross validation\n val_sample_index = -1 * int(0.2 * len(y))\n X_train, X_val = X_shuffled[:val_sample_index], X_shuffled[val_sample_index:]\n y_train, y_val = y_shuffled[:val_sample_index], y_shuffled[val_sample_index:]\n\n del df_data, X, y, X_shuffled, y_shuffled\n\n embedding_matrix = np.load(\"../embedding/word-embedding-200d-mc5.npy\")\n\n return X_train, y_train, X_val, y_val,embedding_matrix","def generate_embedding_matrix(self):\n # get all the embeddings\n all_embs = np.stack(list(self.embeddings.values()))\n\n # mean and standard deviation of the embedding values\n emb_mean, emb_std = all_embs.mean(), all_embs.std()\n\n # Find the number of words the the train set\n word_index = self.tokenizer.word_index\n rows = min(self.max_features, len(word_index))\n\n # create embeddings for each word by sampling from a normal distribtion\n # with parameters calculated above.\n embedding_matrix = np.random.normal(emb_mean, emb_std, (rows + 1, self.embed_size))\n\n for word, i in word_index.items():\n # TODO: replace this with stop words and frequency instead\n if i >= self.max_features:\n continue\n\n embedding_vector = self.embeddings.get(word)\n\n # if word is found in the embeddings used\n if embedding_vector is not None:\n # replace row of embeddings matrix with trained embeddings vector\n embedding_matrix[i] = embedding_vector\n\n return embedding_matrix","def get_google_word2vec_W(fname, vocab, vocab_size=1000000, index_from=3):\n f = open(fname, 'rb')\n header = f.readline()\n vocab1_size, embedding_dim = list(map(int, header.split()))\n binary_len = np.dtype('float32').itemsize * embedding_dim\n vocab_size = min(len(vocab) + index_from, vocab_size)\n W = np.zeros((vocab_size, embedding_dim))\n\n found_words = {}\n for i, line in enumerate(range(vocab1_size)):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch)\n if word in vocab:\n wrd_id = vocab[word] + index_from\n if wrd_id < vocab_size:\n W[wrd_id] = np.fromstring(\n f.read(binary_len), dtype='float32')\n found_words[wrd_id] = 1\n else:\n f.read(binary_len)\n\n cnt = 0\n for wrd_id in range(vocab_size):\n if wrd_id not in found_words:\n W[wrd_id] = np.random.uniform(-0.25, 0.25, embedding_dim)\n cnt += 1\n assert cnt + len(found_words) == vocab_size\n\n f.close()\n\n return W, embedding_dim, vocab_size","def _load_bin_vec(fname, vocab):\n print 'load bin...'\n word_vecs = {}\n cnt = 0\n\n with open(fname, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n print 'embedding vocab size: %d , embedding vector size: %d'%(vocab_size,layer1_size)\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch)\n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32')\n else:\n f.read(binary_len)\n cnt +=1\n if cnt%10000 == 0:\n \tprint '%d lines...'%cnt\n return (word_vecs, layer1_size)","def get_word_embedding(counter, emb_file, emb_size, vocab_size, vec_size, vocab_file):\n print(\"Generating word embedding...\")\n # load word embeddings\n embedding_dict = {}\n with open(emb_file, \"r\", encoding=\"utf-8\") as fh:\n for line in tqdm(fh, total=emb_size):\n array = line.split()\n word = \"\".join(array[0:-vec_size])\n vector = list(map(float, array[-vec_size:]))\n embedding_dict[word] = vector\n\n TRANSLATE = {\n \"-lsb-\": \"[\", \"-rsb-\": \"]\", \"-lrb-\": \"(\", \"-rrb-\": \")\", \"-lcb-\": \"{\",\n \"-rcb-\": \"}\", \"-LSB-\": \"[\", \"-RSB-\": \"]\", \"-LRB-\": \"(\", \"-RRB-\": \")\",\n \"-LCB-\": \"{\", \"-RCB-\": \"}\"\n }\n SPECIAL_TOKENS = [\"<NULL>\", \"<UNK>\", \"<S>\", \"</S>\"]\n words = list(map(lambda x: x[0], sorted(counter.items(), key=lambda x: x[1], reverse=True)))\n words = SPECIAL_TOKENS + words\n if vocab_size > 0:\n words = words[:vocab_size]\n with open(vocab_file, 'w') as f:\n f.write('\\n'.join(words[1:]))\n embedding = np.random.normal(scale=0.1, size=(len(words), vec_size))\n word2idx_dict = {}\n unknown_count = 0\n for i, word in enumerate(words):\n word2idx_dict[word] = i\n if word in TRANSLATE:\n word = TRANSLATE[word]\n done = False\n for w in (word, word.lower(), word.upper(), word.capitalize()):\n if w in embedding_dict:\n embedding[i] = embedding_dict[w]\n done = True\n break\n if not done:\n unknown_count += 1\n return embedding, word2idx_dict, unknown_count","def save_whiten_mat(W):\n w_id = open('data/W.bin','w')\n W.tofile(w_id)\n w_id.close()","def load_word2vec(self, path, binary=True, reserve_zero=True, reserve_oov_token=True):\n self.allow_oov = reserve_oov_token\n self.reserve_zero = reserve_zero\n words = []\n if self.reserve_zero:\n words.append('__ZERO__')\n if self.allow_oov:\n words.append('__OUT_OF_VOCAB__')\n self.oov_index = len(words) - 1\n\n if binary:\n with open(path, 'rb') as f:\n # Get number of vectors and vector size\n # from first line\n num_vectors, vector_size = map(\n int, f.readline().decode('UTF-8').split())\n FLOAT_SIZE = 4\n\n self._matrix = np.zeros(\n [num_vectors + len(words), vector_size], dtype='float32')\n # Assign random vector for OOV token if it exists\n if self.allow_oov:\n self._matrix[self.oov_index] = np.random.randn(vector_size, )\n\n update = words.append # Speedup\n for i in tqdm(range(len(words), num_vectors+len(words))):\n # Reads until a whitespace is found (get a word)\n word = b\"\"\n while True:\n char = f.read(1)\n if char == b\" \":\n break\n word += char\n update(word)\n #Read vector\n vecs = f.read(FLOAT_SIZE * vector_size)\n self._matrix[i] = np.frombuffer(vecs, 'f')\n\n self.vocab = words\n else:\n print(\"This feature is yet to be implemented\")","def read_w2v(w2v_path, word2index, n_dims=300, unk_token=\"unk\"):\n print('Getting Word Vectors...', file=sys.stderr)\n vocab = set()\n # hacky thing to deal with making sure to incorporate unk tokens in the form they are in for a given embedding type\n if unk_token not in word2index:\n word2index[unk_token] = 0 # hardcoded, this would be better if it was a method of a class\n\n word_vectors = np.zeros((len(word2index), n_dims)) # length of vocab x embedding dimensions\n with open(w2v_path) as file:\n lc = 0\n for line in file:\n lc += 1\n line = line.strip()\n if line:\n row = line.split()\n token = row[0]\n if token in word2index or token == unk_token:\n vocab.add(token)\n try:\n vec_data = [float(x) for x in row[1:]]\n word_vectors[word2index[token]] = np.asarray(vec_data)\n if lc == 1:\n if len(vec_data) != n_dims:\n raise RuntimeError(\"wrong number of dimensions\")\n except:\n print('Error on line {}'.format(lc), file=sys.stderr)\n # puts data for a given embedding at an index based on the word2index dict\n # end up with a matrix of the entire vocab\n tokens_without_embeddings = set(word2index) - vocab\n print('Word Vectors ready!', file=sys.stderr)\n print('{} tokens from text ({:.2f}%) have no embeddings'.format(\n len(tokens_without_embeddings), len(tokens_without_embeddings)*100/len(word2index)), file=sys.stderr)\n print('Tokens without embeddings: {}'.format(tokens_without_embeddings), file=sys.stderr)\n print('Setting those tokens to unk embedding', file=sys.stderr)\n for token in tokens_without_embeddings:\n word_vectors[word2index[token]] = word_vectors[word2index[unk_token]]\n return word_vectors","def embedding_sentence(input_file, save_path, max_length):\n lines = _read_csv(input_file)\n split_lines = []\n label_list = []\n for line in lines:\n split_lines.append(sentence_split(line[1], max_length))\n label_list.append(int(line[2]))\n del lines\n\n writer = tf.python_io.TFRecordWriter(save_path)\n for index, line in enumerate(split_lines):\n bytes_words = []\n for word in line:\n bytes_words.append(str.encode(word))\n example = tf.train.Example(features=tf.train.Features(feature={\n \"label\":\n tf.train.Feature(int64_list=tf.train.Int64List(value=[label_list[index]])),\n \"features\":\n tf.train.Feature(bytes_list=tf.train.BytesList(value=bytes_words))\n }))\n writer.write(example.SerializeToString())","def creating_feature_vector():\r\n\twordlist = []\r\n\tlabel = \"\"\r\n\tfw = open(\"feature_vector.txt\", \"w+\", encoding = \"utf-8\")\r\n\twith open(\"D:\\\\Python_Prac\\\\wordstag\\\\modules\\\\HI_EN_TRAIN.txt\", \"r\", encoding = \"utf-8\") as f:\r\n\t\tfor line in f:\r\n\t\t\twordlist.append(line)\r\n\t\tfor index, line in enumerate(wordlist):\r\n\t\t\tif line == \"\\n\":\r\n\t\t\t\tcontinue\r\n\t\t\tcontext = line.split(\"\\t\")\r\n\t\t\tlabel = context[1]\r\n\t\t\tfeature_vector = label+\" \"\r\n\t\t\tngram_vector = ngram_frequency(str(context[0]))\r\n\t\t\tfor vector in ngram_vector:\r\n\t\t\t\tfeature_vector += str(vector)+\" \"\r\n\t\t\tfeature_vector += str(is_english(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(is_hindi(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(is_abbr(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(med_in_english(context[0]))+\" \"\r\n\t\t\tfeature_vector += str(med_in_hindi(context[0]))+\" \"\r\n\t\t\tbefore = [0,0,0]\r\n\t\t\tafter = [0,0,0]\r\n\t\t\tfor i in range(3):\r\n\t\t\t\tif (index-i) < 0 or (index-i+1) > len(wordlist)-1:\r\n\t\t\t\t\tcontinue\r\n\t\t\t\tbefore[2-i] = get_word_context(wordlist[index-i+1].split(\"\\t\")[0])\r\n\t\t\tfor i in range(3):\r\n\t\t\t\tif (index+i+1) > len(wordlist)-1:\r\n\t\t\t\t\tcontinue\r\n\t\t\t\tafter[2-i] = get_word_context(wordlist[index+i+1].split(\"\\t\")[0])\r\n\t\t\tfor i in before:\r\n\t\t\t\tfeature_vector += str(i)+\" \"\r\n\t\t\tfor i in after:\r\n\t\t\t\tfeature_vector += str(i)+\" \"\r\n\t\t\tfeature_vector += \"\\n\"\r\n\t\t\tfw.write(feature_vector)\r\n\t\t\tprint(\"Proceeding...\"+str(index+1)+\" of 16683\")\r\n\r\n\tfw.close()","def load_word2vec_embeddings(word2vec_file, word_map):\n # Load word2vec model into memory\n w2v = gensim.models.KeyedVectors.load(word2vec_file, mmap='r')\n\n\n\n # Create tensor to hold embeddings for words that are in-corpus\n # word_map 내 단어들에 대한 임베딩 벡터 만들기\n embeddings = torch.FloatTensor(len(word_map), w2v.vector_size)\n init_embedding(embeddings)\n\n # Read embedding file\n\n for word in word_map:\n if word in w2v.vocab:\n embeddings[word_map[word]] = torch.FloatTensor(w2v[word])\n\n\n return embeddings, w2v.vector_size","def load_word_embeddings(self, word_embeddings, word_to_ix):\n logger.info(\"Loading the vocabulary\")\n self.vocab = {}\n self.index2word = []\n counts = {}\n for word in word_to_ix:\n counts[word] = counts.get(word, 0) + 1\n self.vocab_size = len(counts)\n self.vector_size = word_embeddings.shape[1]\n self.vectors = np.zeros((self.vocab_size, self.vector_size))\n self.index2word = [None] * self.vocab_size\n logger.info(\"Corpus has %i words\", len(self.vocab))\n for word_id, word in enumerate(counts):\n self.vocab[word] = Vocab(index=word_id, count=counts[word])\n self.vectors[word_id] = word_embeddings[word_to_ix[word]]\n self.index2word[word_id] = word\n assert((len(self.vocab), self.vector_size) == self.vectors.shape)\n logger.info(\"Loaded matrix of %d size and %d dimensions\", self.vocab_size, self.vector_size)","def createMatrices(file, word2Idx, maxSentenceLen, extendMapping, labelsMapping, aspectMapping, typeMapping, tenseMapping, eventClassMapping, distanceMapping, sentenceLengthMapping):\n labels = []\n eventMatrix = []\n timeMatrix = []\n\n sentenceLengths = []\n sentenceMatrix = []\n positionMatrix_e = []\n positionMatrix_t = []\n\n aspectMatrix = []\n typeMatrix = []\n tenseMatrix = []\n eventClassMatrix = []\n featuresList = []\n \n \n minDistance = 0\n for distanceKey in distanceMapping.iterkeys():\n if isinstance(distanceKey, (int, long)):\n minDistance = min(minDistance, int(distanceKey))\n \n for line in open(file):\n features = eval(line.strip())\n featuresList.append(features)\n label = features['label']\n event = features[\"Token[0]\"]\n eventPosition = int(features[\"eventPosition\"])\n tokens = features[\"textInBetween\"] if \"textInBetween\" in features else features[\"sentence\"]\n \n aspect = features[\"aspect\"]\n tense = features[\"tense\"]\n eventClass = features[\"eventClass\"]\n \n labels.append(labelsMapping[label.lower()] if label.lower() in labelsMapping else -1)\n eventMatrix.append(getWordIdx(event, word2Idx))\n \n aspectMatrix.append(getMappingIdx(aspect, aspectMapping, extendMapping))\n tenseMatrix.append(getMappingIdx(tense, tenseMapping, extendMapping))\n eventClassMatrix.append(getMappingIdx(eventClass, eventClassMapping, extendMapping))\n \n if 'TimeTokenFirst' in features:\n time = features['TimeTokenFirst']\n timeMatrix.append(getWordIdx(time, word2Idx))\n \n if 'type' in features:\n type = features[\"type\"]\n typeMatrix.append(getMappingIdx(type, typeMapping, extendMapping))\n \n timePosition = int(features[\"timeFirstPosition\"]) if 'timeFirstPosition' in features else 0\n \n\n if len(tokens) in sentenceLengthMapping:\n sentenceLengths.append(sentenceLengthMapping[len(tokens)])\n else:\n sentenceLengths.append(sentenceLengthMapping['GreaterMax'])\n\n \n tokenIds = np.zeros(maxSentenceLen)\n positionValues_e = np.zeros(maxSentenceLen)\n positionValues_t = np.zeros(maxSentenceLen)\n for idx in xrange(0, min(maxSentenceLen, len(tokens))):\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\n \n distance_e = idx - eventPosition\n distance_t = idx - timePosition\n\n if distance_e in distanceMapping:\n positionValues_e[idx] = distanceMapping[distance_e]\n elif distance_e <= minDistance:\n positionValues_e[idx] = distanceMapping['LowerMin']\n else:\n positionValues_e[idx] = distanceMapping['GreaterMax']\n \n if distance_t in distanceMapping:\n positionValues_t[idx] = distanceMapping[distance_t]\n elif distance_t <= minDistance:\n positionValues_t[idx] = distanceMapping['LowerMin']\n else:\n positionValues_t[idx] = distanceMapping['GreaterMax']\n\n sentenceMatrix.append(tokenIds)\n positionMatrix_e.append(positionValues_e)\n positionMatrix_t.append(positionValues_t)\n\n \n labels = np.array(labels, dtype='int32')\n eventMatrix = np.expand_dims(np.array(eventMatrix, dtype='int32'), axis=1)\n timeMatrix = np.expand_dims(np.array(timeMatrix, dtype='int32'), axis=1)\n aspectMatrix = np.expand_dims(np.array(aspectMatrix, dtype='int32'), axis=1)\n typeMatrix = np.expand_dims(np.array(typeMatrix, dtype='int32'), axis=1)\n tenseMatrix = np.expand_dims(np.array(tenseMatrix, dtype='int32'), axis=1)\n eventClassMatrix = np.expand_dims(np.array(eventClassMatrix, dtype='int32'), axis=1)\n sentenceLengths = np.expand_dims(np.array(sentenceLengths, dtype='int32'), axis=1)\n \n \n sentenceMatrix = np.array(sentenceMatrix, dtype='int32')\n positionMatrix_e = np.array(positionMatrix_e, dtype='int32')\n positionMatrix_t = np.array(positionMatrix_t, dtype='int32')\n \n\n\n return {'labels': labels,\n 'event':eventMatrix, \n 'time':timeMatrix, \n 'sentence':sentenceMatrix, \n 'positions_e':positionMatrix_e, \n 'positions_t':positionMatrix_t, \n 'aspect':aspectMatrix, \n 'tense':tenseMatrix, \n 'eventClass':eventClassMatrix, \n 'type': typeMatrix,\n 'sentence_len': sentenceLengths,\n 'features': featuresList}","def prepare_word_emb_matrices(experiment):\r\n\r\n with open(\"public_data/stats/stats_train.pkl\", 'rb') as stats:\r\n stats = pickle.load(stats)\r\n vocab = stats[\"VOCAB\"]\r\n stops = [word.lower() for word in set(stopwords.words('english'))]\r\n vocab = vocab + stops\r\n\r\n if experiment == \"RANDOM\":\r\n word_embs = np.random.uniform(low=-1.0, high=1.0, size=(len(vocab), PARAMS[\"SIZE\"])).astype(\"float32\")\r\n\r\n else:\r\n word_embs = []\r\n count_unk = 0\r\n count_kn = 0\r\n\r\n if experiment == \"5\":\r\n emb_model = KeyedVectors.load_word2vec_format(\"public_data/models/experiment_5/embeddings_5.bin\",\r\n binary=True)\r\n elif experiment == \"6\":\r\n emb_model = Word2Vec.load(\"public_data/models/experiment_6/embeddings_6\")\r\n\r\n elif experiment in [\"7\", \"8\"]:\r\n emb_model = FastText.load_fasttext_format(\"public_data/models/experiment_%s/embeddings_%s.bin\"\r\n %(experiment, experiment))\r\n for word in vocab:\r\n if word in emb_model:\r\n word_embs.append(emb_model[word])\r\n count_kn += 1\r\n else:\r\n word_embs.append(np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\"SIZE\"]))\r\n count_unk += 1\r\n\r\n word_embs = np.array(word_embs).astype(\"float32\")\r\n print(count_unk / (count_kn + count_unk))\r\n\r\n pad = np.zeros(shape=PARAMS[\"SIZE\"]).astype(\"float32\")\r\n unk = np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\"SIZE\"]).astype(\"float32\")\r\n word_embs = np.insert(word_embs, 0, unk, axis=0) #id 1\r\n word_embs = np.insert(word_embs, 0, pad, axis=0) #id 0\r\n\r\n with open(\"public_data/embeddings/word_embeddings_%s.pkl\" %experiment, 'wb') as out:\r\n pickle.dump(word_embs, out, protocol=4)\r\n\r\n return word_embs","def __init__(self, vector_file='', transform=None):\n self.word2id = {}\n\n # Captures word order, for export() and translate methods\n self.id2word = []\n\n print('reading word vectors from %s' % vector_file)\n with open(vector_file, 'r', errors='ignore') as f:\n line = f.readline()\n header_tokens = line.rstrip('\\n').split(' ')\n if len(header_tokens) == 2:\n self.n_words, self.n_dim = [int(x) for x in header_tokens]\n self.embed = np.zeros((self.n_words, self.n_dim))\n lines = f.read().split('\\n')\n for i, line in enumerate(lines):\n if line == '':\n continue\n elems = line.rstrip('\\n').split(' ')\n self.word2id[elems[0]] = i\n self.embed[i] = elems[1:self.n_dim + 1]\n self.id2word.append(elems[0])\n else:\n self.n_words, self.n_dim = 2196017, 300\n self.embed = np.zeros((self.n_words, self.n_dim))\n self.word2id[header_tokens[0]] = 0\n self.embed[0] = header_tokens[1:self.n_dim + 1]\n self.id2word.append(header_tokens[0])\n for i, line in enumerate(f.read().split('\\n')):\n if line == '':\n continue\n elems = line.rstrip('\\n').split(' ')\n self.word2id[elems[0]] = i+1\n self.embed[i+1] = elems[1:self.n_dim+1]\n self.id2word.append(elems[0])\n\n # Used in translate_inverted_softmax()\n self.softmax_denominators = None\n\n if transform is not None:\n print('Applying transformation to embedding')\n self.apply_transform(transform)","def createMatrices(file, word2Idx, maxSentenceLen=100):\n labels = []\n positionMatrix1 = []\n positionMatrix2 = []\n tokenMatrix = []\n \n for line in open(file):\n splits = line.strip().split('\\t')\n \n label = splits[0]\n pos1 = splits[1]\n pos2 = splits[2]\n sentence = splits[3]\n tokens = sentence.split(\" \")\n \n \n \n \n tokenIds = np.zeros(maxSentenceLen)\n positionValues1 = np.zeros(maxSentenceLen)\n positionValues2 = np.zeros(maxSentenceLen)\n \n for idx in range(0, min(maxSentenceLen, len(tokens))):\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\n \n distance1 = idx - int(pos1)\n distance2 = idx - int(pos2)\n \n if distance1 in distanceMapping:\n positionValues1[idx] = distanceMapping[distance1]\n elif distance1 <= minDistance:\n positionValues1[idx] = distanceMapping['LowerMin']\n else:\n positionValues1[idx] = distanceMapping['GreaterMax']\n \n if distance2 in distanceMapping:\n positionValues2[idx] = distanceMapping[distance2]\n elif distance2 <= minDistance:\n positionValues2[idx] = distanceMapping['LowerMin']\n else:\n positionValues2[idx] = distanceMapping['GreaterMax']\n \n tokenMatrix.append(tokenIds)\n positionMatrix1.append(positionValues1)\n positionMatrix2.append(positionValues2)\n \n labels.append(labelsMapping[label])\n \n\n \n return np.array(labels, dtype='int32'), np.array(tokenMatrix, dtype='int32'), np.array(positionMatrix1, dtype='int32'), np.array(positionMatrix2, dtype='int32'),","def buildEmbeddingMatrix(path_to_gloVe, tokenizer, embedding_dimen=300):\n logging.info(\"Loading GloVe vector model..\")\n t = time()\n # Loads the gloVe model into a dictionary\n with open(path_to_gloVe, encoding='utf8') as file:\n embeddings = dict()\n for line in file:\n values = line.split()\n # key is the word, value is the numpy array for the corresponding word vector\n embeddings[values[0]] = np.asarray(values[1:], 'float32')\n # Create a 2D tensor of shape(num_unique_words+1, embedding_dimen) (Index 0 is used for padding)\n embedding_matrix = np.zeros((len(nltk_tokenizer.word_index) + 1, embedding_dimen))\n word_found_in_embedding = 0\n for word, index in nltk_tokenizer.word_index.items():\n embedding_vector = embeddings.get(word)\n # Only populate word vectors that exist in GloVe model,\n # words not found (e.g: spelling error) will be padded with zeroes as their word vector\n if embedding_vector is not None:\n embedding_matrix[index] = embedding_vector\n word_found_in_embedding += 1\n logging.info(\"Done!\")\n logging.info(\"Loaded {} word vectors into the embedding.\".format(len(embedding_matrix)))\n logging.info(\"Found {} word vectors that exist in the GloVe model.\".format(word_found_in_embedding))\n logging.info(\"Time taken to load pre-trained GloVe model: {} mins\".format(round(((time() - t) / 60), 2)))\n return embedding_matrix","def read_txt_embeddings(path, params):\n word2id = {}\n vectors = []\n\n # load pretrained embeddings\n _emb_dim_file = params.emb_dim\n with io.open(path, 'r', encoding='utf-8', newline='\\n', errors='ignore') as f:\n for i, line in enumerate(f):\n if i == 0:\n split = line.split()\n assert len(split) == 2\n assert _emb_dim_file == int(split[1])\n continue\n word, vect = line.rstrip().split(' ', 1)\n vect = np.fromstring(vect, sep=' ')\n if word in word2id:\n logger.warning(\"Word \\\"%s\\\" found twice!\" % word)\n continue\n if not vect.shape == (_emb_dim_file,):\n logger.warning(\"Invalid dimension (%i) for word \\\"%s\\\" in line %i.\"\n % (vect.shape[0], word, i))\n continue\n assert vect.shape == (_emb_dim_file,)\n word2id[word] = len(word2id)\n vectors.append(vect[None])\n\n assert len(word2id) == len(vectors)\n logger.info(\"Loaded %i pretrained word embeddings from %s\" % (len(vectors), path))\n\n # compute new vocabulary / embeddings\n embeddings = np.concatenate(vectors, 0)\n embeddings = torch.from_numpy(embeddings).float()\n\n assert embeddings.size() == (len(word2id), params.emb_dim)\n return word2id, embeddings","def glove(data_fname='glove.840B.300d.txt', out_fname='glove.pkl'):\n words, U, dim = [], [], None\n with open(DATA_DIR + data_fname, 'rb') as f:\n for j, line in enumerate(f):\n x = line.strip().split()\n word, vector, d = x[0], np.ravel(x[1:]), len(x) - 1\n if dim is None: dim = d\n elif d != dim: raise Exception('{0}: {1}!={2}'.format(j, dim, d))\n U.append(vector)\n words.append(word)\n U = np.array(U)\n print \"Found {0} words\".format(len(words))\n print \"Found {0}x{1} embedding matrix\".format(*U.shape)\n with open(DATA_DIR + out_fname, 'wb') as f:\n cPickle.dump((words, U), f)","def load_embeddings(embeddings_path):\n\n embeddings_index = {}\n f = open(embeddings_path, encoding='utf-8')\n for line in tqdm(f):\n values = line.rstrip().split(' ')\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n f.close()\n print('Found {} word vectors.'.format(len(embeddings_index)))\n return embeddings_index","def load_embeddings(path, vocab, source_domain, target_domain, emb_name):\n\n pkl = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\n if os.path.exists(pkl):\n print(\"Load embeddings from existing pkl file %s...\" % pkl)\n # word embeddings weights have been loaded\n embeddings = pickle.load(open(pkl, 'rb'))\n else:\n print(\"Load embedding from %s...\" % path)\n raw_embeddings = {}\n if emb_name == 'yelp_electronics':\n with open(path) as fp:\n for line in fp:\n word_vector = line.split(\",\")[:-1]\n vector_list = []\n for element in word_vector[len(word_vector) - 100:]:\n vector_list.append(float(element))\n word = ','.join(word_vector[:len(word_vector) - 100])\n vector = np.asarray(vector_list)\n if word in vocab:\n raw_embeddings[word] = vector\n else:\n with open(path) as fp:\n for line in fp:\n eles = line.strip().split(' ')\n word = eles[0]\n if word in vocab:\n raw_embeddings[word] = eles[1:]\n\n dim_w = len(raw_embeddings['the'])\n n_words = len(vocab)\n embeddings = np.zeros(shape=(n_words, dim_w))\n for w in vocab:\n wid = vocab[w]\n if w in raw_embeddings:\n embeddings[wid] = np.array([float(ele) for ele in raw_embeddings[w]])\n else:\n # for OOV words, add random initialization\n embeddings[wid] = np.random.uniform(-0.25, 0.25, dim_w)\n print(\"Find %s word embeddings...\" % len(embeddings))\n if not os.path.exists('./work/embeddings'):\n os.mkdir('./work/embeddings')\n emb_path = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\n # write the embedding weights back to the disk\n pickle.dump(embeddings, open(emb_path, 'wb'))\n embeddings = np.array(embeddings, dtype='float32')\n return embeddings","def load_bin_vec(word2vec, vocab):\n word_vecs = {}\n with open(word2vec, \"rb\") as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = np.dtype('float32').itemsize * layer1_size\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch)\n if word in vocab:\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32')\n else:\n f.read(binary_len)\n return word_vecs","def create_embedding_matrix(self):\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\n vocab_size = len(self.vocab)\n result = np.zeros((vocab_size, self.embed_dim))\n unknown_token_set = set()\n\n found_words = 0\n avg = np.zeros(self.embed_dim)\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\n try:\n result[_] = self.pretrained_embedding[self.id2word[_]]\n avg += result[_]\n found_words += 1\n except:\n unknown_token_set.add(_)\n\n avg /= found_words\n for _ in unknown_token_set:\n result[_] = avg\n self.embedding = result\n return found_words, len(self.id2word)","def get_W(word_vecs, k=100,path='wordemb'):\n vocab_size = len(word_vecs)\n word_idx_map = dict()\n W = np.zeros(shape=(vocab_size+1, k), dtype='float32')\n W[0] = np.zeros(k, dtype='float32')\n i = 1\n f =open(path+'.word','w')\n for word in word_vecs:\n # print(\"#############################\")\n # print(word_vecs[word].shape)\n # print(word)\n # print(W[i].shape)\n # print(\"#############################\")\n W[i] = word_vecs[word]\n f.write(word+'\\n')\n word_idx_map[word] = i\n i += 1\n np.savetxt(path+'.txt',W,fmt='%.7f', delimiter=' ')\n f.close()\n return W, word_idx_map","def get_word_embeddings(t, folder, lang=\"en\"):\n vecs_url = f\"https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.{lang}.300.vec.gz\"\n vecs_gz_filename = vecs_url.rpartition(\"/\")[2]\n os.makedirs(folder, exist_ok=True)\n vecs_gz_filepath = os.path.join(folder, vecs_gz_filename)\n\n tokenizer_vocab_size = len(t.vocab)\n\n if wait_for_file_stable(vecs_gz_filepath):\n print(\"Using existing embeddings file\")\n else:\n print(\"Downloading word vectors...\")\n subprocess.run([\" \".join([\"wget\", \"-NP\", folder, vecs_url])], check=True, shell=True)\n\n print(\"Loading into memory...\")\n embeddings_index = dict()\n with gzip.open(vecs_gz_filepath, \"rt\") as zipf:\n firstline = zipf.readline()\n emb_vocab_size, emb_d = firstline.split(\" \")\n emb_vocab_size = int(emb_vocab_size)\n emb_d = int(emb_d)\n for line in zipf:\n values = line.split()\n word = values[0]\n # Only load subset of the embeddings recognised by the tokenizer:\n if word in t.vocab.stoi:\n coefs = np.asarray(values[1:], dtype=\"float32\")\n embeddings_index[word] = coefs\n print(\"Loaded {} of {} word vectors for tokenizer vocabulary length {}\".format(\n len(embeddings_index),\n emb_vocab_size,\n tokenizer_vocab_size,\n ))\n\n # create a weight matrix for words in training docs\n embedding_matrix = np.zeros((tokenizer_vocab_size, emb_d))\n for word, i in t.vocab.stoi.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n return embedding_matrix","def _add_pre_trained_embedding(self):\n\n if self.embedding_type['type'] == 'glove':\n self.logging.info('use pre-trained glove word2vec')\n # a. load pre trained glove\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\n import os\n import numpy as np\n\n embeddings_index = {}\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\n for line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n f.close()\n\n self.logging.info('')\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\n\n # b. compute embedding matrix\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n\n elif self.embedding_type['type'] == 'gensim':\n self.logging.info('use pre-trained gensim word2vec')\n\n import gzip\n import gensim\n from keras.layers import Embedding\n import numpy as np\n\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\n\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\n pretrained_weights = model.wv.syn0\n vocab_size, vector_dim = pretrained_weights.shape\n\n method = 3\n if method == 1:\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\n # into our TensorFlow and Keras models\n\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\n for i in range(len(model.wv.vocab)):\n embedding_vector = model.wv[model.wv.index2word[i]]\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\n output_dim=embedding_matrix.shape[1],\n # input_length=self.maxlen,\n weights=[embedding_matrix],\n trainable=False)\n elif method == 2:\n self.logging.info('word2vec simple embedding matching - simple complex')\n embedding_layer = Embedding(input_dim=vocab_size,\n output_dim=vector_dim,\n input_length=self.maxlen,\n weights=[pretrained_weights],\n trainable=False)\n elif method == 3:\n\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\n # b. compute embedding matrix\n\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\n\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n if word in model.wv:\n embedding_vector = model.wv[word]\n embedding_matrix[i] = embedding_vector\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt))\n\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n else:\n raise ValueError('unknown method value')\n\n else:\n raise ValueError('unknown embedding type')\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\n return embedding_layer","def load_embedding(embedding_file_path, word_index, embedding_dim):\n # Create a Numpy Placeholder for Embedding\n max_features = len(word_index)+1\n embedding_weights = np.random.random([max_features, embedding_dim])\n count = 0\n glove_file = open(embedding_file_path)\n for line in glove_file:\n word, vector = line.split(' ')[0], line.split(' ')[1:]\n if word in word_index and word_index[word] <= max_features:\n count += 1\n vector = list(map(float, vector))\n embedding_weights[word_index[word]] = [float(i) for i in vector]\n\n print('Fraction found in glove {}'.format(count/len(embedding_weights)))\n return embedding_weights","def load_word2vec(path):\n model = gensim.models.KeyedVectors.load_word2vec_format(path, binary=True) \n return model","def export_trimmed_glove_vectors(vocab, glove_filename, trimmed_filename, dim):\n embeddings = np.zeros([len(vocab), dim])\n with open(glove_filename, encoding='utf-8') as f:\n for line in f:\n line = line.strip().split(' ')\n word = line[0]\n embedding = [float(x) for x in line[1:]]\n if word in vocab:\n word_idx = vocab[word]\n embeddings[word_idx] = np.asarray(embedding)\n\n np.savez_compressed(trimmed_filename, embeddings=embeddings)","def generate_conll2003_embeddings():\n glove_embedding = get_glove_embedding()\n\n word2index = {}\n idx2word = {}\n embed_array = []\n\n word2index[\"<pad>\"] = 1\n embed_array.append(init_embedding())\n\n word2index[\"<unk>\"] = 0\n embed_array.append(init_embedding())\n\n data = []\n with open(TRAIN_DATA_PATH, \"r\") as f:\n for line in f:\n data.append(json.loads(line))\n\n idx = 2\n\n for sample in tqdm(data, total=len(data)):\n words = sample[\"tokens\"]\n\n for w in words:\n w = w.lower()\n\n # if word is not present in dictionary, add to dictionary and append embedding vector\n if w not in word2index.keys():\n word2index[w] = idx\n idx += 1\n if w not in glove_embedding.keys():\n ev = init_embedding()\n else:\n ev = glove_embedding[w]\n\n embed_array.append(ev)\n\n else:\n continue\n\n # save embeddings\n embed_array = np.vstack(embed_array)\n np.save(EMBD_OUTPUT_PATH, embed_array)\n\n # save dictionary\n print(\"Dicitionary Size: \", len(word2index))\n with open(DICTIONARY_OUTPUT_PATH, \"w\") as f:\n json.dump(word2index, f)","def glove_embedding(self, texts, file):\n self.embedding_dict = dict()\n glove_file = open(file, encoding='utf-8')\n for line in glove_file:\n word_vector = line.split()\n word = word_vector[0]\n word_vector_arr = np.asarray(word_vector[1:], dtype='float32')\n self.embedding_dict[word] = word_vector_arr\n glove_file.close()\n \n i = 0\n with pgb.ProgressBar(max_value=len(texts)) as bar:\n for text in texts:\n vec = []\n text = text.split()\n for t in text:\n try:\n vec.append(self.embedding_dict[t.lower()])\n except KeyError:\n pass\n ## There are no matched words\n if len(vec) == 0:\n print(\"len 0 vec\")\n self.word_vec.append(np.zeros((100)))\n else:\n #print(np.array(vec))\n #print(np.array(vec).shape)\n sentence = self.sentence_vec(np.array(vec))\n #print(sentence)\n #print(sentence.shape)\n self.word_vec.append(sentence)\n i += 1\n bar.update(i)\n self.word_vec = np.array(self.word_vec)\n print(self.word_vec.shape)","def vectorize(self,clean_path):\n \n #load pretrained embedding model (GloVe)\n glove = spacy.load('en_core_web_lg')\n #extract unique words (aka vocabulary)\n unique_words = set()\n for d in self.docs: \n txt = d.text\n doc = glove(txt)\n for word in doc: \n if word.has_vector:\n unique_words.add(word.text)\n #change set to list type\n unique_words = list(unique_words)\n #save vector representation\n word_vectors = np.array([glove(word).vector for word in unique_words if glove(word).has_vector])\n #index vectors by corresponding word \n corpus_vectors = pd.DataFrame(word_vectors, index=unique_words)\n with open(clean_path + 'corpus_vectors.pkl', 'wb') as f:\n pickle.dump(corpus_vectors,f)\n self.vectors = corpus_vectors\n print('Saved embedding vectors.')\n return","def build_doc_sense_vec(self):\n\t\twith codecs.open(self.vocab_file, encoding='utf-8', mode='r') as infile:\n\t\t\tline = infile.readline()\n\t\t\ti = 0\n\t\t\twhile line:\n\t\t\t\tword = line.split()[0]\n\t\t\t\tif not self.word2IdVocabulary.has_key(word):\n\t\t\t\t\t# print i, word\n\t\t\t\t\t# else:\n\t\t\t\t\tself.word2IdVocabulary[word] = i\n\t\t\t\tif not self.id2WordVocabulary.has_key(i):\n\t\t\t\t\tself.id2WordVocabulary[i] = word\n\t\t\t\tline = infile.readline()\n\t\t\t\ti += 1\n\t\t\tself.vocab_num = len(self.word2IdVocabulary)\n\t\t\tprint \"vocabulary number:\" + str(self.vocab_num)\n\n\t\twith codecs.open(self.vec_file, encoding='utf-8', mode='r') as vecfile:\n\t\t\twith codecs.open(self.vec_out_file, encoding='utf-8', mode='a+') as vec_outfile:\n\n\t\t\t\tfor i, line in enumerate(vecfile):\n\t\t\t\t\tif i % 10000 == 0:\n\t\t\t\t\t\tprint i\n\t\t\t\t\t# if i > 72:\n\t\t\t\t\t# \tbreak\n\t\t\t\t\tif i == 0:\n\t\t\t\t\t\ta, b, c = map(int, line.split()[:3])\n\t\t\t\t\t\tprint('Number of sememes: {}\\n'\n\t\t\t\t\t\t\t 'Number of words: {}\\n'\n\t\t\t\t\t\t\t 'Dimension of vectors: {}'.format(a, b, c))\n\t\t\t\t\telif i > 462667:\n\t\t\t\t\t\tsline = line.strip('\\n').split()\n\t\t\t\t\t\tword = sline[0]\n\t\t\t\t\t\tvector_list = []\n\t\t\t\t\t\tvector_list.append(sline[1:])\n\t\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\t\tword_id = self.word2IdVocabulary[word]\n\t\t\t\t\t\tif not self.vectors.has_key(word_id):\n\t\t\t\t\t\t\tself.vectors[word_id] = vector_array\n\t\t\t\t\t\t# vector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t\tif not self.vector_mean.has_key(word_id):\n\t\t\t\t\t\t\tself.vector_mean[word_id] = vector_array\n\t\t\t\t\t\t# vec_outfile.write(line)\n\t\t\t\t\telif i > 462887:\n\t\t\t\t\t\tbreak\n\t\t\t\t\telse:\n\t\t\t\t\t\tsline = line.strip('\\n').split()\n\t\t\t\t\t\tword = sline[0]\n\t\t\t\t\t\tsense_num = int(sline[1])\n\t\t\t\t\t\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\n\t\t\t\t\t\tvector_list = []\n\t\t\t\t\t\tfor start in range(0, len(vectors), c):\n\t\t\t\t\t\t\tvector_list.append(list(map(float, vectors[start: start+c])))\n\t\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\t\tword_id = self.word2IdVocabulary[word]\n\t\t\t\t\t\tif not self.vectors.has_key(word_id):\n\t\t\t\t\t\t\tself.vectors[word_id] = vector_array\n\t\t\t\t\t\tvector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t\tif not self.vector_mean.has_key(word_id):\n\t\t\t\t\t\t\tself.vector_mean[word_id] = vector_mean\n\t\t\t\t\t\t'''j = 0\n\t\t\t\t\t\tfor each_sense_vec in vector_array:\n\t\t\t\t\t\t\tif len(vector_array) > 1:\n\t\t\t\t\t\t\t\tnew_line = word + '_' + str(j) + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tformatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\n'\n\t\t\t\t\t\t\t\tj += 1\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tnew_line = word + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t formatter={'float_kind': lambda\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t x: '%6f' % x})[1:-1] + '\\n'\n\n\t\t\t\t\t\t\tvec_outfile.write(new_line)'''\n\n\t\twith codecs.open(self.doc_file, encoding='utf-8', mode='r') as docfile:\n\t\t\twith codecs.open(self.doc_out_file, encoding='utf-8', mode='a+') as doc_outfile:\n\t\t\t\twith codecs.open(self.vec_out_file_bydoc, encoding='utf-8', mode='a+') as vec_outfile_bydoc:\n\t\t\t\t\tprint \"Processing document file......\"\n\t\t\t\t\tline = docfile.readline().strip('\\n')\n\t\t\t\t\twhile line:\n\t\t\t\t\t\twords = line.split()\n\t\t\t\t\t\tnew_words = [x for x in words]\n\t\t\t\t\t\tfor i in range(len(words)):\n\t\t\t\t\t\t\tword_id = self.word2IdVocabulary[words[i]]\n\t\t\t\t\t\t\tsense_vecs = self.vectors[word_id]\n\t\t\t\t\t\t\tsense_num = len(sense_vecs)\n\t\t\t\t\t\t\tif sense_num > 1:\n\t\t\t\t\t\t\t\tcontext_words = []\n\t\t\t\t\t\t\t\tfor x in range(i-int(self.context_num), i+int(self.context_num)+1):\n\t\t\t\t\t\t\t\t\tif x != i and 0 <= x < len(words):\n\t\t\t\t\t\t\t\t\t\tcontext_words.append(words[x])\n\t\t\t\t\t\t\t\tsense_index = self.select_attention(context_words, sense_vecs)\n\t\t\t\t\t\t\t\tword_vec_i = sense_vecs[sense_index]\n\t\t\t\t\t\t\t\tnew_wordi = words[i] + '_' + str(sense_index)\n\t\t\t\t\t\t\t\tself.vector_word_doc[new_wordi.encode('utf-8')] = word_vec_i\n\t\t\t\t\t\t\t\tnew_words[i] = new_wordi\n\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tword_vec_i = sense_vecs[0]\n\t\t\t\t\t\t\t\tself.vector_word_doc[words[i].encode('utf-8')] = word_vec_i\n\t\t\t\t\t\t\tvec_outfile_bydoc.write(new_words[i] + ' ' + np.array2string(word_vec_i, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t formatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\n')\n\n\t\t\t\t\t\tdoc_outfile.write(' '.join(new_words) + '\\n')\n\n\t\t\t\t\t\tline = docfile.readline()\n\n\t\treturn self.vector_word_doc","def save_dict(emb, path_to_vec, dim=100):\n word_vec = {}\n for w in emb.keys():\n word_vec[w] = emb[w]\n with open(path_to_vec + f'embedding_{str(dim)}d.txt', 'w') as file:\n for w, v in word_vec.items():\n file.write(w + ' ')\n for el in v:\n file.write(\"{:.20f}\".format(float(el)) + ' ')\n file.write('\\n')","def _initialize_embeddings(self, chunk_file):\n input = SRP.Vector_file(chunk_file)\n dataset = input.to_matrix(unit_length = True)\n self.matrix = dataset['matrix']\n \n ids = dataset['names']\n self.ids = ids\n\n sections = [a.split(\"-\") for a in dataset['names']]\n try:\n htids, sections, starts, ends = zip(*sections)\n except:\n # The old format: deprecated.\n htids, sections = zip(*sections)\n sections = pd.DataFrame({'mtid': ids, 'htid': htids, 'section': list(map(int, sections))}).set_index('htid')\n\n self.chunk_metadata = sections.join(self.metadata, how='left').reset_index()\n \n self.mtid_lookup = dict(zip(dataset['names'], range(len(dataset['names']))))\n \n self.htid_lookup = defaultdict(list)\n for i, htid in enumerate(htids):\n self.htid_lookup[htid].append(ids[i])","def get_weibo_data(vocab_file, vector_file):\n if os.path.exists(\"word_misc.pkl\"):\n return cPickle.load(open(\"word_misc.pkl\", \"rb\"))\n\n word_misc, word2id, id2word = {}, {}, {}\n word_count = 0\n\n # vocab file\n print \"Building vocabulary ...\"\n for lines in open(vocab_file).readlines():\n word = lines.split()[0]\n if not is_unwanted_words(word, ['', '\\n']):\n word2id[word] = word_count\n id2word[word_count] = word\n word_count += 1\n word2id['_START'] = word_count\n id2word[word_count] = '_START'\n word_count += 1\n word2id['_END'] = word_count\n id2word[word_count] = '_END'\n word_count += 1\n word2id['_UNK'] = word_count\n id2word[word_count] = '_UNK'\n word_count += 1\n word2id['_MASK'] = word_count\n id2word[word_count] = '_MASK'\n word_count += 1\n print \"Vocabulary size:\", word_count\n\n # Initialization is refered to in https://www.tensorflow.org/versions/r0.7/tutorials/word2vec/index.html\n word_emb = (1/np.sqrt(word_count)*(2*np.random.rand(word_count, options['embedding_size']) - 1)).tolist()\n\n # load word vectors\n for lines in open(vector_file).readlines()[1:]:\n word = lines.split()[0]\n #if word == '</s>' or word not in word2id.keys():\n # continue\n if word not in word2id.keys():\n continue\n ids = word2id[word]\n #print ids, lines, len(word_emb)\n word_emb[ids] = [float(w) for w in lines.split()[1:]]\n\n print len(word_emb), \"words have been loaded with\", len(word_emb[0]), \"dimensions\"\n\n # load word misc\n word_misc['id2word'] = id2word\n word_misc['word2id'] = word2id\n word_misc['word_count'] = word_count\n word_misc['word_emb'] = word_emb\n cPickle.dump(word_misc, open(\"word_misc.pkl\", \"wb\"))\n print \"Dump complete.\"\n return word_misc","def dump_token_embeddings(vocab_file, options_file, weight_file, outfile):\n with open(options_file, 'r') as fin:\n options = json.load(fin)\n max_word_length = options['char_cnn']['max_characters_per_token']\n\n vocab = UnicodeCharsVocabulary(vocab_file, max_word_length)\n batcher = Batcher(vocab_file, max_word_length)\n print('Computing {} LM token vectors'.format(vocab.size))\n\n ids_placeholder = tf.placeholder(\n 'int32',\n shape=(None, None, max_word_length)\n )\n print('Building Language model')\n model = BidirectionalLanguageModel(\n options_file, weight_file, ids_placeholder\n )\n\n embedding_op = model.get_ops()['token_embeddings']\n\n n_tokens = vocab.size\n embed_dim = int(embedding_op.shape[2])\n\n embeddings = np.zeros((n_tokens, embed_dim), dtype=lm_model.DTYPE)\n\n config = tf.ConfigProto(allow_soft_placement=True)\n with tf.Session(config=config) as sess:\n sess.run(tf.global_variables_initializer())\n for k in tqdm(range(n_tokens), desc='Computing LM token embeddings', ncols=80):\n token = vocab.id_to_word(k)\n char_ids = batcher.batch_sentences([[token]])[0, 1, :].reshape(\n 1, 1, -1)\n embeddings[k, :] = sess.run(\n embedding_op, feed_dict={ids_placeholder: char_ids}\n )\n\n with h5py.File(outfile, 'w') as fout:\n fout.create_dataset(\n 'embedding', embeddings.shape, dtype='float32', data=embeddings\n )","def generateMatrix(self):\n if self.tokenWeights and self.extraFeatures:\n nFeatures = self.wordId + self.wordId2 + len(self.EXTRA_WEIGHTS_LABELS)\n logging.info('Exporting TOKEN WEIGHTS AND EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n # iterate through 1st sentence\n for wId, val in doc['s1'].iteritems():\n mtrx[docId, wId] = val\n # then iterate thru 2nd sentence, store on 2ND PARTITION\n for wId, val in doc['s2'].iteritems():\n mtrx[docId, self.wordId + wId] = val\n # finally extra features values stored at the end of the vector\n for label, val in doc['extraFeatures'].iteritems():\n mtrx[docId, self.wordId + self.wordId2 + self.EXTRA_WEIGHTS_LABELS.index(label)] = val\n\n elif self.tokenWeights and not self.extraFeatures:\n nFeatures = self.wordId + self.wordId2\n logging.info('Exporting TOKEN WEIGHTS %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n # iterate through 1st sentence\n for wId, val in doc['s1'].iteritems():\n mtrx[docId, wId] = val\n # then iterate thru 2nd sentence, store on 2ND PARTITION\n for wId, val in doc['s2'].iteritems():\n mtrx[docId, self.wordId + wId] = val\n else:\n nFeatures = len(self.EXTRA_WEIGHTS_LABELS)\n logging.info('Exporting EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n for label, val in doc['extraFeatures'].iteritems():\n mtrx[docId, self.EXTRA_WEIGHTS_LABELS.index(label)] = val\n logging.info('Matrix generated')\n logging.info(mtrx.shape)\n return mtrx","def load_embed(file_name, vocab_size):\n\n with tf.io.gfile.Open(file_name, 'r') as embed_file:\n vocab = []\n embeds = []\n depth = -1\n for index, line in enumerate(embed_file):\n if vocab_size > 0 and index >= vocab_size:\n break\n line = line.strip()\n tokens = line.strip().split(' ')\n word = tokens[0]\n vocab.append(word)\n if depth == -1:\n embed = [float(token) for token in tokens[1:]]\n else:\n embed = [float(token) for token in tokens[-depth:]]\n d = len(embed)\n if depth == -1:\n depth = d\n if d != depth:\n raise ValueError('Inconsistent embedding sizes')\n embeds.append(embed)\n\n embeds = np.stack(embeds)\n\n return vocab, embeds, depth","def dump_w2vdictionary(outfilename,wordlist,matrix):\n ostream = open(outfilename,'w')\n print('%d %d'%(len(wordlist),matrix.shape[1]),file=ostream)\n for word,vec in zip(wordlist,matrix):\n print(' '.join([word]+ [ str(elt) for elt in vec]),file=ostream)\n ostream.close()","def load(cls, filepath) -> 'Word2VecEmbedding':\n with open(filepath, 'rb') as f:\n embedding = pickle.load(f)\n embedding.word2idx = {spell: idx for idx, spell in enumerate(embedding.vocab.idx2word)}\n return embedding","def write_vecs(self, vecs_fname):\r\n header = f'{self.vectors.shape[0]} {self.vectors.shape[1]}'\r\n np.savetxt(vecs_fname, np.hstack([self.words.reshape(-1, 1), self.vectors]), fmt='%s', header=header)","def load_embeddings(glove_path, vocab):\n vocab_size = vocab.get_vocab_size()\n words_to_keep = set(vocab.get_index_to_token_vocabulary().values())\n glove_embeddings = {}\n embedding_dim = None\n\n logger.info(\"Reading GloVe embeddings from {}\".format(glove_path))\n with open(glove_path) as glove_file:\n for line in tqdm(glove_file,\n total=get_num_lines(glove_path)):\n fields = line.strip().split(\" \")\n word = fields[0]\n if word in words_to_keep:\n vector = np.asarray(fields[1:], dtype=\"float32\")\n if embedding_dim is None:\n embedding_dim = len(vector)\n else:\n assert embedding_dim == len(vector)\n glove_embeddings[word] = vector\n\n all_embeddings = np.asarray(list(glove_embeddings.values()))\n embeddings_mean = float(np.mean(all_embeddings))\n embeddings_std = float(np.std(all_embeddings))\n logger.info(\"Initializing {}-dimensional pretrained \"\n \"embeddings for {} tokens\".format(\n embedding_dim, vocab_size))\n embedding_matrix = torch.FloatTensor(\n vocab_size, embedding_dim).normal_(\n embeddings_mean, embeddings_std)\n # Manually zero out the embedding of the padding token (0).\n embedding_matrix[0].fill_(0)\n # This starts from 1 because 0 is the padding token, which\n # we don't want to modify.\n for i in range(1, vocab_size):\n word = vocab.get_token_from_index(i)\n\n # If we don't have a pre-trained vector for this word,\n # we don't change the row and the word has random initialization.\n if word in glove_embeddings:\n embedding_matrix[i] = torch.FloatTensor(glove_embeddings[word])\n return embedding_matrix","def get_word_embeddings(self):\n embedding_index = {}\n with open('./glove/glove.6B.100d.txt', encoding=\"utf8\") as f:\n for line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embedding_index[word] = coefs\n return embedding_index","def save_embedding(emb, emb_dim, vocabs, save_dir, file_name):\n\tembedding = emb.weight.data.tolist()\n\n\tnum_vocab = len(embedding)\n\n\tvocab2emb = {}\n\tfor id in list(vocabs.index2word.keys())[:num_vocab]:\n\t\tvocab2emb[vocabs.index2word[id]] = embedding[id]\n\t\n\ttry:\n\t\tdel vocab2emb['<PAD>']\n\t\tnum_vocab-=1\n\texcept:\n\t\tpass\n\t\n\tpath = save_dir / (file_name + \".vec\")\n\twith path.open(\"w\") as ff:\n\t\tff.write(str(num_vocab) + \" \" + str(emb_dim) + \"\\n\")\n\t\tfor word, embed in vocab2emb.items():\n\t\t\tcontent = word + \" \" + \" \".join(map(str, embed)) + \"\\n\"\n\t\t\tff.write(content)","def _index(self, corpus):\n\n # Transform documents to embeddings vectors\n ids, dimensions, stream = self.embedder.model.index(corpus)\n\n # Load streamed embeddings back to memory\n embeddings = np.empty((len(ids), dimensions), dtype=np.float32)\n with open(stream, \"rb\") as queue:\n for x in range(embeddings.shape[0]):\n embeddings[x] = pickle.load(queue)\n\n # Remove temporary file\n os.remove(stream)\n\n all_text = []\n for para_id, text, _ in corpus:\n all_text.append([text, para_id])\n\n df = pd.DataFrame(all_text, columns=[\"text\", \"paragraph_id\"])\n\n embedding_path = os.path.join(\n self.index_path, self.embed_paths[\"embeddings\"])\n dataframe_path = os.path.join(\n self.index_path, self.embed_paths[\"dataframe\"])\n ids_path = os.path.join(self.index_path, self.embed_paths[\"ids\"])\n\n # Load new data\n if os.path.isfile(embedding_path) and (self.encoder_args[\"overwrite\"] is False):\n logger.info(f\"Loading new data from {embedding_path}\")\n\n # Load existing embeddings\n old_embeddings = np.load(embedding_path) # LOAD EMBEDDINGS\n # Remove embeddings with document id overlaps\n embeddings = np.vstack((old_embeddings, embeddings))\n\n # load IDs\n old_ids = [doc_id[:-1] for doc_id in open_txt(ids_path)]\n logger.debug(f\"New ID Length = {len(ids)}\")\n logger.debug(f\"Old ID Length = {len(old_ids)}\")\n # Remove document ids overlaps\n logger.debug(f\"New ID Length = {len(ids)}\")\n ids = old_ids + ids\n logger.debug(f\"Merged ID Length = {len(ids)}\")\n\n # Append new dataframe\n old_df = pd.read_csv(dataframe_path)\n df = pd.concat([old_df, df])\n\n # Store embeddings and document index\n # for future reference\n np.save(embedding_path, embeddings)\n with open(ids_path, \"w\") as fp:\n fp.writelines([i + \"\\n\" for i in ids])\n\n # Save data csv\n df.to_csv(dataframe_path, index=False)\n\n # Normalize embeddings\n self.embedder.normalize(embeddings)\n\n # Save embeddings metadata\n self.embedder.config[\"ids\"] = ids\n self.embedder.config[\"dimensions\"] = dimensions\n\n # Create embeddings index\n logger.info(f\"Creating embeddings and index\")\n self.embedder.embeddings = ANN.create(self.embedder.config)\n logger.info(f\"Created embeddings\")\n\n # Build the index\n self.embedder.embeddings.index(embeddings)\n logger.info(f\"Built the embeddings index\")","def load_model(self, file=FILENAME, dim=DIMENSION, normalize=False):\n print(\"Loading pretrained Glove vectors from file {}\".format(FILENAME))\n self.dimension = dim\n self.normalize = normalize\n with open(file, \"r\", encoding=\"utf-8\") as textfile:\n self.num_tokens = count_lines(textfile)\n self.tokens_arr = [\"\" for i in range(self.num_tokens)]\n self.embeddings_mat = np.zeros((self.num_tokens, self.dimension))\n\n for idx, line in enumerate(textfile):\n line = line.split()\n token = ''.join(line[:-self.dimension])\n self.tokens_arr[idx] = token\n self.token_to_idx[token] = idx \n vec = list(map(float, line[-self.dimension:]))\n if self.normalize: \n # normalize the vectors as they are put into the matrix\n vec = vec / np.linalg.norm(vec)\n self.embeddings_mat[idx] = vec \n if (idx+1) % 200000 == 0:\n print(\" --{}% loaded.\".format(round(idx/self.num_tokens*100, 2)))\n print(\"Finished loading Glove model. {} vectors loaded\".format(self.num_tokens))","def get_embeddings(emb_path, emb_length, vocab_size, embedding_type):\n print(\"Loading {} embeddings from file: {}...\".format(embedding_type, emb_path))\n\n emb_matrix = []\n str2id = {}\n idx = 0\n with open(emb_path, 'r') as fh:\n for line in tqdm(fh, total=vocab_size):\n line = line.lstrip().rstrip().split(\" \")\n word = line[0]\n vector = list(map(float, line[1:]))\n if emb_length != len(vector):\n raise Exception(\n \"{}: Expected vector of size {}, but got vector of size {}.\".format(idx, emb_length, len(vector)))\n emb_matrix.append(vector)\n str2id[word] = idx\n idx += 1\n\n emb_matrix = np.array(emb_matrix, dtype=np.float32)\n print(\"Loaded {} embedding matrix with shape {}.\".format(embedding_type, emb_matrix.shape))\n\n return emb_matrix, str2id","def build_vocab(path, fname):\r\n\twords = open(path, 'r', encoding='utf-8').read().split()\r\n\twordCount = Counter(words)\r\n\tif not os.path.exists(pm.vocab_path):\r\n\t\tos.makedirs(pm.vocab_path)\r\n\twith open(pm.vocab_path + fname, 'w', encoding='utf-8') as f:\r\n\t\tf.write(\"{}\\t1000000000\\n{}\\t1000000000\\n{}\\t1000000000\\n{}\\t1000000000\\n\".format(\"<PAD>\", \"<UNK>\", \"<SOS>\", \"<EOS>\"))\r\n\t\tfor word, count in wordCount.most_common(len(wordCount)):\r\n\t\t\tf.write(u\"{}\\t{}\\n\".format(word, count))","def load_vec(fname, vocab, binary = True):\n print(\" Loading word2vec...\")\n #w2v_cache = \"cache\\\\w2v\"\n #if os.path.isfile(w2v_cache):\n # return cPickle.load(open(w2v_cache,\"rb\"))\n\n mode = (\"rb\" if binary else \"r\")\n word_vecs = {}\n with open(fname, mode) as f:\n header = f.readline()\n vocab_size, layer1_size = map(int, header.split())\n binary_len = numpy.dtype('float32').itemsize * layer1_size\n\n def getline():\n if binary:\n return numpy.fromstring(f.read(binary_len), dtype='float32')\n else:\n return numpy.array(f.readline().split(), dtype='float32')\n\n for line in xrange(vocab_size):\n word = []\n while True:\n ch = f.read(1)\n if ch == ' ':\n word = ''.join(word)\n break\n if ch != '\\n':\n word.append(ch)\n if word in vocab:\n word_vecs[word] = getline()\n else:\n getline()\n print(\" Loaded word2vec...\")\n# cPickle.dump(word_vecs, open(w2v_cache, \"wb\"))\n return word_vecs","def read_parse_write(tokenizer: BertTokenizer, bert_client: BertClient, infile: str, outfile: str, mode) -> None:\n reader = Reader()\n insts = reader.read_txt(infile, -1)\n f = open(outfile, 'wb')\n all_vecs = []\n all_sents = []\n for inst in insts:\n all_sents.append(inst.input.words)\n for sent in tqdm(all_sents, desc=\"BERT encoding\"):\n word_piece_tokens, word_to_piece_index = bert_tokenize_words(tokenizer, sent, mode=mode)\n bert_vec =np.squeeze(bert_client.encode([word_piece_tokens], is_tokenized=True),\n axis=0)[1:-1, :] ## exclude the [CLS] and [SEP]\n bert_vec = bert_vec[word_to_piece_index, :]\n print(bert_vec.shape)\n all_vecs.append(bert_vec)\n\n print(\"Finishing embedding BERT sequences, saving the vector files.\")\n pickle.dump(all_vecs, f)\n f.close()","def index_embedding_words(embedding_file):\n words = set()\n with open(embedding_file, encoding='utf-8') as f:\n for line in f:\n w = Dictionary.normalize(line.rstrip().split(' ')[0])\n words.add(w)\n return words","def index_embedding_words(embedding_file):\n words = set()\n with open(embedding_file) as f:\n for line in f:\n w = Dictionary.normalize(line.rstrip().split(' ')[0])\n words.add(w)\n return words","def load_document_embeddings(path):\n embedding_dimension = 0\n \n # First pass to work out maximum topic ID to create numpy embeddings\n with open(path, 'rb') as avro_file:\n avro_reader = reader(avro_file)\n for document_embedding in avro_reader:\n topic_probs = document_embedding['topic_probs']\n \n for topic_prob in topic_probs:\n topic_id = topic_prob['topic_id']\n if topic_id + 1 > embedding_dimension:\n embedding_dimension = topic_id + 1\n \n # Second pass to actually store the embeddings\n x = []\n y = []\n \n with open(path, 'rb') as avro_file:\n avro_reader = reader(avro_file)\n for document_embedding in avro_reader:\n label = document_embedding['label']\n topic_probs = document_embedding['topic_probs']\n \n embedding = np.zeros(shape=embedding_dimension, dtype=np.float32)\n \n for topic_prob in topic_probs:\n topic_id = topic_prob['topic_id']\n prob = topic_prob['prob']\n embedding[topic_id] = prob\n \n x.append(embedding)\n y.append(label)\n \n return x, y","def load_kb_embeddings(path_to_folder):\n\n entity2idx = {}\n allowed_indices = set()\n with open(\"data/entity2id.filtered.txt\", 'r') as f:\n for l in f.readlines():\n k, v, idx = tuple(l.strip().split(\"\\t\"))\n entity2idx[k] = int(idx) + 3\n allowed_indices.add(int(v))\n\n embeddings = []\n with open(path_to_folder + \"/entity2vec.vec\", 'r') as f:\n idx = 0\n for line in f.readlines():\n if idx in allowed_indices:\n split = line.strip().split('\\t')\n embeddings.append([float(num) for num in split])\n idx += 1\n\n entity2idx[all_zeroes] = 0 # 0 is reserved for padding\n entity2idx[unknown_el] = 1 # 1 is reserved for OOV\n entity2idx[no_annotation] = 2 # 2 is reserved for no annotation tokens\n embedding_size = len(embeddings[0])\n vector_oov = 2 * 0.1 * np.random.rand(embedding_size) - 0.1\n vector_na = 2 * 0.1 * np.random.rand(embedding_size) - 0.1\n embeddings = np.asarray([[0.0]*embedding_size, vector_oov, vector_na] + embeddings, dtype='float32')\n\n print(\"KB embeddings loaded: {}\".format(embeddings.shape))\n assert len(entity2idx) == len(embeddings)\n\n return entity2idx, embeddings"],"string":"[\n \"def create_embedding_matrix(filepath, word_index, embedding_dim):\\n vocab_size = len(word_index) + 1 # Adding again 1 because of reserved 0 index\\n embedding_matrix = np.zeros((vocab_size, embedding_dim))\\n\\n with open(filepath) as f:\\n for line in f:\\n word, *vector = line.split()\\n if word in word_index:\\n idx = word_index[word] \\n embedding_matrix[idx] = np.array(\\n vector, dtype=np.float32)[:embedding_dim]\\n\\n return embedding_matrix\",\n \"def w2v_embedding(input_file, bin_file, output_file):\\n print(\\\"Loading the training corpus.\\\")\\n df = open(src_file_path, \\\"r\\\") # Open the text file stored at src_file_path\\n df = df.read() # Read the text file\\n tokens1 = word_tokenize(df) # Tokenize\\n token_list = []\\n print(\\\"Writing the bin file.\\\")\\n models = KeyedVectors.load_word2vec_format(bin_destination_file_path, binary=True) # Save bin format\\n print(\\\"Saving the word embeddings.\\\")\\n models.save_word2vec_format(txt_file_destination_path, binary=False) # Save the word vectors\\n \\n return txt_file_destination_path\",\n \"def getWordEmbeddingsMatrix(script_directory, embedding_file):\\n translator = str.maketrans('', '', string.punctuation)\\n all_words = []\\n print(\\\"Loading vocab from text files in:\\\")\\n for d in os.listdir(script_directory):\\n print(d)\\n for fname in os.listdir(\\\"%s/%s\\\" % (script_directory, d)):\\n with open(\\\"%s/%s/%s\\\" % (script_directory, d, fname), 'r') as f:\\n words = [w.translate(translator) for w in f.read().split() if w.translate(translator) != \\\"\\\"]\\n all_words.extend(words)\\n\\n model = KeyedVectors.load_word2vec_format(embedding_file, binary=True)\\n vocab = {\\\"PAD\\\" : 0, \\\"EOS\\\" : 1}\\n vocab.update({w : i + 2 for i,w in enumerate([w1 for w1 in set(all_words) if w1 in model]) })\\n inv_dict = vocab.keys()\\n ## Take a minute to load...\\n\\n vocab_size = len(inv_dict)\\n emb_size = 300 # or whatever the size of your embeddings\\n embeddings = np.zeros((vocab_size + 1, emb_size))\\n for k,v in vocab.items():\\n embeddings[v] = model[k]\\n vocab[\\\"UNK\\\"] = len(vocab.keys())\\n embeddings[vocab[\\\"UNK\\\"]] = np.ones(emb_size)\\n del model\\n ## Now we have a numpy matrix of embeddings...\\n # x_model = tf.placeholder(tf.int32, shape=[None, input_size])\\n # with tf.device(\\\"/cpu:0\\\"):\\n # embedded_x = tf.nn.embedding_lookup(embeddings, x_model)\\n return embeddings, vocab\",\n \"def make_embedding(path, words, indices):\\n #root = '/'.join(path.split('/')[0:-1])\\n #all_paths = [root+'/'+x for x in os.listdir(root)] #'/'.join(path.split('/')[0:-1]))\\n #for path in all_paths:\\n vec_path = 'data/'+path.split('/')[-1]+'_'+mode\\n print(vec_path)\\n if os.path.exists(vec_path+'.npy'):\\n np_vecs = np.load(vec_path+'.npy')\\n else:\\n words_len = len(words)\\n vecs = []\\n if mode == 'word':\\n f = load_model('wiki.en.bin')\\n for i, w in enumerate(words):\\n if mode == 'word':\\n vec = f.get_word_vector(w)\\n else:\\n vec = eye[indices[w]]\\n vecs.append(vec) \\n if i % 10000 == 0:\\n print(\\\"{} / {}\\\".format(i, words_len))\\n np_vecs = np.asarray(vecs, dtype=np.int8)\\n np.save(vec_path, np_vecs)\\n return np_vecs\",\n \"def embedding_matrix(path_to_embedding : str,embedding_dim: int, word_index : dict) -> np.array:\\n embeddings_index = {}\\n f = open(path_to_embedding, encoding='utf-8')\\n for line in f:\\n try:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n except:\\n pass\\n \\n f.close()\\n\\n embedding_matrix = np.zeros((len(word_index) + 1,embedding_dim))\\n found = 0\\n for word, i in word_index.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n # words not found in embedding index will be all-zeros.\\n found +=1\\n embedding_matrix[i] = embedding_vector\\n\\n return embedding_matrix\",\n \"def load_embedding_matrix(filepath, word2vec_format = False):\\n if word2vec_format:\\n return gensim.models.KeyedVectors.load_word2vec_format(filepath, binary=True)\\n else: #own pretrained model\\n return gensim.models.Word2Vec.load(filepath)\",\n \"def save_embeddings(self, filename, binary=True):\\n with open(filename, \\\"wb\\\", encoding=\\\"utf8\\\") as fout:\\n fout.write(\\\"%s %s\\\\n\\\" % self._vecs.shape)\\n # store in sorted order: most frequent words at the top\\n for i, word in enumerate(self._words):\\n row = self._vecs[i]\\n if binary:\\n fout.write(word + b\\\" \\\" + row.tostring())\\n else:\\n fout.write(\\n \\\"%s %s\\\\n\\\" % (word, \\\" \\\".join(\\\"%f\\\" % val for val in row))\\n )\",\n \"def load_embeddings(filename):\\n labels = []\\n rows = []\\n with open(filename, encoding='utf-8') as infile:\\n for i, line in enumerate(infile):\\n items = line.rstrip().split(' ')\\n if len(items) == 2:\\n # This is a header row giving the shape of the matrix\\n continue\\n labels.append(items[0])\\n values = np.array([float(x) for x in items[1:]], 'f')\\n rows.append(values)\\n\\n arr = np.vstack(rows)\\n return pd.DataFrame(arr, index=labels, dtype='f')\",\n \"def load_embeddings(filename):\\n count = 0\\n matrix = []\\n word_map = {}\\n with open(filename, encoding=\\\"utf8\\\") as f:\\n # with open(filename) as f:\\n for line in f:\\n line = line.strip()\\n items = line.split()\\n word = items[0]\\n rest = items[1:]\\n # print(\\\"word:\\\", word)\\n word_map[word] = count\\n count += 1\\n\\n rest = list(map(float, rest))\\n matrix.append(rest)\\n matrix = np.array(matrix)\\n return word_map, matrix\",\n \"def gen_embedding(path):\\r\\n word_emb = {}\\r\\n with open(path, encoding='utf-8') as f:\\r\\n for line in tqdm(f):\\r\\n values = line.split()\\r\\n word_emb[values[0]] = np.asarray(values[1:], dtype='float32')\\r\\n return word_emb\",\n \"def prepare_embedding_matrix(emb_data_path, emb_size, vocab, random_seed=1984):\\n vocab_size = len(vocab)\\n mime = mimetypes.guess_type(emb_data_path)\\n np.random.seed(random_seed)\\n # in case the file type is text - we'll treat it as such\\n if mime[0] is not None:\\n vectors = {}\\n with open(emb_data_path, 'rb') as f:\\n for l in f:\\n line = l.decode().split()\\n word = line[0]\\n if word in vocab:\\n vect = np.array(line[1:]).astype(np.float)\\n vectors[word] = vect\\n embeddings = np.zeros((vocab_size, emb_size))\\n words_found = 0\\n for i, word in enumerate(vocab):\\n try:\\n embeddings[i] = vectors[word]\\n words_found += 1\\n except KeyError:\\n embeddings[i] = np.random.normal(scale=0.6, size=(emb_size,))\\n # in case the file type is not text - we'll assume it is a Gensim model, and we'll treat it as such\\n else:\\n emb_model = gensim.models.Word2Vec.load(emb_data_path)\\n embeddings = np.zeros((vocab_size, emb_size))\\n words_found = 0\\n for i, word in enumerate(vocab):\\n try:\\n embeddings[i] = emb_model.wv[word]\\n words_found += 1\\n except KeyError:\\n embeddings[i] = np.random.normal(scale=0.6, size=(emb_size,))\\n # in both options (text file of a Gensim model, we do the next 2 steps\\n return embeddings\",\n \"def load_word2vect(self, file_path):\\n self.embeddings = []\\n self.word_to_idx = {'<pad>' : 0}\\n self.vocab = ['<pad>']\\n\\n model = w2v.load(file_path)\\n self.embedding_size = model.vectors.shape[1]\\n pad_embedding = np.zeros(self.embedding_size, \\\"float32\\\")\\n self.embeddings.append(pad_embedding)\\n\\n train_words_set = set([word for text in self.train_data for word in\\n text[1].split(\\\" \\\")])\\n\\n for w in model.vocab:\\n if w in train_words_set:\\n self.word_to_idx[w] = len(self.vocab)\\n self.vocab.append(w)\\n self.embeddings.append(model[w])\\n\\n del model\",\n \"def load_word_vectors(filepath, word_index, vector_size):\\n embedding_matrix = np.zeros((len(word_index) + 1, vector_size))\\n\\n fin = io.open(filepath, \\\"r\\\", encoding=\\\"utf-8\\\", newline=\\\"\\\\n\\\", errors=\\\"ignore\\\")\\n n, d = map(int, fin.readline().split())\\n\\n for line in fin:\\n tokens = line.rstrip().split(\\\" \\\")\\n if tokens[0] in word_index:\\n w = word_index[tokens[0]]\\n embedding_matrix[w] = np.fromiter(map(float, tokens[1:]), \\\"float\\\")\\n\\n return embedding_matrix\",\n \"def senna(vector_f='embeddings.txt', words_f ='words.lst', out_f='senna.pkl'):\\n with open(DATA_DIR + words_f, 'rb') as f:\\n words = [line.strip() for line in f]\\n M = np.loadtxt(DATA_DIR + vector_f)\\n print \\\"Found {0} words\\\".format(len(words))\\n print \\\"Found {0}x{1} embedding matrix\\\".format(*M.shape)\\n with open(DATA_DIR + out_f, 'wb') as f:\\n cPickle.dump((words, M), f)\",\n \"def load_emb_matrix(path):\\n embedding_matrix = np.load(path + '/emb_matrix.npy')\\n print('Embedding matrix load from local sys successful\\\\n')\\n print('Denormalized Shape: ({},{})'.format(np.shape(embedding_matrix)[0], np.shape(embedding_matrix)[1]))\\n return embedding_matrix\",\n \"def make_embeddings(self):\\n\\t\\tprint(\\\"Presetting embedding weights\\\")\\n\\t\\t\\t\\n\\t\\tnp.random.seed(0)\\n\\t\\tweights = np.random.uniform(low = -0.05, high = 0.05, size = (self.FREQCAP, self.EMB_SIZE))\\n\\t\\t\\n\\t\\tcounter = 0\\n\\n\\t\\twords = []\\n\\t\\tweights_tmp = []\\n\\n\\t\\twith open(self.embeddingpath) as handle:\\n\\t\\t\\tfor i, line in enumerate(handle):\\n\\t\\t\\t\\ttmp = line.strip()\\n\\t\\t\\t\\tif len(tmp) > 0:\\n\\t\\t\\t\\t\\tsplit = tmp.split(\\\" \\\")\\n\\t\\t\\t\\t\\tif split[0] in self.worddict and len(split[1:]) == 300:\\n\\t\\t\\t\\t\\t\\twords.append(split[0])\\n\\t\\t\\t\\t\\t\\tweights_tmp.append([float(a) for a in split[1:]])\\n\\t\\t\\n\\t\\tweights_tmp = np.array(weights_tmp)\\n\\n\\t\\tfor word, column in zip(words, weights_tmp):\\n\\t\\t\\tif self.worddict[word] < self.FREQCAP:\\n\\t\\t\\t\\tcounter += 1\\n\\t\\t\\t\\tweights[self.worddict[word],:] = column\\n\\t\\t\\n\\t\\tprint(\\\"Set\\\", counter, \\\"of\\\", weights.shape[0], \\\"columns\\\")\\n\\t\\t\\n\\t\\tif self.EMB_SIZE < weights.shape[-1]:\\n\\t\\t\\tprint(\\\"Reducing dimensionality to\\\", self.EMB_SIZE)\\n\\t\\t\\tpca = PCA(self.EMB_SIZE)\\n\\t\\t\\tweights = pca.fit_transform(weights)\\n\\t\\t\\n\\t\\tself.embeddings = [weights]\",\n \"def load_embeddings(emb_file, oovs=[], pads=[], sep=' ', lower=False, case_dim=True):\\n word2emb = {}\\n word2idx = {}\\n\\n # read and store all word vectors\\n for line in open(emb_file, errors = 'ignore', encoding = 'utf-8'):\\n try:\\n fields = line.strip().split(sep)\\n word = fields[0]\\n vec = np.asarray(fields[1:], dtype='float32')\\n if case_dim:\\n is_upper = float(word[0].isupper())\\n vec = np.insert(vec, 0, is_upper, axis=0)\\n if lower:\\n word = word.lower()\\n word2emb[word] = vec\\n if word not in word2idx:\\n word2idx[word] = len(word2idx)\\n except Exception as e:\\n print('[WARNING] Exception in `load_embeddings`:', e)\\n\\n # get dimensions from the last vector added\\n emb_dim = word2emb[word].shape[0]\\n\\n # add custom embeddings for special characters\\n mu = 0\\n sigma = 0.01\\n\\n for word in pads:\\n if word not in word2idx:\\n if case_dim:\\n vec = npr.normal(mu, sigma, emb_dim-1)\\n vec = np.insert(vec, 0, 0., axis=0)\\n else:\\n vec = npr.normal(mu, sigma, emb_dim)\\n word2emb[word] = vec\\n word2idx[word] = len(word2idx)\\n else:\\n print('[WARNING] Padding item ' + word + ' has an embedding vector')\\n\\n for word in oovs:\\n if word not in word2idx:\\n if case_dim:\\n vec = npr.normal(mu, sigma, emb_dim-1)\\n is_upper = float(word[0].isupper())\\n vec = np.insert(vec, 0, is_upper, axis=0)\\n else:\\n vec = npr.normal(mu, sigma, emb_dim)\\n word2emb[word] = vec\\n word2idx[word] = len(word2idx)\\n else:\\n print('[WARNING] OOV alias ' + word + ' has an embedding vector')\\n\\n # create an embedding matrix\\n vocab_size = len(word2emb)\\n emb_matrix = np.zeros((vocab_size, emb_dim))\\n for word, idx in word2idx.items():\\n if word in word2emb:\\n vec = word2emb[word]\\n if vec is not None and vec.shape[0] == emb_dim:\\n emb_matrix[idx] = np.asarray(vec)\\n\\n # print feedback data and return mappings\\n print('[INFO] Embedding vocabulary:', emb_matrix.shape[0], '(lowercase: ' + str(lower) + ')')\\n print('[INFO] OOV aliases:', oovs)\\n print('[INFO] Padding items:', pads)\\n print('[INFO] Embedding dimensions:', emb_dim, '(extra case dimension: ' + str(case_dim) + ')')\\n return word2idx, np.asarray(emb_matrix), emb_dim\",\n \"def load_bin_vec(filename):\\n w2v = {}\\n with open(filename, 'r') as f:\\n header = f.readline()\\n vocab_size, emb_size = map(int, header.split())\\n for line in f:\\n cline = line.split()\\n w2v[cline[0]] = np.array(cline[1:], dtype=np.float64)\\n return w2v, emb_size, vocab_size\",\n \"def gen_embeddings(vocab, file, emb_size, emb_dim):\\n # embeddings = np.random.randn(vocab.n_words, emb_size) * 0.01\\n embeddings = np.zeros((vocab.n_words, emb_size))\\n print('Embeddings: %d x %d' % (vocab.n_words, emb_size))\\n if file is not None:\\n print('Loading embedding file: %s' % file)\\n pre_trained = 0\\n for line in open(file).readlines():\\n sp = line.split()\\n if(len(sp) == emb_dim + 1):\\n if sp[0] in vocab.word2index:\\n pre_trained += 1\\n embeddings[vocab.word2index[sp[0]]] = [float(x) for x in sp[1:]]\\n else:\\n print(sp[0])\\n print('Pre-trained: %d (%.2f%%)' % (pre_trained, pre_trained * 100.0 / vocab.n_words))\\n return embeddings\",\n \"def write_embeddings_to_file(self):\\n modes = [self.generator, self.discriminator]\\n for i in range(2):\\n embedding_matrix = modes[i].embedding_matrix\\n embedding_matrix = embedding_matrix.detach().to('cpu').numpy()\\n index = np.array(range(self.n_node)).reshape(-1, 1)\\n embedding_matrix = np.hstack([index, embedding_matrix])\\n embedding_list = embedding_matrix.tolist()\\n embedding_str = [str(int(emb[0])) + \\\"\\\\t\\\" + \\\"\\\\t\\\".join([str(x) for x in emb[1:]]) + \\\"\\\\n\\\" \\n for emb in embedding_list]\\n with open(config.emb_filenames[i], \\\"w+\\\") as f:\\n lines = [str(self.n_node) + \\\"\\\\t\\\" + str(config.n_emb) + \\\"\\\\n\\\"] + embedding_str\\n f.writelines(lines)\",\n \"def training_examples_to_vec(test_file, embeddings_file, num_words, word_dim):\\n x = []\\n ignore_words = stopwords.words('english')\\n lemmatizer = WordNetLemmatizer()\\n stemmer = SnowballStemmer('english')\\n word_idx, word_vectors = hf.create_indices_for_vectors(embeddings_file, return_vectors=True)\\n with open(test_file, 'r') as f:\\n for line in f:\\n stemmedWords = set([])\\n long_string = line.split(' ')\\n total_words = int(len(long_string) / 2)\\n total_example_vec = np.empty([num_words, word_dim], dtype=np.float32)\\n if total_words - 1 <= num_words:\\n continue\\n count = 0\\n\\n for i in range(1, total_words):\\n word = long_string[2 * i].split(\\\"'\\\")[0]\\n\\n if (word in ignore_words) or (len(word) <= 3):\\n continue\\n\\n if not word.isalpha():\\n continue\\n\\n try:\\n stem = stemmer.stem(word)\\n lemma = lemmatizer.lemmatize(word)\\n except UnicodeDecodeError:\\n continue\\n\\n if stem in stemmedWords:\\n continue\\n\\n try:\\n idx_num = word_idx[word]\\n except KeyError:\\n\\n try:\\n idx_num = word_idx[lemma]\\n except KeyError:\\n\\n try:\\n idx_num = word_idx[stem]\\n except KeyError:\\n continue\\n\\n word_vec = word_vectors[idx_num]\\n total_example_vec[count] = word_vec\\n stemmedWords.add(stem)\\n count += 1\\n if count >= num_words:\\n break\\n x.append(total_example_vec)\\n return x\",\n \"def make_embedding_matrix(docs, size, min_count = 5, window = 5, n_iter = 5, savename = None, workers = 3):\\n\\n print('Starting the embedding generation')\\n t0 = time.time()\\n model = gensim.models.Word2Vec(docs, min_count=min_count, window = window,\\n size = size, iter = n_iter, workers = workers)\\n t1 = time.time()\\n print('All done, total time %s' % (t1-t0))\\n \\n if savename is not None:\\n model.save(savename)\\n \\n return model\",\n \"def load_bin_vec(self, fname, vocab):\\n word_vecs = {}\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n print header\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch)\\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32')\\n # logger.info(word_vecs[word])\\n else:\\n f.read(binary_len)\\n # logger.info(\\\"num words already in word2vec: \\\" + str(len(word_vecs)))\\n return word_vecs\",\n \"def load_word2vec_matrix(vocab_size,\\n embedding_size,\\n word2vec_path):\\n if not os.path.isfile(word2vec_path):\\n raise IOError(\\\"✘ The word2vec file doesn't exist. \\\"\\n \\\"Please use function <create_vocab_size(embedding_size)\\\"\\n \\\"> to create it!\\\")\\n\\n model = word2vec.KeyedVectors.load_word2vec_format(word2vec_path,\\n binary=True,\\n limit=400000)\\n\\n vocab = dict([(k, v.index) for k, v in model.wv.vocab.items()])\\n vector = np.zeros([vocab_size, embedding_size])\\n for key, value in vocab.items():\\n if key is not None:\\n vector[value] = model[key]\\n return vector\",\n \"def load_bin_embeddings(path, params):\\n model = load_fasttext_model(path)\\n assert model.get_dimension() == params.emb_dim\\n words = model.get_labels()\\n logger.info(\\\"Loaded binary model from %s\\\" % path)\\n\\n # compute new vocabulary / embeddings\\n embeddings = np.concatenate([model.get_word_vector(w)[None] for w in words], 0)\\n embeddings = torch.from_numpy(embeddings).float()\\n word2id = {w: i for i, w in enumerate(words)}\\n logger.info(\\\"Generated embeddings for %i words.\\\" % len(words))\\n\\n assert embeddings.size() == (len(word2id), params.emb_dim)\\n return word2id, embeddings\",\n \"def load_bin_vec(fname, vocab):\\n word_vecs = {}\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word).lower()\\n break\\n if ch != '\\\\n':\\n word.append(ch) \\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \\n else:\\n f.read(binary_len)\\n return word_vecs\",\n \"def load_bin_vec(fname, vocab):\\n word_vecs = {}\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch) \\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \\n else:\\n f.read(binary_len)\\n return word_vecs\",\n \"def convert_to_mindrecord(embed_size, data_path, proprocess_path, glove_path):\\n\\n num_shard = 4\\n train_features, train_labels, test_features, test_labels, weight_np, _ = \\\\\\n preprocess(data_path, glove_path, embed_size)\\n np.savetxt(os.path.join(proprocess_path, 'weight.txt'), weight_np)\\n\\n print(\\\"train_features.shape:\\\", train_features.shape, \\\"train_labels.shape:\\\", train_labels.shape, \\\"weight_np.shape:\\\",\\n weight_np.shape, \\\"type:\\\", train_labels.dtype)\\n # write mindrecord\\n schema_json = {\\\"id\\\": {\\\"type\\\": \\\"int32\\\"},\\n \\\"label\\\": {\\\"type\\\": \\\"int32\\\"},\\n \\\"feature\\\": {\\\"type\\\": \\\"int32\\\", \\\"shape\\\": [-1]}}\\n\\n writer = FileWriter(os.path.join(proprocess_path, 'aclImdb_train.mindrecord'), num_shard)\\n data = get_imdb_data(train_labels, train_features)\\n writer.add_schema(schema_json, \\\"nlp_schema\\\")\\n writer.add_index([\\\"id\\\", \\\"label\\\"])\\n writer.write_raw_data(data)\\n writer.commit()\\n\\n writer = FileWriter(os.path.join(proprocess_path, 'aclImdb_test.mindrecord'), num_shard)\\n data = get_imdb_data(test_labels, test_features)\\n writer.add_schema(schema_json, \\\"nlp_schema\\\")\\n writer.add_index([\\\"id\\\", \\\"label\\\"])\\n writer.write_raw_data(data)\\n writer.commit()\",\n \"def load_glove_matrix(w2i, glove_file):\\n f = open(glove_file, 'rb')\\n vocab_size = len(w2i)\\n embedding_dim = 0\\n\\n # Load all glove vectors, put them in a matrix\\n for line in f:\\n split_line = line.split()\\n word = split_line[0]\\n embedding = np.array([float(val) for val in split_line[1:]])\\n if embedding_dim == 0:\\n embedding_dim = len(embedding)\\n embeddings_matrix = np.zeros((vocab_size, embedding_dim))\\n\\n # Use only words that are in the corpus\\n if word in w2i:\\n embeddings_matrix[w2i[word], :] = embedding\\n\\n # Replace zero vectors with random numbers\\n for i, row in enumerate(embeddings_matrix):\\n if not (False in [n == 0 for n in row]):\\n vec = np.random.rand(1, embedding_dim)\\n embeddings_matrix[i, :] = vec / np.linalg.norm(vec)\\n return embeddings_matrix\",\n \"def load_bin_vec(fname, vocab):\\n word_vecs = {}\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch) \\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \\n else:\\n f.read(binary_len)\\n return word_vecs\",\n \"def load_bin_vec(fname, vocab):\\n word_vecs = {}\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch) \\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \\n else:\\n f.read(binary_len)\\n return word_vecs\",\n \"def loadw2v(embfile, embsize, myzipfile=None, maxvoc=None):\\n word_to_ix = {}\\n word_to_ix[constants.PAD_ITEM] = 0\\n word_to_ix[constants.UNK_ITEM] = 1\\n # fill padding word with zeros\\n model = [[0.]*embsize]\\n # fill unk word with random numbers\\n model.append(np.random.normal(0,0.15,size=embsize).tolist())\\n if myzipfile != None:\\n zip = zipfile.ZipFile(myzipfile, 'r')\\n f = zip.read(embfile).split(\\\"\\\\n\\\")\\n else:\\n #f = open(embfile, 'r')\\n f = codecs.open(embfile, \\\"r\\\", \\\"utf-8\\\")\\n ix = 2\\n for line in f:\\n if maxvoc!=None:\\n if ix >= maxvoc:\\n break\\n splitLine = line.split()\\n if(len(splitLine)>embsize+1):\\n phrase_lst = splitLine[:-embsize]\\n word = ' '.join(phrase_lst)\\n embedding = [float(val) for val in splitLine[-embsize:]]\\n word_to_ix[word] = ix\\n model.append(embedding)\\n ix += 1\\n elif(len(splitLine)>2):\\n word = splitLine[0]\\n embedding = [float(val) for val in splitLine[1:]]\\n word_to_ix[word]=ix\\n model.append(embedding)\\n ix += 1\\n else:\\n print(line)\\n print(\\\"%d words loaded!\\\" % len(model))\\n return word_to_ix, model\",\n \"def init_word_embeddings(session, model, embeddings_file):\\n # Create word embedding array from word2vec file\\n vocab_size = FLAGS.vocab_size\\n embeddings = []\\n with tf.gfile.Open(embeddings_file) as f:\\n i = 0\\n while i < vocab_size:\\n numbers = f.readline().split()\\n if len(numbers) > 0:\\n embeddings.append([float(n) for n in numbers])\\n i += 1\\n else:\\n break # Last line of embeddings file is empty\\n\\n # Eliminate the random word embeddings and introduce word2vec to the realm of variable scopes.\\n # The victims will be:\\n # \\\"embedding_attention_seq2seq/RNN/EmbeddingWrapper/embedding\\\"\\n # \\\"embedding_attention_seq2seq/embedding_attention_decoder/embedding\\\"\\n np_embeddings = np.array(embeddings)\\n feed_dict = {model.word2vec_placeholder: np_embeddings}\\n session.run(model.word2vec_assign_encoder_op, feed_dict=feed_dict)\\n session.run(model.word2vec_assign_decoder_op, feed_dict=feed_dict)\",\n \"def load_bin_vec(fname, vocab):\\n word_vecs = {}\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch) \\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \\n else:\\n f.read(binary_len)\\n return word_vecs\",\n \"def load_bin_vec(fname, vocab):\\n word_vecs = {}\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n # print(vocab_size)\\n for line in range(vocab_size):\\n # print(line)\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch)\\n # print(word)\\n if word in vocab:\\n # print(word)\\n word_vecs[word] = np.frombuffer(f.read(binary_len), dtype='float32')\\n else:\\n f.read(binary_len)\\n\\n return word_vecs\",\n \"def load_embedding(self, glove_dir='glove.6B/'):\\n\\n f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'))\\n for line in f:\\n values = line.split()\\n word = values[0]\\n self.embeddings_index[word] = np.asarray(values[1:], dtype='float32')\\n f.close()\",\n \"def save_bin(words,data,fname):\\n\\n out=open(fname,\\\"wb\\\")\\n\\n rows,dims=data.shape\\n out.write(\\\"{} {}\\\\n\\\".format(rows,dims).encode(\\\"utf-8\\\"))\\n counter=0\\n\\n for i,w in enumerate(words):\\n out.write(w.encode(\\\"utf-8\\\"))\\n out.write(\\\" \\\".encode(\\\"utf-8\\\"))\\n out.write(struct.pack(\\\"{}f\\\".format(dims),*data[i,:]))\\n counter+=1\\n \\n out.close()\\n print(\\\"Model saved to\\\",fname,file=sys.stderr)\",\n \"def load_bin_vec(fname, vocab):\\n word_vecs = {}\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch)\\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32') \\n else:\\n f.read(binary_len)\\n cPickle.dump(word_vecs, open(\\\"./data/word_vecs.pkl\\\", \\\"w\\\"))\\n return word_vecs\",\n \"def buildBTree(T, file):\\r\\n for line in file:\\r\\n word_line = line.split(' ')\\r\\n word = word_line[0]\\r\\n embedding = word_line[1:]\\r\\n embedding = [float(i) for i in embedding]\\r\\n if word[0].isalpha():\\r\\n word_emb_object = WordEmbedding.WordEmbedding(word, embedding)\\r\\n insertElement(T, word_emb_object)\\r\\n return T\",\n \"def load_embeddings(filepath, vocabulary, retain):\\n \\n word2index = dict()\\n word_vectors = list()\\n\\n def add_entry(word, vector):\\n word2index[word] = len(word2index)\\n word_vectors.append(vector)\\n\\n model = gensim.models.KeyedVectors.load(filepath)\\n\\n # adding special tokens <FIL>, <UNK> and <NUM>\\n dim = model.vector_size\\n add_entry('<fil>', np.zeros((dim,)))\\n for special in ['<unk>', '<num>']:\\n vector = np.random.uniform(-0.025, 0.025, (dim,))\\n add_entry(special, vector)\\n\\n if retain:\\n for word, _ in model.vocab.items():\\n add_entry(word, model[word])\\n else:\\n for word in vocabulary:\\n if word in model:\\n add_entry(word, model[word])\\n\\n vocabulary = vocabulary.intersection(word2index.keys())\\n return word2index, np.asarray(word_vectors)\",\n \"def load_embeddings(embedding_path):\\n print('loading word embeddings from %s' % embedding_path)\\n weight_vectors = []\\n word_idx = {}\\n with codecs.open(embedding_path, encoding='utf-8') as f:\\n for line in f:\\n word, vec = line.split(u' ', 1)\\n word_idx[word] = len(weight_vectors)\\n weight_vectors.append(np.array(vec.split(), dtype=np.float32))\\n # Annoying implementation detail; '(' and ')' are replaced by '-LRB-' and\\n # '-RRB-' respectively in the parse-trees.\\n word_idx[u'-LRB-'] = word_idx.pop(u'(')\\n word_idx[u'-RRB-'] = word_idx.pop(u')')\\n # Random embedding vector for unknown words.\\n weight_vectors.append(np.random.uniform(\\n -0.05, 0.05, weight_vectors[0].shape).astype(np.float32))\\n return np.stack(weight_vectors), word_idx\",\n \"def load_embedding_file(self):\\n if self.language == 'en':\\n embed_file_dir = self.embedding_path\\n wv = KeyedVectors.load_word2vec_format(embed_file_dir, binary=True)\\n self.pretrained_embedding = {}\\n for word in wv.vocab.keys():\\n normalized_word = normalization.process(self.language.upper(), word, letters_to_keep='', letters_to_remove='',\\n lowercase=True, remove_repetitions_count=-1, remove_punct=True,\\n remove_digits=True, remove_vowels=False, remove_diacritics=True,\\n remove_spaces=False, remove_apostrophe=True, copy_through=False,\\n keep_romanized_text=False)\\n self.pretrained_embedding[normalized_word] = wv[word]\\n self.embed_dim = 300\\n\\n else:\\n embed_file_dir = self.embedding_path\\n fin = open(embed_file_dir, 'r', encoding='utf-8', newline='\\\\n', errors='ignore')\\n data = {}\\n for line in fin:\\n if len(line.split()) == 2: # header\\n continue\\n tokens = line.rstrip().split(' ')\\n word = tokens[0]\\n normalized_word = normalization.process(self.language.upper(), word, letters_to_keep='', letters_to_remove='',\\n lowercase=True, remove_repetitions_count=-1, remove_punct=True,\\n remove_digits=True, remove_vowels=False, remove_diacritics=True,\\n remove_spaces=False, remove_apostrophe=True, copy_through=False,\\n keep_romanized_text=False)\\n data[normalized_word] = np.array(tokens[1:])\\n self.pretrained_embedding = data\\n self.embed_dim = 300\",\n \"def dep_w2v(data_fname='deps.words', out_fname='depw2v.pkl'):\\n M = np.loadtxt(DATA_DIR + data_fname, converters={0: lambda x: 0})\\n M = M[:, 1:]\\n print \\\"Loaded {0}x{1} word vector matrix\\\".format(*M.shape)\\n with open(DATA_DIR + data_fname, 'rb') as f:\\n words = [line.split()[0] for line in f]\\n with open(DATA_DIR + out_fname, 'wb') as f:\\n cPickle.dump((words, M), f)\",\n \"def load_embeddings(path):\\r\\n\\r\\n embeds = dict() # dictionary mapping words to vectors\\r\\n for line in open(path, encoding='utf-8'):\\r\\n row = line.strip().split('\\\\t')\\r\\n embeds[row[0]] = np.array(row[1:], dtype=np.float32)\\r\\n\\r\\n embeddings_dim = embeds[list(embeds)[0]].shape[0]\\r\\n\\r\\n return embeds, embeddings_dim\",\n \"def write_matrix_to_binary(file_name, val):\\n with open(file_name, 'wb') as file:\\n nrow = val.shape[0]\\n ncol = val.shape[1]\\n file.write(int32_to_bytes(nrow) + int32_to_bytes(ncol) + val.astype(float).tobytes(order='C'))\",\n \"def load_data_and_embedding():\\n\\n # Load data\\n df_data = pd.read_csv('../new_data/train_ids_and_labels_1400.txt',nrows=10000)\\n y = df_data['class'] - 1 # class (0 ~ 18)\\n X = df_data.drop(['class'], axis=1).values\\n\\n # Transform to binary class matrix\\n y = to_categorical(y.values)\\n\\n # Randomly shuffle data\\n np.random.seed(10)\\n\\n shuffle_indices = np.random.permutation(range(len(y)))\\n X_shuffled = X[shuffle_indices]\\n y_shuffled = y[shuffle_indices]\\n\\n # Split to train/test set\\n # TODO: This is very crude, should use cross validation\\n val_sample_index = -1 * int(0.2 * len(y))\\n X_train, X_val = X_shuffled[:val_sample_index], X_shuffled[val_sample_index:]\\n y_train, y_val = y_shuffled[:val_sample_index], y_shuffled[val_sample_index:]\\n\\n del df_data, X, y, X_shuffled, y_shuffled\\n\\n embedding_matrix = np.load(\\\"../embedding/word-embedding-200d-mc5.npy\\\")\\n\\n return X_train, y_train, X_val, y_val,embedding_matrix\",\n \"def generate_embedding_matrix(self):\\n # get all the embeddings\\n all_embs = np.stack(list(self.embeddings.values()))\\n\\n # mean and standard deviation of the embedding values\\n emb_mean, emb_std = all_embs.mean(), all_embs.std()\\n\\n # Find the number of words the the train set\\n word_index = self.tokenizer.word_index\\n rows = min(self.max_features, len(word_index))\\n\\n # create embeddings for each word by sampling from a normal distribtion\\n # with parameters calculated above.\\n embedding_matrix = np.random.normal(emb_mean, emb_std, (rows + 1, self.embed_size))\\n\\n for word, i in word_index.items():\\n # TODO: replace this with stop words and frequency instead\\n if i >= self.max_features:\\n continue\\n\\n embedding_vector = self.embeddings.get(word)\\n\\n # if word is found in the embeddings used\\n if embedding_vector is not None:\\n # replace row of embeddings matrix with trained embeddings vector\\n embedding_matrix[i] = embedding_vector\\n\\n return embedding_matrix\",\n \"def get_google_word2vec_W(fname, vocab, vocab_size=1000000, index_from=3):\\n f = open(fname, 'rb')\\n header = f.readline()\\n vocab1_size, embedding_dim = list(map(int, header.split()))\\n binary_len = np.dtype('float32').itemsize * embedding_dim\\n vocab_size = min(len(vocab) + index_from, vocab_size)\\n W = np.zeros((vocab_size, embedding_dim))\\n\\n found_words = {}\\n for i, line in enumerate(range(vocab1_size)):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch)\\n if word in vocab:\\n wrd_id = vocab[word] + index_from\\n if wrd_id < vocab_size:\\n W[wrd_id] = np.fromstring(\\n f.read(binary_len), dtype='float32')\\n found_words[wrd_id] = 1\\n else:\\n f.read(binary_len)\\n\\n cnt = 0\\n for wrd_id in range(vocab_size):\\n if wrd_id not in found_words:\\n W[wrd_id] = np.random.uniform(-0.25, 0.25, embedding_dim)\\n cnt += 1\\n assert cnt + len(found_words) == vocab_size\\n\\n f.close()\\n\\n return W, embedding_dim, vocab_size\",\n \"def _load_bin_vec(fname, vocab):\\n print 'load bin...'\\n word_vecs = {}\\n cnt = 0\\n\\n with open(fname, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n print 'embedding vocab size: %d , embedding vector size: %d'%(vocab_size,layer1_size)\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch)\\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32')\\n else:\\n f.read(binary_len)\\n cnt +=1\\n if cnt%10000 == 0:\\n \\tprint '%d lines...'%cnt\\n return (word_vecs, layer1_size)\",\n \"def get_word_embedding(counter, emb_file, emb_size, vocab_size, vec_size, vocab_file):\\n print(\\\"Generating word embedding...\\\")\\n # load word embeddings\\n embedding_dict = {}\\n with open(emb_file, \\\"r\\\", encoding=\\\"utf-8\\\") as fh:\\n for line in tqdm(fh, total=emb_size):\\n array = line.split()\\n word = \\\"\\\".join(array[0:-vec_size])\\n vector = list(map(float, array[-vec_size:]))\\n embedding_dict[word] = vector\\n\\n TRANSLATE = {\\n \\\"-lsb-\\\": \\\"[\\\", \\\"-rsb-\\\": \\\"]\\\", \\\"-lrb-\\\": \\\"(\\\", \\\"-rrb-\\\": \\\")\\\", \\\"-lcb-\\\": \\\"{\\\",\\n \\\"-rcb-\\\": \\\"}\\\", \\\"-LSB-\\\": \\\"[\\\", \\\"-RSB-\\\": \\\"]\\\", \\\"-LRB-\\\": \\\"(\\\", \\\"-RRB-\\\": \\\")\\\",\\n \\\"-LCB-\\\": \\\"{\\\", \\\"-RCB-\\\": \\\"}\\\"\\n }\\n SPECIAL_TOKENS = [\\\"<NULL>\\\", \\\"<UNK>\\\", \\\"<S>\\\", \\\"</S>\\\"]\\n words = list(map(lambda x: x[0], sorted(counter.items(), key=lambda x: x[1], reverse=True)))\\n words = SPECIAL_TOKENS + words\\n if vocab_size > 0:\\n words = words[:vocab_size]\\n with open(vocab_file, 'w') as f:\\n f.write('\\\\n'.join(words[1:]))\\n embedding = np.random.normal(scale=0.1, size=(len(words), vec_size))\\n word2idx_dict = {}\\n unknown_count = 0\\n for i, word in enumerate(words):\\n word2idx_dict[word] = i\\n if word in TRANSLATE:\\n word = TRANSLATE[word]\\n done = False\\n for w in (word, word.lower(), word.upper(), word.capitalize()):\\n if w in embedding_dict:\\n embedding[i] = embedding_dict[w]\\n done = True\\n break\\n if not done:\\n unknown_count += 1\\n return embedding, word2idx_dict, unknown_count\",\n \"def save_whiten_mat(W):\\n w_id = open('data/W.bin','w')\\n W.tofile(w_id)\\n w_id.close()\",\n \"def load_word2vec(self, path, binary=True, reserve_zero=True, reserve_oov_token=True):\\n self.allow_oov = reserve_oov_token\\n self.reserve_zero = reserve_zero\\n words = []\\n if self.reserve_zero:\\n words.append('__ZERO__')\\n if self.allow_oov:\\n words.append('__OUT_OF_VOCAB__')\\n self.oov_index = len(words) - 1\\n\\n if binary:\\n with open(path, 'rb') as f:\\n # Get number of vectors and vector size\\n # from first line\\n num_vectors, vector_size = map(\\n int, f.readline().decode('UTF-8').split())\\n FLOAT_SIZE = 4\\n\\n self._matrix = np.zeros(\\n [num_vectors + len(words), vector_size], dtype='float32')\\n # Assign random vector for OOV token if it exists\\n if self.allow_oov:\\n self._matrix[self.oov_index] = np.random.randn(vector_size, )\\n\\n update = words.append # Speedup\\n for i in tqdm(range(len(words), num_vectors+len(words))):\\n # Reads until a whitespace is found (get a word)\\n word = b\\\"\\\"\\n while True:\\n char = f.read(1)\\n if char == b\\\" \\\":\\n break\\n word += char\\n update(word)\\n #Read vector\\n vecs = f.read(FLOAT_SIZE * vector_size)\\n self._matrix[i] = np.frombuffer(vecs, 'f')\\n\\n self.vocab = words\\n else:\\n print(\\\"This feature is yet to be implemented\\\")\",\n \"def read_w2v(w2v_path, word2index, n_dims=300, unk_token=\\\"unk\\\"):\\n print('Getting Word Vectors...', file=sys.stderr)\\n vocab = set()\\n # hacky thing to deal with making sure to incorporate unk tokens in the form they are in for a given embedding type\\n if unk_token not in word2index:\\n word2index[unk_token] = 0 # hardcoded, this would be better if it was a method of a class\\n\\n word_vectors = np.zeros((len(word2index), n_dims)) # length of vocab x embedding dimensions\\n with open(w2v_path) as file:\\n lc = 0\\n for line in file:\\n lc += 1\\n line = line.strip()\\n if line:\\n row = line.split()\\n token = row[0]\\n if token in word2index or token == unk_token:\\n vocab.add(token)\\n try:\\n vec_data = [float(x) for x in row[1:]]\\n word_vectors[word2index[token]] = np.asarray(vec_data)\\n if lc == 1:\\n if len(vec_data) != n_dims:\\n raise RuntimeError(\\\"wrong number of dimensions\\\")\\n except:\\n print('Error on line {}'.format(lc), file=sys.stderr)\\n # puts data for a given embedding at an index based on the word2index dict\\n # end up with a matrix of the entire vocab\\n tokens_without_embeddings = set(word2index) - vocab\\n print('Word Vectors ready!', file=sys.stderr)\\n print('{} tokens from text ({:.2f}%) have no embeddings'.format(\\n len(tokens_without_embeddings), len(tokens_without_embeddings)*100/len(word2index)), file=sys.stderr)\\n print('Tokens without embeddings: {}'.format(tokens_without_embeddings), file=sys.stderr)\\n print('Setting those tokens to unk embedding', file=sys.stderr)\\n for token in tokens_without_embeddings:\\n word_vectors[word2index[token]] = word_vectors[word2index[unk_token]]\\n return word_vectors\",\n \"def embedding_sentence(input_file, save_path, max_length):\\n lines = _read_csv(input_file)\\n split_lines = []\\n label_list = []\\n for line in lines:\\n split_lines.append(sentence_split(line[1], max_length))\\n label_list.append(int(line[2]))\\n del lines\\n\\n writer = tf.python_io.TFRecordWriter(save_path)\\n for index, line in enumerate(split_lines):\\n bytes_words = []\\n for word in line:\\n bytes_words.append(str.encode(word))\\n example = tf.train.Example(features=tf.train.Features(feature={\\n \\\"label\\\":\\n tf.train.Feature(int64_list=tf.train.Int64List(value=[label_list[index]])),\\n \\\"features\\\":\\n tf.train.Feature(bytes_list=tf.train.BytesList(value=bytes_words))\\n }))\\n writer.write(example.SerializeToString())\",\n \"def creating_feature_vector():\\r\\n\\twordlist = []\\r\\n\\tlabel = \\\"\\\"\\r\\n\\tfw = open(\\\"feature_vector.txt\\\", \\\"w+\\\", encoding = \\\"utf-8\\\")\\r\\n\\twith open(\\\"D:\\\\\\\\Python_Prac\\\\\\\\wordstag\\\\\\\\modules\\\\\\\\HI_EN_TRAIN.txt\\\", \\\"r\\\", encoding = \\\"utf-8\\\") as f:\\r\\n\\t\\tfor line in f:\\r\\n\\t\\t\\twordlist.append(line)\\r\\n\\t\\tfor index, line in enumerate(wordlist):\\r\\n\\t\\t\\tif line == \\\"\\\\n\\\":\\r\\n\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\tcontext = line.split(\\\"\\\\t\\\")\\r\\n\\t\\t\\tlabel = context[1]\\r\\n\\t\\t\\tfeature_vector = label+\\\" \\\"\\r\\n\\t\\t\\tngram_vector = ngram_frequency(str(context[0]))\\r\\n\\t\\t\\tfor vector in ngram_vector:\\r\\n\\t\\t\\t\\tfeature_vector += str(vector)+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_english(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_hindi(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(is_abbr(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(med_in_english(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += str(med_in_hindi(context[0]))+\\\" \\\"\\r\\n\\t\\t\\tbefore = [0,0,0]\\r\\n\\t\\t\\tafter = [0,0,0]\\r\\n\\t\\t\\tfor i in range(3):\\r\\n\\t\\t\\t\\tif (index-i) < 0 or (index-i+1) > len(wordlist)-1:\\r\\n\\t\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\t\\tbefore[2-i] = get_word_context(wordlist[index-i+1].split(\\\"\\\\t\\\")[0])\\r\\n\\t\\t\\tfor i in range(3):\\r\\n\\t\\t\\t\\tif (index+i+1) > len(wordlist)-1:\\r\\n\\t\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\t\\tafter[2-i] = get_word_context(wordlist[index+i+1].split(\\\"\\\\t\\\")[0])\\r\\n\\t\\t\\tfor i in before:\\r\\n\\t\\t\\t\\tfeature_vector += str(i)+\\\" \\\"\\r\\n\\t\\t\\tfor i in after:\\r\\n\\t\\t\\t\\tfeature_vector += str(i)+\\\" \\\"\\r\\n\\t\\t\\tfeature_vector += \\\"\\\\n\\\"\\r\\n\\t\\t\\tfw.write(feature_vector)\\r\\n\\t\\t\\tprint(\\\"Proceeding...\\\"+str(index+1)+\\\" of 16683\\\")\\r\\n\\r\\n\\tfw.close()\",\n \"def load_word2vec_embeddings(word2vec_file, word_map):\\n # Load word2vec model into memory\\n w2v = gensim.models.KeyedVectors.load(word2vec_file, mmap='r')\\n\\n\\n\\n # Create tensor to hold embeddings for words that are in-corpus\\n # word_map 내 단어들에 대한 임베딩 벡터 만들기\\n embeddings = torch.FloatTensor(len(word_map), w2v.vector_size)\\n init_embedding(embeddings)\\n\\n # Read embedding file\\n\\n for word in word_map:\\n if word in w2v.vocab:\\n embeddings[word_map[word]] = torch.FloatTensor(w2v[word])\\n\\n\\n return embeddings, w2v.vector_size\",\n \"def load_word_embeddings(self, word_embeddings, word_to_ix):\\n logger.info(\\\"Loading the vocabulary\\\")\\n self.vocab = {}\\n self.index2word = []\\n counts = {}\\n for word in word_to_ix:\\n counts[word] = counts.get(word, 0) + 1\\n self.vocab_size = len(counts)\\n self.vector_size = word_embeddings.shape[1]\\n self.vectors = np.zeros((self.vocab_size, self.vector_size))\\n self.index2word = [None] * self.vocab_size\\n logger.info(\\\"Corpus has %i words\\\", len(self.vocab))\\n for word_id, word in enumerate(counts):\\n self.vocab[word] = Vocab(index=word_id, count=counts[word])\\n self.vectors[word_id] = word_embeddings[word_to_ix[word]]\\n self.index2word[word_id] = word\\n assert((len(self.vocab), self.vector_size) == self.vectors.shape)\\n logger.info(\\\"Loaded matrix of %d size and %d dimensions\\\", self.vocab_size, self.vector_size)\",\n \"def createMatrices(file, word2Idx, maxSentenceLen, extendMapping, labelsMapping, aspectMapping, typeMapping, tenseMapping, eventClassMapping, distanceMapping, sentenceLengthMapping):\\n labels = []\\n eventMatrix = []\\n timeMatrix = []\\n\\n sentenceLengths = []\\n sentenceMatrix = []\\n positionMatrix_e = []\\n positionMatrix_t = []\\n\\n aspectMatrix = []\\n typeMatrix = []\\n tenseMatrix = []\\n eventClassMatrix = []\\n featuresList = []\\n \\n \\n minDistance = 0\\n for distanceKey in distanceMapping.iterkeys():\\n if isinstance(distanceKey, (int, long)):\\n minDistance = min(minDistance, int(distanceKey))\\n \\n for line in open(file):\\n features = eval(line.strip())\\n featuresList.append(features)\\n label = features['label']\\n event = features[\\\"Token[0]\\\"]\\n eventPosition = int(features[\\\"eventPosition\\\"])\\n tokens = features[\\\"textInBetween\\\"] if \\\"textInBetween\\\" in features else features[\\\"sentence\\\"]\\n \\n aspect = features[\\\"aspect\\\"]\\n tense = features[\\\"tense\\\"]\\n eventClass = features[\\\"eventClass\\\"]\\n \\n labels.append(labelsMapping[label.lower()] if label.lower() in labelsMapping else -1)\\n eventMatrix.append(getWordIdx(event, word2Idx))\\n \\n aspectMatrix.append(getMappingIdx(aspect, aspectMapping, extendMapping))\\n tenseMatrix.append(getMappingIdx(tense, tenseMapping, extendMapping))\\n eventClassMatrix.append(getMappingIdx(eventClass, eventClassMapping, extendMapping))\\n \\n if 'TimeTokenFirst' in features:\\n time = features['TimeTokenFirst']\\n timeMatrix.append(getWordIdx(time, word2Idx))\\n \\n if 'type' in features:\\n type = features[\\\"type\\\"]\\n typeMatrix.append(getMappingIdx(type, typeMapping, extendMapping))\\n \\n timePosition = int(features[\\\"timeFirstPosition\\\"]) if 'timeFirstPosition' in features else 0\\n \\n\\n if len(tokens) in sentenceLengthMapping:\\n sentenceLengths.append(sentenceLengthMapping[len(tokens)])\\n else:\\n sentenceLengths.append(sentenceLengthMapping['GreaterMax'])\\n\\n \\n tokenIds = np.zeros(maxSentenceLen)\\n positionValues_e = np.zeros(maxSentenceLen)\\n positionValues_t = np.zeros(maxSentenceLen)\\n for idx in xrange(0, min(maxSentenceLen, len(tokens))):\\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\\n \\n distance_e = idx - eventPosition\\n distance_t = idx - timePosition\\n\\n if distance_e in distanceMapping:\\n positionValues_e[idx] = distanceMapping[distance_e]\\n elif distance_e <= minDistance:\\n positionValues_e[idx] = distanceMapping['LowerMin']\\n else:\\n positionValues_e[idx] = distanceMapping['GreaterMax']\\n \\n if distance_t in distanceMapping:\\n positionValues_t[idx] = distanceMapping[distance_t]\\n elif distance_t <= minDistance:\\n positionValues_t[idx] = distanceMapping['LowerMin']\\n else:\\n positionValues_t[idx] = distanceMapping['GreaterMax']\\n\\n sentenceMatrix.append(tokenIds)\\n positionMatrix_e.append(positionValues_e)\\n positionMatrix_t.append(positionValues_t)\\n\\n \\n labels = np.array(labels, dtype='int32')\\n eventMatrix = np.expand_dims(np.array(eventMatrix, dtype='int32'), axis=1)\\n timeMatrix = np.expand_dims(np.array(timeMatrix, dtype='int32'), axis=1)\\n aspectMatrix = np.expand_dims(np.array(aspectMatrix, dtype='int32'), axis=1)\\n typeMatrix = np.expand_dims(np.array(typeMatrix, dtype='int32'), axis=1)\\n tenseMatrix = np.expand_dims(np.array(tenseMatrix, dtype='int32'), axis=1)\\n eventClassMatrix = np.expand_dims(np.array(eventClassMatrix, dtype='int32'), axis=1)\\n sentenceLengths = np.expand_dims(np.array(sentenceLengths, dtype='int32'), axis=1)\\n \\n \\n sentenceMatrix = np.array(sentenceMatrix, dtype='int32')\\n positionMatrix_e = np.array(positionMatrix_e, dtype='int32')\\n positionMatrix_t = np.array(positionMatrix_t, dtype='int32')\\n \\n\\n\\n return {'labels': labels,\\n 'event':eventMatrix, \\n 'time':timeMatrix, \\n 'sentence':sentenceMatrix, \\n 'positions_e':positionMatrix_e, \\n 'positions_t':positionMatrix_t, \\n 'aspect':aspectMatrix, \\n 'tense':tenseMatrix, \\n 'eventClass':eventClassMatrix, \\n 'type': typeMatrix,\\n 'sentence_len': sentenceLengths,\\n 'features': featuresList}\",\n \"def prepare_word_emb_matrices(experiment):\\r\\n\\r\\n with open(\\\"public_data/stats/stats_train.pkl\\\", 'rb') as stats:\\r\\n stats = pickle.load(stats)\\r\\n vocab = stats[\\\"VOCAB\\\"]\\r\\n stops = [word.lower() for word in set(stopwords.words('english'))]\\r\\n vocab = vocab + stops\\r\\n\\r\\n if experiment == \\\"RANDOM\\\":\\r\\n word_embs = np.random.uniform(low=-1.0, high=1.0, size=(len(vocab), PARAMS[\\\"SIZE\\\"])).astype(\\\"float32\\\")\\r\\n\\r\\n else:\\r\\n word_embs = []\\r\\n count_unk = 0\\r\\n count_kn = 0\\r\\n\\r\\n if experiment == \\\"5\\\":\\r\\n emb_model = KeyedVectors.load_word2vec_format(\\\"public_data/models/experiment_5/embeddings_5.bin\\\",\\r\\n binary=True)\\r\\n elif experiment == \\\"6\\\":\\r\\n emb_model = Word2Vec.load(\\\"public_data/models/experiment_6/embeddings_6\\\")\\r\\n\\r\\n elif experiment in [\\\"7\\\", \\\"8\\\"]:\\r\\n emb_model = FastText.load_fasttext_format(\\\"public_data/models/experiment_%s/embeddings_%s.bin\\\"\\r\\n %(experiment, experiment))\\r\\n for word in vocab:\\r\\n if word in emb_model:\\r\\n word_embs.append(emb_model[word])\\r\\n count_kn += 1\\r\\n else:\\r\\n word_embs.append(np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\\\"SIZE\\\"]))\\r\\n count_unk += 1\\r\\n\\r\\n word_embs = np.array(word_embs).astype(\\\"float32\\\")\\r\\n print(count_unk / (count_kn + count_unk))\\r\\n\\r\\n pad = np.zeros(shape=PARAMS[\\\"SIZE\\\"]).astype(\\\"float32\\\")\\r\\n unk = np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\\\"SIZE\\\"]).astype(\\\"float32\\\")\\r\\n word_embs = np.insert(word_embs, 0, unk, axis=0) #id 1\\r\\n word_embs = np.insert(word_embs, 0, pad, axis=0) #id 0\\r\\n\\r\\n with open(\\\"public_data/embeddings/word_embeddings_%s.pkl\\\" %experiment, 'wb') as out:\\r\\n pickle.dump(word_embs, out, protocol=4)\\r\\n\\r\\n return word_embs\",\n \"def __init__(self, vector_file='', transform=None):\\n self.word2id = {}\\n\\n # Captures word order, for export() and translate methods\\n self.id2word = []\\n\\n print('reading word vectors from %s' % vector_file)\\n with open(vector_file, 'r', errors='ignore') as f:\\n line = f.readline()\\n header_tokens = line.rstrip('\\\\n').split(' ')\\n if len(header_tokens) == 2:\\n self.n_words, self.n_dim = [int(x) for x in header_tokens]\\n self.embed = np.zeros((self.n_words, self.n_dim))\\n lines = f.read().split('\\\\n')\\n for i, line in enumerate(lines):\\n if line == '':\\n continue\\n elems = line.rstrip('\\\\n').split(' ')\\n self.word2id[elems[0]] = i\\n self.embed[i] = elems[1:self.n_dim + 1]\\n self.id2word.append(elems[0])\\n else:\\n self.n_words, self.n_dim = 2196017, 300\\n self.embed = np.zeros((self.n_words, self.n_dim))\\n self.word2id[header_tokens[0]] = 0\\n self.embed[0] = header_tokens[1:self.n_dim + 1]\\n self.id2word.append(header_tokens[0])\\n for i, line in enumerate(f.read().split('\\\\n')):\\n if line == '':\\n continue\\n elems = line.rstrip('\\\\n').split(' ')\\n self.word2id[elems[0]] = i+1\\n self.embed[i+1] = elems[1:self.n_dim+1]\\n self.id2word.append(elems[0])\\n\\n # Used in translate_inverted_softmax()\\n self.softmax_denominators = None\\n\\n if transform is not None:\\n print('Applying transformation to embedding')\\n self.apply_transform(transform)\",\n \"def createMatrices(file, word2Idx, maxSentenceLen=100):\\n labels = []\\n positionMatrix1 = []\\n positionMatrix2 = []\\n tokenMatrix = []\\n \\n for line in open(file):\\n splits = line.strip().split('\\\\t')\\n \\n label = splits[0]\\n pos1 = splits[1]\\n pos2 = splits[2]\\n sentence = splits[3]\\n tokens = sentence.split(\\\" \\\")\\n \\n \\n \\n \\n tokenIds = np.zeros(maxSentenceLen)\\n positionValues1 = np.zeros(maxSentenceLen)\\n positionValues2 = np.zeros(maxSentenceLen)\\n \\n for idx in range(0, min(maxSentenceLen, len(tokens))):\\n tokenIds[idx] = getWordIdx(tokens[idx], word2Idx)\\n \\n distance1 = idx - int(pos1)\\n distance2 = idx - int(pos2)\\n \\n if distance1 in distanceMapping:\\n positionValues1[idx] = distanceMapping[distance1]\\n elif distance1 <= minDistance:\\n positionValues1[idx] = distanceMapping['LowerMin']\\n else:\\n positionValues1[idx] = distanceMapping['GreaterMax']\\n \\n if distance2 in distanceMapping:\\n positionValues2[idx] = distanceMapping[distance2]\\n elif distance2 <= minDistance:\\n positionValues2[idx] = distanceMapping['LowerMin']\\n else:\\n positionValues2[idx] = distanceMapping['GreaterMax']\\n \\n tokenMatrix.append(tokenIds)\\n positionMatrix1.append(positionValues1)\\n positionMatrix2.append(positionValues2)\\n \\n labels.append(labelsMapping[label])\\n \\n\\n \\n return np.array(labels, dtype='int32'), np.array(tokenMatrix, dtype='int32'), np.array(positionMatrix1, dtype='int32'), np.array(positionMatrix2, dtype='int32'),\",\n \"def buildEmbeddingMatrix(path_to_gloVe, tokenizer, embedding_dimen=300):\\n logging.info(\\\"Loading GloVe vector model..\\\")\\n t = time()\\n # Loads the gloVe model into a dictionary\\n with open(path_to_gloVe, encoding='utf8') as file:\\n embeddings = dict()\\n for line in file:\\n values = line.split()\\n # key is the word, value is the numpy array for the corresponding word vector\\n embeddings[values[0]] = np.asarray(values[1:], 'float32')\\n # Create a 2D tensor of shape(num_unique_words+1, embedding_dimen) (Index 0 is used for padding)\\n embedding_matrix = np.zeros((len(nltk_tokenizer.word_index) + 1, embedding_dimen))\\n word_found_in_embedding = 0\\n for word, index in nltk_tokenizer.word_index.items():\\n embedding_vector = embeddings.get(word)\\n # Only populate word vectors that exist in GloVe model,\\n # words not found (e.g: spelling error) will be padded with zeroes as their word vector\\n if embedding_vector is not None:\\n embedding_matrix[index] = embedding_vector\\n word_found_in_embedding += 1\\n logging.info(\\\"Done!\\\")\\n logging.info(\\\"Loaded {} word vectors into the embedding.\\\".format(len(embedding_matrix)))\\n logging.info(\\\"Found {} word vectors that exist in the GloVe model.\\\".format(word_found_in_embedding))\\n logging.info(\\\"Time taken to load pre-trained GloVe model: {} mins\\\".format(round(((time() - t) / 60), 2)))\\n return embedding_matrix\",\n \"def read_txt_embeddings(path, params):\\n word2id = {}\\n vectors = []\\n\\n # load pretrained embeddings\\n _emb_dim_file = params.emb_dim\\n with io.open(path, 'r', encoding='utf-8', newline='\\\\n', errors='ignore') as f:\\n for i, line in enumerate(f):\\n if i == 0:\\n split = line.split()\\n assert len(split) == 2\\n assert _emb_dim_file == int(split[1])\\n continue\\n word, vect = line.rstrip().split(' ', 1)\\n vect = np.fromstring(vect, sep=' ')\\n if word in word2id:\\n logger.warning(\\\"Word \\\\\\\"%s\\\\\\\" found twice!\\\" % word)\\n continue\\n if not vect.shape == (_emb_dim_file,):\\n logger.warning(\\\"Invalid dimension (%i) for word \\\\\\\"%s\\\\\\\" in line %i.\\\"\\n % (vect.shape[0], word, i))\\n continue\\n assert vect.shape == (_emb_dim_file,)\\n word2id[word] = len(word2id)\\n vectors.append(vect[None])\\n\\n assert len(word2id) == len(vectors)\\n logger.info(\\\"Loaded %i pretrained word embeddings from %s\\\" % (len(vectors), path))\\n\\n # compute new vocabulary / embeddings\\n embeddings = np.concatenate(vectors, 0)\\n embeddings = torch.from_numpy(embeddings).float()\\n\\n assert embeddings.size() == (len(word2id), params.emb_dim)\\n return word2id, embeddings\",\n \"def glove(data_fname='glove.840B.300d.txt', out_fname='glove.pkl'):\\n words, U, dim = [], [], None\\n with open(DATA_DIR + data_fname, 'rb') as f:\\n for j, line in enumerate(f):\\n x = line.strip().split()\\n word, vector, d = x[0], np.ravel(x[1:]), len(x) - 1\\n if dim is None: dim = d\\n elif d != dim: raise Exception('{0}: {1}!={2}'.format(j, dim, d))\\n U.append(vector)\\n words.append(word)\\n U = np.array(U)\\n print \\\"Found {0} words\\\".format(len(words))\\n print \\\"Found {0}x{1} embedding matrix\\\".format(*U.shape)\\n with open(DATA_DIR + out_fname, 'wb') as f:\\n cPickle.dump((words, U), f)\",\n \"def load_embeddings(embeddings_path):\\n\\n embeddings_index = {}\\n f = open(embeddings_path, encoding='utf-8')\\n for line in tqdm(f):\\n values = line.rstrip().split(' ')\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n f.close()\\n print('Found {} word vectors.'.format(len(embeddings_index)))\\n return embeddings_index\",\n \"def load_embeddings(path, vocab, source_domain, target_domain, emb_name):\\n\\n pkl = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\\n if os.path.exists(pkl):\\n print(\\\"Load embeddings from existing pkl file %s...\\\" % pkl)\\n # word embeddings weights have been loaded\\n embeddings = pickle.load(open(pkl, 'rb'))\\n else:\\n print(\\\"Load embedding from %s...\\\" % path)\\n raw_embeddings = {}\\n if emb_name == 'yelp_electronics':\\n with open(path) as fp:\\n for line in fp:\\n word_vector = line.split(\\\",\\\")[:-1]\\n vector_list = []\\n for element in word_vector[len(word_vector) - 100:]:\\n vector_list.append(float(element))\\n word = ','.join(word_vector[:len(word_vector) - 100])\\n vector = np.asarray(vector_list)\\n if word in vocab:\\n raw_embeddings[word] = vector\\n else:\\n with open(path) as fp:\\n for line in fp:\\n eles = line.strip().split(' ')\\n word = eles[0]\\n if word in vocab:\\n raw_embeddings[word] = eles[1:]\\n\\n dim_w = len(raw_embeddings['the'])\\n n_words = len(vocab)\\n embeddings = np.zeros(shape=(n_words, dim_w))\\n for w in vocab:\\n wid = vocab[w]\\n if w in raw_embeddings:\\n embeddings[wid] = np.array([float(ele) for ele in raw_embeddings[w]])\\n else:\\n # for OOV words, add random initialization\\n embeddings[wid] = np.random.uniform(-0.25, 0.25, dim_w)\\n print(\\\"Find %s word embeddings...\\\" % len(embeddings))\\n if not os.path.exists('./work/embeddings'):\\n os.mkdir('./work/embeddings')\\n emb_path = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\\n # write the embedding weights back to the disk\\n pickle.dump(embeddings, open(emb_path, 'wb'))\\n embeddings = np.array(embeddings, dtype='float32')\\n return embeddings\",\n \"def load_bin_vec(word2vec, vocab):\\n word_vecs = {}\\n with open(word2vec, \\\"rb\\\") as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = np.dtype('float32').itemsize * layer1_size\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch)\\n if word in vocab:\\n word_vecs[word] = np.fromstring(f.read(binary_len), dtype='float32')\\n else:\\n f.read(binary_len)\\n return word_vecs\",\n \"def create_embedding_matrix(self):\\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\\n vocab_size = len(self.vocab)\\n result = np.zeros((vocab_size, self.embed_dim))\\n unknown_token_set = set()\\n\\n found_words = 0\\n avg = np.zeros(self.embed_dim)\\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\\n try:\\n result[_] = self.pretrained_embedding[self.id2word[_]]\\n avg += result[_]\\n found_words += 1\\n except:\\n unknown_token_set.add(_)\\n\\n avg /= found_words\\n for _ in unknown_token_set:\\n result[_] = avg\\n self.embedding = result\\n return found_words, len(self.id2word)\",\n \"def get_W(word_vecs, k=100,path='wordemb'):\\n vocab_size = len(word_vecs)\\n word_idx_map = dict()\\n W = np.zeros(shape=(vocab_size+1, k), dtype='float32')\\n W[0] = np.zeros(k, dtype='float32')\\n i = 1\\n f =open(path+'.word','w')\\n for word in word_vecs:\\n # print(\\\"#############################\\\")\\n # print(word_vecs[word].shape)\\n # print(word)\\n # print(W[i].shape)\\n # print(\\\"#############################\\\")\\n W[i] = word_vecs[word]\\n f.write(word+'\\\\n')\\n word_idx_map[word] = i\\n i += 1\\n np.savetxt(path+'.txt',W,fmt='%.7f', delimiter=' ')\\n f.close()\\n return W, word_idx_map\",\n \"def get_word_embeddings(t, folder, lang=\\\"en\\\"):\\n vecs_url = f\\\"https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.{lang}.300.vec.gz\\\"\\n vecs_gz_filename = vecs_url.rpartition(\\\"/\\\")[2]\\n os.makedirs(folder, exist_ok=True)\\n vecs_gz_filepath = os.path.join(folder, vecs_gz_filename)\\n\\n tokenizer_vocab_size = len(t.vocab)\\n\\n if wait_for_file_stable(vecs_gz_filepath):\\n print(\\\"Using existing embeddings file\\\")\\n else:\\n print(\\\"Downloading word vectors...\\\")\\n subprocess.run([\\\" \\\".join([\\\"wget\\\", \\\"-NP\\\", folder, vecs_url])], check=True, shell=True)\\n\\n print(\\\"Loading into memory...\\\")\\n embeddings_index = dict()\\n with gzip.open(vecs_gz_filepath, \\\"rt\\\") as zipf:\\n firstline = zipf.readline()\\n emb_vocab_size, emb_d = firstline.split(\\\" \\\")\\n emb_vocab_size = int(emb_vocab_size)\\n emb_d = int(emb_d)\\n for line in zipf:\\n values = line.split()\\n word = values[0]\\n # Only load subset of the embeddings recognised by the tokenizer:\\n if word in t.vocab.stoi:\\n coefs = np.asarray(values[1:], dtype=\\\"float32\\\")\\n embeddings_index[word] = coefs\\n print(\\\"Loaded {} of {} word vectors for tokenizer vocabulary length {}\\\".format(\\n len(embeddings_index),\\n emb_vocab_size,\\n tokenizer_vocab_size,\\n ))\\n\\n # create a weight matrix for words in training docs\\n embedding_matrix = np.zeros((tokenizer_vocab_size, emb_d))\\n for word, i in t.vocab.stoi.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n return embedding_matrix\",\n \"def _add_pre_trained_embedding(self):\\n\\n if self.embedding_type['type'] == 'glove':\\n self.logging.info('use pre-trained glove word2vec')\\n # a. load pre trained glove\\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\\n import os\\n import numpy as np\\n\\n embeddings_index = {}\\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\\n for line in f:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n f.close()\\n\\n self.logging.info('')\\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\\n\\n # b. compute embedding matrix\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n\\n elif self.embedding_type['type'] == 'gensim':\\n self.logging.info('use pre-trained gensim word2vec')\\n\\n import gzip\\n import gensim\\n from keras.layers import Embedding\\n import numpy as np\\n\\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\\n\\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\\n pretrained_weights = model.wv.syn0\\n vocab_size, vector_dim = pretrained_weights.shape\\n\\n method = 3\\n if method == 1:\\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\\n # into our TensorFlow and Keras models\\n\\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\\n for i in range(len(model.wv.vocab)):\\n embedding_vector = model.wv[model.wv.index2word[i]]\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\\n output_dim=embedding_matrix.shape[1],\\n # input_length=self.maxlen,\\n weights=[embedding_matrix],\\n trainable=False)\\n elif method == 2:\\n self.logging.info('word2vec simple embedding matching - simple complex')\\n embedding_layer = Embedding(input_dim=vocab_size,\\n output_dim=vector_dim,\\n input_length=self.maxlen,\\n weights=[pretrained_weights],\\n trainable=False)\\n elif method == 3:\\n\\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\\n # b. compute embedding matrix\\n\\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\\n\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n if word in model.wv:\\n embedding_vector = model.wv[word]\\n embedding_matrix[i] = embedding_vector\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt))\\n\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n else:\\n raise ValueError('unknown method value')\\n\\n else:\\n raise ValueError('unknown embedding type')\\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\\n return embedding_layer\",\n \"def load_embedding(embedding_file_path, word_index, embedding_dim):\\n # Create a Numpy Placeholder for Embedding\\n max_features = len(word_index)+1\\n embedding_weights = np.random.random([max_features, embedding_dim])\\n count = 0\\n glove_file = open(embedding_file_path)\\n for line in glove_file:\\n word, vector = line.split(' ')[0], line.split(' ')[1:]\\n if word in word_index and word_index[word] <= max_features:\\n count += 1\\n vector = list(map(float, vector))\\n embedding_weights[word_index[word]] = [float(i) for i in vector]\\n\\n print('Fraction found in glove {}'.format(count/len(embedding_weights)))\\n return embedding_weights\",\n \"def load_word2vec(path):\\n model = gensim.models.KeyedVectors.load_word2vec_format(path, binary=True) \\n return model\",\n \"def export_trimmed_glove_vectors(vocab, glove_filename, trimmed_filename, dim):\\n embeddings = np.zeros([len(vocab), dim])\\n with open(glove_filename, encoding='utf-8') as f:\\n for line in f:\\n line = line.strip().split(' ')\\n word = line[0]\\n embedding = [float(x) for x in line[1:]]\\n if word in vocab:\\n word_idx = vocab[word]\\n embeddings[word_idx] = np.asarray(embedding)\\n\\n np.savez_compressed(trimmed_filename, embeddings=embeddings)\",\n \"def generate_conll2003_embeddings():\\n glove_embedding = get_glove_embedding()\\n\\n word2index = {}\\n idx2word = {}\\n embed_array = []\\n\\n word2index[\\\"<pad>\\\"] = 1\\n embed_array.append(init_embedding())\\n\\n word2index[\\\"<unk>\\\"] = 0\\n embed_array.append(init_embedding())\\n\\n data = []\\n with open(TRAIN_DATA_PATH, \\\"r\\\") as f:\\n for line in f:\\n data.append(json.loads(line))\\n\\n idx = 2\\n\\n for sample in tqdm(data, total=len(data)):\\n words = sample[\\\"tokens\\\"]\\n\\n for w in words:\\n w = w.lower()\\n\\n # if word is not present in dictionary, add to dictionary and append embedding vector\\n if w not in word2index.keys():\\n word2index[w] = idx\\n idx += 1\\n if w not in glove_embedding.keys():\\n ev = init_embedding()\\n else:\\n ev = glove_embedding[w]\\n\\n embed_array.append(ev)\\n\\n else:\\n continue\\n\\n # save embeddings\\n embed_array = np.vstack(embed_array)\\n np.save(EMBD_OUTPUT_PATH, embed_array)\\n\\n # save dictionary\\n print(\\\"Dicitionary Size: \\\", len(word2index))\\n with open(DICTIONARY_OUTPUT_PATH, \\\"w\\\") as f:\\n json.dump(word2index, f)\",\n \"def glove_embedding(self, texts, file):\\n self.embedding_dict = dict()\\n glove_file = open(file, encoding='utf-8')\\n for line in glove_file:\\n word_vector = line.split()\\n word = word_vector[0]\\n word_vector_arr = np.asarray(word_vector[1:], dtype='float32')\\n self.embedding_dict[word] = word_vector_arr\\n glove_file.close()\\n \\n i = 0\\n with pgb.ProgressBar(max_value=len(texts)) as bar:\\n for text in texts:\\n vec = []\\n text = text.split()\\n for t in text:\\n try:\\n vec.append(self.embedding_dict[t.lower()])\\n except KeyError:\\n pass\\n ## There are no matched words\\n if len(vec) == 0:\\n print(\\\"len 0 vec\\\")\\n self.word_vec.append(np.zeros((100)))\\n else:\\n #print(np.array(vec))\\n #print(np.array(vec).shape)\\n sentence = self.sentence_vec(np.array(vec))\\n #print(sentence)\\n #print(sentence.shape)\\n self.word_vec.append(sentence)\\n i += 1\\n bar.update(i)\\n self.word_vec = np.array(self.word_vec)\\n print(self.word_vec.shape)\",\n \"def vectorize(self,clean_path):\\n \\n #load pretrained embedding model (GloVe)\\n glove = spacy.load('en_core_web_lg')\\n #extract unique words (aka vocabulary)\\n unique_words = set()\\n for d in self.docs: \\n txt = d.text\\n doc = glove(txt)\\n for word in doc: \\n if word.has_vector:\\n unique_words.add(word.text)\\n #change set to list type\\n unique_words = list(unique_words)\\n #save vector representation\\n word_vectors = np.array([glove(word).vector for word in unique_words if glove(word).has_vector])\\n #index vectors by corresponding word \\n corpus_vectors = pd.DataFrame(word_vectors, index=unique_words)\\n with open(clean_path + 'corpus_vectors.pkl', 'wb') as f:\\n pickle.dump(corpus_vectors,f)\\n self.vectors = corpus_vectors\\n print('Saved embedding vectors.')\\n return\",\n \"def build_doc_sense_vec(self):\\n\\t\\twith codecs.open(self.vocab_file, encoding='utf-8', mode='r') as infile:\\n\\t\\t\\tline = infile.readline()\\n\\t\\t\\ti = 0\\n\\t\\t\\twhile line:\\n\\t\\t\\t\\tword = line.split()[0]\\n\\t\\t\\t\\tif not self.word2IdVocabulary.has_key(word):\\n\\t\\t\\t\\t\\t# print i, word\\n\\t\\t\\t\\t\\t# else:\\n\\t\\t\\t\\t\\tself.word2IdVocabulary[word] = i\\n\\t\\t\\t\\tif not self.id2WordVocabulary.has_key(i):\\n\\t\\t\\t\\t\\tself.id2WordVocabulary[i] = word\\n\\t\\t\\t\\tline = infile.readline()\\n\\t\\t\\t\\ti += 1\\n\\t\\t\\tself.vocab_num = len(self.word2IdVocabulary)\\n\\t\\t\\tprint \\\"vocabulary number:\\\" + str(self.vocab_num)\\n\\n\\t\\twith codecs.open(self.vec_file, encoding='utf-8', mode='r') as vecfile:\\n\\t\\t\\twith codecs.open(self.vec_out_file, encoding='utf-8', mode='a+') as vec_outfile:\\n\\n\\t\\t\\t\\tfor i, line in enumerate(vecfile):\\n\\t\\t\\t\\t\\tif i % 10000 == 0:\\n\\t\\t\\t\\t\\t\\tprint i\\n\\t\\t\\t\\t\\t# if i > 72:\\n\\t\\t\\t\\t\\t# \\tbreak\\n\\t\\t\\t\\t\\tif i == 0:\\n\\t\\t\\t\\t\\t\\ta, b, c = map(int, line.split()[:3])\\n\\t\\t\\t\\t\\t\\tprint('Number of sememes: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t 'Number of words: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t 'Dimension of vectors: {}'.format(a, b, c))\\n\\t\\t\\t\\t\\telif i > 462667:\\n\\t\\t\\t\\t\\t\\tsline = line.strip('\\\\n').split()\\n\\t\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\t\\tvector_list.append(sline[1:])\\n\\t\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[word]\\n\\t\\t\\t\\t\\t\\tif not self.vectors.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vectors[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\t# vector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t\\tif not self.vector_mean.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vector_mean[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\t# vec_outfile.write(line)\\n\\t\\t\\t\\t\\telif i > 462887:\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tsline = line.strip('\\\\n').split()\\n\\t\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\t\\tsense_num = int(sline[1])\\n\\t\\t\\t\\t\\t\\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\\n\\t\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\t\\tfor start in range(0, len(vectors), c):\\n\\t\\t\\t\\t\\t\\t\\tvector_list.append(list(map(float, vectors[start: start+c])))\\n\\t\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[word]\\n\\t\\t\\t\\t\\t\\tif not self.vectors.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vectors[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\tvector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t\\tif not self.vector_mean.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vector_mean[word_id] = vector_mean\\n\\t\\t\\t\\t\\t\\t'''j = 0\\n\\t\\t\\t\\t\\t\\tfor each_sense_vec in vector_array:\\n\\t\\t\\t\\t\\t\\t\\tif len(vector_array) > 1:\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_line = word + '_' + str(j) + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tformatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t\\tj += 1\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_line = word + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter={'float_kind': lambda\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t x: '%6f' % x})[1:-1] + '\\\\n'\\n\\n\\t\\t\\t\\t\\t\\t\\tvec_outfile.write(new_line)'''\\n\\n\\t\\twith codecs.open(self.doc_file, encoding='utf-8', mode='r') as docfile:\\n\\t\\t\\twith codecs.open(self.doc_out_file, encoding='utf-8', mode='a+') as doc_outfile:\\n\\t\\t\\t\\twith codecs.open(self.vec_out_file_bydoc, encoding='utf-8', mode='a+') as vec_outfile_bydoc:\\n\\t\\t\\t\\t\\tprint \\\"Processing document file......\\\"\\n\\t\\t\\t\\t\\tline = docfile.readline().strip('\\\\n')\\n\\t\\t\\t\\t\\twhile line:\\n\\t\\t\\t\\t\\t\\twords = line.split()\\n\\t\\t\\t\\t\\t\\tnew_words = [x for x in words]\\n\\t\\t\\t\\t\\t\\tfor i in range(len(words)):\\n\\t\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[words[i]]\\n\\t\\t\\t\\t\\t\\t\\tsense_vecs = self.vectors[word_id]\\n\\t\\t\\t\\t\\t\\t\\tsense_num = len(sense_vecs)\\n\\t\\t\\t\\t\\t\\t\\tif sense_num > 1:\\n\\t\\t\\t\\t\\t\\t\\t\\tcontext_words = []\\n\\t\\t\\t\\t\\t\\t\\t\\tfor x in range(i-int(self.context_num), i+int(self.context_num)+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif x != i and 0 <= x < len(words):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcontext_words.append(words[x])\\n\\t\\t\\t\\t\\t\\t\\t\\tsense_index = self.select_attention(context_words, sense_vecs)\\n\\t\\t\\t\\t\\t\\t\\t\\tword_vec_i = sense_vecs[sense_index]\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_wordi = words[i] + '_' + str(sense_index)\\n\\t\\t\\t\\t\\t\\t\\t\\tself.vector_word_doc[new_wordi.encode('utf-8')] = word_vec_i\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_words[i] = new_wordi\\n\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tword_vec_i = sense_vecs[0]\\n\\t\\t\\t\\t\\t\\t\\t\\tself.vector_word_doc[words[i].encode('utf-8')] = word_vec_i\\n\\t\\t\\t\\t\\t\\t\\tvec_outfile_bydoc.write(new_words[i] + ' ' + np.array2string(word_vec_i, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\\\n')\\n\\n\\t\\t\\t\\t\\t\\tdoc_outfile.write(' '.join(new_words) + '\\\\n')\\n\\n\\t\\t\\t\\t\\t\\tline = docfile.readline()\\n\\n\\t\\treturn self.vector_word_doc\",\n \"def save_dict(emb, path_to_vec, dim=100):\\n word_vec = {}\\n for w in emb.keys():\\n word_vec[w] = emb[w]\\n with open(path_to_vec + f'embedding_{str(dim)}d.txt', 'w') as file:\\n for w, v in word_vec.items():\\n file.write(w + ' ')\\n for el in v:\\n file.write(\\\"{:.20f}\\\".format(float(el)) + ' ')\\n file.write('\\\\n')\",\n \"def _initialize_embeddings(self, chunk_file):\\n input = SRP.Vector_file(chunk_file)\\n dataset = input.to_matrix(unit_length = True)\\n self.matrix = dataset['matrix']\\n \\n ids = dataset['names']\\n self.ids = ids\\n\\n sections = [a.split(\\\"-\\\") for a in dataset['names']]\\n try:\\n htids, sections, starts, ends = zip(*sections)\\n except:\\n # The old format: deprecated.\\n htids, sections = zip(*sections)\\n sections = pd.DataFrame({'mtid': ids, 'htid': htids, 'section': list(map(int, sections))}).set_index('htid')\\n\\n self.chunk_metadata = sections.join(self.metadata, how='left').reset_index()\\n \\n self.mtid_lookup = dict(zip(dataset['names'], range(len(dataset['names']))))\\n \\n self.htid_lookup = defaultdict(list)\\n for i, htid in enumerate(htids):\\n self.htid_lookup[htid].append(ids[i])\",\n \"def get_weibo_data(vocab_file, vector_file):\\n if os.path.exists(\\\"word_misc.pkl\\\"):\\n return cPickle.load(open(\\\"word_misc.pkl\\\", \\\"rb\\\"))\\n\\n word_misc, word2id, id2word = {}, {}, {}\\n word_count = 0\\n\\n # vocab file\\n print \\\"Building vocabulary ...\\\"\\n for lines in open(vocab_file).readlines():\\n word = lines.split()[0]\\n if not is_unwanted_words(word, ['', '\\\\n']):\\n word2id[word] = word_count\\n id2word[word_count] = word\\n word_count += 1\\n word2id['_START'] = word_count\\n id2word[word_count] = '_START'\\n word_count += 1\\n word2id['_END'] = word_count\\n id2word[word_count] = '_END'\\n word_count += 1\\n word2id['_UNK'] = word_count\\n id2word[word_count] = '_UNK'\\n word_count += 1\\n word2id['_MASK'] = word_count\\n id2word[word_count] = '_MASK'\\n word_count += 1\\n print \\\"Vocabulary size:\\\", word_count\\n\\n # Initialization is refered to in https://www.tensorflow.org/versions/r0.7/tutorials/word2vec/index.html\\n word_emb = (1/np.sqrt(word_count)*(2*np.random.rand(word_count, options['embedding_size']) - 1)).tolist()\\n\\n # load word vectors\\n for lines in open(vector_file).readlines()[1:]:\\n word = lines.split()[0]\\n #if word == '</s>' or word not in word2id.keys():\\n # continue\\n if word not in word2id.keys():\\n continue\\n ids = word2id[word]\\n #print ids, lines, len(word_emb)\\n word_emb[ids] = [float(w) for w in lines.split()[1:]]\\n\\n print len(word_emb), \\\"words have been loaded with\\\", len(word_emb[0]), \\\"dimensions\\\"\\n\\n # load word misc\\n word_misc['id2word'] = id2word\\n word_misc['word2id'] = word2id\\n word_misc['word_count'] = word_count\\n word_misc['word_emb'] = word_emb\\n cPickle.dump(word_misc, open(\\\"word_misc.pkl\\\", \\\"wb\\\"))\\n print \\\"Dump complete.\\\"\\n return word_misc\",\n \"def dump_token_embeddings(vocab_file, options_file, weight_file, outfile):\\n with open(options_file, 'r') as fin:\\n options = json.load(fin)\\n max_word_length = options['char_cnn']['max_characters_per_token']\\n\\n vocab = UnicodeCharsVocabulary(vocab_file, max_word_length)\\n batcher = Batcher(vocab_file, max_word_length)\\n print('Computing {} LM token vectors'.format(vocab.size))\\n\\n ids_placeholder = tf.placeholder(\\n 'int32',\\n shape=(None, None, max_word_length)\\n )\\n print('Building Language model')\\n model = BidirectionalLanguageModel(\\n options_file, weight_file, ids_placeholder\\n )\\n\\n embedding_op = model.get_ops()['token_embeddings']\\n\\n n_tokens = vocab.size\\n embed_dim = int(embedding_op.shape[2])\\n\\n embeddings = np.zeros((n_tokens, embed_dim), dtype=lm_model.DTYPE)\\n\\n config = tf.ConfigProto(allow_soft_placement=True)\\n with tf.Session(config=config) as sess:\\n sess.run(tf.global_variables_initializer())\\n for k in tqdm(range(n_tokens), desc='Computing LM token embeddings', ncols=80):\\n token = vocab.id_to_word(k)\\n char_ids = batcher.batch_sentences([[token]])[0, 1, :].reshape(\\n 1, 1, -1)\\n embeddings[k, :] = sess.run(\\n embedding_op, feed_dict={ids_placeholder: char_ids}\\n )\\n\\n with h5py.File(outfile, 'w') as fout:\\n fout.create_dataset(\\n 'embedding', embeddings.shape, dtype='float32', data=embeddings\\n )\",\n \"def generateMatrix(self):\\n if self.tokenWeights and self.extraFeatures:\\n nFeatures = self.wordId + self.wordId2 + len(self.EXTRA_WEIGHTS_LABELS)\\n logging.info('Exporting TOKEN WEIGHTS AND EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n # iterate through 1st sentence\\n for wId, val in doc['s1'].iteritems():\\n mtrx[docId, wId] = val\\n # then iterate thru 2nd sentence, store on 2ND PARTITION\\n for wId, val in doc['s2'].iteritems():\\n mtrx[docId, self.wordId + wId] = val\\n # finally extra features values stored at the end of the vector\\n for label, val in doc['extraFeatures'].iteritems():\\n mtrx[docId, self.wordId + self.wordId2 + self.EXTRA_WEIGHTS_LABELS.index(label)] = val\\n\\n elif self.tokenWeights and not self.extraFeatures:\\n nFeatures = self.wordId + self.wordId2\\n logging.info('Exporting TOKEN WEIGHTS %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n # iterate through 1st sentence\\n for wId, val in doc['s1'].iteritems():\\n mtrx[docId, wId] = val\\n # then iterate thru 2nd sentence, store on 2ND PARTITION\\n for wId, val in doc['s2'].iteritems():\\n mtrx[docId, self.wordId + wId] = val\\n else:\\n nFeatures = len(self.EXTRA_WEIGHTS_LABELS)\\n logging.info('Exporting EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n for label, val in doc['extraFeatures'].iteritems():\\n mtrx[docId, self.EXTRA_WEIGHTS_LABELS.index(label)] = val\\n logging.info('Matrix generated')\\n logging.info(mtrx.shape)\\n return mtrx\",\n \"def load_embed(file_name, vocab_size):\\n\\n with tf.io.gfile.Open(file_name, 'r') as embed_file:\\n vocab = []\\n embeds = []\\n depth = -1\\n for index, line in enumerate(embed_file):\\n if vocab_size > 0 and index >= vocab_size:\\n break\\n line = line.strip()\\n tokens = line.strip().split(' ')\\n word = tokens[0]\\n vocab.append(word)\\n if depth == -1:\\n embed = [float(token) for token in tokens[1:]]\\n else:\\n embed = [float(token) for token in tokens[-depth:]]\\n d = len(embed)\\n if depth == -1:\\n depth = d\\n if d != depth:\\n raise ValueError('Inconsistent embedding sizes')\\n embeds.append(embed)\\n\\n embeds = np.stack(embeds)\\n\\n return vocab, embeds, depth\",\n \"def dump_w2vdictionary(outfilename,wordlist,matrix):\\n ostream = open(outfilename,'w')\\n print('%d %d'%(len(wordlist),matrix.shape[1]),file=ostream)\\n for word,vec in zip(wordlist,matrix):\\n print(' '.join([word]+ [ str(elt) for elt in vec]),file=ostream)\\n ostream.close()\",\n \"def load(cls, filepath) -> 'Word2VecEmbedding':\\n with open(filepath, 'rb') as f:\\n embedding = pickle.load(f)\\n embedding.word2idx = {spell: idx for idx, spell in enumerate(embedding.vocab.idx2word)}\\n return embedding\",\n \"def write_vecs(self, vecs_fname):\\r\\n header = f'{self.vectors.shape[0]} {self.vectors.shape[1]}'\\r\\n np.savetxt(vecs_fname, np.hstack([self.words.reshape(-1, 1), self.vectors]), fmt='%s', header=header)\",\n \"def load_embeddings(glove_path, vocab):\\n vocab_size = vocab.get_vocab_size()\\n words_to_keep = set(vocab.get_index_to_token_vocabulary().values())\\n glove_embeddings = {}\\n embedding_dim = None\\n\\n logger.info(\\\"Reading GloVe embeddings from {}\\\".format(glove_path))\\n with open(glove_path) as glove_file:\\n for line in tqdm(glove_file,\\n total=get_num_lines(glove_path)):\\n fields = line.strip().split(\\\" \\\")\\n word = fields[0]\\n if word in words_to_keep:\\n vector = np.asarray(fields[1:], dtype=\\\"float32\\\")\\n if embedding_dim is None:\\n embedding_dim = len(vector)\\n else:\\n assert embedding_dim == len(vector)\\n glove_embeddings[word] = vector\\n\\n all_embeddings = np.asarray(list(glove_embeddings.values()))\\n embeddings_mean = float(np.mean(all_embeddings))\\n embeddings_std = float(np.std(all_embeddings))\\n logger.info(\\\"Initializing {}-dimensional pretrained \\\"\\n \\\"embeddings for {} tokens\\\".format(\\n embedding_dim, vocab_size))\\n embedding_matrix = torch.FloatTensor(\\n vocab_size, embedding_dim).normal_(\\n embeddings_mean, embeddings_std)\\n # Manually zero out the embedding of the padding token (0).\\n embedding_matrix[0].fill_(0)\\n # This starts from 1 because 0 is the padding token, which\\n # we don't want to modify.\\n for i in range(1, vocab_size):\\n word = vocab.get_token_from_index(i)\\n\\n # If we don't have a pre-trained vector for this word,\\n # we don't change the row and the word has random initialization.\\n if word in glove_embeddings:\\n embedding_matrix[i] = torch.FloatTensor(glove_embeddings[word])\\n return embedding_matrix\",\n \"def get_word_embeddings(self):\\n embedding_index = {}\\n with open('./glove/glove.6B.100d.txt', encoding=\\\"utf8\\\") as f:\\n for line in f:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embedding_index[word] = coefs\\n return embedding_index\",\n \"def save_embedding(emb, emb_dim, vocabs, save_dir, file_name):\\n\\tembedding = emb.weight.data.tolist()\\n\\n\\tnum_vocab = len(embedding)\\n\\n\\tvocab2emb = {}\\n\\tfor id in list(vocabs.index2word.keys())[:num_vocab]:\\n\\t\\tvocab2emb[vocabs.index2word[id]] = embedding[id]\\n\\t\\n\\ttry:\\n\\t\\tdel vocab2emb['<PAD>']\\n\\t\\tnum_vocab-=1\\n\\texcept:\\n\\t\\tpass\\n\\t\\n\\tpath = save_dir / (file_name + \\\".vec\\\")\\n\\twith path.open(\\\"w\\\") as ff:\\n\\t\\tff.write(str(num_vocab) + \\\" \\\" + str(emb_dim) + \\\"\\\\n\\\")\\n\\t\\tfor word, embed in vocab2emb.items():\\n\\t\\t\\tcontent = word + \\\" \\\" + \\\" \\\".join(map(str, embed)) + \\\"\\\\n\\\"\\n\\t\\t\\tff.write(content)\",\n \"def _index(self, corpus):\\n\\n # Transform documents to embeddings vectors\\n ids, dimensions, stream = self.embedder.model.index(corpus)\\n\\n # Load streamed embeddings back to memory\\n embeddings = np.empty((len(ids), dimensions), dtype=np.float32)\\n with open(stream, \\\"rb\\\") as queue:\\n for x in range(embeddings.shape[0]):\\n embeddings[x] = pickle.load(queue)\\n\\n # Remove temporary file\\n os.remove(stream)\\n\\n all_text = []\\n for para_id, text, _ in corpus:\\n all_text.append([text, para_id])\\n\\n df = pd.DataFrame(all_text, columns=[\\\"text\\\", \\\"paragraph_id\\\"])\\n\\n embedding_path = os.path.join(\\n self.index_path, self.embed_paths[\\\"embeddings\\\"])\\n dataframe_path = os.path.join(\\n self.index_path, self.embed_paths[\\\"dataframe\\\"])\\n ids_path = os.path.join(self.index_path, self.embed_paths[\\\"ids\\\"])\\n\\n # Load new data\\n if os.path.isfile(embedding_path) and (self.encoder_args[\\\"overwrite\\\"] is False):\\n logger.info(f\\\"Loading new data from {embedding_path}\\\")\\n\\n # Load existing embeddings\\n old_embeddings = np.load(embedding_path) # LOAD EMBEDDINGS\\n # Remove embeddings with document id overlaps\\n embeddings = np.vstack((old_embeddings, embeddings))\\n\\n # load IDs\\n old_ids = [doc_id[:-1] for doc_id in open_txt(ids_path)]\\n logger.debug(f\\\"New ID Length = {len(ids)}\\\")\\n logger.debug(f\\\"Old ID Length = {len(old_ids)}\\\")\\n # Remove document ids overlaps\\n logger.debug(f\\\"New ID Length = {len(ids)}\\\")\\n ids = old_ids + ids\\n logger.debug(f\\\"Merged ID Length = {len(ids)}\\\")\\n\\n # Append new dataframe\\n old_df = pd.read_csv(dataframe_path)\\n df = pd.concat([old_df, df])\\n\\n # Store embeddings and document index\\n # for future reference\\n np.save(embedding_path, embeddings)\\n with open(ids_path, \\\"w\\\") as fp:\\n fp.writelines([i + \\\"\\\\n\\\" for i in ids])\\n\\n # Save data csv\\n df.to_csv(dataframe_path, index=False)\\n\\n # Normalize embeddings\\n self.embedder.normalize(embeddings)\\n\\n # Save embeddings metadata\\n self.embedder.config[\\\"ids\\\"] = ids\\n self.embedder.config[\\\"dimensions\\\"] = dimensions\\n\\n # Create embeddings index\\n logger.info(f\\\"Creating embeddings and index\\\")\\n self.embedder.embeddings = ANN.create(self.embedder.config)\\n logger.info(f\\\"Created embeddings\\\")\\n\\n # Build the index\\n self.embedder.embeddings.index(embeddings)\\n logger.info(f\\\"Built the embeddings index\\\")\",\n \"def load_model(self, file=FILENAME, dim=DIMENSION, normalize=False):\\n print(\\\"Loading pretrained Glove vectors from file {}\\\".format(FILENAME))\\n self.dimension = dim\\n self.normalize = normalize\\n with open(file, \\\"r\\\", encoding=\\\"utf-8\\\") as textfile:\\n self.num_tokens = count_lines(textfile)\\n self.tokens_arr = [\\\"\\\" for i in range(self.num_tokens)]\\n self.embeddings_mat = np.zeros((self.num_tokens, self.dimension))\\n\\n for idx, line in enumerate(textfile):\\n line = line.split()\\n token = ''.join(line[:-self.dimension])\\n self.tokens_arr[idx] = token\\n self.token_to_idx[token] = idx \\n vec = list(map(float, line[-self.dimension:]))\\n if self.normalize: \\n # normalize the vectors as they are put into the matrix\\n vec = vec / np.linalg.norm(vec)\\n self.embeddings_mat[idx] = vec \\n if (idx+1) % 200000 == 0:\\n print(\\\" --{}% loaded.\\\".format(round(idx/self.num_tokens*100, 2)))\\n print(\\\"Finished loading Glove model. {} vectors loaded\\\".format(self.num_tokens))\",\n \"def get_embeddings(emb_path, emb_length, vocab_size, embedding_type):\\n print(\\\"Loading {} embeddings from file: {}...\\\".format(embedding_type, emb_path))\\n\\n emb_matrix = []\\n str2id = {}\\n idx = 0\\n with open(emb_path, 'r') as fh:\\n for line in tqdm(fh, total=vocab_size):\\n line = line.lstrip().rstrip().split(\\\" \\\")\\n word = line[0]\\n vector = list(map(float, line[1:]))\\n if emb_length != len(vector):\\n raise Exception(\\n \\\"{}: Expected vector of size {}, but got vector of size {}.\\\".format(idx, emb_length, len(vector)))\\n emb_matrix.append(vector)\\n str2id[word] = idx\\n idx += 1\\n\\n emb_matrix = np.array(emb_matrix, dtype=np.float32)\\n print(\\\"Loaded {} embedding matrix with shape {}.\\\".format(embedding_type, emb_matrix.shape))\\n\\n return emb_matrix, str2id\",\n \"def build_vocab(path, fname):\\r\\n\\twords = open(path, 'r', encoding='utf-8').read().split()\\r\\n\\twordCount = Counter(words)\\r\\n\\tif not os.path.exists(pm.vocab_path):\\r\\n\\t\\tos.makedirs(pm.vocab_path)\\r\\n\\twith open(pm.vocab_path + fname, 'w', encoding='utf-8') as f:\\r\\n\\t\\tf.write(\\\"{}\\\\t1000000000\\\\n{}\\\\t1000000000\\\\n{}\\\\t1000000000\\\\n{}\\\\t1000000000\\\\n\\\".format(\\\"<PAD>\\\", \\\"<UNK>\\\", \\\"<SOS>\\\", \\\"<EOS>\\\"))\\r\\n\\t\\tfor word, count in wordCount.most_common(len(wordCount)):\\r\\n\\t\\t\\tf.write(u\\\"{}\\\\t{}\\\\n\\\".format(word, count))\",\n \"def load_vec(fname, vocab, binary = True):\\n print(\\\" Loading word2vec...\\\")\\n #w2v_cache = \\\"cache\\\\\\\\w2v\\\"\\n #if os.path.isfile(w2v_cache):\\n # return cPickle.load(open(w2v_cache,\\\"rb\\\"))\\n\\n mode = (\\\"rb\\\" if binary else \\\"r\\\")\\n word_vecs = {}\\n with open(fname, mode) as f:\\n header = f.readline()\\n vocab_size, layer1_size = map(int, header.split())\\n binary_len = numpy.dtype('float32').itemsize * layer1_size\\n\\n def getline():\\n if binary:\\n return numpy.fromstring(f.read(binary_len), dtype='float32')\\n else:\\n return numpy.array(f.readline().split(), dtype='float32')\\n\\n for line in xrange(vocab_size):\\n word = []\\n while True:\\n ch = f.read(1)\\n if ch == ' ':\\n word = ''.join(word)\\n break\\n if ch != '\\\\n':\\n word.append(ch)\\n if word in vocab:\\n word_vecs[word] = getline()\\n else:\\n getline()\\n print(\\\" Loaded word2vec...\\\")\\n# cPickle.dump(word_vecs, open(w2v_cache, \\\"wb\\\"))\\n return word_vecs\",\n \"def read_parse_write(tokenizer: BertTokenizer, bert_client: BertClient, infile: str, outfile: str, mode) -> None:\\n reader = Reader()\\n insts = reader.read_txt(infile, -1)\\n f = open(outfile, 'wb')\\n all_vecs = []\\n all_sents = []\\n for inst in insts:\\n all_sents.append(inst.input.words)\\n for sent in tqdm(all_sents, desc=\\\"BERT encoding\\\"):\\n word_piece_tokens, word_to_piece_index = bert_tokenize_words(tokenizer, sent, mode=mode)\\n bert_vec =np.squeeze(bert_client.encode([word_piece_tokens], is_tokenized=True),\\n axis=0)[1:-1, :] ## exclude the [CLS] and [SEP]\\n bert_vec = bert_vec[word_to_piece_index, :]\\n print(bert_vec.shape)\\n all_vecs.append(bert_vec)\\n\\n print(\\\"Finishing embedding BERT sequences, saving the vector files.\\\")\\n pickle.dump(all_vecs, f)\\n f.close()\",\n \"def index_embedding_words(embedding_file):\\n words = set()\\n with open(embedding_file, encoding='utf-8') as f:\\n for line in f:\\n w = Dictionary.normalize(line.rstrip().split(' ')[0])\\n words.add(w)\\n return words\",\n \"def index_embedding_words(embedding_file):\\n words = set()\\n with open(embedding_file) as f:\\n for line in f:\\n w = Dictionary.normalize(line.rstrip().split(' ')[0])\\n words.add(w)\\n return words\",\n \"def load_document_embeddings(path):\\n embedding_dimension = 0\\n \\n # First pass to work out maximum topic ID to create numpy embeddings\\n with open(path, 'rb') as avro_file:\\n avro_reader = reader(avro_file)\\n for document_embedding in avro_reader:\\n topic_probs = document_embedding['topic_probs']\\n \\n for topic_prob in topic_probs:\\n topic_id = topic_prob['topic_id']\\n if topic_id + 1 > embedding_dimension:\\n embedding_dimension = topic_id + 1\\n \\n # Second pass to actually store the embeddings\\n x = []\\n y = []\\n \\n with open(path, 'rb') as avro_file:\\n avro_reader = reader(avro_file)\\n for document_embedding in avro_reader:\\n label = document_embedding['label']\\n topic_probs = document_embedding['topic_probs']\\n \\n embedding = np.zeros(shape=embedding_dimension, dtype=np.float32)\\n \\n for topic_prob in topic_probs:\\n topic_id = topic_prob['topic_id']\\n prob = topic_prob['prob']\\n embedding[topic_id] = prob\\n \\n x.append(embedding)\\n y.append(label)\\n \\n return x, y\",\n \"def load_kb_embeddings(path_to_folder):\\n\\n entity2idx = {}\\n allowed_indices = set()\\n with open(\\\"data/entity2id.filtered.txt\\\", 'r') as f:\\n for l in f.readlines():\\n k, v, idx = tuple(l.strip().split(\\\"\\\\t\\\"))\\n entity2idx[k] = int(idx) + 3\\n allowed_indices.add(int(v))\\n\\n embeddings = []\\n with open(path_to_folder + \\\"/entity2vec.vec\\\", 'r') as f:\\n idx = 0\\n for line in f.readlines():\\n if idx in allowed_indices:\\n split = line.strip().split('\\\\t')\\n embeddings.append([float(num) for num in split])\\n idx += 1\\n\\n entity2idx[all_zeroes] = 0 # 0 is reserved for padding\\n entity2idx[unknown_el] = 1 # 1 is reserved for OOV\\n entity2idx[no_annotation] = 2 # 2 is reserved for no annotation tokens\\n embedding_size = len(embeddings[0])\\n vector_oov = 2 * 0.1 * np.random.rand(embedding_size) - 0.1\\n vector_na = 2 * 0.1 * np.random.rand(embedding_size) - 0.1\\n embeddings = np.asarray([[0.0]*embedding_size, vector_oov, vector_na] + embeddings, dtype='float32')\\n\\n print(\\\"KB embeddings loaded: {}\\\".format(embeddings.shape))\\n assert len(entity2idx) == len(embeddings)\\n\\n return entity2idx, embeddings\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71148777","0.6811717","0.66535574","0.6645278","0.6578764","0.65542287","0.65381473","0.6517769","0.65073204","0.6506877","0.6471639","0.64159757","0.6356227","0.6192997","0.6183885","0.61746114","0.6166684","0.61592853","0.6129667","0.6122645","0.6088486","0.60813224","0.60772914","0.6042444","0.60298187","0.6023485","0.6022087","0.60171074","0.6014173","0.6008453","0.6008453","0.59816074","0.59710693","0.5967253","0.59616196","0.5912518","0.5895809","0.588005","0.58632416","0.58617383","0.58563566","0.58541507","0.58519274","0.58469146","0.5836216","0.5832418","0.58237845","0.5806099","0.5790942","0.57888454","0.57771164","0.5765494","0.5758492","0.57237804","0.57122403","0.5703389","0.5701977","0.568764","0.56809884","0.5668694","0.5653646","0.5649044","0.56363374","0.5636334","0.56261283","0.56094986","0.56017107","0.55994207","0.55980456","0.55748093","0.55699784","0.5555976","0.5555858","0.55527455","0.55505294","0.5544518","0.55284244","0.5521909","0.5518164","0.55066353","0.5497087","0.54915684","0.5479812","0.5473824","0.546045","0.54562503","0.54539007","0.54495054","0.544351","0.54377824","0.54331636","0.5423207","0.5421899","0.5420104","0.54017496","0.54003096","0.5394041","0.53881335","0.5383519","0.5378857"],"string":"[\n \"0.71148777\",\n \"0.6811717\",\n \"0.66535574\",\n \"0.6645278\",\n \"0.6578764\",\n \"0.65542287\",\n \"0.65381473\",\n \"0.6517769\",\n \"0.65073204\",\n \"0.6506877\",\n \"0.6471639\",\n \"0.64159757\",\n \"0.6356227\",\n \"0.6192997\",\n \"0.6183885\",\n \"0.61746114\",\n \"0.6166684\",\n \"0.61592853\",\n \"0.6129667\",\n \"0.6122645\",\n \"0.6088486\",\n \"0.60813224\",\n \"0.60772914\",\n \"0.6042444\",\n \"0.60298187\",\n \"0.6023485\",\n \"0.6022087\",\n \"0.60171074\",\n \"0.6014173\",\n \"0.6008453\",\n \"0.6008453\",\n \"0.59816074\",\n \"0.59710693\",\n \"0.5967253\",\n \"0.59616196\",\n \"0.5912518\",\n \"0.5895809\",\n \"0.588005\",\n \"0.58632416\",\n \"0.58617383\",\n \"0.58563566\",\n \"0.58541507\",\n \"0.58519274\",\n \"0.58469146\",\n \"0.5836216\",\n \"0.5832418\",\n \"0.58237845\",\n \"0.5806099\",\n \"0.5790942\",\n \"0.57888454\",\n \"0.57771164\",\n \"0.5765494\",\n \"0.5758492\",\n \"0.57237804\",\n \"0.57122403\",\n \"0.5703389\",\n \"0.5701977\",\n \"0.568764\",\n \"0.56809884\",\n \"0.5668694\",\n \"0.5653646\",\n \"0.5649044\",\n \"0.56363374\",\n \"0.5636334\",\n \"0.56261283\",\n \"0.56094986\",\n \"0.56017107\",\n \"0.55994207\",\n \"0.55980456\",\n \"0.55748093\",\n \"0.55699784\",\n \"0.5555976\",\n \"0.5555858\",\n \"0.55527455\",\n \"0.55505294\",\n \"0.5544518\",\n \"0.55284244\",\n \"0.5521909\",\n \"0.5518164\",\n \"0.55066353\",\n \"0.5497087\",\n \"0.54915684\",\n \"0.5479812\",\n \"0.5473824\",\n \"0.546045\",\n \"0.54562503\",\n \"0.54539007\",\n \"0.54495054\",\n \"0.544351\",\n \"0.54377824\",\n \"0.54331636\",\n \"0.5423207\",\n \"0.5421899\",\n \"0.5420104\",\n \"0.54017496\",\n \"0.54003096\",\n \"0.5394041\",\n \"0.53881335\",\n \"0.5383519\",\n \"0.5378857\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69728744"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84895,"cells":{"query":{"kind":"string","value":"Helper function to add new token to self.word2idx and embedding to self.embeddings"},"document":{"kind":"string","value":"def add_embedding(self, token, embedding):\n self.word2idx[token] = self.vocab_size\n self.vocab_size += 1\n\n self.embedding = np.vstack((self.embedding, embedding))"},"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 add_to_dict(self, tokens):\n# TODO: ?add normalization of a token?\n for token in tokens:\n if self.embedding_words and (token not in self.embedding_words):\n continue\n self.freq[token] += 1\n if token not in self.tok2ind:\n index = len(self.tok2ind)\n self.tok2ind[token] = index\n self.ind2tok[index] = token","def index_word(self, token):\n if token not in self.word_2_idx:\n idx = len(self.word_2_idx)\n self.word_2_idx[token] = idx\n self.idx_2_word[idx] = token","def to_token_embedding(self, tokens, unknown_behavior='impute_raise',\n batch_size=1024, ctx=cpu()):\n\n new_embedding = emb.TokenEmbedding(unknown_token=None)\n new_embedding._token_to_idx.update(\n (token, idx) for idx, token in enumerate(tokens))\n new_embedding._idx_to_token = tokens\n new_idx_to_vec = []\n\n # Compute embeddings in batches for all idx\n start_pointer = 0\n end_pointer = batch_size\n while True:\n batch = tokens[start_pointer:end_pointer]\n batch_embedding = self._to_token_embedding_batch(\n batch, unknown_behavior, ctx)\n new_idx_to_vec.append(batch_embedding.as_in_context(cpu()))\n\n if end_pointer >= len(tokens):\n break\n start_pointer += batch_size\n end_pointer += batch_size\n\n new_idx_to_vec = nd.concat(*new_idx_to_vec, dim=0)\n new_embedding._idx_to_vec = new_idx_to_vec\n return new_embedding","def add_special_tokens_(model, tokenizer, update_model=True):\n orig_num_tokens = len(tokenizer)\n num_added_tokens = tokenizer.add_special_tokens(ATTR_TO_SPECIAL_TOKEN) # doesn't add if they are already there\n #print(\"coab::\",len(tokenizer.vocab))\n if (num_added_tokens > 0 and update_model):\n model.encoder.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\n model.decoder.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\n #print(model.encoder.embeddings.word_embeddings.weight.shape)\n #print(model.decoder.bert.embeddings.word_embeddings.weight.shape)","def add_special_tokens_(model, tokenizer):\n orig_num_tokens = len(tokenizer.encoder)\n num_added_tokens = tokenizer.add_special_tokens(ATTR_TO_SPECIAL_TOKEN) # doesn't add if they are already there\n if num_added_tokens > 0:\n model.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)","def add_token(\r\n self,\r\n ind: int,\r\n w: str,\r\n ) -> AddToken:\r\n self.t = self.t + 1\r\n content = self._encrypt_update(self.t, Op.ADD, ind, w)\r\n return self.sigma.add_token(content, w)","def add_word_embedding_op(self):\n if self.pos:\n print(\"adding pos embeddings\")\n with tf.variable_scope(\"pos\"):\n _pos_embeddings = tf.Variable(self.pos_embeddings,\n name=\"la_pos_embeddings\",\n dtype=tf.float32, trainable=False)\n pos_embeddings = tf.nn.embedding_lookup(_pos_embeddings, self.pos_ids,\n name=\"pos_embeddings\")\n self.pos_vecs = pos_embeddings\n print(\"adding word_embeddings\")\n with tf.variable_scope(\"words\"):\n _word_embeddings = tf.Variable(self.embeddings, name=\"_word_embeddings\",\n dtype=tf.float32, trainable=False)\n word_embeddings = tf.nn.embedding_lookup(_word_embeddings,\n self.word_ids,\n name=\"word_embeddings\")\n if self.use_window:\n print(\"Concatenating word vectors of context words\")\n word_embeddings_sl = tf.nn.embedding_lookup(_word_embeddings,\n self.word_ids_sl,\n name=\"word_embeddings_sl\")\n word_embeddings_sr = tf.nn.embedding_lookup(_word_embeddings,\n self.word_ids_sr,\n name=\"word_embeddings_sr\")\n word_embeddings = tf.concat([word_embeddings_sr, word_embeddings,\n word_embeddings_sl], axis=-1)\n if self.use_char_embeddings:\n print(\"adding CNN for char embeddings\")\n with tf.variable_scope(\"chars\"):\n _char_embeddings = tf.get_variable(name=\"_char_embeddings\",\n dtype=tf.float32,\n shape=[self.char_count, \n self.c_dim_input])\n char_embeddings = tf.nn.embedding_lookup(_char_embeddings, \n self.char_ids, \n name=\"char_embeddings\")\n s = char_embeddings.shape\n # the shape of our char_embeddings is now (batch_size, max number of words\n # in each sentence, max number of chars in each word, self.c_dim )\n char_filter = tf.get_variable(\"char_filter\", dtype=tf.float32,\n shape=[self.c_filter_width, \n self.c_filter_height,\n self.c_dim_input,\n self.c_dim_output])\n print(\"adding 2d convolution layer\")\n char_conv_layer = tf.nn.conv2d(char_embeddings, char_filter, \n strides=[1, 1, 1, 1], \n padding=\"SAME\")\n char_conv_layer = tf.nn.tanh(char_conv_layer)\n print(\"adding 2d pooling layer\")\n char_conv_layer = tf.layers.max_pooling2d(char_conv_layer, \n 1, \n strides=1)\n char_output = tf.reshape(char_conv_layer, shape=[-1, self.max_len, \n self.max_word_length*\n self.c_dim_output])\n word_embeddings = tf.concat([word_embeddings, char_output], axis=-1)\n if self.pos and self.concat_pos:\n print(\"concatenating pos with word_embeddings\")\n word_embeddings = tf.concat([word_embeddings, pos_embeddings], axis=-1)\n self.word_embeddings = word_embeddings\n if self.use_additional and self.hybrid:\n print(\"using additional embeddings\")\n _word_embeddings_2 = tf.Variable(self.additional_embeddings,\n name=\"two_word_embeddings\",\n dtype=tf.float32, trainable=False)\n word_embeddings_2 = tf.nn.embedding_lookup(_word_embeddings_2,\n self.word_ids,\n name=\"two_word_embeddings\")\n self.word_embeddings_2 = word_embeddings_2","def add(self, document):\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\n if not token.isalpha():\n continue\n\n if token in self.stopwords:\n continue\n \n if self.stemmer:\n token = self.stemmer.stem(token)\n \n if self.__unique_id not in self.index[token]:\n self.index[token].append(self.__unique_id)\n \n self.documents[self.__unique_id] = document\n self.__unique_id += 1","def TransformerTokenEmbedding(\n num_embeddings, embedding_dim, padding_idx, freeze_embed=False\n):\n m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx)\n nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5)\n nn.init.constant_(m.weight[padding_idx], 0)\n if freeze_embed:\n m.weight.requires_grad = False\n return m","def _look_up(self, token):\n if self.args.add_vn:\n return tf.nn.embedding_lookup(self.embedding_matrix + \\\n tf.random.normal(tf.shape(self.embedding_matrix), stddev=0.075), token)\n\n return tf.nn.embedding_lookup(self.embedding_matrix, token)","def make_idx2word():\n idx2word = {}\n d = train_data.shared['word2idx']\n for word, idx in d.items():\n print(word)\n idx2word[idx] = word\n if config.use_glove_for_unk:\n d2 = train_data.shared['new_word2idx']\n for word, idx in d2.items():\n print(word)\n idx2word[idx+len(d)] = word\n return idx2word","def _build_token_dict(self, corpus: List[List[str]]):\n self.token2idx = self.load_from_vocab_file(self.vocab_path)\n self.idx2token = dict([(value, key)\n for key, value in self.token2idx.items()])\n logging.debug(f\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\")\n self.dataset_info['token_count'] = len(self.token2idx)","def _feed(self, SeqSeqToken, token_to_index, index_to_token):\n for SeqToken in SeqSeqToken:\n for Token in SeqToken:\n if not token_to_index.has_key(Token):\n i = len(index_to_token)\n token_to_index[Token] = i\n index_to_token.insert(i, Token)","def process_new_tokens(tokens,processed_tokens_set, model, dictionary):\n if hasattr(model, 'using_pretrained') and model.using_pretrained is not None:\n processed_tokens_set.update(tokens)\n update_embedding_layer(processed_tokens_set, model, dictionary)","def add(self, token_docid):\n token = token_docid[0]\n doc_id = token_docid[1]\n # collapse identical tokens together\n if token in self.posting:\n self.posting[token].append(doc_id)\n else:\n self.posting[token] = [doc_id]","def add(self, tokens):\n\n for token in tokens:\n self.vocab.add(token)\n\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\n if leader not in self.frequencies:\n self.frequencies[leader] = Frequency()\n\n self.frequencies[leader].add(token)","def add_token(self,token):\n\t\tif not token:\n\t\t\tlogging.error(\"Token cannot be empty!\")\n\t\t\texit()\n\n\t\tself.tokens.append(token.lower())\n\t\t#self.user_defined_token = token.lower()","def _add_pre_trained_embedding(self):\n\n if self.embedding_type['type'] == 'glove':\n self.logging.info('use pre-trained glove word2vec')\n # a. load pre trained glove\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\n import os\n import numpy as np\n\n embeddings_index = {}\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\n for line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n f.close()\n\n self.logging.info('')\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\n\n # b. compute embedding matrix\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n\n elif self.embedding_type['type'] == 'gensim':\n self.logging.info('use pre-trained gensim word2vec')\n\n import gzip\n import gensim\n from keras.layers import Embedding\n import numpy as np\n\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\n\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\n pretrained_weights = model.wv.syn0\n vocab_size, vector_dim = pretrained_weights.shape\n\n method = 3\n if method == 1:\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\n # into our TensorFlow and Keras models\n\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\n for i in range(len(model.wv.vocab)):\n embedding_vector = model.wv[model.wv.index2word[i]]\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\n output_dim=embedding_matrix.shape[1],\n # input_length=self.maxlen,\n weights=[embedding_matrix],\n trainable=False)\n elif method == 2:\n self.logging.info('word2vec simple embedding matching - simple complex')\n embedding_layer = Embedding(input_dim=vocab_size,\n output_dim=vector_dim,\n input_length=self.maxlen,\n weights=[pretrained_weights],\n trainable=False)\n elif method == 3:\n\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\n # b. compute embedding matrix\n\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\n\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n if word in model.wv:\n embedding_vector = model.wv[word]\n embedding_matrix[i] = embedding_vector\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt))\n\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n else:\n raise ValueError('unknown method value')\n\n else:\n raise ValueError('unknown embedding type')\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\n return embedding_layer","def replace_token_with_index(self, tokenized_tweet, max_length_dictionary):\n\n # should be replacing each token in a list of tokens by their corresponding index\n # Source: https://github.com/stanfordnlp/GloVe\n # Source: https://towardsdatascience.com/word-embeddings-for-sentiment-analysis-65f42ea5d26e\n\n if self.mode == \"zip\":\n for idx, word in enumerate(tokenized_tweet):\n if word not in self.corpus:\n tokenized_tweet[idx] = \"<unknown>\"\n else:\n for idx, word in enumerate(tokenized_tweet):\n if word not in self.corpus:\n tokenized_tweet[idx] = \"<unk>\"\n return [self.corpus.index(x) for x in tokenized_tweet]","def _add_word(self, word):\n if not word in self._word2idx.keys():\n self._word2idx[word] = self.vocab_size\n self.freqs[word] = 0\n self._idx2word[self.vocab_size] = word\n self.vocab_size += 1\n self.freqs[word] += 1","def add_word_embeddings_op(self):\n with tf.variable_scope(\"words\"):\n if self.config.embeddings is None:\n self.logger.info(\"WARNING: randomly initializing word vectors\")\n _word_embeddings = tf.get_variable(\n name=\"_word_embeddings\",\n dtype=tf.float32,\n shape=[self.config.nwords, self.config.dim_word])\n else:\n _word_embeddings = tf.Variable(\n self.config.embeddings,\n name=\"_word_embeddings\",\n dtype=tf.float32,\n trainable=self.config.train_embeddings)\n\n word_embeddings = tf.nn.embedding_lookup(_word_embeddings,\n self.word_ids, name=\"word_embeddings\")\n\n with tf.variable_scope(\"chars\"):\n if self.config.use_chars:\n # get char embeddings matrix\n _char_embeddings = tf.get_variable(\n name=\"_char_embeddings\",\n dtype=tf.float32,\n shape=[self.config.nchars, self.config.dim_char])\n char_embeddings = tf.nn.embedding_lookup(_char_embeddings,\n self.char_ids, name=\"char_embeddings\")\n\n # put the time dimension on axis=1\n s = tf.shape(char_embeddings)\n char_embeddings = tf.reshape(char_embeddings,\n shape=[s[0]*s[1], s[-2], self.config.dim_char])\n word_lengths = tf.reshape(self.word_lengths, shape=[s[0]*s[1]])\n\n # bi lstm on chars\n cell_fw = tf.contrib.rnn.LSTMCell(self.config.hidden_size_char,\n state_is_tuple=True)\n cell_bw = tf.contrib.rnn.LSTMCell(self.config.hidden_size_char,\n state_is_tuple=True)\n _output = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, char_embeddings,\n sequence_length=word_lengths, dtype=tf.float32)\n\n # read and concat output\n _, ((_, output_fw), (_, output_bw)) = _output\n output = tf.concat([output_fw, output_bw], axis=-1)\n\n # shape = (batch size, max sentence length, char hidden size)\n output = tf.reshape(output,\n shape=[s[0], s[1], 2*self.config.hidden_size_char])\n word_embeddings = tf.concat([word_embeddings, output], axis=-1)\n\n self.word_embeddings = tf.nn.dropout(word_embeddings, self.dropout)","def pass_word(word, model, input_embedding, char2idx, device, use_head=True):\n inp = torch.LongTensor([char2idx['START']] + [char2idx[c] for c in word]).to(device)\n inp = pack([inp])\n out, hidden = model(input_embedding.unsqueeze(0), inp, use_head=use_head)\n return out, hidden","def _init_vocab(self):\n self._word2idx = {}\n self._idx2word = {}\n self.freqs = {}\n self.vocab_size = 0\n\n self._add_word(self.pad_word)\n self._add_word(self.start_word)\n self._add_word(self.end_word)\n self._add_word(self.unk_word)\n\n self.start_word_idx = self.stoi(self.start_word)\n self.end_word_idx = self.stoi(self.end_word)\n self.unk_word_idx = self.stoi(self.unk_word)\n self.pad_word_idx = self.stoi(self.pad_word)\n\n self._special_tokens = {\n 'bos_token': self.start_word,\n 'cls_token': self.start_word,\n 'eos_token': self.end_word,\n 'sep_token': self.end_word,\n 'pad_token': self.pad_word,\n 'unk_token': self.unk_word,\n }\n\n self._special_ids = {\n 'bos_token_id': self.start_word_idx,\n 'cls_token_id': self.start_word_idx,\n 'eos_token_id': self.end_word_idx,\n 'sep_token_id': self.end_word_idx,\n 'pad_token_id': self.pad_word_idx,\n 'unk_token_id': self.unk_word_idx,\n }\n\n self.cls_token_id = self.bos_token_id = self.start_word_idx\n self.eos_token_id = self.sep_token_id = self.end_word_idx\n self.pad_token_id = self.pad_word_idx\n self.unk_token_id = self.unk_word_idx\n\n self.cls_token = self.bos_token = self.start_word\n self.eos_token = self.sep_token = self.end_word\n self.pad_token = self.pad_word\n self.unk_token = self.unk_word","def add_token(self, token):\n token = self.process_token(token)\n self._token_count.update([token])","def add_token(self, token):\n token = self.process_token(token)\n self._token_count.update([token])","def add_word(self, word):\n if word not in self.word2index:\n self.word2index[word] = self.n_words\n self.word2count[word] = 1\n self.index2word[self.n_words] = word\n self.n_words += 1\n else:\n self.word2count[word] += 1","def add_word(self, word):\n if word not in self.word2index:\n self.word2index[word] = self.n_words\n self.word2count[word] = 1\n self.index2word[self.n_words] = word\n self.n_words += 1\n else:\n self.word2count[word] += 1","def add_word(self):\n word = self.word # easier to call word now\n\n wordlist_path = self.get_wordlist_path()\n with open(wordlist_path) as f:\n data = json.load(f)\n\n if exists_already(data,word):\n exit()\n\n next_index = int(data[\"cur_index\"]) + 1 # new index\n data[\"words\"][next_index] = word # update wordlist\n data[\"words\"] = dict(sorted(data[\"words\"].items(), key=lambda item: item[1])) # alphabetisize\n data[\"cur_index\"] = next_index # update index\n\n with open(wordlist_path, 'w') as f:\n json.dump(data, f, indent = 4)\n\n print(f\"[{word}] added to [{self.pos}]. This is the [{next_index}] indexed word added.\")","def add_paragram(self):\n num_new_words = 720000\n new_embeddings = np.empty((num_new_words, self.embedding_size))\n concat_emb = np.zeros((2, self.embedding_size))\n new_word2idx = dict()\n new_words_count = 0\n\n self.load_all()\n fi = open(self.config.word_vec_fi_paragram, \"r\", encoding=\"utf8\",\n errors='ignore')\n embed_gen = self.embeddings_file_gen(fi)\n\n for token, embedding in embed_gen:\n if token not in self.word2idx:\n new_word2idx[token] = self.vocab_size\n new_embeddings[new_words_count, :] = embedding\n self.vocab_size += 1\n new_words_count += 1\n else:\n concat_emb[0, :] = self.embedding[self.word2idx[token]]\n concat_emb[1, :] = embedding\n self.embedding[self.word2idx[token]] = np.mean(\n concat_emb,\n axis=0\n )\n\n self.word2idx.update(new_word2idx)\n self.embedding = np.vstack((\n self.embedding,\n new_embeddings[:new_words_count, :]\n ))\n\n self.write_all()\n fi.close()","def index_new_tweet(self, id_str, tweet_tokens: list):\n self.tweet_count += 1\n unique_words = set(tweet_tokens)\n unique_word_pairs = set()\n for i in unique_words:\n for j in unique_words - {i}:\n # To us [a, b] = [b, a], and sorting gives us a distinct representation.\n unique_word_pairs.add(tuple(sorted([i, j])))\n for w in unique_words | unique_word_pairs:\n self.index[self.epoch][w] = id_str\n current_freq = self.frequency_map.get(w, 0)\n self.frequency_map[w] = current_freq + 1\n # Get word statistics from hash table\n statistics_present = w in self.stats_map\n if not statistics_present:\n (mu, sigma) = (math.inf, math.inf)\n for h in self.hash_functions:\n c = get_hash(h(), repr(w)) % 2 ** self.bit_count\n if self.buckets[c][\"ewma\"] < mu:\n mu = self.buckets[c][\"ewma\"]\n sigma = self.buckets[c][\"ewmvar\"]\n self.stats_map[w] = (mu, sigma)\n (mu, sigma) = self.stats_map[w]\n # Test for significance threshold\n x = self.frequency_map[w]\n if self._is_frequency_significant(mu, sigma, x):\n self.refinement.append((w, self._get_significance(mu, sigma, x)))\n # if self.refinement:\n # r = self.refinement\n # self.refinement = []\n # return r","def _update_feature_vec(fvec, word, tag_ngram):","def add_unknown_token(self):\n self.load_all()\n sample_idxs = np.random.randint(0, self.embedding.shape[0],\n self.config.embedding_sample_size)\n unknown_vector = np.mean(self.embedding[sample_idxs, :], axis=0)\n\n self.add_embedding(self.config.unknown_token, unknown_vector)\n self.write_all()","def add_embedding(self):\n ### YOUR CODE HERE (~4-6 lines)\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\n ### END YOUR CODE\n return embeddings","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.pretrained_word_mat = tf.get_variable(\"word_emb_mat\",\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[2:],\n dtype=tf.float32),\n trainable=False)\n self.word_pad_unk_mat = tf.get_variable(\"word_unk_pad\",\n [2, self.pretrained_word_mat.get_shape()[1]],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[:2],\n dtype=tf.float32),\n trainable=True)\n\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)","def add_vocab_word(self, word):\n # If it's a special token, it'll be separatelly processed during saving file. Skip here.\n if word in special_tokens:\n return\n # Check each character in the word. We don't want none-character (control code) in the vocaburary.\n for char in word:\n if cu.is_none_char(char):\n return\n # If it's a new word, store it.\n if (not word in self.words_ext) and (not word in self.words_new):\n self.words_new.append(word)","def analyze_corpus(self,\n x: Union[Tuple[List[List[str]], ...], List[List[str]]],\n y: Union[List[List[Any]], List[Any]]):\n if len(self.processor.token2idx) == 0:\n self._build_token2idx_from_gpt()\n super(GPT2Embedding, self).analyze_corpus(x, y)","def add_tokens(self, sample):\n # Text\n inputs = self._tokenizer.encode_plus(sample['text'],\n add_special_tokens=True,\n max_length=self._max_text_length,\n padding='max_length', # TODO padding here or in model (together with item_glove)?\n truncation=True, # truncate to 512 (added for MSNBC dataset)\n return_attention_mask=True)\n # TODO warn if text was truncated\n #if len(TODO) > self._max_text_length:\n # self._logger.info(f'Truncate long input sentence ({len(TODO)} tokens) to {self._max_text_length}')\n sample['text_tokenized'] = inputs['input_ids']\n sample['text_attention_mask'] = inputs['attention_mask']\n # Item name (mention/surface form)\n inputs = self._tokenizer.encode(sample['item_name'],\n add_special_tokens=False)\n sample['item_name_tokenized'] = inputs","def _resize_token_embeddings(\n cls, model: PreTrainedModel, tokenizer_wrapper: TokenizerWrapper\n ):\n if tokenizer_wrapper.num_added_special_tokens > 0:\n model.resize_token_embeddings(\n new_num_tokens=len(tokenizer_wrapper.tokenizer)\n )","def _add_seq2seq(self):\n hps = self._hps\n vsize = self._vocab.size() # size of the vocabulary\n \n with tf.variable_scope('seq2seq'):\n # Some initializers\n self.rand_unif_init = tf.random_uniform_initializer(-hps.rand_unif_init_mag, hps.rand_unif_init_mag, seed=123)\n self.trunc_norm_init = tf.truncated_normal_initializer(stddev=hps.trunc_norm_init_std)\n\n\n with tf.variable_scope('embedding'):\n if hps.pretrained_embeddings:\n word2vec = load_embeddings(hps.embeddings_path, self._vocab.word2id, hps.rand_unif_init_mag)\n self.embedding = tf.get_variable('embedding', [vsize, hps.emb_dim],\n dtype=tf.float32, initializer=tf.constant_initializer(word2vec))\n # self.assign_embedding = tf.assign(self.embedding, word2vec)\n else:\n self.embedding = tf.get_variable('embedding', [vsize, hps.emb_dim],\n dtype=tf.float32, initializer=self.trunc_norm_init)\n if hps.mode==\"train\": self._add_emb_vis(self.embedding) # add to tensorboard\n\n # tensor with shape (batch_size, max_enc_steps, emb_size)\n emb_enc_inputs = tf.nn.embedding_lookup(self.embedding, self._enc_batch)\n if self._hps.hier:\n enc_batch_sections = tf.unstack(self._enc_batch_sections, axis=1)\n sec_emb_enc_inputs = [tf.nn.embedding_lookup(self.embedding, section)\n for section in enc_batch_sections]\n # list length max_dec_steps containing shape (batch_size, emb_size)\n emb_dec_inputs = [tf.nn.embedding_lookup(self.embedding, x)\n for x in tf.unstack(self._dec_batch, axis=1)]\n\n\n # Hierarchical attention model\n if self._hps.hier:\n with tf.variable_scope('encoder'), tf.device(self._next_device()):\n sec_enc_outs = []\n states_fw = []\n states_bw = []\n states = []\n\n # level 1, encode words to sections\n with tf.variable_scope(\"word_level_encoder\", reuse=tf.AUTO_REUSE) as scope:\n encoder_outputs_words = []\n cell_fw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n cell_bw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n fw_st, bw_st = None, None\n if self._hps.use_do: # DropOut\n cell_fw = tf.contrib.rnn.DropoutWrapper(cell_fw, output_keep_prob=1.0 - self._hps.do_prob)\n cell_bw = tf.contrib.rnn.DropoutWrapper(cell_bw, output_keep_prob=1.0 - self._hps.do_prob)\n for i in range(self._hps.num_sections):\n encoder_tmp_output, (fw_st, bw_st) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, inputs=sec_emb_enc_inputs[i], dtype=tf.float32,\n sequence_length=self._batch_sections_len[:,i], swap_memory=True, initial_state_bw=bw_st, initial_state_fw=fw_st)\n # concatenate the forwards and backwards states\n encoder_tmp_output = tf.concat(axis=2, values=encoder_tmp_output) #shape=[batch x seq_len x hidden_size]\n \n encoder_outputs_words.append(encoder_tmp_output)\n # instead of concating the fw and bw states, we use a ff network\n combined_state = self._reduce_states(fw_st, bw_st)\n states.append(combined_state)\n scope.reuse_variables()\n \n # level 2, encode sections to doc\n encoder_outputs_words = tf.stack(encoder_outputs_words, axis=1) # shape [batch x num_sections x seq_len x hidden_size]\n shapes = encoder_outputs_words.shape\n encoder_outputs_words = tf.reshape(encoder_outputs_words, (shapes[0].value, -1, shapes[-1].value)) #shape=[batch x (seq_len * num_sections) x hidden_size]\n\n doc_sections_h = tf.stack([s.h for s in states], axis=1) # [batch x num_sections x hidden_size]\n doc_sections_c = tf.stack([s.c for s in states], axis=1) # [batch x num_sections x hidden_size]\n\n with tf.variable_scope(\"section_level_encoder\"):\n if FLAGS.section_level_encoder == 'RNN':\n cell_fw_1 = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n cell_bw_1 = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n if self._hps.use_do:\n cell_fw_1 = tf.contrib.rnn.DropoutWrapper(cell_fw_1, output_keep_prob=1.0 - self._hps.do_prob)\n cell_bw_1 = tf.contrib.rnn.DropoutWrapper(cell_bw_1, output_keep_prob=1.0 - self._hps.do_prob)\n encoder_output_sections, (fw_st_2, bw_st_2) =\\\n tf.nn.bidirectional_dynamic_rnn(cell_fw_1, cell_bw_1, inputs=doc_sections_h, sequence_length=self._doc_sec_lens, dtype=tf.float32, swap_memory=True)\n encoder_output_sections = tf.concat(axis=2, values=encoder_output_sections)\n doc_sections_state = self._reduce_states(fw_st_2, bw_st_2)\n else:\n if FLAGS.section_level_encoder == 'AVG': # average section cells\n doc_sections_state_h = tf.reduce_mean(doc_sections_h, axis=1)\n doc_sections_state_c = tf.reduce_mean(doc_sections_c, axis=1)\n elif FLAGS.section_level_encoder == 'FF': # use a feedforward network to combine section cells\n doc_sections_state_h = tf.reshape([doc_sections_h.shape[0].eval(), -1])\n doc_sections_state_h = tf.layers.dense(\n inputs=doc_sections_state_h,\n units=self._hps.hidden,\n activation=tf.nn.relu) \n doc_sections_state_c = tf.reshape([doc_sections_c.shape[0].eval(), -1])\n doc_sections_state_c = tf.layers.dense(\n inputs=doc_sections_state_c,\n units=self._hps.hidden,\n activation=tf.nn.relu)\n else:\n raise AttributeError('FLAGS.section_level_encoder={} is not a valid option'.format(FLAGS.section_level_encoder))\n doc_sections_state = tf.contrib.rnn.LSTMStateTuple(doc_sections_state_c, doc_sections_state_h)\n encoder_output_sections = doc_sections_h \n \n elif not self._hps.multi_layer_encoder:\n with tf.variable_scope('encoder'):\n with tf.variable_scope('word_level_encoder'):\n cell_fw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n cell_bw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n (encoder_outputs, (fw_st, bw_st)) =\\\n tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs=emb_enc_inputs, dtype=tf.float32, sequence_length=self._enc_lens, swap_memory=True)\n # concatenate the forwards and backwards states\n encoder_outputs = tf.concat(axis=2, values=encoder_outputs)\n \n # stack n layers of lstms for encoder\n elif self._hps.multi_layer_encoder:\n # TODO: check\n for layer_i in xrange(self._hps.enc_layers):\n with tf.variable_scope('encoder%d'%layer_i), tf.device(\n self._next_device()):\n cell_fw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n cell_bw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n if self._hps.use_do: # add dropout\n cell_fw = tf.contrib.rnn.DropoutWrapper(cell_fw, output_keep_prob=1.0 - self._hps.do_prob)\n cell_bw = tf.contrib.rnn.DropoutWrapper(cell_bw, output_keep_prob=1.0 - self._hps.do_prob)\n emb_enc_inputs, (fw_st, bw_st) =\\\n tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs=emb_enc_inputs, dtype=tf.float32, sequence_length=self._enc_lens, swap_memory=True)\n emb_enc_inputs = tf.concat(axis=2, values=emb_enc_inputs)\n encoder_outputs = emb_enc_inputs\n \n if self._hps.hier:\n self._enc_sec_states = encoder_output_sections\n self._enc_states = encoder_outputs_words \n else:\n self._enc_states = encoder_outputs\n self._enc_sec_states = None\n \n # convert the encoder bidirectional hidden state to the decoder state\n # (unidirectional) by an MLP\n if self._hps.hier:\n self._dec_in_state = doc_sections_state\n else:\n with tf.variable_scope('encoder'):\n with tf.variable_scope('word_level_encoder'):\n self._dec_in_state = self._reduce_states(fw_st, bw_st) \n \n # Add the decoder\n\n with tf.variable_scope('decoder'), tf.device(self._next_device()):\n cell = tf.contrib.rnn.LSTMCell(\n self._hps.hidden_dim,\n state_is_tuple=True,\n initializer=self.rand_unif_init)\n \n # We need to pass in the previous step's coverage vector each time\n prev_coverage = self.prev_coverage\\\n if hps.mode==\"decode\" and self._hps.coverage \\\n else None \n \n \n if self._hps.hier:\n decoder_outputs, self._dec_out_state, self.attn_dists, self.p_gens, self.coverage, self.attn_dists_sec =\\\n self.attn_decoder(emb_dec_inputs,\n self._dec_in_state,\n self._enc_states,\n cell,\n self._enc_sec_states,\n num_words_section=self._batch_sections_len,\n enc_padding_mask=self._enc_padding_mask,\n enc_section_padding_mask=self._enc_section_padding_mask,\n initial_state_attention=(self._hps.mode==\"decode\"),\n pointer_gen=self._hps.pointer_gen,\n use_coverage=self._hps.coverage,\n prev_coverage=prev_coverage,\n temperature=self._hps.temperature\n )\n \n else:\n decoder_outputs, self._dec_out_state, self.attn_dists, self.p_gens, self.coverage, _ =\\\n self.attn_decoder(emb_dec_inputs,\n self._dec_in_state,\n self._enc_states,\n cell,\n encoder_section_states=None,\n num_words_section=None,\n enc_padding_mask=self._enc_padding_mask,\n initial_state_attention=(self._hps.mode==\"decode\"),\n pointer_gen=self._hps.pointer_gen,\n use_coverage=self._hps.coverage,\n prev_coverage=prev_coverage,\n ) \n \n\n # Project decoder output to vocabulary\n with tf.variable_scope('output_projection'), tf.device(self._next_device()):\n if self._hps.output_weight_sharing:\n # share weights of embedding layer with projection\n # self.embedding is in shape [vsize, hps.emb_dim]\n w_proj = tf.get_variable('w_proj', [self._hps.emb_dim, self._hps.hidden_dim],\n dtype=tf.float32, initializer=self.trunc_norm_init)\n w = tf.tanh(tf.transpose(tf.matmul(self.embedding, w_proj))) # shape = [vsize, hps.hidden_dim]\n \n # w_t = tf.transpose(w)\n b = tf.get_variable('b', [vsize],\n dtype=tf.float32, initializer=self.trunc_norm_init)\n else: \n w = tf.get_variable('w', [self._hps.hidden_dim, vsize],\n dtype=tf.float32, initializer=self.trunc_norm_init)\n # w_t = tf.transpose(w)\n b = tf.get_variable('b', [vsize],\n dtype=tf.float32, initializer=self.trunc_norm_init)\n # vocabulary score at each decoder step\n vocab_scores = []\n for i,output in enumerate(decoder_outputs):\n if i > 0:\n tf.get_variable_scope().reuse_variables()\n vocab_scores.append(tf.nn.xw_plus_b(output, w, b)) # apply the linear layer\n\n # the final vocab distribution for each decoder time step\n # shape of each element is [batch_size, vsize]\n vocab_dists = [tf.nn.softmax(s) for s in vocab_scores] \n\n \n # pointing / generating\n if FLAGS.pointer_gen:\n final_dists = self._calc_final_dist(vocab_dists, self.attn_dists)\n# log_dists = [tf.log(dist) for dist in final_dists]\n else:\n# log_dists = [tf.log(dist) for dist in vocab_dists]\n final_dists = vocab_dists\n \n\n # Calculate Losses:\n \n if self._hps.mode in ['train', 'eval']:\n # Calculate the loss\n with tf.variable_scope('loss'), tf.device(self._next_device()):\n if FLAGS.pointer_gen:\n # Calculate the loss per step\n # This is fiddly; we use tf.gather_nd to pick out the gold target words\n # will be list length max_dec_steps containing shape (batch_size)\n loss_per_step = [] \n batch_nums = tf.range(0, limit=hps.batch_size) # shape (batch_size)\n for dec_step, dist in enumerate(final_dists):\n # The indices of the target words. shape (batch_size)\n targets = self._target_batch[:,dec_step] \n indices = tf.stack( (batch_nums, targets), axis=1) # shape (batch_size, 2)\n # shape (batch_size). loss on this step for each batch\n gold_probs = tf.gather_nd(dist, indices)\n losses = -tf.log(gold_probs)\n loss_per_step.append(losses)\n\n # Apply dec_padding_mask mask and get loss\n self._loss = _mask_and_avg(loss_per_step, self._dec_padding_mask)\n \n\n else: # baseline model\n # this applies softmax internally\n self._loss = tf.contrib.seq2seq.sequence_loss(\n tf.stack(vocab_scores, axis=1), self._target_batch, self._dec_padding_mask) # this applies softmax internally\n\n tf.summary.scalar('loss', self._loss)\n\n # Calculate coverage loss from the attention distributions\n if self._hps.coverage:\n with tf.variable_scope('coverage_loss'):\n self._coverage_loss = _coverage_loss(self.attn_dists, self._dec_padding_mask)\n tf.summary.scalar('coverage_loss', self._coverage_loss)\n self._total_loss = self._loss + self._hps.cov_loss_wt * self._coverage_loss\n tf.summary.scalar('total_loss', self._total_loss)\n \n # ---------------------------/\n\n\n if self._hps.mode == \"decode\":\n assert len(final_dists) == 1 # final_dists is a singleton list containing shape (batch_size, extended_vsize)\n final_dists = final_dists[0]\n topk_probs, self._topk_ids = tf.nn.top_k(final_dists, hps.batch_size*2) # take the k largest probs. note batch_size=beam_size in decode mode\n self._topk_log_probs = tf.log(topk_probs)","def token_to_alias(raw_text, vocab):\n pass","def add_doc_to_vocab(filename, vocab):\n doc = load_doc(filename)\n tokens = clean_doc(doc)\n vocab.update(tokens)","def add_doc_to_vocab(filename, vocab):\n doc = load_doc(filename)\n tokens = clean_doc(doc)\n vocab.update(tokens)","def add_embedding(self, prefix=''):\n with tf.variable_scope(prefix + 'embed'):\n if self.cfg.fix_emb:\n assert (hasattr(self.cfg, 'W_emb'))\n W_emb = pkl.load(open(self.cfg.W_emb_path, 'rb'))\n W = tf.get_variable('W', initializer= W_emb, trainable=True)\n print(\"iniitalize word embedding finished\")\n else:\n weightInit = tf.random_uniform_initializer(-0.001, 0.001)\n vocab = pkl.load(open(self.cfg.vocab_path, 'rb'))\n W = tf.get_variable('W', [len(vocab), self.cfg.emb_size], initializer=weightInit)\n if hasattr(self.cfg, 'relu_w') and self.cfg.relu_w:\n W = tf.nn.relu(W)\n return W","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.word_embeddings = tf.get_variable(\n 'word_embeddings',\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\n trainable=True\n )\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\n\n with tf.variable_scope('char_embedding'):\n self.char_embeddings = tf.get_variable(\n 'char_embeddings',\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\n trainable=True\n )\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\n\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \"p_emb\")\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \"q_emb\")\n '''\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\n\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=None)\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=True)\n\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\n\n batch_size = tf.shape(self.p_word_emb)[0]\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\n\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\n '''\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)","def word2vec2embed(word2vec, word2idx):\n\temb_dim = word2vec['the'].shape[0]\n\temb = torch.nn.Embedding(len(word2idx), emb_dim) \n\temb_matrix = []\n\tfor w, idx in word2idx.items():\n\t\tif w in word2vec:\n\t\t\temb_matrix.append(word2vec[w])\n\t\telse:\n\t\t\temb_matrix.append(np.zeros(emb_dim,))\n\temb.weight.data.copy_(torch.from_numpy(np.array(emb_matrix)))\n\treturn emb","def AddToken(self, token, merge=False):\n token.SetLangId(self.id_)\n if not merge:\n self.tokens_.append(token)\n else:\n exists = self.MatchToken(token)\n if exists is None:\n self.tokens_.append(token)\n else:\n exists.IncrementCount(token.Count())","def build(self,unused):\n # (word_embeddings_shape, _) = input_shapes\n # width = word_embeddings_shape.as_list()[-1]\n if self.use_type_embeddings:\n self.type_embeddings = self.add_weight(\n \"token_type_embeddings\",\n shape=[self.token_type_vocab_size, self.word_embedding_width],\n initializer=get_initializer(self.initializer_range),\n dtype=self.dtype)\n\n self.position_embeddings = None\n if self.use_position_embeddings:\n self.position_embeddings = self.add_weight(\n \"position_embeddings\",\n shape=[self.max_position_embeddings, self.word_embedding_width],\n initializer=get_initializer(self.initializer_range),\n dtype=self.dtype)\n\n self.output_layer_norm = tf.keras.layers.LayerNormalization(\n name=LAYER_NORM_NAME, axis=-1, epsilon=1e-12, dtype=tf.float32)\n self.output_dropout = tf.keras.layers.Dropout(\n rate=self.dropout_prob, dtype=tf.float32)\n super().build(unused)","def __init__(self,\n embedder: Embedder,\n word_to_index: Dict[str, int],\n cuda: bool = False):\n super(IndexBatchEmbedder, self).__init__(embedder, OrderedDict(word_to_index), cuda=cuda)","def add_embeddings(self):\n\n with tf.device('/cpu:0'):\n with tf.variable_scope('Embedding_Layer'):\n embeddings = tf.Variable(self.initial_embeddings,name = 'Embeddings')\n self.input_embeddings = tf.nn.embedding_lookup(embeddings, self.inputs_placeholder) #(N,S,D)\n self.question_embeddings = tf.nn.embedding_lookup(embeddings, self.questions_placeholder) #(N,S,D)","def index_words(self, tokens):\n for token in tokens:\n self.index_word(token)","def add_word_tag(self, token, label):\n # Add total count for label\n self.label_counts[label] += 1\n # Add count for word given label\n if token not in self.words_labels_counts[label]:\n self.words_labels_counts[label][token] = 1\n else:\n self.words_labels_counts[label][token] += 1","def replace_tokens(self, tokens):\n details = []\n idx = 0\n if len(tokens) >= min_token_num:\n for i in range(len(tokens)):\n old_token = tokens[i]\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\n tokens[i] = self.get_insert_token(tokens[i])\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\n idx += len(tokens[i])\n return tokens, details","def preprocess(self, sequence, word2idx):\n context = [word2idx[word]\n if word in word2idx else UNK_token for word in sequence.split()]\n context = torch.Tensor(context)\n return context","def add_new_doc(self, document, documents_list_length=10000):\n\n try:\n document_dictionary = document.term_doc_dictionary\n # self.countDoc += 1\n for term in document_dictionary.keys():\n if self.stemming == 'y':\n my_stemmer = Stemmer()\n term = my_stemmer.stem_term(term)\n # Update inverted index and posting\n if term not in self.inverted_idx.keys():\n self.inverted_idx[term] = [1, [\n (document_dictionary[term], document.tweet_id)]] # amount of doc, freq in the doc, doc id.\n\n else:\n self.inverted_idx[term][0] += 1 # amount of doc\n self.inverted_idx[term][1].append((document_dictionary[term],\n document.tweet_id)) # freq in the doc # doc id\n\n if term not in self.postingDict.keys():\n self.postingDict[term] = [(document.tweet_id, document_dictionary[term])]\n else:\n self.postingDict[term].append((document.tweet_id, document_dictionary[term]))\n # self.countTweet -= 1\n\n if document.tweet_id not in self.tweet_dict.keys():\n self.tweet_dict[document.tweet_id] = [[term, document_dictionary[term]], 1,\n 0] # [term,freq in tweet], amount of unique terms in tweet, amount of terms in tweet\n elif document_dictionary[term] > self.tweet_dict[document.tweet_id][0][\n 1]: # tweet exist, compering between freq in two terms\n if self.tweet_dict[document.tweet_id][0][\n 1] == 1: # before change term check if the last term is unique\n self.tweet_dict[document.tweet_id][\n 1] += 1 # last term is unique: add to the amount of uniqe terms in tweet\n self.tweet_dict[document.tweet_id][0] = [term,\n document_dictionary[term]] # change between the terms\n self.tweet_dict[document.tweet_id][2] += 1\n elif document_dictionary[term] == 1: # tweet exist, not most common, check if unique\n self.tweet_dict[document.tweet_id][1] += 1\n self.tweet_dict[document.tweet_id][2] += 1\n except:\n # print('problem in indexer : add_new_doc')\n # print(traceback.print_exc())\n pass","def preprocess(self, sequence, word2idx):\n story = [word2idx[word] if word in word2idx else UNK_token for word in sequence.split()]\n story = torch.Tensor(story)\n return story","def __iadd__(self, other):\n if isinstance(other, Token):\n new = Token(self.text + other.text, self.position, self.category)\n else:\n new = Token(self.text + other, self.position, self.category)\n return new","def addToken(self, token: Token, offset: int):\n self.__tokens.append(token)\n self.__tokenMap[token] = offset","def merge_with(self, other):\n old2new = {}\n for other_id, other_token in iteritems(other):\n if other_token in self.token2id:\n new_id = self.token2id[other_token]\n else:\n new_id = len(self.token2id)\n self.token2id[other_token] = new_id\n self.dfs[new_id] = 0\n old2new[other_id] = new_id\n try:\n self.dfs[new_id] += other.dfs[other_id]\n except Exception:\n # `other` isn't a Dictionary (probably just a dict) => ignore dfs, keep going\n pass\n try:\n self.num_docs += other.num_docs\n self.num_nnz += other.num_nnz\n self.num_pos += other.num_pos\n except Exception:\n pass\n\n import gensim.models\n return gensim.models.VocabTransform(old2new)","def add_new_doc(self, document, end_of_corpus):\n max_tf = 0\n unique_terms_counter = 0\n document_dictionary = document.term_doc_dictionary\n # Go over each term in the doc\n for term in document_dictionary:\n try:\n # Update inverted index and posting\n if term not in self.inverted_idx:\n self.inverted_idx[term] = 1\n unique_terms_counter += 1\n else:\n self.inverted_idx[term] += 1\n if term not in self.posting_dict:\n self.posting_dict[term] = []\n\n self.posting_dict[term].append(\n (document.tweet_id, document_dictionary[term])) # key: str , value: array of tuples\n\n max_tf = max(document_dictionary[term], max_tf)\n\n except:\n\n print('problem with the following key {}'.format(term[0]))\n\n document.max_tf = max_tf\n document.unique_terms = unique_terms_counter\n self.docs_count += 1\n\n modulo = int(document.tweet_id) % 10\n self.documents[modulo][document.tweet_id] = [document.term_doc_dictionary, document.max_tf]\n\n if self.docs_count == self.DOCS_SIZE or end_of_corpus: # if we reach chunk size or end of corpus\n self.add_to_file(end_of_corpus)\n self.docs_count = 0\n self.posting_dict = {}\n\n for i in self.documents: # 0 - 9\n if self.documents[i].__len__() > 15000:\n doc = utils.load_obj(self.out + \"document\" + str(i))\n doc.update(self.documents[i])\n utils.save_obj(doc, self.out + \"document\" + str(i))\n self.documents[i] = {}","def set_embeddings(self):","def add(self, key, idx=None, count=1):\n key = self.lower_(key)\n if idx is not None:\n self.index2word[idx] = key\n self.word2index[key] = idx\n else:\n if key not in self.word2index:\n idx = len(self.word2index)\n self.index2word[idx] = key\n self.word2index[key] = idx\n\n if key not in self.word_count:\n self.word_count[key] = count\n else:\n self.word_count[key] += count","def update(self):\n self.__token += self.__lines[self.__i]\n self.__i += 1","def add_embedding(self):\n #with tf.variable_scope(\"RNN\", reuse = tf.AUTO_REUSE):\n embeddings = tf.get_variable(\"embeddings\", initializer = self.pretrained_embeddings,trainable=True)\n inputs = self.input_placeholder\n inputs = tf.reshape(inputs, [self.config.batch_size, -1 , self.config.n_features])\n embeddings = tf.nn.embedding_lookup(embeddings, self.input_placeholder)\n embeddings = tf.reshape(embeddings, [self.config.batch_size, -1, self.config.n_features* self.config.embed_size])\n embeddings = tf.cast(embeddings, tf.float32)\n return embeddings","def attachTokens(tokens, dynamicVocab=False, parse=False):\n tokenTxt, posTxt = '', ''\n global importantFrequentWordDic\n if dynamicVocab:\n for t in tokens:\n if parse:\n if len(tokens) > 1:\n if t.getLemma() in importantFrequentWordDic:\n tokenTxt += t.getTokenOrLemma() + '_'\n else:\n tokenTxt += unk + '_'\n else:\n tokenTxt += t.getTokenOrLemma() + '_'\n else:\n if t.getLemma() in importantFrequentWordDic:\n tokenTxt += t.getTokenOrLemma() + '_'\n else:\n tokenTxt += unk + '_'\n tokenTxt = tokenTxt[:-1]\n else:\n tokenTxt = '_'.join(t.getTokenOrLemma() for t in tokens)\n posTxt = '_'.join(t.posTag for t in tokens)\n return tokenTxt, posTxt.lower()","def _add_new_word(self, word):\n if word not in self.word_to_id:\n word_id = len(self.word_to_id)\n self.word_to_id[word] = word_id\n self.id_to_word[word_id] = word","def add_word(self, word, vector=None, low=-2., high=2.):\n if word not in self.w2v_idx:\n self.w2v_idx[word] = len(self.w2v_idx)\n if vector is None:\n vector = np.random.uniform(low=low, high=high, size=(self.w2v_dim,))\n self.w2v_out.append(np.asarray(vector, dtype=np.float32))\n else:\n print(\"word %s already in this word2vec\" % word)","def _index(self, corpus):\n\n # Transform documents to embeddings vectors\n ids, dimensions, stream = self.embedder.model.index(corpus)\n\n # Load streamed embeddings back to memory\n embeddings = np.empty((len(ids), dimensions), dtype=np.float32)\n with open(stream, \"rb\") as queue:\n for x in range(embeddings.shape[0]):\n embeddings[x] = pickle.load(queue)\n\n # Remove temporary file\n os.remove(stream)\n\n all_text = []\n for para_id, text, _ in corpus:\n all_text.append([text, para_id])\n\n df = pd.DataFrame(all_text, columns=[\"text\", \"paragraph_id\"])\n\n embedding_path = os.path.join(\n self.index_path, self.embed_paths[\"embeddings\"])\n dataframe_path = os.path.join(\n self.index_path, self.embed_paths[\"dataframe\"])\n ids_path = os.path.join(self.index_path, self.embed_paths[\"ids\"])\n\n # Load new data\n if os.path.isfile(embedding_path) and (self.encoder_args[\"overwrite\"] is False):\n logger.info(f\"Loading new data from {embedding_path}\")\n\n # Load existing embeddings\n old_embeddings = np.load(embedding_path) # LOAD EMBEDDINGS\n # Remove embeddings with document id overlaps\n embeddings = np.vstack((old_embeddings, embeddings))\n\n # load IDs\n old_ids = [doc_id[:-1] for doc_id in open_txt(ids_path)]\n logger.debug(f\"New ID Length = {len(ids)}\")\n logger.debug(f\"Old ID Length = {len(old_ids)}\")\n # Remove document ids overlaps\n logger.debug(f\"New ID Length = {len(ids)}\")\n ids = old_ids + ids\n logger.debug(f\"Merged ID Length = {len(ids)}\")\n\n # Append new dataframe\n old_df = pd.read_csv(dataframe_path)\n df = pd.concat([old_df, df])\n\n # Store embeddings and document index\n # for future reference\n np.save(embedding_path, embeddings)\n with open(ids_path, \"w\") as fp:\n fp.writelines([i + \"\\n\" for i in ids])\n\n # Save data csv\n df.to_csv(dataframe_path, index=False)\n\n # Normalize embeddings\n self.embedder.normalize(embeddings)\n\n # Save embeddings metadata\n self.embedder.config[\"ids\"] = ids\n self.embedder.config[\"dimensions\"] = dimensions\n\n # Create embeddings index\n logger.info(f\"Creating embeddings and index\")\n self.embedder.embeddings = ANN.create(self.embedder.config)\n logger.info(f\"Created embeddings\")\n\n # Build the index\n self.embedder.embeddings.index(embeddings)\n logger.info(f\"Built the embeddings index\")","def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\r\n input_string_x1=input_string_x1.decode(\"utf-8\")\r\n input_string_x2 = input_string_x2.decode(\"utf-8\")\r\n #1. get blue score vector\r\n feature_list=[]\r\n #get blue score with n-gram\r\n for i in range(n_gram):\r\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\r\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\r\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\r\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\r\n feature_list.append(blue_score_i_1)\r\n feature_list.append(blue_score_i_2)\r\n\r\n #2. get length of questions, difference of length\r\n length1=float(len(input_string_x1))\r\n length2=float(len(input_string_x2))\r\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\r\n feature_list.append(length_diff)\r\n\r\n #3. how many words are same, how many words are unique\r\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\r\n feature_list.extend(sentence_diff_overlap_features_list)\r\n\r\n #4. question 1,2 start with how/why/when\r\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\r\n #print(\"how_why_feature_list:\",how_why_feature_list)\r\n #feature_list.extend(how_why_feature_list)\r\n\r\n #5.edit distance\r\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\r\n feature_list.append(edit_distance)\r\n\r\n #6.cos distance from sentence embedding\r\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\r\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\r\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\r\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\r\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\r\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\r\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\r\n feature_list.extend(distance_list_fasttext)\r\n feature_list.extend(distance_list_word2vec)\r\n #feature_list.extend(list(sentence_diffence))\r\n #feature_list.extend(list(sentence_multiply))\r\n return feature_list","def next_word(self):\n self.append = self.add_new_word","def build_word_embeddings(self):\n if self.mode == \"encode\":\n # Word embeddings are fed from an external vocabulary which has possibly\n # been expanded (see vocabulary_expansion.py).\n encode_emb1 = tf.placeholder(tf.float32, (\n None, None, self.config.word_embedding_dim), \"encode_emb1\")\n # No sequences to decode.\n encode_emb2 = tf.placeholder(tf.float32, (\n None, None, self.config.word_embedding_dim), \"encode_emb2\")\n elif self.mode == \"test\":\n encode_emb1 = tf.placeholder(tf.float32, (\n None, None, self.config.word_embedding_dim), \"encode_emb1\")\n # No sequences to decode.\n encode_emb2 = tf.placeholder(tf.float32, (\n None, None, self.config.word_embedding_dim), \"encode_emb2\")\n else:\n word_emb = tf.get_variable(\n name=\"word_embedding\",\n shape=[self.config.vocab_size, self.config.word_embedding_dim],\n initializer=self.uniform_initializer)\n\n encode_emb1 = tf.nn.embedding_lookup(word_emb, self.encode_ids1)\n encode_emb2 = tf.nn.embedding_lookup(word_emb, self.encode_ids2)\n\n\n self.encode_emb1 = encode_emb1\n self.encode_emb2 = encode_emb2","def _get_embedding_layer(self, input_data, doc_input_data):\n opts = self._options\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\n embed = []\n\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\n embed_d = []\n for n in range(opts.sentence_sample):\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\n embed_d.append(temp)\n\n if opts.concat == 'True':\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\n for j in range(opts.window_size):\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed.append(embed_w)\n embed.append(embed_d)\n else:\n combined_embed_vector_length = opts.embed_dim\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\n for j in range(opts.window_size):\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed_w += embed_d\n embed.append(embed_w)\n\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length","def encode_samples(tokenized_samples, word_to_idx):\n features = []\n for sample in tokenized_samples:\n feature = []\n for token in sample:\n if token in word_to_idx:\n feature.append(word_to_idx[token])\n else:\n feature.append(0)\n features.append(feature)\n return features","def dump_token_embeddings(vocab_file, options_file, weight_file, outfile):\n with open(options_file, 'r') as fin:\n options = json.load(fin)\n max_word_length = options['char_cnn']['max_characters_per_token']\n\n vocab = UnicodeCharsVocabulary(vocab_file, max_word_length)\n batcher = Batcher(vocab_file, max_word_length)\n print('Computing {} LM token vectors'.format(vocab.size))\n\n ids_placeholder = tf.placeholder(\n 'int32',\n shape=(None, None, max_word_length)\n )\n print('Building Language model')\n model = BidirectionalLanguageModel(\n options_file, weight_file, ids_placeholder\n )\n\n embedding_op = model.get_ops()['token_embeddings']\n\n n_tokens = vocab.size\n embed_dim = int(embedding_op.shape[2])\n\n embeddings = np.zeros((n_tokens, embed_dim), dtype=lm_model.DTYPE)\n\n config = tf.ConfigProto(allow_soft_placement=True)\n with tf.Session(config=config) as sess:\n sess.run(tf.global_variables_initializer())\n for k in tqdm(range(n_tokens), desc='Computing LM token embeddings', ncols=80):\n token = vocab.id_to_word(k)\n char_ids = batcher.batch_sentences([[token]])[0, 1, :].reshape(\n 1, 1, -1)\n embeddings[k, :] = sess.run(\n embedding_op, feed_dict={ids_placeholder: char_ids}\n )\n\n with h5py.File(outfile, 'w') as fout:\n fout.create_dataset(\n 'embedding', embeddings.shape, dtype='float32', data=embeddings\n )","def prepare_inputs(token_mapping, w2v_W, w2v_U, sentences):\n tokens = [tokenize(token_mapping, sentence) for sentence in sentences] \n \n depth = len(token_mapping)\n one_hot_tokens = []\n for sentence in tokens:\n one_hot_sentence = []\n for i, token in enumerate(sentence):\n if token != token_mapping['#UNK#']:\n one_hot_sentence.append(one_hot_encode(token, depth))\n else:\n if i <= 2:\n context_tokens = sentence[:i] + sentence[i+1:i+3]\n else:\n context_tokens = sentence[i-2:i] + sentence[i+1:i+3]\n context_one_hot = [one_hot_encode(token, depth) for token in context_tokens]\n context_mean = np.mean(np.asarray(context_one_hot), axis=0)\n one_hot_sentence.append(context_mean)\n one_hot_tokens.append(one_hot_sentence)\n \n one_hot_tokens = [np.asarray(ls) for ls in one_hot_tokens]\n vec_tokens = [word2vec(w2v_W, w2v_U, sentence) for sentence in tqdm(one_hot_tokens, desc='Vectorizing tokens')]\n return vec_tokens","def forward(self, doc):\n out = torch.tensor([]).float().to(self.device)\n\n for i in range(len(doc)):\n sentences_raw = sentencesplit(cleantxt(doc[i]))\n sentences_ready = torch.tensor([]).float().to(self.device)\n for sentence in sentences_raw:\n sentence = sentence.split()\n if sentence == []:\n continue\n lookup_tensor = torch.tensor([]).long().to(self.device)\n for word in sentence:\n if word in self.embedd_dict:\n lookup_tensor = torch.cat((lookup_tensor,\n torch.LongTensor([self.embedd_dict[word]])), 0)\n else:\n lookup_tensor = torch.cat((lookup_tensor, torch.LongTensor([0])), 0)\n # Word embedding\n xw = self.word_embedding(lookup_tensor).view(1, -1, self.embedding_dim).to(self.device)\n # Word GRU\n self.hidden_gru_words = self.init_hidden_words()\n hw, self.hidden_gru_words = self.gru_word(xw, self.hidden_gru_words)\n # Word MLP\n uw = nn.Tanh()(self.MLP_word(hw)).to(self.device)\n # Word attention\n attention_score = torch.matmul(uw, self.attention_word).squeeze().to(self.device)\n attention_score = F.softmax(attention_score, dim=0).view(uw.size(0), uw.size(1), 1).to(self.device)\n scored_x = (hw * attention_score).to(self.device)\n s = torch.sum(scored_x, dim=1).to(self.device)\n #collecting sentences\n sentences_ready = torch.cat((sentences_ready, s), 0)\n # Sentence GRU\n if len(sentences_ready) == 0:\n out = torch.cat((out,\n torch.randn(1, self.number_cat).to(self.device)), 0).to(self.device)\n continue\n sentences_ready_gru = sentences_ready.view(1, -1, self.embedding_dim).to(self.device)\n self.hidden_gru_sentences = self.init_hidden_sentences()\n hs, self.hidden_gru_sentences = self.gru_sentence(torch.tensor(sentences_ready_gru), self.hidden_gru_sentences)\n # SENTENCE MLP\n us = nn.Tanh()(self.MLP_sentence(hs)).to(self.device)\n # Sentence attention\n attention_score = torch.matmul(us, self.attention_sentence).squeeze().to(self.device)\n attention_score = F.softmax(attention_score, dim=0).view(us.size(0), us.size(1), 1).to(self.device)\n scored_x = (hs * attention_score).to(self.device)\n v = torch.sum(scored_x, dim=1).to(self.device)\n # classification\n p = self.MLP_classification(v).to(self.device)\n out = torch.cat((out, p.float()), 0).float().to(self.device)\n return out","def _build_forward(self):\n # with tf.variable_scope(\"word_embeddings\"):\n # # Shape: (batch_size, num_sentence_words, embedding_dim)\n # embedded_sentence_one = tf.nn.embedding_lookup( self.word_emb_mat, self.sentence_one)\n # embedded_sentence_two = tf.nn.embedding_lookup( self.word_emb_mat, self.sentence_two)\n\n M1, A1, encoded_sentence_one = self.process_sentence(self.sentence_one, self.sentence_len_one, scope_name = 'sentence_one')\n M2, A2, encoded_sentence_two = self.process_sentence(self.sentence_two, self.sentence_len_two, scope_name = 'sentence_two')\n\n with tf.name_scope(\"loss\"):\n # Use the exponential of the negative L1 distance\n # between the two encoded sentences to get an output\n # distribution over labels.\n # Shape: (batch_size, 2)\n \n # Manually calculating cross-entropy, since we output\n # probabilities and can't use softmax_cross_entropy_with_logits\n # Add epsilon to the probabilities in order to prevent log(0)\n\n if self.use_contrastive:\n self.loss = self.constrastive_loss(encoded_sentence_one, encoded_sentence_two, self.y_true)\n else:\n self.y_pred = self._l1_similarity(encoded_sentence_one, encoded_sentence_two)\n self.loss = tf.reduce_mean(-tf.reduce_sum(tf.cast(self.y_true, \"float\") *tf.log(self.y_pred),axis=1))\n\n self.loss = self.loss + self.matrix_penalty(A1) + self.matrix_penalty(A2) #add matrix penalty\n\n with tf.name_scope(\"accuracy\"):\n # Get the correct predictions.\n # Shape: (batch_size,) of bool\n correct_predictions = tf.equal(\n tf.argmax(self.y_pred, 1),\n tf.argmax(self.y_true, 1))\n\n # Cast to float, and take the mean to get accuracy\n self.accuracy = tf.reduce_mean(tf.cast(correct_predictions,\n \"float\"))\n\n with tf.name_scope(\"train\"):\n optimizer = tf.train.AdamOptimizer()\n self.training_op = optimizer.minimize(self.loss,\n global_step=self.global_step)\n\n with tf.name_scope(\"train_summaries\"):\n # Add the loss and the accuracy to the tensorboard summary\n tf.summary.scalar(\"loss\", self.loss)\n tf.summary.scalar(\"accuracy\", self.accuracy)\n self.summary_op = tf.summary.merge_all()","def construct_embedding(self):\n i = 0\n self.load_dicts()\n embedding_shape = (max(self.word2idx.values()) + 1,\n self.embedding_size)\n self.embedding = np.zeros(embedding_shape)\n\n with open(self.config.word_vec_fi_glove, 'r') as fi:\n for line in fi:\n word_vec = line.split(\" \")[1:]\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\n i += 1\n\n self.write_embedding()","def toLingDataToken(token):\n\n t = Token()\n\n t.set(\n id=token.i,\n word=token.orth_,\n lemma=token.lemma_,\n POS=token.tag_,\n SPOS=token.pos_,\n depID=token.dep,\n depStr=token.dep_,\n NE=token.ent_type_,\n foreign=token.is_oov\n )\n\n # setting features\n '''\n t.features = {}\n #print(t.POS)\n featureStr = translate(t.POS)\n # save string form of feature translation\n t.features['str'] = featureStr\n\n featureArr = featureStr.split(\"+\")\n #print(featureArr)\n # find the first feature\n i = 0\n while len(featureArr[i]) < 1:\n i += 1\n\n t.features['type'] = featureArr[i]\n if t.features['type'] in [\"N\"]:\n # look for number\n i += 1\n while i < len(featureArr):\n # this means it's probably a number declaration\n if len(featureArr[i]) < 4:\n t.features['number'] = featureArr[i]\n # and next feature could be type of noun\n if i + 1 < len(featureArr):\n t.features['isProper'] = featureArr[i + 1]\n break\n i += 1\n\n if t.features['type'] in [\"V\"]:\n # look for person and number\n i += 1\n while i < len(featureArr):\n # this means it's probably a person declaration\n if len(featureArr[i]) < 4:\n t.features['person'] = featureArr[i]\n # and next feature could be number\n if i + 1 < len(featureArr):\n t.features['number'] = featureArr[i + 1]\n break\n else:\n # probably a tense\n t.features['tense'] = featureArr[i]\n t.features['isParticiple'] = (\"Part\" in featureArr[i])\n\n i += 1\n #print(t.features)\n '''\n\n # setting wordType\n if token.tag_ == \"BES\": # copula\n t.set(wordType=4)\n elif token.pos_ == \"VERB\":\n t.set(wordType=1)\n elif token.pos_ == \"NOUN\" or token.pos_ == \"PROPN\":\n t.set(wordType=2)\n elif token.pos_ == \"PRON\":\n t.set(wordType=3)\n else:\n t.set(wordType=5)\n\n # spaCy does not have coreferencing...\n\n return t","def get_mismatch_token_idx(self, words: List[str]):\n # todo(yuxian): this line is extremely slow, need optimization\n wordpieces, offsets = self._allennlp_tokenizer.intra_word_tokenize(words)\n\n # For tokens that don't correspond to any word pieces, we put (-1, -1) into the offsets.\n # That results in the embedding for the token to be all zeros.\n offsets = [x if x is not None else (-1, -1) for x in offsets]\n\n output = {\n \"token_ids\": torch.LongTensor([t.text_id for t in wordpieces]),\n \"word_mask\": torch.BoolTensor([True] * len(words)), # for original tokens (i.e. word-level)\n \"offsets\": torch.LongTensor(offsets),\n \"wordpiece_mask\": torch.BoolTensor([True] * len(wordpieces)), # for wordpieces (i.e. subword-level)\n }\n return output","def add_new_doc(self, document):\n self.counterOfTweets += 1\n docID = document.tweet_id\n document_dictionary = document.term_doc_dictionary # document_dictionary = {term:[[indexes],freq]}\n self.tweetTerms[docID] = list(document_dictionary.keys())\n freq_max = sorted(list(document_dictionary.values()), key=itemgetter(1), reverse=True)[0][1] # Gets the maxFreq\n postingFileName = \"\"\n\n # Go over each term in the doc\n for term in sorted(list(document_dictionary.keys())):\n\n # Deciding the type of the term\n if (str(term[0]).lower() not in self.letters): # others\n type = 1\n elif (len(term) > 1): # 'J'\n if str(term[1]).lower() not in self.letters and str(term[1]).lower() != '.': # 1400 -> 1.400K\n type = 1\n else: # strings\n type = 2\n else: # strings\n type = 2\n\n if (' ' in term): # alone entities\n if term not in self.alone_entities_dict: # fix it\n self.alone_entities_dict[term] = 0\n self.alone_entities_dict[term] += 1\n\n if (type == 1):\n if (postingFileName != \"postingOthers\"):\n postingFileName = \"postingOthers\"\n\n elif (len(term) == 1):\n if postingFileName != \"posting_\" + term.lower():\n postingFileName = \"posting_\" + term.lower()\n\n elif (term[1] == '.'):\n if postingFileName != \"posting_\" + term[0].lower():\n postingFileName = \"posting_\" + term[0].lower()\n else:\n if postingFileName != \"posting_\" + str(term[0]).lower() + str(term[1]).lower():\n postingFileName = \"posting_\" + term[0].lower() + term[1].lower()\n\n indexes_t = document_dictionary[term][0]\n freq_t = document_dictionary[term][1]\n tf = freq_t / freq_max\n\n if term not in self.inverted_idx.keys():\n self.postingFiles[postingFileName][term] = []\n self.postingFiles[postingFileName][term].append([freq_t, docID, indexes_t, tf])\n self.inverted_idx[term] = [1, freq_t, postingFileName]\n\n else:\n # update inv_dict:\n self.inverted_idx[term][0] += 1 # add another doc to the count in the inv_dict\n self.inverted_idx[term][1] += freq_t\n self.postingFiles[postingFileName][term].append([freq_t, docID, indexes_t, tf])","def add_word(self, word, freq=None):\n pass","def _add_token_node_ids_to_span_nodes(self):\n span_dict = defaultdict(list)\n for span_edge in self._spanning_relation_ids:\n token_node_id = self.edges[span_edge].target\n span_node_id = self.edges[span_edge].source\n span_dict[span_node_id].append(token_node_id)\n\n for span_node_id in span_dict:\n self.nodes[span_node_id].tokens = span_dict[span_node_id]","def __init__(\n self,\n word_embeddings: BasicTextFieldEmbedder,\n input_dim: int,\n hidden_dim: int,\n attn_dim: int,\n features_to_idx: dict = None,\n feature_dim: int = None,\n dropout: float = 0.5,\n ):\n super(AttentiveNER, self).__init__()\n self.word_embeddings = word_embeddings\n self.hidden_dim = hidden_dim\n self.left_bilstm = PytorchSeq2SeqWrapper(\n nn.LSTM(\n input_dim, hidden_dim, batch_first=True, bidirectional=True\n )\n )\n self.right_bilstm = PytorchSeq2SeqWrapper(\n nn.LSTM(\n input_dim, hidden_dim, batch_first=True, bidirectional=True\n )\n )\n\n self.attn = Attention(hidden_dim * 2, attn_dim)\n\n if features_to_idx is not None:\n self.feat_embs = nn.Embedding(\n len(features_to_idx) + 1, feature_dim, padding_idx=0\n )\n self.feat_to_idx = features_to_idx\n\n self.output_dim = (\n 2 * hidden_dim + input_dim + feature_dim\n ) # 50 is for features\n else:\n self.feat_to_idx = None\n self.output_dim = 2 * hidden_dim + input_dim\n\n self.dropout = nn.Dropout(dropout)","def _convert_id_to_token(self, index):\n return self.reverse_vocab.get(index, self.unk_token)","def index(self):\n print(\"Indexing...\")\n # ------------------------------------------------------------------\n # TODO: Create an inverted, positional index.\n # Granted this may not be a linked list as in a proper\n # implementation.\n # This index should allow easy access to both \n # 1) the documents in which a particular word is contained, and \n # 2) for every document, the positions of that word in the document \n # Some helpful instance variables:\n # * self.docs = List of documents\n # * self.titles = List of titles\n inv_index = defaultdict(set)\n self.tf = defaultdict(Counter)\n \n for word in self.vocab:\n inv_index[word] = {} # create dictionary with words in V\n\n # Generate inverted index here\n for doc in range(len(self.docs)):\n for word in self.docs[doc]:\n self.tf[doc][word] += 1 # represents how many times word 'word' is mentioned in document 'i'\n \n for doc, title in zip(self.docs, self.titles):\n for word in self.vocab:\n inv_index[word][title] = [] # list for each word in vocabulary for all titles\n for pos, word in enumerate(doc):\n inv_index[word][title].append(pos)\n\n self.inv_index = inv_index\n # ------------------------------------------------------------------\n\n # turn self.docs into a map from ID to bag of words\n id_to_bag_of_words = {}\n for d, doc in enumerate(self.docs):\n bag_of_words = set(doc)\n id_to_bag_of_words[d] = bag_of_words\n self.docs = id_to_bag_of_words","def add_to_index(self, term_, doc_id_):\n\n if(term_ not in self.inverted_index.keys()):\n postingsList=LinkedList()\n postingsList.insert_at_end(doc_id_)\n #Doc freq\n postingsList.length=postingsList.length+1\n self.inverted_index[term_]=postingsList\n# self.inverted_index[term_].start_node.term_frequency += 1\n elif(not self.is_doc_id_in_posting_list(self.inverted_index[term_],doc_id_,term_)):\n self.inverted_index[term_].insert_at_end(doc_id_)\n self.inverted_index[term_].length=self.inverted_index[term_].length+1","def pretrained_embedding_layer(word_to_vec_map, word_to_index):\n \n vocab_size = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\n any_word = list(word_to_vec_map.keys())[0]\n emb_dim = word_to_vec_map[any_word].shape[0] # define dimensionality of your GloVe word vectors (= 50)\n \n ### START CODE HERE ###\n # Step 1\n # Initialize the embedding matrix as a numpy array of zeros.\n # See instructions above to choose the correct shape.\n emb_matrix = np.zeros((vocab_size, emb_dim))\n \n # Step 2\n # Set each row \"idx\" of the embedding matrix to be \n # the word vector representation of the idx'th word of the vocabulary\n for word, idx in word_to_index.items():\n emb_matrix[idx, :] = word_to_vec_map[word]\n\n # Step 3\n # Define Keras embedding layer with the correct input and output sizes\n # Make it non-trainable.\n embedding_layer = tensorflow.keras.layers.Embedding(input_dim = vocab_size, output_dim = emb_dim, trainable = False)\n ### END CODE HERE ###\n\n # Step 4 (already done for you; please do not modify)\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \n embedding_layer.build((None,)) # Do not modify the \"None\". This line of code is complete as-is.\n \n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n embedding_layer.set_weights([emb_matrix])\n \n return embedding_layer","def __add__(self, other):\n if isinstance(other, Token):\n return Token(self.text + other.text, self.position, self.category)\n else:\n return Token(self.text + other, self.position, self.category)","def add_token(self, amount):\n self.M += amount","def add_word(self,word,index):\r\n\r\n #with shelf\r\n if self.using_shelf:\r\n\r\n if word in self.word_dict:\r\n\r\n self.word_dict[word].add(str(index))\r\n else:\r\n self.word_dict[word] = {str(index)}\r\n\r\n\r\n #with database\r\n if self.using_database:\r\n\r\n value_tuple = (notebookname, word,)\r\n db_cursor.execute(\"INSERT OR REPLACE \"\r\n +\"INTO all_words \"\r\n +\"(word, notebook)\"\r\n +\" VALUES (?,?);\",value_tuple)\r\n value_tuple = (notebookname, word, str(index))\r\n db_cursor.execute(\"INSERT OR REPLACE\"\r\n +\" INTO word_to_indexes \"\r\n +\"(notebook, word, note_index)\"\r\n +\" VALUES (?,?,?);\",\r\n value_tuple)","def Emojify_V2(input_shape, word_to_vec_map, word_to_index):\n \n ### START CODE HERE ###\n # Define sentence_indices as the input of the graph.\n # It should be of shape input_shape and dtype 'int32' (as it contains indices, which are integers).\n sentence_indices = Input(shape = input_shape, dtype = 'int32')\n \n # Create the embedding layer pretrained with GloVe Vectors (≈1 line)\n # def pretrained_embedding_layer(word_to_vec_map, word_to_index): # return embedding_layer\n embedding_layer = pretrained_embedding_layer(word_to_vec_map, word_to_index)\n \n # Propagate sentence_indices through your embedding layer\n # (See additional hints in the instructions).\n embeddings = embedding_layer(sentence_indices) \n \n # Propagate the embeddings through an LSTM layer with 128-dimensional hidden state\n # The returned output should be a batch of sequences.\n X = LSTM(units = 128, return_sequences = True)(embeddings)\n # Add dropout with a probability of 0.5\n X = Dropout(rate = 0.5)(X)\n # Propagate X trough another LSTM layer with 128-dimensional hidden state\n # The returned output should be a single hidden state, not a batch of sequences.\n X = LSTM(units = 128, return_sequences = False)(X)\n # Add dropout with a probability of 0.5\n X = Dropout(rate = 0.5)(X) \n # Propagate X through a Dense layer with 5 units\n X = Dense(units = 5)(X)\n # Add a softmax activation\n X = Activation(activation = 'softmax')(X)\n \n # Create Model instance which converts sentence_indices into X.\n model = Model(inputs = sentence_indices, outputs = X)\n \n ### END CODE HERE ###\n \n return model","def build_token_dict(vocab):\r\n token_to_idx, idx_to_token = {}, {}\r\n next_idx = 1\r\n vocab_sorted = sorted(list(vocab)) # make sure it's the same order everytime\r\n for token in vocab_sorted:\r\n token_to_idx[token] = next_idx\r\n idx_to_token[next_idx] = token\r\n next_idx = next_idx + 1\r\n\r\n return token_to_idx, idx_to_token","def add_word(self, word):\n word = self.map_word(word)\n super(InvariantLanguage, self).add_word(word)","def add_embedding_layer(self, emb_matrix, ans2id, context2id, use_same=True):\n with vs.variable_scope(\"embeddings\"):\n qn_embedding_matrix = tf.Variable(emb_matrix, dtype=tf.float32,\n name=\"qn_emb_matrix\") # shape (400002, embedding_size)\n self.qn_embs = embedding_ops.embedding_lookup(qn_embedding_matrix, self.qn_ids)\n\n self.context_embedding_matrix = tf.Variable(tf.one_hot(range(len(context2id)), len(context2id)),\n name=\"context_emb_matrix\")\n if not use_same:\n self.ans_embedding_matrix = tf.Variable(tf.one_hot(range(len(ans2id)), len(ans2id)),\n dtype=tf.float32, name=\"ans_emb_matrix\")\n else:\n self.ans_embedding_matrix = tf.identity(self.context_embedding_matrix, name=\"ans_emb_matrix\")\n\n if self.FLAGS.use_raw_graph:\n self.context_embs = embedding_ops.embedding_lookup(self.context_embedding_matrix, self.context_ids)\n else:\n self.context_embs = tf.identity(self.context_embedding)\n self.ans_embs = embedding_ops.embedding_lookup(self.ans_embedding_matrix, self.ans_ids)","def forward(\n self,\n mention_tokens: torch.tensor,\n left_tokens: torch.tensor,\n right_tokens: torch.tensor,\n features: torch.tensor = None,\n ):\n mention_mask = get_text_field_mask(mention_tokens)\n mention_embs = self.word_embeddings(mention_tokens)\n avg_mentions = masked_mean(\n mention_embs, mention_mask.unsqueeze(-1), dim=1\n )\n avg_mentions = self.dropout(avg_mentions)\n\n left_mask = get_text_field_mask(left_tokens)\n left_embs = self.word_embeddings(left_tokens)\n left_hidden_states = self.left_bilstm(left_embs, left_mask)\n\n right_mask = get_text_field_mask(right_tokens)\n right_embs = self.word_embeddings(right_tokens)\n right_hidden_states = self.right_bilstm(right_embs, right_mask)\n\n full_mask = torch.cat([left_mask, right_mask], dim=1)\n full_hidden = torch.cat(\n [left_hidden_states, right_hidden_states], dim=1\n )\n\n attn_scores = self.attn(full_hidden, full_mask)\n context = torch.sum(full_hidden * attn_scores, dim=1)\n\n if self.feat_to_idx is not None:\n feat_rep = torch.sum(self.feat_embs(features), dim=1)\n feat_rep = self.dropout(feat_rep)\n\n mention_rep = torch.cat([avg_mentions, context, feat_rep], dim=1)\n else:\n mention_rep = torch.cat([avg_mentions, context], dim=1)\n\n return mention_rep","def add_instance(self, row, ind2c, c2ind, w2ind, dv_dict, num_labels):\n labels = set()\n hadm_id = int(row[1])\n text = row[2]\n length = int(row[4])\n cur_code_set = set()\n labels_idx = np.zeros(num_labels)\n labelled = False\n desc_vecs = []\n #get codes as a multi-hot vector\n for l in row[3].split(';'):\n if l in c2ind.keys():\n code = int(c2ind[l])\n labels_idx[code] = 1\n cur_code_set.add(code)\n labelled = True\n if not labelled:\n return\n if self.desc_embed:\n for code in cur_code_set:\n l = ind2c[code]\n if l in dv_dict.keys():\n #need to copy or description padding will get screwed up\n desc_vecs.append(dv_dict[l][:])\n else:\n desc_vecs.append([len(w2ind)+1])\n #OOV words are given a unique index at end of vocab lookup\n text = [int(w2ind[w]) if w in w2ind else len(w2ind)+1 for w in text.split()]\n #truncate long documents\n if len(text) > self.max_length:\n text = text[:self.max_length]\n\n #build instance\n self.docs.append(text)\n self.labels.append(labels_idx)\n self.hadm_ids.append(hadm_id)\n self.code_set = self.code_set.union(cur_code_set)\n if self.desc_embed:\n self.descs.append(pad_desc_vecs(desc_vecs))\n #reset length\n self.length = min(self.max_length, length)","def w2v_embedding(input_file, bin_file, output_file):\n print(\"Loading the training corpus.\")\n df = open(src_file_path, \"r\") # Open the text file stored at src_file_path\n df = df.read() # Read the text file\n tokens1 = word_tokenize(df) # Tokenize\n token_list = []\n print(\"Writing the bin file.\")\n models = KeyedVectors.load_word2vec_format(bin_destination_file_path, binary=True) # Save bin format\n print(\"Saving the word embeddings.\")\n models.save_word2vec_format(txt_file_destination_path, binary=False) # Save the word vectors\n \n return txt_file_destination_path","def _add_offsets_to_token_nodes(self):\n for edge_index in self._textual_relation_ids:\n token_node_index = self.edges[edge_index].source\n self.nodes[token_node_index].onset = self.edges[edge_index].onset\n self.nodes[token_node_index].offset = self.edges[edge_index].offset","def update_embedding_layer(line_tokens, model, dictionary):\n\n global elmo_embedder\n\n out_of_corpus_vocab = [word for word in line_tokens if word not in dictionary.word2idx]\n if len(out_of_corpus_vocab) == 0:\n return\n\n print(\"OOV words found:\", out_of_corpus_vocab, file=sys.stderr)\n\n if model.using_pretrained == \"fasttext\":\n pretrained_emb_model = vc.FastText()\n elif model.using_pretrained == \"glove\":\n pretrained_emb_model = vc.GloVe()\n elif model.using_pretrained == \"elmo_top\" or model.using_pretrained == \"elmo_avg\":\n dirname = os.path.dirname(__file__)\n options_file = os.path.join(dirname, '../elmo-config/elmo_2x4096_512_2048cnn_2xhighway_options.json')\n weight_file = os.path.join(dirname, '../elmo-config/elmo_2x4096_512_2048cnn_2xhighway_weights.hdf5')\n # Retrieve cached version if already loaded, saves a lot of time if this code path is executed multiple times\n if elmo_embedder is None:\n elmo_embedder = ElmoEmbedder(options_file, weight_file)\n else:\n raise Exception(\"Unsupported embedding model:\", model.using_pretrained)\n\n print(\"Using Pretrained embedding:\", model.using_pretrained)\n\n if model.using_pretrained in ['fasttext', 'glove']:\n\n pretrained_vectors = pretrained_emb_model.vectors\n pretrained_stoi = pretrained_emb_model.stoi\n\n elif 'elmo' in model.using_pretrained:\n # We get the embeddings for all line_tokens which includes both known and unknown, if any.\n # As elmo is character level we can find embedding of any word\n reduced_vocab = [token for token in line_tokens if token not in\n [\"#\", \"<EOT>\", \"<EOL>\", \"</s>\", \"<eos>\", \"<P>\", \"<unk>\"]]\n pretrained_stoi = {v: k for k, v in enumerate(reduced_vocab)}\n elmo_embeddings = elmo_embedder.embed_sentence(reduced_vocab)\n if 'top' in model.using_pretrained:\n pretrained_vectors = elmo_embeddings[-1]\n elif 'avg' in model.using_pretrained:\n pretrained_vectors = np.average(elmo_embeddings, axis=0)\n pretrained_vectors = torch.from_numpy(pretrained_vectors)\n out_of_corpus_vocab = [word for word in line_tokens if word not in dictionary.word2idx and word in pretrained_stoi]\n\n if len(out_of_corpus_vocab) == 0:\n return\n\n # Update for only unknown/new word\n new_vectors = []\n for word in out_of_corpus_vocab:\n dictionary.add_word(word)\n new_vectors.append(pretrained_stoi[word])\n\n new_vectors = torch.index_select(pretrained_vectors, 0, torch.LongTensor(new_vectors))\n\n model.embedder = torch.nn.Embedding.from_pretrained(torch.cat([model.embedder.weight, new_vectors]))\n if model.tie_weights:\n model.decoder.weight = model.encoder.weight","def build_vocab(self, lst_tokens):\n freqs = {}\n\n # Calculate frequency of words\n for tokens in lst_tokens:\n for word in tokens:\n if word not in self._special_tokens.values() and word not in freqs.keys():\n freqs[word] = 0\n freqs[word] += 1\n\n # Sort words by frequency\n sorted_freqs = {k: v for k, v in sorted(freqs.items(), key=lambda item: item[1], reverse=True)}\n\n # Max size\n if self.max_size is not None:\n sorted_freqs = {k: v for i, (k, v) in enumerate(sorted_freqs.items()) if i < self.max_size}\n\n # Filter low frequency words\n if self.min_freq is not None:\n sorted_freqs = {k: v for k, v in sorted_freqs.items() if v >= self.min_freq}\n\n for word, freq in sorted_freqs.items():\n self._word2idx[word] = self.vocab_size\n self._idx2word[self.vocab_size] = word\n self.vocab_size += 1\n self.freqs[word] = freq"],"string":"[\n \"def add_to_dict(self, tokens):\\n# TODO: ?add normalization of a token?\\n for token in tokens:\\n if self.embedding_words and (token not in self.embedding_words):\\n continue\\n self.freq[token] += 1\\n if token not in self.tok2ind:\\n index = len(self.tok2ind)\\n self.tok2ind[token] = index\\n self.ind2tok[index] = token\",\n \"def index_word(self, token):\\n if token not in self.word_2_idx:\\n idx = len(self.word_2_idx)\\n self.word_2_idx[token] = idx\\n self.idx_2_word[idx] = token\",\n \"def to_token_embedding(self, tokens, unknown_behavior='impute_raise',\\n batch_size=1024, ctx=cpu()):\\n\\n new_embedding = emb.TokenEmbedding(unknown_token=None)\\n new_embedding._token_to_idx.update(\\n (token, idx) for idx, token in enumerate(tokens))\\n new_embedding._idx_to_token = tokens\\n new_idx_to_vec = []\\n\\n # Compute embeddings in batches for all idx\\n start_pointer = 0\\n end_pointer = batch_size\\n while True:\\n batch = tokens[start_pointer:end_pointer]\\n batch_embedding = self._to_token_embedding_batch(\\n batch, unknown_behavior, ctx)\\n new_idx_to_vec.append(batch_embedding.as_in_context(cpu()))\\n\\n if end_pointer >= len(tokens):\\n break\\n start_pointer += batch_size\\n end_pointer += batch_size\\n\\n new_idx_to_vec = nd.concat(*new_idx_to_vec, dim=0)\\n new_embedding._idx_to_vec = new_idx_to_vec\\n return new_embedding\",\n \"def add_special_tokens_(model, tokenizer, update_model=True):\\n orig_num_tokens = len(tokenizer)\\n num_added_tokens = tokenizer.add_special_tokens(ATTR_TO_SPECIAL_TOKEN) # doesn't add if they are already there\\n #print(\\\"coab::\\\",len(tokenizer.vocab))\\n if (num_added_tokens > 0 and update_model):\\n model.encoder.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\\n model.decoder.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\\n #print(model.encoder.embeddings.word_embeddings.weight.shape)\\n #print(model.decoder.bert.embeddings.word_embeddings.weight.shape)\",\n \"def add_special_tokens_(model, tokenizer):\\n orig_num_tokens = len(tokenizer.encoder)\\n num_added_tokens = tokenizer.add_special_tokens(ATTR_TO_SPECIAL_TOKEN) # doesn't add if they are already there\\n if num_added_tokens > 0:\\n model.resize_token_embeddings(new_num_tokens=orig_num_tokens + num_added_tokens)\",\n \"def add_token(\\r\\n self,\\r\\n ind: int,\\r\\n w: str,\\r\\n ) -> AddToken:\\r\\n self.t = self.t + 1\\r\\n content = self._encrypt_update(self.t, Op.ADD, ind, w)\\r\\n return self.sigma.add_token(content, w)\",\n \"def add_word_embedding_op(self):\\n if self.pos:\\n print(\\\"adding pos embeddings\\\")\\n with tf.variable_scope(\\\"pos\\\"):\\n _pos_embeddings = tf.Variable(self.pos_embeddings,\\n name=\\\"la_pos_embeddings\\\",\\n dtype=tf.float32, trainable=False)\\n pos_embeddings = tf.nn.embedding_lookup(_pos_embeddings, self.pos_ids,\\n name=\\\"pos_embeddings\\\")\\n self.pos_vecs = pos_embeddings\\n print(\\\"adding word_embeddings\\\")\\n with tf.variable_scope(\\\"words\\\"):\\n _word_embeddings = tf.Variable(self.embeddings, name=\\\"_word_embeddings\\\",\\n dtype=tf.float32, trainable=False)\\n word_embeddings = tf.nn.embedding_lookup(_word_embeddings,\\n self.word_ids,\\n name=\\\"word_embeddings\\\")\\n if self.use_window:\\n print(\\\"Concatenating word vectors of context words\\\")\\n word_embeddings_sl = tf.nn.embedding_lookup(_word_embeddings,\\n self.word_ids_sl,\\n name=\\\"word_embeddings_sl\\\")\\n word_embeddings_sr = tf.nn.embedding_lookup(_word_embeddings,\\n self.word_ids_sr,\\n name=\\\"word_embeddings_sr\\\")\\n word_embeddings = tf.concat([word_embeddings_sr, word_embeddings,\\n word_embeddings_sl], axis=-1)\\n if self.use_char_embeddings:\\n print(\\\"adding CNN for char embeddings\\\")\\n with tf.variable_scope(\\\"chars\\\"):\\n _char_embeddings = tf.get_variable(name=\\\"_char_embeddings\\\",\\n dtype=tf.float32,\\n shape=[self.char_count, \\n self.c_dim_input])\\n char_embeddings = tf.nn.embedding_lookup(_char_embeddings, \\n self.char_ids, \\n name=\\\"char_embeddings\\\")\\n s = char_embeddings.shape\\n # the shape of our char_embeddings is now (batch_size, max number of words\\n # in each sentence, max number of chars in each word, self.c_dim )\\n char_filter = tf.get_variable(\\\"char_filter\\\", dtype=tf.float32,\\n shape=[self.c_filter_width, \\n self.c_filter_height,\\n self.c_dim_input,\\n self.c_dim_output])\\n print(\\\"adding 2d convolution layer\\\")\\n char_conv_layer = tf.nn.conv2d(char_embeddings, char_filter, \\n strides=[1, 1, 1, 1], \\n padding=\\\"SAME\\\")\\n char_conv_layer = tf.nn.tanh(char_conv_layer)\\n print(\\\"adding 2d pooling layer\\\")\\n char_conv_layer = tf.layers.max_pooling2d(char_conv_layer, \\n 1, \\n strides=1)\\n char_output = tf.reshape(char_conv_layer, shape=[-1, self.max_len, \\n self.max_word_length*\\n self.c_dim_output])\\n word_embeddings = tf.concat([word_embeddings, char_output], axis=-1)\\n if self.pos and self.concat_pos:\\n print(\\\"concatenating pos with word_embeddings\\\")\\n word_embeddings = tf.concat([word_embeddings, pos_embeddings], axis=-1)\\n self.word_embeddings = word_embeddings\\n if self.use_additional and self.hybrid:\\n print(\\\"using additional embeddings\\\")\\n _word_embeddings_2 = tf.Variable(self.additional_embeddings,\\n name=\\\"two_word_embeddings\\\",\\n dtype=tf.float32, trainable=False)\\n word_embeddings_2 = tf.nn.embedding_lookup(_word_embeddings_2,\\n self.word_ids,\\n name=\\\"two_word_embeddings\\\")\\n self.word_embeddings_2 = word_embeddings_2\",\n \"def add(self, document):\\n #words=[word.lower() for word in words if word.isalpha()] #added on 0415\\n for token in [t.lower() for t in nltk.word_tokenize(document)]:\\n if not token.isalpha():\\n continue\\n\\n if token in self.stopwords:\\n continue\\n \\n if self.stemmer:\\n token = self.stemmer.stem(token)\\n \\n if self.__unique_id not in self.index[token]:\\n self.index[token].append(self.__unique_id)\\n \\n self.documents[self.__unique_id] = document\\n self.__unique_id += 1\",\n \"def TransformerTokenEmbedding(\\n num_embeddings, embedding_dim, padding_idx, freeze_embed=False\\n):\\n m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx)\\n nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5)\\n nn.init.constant_(m.weight[padding_idx], 0)\\n if freeze_embed:\\n m.weight.requires_grad = False\\n return m\",\n \"def _look_up(self, token):\\n if self.args.add_vn:\\n return tf.nn.embedding_lookup(self.embedding_matrix + \\\\\\n tf.random.normal(tf.shape(self.embedding_matrix), stddev=0.075), token)\\n\\n return tf.nn.embedding_lookup(self.embedding_matrix, token)\",\n \"def make_idx2word():\\n idx2word = {}\\n d = train_data.shared['word2idx']\\n for word, idx in d.items():\\n print(word)\\n idx2word[idx] = word\\n if config.use_glove_for_unk:\\n d2 = train_data.shared['new_word2idx']\\n for word, idx in d2.items():\\n print(word)\\n idx2word[idx+len(d)] = word\\n return idx2word\",\n \"def _build_token_dict(self, corpus: List[List[str]]):\\n self.token2idx = self.load_from_vocab_file(self.vocab_path)\\n self.idx2token = dict([(value, key)\\n for key, value in self.token2idx.items()])\\n logging.debug(f\\\"build token2idx dict finished, contains {len(self.token2idx)} tokens.\\\")\\n self.dataset_info['token_count'] = len(self.token2idx)\",\n \"def _feed(self, SeqSeqToken, token_to_index, index_to_token):\\n for SeqToken in SeqSeqToken:\\n for Token in SeqToken:\\n if not token_to_index.has_key(Token):\\n i = len(index_to_token)\\n token_to_index[Token] = i\\n index_to_token.insert(i, Token)\",\n \"def process_new_tokens(tokens,processed_tokens_set, model, dictionary):\\n if hasattr(model, 'using_pretrained') and model.using_pretrained is not None:\\n processed_tokens_set.update(tokens)\\n update_embedding_layer(processed_tokens_set, model, dictionary)\",\n \"def add(self, token_docid):\\n token = token_docid[0]\\n doc_id = token_docid[1]\\n # collapse identical tokens together\\n if token in self.posting:\\n self.posting[token].append(doc_id)\\n else:\\n self.posting[token] = [doc_id]\",\n \"def add(self, tokens):\\n\\n for token in tokens:\\n self.vocab.add(token)\\n\\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\\n if leader not in self.frequencies:\\n self.frequencies[leader] = Frequency()\\n\\n self.frequencies[leader].add(token)\",\n \"def add_token(self,token):\\n\\t\\tif not token:\\n\\t\\t\\tlogging.error(\\\"Token cannot be empty!\\\")\\n\\t\\t\\texit()\\n\\n\\t\\tself.tokens.append(token.lower())\\n\\t\\t#self.user_defined_token = token.lower()\",\n \"def _add_pre_trained_embedding(self):\\n\\n if self.embedding_type['type'] == 'glove':\\n self.logging.info('use pre-trained glove word2vec')\\n # a. load pre trained glove\\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\\n import os\\n import numpy as np\\n\\n embeddings_index = {}\\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\\n for line in f:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n f.close()\\n\\n self.logging.info('')\\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\\n\\n # b. compute embedding matrix\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n\\n elif self.embedding_type['type'] == 'gensim':\\n self.logging.info('use pre-trained gensim word2vec')\\n\\n import gzip\\n import gensim\\n from keras.layers import Embedding\\n import numpy as np\\n\\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\\n\\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\\n pretrained_weights = model.wv.syn0\\n vocab_size, vector_dim = pretrained_weights.shape\\n\\n method = 3\\n if method == 1:\\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\\n # into our TensorFlow and Keras models\\n\\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\\n for i in range(len(model.wv.vocab)):\\n embedding_vector = model.wv[model.wv.index2word[i]]\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\\n output_dim=embedding_matrix.shape[1],\\n # input_length=self.maxlen,\\n weights=[embedding_matrix],\\n trainable=False)\\n elif method == 2:\\n self.logging.info('word2vec simple embedding matching - simple complex')\\n embedding_layer = Embedding(input_dim=vocab_size,\\n output_dim=vector_dim,\\n input_length=self.maxlen,\\n weights=[pretrained_weights],\\n trainable=False)\\n elif method == 3:\\n\\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\\n # b. compute embedding matrix\\n\\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\\n\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n if word in model.wv:\\n embedding_vector = model.wv[word]\\n embedding_matrix[i] = embedding_vector\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt))\\n\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n else:\\n raise ValueError('unknown method value')\\n\\n else:\\n raise ValueError('unknown embedding type')\\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\\n return embedding_layer\",\n \"def replace_token_with_index(self, tokenized_tweet, max_length_dictionary):\\n\\n # should be replacing each token in a list of tokens by their corresponding index\\n # Source: https://github.com/stanfordnlp/GloVe\\n # Source: https://towardsdatascience.com/word-embeddings-for-sentiment-analysis-65f42ea5d26e\\n\\n if self.mode == \\\"zip\\\":\\n for idx, word in enumerate(tokenized_tweet):\\n if word not in self.corpus:\\n tokenized_tweet[idx] = \\\"<unknown>\\\"\\n else:\\n for idx, word in enumerate(tokenized_tweet):\\n if word not in self.corpus:\\n tokenized_tweet[idx] = \\\"<unk>\\\"\\n return [self.corpus.index(x) for x in tokenized_tweet]\",\n \"def _add_word(self, word):\\n if not word in self._word2idx.keys():\\n self._word2idx[word] = self.vocab_size\\n self.freqs[word] = 0\\n self._idx2word[self.vocab_size] = word\\n self.vocab_size += 1\\n self.freqs[word] += 1\",\n \"def add_word_embeddings_op(self):\\n with tf.variable_scope(\\\"words\\\"):\\n if self.config.embeddings is None:\\n self.logger.info(\\\"WARNING: randomly initializing word vectors\\\")\\n _word_embeddings = tf.get_variable(\\n name=\\\"_word_embeddings\\\",\\n dtype=tf.float32,\\n shape=[self.config.nwords, self.config.dim_word])\\n else:\\n _word_embeddings = tf.Variable(\\n self.config.embeddings,\\n name=\\\"_word_embeddings\\\",\\n dtype=tf.float32,\\n trainable=self.config.train_embeddings)\\n\\n word_embeddings = tf.nn.embedding_lookup(_word_embeddings,\\n self.word_ids, name=\\\"word_embeddings\\\")\\n\\n with tf.variable_scope(\\\"chars\\\"):\\n if self.config.use_chars:\\n # get char embeddings matrix\\n _char_embeddings = tf.get_variable(\\n name=\\\"_char_embeddings\\\",\\n dtype=tf.float32,\\n shape=[self.config.nchars, self.config.dim_char])\\n char_embeddings = tf.nn.embedding_lookup(_char_embeddings,\\n self.char_ids, name=\\\"char_embeddings\\\")\\n\\n # put the time dimension on axis=1\\n s = tf.shape(char_embeddings)\\n char_embeddings = tf.reshape(char_embeddings,\\n shape=[s[0]*s[1], s[-2], self.config.dim_char])\\n word_lengths = tf.reshape(self.word_lengths, shape=[s[0]*s[1]])\\n\\n # bi lstm on chars\\n cell_fw = tf.contrib.rnn.LSTMCell(self.config.hidden_size_char,\\n state_is_tuple=True)\\n cell_bw = tf.contrib.rnn.LSTMCell(self.config.hidden_size_char,\\n state_is_tuple=True)\\n _output = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, char_embeddings,\\n sequence_length=word_lengths, dtype=tf.float32)\\n\\n # read and concat output\\n _, ((_, output_fw), (_, output_bw)) = _output\\n output = tf.concat([output_fw, output_bw], axis=-1)\\n\\n # shape = (batch size, max sentence length, char hidden size)\\n output = tf.reshape(output,\\n shape=[s[0], s[1], 2*self.config.hidden_size_char])\\n word_embeddings = tf.concat([word_embeddings, output], axis=-1)\\n\\n self.word_embeddings = tf.nn.dropout(word_embeddings, self.dropout)\",\n \"def pass_word(word, model, input_embedding, char2idx, device, use_head=True):\\n inp = torch.LongTensor([char2idx['START']] + [char2idx[c] for c in word]).to(device)\\n inp = pack([inp])\\n out, hidden = model(input_embedding.unsqueeze(0), inp, use_head=use_head)\\n return out, hidden\",\n \"def _init_vocab(self):\\n self._word2idx = {}\\n self._idx2word = {}\\n self.freqs = {}\\n self.vocab_size = 0\\n\\n self._add_word(self.pad_word)\\n self._add_word(self.start_word)\\n self._add_word(self.end_word)\\n self._add_word(self.unk_word)\\n\\n self.start_word_idx = self.stoi(self.start_word)\\n self.end_word_idx = self.stoi(self.end_word)\\n self.unk_word_idx = self.stoi(self.unk_word)\\n self.pad_word_idx = self.stoi(self.pad_word)\\n\\n self._special_tokens = {\\n 'bos_token': self.start_word,\\n 'cls_token': self.start_word,\\n 'eos_token': self.end_word,\\n 'sep_token': self.end_word,\\n 'pad_token': self.pad_word,\\n 'unk_token': self.unk_word,\\n }\\n\\n self._special_ids = {\\n 'bos_token_id': self.start_word_idx,\\n 'cls_token_id': self.start_word_idx,\\n 'eos_token_id': self.end_word_idx,\\n 'sep_token_id': self.end_word_idx,\\n 'pad_token_id': self.pad_word_idx,\\n 'unk_token_id': self.unk_word_idx,\\n }\\n\\n self.cls_token_id = self.bos_token_id = self.start_word_idx\\n self.eos_token_id = self.sep_token_id = self.end_word_idx\\n self.pad_token_id = self.pad_word_idx\\n self.unk_token_id = self.unk_word_idx\\n\\n self.cls_token = self.bos_token = self.start_word\\n self.eos_token = self.sep_token = self.end_word\\n self.pad_token = self.pad_word\\n self.unk_token = self.unk_word\",\n \"def add_token(self, token):\\n token = self.process_token(token)\\n self._token_count.update([token])\",\n \"def add_token(self, token):\\n token = self.process_token(token)\\n self._token_count.update([token])\",\n \"def add_word(self, word):\\n if word not in self.word2index:\\n self.word2index[word] = self.n_words\\n self.word2count[word] = 1\\n self.index2word[self.n_words] = word\\n self.n_words += 1\\n else:\\n self.word2count[word] += 1\",\n \"def add_word(self, word):\\n if word not in self.word2index:\\n self.word2index[word] = self.n_words\\n self.word2count[word] = 1\\n self.index2word[self.n_words] = word\\n self.n_words += 1\\n else:\\n self.word2count[word] += 1\",\n \"def add_word(self):\\n word = self.word # easier to call word now\\n\\n wordlist_path = self.get_wordlist_path()\\n with open(wordlist_path) as f:\\n data = json.load(f)\\n\\n if exists_already(data,word):\\n exit()\\n\\n next_index = int(data[\\\"cur_index\\\"]) + 1 # new index\\n data[\\\"words\\\"][next_index] = word # update wordlist\\n data[\\\"words\\\"] = dict(sorted(data[\\\"words\\\"].items(), key=lambda item: item[1])) # alphabetisize\\n data[\\\"cur_index\\\"] = next_index # update index\\n\\n with open(wordlist_path, 'w') as f:\\n json.dump(data, f, indent = 4)\\n\\n print(f\\\"[{word}] added to [{self.pos}]. This is the [{next_index}] indexed word added.\\\")\",\n \"def add_paragram(self):\\n num_new_words = 720000\\n new_embeddings = np.empty((num_new_words, self.embedding_size))\\n concat_emb = np.zeros((2, self.embedding_size))\\n new_word2idx = dict()\\n new_words_count = 0\\n\\n self.load_all()\\n fi = open(self.config.word_vec_fi_paragram, \\\"r\\\", encoding=\\\"utf8\\\",\\n errors='ignore')\\n embed_gen = self.embeddings_file_gen(fi)\\n\\n for token, embedding in embed_gen:\\n if token not in self.word2idx:\\n new_word2idx[token] = self.vocab_size\\n new_embeddings[new_words_count, :] = embedding\\n self.vocab_size += 1\\n new_words_count += 1\\n else:\\n concat_emb[0, :] = self.embedding[self.word2idx[token]]\\n concat_emb[1, :] = embedding\\n self.embedding[self.word2idx[token]] = np.mean(\\n concat_emb,\\n axis=0\\n )\\n\\n self.word2idx.update(new_word2idx)\\n self.embedding = np.vstack((\\n self.embedding,\\n new_embeddings[:new_words_count, :]\\n ))\\n\\n self.write_all()\\n fi.close()\",\n \"def index_new_tweet(self, id_str, tweet_tokens: list):\\n self.tweet_count += 1\\n unique_words = set(tweet_tokens)\\n unique_word_pairs = set()\\n for i in unique_words:\\n for j in unique_words - {i}:\\n # To us [a, b] = [b, a], and sorting gives us a distinct representation.\\n unique_word_pairs.add(tuple(sorted([i, j])))\\n for w in unique_words | unique_word_pairs:\\n self.index[self.epoch][w] = id_str\\n current_freq = self.frequency_map.get(w, 0)\\n self.frequency_map[w] = current_freq + 1\\n # Get word statistics from hash table\\n statistics_present = w in self.stats_map\\n if not statistics_present:\\n (mu, sigma) = (math.inf, math.inf)\\n for h in self.hash_functions:\\n c = get_hash(h(), repr(w)) % 2 ** self.bit_count\\n if self.buckets[c][\\\"ewma\\\"] < mu:\\n mu = self.buckets[c][\\\"ewma\\\"]\\n sigma = self.buckets[c][\\\"ewmvar\\\"]\\n self.stats_map[w] = (mu, sigma)\\n (mu, sigma) = self.stats_map[w]\\n # Test for significance threshold\\n x = self.frequency_map[w]\\n if self._is_frequency_significant(mu, sigma, x):\\n self.refinement.append((w, self._get_significance(mu, sigma, x)))\\n # if self.refinement:\\n # r = self.refinement\\n # self.refinement = []\\n # return r\",\n \"def _update_feature_vec(fvec, word, tag_ngram):\",\n \"def add_unknown_token(self):\\n self.load_all()\\n sample_idxs = np.random.randint(0, self.embedding.shape[0],\\n self.config.embedding_sample_size)\\n unknown_vector = np.mean(self.embedding[sample_idxs, :], axis=0)\\n\\n self.add_embedding(self.config.unknown_token, unknown_vector)\\n self.write_all()\",\n \"def add_embedding(self):\\n ### YOUR CODE HERE (~4-6 lines)\\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\\n ### END YOUR CODE\\n return embeddings\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.pretrained_word_mat = tf.get_variable(\\\"word_emb_mat\\\",\\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[2:],\\n dtype=tf.float32),\\n trainable=False)\\n self.word_pad_unk_mat = tf.get_variable(\\\"word_unk_pad\\\",\\n [2, self.pretrained_word_mat.get_shape()[1]],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[:2],\\n dtype=tf.float32),\\n trainable=True)\\n\\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)\",\n \"def add_vocab_word(self, word):\\n # If it's a special token, it'll be separatelly processed during saving file. Skip here.\\n if word in special_tokens:\\n return\\n # Check each character in the word. We don't want none-character (control code) in the vocaburary.\\n for char in word:\\n if cu.is_none_char(char):\\n return\\n # If it's a new word, store it.\\n if (not word in self.words_ext) and (not word in self.words_new):\\n self.words_new.append(word)\",\n \"def analyze_corpus(self,\\n x: Union[Tuple[List[List[str]], ...], List[List[str]]],\\n y: Union[List[List[Any]], List[Any]]):\\n if len(self.processor.token2idx) == 0:\\n self._build_token2idx_from_gpt()\\n super(GPT2Embedding, self).analyze_corpus(x, y)\",\n \"def add_tokens(self, sample):\\n # Text\\n inputs = self._tokenizer.encode_plus(sample['text'],\\n add_special_tokens=True,\\n max_length=self._max_text_length,\\n padding='max_length', # TODO padding here or in model (together with item_glove)?\\n truncation=True, # truncate to 512 (added for MSNBC dataset)\\n return_attention_mask=True)\\n # TODO warn if text was truncated\\n #if len(TODO) > self._max_text_length:\\n # self._logger.info(f'Truncate long input sentence ({len(TODO)} tokens) to {self._max_text_length}')\\n sample['text_tokenized'] = inputs['input_ids']\\n sample['text_attention_mask'] = inputs['attention_mask']\\n # Item name (mention/surface form)\\n inputs = self._tokenizer.encode(sample['item_name'],\\n add_special_tokens=False)\\n sample['item_name_tokenized'] = inputs\",\n \"def _resize_token_embeddings(\\n cls, model: PreTrainedModel, tokenizer_wrapper: TokenizerWrapper\\n ):\\n if tokenizer_wrapper.num_added_special_tokens > 0:\\n model.resize_token_embeddings(\\n new_num_tokens=len(tokenizer_wrapper.tokenizer)\\n )\",\n \"def _add_seq2seq(self):\\n hps = self._hps\\n vsize = self._vocab.size() # size of the vocabulary\\n \\n with tf.variable_scope('seq2seq'):\\n # Some initializers\\n self.rand_unif_init = tf.random_uniform_initializer(-hps.rand_unif_init_mag, hps.rand_unif_init_mag, seed=123)\\n self.trunc_norm_init = tf.truncated_normal_initializer(stddev=hps.trunc_norm_init_std)\\n\\n\\n with tf.variable_scope('embedding'):\\n if hps.pretrained_embeddings:\\n word2vec = load_embeddings(hps.embeddings_path, self._vocab.word2id, hps.rand_unif_init_mag)\\n self.embedding = tf.get_variable('embedding', [vsize, hps.emb_dim],\\n dtype=tf.float32, initializer=tf.constant_initializer(word2vec))\\n # self.assign_embedding = tf.assign(self.embedding, word2vec)\\n else:\\n self.embedding = tf.get_variable('embedding', [vsize, hps.emb_dim],\\n dtype=tf.float32, initializer=self.trunc_norm_init)\\n if hps.mode==\\\"train\\\": self._add_emb_vis(self.embedding) # add to tensorboard\\n\\n # tensor with shape (batch_size, max_enc_steps, emb_size)\\n emb_enc_inputs = tf.nn.embedding_lookup(self.embedding, self._enc_batch)\\n if self._hps.hier:\\n enc_batch_sections = tf.unstack(self._enc_batch_sections, axis=1)\\n sec_emb_enc_inputs = [tf.nn.embedding_lookup(self.embedding, section)\\n for section in enc_batch_sections]\\n # list length max_dec_steps containing shape (batch_size, emb_size)\\n emb_dec_inputs = [tf.nn.embedding_lookup(self.embedding, x)\\n for x in tf.unstack(self._dec_batch, axis=1)]\\n\\n\\n # Hierarchical attention model\\n if self._hps.hier:\\n with tf.variable_scope('encoder'), tf.device(self._next_device()):\\n sec_enc_outs = []\\n states_fw = []\\n states_bw = []\\n states = []\\n\\n # level 1, encode words to sections\\n with tf.variable_scope(\\\"word_level_encoder\\\", reuse=tf.AUTO_REUSE) as scope:\\n encoder_outputs_words = []\\n cell_fw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n cell_bw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n fw_st, bw_st = None, None\\n if self._hps.use_do: # DropOut\\n cell_fw = tf.contrib.rnn.DropoutWrapper(cell_fw, output_keep_prob=1.0 - self._hps.do_prob)\\n cell_bw = tf.contrib.rnn.DropoutWrapper(cell_bw, output_keep_prob=1.0 - self._hps.do_prob)\\n for i in range(self._hps.num_sections):\\n encoder_tmp_output, (fw_st, bw_st) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, inputs=sec_emb_enc_inputs[i], dtype=tf.float32,\\n sequence_length=self._batch_sections_len[:,i], swap_memory=True, initial_state_bw=bw_st, initial_state_fw=fw_st)\\n # concatenate the forwards and backwards states\\n encoder_tmp_output = tf.concat(axis=2, values=encoder_tmp_output) #shape=[batch x seq_len x hidden_size]\\n \\n encoder_outputs_words.append(encoder_tmp_output)\\n # instead of concating the fw and bw states, we use a ff network\\n combined_state = self._reduce_states(fw_st, bw_st)\\n states.append(combined_state)\\n scope.reuse_variables()\\n \\n # level 2, encode sections to doc\\n encoder_outputs_words = tf.stack(encoder_outputs_words, axis=1) # shape [batch x num_sections x seq_len x hidden_size]\\n shapes = encoder_outputs_words.shape\\n encoder_outputs_words = tf.reshape(encoder_outputs_words, (shapes[0].value, -1, shapes[-1].value)) #shape=[batch x (seq_len * num_sections) x hidden_size]\\n\\n doc_sections_h = tf.stack([s.h for s in states], axis=1) # [batch x num_sections x hidden_size]\\n doc_sections_c = tf.stack([s.c for s in states], axis=1) # [batch x num_sections x hidden_size]\\n\\n with tf.variable_scope(\\\"section_level_encoder\\\"):\\n if FLAGS.section_level_encoder == 'RNN':\\n cell_fw_1 = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n cell_bw_1 = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n if self._hps.use_do:\\n cell_fw_1 = tf.contrib.rnn.DropoutWrapper(cell_fw_1, output_keep_prob=1.0 - self._hps.do_prob)\\n cell_bw_1 = tf.contrib.rnn.DropoutWrapper(cell_bw_1, output_keep_prob=1.0 - self._hps.do_prob)\\n encoder_output_sections, (fw_st_2, bw_st_2) =\\\\\\n tf.nn.bidirectional_dynamic_rnn(cell_fw_1, cell_bw_1, inputs=doc_sections_h, sequence_length=self._doc_sec_lens, dtype=tf.float32, swap_memory=True)\\n encoder_output_sections = tf.concat(axis=2, values=encoder_output_sections)\\n doc_sections_state = self._reduce_states(fw_st_2, bw_st_2)\\n else:\\n if FLAGS.section_level_encoder == 'AVG': # average section cells\\n doc_sections_state_h = tf.reduce_mean(doc_sections_h, axis=1)\\n doc_sections_state_c = tf.reduce_mean(doc_sections_c, axis=1)\\n elif FLAGS.section_level_encoder == 'FF': # use a feedforward network to combine section cells\\n doc_sections_state_h = tf.reshape([doc_sections_h.shape[0].eval(), -1])\\n doc_sections_state_h = tf.layers.dense(\\n inputs=doc_sections_state_h,\\n units=self._hps.hidden,\\n activation=tf.nn.relu) \\n doc_sections_state_c = tf.reshape([doc_sections_c.shape[0].eval(), -1])\\n doc_sections_state_c = tf.layers.dense(\\n inputs=doc_sections_state_c,\\n units=self._hps.hidden,\\n activation=tf.nn.relu)\\n else:\\n raise AttributeError('FLAGS.section_level_encoder={} is not a valid option'.format(FLAGS.section_level_encoder))\\n doc_sections_state = tf.contrib.rnn.LSTMStateTuple(doc_sections_state_c, doc_sections_state_h)\\n encoder_output_sections = doc_sections_h \\n \\n elif not self._hps.multi_layer_encoder:\\n with tf.variable_scope('encoder'):\\n with tf.variable_scope('word_level_encoder'):\\n cell_fw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n cell_bw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n (encoder_outputs, (fw_st, bw_st)) =\\\\\\n tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs=emb_enc_inputs, dtype=tf.float32, sequence_length=self._enc_lens, swap_memory=True)\\n # concatenate the forwards and backwards states\\n encoder_outputs = tf.concat(axis=2, values=encoder_outputs)\\n \\n # stack n layers of lstms for encoder\\n elif self._hps.multi_layer_encoder:\\n # TODO: check\\n for layer_i in xrange(self._hps.enc_layers):\\n with tf.variable_scope('encoder%d'%layer_i), tf.device(\\n self._next_device()):\\n cell_fw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n cell_bw = tf.contrib.rnn.LSTMCell(self._hps.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n if self._hps.use_do: # add dropout\\n cell_fw = tf.contrib.rnn.DropoutWrapper(cell_fw, output_keep_prob=1.0 - self._hps.do_prob)\\n cell_bw = tf.contrib.rnn.DropoutWrapper(cell_bw, output_keep_prob=1.0 - self._hps.do_prob)\\n emb_enc_inputs, (fw_st, bw_st) =\\\\\\n tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs=emb_enc_inputs, dtype=tf.float32, sequence_length=self._enc_lens, swap_memory=True)\\n emb_enc_inputs = tf.concat(axis=2, values=emb_enc_inputs)\\n encoder_outputs = emb_enc_inputs\\n \\n if self._hps.hier:\\n self._enc_sec_states = encoder_output_sections\\n self._enc_states = encoder_outputs_words \\n else:\\n self._enc_states = encoder_outputs\\n self._enc_sec_states = None\\n \\n # convert the encoder bidirectional hidden state to the decoder state\\n # (unidirectional) by an MLP\\n if self._hps.hier:\\n self._dec_in_state = doc_sections_state\\n else:\\n with tf.variable_scope('encoder'):\\n with tf.variable_scope('word_level_encoder'):\\n self._dec_in_state = self._reduce_states(fw_st, bw_st) \\n \\n # Add the decoder\\n\\n with tf.variable_scope('decoder'), tf.device(self._next_device()):\\n cell = tf.contrib.rnn.LSTMCell(\\n self._hps.hidden_dim,\\n state_is_tuple=True,\\n initializer=self.rand_unif_init)\\n \\n # We need to pass in the previous step's coverage vector each time\\n prev_coverage = self.prev_coverage\\\\\\n if hps.mode==\\\"decode\\\" and self._hps.coverage \\\\\\n else None \\n \\n \\n if self._hps.hier:\\n decoder_outputs, self._dec_out_state, self.attn_dists, self.p_gens, self.coverage, self.attn_dists_sec =\\\\\\n self.attn_decoder(emb_dec_inputs,\\n self._dec_in_state,\\n self._enc_states,\\n cell,\\n self._enc_sec_states,\\n num_words_section=self._batch_sections_len,\\n enc_padding_mask=self._enc_padding_mask,\\n enc_section_padding_mask=self._enc_section_padding_mask,\\n initial_state_attention=(self._hps.mode==\\\"decode\\\"),\\n pointer_gen=self._hps.pointer_gen,\\n use_coverage=self._hps.coverage,\\n prev_coverage=prev_coverage,\\n temperature=self._hps.temperature\\n )\\n \\n else:\\n decoder_outputs, self._dec_out_state, self.attn_dists, self.p_gens, self.coverage, _ =\\\\\\n self.attn_decoder(emb_dec_inputs,\\n self._dec_in_state,\\n self._enc_states,\\n cell,\\n encoder_section_states=None,\\n num_words_section=None,\\n enc_padding_mask=self._enc_padding_mask,\\n initial_state_attention=(self._hps.mode==\\\"decode\\\"),\\n pointer_gen=self._hps.pointer_gen,\\n use_coverage=self._hps.coverage,\\n prev_coverage=prev_coverage,\\n ) \\n \\n\\n # Project decoder output to vocabulary\\n with tf.variable_scope('output_projection'), tf.device(self._next_device()):\\n if self._hps.output_weight_sharing:\\n # share weights of embedding layer with projection\\n # self.embedding is in shape [vsize, hps.emb_dim]\\n w_proj = tf.get_variable('w_proj', [self._hps.emb_dim, self._hps.hidden_dim],\\n dtype=tf.float32, initializer=self.trunc_norm_init)\\n w = tf.tanh(tf.transpose(tf.matmul(self.embedding, w_proj))) # shape = [vsize, hps.hidden_dim]\\n \\n # w_t = tf.transpose(w)\\n b = tf.get_variable('b', [vsize],\\n dtype=tf.float32, initializer=self.trunc_norm_init)\\n else: \\n w = tf.get_variable('w', [self._hps.hidden_dim, vsize],\\n dtype=tf.float32, initializer=self.trunc_norm_init)\\n # w_t = tf.transpose(w)\\n b = tf.get_variable('b', [vsize],\\n dtype=tf.float32, initializer=self.trunc_norm_init)\\n # vocabulary score at each decoder step\\n vocab_scores = []\\n for i,output in enumerate(decoder_outputs):\\n if i > 0:\\n tf.get_variable_scope().reuse_variables()\\n vocab_scores.append(tf.nn.xw_plus_b(output, w, b)) # apply the linear layer\\n\\n # the final vocab distribution for each decoder time step\\n # shape of each element is [batch_size, vsize]\\n vocab_dists = [tf.nn.softmax(s) for s in vocab_scores] \\n\\n \\n # pointing / generating\\n if FLAGS.pointer_gen:\\n final_dists = self._calc_final_dist(vocab_dists, self.attn_dists)\\n# log_dists = [tf.log(dist) for dist in final_dists]\\n else:\\n# log_dists = [tf.log(dist) for dist in vocab_dists]\\n final_dists = vocab_dists\\n \\n\\n # Calculate Losses:\\n \\n if self._hps.mode in ['train', 'eval']:\\n # Calculate the loss\\n with tf.variable_scope('loss'), tf.device(self._next_device()):\\n if FLAGS.pointer_gen:\\n # Calculate the loss per step\\n # This is fiddly; we use tf.gather_nd to pick out the gold target words\\n # will be list length max_dec_steps containing shape (batch_size)\\n loss_per_step = [] \\n batch_nums = tf.range(0, limit=hps.batch_size) # shape (batch_size)\\n for dec_step, dist in enumerate(final_dists):\\n # The indices of the target words. shape (batch_size)\\n targets = self._target_batch[:,dec_step] \\n indices = tf.stack( (batch_nums, targets), axis=1) # shape (batch_size, 2)\\n # shape (batch_size). loss on this step for each batch\\n gold_probs = tf.gather_nd(dist, indices)\\n losses = -tf.log(gold_probs)\\n loss_per_step.append(losses)\\n\\n # Apply dec_padding_mask mask and get loss\\n self._loss = _mask_and_avg(loss_per_step, self._dec_padding_mask)\\n \\n\\n else: # baseline model\\n # this applies softmax internally\\n self._loss = tf.contrib.seq2seq.sequence_loss(\\n tf.stack(vocab_scores, axis=1), self._target_batch, self._dec_padding_mask) # this applies softmax internally\\n\\n tf.summary.scalar('loss', self._loss)\\n\\n # Calculate coverage loss from the attention distributions\\n if self._hps.coverage:\\n with tf.variable_scope('coverage_loss'):\\n self._coverage_loss = _coverage_loss(self.attn_dists, self._dec_padding_mask)\\n tf.summary.scalar('coverage_loss', self._coverage_loss)\\n self._total_loss = self._loss + self._hps.cov_loss_wt * self._coverage_loss\\n tf.summary.scalar('total_loss', self._total_loss)\\n \\n # ---------------------------/\\n\\n\\n if self._hps.mode == \\\"decode\\\":\\n assert len(final_dists) == 1 # final_dists is a singleton list containing shape (batch_size, extended_vsize)\\n final_dists = final_dists[0]\\n topk_probs, self._topk_ids = tf.nn.top_k(final_dists, hps.batch_size*2) # take the k largest probs. note batch_size=beam_size in decode mode\\n self._topk_log_probs = tf.log(topk_probs)\",\n \"def token_to_alias(raw_text, vocab):\\n pass\",\n \"def add_doc_to_vocab(filename, vocab):\\n doc = load_doc(filename)\\n tokens = clean_doc(doc)\\n vocab.update(tokens)\",\n \"def add_doc_to_vocab(filename, vocab):\\n doc = load_doc(filename)\\n tokens = clean_doc(doc)\\n vocab.update(tokens)\",\n \"def add_embedding(self, prefix=''):\\n with tf.variable_scope(prefix + 'embed'):\\n if self.cfg.fix_emb:\\n assert (hasattr(self.cfg, 'W_emb'))\\n W_emb = pkl.load(open(self.cfg.W_emb_path, 'rb'))\\n W = tf.get_variable('W', initializer= W_emb, trainable=True)\\n print(\\\"iniitalize word embedding finished\\\")\\n else:\\n weightInit = tf.random_uniform_initializer(-0.001, 0.001)\\n vocab = pkl.load(open(self.cfg.vocab_path, 'rb'))\\n W = tf.get_variable('W', [len(vocab), self.cfg.emb_size], initializer=weightInit)\\n if hasattr(self.cfg, 'relu_w') and self.cfg.relu_w:\\n W = tf.nn.relu(W)\\n return W\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.word_embeddings = tf.get_variable(\\n 'word_embeddings',\\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\\n trainable=True\\n )\\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\\n\\n with tf.variable_scope('char_embedding'):\\n self.char_embeddings = tf.get_variable(\\n 'char_embeddings',\\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\\n trainable=True\\n )\\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\\n\\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \\\"p_emb\\\")\\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \\\"q_emb\\\")\\n '''\\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\\n\\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=None)\\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=True)\\n\\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\\n\\n batch_size = tf.shape(self.p_word_emb)[0]\\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\\n\\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\\n '''\\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)\",\n \"def word2vec2embed(word2vec, word2idx):\\n\\temb_dim = word2vec['the'].shape[0]\\n\\temb = torch.nn.Embedding(len(word2idx), emb_dim) \\n\\temb_matrix = []\\n\\tfor w, idx in word2idx.items():\\n\\t\\tif w in word2vec:\\n\\t\\t\\temb_matrix.append(word2vec[w])\\n\\t\\telse:\\n\\t\\t\\temb_matrix.append(np.zeros(emb_dim,))\\n\\temb.weight.data.copy_(torch.from_numpy(np.array(emb_matrix)))\\n\\treturn emb\",\n \"def AddToken(self, token, merge=False):\\n token.SetLangId(self.id_)\\n if not merge:\\n self.tokens_.append(token)\\n else:\\n exists = self.MatchToken(token)\\n if exists is None:\\n self.tokens_.append(token)\\n else:\\n exists.IncrementCount(token.Count())\",\n \"def build(self,unused):\\n # (word_embeddings_shape, _) = input_shapes\\n # width = word_embeddings_shape.as_list()[-1]\\n if self.use_type_embeddings:\\n self.type_embeddings = self.add_weight(\\n \\\"token_type_embeddings\\\",\\n shape=[self.token_type_vocab_size, self.word_embedding_width],\\n initializer=get_initializer(self.initializer_range),\\n dtype=self.dtype)\\n\\n self.position_embeddings = None\\n if self.use_position_embeddings:\\n self.position_embeddings = self.add_weight(\\n \\\"position_embeddings\\\",\\n shape=[self.max_position_embeddings, self.word_embedding_width],\\n initializer=get_initializer(self.initializer_range),\\n dtype=self.dtype)\\n\\n self.output_layer_norm = tf.keras.layers.LayerNormalization(\\n name=LAYER_NORM_NAME, axis=-1, epsilon=1e-12, dtype=tf.float32)\\n self.output_dropout = tf.keras.layers.Dropout(\\n rate=self.dropout_prob, dtype=tf.float32)\\n super().build(unused)\",\n \"def __init__(self,\\n embedder: Embedder,\\n word_to_index: Dict[str, int],\\n cuda: bool = False):\\n super(IndexBatchEmbedder, self).__init__(embedder, OrderedDict(word_to_index), cuda=cuda)\",\n \"def add_embeddings(self):\\n\\n with tf.device('/cpu:0'):\\n with tf.variable_scope('Embedding_Layer'):\\n embeddings = tf.Variable(self.initial_embeddings,name = 'Embeddings')\\n self.input_embeddings = tf.nn.embedding_lookup(embeddings, self.inputs_placeholder) #(N,S,D)\\n self.question_embeddings = tf.nn.embedding_lookup(embeddings, self.questions_placeholder) #(N,S,D)\",\n \"def index_words(self, tokens):\\n for token in tokens:\\n self.index_word(token)\",\n \"def add_word_tag(self, token, label):\\n # Add total count for label\\n self.label_counts[label] += 1\\n # Add count for word given label\\n if token not in self.words_labels_counts[label]:\\n self.words_labels_counts[label][token] = 1\\n else:\\n self.words_labels_counts[label][token] += 1\",\n \"def replace_tokens(self, tokens):\\n details = []\\n idx = 0\\n if len(tokens) >= min_token_num:\\n for i in range(len(tokens)):\\n old_token = tokens[i]\\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\\n tokens[i] = self.get_insert_token(tokens[i])\\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\\n idx += len(tokens[i])\\n return tokens, details\",\n \"def preprocess(self, sequence, word2idx):\\n context = [word2idx[word]\\n if word in word2idx else UNK_token for word in sequence.split()]\\n context = torch.Tensor(context)\\n return context\",\n \"def add_new_doc(self, document, documents_list_length=10000):\\n\\n try:\\n document_dictionary = document.term_doc_dictionary\\n # self.countDoc += 1\\n for term in document_dictionary.keys():\\n if self.stemming == 'y':\\n my_stemmer = Stemmer()\\n term = my_stemmer.stem_term(term)\\n # Update inverted index and posting\\n if term not in self.inverted_idx.keys():\\n self.inverted_idx[term] = [1, [\\n (document_dictionary[term], document.tweet_id)]] # amount of doc, freq in the doc, doc id.\\n\\n else:\\n self.inverted_idx[term][0] += 1 # amount of doc\\n self.inverted_idx[term][1].append((document_dictionary[term],\\n document.tweet_id)) # freq in the doc # doc id\\n\\n if term not in self.postingDict.keys():\\n self.postingDict[term] = [(document.tweet_id, document_dictionary[term])]\\n else:\\n self.postingDict[term].append((document.tweet_id, document_dictionary[term]))\\n # self.countTweet -= 1\\n\\n if document.tweet_id not in self.tweet_dict.keys():\\n self.tweet_dict[document.tweet_id] = [[term, document_dictionary[term]], 1,\\n 0] # [term,freq in tweet], amount of unique terms in tweet, amount of terms in tweet\\n elif document_dictionary[term] > self.tweet_dict[document.tweet_id][0][\\n 1]: # tweet exist, compering between freq in two terms\\n if self.tweet_dict[document.tweet_id][0][\\n 1] == 1: # before change term check if the last term is unique\\n self.tweet_dict[document.tweet_id][\\n 1] += 1 # last term is unique: add to the amount of uniqe terms in tweet\\n self.tweet_dict[document.tweet_id][0] = [term,\\n document_dictionary[term]] # change between the terms\\n self.tweet_dict[document.tweet_id][2] += 1\\n elif document_dictionary[term] == 1: # tweet exist, not most common, check if unique\\n self.tweet_dict[document.tweet_id][1] += 1\\n self.tweet_dict[document.tweet_id][2] += 1\\n except:\\n # print('problem in indexer : add_new_doc')\\n # print(traceback.print_exc())\\n pass\",\n \"def preprocess(self, sequence, word2idx):\\n story = [word2idx[word] if word in word2idx else UNK_token for word in sequence.split()]\\n story = torch.Tensor(story)\\n return story\",\n \"def __iadd__(self, other):\\n if isinstance(other, Token):\\n new = Token(self.text + other.text, self.position, self.category)\\n else:\\n new = Token(self.text + other, self.position, self.category)\\n return new\",\n \"def addToken(self, token: Token, offset: int):\\n self.__tokens.append(token)\\n self.__tokenMap[token] = offset\",\n \"def merge_with(self, other):\\n old2new = {}\\n for other_id, other_token in iteritems(other):\\n if other_token in self.token2id:\\n new_id = self.token2id[other_token]\\n else:\\n new_id = len(self.token2id)\\n self.token2id[other_token] = new_id\\n self.dfs[new_id] = 0\\n old2new[other_id] = new_id\\n try:\\n self.dfs[new_id] += other.dfs[other_id]\\n except Exception:\\n # `other` isn't a Dictionary (probably just a dict) => ignore dfs, keep going\\n pass\\n try:\\n self.num_docs += other.num_docs\\n self.num_nnz += other.num_nnz\\n self.num_pos += other.num_pos\\n except Exception:\\n pass\\n\\n import gensim.models\\n return gensim.models.VocabTransform(old2new)\",\n \"def add_new_doc(self, document, end_of_corpus):\\n max_tf = 0\\n unique_terms_counter = 0\\n document_dictionary = document.term_doc_dictionary\\n # Go over each term in the doc\\n for term in document_dictionary:\\n try:\\n # Update inverted index and posting\\n if term not in self.inverted_idx:\\n self.inverted_idx[term] = 1\\n unique_terms_counter += 1\\n else:\\n self.inverted_idx[term] += 1\\n if term not in self.posting_dict:\\n self.posting_dict[term] = []\\n\\n self.posting_dict[term].append(\\n (document.tweet_id, document_dictionary[term])) # key: str , value: array of tuples\\n\\n max_tf = max(document_dictionary[term], max_tf)\\n\\n except:\\n\\n print('problem with the following key {}'.format(term[0]))\\n\\n document.max_tf = max_tf\\n document.unique_terms = unique_terms_counter\\n self.docs_count += 1\\n\\n modulo = int(document.tweet_id) % 10\\n self.documents[modulo][document.tweet_id] = [document.term_doc_dictionary, document.max_tf]\\n\\n if self.docs_count == self.DOCS_SIZE or end_of_corpus: # if we reach chunk size or end of corpus\\n self.add_to_file(end_of_corpus)\\n self.docs_count = 0\\n self.posting_dict = {}\\n\\n for i in self.documents: # 0 - 9\\n if self.documents[i].__len__() > 15000:\\n doc = utils.load_obj(self.out + \\\"document\\\" + str(i))\\n doc.update(self.documents[i])\\n utils.save_obj(doc, self.out + \\\"document\\\" + str(i))\\n self.documents[i] = {}\",\n \"def set_embeddings(self):\",\n \"def add(self, key, idx=None, count=1):\\n key = self.lower_(key)\\n if idx is not None:\\n self.index2word[idx] = key\\n self.word2index[key] = idx\\n else:\\n if key not in self.word2index:\\n idx = len(self.word2index)\\n self.index2word[idx] = key\\n self.word2index[key] = idx\\n\\n if key not in self.word_count:\\n self.word_count[key] = count\\n else:\\n self.word_count[key] += count\",\n \"def update(self):\\n self.__token += self.__lines[self.__i]\\n self.__i += 1\",\n \"def add_embedding(self):\\n #with tf.variable_scope(\\\"RNN\\\", reuse = tf.AUTO_REUSE):\\n embeddings = tf.get_variable(\\\"embeddings\\\", initializer = self.pretrained_embeddings,trainable=True)\\n inputs = self.input_placeholder\\n inputs = tf.reshape(inputs, [self.config.batch_size, -1 , self.config.n_features])\\n embeddings = tf.nn.embedding_lookup(embeddings, self.input_placeholder)\\n embeddings = tf.reshape(embeddings, [self.config.batch_size, -1, self.config.n_features* self.config.embed_size])\\n embeddings = tf.cast(embeddings, tf.float32)\\n return embeddings\",\n \"def attachTokens(tokens, dynamicVocab=False, parse=False):\\n tokenTxt, posTxt = '', ''\\n global importantFrequentWordDic\\n if dynamicVocab:\\n for t in tokens:\\n if parse:\\n if len(tokens) > 1:\\n if t.getLemma() in importantFrequentWordDic:\\n tokenTxt += t.getTokenOrLemma() + '_'\\n else:\\n tokenTxt += unk + '_'\\n else:\\n tokenTxt += t.getTokenOrLemma() + '_'\\n else:\\n if t.getLemma() in importantFrequentWordDic:\\n tokenTxt += t.getTokenOrLemma() + '_'\\n else:\\n tokenTxt += unk + '_'\\n tokenTxt = tokenTxt[:-1]\\n else:\\n tokenTxt = '_'.join(t.getTokenOrLemma() for t in tokens)\\n posTxt = '_'.join(t.posTag for t in tokens)\\n return tokenTxt, posTxt.lower()\",\n \"def _add_new_word(self, word):\\n if word not in self.word_to_id:\\n word_id = len(self.word_to_id)\\n self.word_to_id[word] = word_id\\n self.id_to_word[word_id] = word\",\n \"def add_word(self, word, vector=None, low=-2., high=2.):\\n if word not in self.w2v_idx:\\n self.w2v_idx[word] = len(self.w2v_idx)\\n if vector is None:\\n vector = np.random.uniform(low=low, high=high, size=(self.w2v_dim,))\\n self.w2v_out.append(np.asarray(vector, dtype=np.float32))\\n else:\\n print(\\\"word %s already in this word2vec\\\" % word)\",\n \"def _index(self, corpus):\\n\\n # Transform documents to embeddings vectors\\n ids, dimensions, stream = self.embedder.model.index(corpus)\\n\\n # Load streamed embeddings back to memory\\n embeddings = np.empty((len(ids), dimensions), dtype=np.float32)\\n with open(stream, \\\"rb\\\") as queue:\\n for x in range(embeddings.shape[0]):\\n embeddings[x] = pickle.load(queue)\\n\\n # Remove temporary file\\n os.remove(stream)\\n\\n all_text = []\\n for para_id, text, _ in corpus:\\n all_text.append([text, para_id])\\n\\n df = pd.DataFrame(all_text, columns=[\\\"text\\\", \\\"paragraph_id\\\"])\\n\\n embedding_path = os.path.join(\\n self.index_path, self.embed_paths[\\\"embeddings\\\"])\\n dataframe_path = os.path.join(\\n self.index_path, self.embed_paths[\\\"dataframe\\\"])\\n ids_path = os.path.join(self.index_path, self.embed_paths[\\\"ids\\\"])\\n\\n # Load new data\\n if os.path.isfile(embedding_path) and (self.encoder_args[\\\"overwrite\\\"] is False):\\n logger.info(f\\\"Loading new data from {embedding_path}\\\")\\n\\n # Load existing embeddings\\n old_embeddings = np.load(embedding_path) # LOAD EMBEDDINGS\\n # Remove embeddings with document id overlaps\\n embeddings = np.vstack((old_embeddings, embeddings))\\n\\n # load IDs\\n old_ids = [doc_id[:-1] for doc_id in open_txt(ids_path)]\\n logger.debug(f\\\"New ID Length = {len(ids)}\\\")\\n logger.debug(f\\\"Old ID Length = {len(old_ids)}\\\")\\n # Remove document ids overlaps\\n logger.debug(f\\\"New ID Length = {len(ids)}\\\")\\n ids = old_ids + ids\\n logger.debug(f\\\"Merged ID Length = {len(ids)}\\\")\\n\\n # Append new dataframe\\n old_df = pd.read_csv(dataframe_path)\\n df = pd.concat([old_df, df])\\n\\n # Store embeddings and document index\\n # for future reference\\n np.save(embedding_path, embeddings)\\n with open(ids_path, \\\"w\\\") as fp:\\n fp.writelines([i + \\\"\\\\n\\\" for i in ids])\\n\\n # Save data csv\\n df.to_csv(dataframe_path, index=False)\\n\\n # Normalize embeddings\\n self.embedder.normalize(embeddings)\\n\\n # Save embeddings metadata\\n self.embedder.config[\\\"ids\\\"] = ids\\n self.embedder.config[\\\"dimensions\\\"] = dimensions\\n\\n # Create embeddings index\\n logger.info(f\\\"Creating embeddings and index\\\")\\n self.embedder.embeddings = ANN.create(self.embedder.config)\\n logger.info(f\\\"Created embeddings\\\")\\n\\n # Build the index\\n self.embedder.embeddings.index(embeddings)\\n logger.info(f\\\"Built the embeddings index\\\")\",\n \"def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\\r\\n input_string_x1=input_string_x1.decode(\\\"utf-8\\\")\\r\\n input_string_x2 = input_string_x2.decode(\\\"utf-8\\\")\\r\\n #1. get blue score vector\\r\\n feature_list=[]\\r\\n #get blue score with n-gram\\r\\n for i in range(n_gram):\\r\\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\\r\\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\\r\\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\\r\\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\\r\\n feature_list.append(blue_score_i_1)\\r\\n feature_list.append(blue_score_i_2)\\r\\n\\r\\n #2. get length of questions, difference of length\\r\\n length1=float(len(input_string_x1))\\r\\n length2=float(len(input_string_x2))\\r\\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\\r\\n feature_list.append(length_diff)\\r\\n\\r\\n #3. how many words are same, how many words are unique\\r\\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\\r\\n feature_list.extend(sentence_diff_overlap_features_list)\\r\\n\\r\\n #4. question 1,2 start with how/why/when\\r\\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\\r\\n #print(\\\"how_why_feature_list:\\\",how_why_feature_list)\\r\\n #feature_list.extend(how_why_feature_list)\\r\\n\\r\\n #5.edit distance\\r\\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\\r\\n feature_list.append(edit_distance)\\r\\n\\r\\n #6.cos distance from sentence embedding\\r\\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\\r\\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\\r\\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\\r\\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\\r\\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\\r\\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\\r\\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\\r\\n feature_list.extend(distance_list_fasttext)\\r\\n feature_list.extend(distance_list_word2vec)\\r\\n #feature_list.extend(list(sentence_diffence))\\r\\n #feature_list.extend(list(sentence_multiply))\\r\\n return feature_list\",\n \"def next_word(self):\\n self.append = self.add_new_word\",\n \"def build_word_embeddings(self):\\n if self.mode == \\\"encode\\\":\\n # Word embeddings are fed from an external vocabulary which has possibly\\n # been expanded (see vocabulary_expansion.py).\\n encode_emb1 = tf.placeholder(tf.float32, (\\n None, None, self.config.word_embedding_dim), \\\"encode_emb1\\\")\\n # No sequences to decode.\\n encode_emb2 = tf.placeholder(tf.float32, (\\n None, None, self.config.word_embedding_dim), \\\"encode_emb2\\\")\\n elif self.mode == \\\"test\\\":\\n encode_emb1 = tf.placeholder(tf.float32, (\\n None, None, self.config.word_embedding_dim), \\\"encode_emb1\\\")\\n # No sequences to decode.\\n encode_emb2 = tf.placeholder(tf.float32, (\\n None, None, self.config.word_embedding_dim), \\\"encode_emb2\\\")\\n else:\\n word_emb = tf.get_variable(\\n name=\\\"word_embedding\\\",\\n shape=[self.config.vocab_size, self.config.word_embedding_dim],\\n initializer=self.uniform_initializer)\\n\\n encode_emb1 = tf.nn.embedding_lookup(word_emb, self.encode_ids1)\\n encode_emb2 = tf.nn.embedding_lookup(word_emb, self.encode_ids2)\\n\\n\\n self.encode_emb1 = encode_emb1\\n self.encode_emb2 = encode_emb2\",\n \"def _get_embedding_layer(self, input_data, doc_input_data):\\n opts = self._options\\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\\n embed = []\\n\\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\\n embed_d = []\\n for n in range(opts.sentence_sample):\\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\\n embed_d.append(temp)\\n\\n if opts.concat == 'True':\\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\\n for j in range(opts.window_size):\\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed.append(embed_w)\\n embed.append(embed_d)\\n else:\\n combined_embed_vector_length = opts.embed_dim\\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\\n for j in range(opts.window_size):\\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed_w += embed_d\\n embed.append(embed_w)\\n\\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length\",\n \"def encode_samples(tokenized_samples, word_to_idx):\\n features = []\\n for sample in tokenized_samples:\\n feature = []\\n for token in sample:\\n if token in word_to_idx:\\n feature.append(word_to_idx[token])\\n else:\\n feature.append(0)\\n features.append(feature)\\n return features\",\n \"def dump_token_embeddings(vocab_file, options_file, weight_file, outfile):\\n with open(options_file, 'r') as fin:\\n options = json.load(fin)\\n max_word_length = options['char_cnn']['max_characters_per_token']\\n\\n vocab = UnicodeCharsVocabulary(vocab_file, max_word_length)\\n batcher = Batcher(vocab_file, max_word_length)\\n print('Computing {} LM token vectors'.format(vocab.size))\\n\\n ids_placeholder = tf.placeholder(\\n 'int32',\\n shape=(None, None, max_word_length)\\n )\\n print('Building Language model')\\n model = BidirectionalLanguageModel(\\n options_file, weight_file, ids_placeholder\\n )\\n\\n embedding_op = model.get_ops()['token_embeddings']\\n\\n n_tokens = vocab.size\\n embed_dim = int(embedding_op.shape[2])\\n\\n embeddings = np.zeros((n_tokens, embed_dim), dtype=lm_model.DTYPE)\\n\\n config = tf.ConfigProto(allow_soft_placement=True)\\n with tf.Session(config=config) as sess:\\n sess.run(tf.global_variables_initializer())\\n for k in tqdm(range(n_tokens), desc='Computing LM token embeddings', ncols=80):\\n token = vocab.id_to_word(k)\\n char_ids = batcher.batch_sentences([[token]])[0, 1, :].reshape(\\n 1, 1, -1)\\n embeddings[k, :] = sess.run(\\n embedding_op, feed_dict={ids_placeholder: char_ids}\\n )\\n\\n with h5py.File(outfile, 'w') as fout:\\n fout.create_dataset(\\n 'embedding', embeddings.shape, dtype='float32', data=embeddings\\n )\",\n \"def prepare_inputs(token_mapping, w2v_W, w2v_U, sentences):\\n tokens = [tokenize(token_mapping, sentence) for sentence in sentences] \\n \\n depth = len(token_mapping)\\n one_hot_tokens = []\\n for sentence in tokens:\\n one_hot_sentence = []\\n for i, token in enumerate(sentence):\\n if token != token_mapping['#UNK#']:\\n one_hot_sentence.append(one_hot_encode(token, depth))\\n else:\\n if i <= 2:\\n context_tokens = sentence[:i] + sentence[i+1:i+3]\\n else:\\n context_tokens = sentence[i-2:i] + sentence[i+1:i+3]\\n context_one_hot = [one_hot_encode(token, depth) for token in context_tokens]\\n context_mean = np.mean(np.asarray(context_one_hot), axis=0)\\n one_hot_sentence.append(context_mean)\\n one_hot_tokens.append(one_hot_sentence)\\n \\n one_hot_tokens = [np.asarray(ls) for ls in one_hot_tokens]\\n vec_tokens = [word2vec(w2v_W, w2v_U, sentence) for sentence in tqdm(one_hot_tokens, desc='Vectorizing tokens')]\\n return vec_tokens\",\n \"def forward(self, doc):\\n out = torch.tensor([]).float().to(self.device)\\n\\n for i in range(len(doc)):\\n sentences_raw = sentencesplit(cleantxt(doc[i]))\\n sentences_ready = torch.tensor([]).float().to(self.device)\\n for sentence in sentences_raw:\\n sentence = sentence.split()\\n if sentence == []:\\n continue\\n lookup_tensor = torch.tensor([]).long().to(self.device)\\n for word in sentence:\\n if word in self.embedd_dict:\\n lookup_tensor = torch.cat((lookup_tensor,\\n torch.LongTensor([self.embedd_dict[word]])), 0)\\n else:\\n lookup_tensor = torch.cat((lookup_tensor, torch.LongTensor([0])), 0)\\n # Word embedding\\n xw = self.word_embedding(lookup_tensor).view(1, -1, self.embedding_dim).to(self.device)\\n # Word GRU\\n self.hidden_gru_words = self.init_hidden_words()\\n hw, self.hidden_gru_words = self.gru_word(xw, self.hidden_gru_words)\\n # Word MLP\\n uw = nn.Tanh()(self.MLP_word(hw)).to(self.device)\\n # Word attention\\n attention_score = torch.matmul(uw, self.attention_word).squeeze().to(self.device)\\n attention_score = F.softmax(attention_score, dim=0).view(uw.size(0), uw.size(1), 1).to(self.device)\\n scored_x = (hw * attention_score).to(self.device)\\n s = torch.sum(scored_x, dim=1).to(self.device)\\n #collecting sentences\\n sentences_ready = torch.cat((sentences_ready, s), 0)\\n # Sentence GRU\\n if len(sentences_ready) == 0:\\n out = torch.cat((out,\\n torch.randn(1, self.number_cat).to(self.device)), 0).to(self.device)\\n continue\\n sentences_ready_gru = sentences_ready.view(1, -1, self.embedding_dim).to(self.device)\\n self.hidden_gru_sentences = self.init_hidden_sentences()\\n hs, self.hidden_gru_sentences = self.gru_sentence(torch.tensor(sentences_ready_gru), self.hidden_gru_sentences)\\n # SENTENCE MLP\\n us = nn.Tanh()(self.MLP_sentence(hs)).to(self.device)\\n # Sentence attention\\n attention_score = torch.matmul(us, self.attention_sentence).squeeze().to(self.device)\\n attention_score = F.softmax(attention_score, dim=0).view(us.size(0), us.size(1), 1).to(self.device)\\n scored_x = (hs * attention_score).to(self.device)\\n v = torch.sum(scored_x, dim=1).to(self.device)\\n # classification\\n p = self.MLP_classification(v).to(self.device)\\n out = torch.cat((out, p.float()), 0).float().to(self.device)\\n return out\",\n \"def _build_forward(self):\\n # with tf.variable_scope(\\\"word_embeddings\\\"):\\n # # Shape: (batch_size, num_sentence_words, embedding_dim)\\n # embedded_sentence_one = tf.nn.embedding_lookup( self.word_emb_mat, self.sentence_one)\\n # embedded_sentence_two = tf.nn.embedding_lookup( self.word_emb_mat, self.sentence_two)\\n\\n M1, A1, encoded_sentence_one = self.process_sentence(self.sentence_one, self.sentence_len_one, scope_name = 'sentence_one')\\n M2, A2, encoded_sentence_two = self.process_sentence(self.sentence_two, self.sentence_len_two, scope_name = 'sentence_two')\\n\\n with tf.name_scope(\\\"loss\\\"):\\n # Use the exponential of the negative L1 distance\\n # between the two encoded sentences to get an output\\n # distribution over labels.\\n # Shape: (batch_size, 2)\\n \\n # Manually calculating cross-entropy, since we output\\n # probabilities and can't use softmax_cross_entropy_with_logits\\n # Add epsilon to the probabilities in order to prevent log(0)\\n\\n if self.use_contrastive:\\n self.loss = self.constrastive_loss(encoded_sentence_one, encoded_sentence_two, self.y_true)\\n else:\\n self.y_pred = self._l1_similarity(encoded_sentence_one, encoded_sentence_two)\\n self.loss = tf.reduce_mean(-tf.reduce_sum(tf.cast(self.y_true, \\\"float\\\") *tf.log(self.y_pred),axis=1))\\n\\n self.loss = self.loss + self.matrix_penalty(A1) + self.matrix_penalty(A2) #add matrix penalty\\n\\n with tf.name_scope(\\\"accuracy\\\"):\\n # Get the correct predictions.\\n # Shape: (batch_size,) of bool\\n correct_predictions = tf.equal(\\n tf.argmax(self.y_pred, 1),\\n tf.argmax(self.y_true, 1))\\n\\n # Cast to float, and take the mean to get accuracy\\n self.accuracy = tf.reduce_mean(tf.cast(correct_predictions,\\n \\\"float\\\"))\\n\\n with tf.name_scope(\\\"train\\\"):\\n optimizer = tf.train.AdamOptimizer()\\n self.training_op = optimizer.minimize(self.loss,\\n global_step=self.global_step)\\n\\n with tf.name_scope(\\\"train_summaries\\\"):\\n # Add the loss and the accuracy to the tensorboard summary\\n tf.summary.scalar(\\\"loss\\\", self.loss)\\n tf.summary.scalar(\\\"accuracy\\\", self.accuracy)\\n self.summary_op = tf.summary.merge_all()\",\n \"def construct_embedding(self):\\n i = 0\\n self.load_dicts()\\n embedding_shape = (max(self.word2idx.values()) + 1,\\n self.embedding_size)\\n self.embedding = np.zeros(embedding_shape)\\n\\n with open(self.config.word_vec_fi_glove, 'r') as fi:\\n for line in fi:\\n word_vec = line.split(\\\" \\\")[1:]\\n self.embedding[i, :] = np.array(word_vec, dtype=np.float32)\\n i += 1\\n\\n self.write_embedding()\",\n \"def toLingDataToken(token):\\n\\n t = Token()\\n\\n t.set(\\n id=token.i,\\n word=token.orth_,\\n lemma=token.lemma_,\\n POS=token.tag_,\\n SPOS=token.pos_,\\n depID=token.dep,\\n depStr=token.dep_,\\n NE=token.ent_type_,\\n foreign=token.is_oov\\n )\\n\\n # setting features\\n '''\\n t.features = {}\\n #print(t.POS)\\n featureStr = translate(t.POS)\\n # save string form of feature translation\\n t.features['str'] = featureStr\\n\\n featureArr = featureStr.split(\\\"+\\\")\\n #print(featureArr)\\n # find the first feature\\n i = 0\\n while len(featureArr[i]) < 1:\\n i += 1\\n\\n t.features['type'] = featureArr[i]\\n if t.features['type'] in [\\\"N\\\"]:\\n # look for number\\n i += 1\\n while i < len(featureArr):\\n # this means it's probably a number declaration\\n if len(featureArr[i]) < 4:\\n t.features['number'] = featureArr[i]\\n # and next feature could be type of noun\\n if i + 1 < len(featureArr):\\n t.features['isProper'] = featureArr[i + 1]\\n break\\n i += 1\\n\\n if t.features['type'] in [\\\"V\\\"]:\\n # look for person and number\\n i += 1\\n while i < len(featureArr):\\n # this means it's probably a person declaration\\n if len(featureArr[i]) < 4:\\n t.features['person'] = featureArr[i]\\n # and next feature could be number\\n if i + 1 < len(featureArr):\\n t.features['number'] = featureArr[i + 1]\\n break\\n else:\\n # probably a tense\\n t.features['tense'] = featureArr[i]\\n t.features['isParticiple'] = (\\\"Part\\\" in featureArr[i])\\n\\n i += 1\\n #print(t.features)\\n '''\\n\\n # setting wordType\\n if token.tag_ == \\\"BES\\\": # copula\\n t.set(wordType=4)\\n elif token.pos_ == \\\"VERB\\\":\\n t.set(wordType=1)\\n elif token.pos_ == \\\"NOUN\\\" or token.pos_ == \\\"PROPN\\\":\\n t.set(wordType=2)\\n elif token.pos_ == \\\"PRON\\\":\\n t.set(wordType=3)\\n else:\\n t.set(wordType=5)\\n\\n # spaCy does not have coreferencing...\\n\\n return t\",\n \"def get_mismatch_token_idx(self, words: List[str]):\\n # todo(yuxian): this line is extremely slow, need optimization\\n wordpieces, offsets = self._allennlp_tokenizer.intra_word_tokenize(words)\\n\\n # For tokens that don't correspond to any word pieces, we put (-1, -1) into the offsets.\\n # That results in the embedding for the token to be all zeros.\\n offsets = [x if x is not None else (-1, -1) for x in offsets]\\n\\n output = {\\n \\\"token_ids\\\": torch.LongTensor([t.text_id for t in wordpieces]),\\n \\\"word_mask\\\": torch.BoolTensor([True] * len(words)), # for original tokens (i.e. word-level)\\n \\\"offsets\\\": torch.LongTensor(offsets),\\n \\\"wordpiece_mask\\\": torch.BoolTensor([True] * len(wordpieces)), # for wordpieces (i.e. subword-level)\\n }\\n return output\",\n \"def add_new_doc(self, document):\\n self.counterOfTweets += 1\\n docID = document.tweet_id\\n document_dictionary = document.term_doc_dictionary # document_dictionary = {term:[[indexes],freq]}\\n self.tweetTerms[docID] = list(document_dictionary.keys())\\n freq_max = sorted(list(document_dictionary.values()), key=itemgetter(1), reverse=True)[0][1] # Gets the maxFreq\\n postingFileName = \\\"\\\"\\n\\n # Go over each term in the doc\\n for term in sorted(list(document_dictionary.keys())):\\n\\n # Deciding the type of the term\\n if (str(term[0]).lower() not in self.letters): # others\\n type = 1\\n elif (len(term) > 1): # 'J'\\n if str(term[1]).lower() not in self.letters and str(term[1]).lower() != '.': # 1400 -> 1.400K\\n type = 1\\n else: # strings\\n type = 2\\n else: # strings\\n type = 2\\n\\n if (' ' in term): # alone entities\\n if term not in self.alone_entities_dict: # fix it\\n self.alone_entities_dict[term] = 0\\n self.alone_entities_dict[term] += 1\\n\\n if (type == 1):\\n if (postingFileName != \\\"postingOthers\\\"):\\n postingFileName = \\\"postingOthers\\\"\\n\\n elif (len(term) == 1):\\n if postingFileName != \\\"posting_\\\" + term.lower():\\n postingFileName = \\\"posting_\\\" + term.lower()\\n\\n elif (term[1] == '.'):\\n if postingFileName != \\\"posting_\\\" + term[0].lower():\\n postingFileName = \\\"posting_\\\" + term[0].lower()\\n else:\\n if postingFileName != \\\"posting_\\\" + str(term[0]).lower() + str(term[1]).lower():\\n postingFileName = \\\"posting_\\\" + term[0].lower() + term[1].lower()\\n\\n indexes_t = document_dictionary[term][0]\\n freq_t = document_dictionary[term][1]\\n tf = freq_t / freq_max\\n\\n if term not in self.inverted_idx.keys():\\n self.postingFiles[postingFileName][term] = []\\n self.postingFiles[postingFileName][term].append([freq_t, docID, indexes_t, tf])\\n self.inverted_idx[term] = [1, freq_t, postingFileName]\\n\\n else:\\n # update inv_dict:\\n self.inverted_idx[term][0] += 1 # add another doc to the count in the inv_dict\\n self.inverted_idx[term][1] += freq_t\\n self.postingFiles[postingFileName][term].append([freq_t, docID, indexes_t, tf])\",\n \"def add_word(self, word, freq=None):\\n pass\",\n \"def _add_token_node_ids_to_span_nodes(self):\\n span_dict = defaultdict(list)\\n for span_edge in self._spanning_relation_ids:\\n token_node_id = self.edges[span_edge].target\\n span_node_id = self.edges[span_edge].source\\n span_dict[span_node_id].append(token_node_id)\\n\\n for span_node_id in span_dict:\\n self.nodes[span_node_id].tokens = span_dict[span_node_id]\",\n \"def __init__(\\n self,\\n word_embeddings: BasicTextFieldEmbedder,\\n input_dim: int,\\n hidden_dim: int,\\n attn_dim: int,\\n features_to_idx: dict = None,\\n feature_dim: int = None,\\n dropout: float = 0.5,\\n ):\\n super(AttentiveNER, self).__init__()\\n self.word_embeddings = word_embeddings\\n self.hidden_dim = hidden_dim\\n self.left_bilstm = PytorchSeq2SeqWrapper(\\n nn.LSTM(\\n input_dim, hidden_dim, batch_first=True, bidirectional=True\\n )\\n )\\n self.right_bilstm = PytorchSeq2SeqWrapper(\\n nn.LSTM(\\n input_dim, hidden_dim, batch_first=True, bidirectional=True\\n )\\n )\\n\\n self.attn = Attention(hidden_dim * 2, attn_dim)\\n\\n if features_to_idx is not None:\\n self.feat_embs = nn.Embedding(\\n len(features_to_idx) + 1, feature_dim, padding_idx=0\\n )\\n self.feat_to_idx = features_to_idx\\n\\n self.output_dim = (\\n 2 * hidden_dim + input_dim + feature_dim\\n ) # 50 is for features\\n else:\\n self.feat_to_idx = None\\n self.output_dim = 2 * hidden_dim + input_dim\\n\\n self.dropout = nn.Dropout(dropout)\",\n \"def _convert_id_to_token(self, index):\\n return self.reverse_vocab.get(index, self.unk_token)\",\n \"def index(self):\\n print(\\\"Indexing...\\\")\\n # ------------------------------------------------------------------\\n # TODO: Create an inverted, positional index.\\n # Granted this may not be a linked list as in a proper\\n # implementation.\\n # This index should allow easy access to both \\n # 1) the documents in which a particular word is contained, and \\n # 2) for every document, the positions of that word in the document \\n # Some helpful instance variables:\\n # * self.docs = List of documents\\n # * self.titles = List of titles\\n inv_index = defaultdict(set)\\n self.tf = defaultdict(Counter)\\n \\n for word in self.vocab:\\n inv_index[word] = {} # create dictionary with words in V\\n\\n # Generate inverted index here\\n for doc in range(len(self.docs)):\\n for word in self.docs[doc]:\\n self.tf[doc][word] += 1 # represents how many times word 'word' is mentioned in document 'i'\\n \\n for doc, title in zip(self.docs, self.titles):\\n for word in self.vocab:\\n inv_index[word][title] = [] # list for each word in vocabulary for all titles\\n for pos, word in enumerate(doc):\\n inv_index[word][title].append(pos)\\n\\n self.inv_index = inv_index\\n # ------------------------------------------------------------------\\n\\n # turn self.docs into a map from ID to bag of words\\n id_to_bag_of_words = {}\\n for d, doc in enumerate(self.docs):\\n bag_of_words = set(doc)\\n id_to_bag_of_words[d] = bag_of_words\\n self.docs = id_to_bag_of_words\",\n \"def add_to_index(self, term_, doc_id_):\\n\\n if(term_ not in self.inverted_index.keys()):\\n postingsList=LinkedList()\\n postingsList.insert_at_end(doc_id_)\\n #Doc freq\\n postingsList.length=postingsList.length+1\\n self.inverted_index[term_]=postingsList\\n# self.inverted_index[term_].start_node.term_frequency += 1\\n elif(not self.is_doc_id_in_posting_list(self.inverted_index[term_],doc_id_,term_)):\\n self.inverted_index[term_].insert_at_end(doc_id_)\\n self.inverted_index[term_].length=self.inverted_index[term_].length+1\",\n \"def pretrained_embedding_layer(word_to_vec_map, word_to_index):\\n \\n vocab_size = len(word_to_index) + 1 # adding 1 to fit Keras embedding (requirement)\\n any_word = list(word_to_vec_map.keys())[0]\\n emb_dim = word_to_vec_map[any_word].shape[0] # define dimensionality of your GloVe word vectors (= 50)\\n \\n ### START CODE HERE ###\\n # Step 1\\n # Initialize the embedding matrix as a numpy array of zeros.\\n # See instructions above to choose the correct shape.\\n emb_matrix = np.zeros((vocab_size, emb_dim))\\n \\n # Step 2\\n # Set each row \\\"idx\\\" of the embedding matrix to be \\n # the word vector representation of the idx'th word of the vocabulary\\n for word, idx in word_to_index.items():\\n emb_matrix[idx, :] = word_to_vec_map[word]\\n\\n # Step 3\\n # Define Keras embedding layer with the correct input and output sizes\\n # Make it non-trainable.\\n embedding_layer = tensorflow.keras.layers.Embedding(input_dim = vocab_size, output_dim = emb_dim, trainable = False)\\n ### END CODE HERE ###\\n\\n # Step 4 (already done for you; please do not modify)\\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \\n embedding_layer.build((None,)) # Do not modify the \\\"None\\\". This line of code is complete as-is.\\n \\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n embedding_layer.set_weights([emb_matrix])\\n \\n return embedding_layer\",\n \"def __add__(self, other):\\n if isinstance(other, Token):\\n return Token(self.text + other.text, self.position, self.category)\\n else:\\n return Token(self.text + other, self.position, self.category)\",\n \"def add_token(self, amount):\\n self.M += amount\",\n \"def add_word(self,word,index):\\r\\n\\r\\n #with shelf\\r\\n if self.using_shelf:\\r\\n\\r\\n if word in self.word_dict:\\r\\n\\r\\n self.word_dict[word].add(str(index))\\r\\n else:\\r\\n self.word_dict[word] = {str(index)}\\r\\n\\r\\n\\r\\n #with database\\r\\n if self.using_database:\\r\\n\\r\\n value_tuple = (notebookname, word,)\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE \\\"\\r\\n +\\\"INTO all_words \\\"\\r\\n +\\\"(word, notebook)\\\"\\r\\n +\\\" VALUES (?,?);\\\",value_tuple)\\r\\n value_tuple = (notebookname, word, str(index))\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE\\\"\\r\\n +\\\" INTO word_to_indexes \\\"\\r\\n +\\\"(notebook, word, note_index)\\\"\\r\\n +\\\" VALUES (?,?,?);\\\",\\r\\n value_tuple)\",\n \"def Emojify_V2(input_shape, word_to_vec_map, word_to_index):\\n \\n ### START CODE HERE ###\\n # Define sentence_indices as the input of the graph.\\n # It should be of shape input_shape and dtype 'int32' (as it contains indices, which are integers).\\n sentence_indices = Input(shape = input_shape, dtype = 'int32')\\n \\n # Create the embedding layer pretrained with GloVe Vectors (≈1 line)\\n # def pretrained_embedding_layer(word_to_vec_map, word_to_index): # return embedding_layer\\n embedding_layer = pretrained_embedding_layer(word_to_vec_map, word_to_index)\\n \\n # Propagate sentence_indices through your embedding layer\\n # (See additional hints in the instructions).\\n embeddings = embedding_layer(sentence_indices) \\n \\n # Propagate the embeddings through an LSTM layer with 128-dimensional hidden state\\n # The returned output should be a batch of sequences.\\n X = LSTM(units = 128, return_sequences = True)(embeddings)\\n # Add dropout with a probability of 0.5\\n X = Dropout(rate = 0.5)(X)\\n # Propagate X trough another LSTM layer with 128-dimensional hidden state\\n # The returned output should be a single hidden state, not a batch of sequences.\\n X = LSTM(units = 128, return_sequences = False)(X)\\n # Add dropout with a probability of 0.5\\n X = Dropout(rate = 0.5)(X) \\n # Propagate X through a Dense layer with 5 units\\n X = Dense(units = 5)(X)\\n # Add a softmax activation\\n X = Activation(activation = 'softmax')(X)\\n \\n # Create Model instance which converts sentence_indices into X.\\n model = Model(inputs = sentence_indices, outputs = X)\\n \\n ### END CODE HERE ###\\n \\n return model\",\n \"def build_token_dict(vocab):\\r\\n token_to_idx, idx_to_token = {}, {}\\r\\n next_idx = 1\\r\\n vocab_sorted = sorted(list(vocab)) # make sure it's the same order everytime\\r\\n for token in vocab_sorted:\\r\\n token_to_idx[token] = next_idx\\r\\n idx_to_token[next_idx] = token\\r\\n next_idx = next_idx + 1\\r\\n\\r\\n return token_to_idx, idx_to_token\",\n \"def add_word(self, word):\\n word = self.map_word(word)\\n super(InvariantLanguage, self).add_word(word)\",\n \"def add_embedding_layer(self, emb_matrix, ans2id, context2id, use_same=True):\\n with vs.variable_scope(\\\"embeddings\\\"):\\n qn_embedding_matrix = tf.Variable(emb_matrix, dtype=tf.float32,\\n name=\\\"qn_emb_matrix\\\") # shape (400002, embedding_size)\\n self.qn_embs = embedding_ops.embedding_lookup(qn_embedding_matrix, self.qn_ids)\\n\\n self.context_embedding_matrix = tf.Variable(tf.one_hot(range(len(context2id)), len(context2id)),\\n name=\\\"context_emb_matrix\\\")\\n if not use_same:\\n self.ans_embedding_matrix = tf.Variable(tf.one_hot(range(len(ans2id)), len(ans2id)),\\n dtype=tf.float32, name=\\\"ans_emb_matrix\\\")\\n else:\\n self.ans_embedding_matrix = tf.identity(self.context_embedding_matrix, name=\\\"ans_emb_matrix\\\")\\n\\n if self.FLAGS.use_raw_graph:\\n self.context_embs = embedding_ops.embedding_lookup(self.context_embedding_matrix, self.context_ids)\\n else:\\n self.context_embs = tf.identity(self.context_embedding)\\n self.ans_embs = embedding_ops.embedding_lookup(self.ans_embedding_matrix, self.ans_ids)\",\n \"def forward(\\n self,\\n mention_tokens: torch.tensor,\\n left_tokens: torch.tensor,\\n right_tokens: torch.tensor,\\n features: torch.tensor = None,\\n ):\\n mention_mask = get_text_field_mask(mention_tokens)\\n mention_embs = self.word_embeddings(mention_tokens)\\n avg_mentions = masked_mean(\\n mention_embs, mention_mask.unsqueeze(-1), dim=1\\n )\\n avg_mentions = self.dropout(avg_mentions)\\n\\n left_mask = get_text_field_mask(left_tokens)\\n left_embs = self.word_embeddings(left_tokens)\\n left_hidden_states = self.left_bilstm(left_embs, left_mask)\\n\\n right_mask = get_text_field_mask(right_tokens)\\n right_embs = self.word_embeddings(right_tokens)\\n right_hidden_states = self.right_bilstm(right_embs, right_mask)\\n\\n full_mask = torch.cat([left_mask, right_mask], dim=1)\\n full_hidden = torch.cat(\\n [left_hidden_states, right_hidden_states], dim=1\\n )\\n\\n attn_scores = self.attn(full_hidden, full_mask)\\n context = torch.sum(full_hidden * attn_scores, dim=1)\\n\\n if self.feat_to_idx is not None:\\n feat_rep = torch.sum(self.feat_embs(features), dim=1)\\n feat_rep = self.dropout(feat_rep)\\n\\n mention_rep = torch.cat([avg_mentions, context, feat_rep], dim=1)\\n else:\\n mention_rep = torch.cat([avg_mentions, context], dim=1)\\n\\n return mention_rep\",\n \"def add_instance(self, row, ind2c, c2ind, w2ind, dv_dict, num_labels):\\n labels = set()\\n hadm_id = int(row[1])\\n text = row[2]\\n length = int(row[4])\\n cur_code_set = set()\\n labels_idx = np.zeros(num_labels)\\n labelled = False\\n desc_vecs = []\\n #get codes as a multi-hot vector\\n for l in row[3].split(';'):\\n if l in c2ind.keys():\\n code = int(c2ind[l])\\n labels_idx[code] = 1\\n cur_code_set.add(code)\\n labelled = True\\n if not labelled:\\n return\\n if self.desc_embed:\\n for code in cur_code_set:\\n l = ind2c[code]\\n if l in dv_dict.keys():\\n #need to copy or description padding will get screwed up\\n desc_vecs.append(dv_dict[l][:])\\n else:\\n desc_vecs.append([len(w2ind)+1])\\n #OOV words are given a unique index at end of vocab lookup\\n text = [int(w2ind[w]) if w in w2ind else len(w2ind)+1 for w in text.split()]\\n #truncate long documents\\n if len(text) > self.max_length:\\n text = text[:self.max_length]\\n\\n #build instance\\n self.docs.append(text)\\n self.labels.append(labels_idx)\\n self.hadm_ids.append(hadm_id)\\n self.code_set = self.code_set.union(cur_code_set)\\n if self.desc_embed:\\n self.descs.append(pad_desc_vecs(desc_vecs))\\n #reset length\\n self.length = min(self.max_length, length)\",\n \"def w2v_embedding(input_file, bin_file, output_file):\\n print(\\\"Loading the training corpus.\\\")\\n df = open(src_file_path, \\\"r\\\") # Open the text file stored at src_file_path\\n df = df.read() # Read the text file\\n tokens1 = word_tokenize(df) # Tokenize\\n token_list = []\\n print(\\\"Writing the bin file.\\\")\\n models = KeyedVectors.load_word2vec_format(bin_destination_file_path, binary=True) # Save bin format\\n print(\\\"Saving the word embeddings.\\\")\\n models.save_word2vec_format(txt_file_destination_path, binary=False) # Save the word vectors\\n \\n return txt_file_destination_path\",\n \"def _add_offsets_to_token_nodes(self):\\n for edge_index in self._textual_relation_ids:\\n token_node_index = self.edges[edge_index].source\\n self.nodes[token_node_index].onset = self.edges[edge_index].onset\\n self.nodes[token_node_index].offset = self.edges[edge_index].offset\",\n \"def update_embedding_layer(line_tokens, model, dictionary):\\n\\n global elmo_embedder\\n\\n out_of_corpus_vocab = [word for word in line_tokens if word not in dictionary.word2idx]\\n if len(out_of_corpus_vocab) == 0:\\n return\\n\\n print(\\\"OOV words found:\\\", out_of_corpus_vocab, file=sys.stderr)\\n\\n if model.using_pretrained == \\\"fasttext\\\":\\n pretrained_emb_model = vc.FastText()\\n elif model.using_pretrained == \\\"glove\\\":\\n pretrained_emb_model = vc.GloVe()\\n elif model.using_pretrained == \\\"elmo_top\\\" or model.using_pretrained == \\\"elmo_avg\\\":\\n dirname = os.path.dirname(__file__)\\n options_file = os.path.join(dirname, '../elmo-config/elmo_2x4096_512_2048cnn_2xhighway_options.json')\\n weight_file = os.path.join(dirname, '../elmo-config/elmo_2x4096_512_2048cnn_2xhighway_weights.hdf5')\\n # Retrieve cached version if already loaded, saves a lot of time if this code path is executed multiple times\\n if elmo_embedder is None:\\n elmo_embedder = ElmoEmbedder(options_file, weight_file)\\n else:\\n raise Exception(\\\"Unsupported embedding model:\\\", model.using_pretrained)\\n\\n print(\\\"Using Pretrained embedding:\\\", model.using_pretrained)\\n\\n if model.using_pretrained in ['fasttext', 'glove']:\\n\\n pretrained_vectors = pretrained_emb_model.vectors\\n pretrained_stoi = pretrained_emb_model.stoi\\n\\n elif 'elmo' in model.using_pretrained:\\n # We get the embeddings for all line_tokens which includes both known and unknown, if any.\\n # As elmo is character level we can find embedding of any word\\n reduced_vocab = [token for token in line_tokens if token not in\\n [\\\"#\\\", \\\"<EOT>\\\", \\\"<EOL>\\\", \\\"</s>\\\", \\\"<eos>\\\", \\\"<P>\\\", \\\"<unk>\\\"]]\\n pretrained_stoi = {v: k for k, v in enumerate(reduced_vocab)}\\n elmo_embeddings = elmo_embedder.embed_sentence(reduced_vocab)\\n if 'top' in model.using_pretrained:\\n pretrained_vectors = elmo_embeddings[-1]\\n elif 'avg' in model.using_pretrained:\\n pretrained_vectors = np.average(elmo_embeddings, axis=0)\\n pretrained_vectors = torch.from_numpy(pretrained_vectors)\\n out_of_corpus_vocab = [word for word in line_tokens if word not in dictionary.word2idx and word in pretrained_stoi]\\n\\n if len(out_of_corpus_vocab) == 0:\\n return\\n\\n # Update for only unknown/new word\\n new_vectors = []\\n for word in out_of_corpus_vocab:\\n dictionary.add_word(word)\\n new_vectors.append(pretrained_stoi[word])\\n\\n new_vectors = torch.index_select(pretrained_vectors, 0, torch.LongTensor(new_vectors))\\n\\n model.embedder = torch.nn.Embedding.from_pretrained(torch.cat([model.embedder.weight, new_vectors]))\\n if model.tie_weights:\\n model.decoder.weight = model.encoder.weight\",\n \"def build_vocab(self, lst_tokens):\\n freqs = {}\\n\\n # Calculate frequency of words\\n for tokens in lst_tokens:\\n for word in tokens:\\n if word not in self._special_tokens.values() and word not in freqs.keys():\\n freqs[word] = 0\\n freqs[word] += 1\\n\\n # Sort words by frequency\\n sorted_freqs = {k: v for k, v in sorted(freqs.items(), key=lambda item: item[1], reverse=True)}\\n\\n # Max size\\n if self.max_size is not None:\\n sorted_freqs = {k: v for i, (k, v) in enumerate(sorted_freqs.items()) if i < self.max_size}\\n\\n # Filter low frequency words\\n if self.min_freq is not None:\\n sorted_freqs = {k: v for k, v in sorted_freqs.items() if v >= self.min_freq}\\n\\n for word, freq in sorted_freqs.items():\\n self._word2idx[word] = self.vocab_size\\n self._idx2word[self.vocab_size] = word\\n self.vocab_size += 1\\n self.freqs[word] = freq\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6996325","0.6894177","0.6658061","0.65426093","0.6435544","0.6401983","0.6349686","0.63282156","0.6324981","0.6320355","0.6309303","0.6281128","0.6220901","0.62193155","0.61735755","0.61483675","0.6124767","0.61123055","0.61009485","0.6099443","0.60539865","0.6029573","0.60260046","0.6010395","0.6010395","0.6009577","0.6009577","0.5972944","0.59658504","0.59261703","0.59149694","0.59134793","0.5890359","0.5890232","0.5882686","0.58539194","0.57795805","0.57790476","0.5774198","0.5770239","0.57543606","0.57543606","0.57454854","0.57359964","0.57103443","0.57082206","0.56904835","0.56885844","0.56872207","0.567664","0.5668175","0.5664222","0.5661086","0.56529963","0.5652149","0.56508565","0.565042","0.56447953","0.56125844","0.5579144","0.5556679","0.55483764","0.5541547","0.5541473","0.55414134","0.55405456","0.55347776","0.5525313","0.55241036","0.55223125","0.55164427","0.55132246","0.5501834","0.5501162","0.5493467","0.5490545","0.5482417","0.5480123","0.54748964","0.5456216","0.5445224","0.54432327","0.5436444","0.5436356","0.5433653","0.543125","0.542317","0.54115456","0.54088515","0.54081637","0.5408023","0.5399552","0.53972554","0.53952867","0.5390998","0.53901255","0.5388979","0.53856087","0.5383562","0.53827226"],"string":"[\n \"0.6996325\",\n \"0.6894177\",\n \"0.6658061\",\n \"0.65426093\",\n \"0.6435544\",\n \"0.6401983\",\n \"0.6349686\",\n \"0.63282156\",\n \"0.6324981\",\n \"0.6320355\",\n \"0.6309303\",\n \"0.6281128\",\n \"0.6220901\",\n \"0.62193155\",\n \"0.61735755\",\n \"0.61483675\",\n \"0.6124767\",\n \"0.61123055\",\n \"0.61009485\",\n \"0.6099443\",\n \"0.60539865\",\n \"0.6029573\",\n \"0.60260046\",\n \"0.6010395\",\n \"0.6010395\",\n \"0.6009577\",\n \"0.6009577\",\n \"0.5972944\",\n \"0.59658504\",\n \"0.59261703\",\n \"0.59149694\",\n \"0.59134793\",\n \"0.5890359\",\n \"0.5890232\",\n \"0.5882686\",\n \"0.58539194\",\n \"0.57795805\",\n \"0.57790476\",\n \"0.5774198\",\n \"0.5770239\",\n \"0.57543606\",\n \"0.57543606\",\n \"0.57454854\",\n \"0.57359964\",\n \"0.57103443\",\n \"0.57082206\",\n \"0.56904835\",\n \"0.56885844\",\n \"0.56872207\",\n \"0.567664\",\n \"0.5668175\",\n \"0.5664222\",\n \"0.5661086\",\n \"0.56529963\",\n \"0.5652149\",\n \"0.56508565\",\n \"0.565042\",\n \"0.56447953\",\n \"0.56125844\",\n \"0.5579144\",\n \"0.5556679\",\n \"0.55483764\",\n \"0.5541547\",\n \"0.5541473\",\n \"0.55414134\",\n \"0.55405456\",\n \"0.55347776\",\n \"0.5525313\",\n \"0.55241036\",\n \"0.55223125\",\n \"0.55164427\",\n \"0.55132246\",\n \"0.5501834\",\n \"0.5501162\",\n \"0.5493467\",\n \"0.5490545\",\n \"0.5482417\",\n \"0.5480123\",\n \"0.54748964\",\n \"0.5456216\",\n \"0.5445224\",\n \"0.54432327\",\n \"0.5436444\",\n \"0.5436356\",\n \"0.5433653\",\n \"0.543125\",\n \"0.542317\",\n \"0.54115456\",\n \"0.54088515\",\n \"0.54081637\",\n \"0.5408023\",\n \"0.5399552\",\n \"0.53972554\",\n \"0.53952867\",\n \"0.5390998\",\n \"0.53901255\",\n \"0.5388979\",\n \"0.53856087\",\n \"0.5383562\",\n \"0.53827226\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77013934"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84896,"cells":{"query":{"kind":"string","value":"Averages word vectors that occur in both glove and paragram and creates union of two embeddings"},"document":{"kind":"string","value":"def add_paragram(self):\n num_new_words = 720000\n new_embeddings = np.empty((num_new_words, self.embedding_size))\n concat_emb = np.zeros((2, self.embedding_size))\n new_word2idx = dict()\n new_words_count = 0\n\n self.load_all()\n fi = open(self.config.word_vec_fi_paragram, \"r\", encoding=\"utf8\",\n errors='ignore')\n embed_gen = self.embeddings_file_gen(fi)\n\n for token, embedding in embed_gen:\n if token not in self.word2idx:\n new_word2idx[token] = self.vocab_size\n new_embeddings[new_words_count, :] = embedding\n self.vocab_size += 1\n new_words_count += 1\n else:\n concat_emb[0, :] = self.embedding[self.word2idx[token]]\n concat_emb[1, :] = embedding\n self.embedding[self.word2idx[token]] = np.mean(\n concat_emb,\n axis=0\n )\n\n self.word2idx.update(new_word2idx)\n self.embedding = np.vstack((\n self.embedding,\n new_embeddings[:new_words_count, :]\n ))\n\n self.write_all()\n fi.close()"},"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 word_averaging(wv, words):\n all_words, mean = set(), []\n \n for word in words:\n if isinstance(word, np.ndarray):\n mean.append(word)\n elif word in wv.vocab:\n mean.append(wv.vectors_norm[wv.vocab[word].index])\n all_words.add(wv.vocab[word].index)\n\n if not mean:\n logging.warning(\"Cannot compute similarity with no input: %s\", words)\n # Remove these examples in pre-processing...\n return np.zeros(50,)\n\n mean = gensim.matutils.unitvec(np.array(mean).mean(axis=0)).astype(np.float32)\n \n return mean","def sentence_to_avg(sentence, word_to_vec_map):\n # Get a valid word contained in the word_to_vec_map. \n any_word = list(word_to_vec_map.keys())[0]\n \n ### START CODE HERE ###\n # Step 1: Split sentence into list of lower case words (≈ 1 line)\n words = sentence.lower().split()\n\n # Initialize the average word vector, should have the same shape as your word vectors.\n avg = np.zeros(word_to_vec_map[any_word].shape)\n \n # Initialize count to 0\n count = 0\n \n # Step 2: average the word vectors. You can loop over the words in the list \"words\".\n for w in words:\n # Check that word exists in word_to_vec_map\n if w in word_to_vec_map:\n avg += word_to_vec_map[w]\n # Increment count\n count +=1\n \n if count > 0:\n # Get the average. But only if count > 0\n avg = avg / count\n \n ### END CODE HERE ###\n \n return avg","def avg_sentence_vector(words, model, num_features, index2word_set):\n featureVec = np.zeros((num_features,), dtype=\"float32\")\n nwords = 0\n\n for word in words:\n if word in index2word_set:\n nwords = nwords+1\n featureVec = np.add(featureVec, model.wv[word])\n # featureVec = np.add(featureVec, model.wv.__getitem__(word))\n\n if nwords>0:\n featureVec = np.divide(featureVec, nwords)\n return featureVec","def compute_avg_w2v_vector(w2v_dict, text_nlp_proc):\n SIZE = 50 # size of the w2v dimension\n list_of_word_vectors = [w2v_dict[w] for w in text_nlp_proc if w in w2v_dict.vocab.keys()]\n if len(list_of_word_vectors) == 0:\n result = [0.0]*SIZE\n else:\n result = np.sum(list_of_word_vectors, axis=0) / len(list_of_word_vectors)\n return result","def _merge_embeddings(self, hidden_states:List[List[float]], indices_subwords:List[List[int]]):\n embed_output = []\n # ignore the first and the last tokens which are respectively the [CLS] and [SEP] tokens\n hidden_states = hidden_states[1:-1 ,:]\n sentence_output = []\n for indices_to_merge in indices_subwords:\n # average the embeddings of the subwords of a word \n sentence_output.append(torch.mean(hidden_states[indices_to_merge], axis=0))\n embed_output.append(torch.stack(sentence_output).to(self.device))\n return embed_output","def get_sentence_average_w2v(sent, word_to_vec, embedding_dim):\n sum_vec = np.zeros((embedding_dim,))\n known_tokens = 0\n for token in sent.text:\n if (token in word_to_vec.dict):\n known_tokens += 1\n sum_vec += word_to_vec[token]\n if (known_tokens != 0):\n return sum_vec / known_tokens\n else:\n return sum_vec","def _get_emb_avg(g, lang):\n emb = np.zeros(emb_dims[lang])\n known_words_count = 0\n words = g.split()\n for w in words:\n if w in models[lang]:\n emb += models[lang][w]\n known_words_count += 1\n emb /= len(words)\n return emb, known_words_count > 0","def _get_emb_wavg(g, lang, a=0.001):\n emb = np.zeros(emb_dims[lang])\n known_words_count = 0\n words = g.split()\n for w in words:\n if w in models[lang]:\n emb += a / (a + word_freqs[lang][w]) * models[lang][w]\n known_words_count += 1\n emb /= len(words)\n return emb, known_words_count > 0","def aggregate_embeddings(list_of_embeddings):\n\n return np.mean(list_of_embeddings, axis=0)","def w2v_aggregation_letters(X, length_vector=100):\n global w2v_model_3gram\n if w2v_model_3gram == None:\n w2v_model_3gram = gensim.models.KeyedVectors.load_word2vec_format(os.path.join(os.environ['NOBULL_PATH'], 'w2v_char.vec'))\n X_raw = []\n for x in X:\n x_letter = cleanText_letters(x)\n X_raw.append(x_letter)\n\n\n num_row = len(X_raw)\n\n max_matrix = np.zeros(shape=(num_row, length_vector))\n\n average_matrix = np.zeros(shape=(num_row, length_vector))\n\n for row in range(num_row):\n \n temp_text = X_raw[row] \n temp_vector = temp_text.split()\n \n unique_vector = list(set(temp_vector))\n num_index = len(unique_vector)\n \n temp_matrix = np.zeros(shape=(num_index, length_vector))\n \n j = 0\n for word in unique_vector:\n \n temp_matrix[j] = get_vector(word, w2v_model_3gram, 100)\n j += 1\n\n max_matrix[row] = np.maximum.reduce(temp_matrix)\n average_matrix[row] = np.mean(temp_matrix, axis=0)\n \n result = np.concatenate((average_matrix, max_matrix), axis=1)\n result = sparse.csr_matrix(result)\n \n header = []\n \n for i in range(length_vector):\n temp_string = \"neww2v_average_\" + str(i) + \"-th\"\n header.append(temp_string)\n \n for i in range(length_vector):\n temp_string = \"neww2v_maximum_\" + str(i) + \"-th\"\n header.append(temp_string)\n\n return result, header","def word_averaging_list(wv, text_list):\n return np.vstack([word_averaging(wv, review) for review in text_list])","def _get_mean_embedding(self, words):\n\n # ensure the size still matches if it's loaded from pretrained word vectors\n size = self.size\n if self.w2v is not None:\n size = next(iter(self.w2v_.values())).size\n\n zero = np.zeros(size)\n if self.tfidf:\n embedding = np.mean([self.w2v_[w] * self.w2idf_[w]\n if w in self.w2v_ else zero for w in words], axis = 0)\n else:\n embedding = np.mean([self.w2v_.get(w, zero) for w in words], axis = 0)\n\n return embedding","def get_embeddings(vectors, text, generate_missing=False, k=300):\r\n embeddings = text.apply(lambda x: get_average_vec(x, vectors, generate_missing=generate_missing, k=k))\r\n return list(embeddings)","def compute_user_input_embedding(txt, model):\r\n embeddings = []\r\n tokens = txt.split(\" \")\r\n for word in tokens:\r\n embeddings.append(model.wv[word])\r\n sentence_embedding = compute_average(embeddings)\r\n return sentence_embedding","def analyze_embeddings(emb):\n dic = {\"Hi\": 0, \"En\": 1, \"Ot\": 2}\n count = [0, 0, 0, 0]\n count_zero = [0, 0, 0, 0]\n for i, j in zip(emb, corpus_trans):\n for k, l in zip(i, j):\n count[dic[l[1]]] += 1\n if sum(k) == 0:\n count_zero[dic[l[1]]] += 1\n count[-1] = sum(count)\n count_zero[-1] - sum(count_zero)\n print(\"hi, en, ot, total\")\n print(\"count: \", count)\n print(\"zero count: \", count_zero)","def average_word_vector(vectorfile, outvectorfile):\n\twith codecs.open(vectorfile, encoding='utf-8', mode='r') as infile:\n\t\twith codecs.open(outvectorfile, encoding='utf-8', mode='a+') as outfile:\n\t\t\tfor i, line in enumerate(infile):\n\t\t\t\tprint i\n\t\t\t\tif i == 0:\n\t\t\t\t\ta, b, c = map(int, line.split()[:3])\n\t\t\t\t\tprint('Number of sememes: {}\\n'\n\t\t\t\t\t\t 'Number of words: {}\\n'\n\t\t\t\t\t\t 'Dimension of vectors: {}'.format(a, b, c))\n\t\t\t\t\toutfile.write(str(b) + ' ' + str(c) + '\\n')\n\t\t\t\telif i > 462667:\n\t\t\t\t\toutfile.write(line)\n\t\t\t\telse:\n\t\t\t\t\tsline = line.split()\n\t\t\t\t\tword = sline[0]\n\t\t\t\t\tsense_num = int(sline[1])\n\t\t\t\t\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\n\t\t\t\t\t# extra = len(vectors) % sense_num\n\t\t\t\t\tvector_list = []\n\t\t\t\t\tfor start in range(0, len(vectors), c):\n\t\t\t\t\t\tvector_list.append(list(map(float, vectors[start: start+c])))\n\t\t\t\t\t# print vector_list\n\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\tvector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t# print np.array2string(vector_mean, max_line_width=200, formatter={'float_kind': lambda x: '%6f'%x})[1:-1].strip('\\n')\n\t\t\t\t\tnew_line = word + ' ' + np.array2string(vector_mean, max_line_width=2000, formatter={'float_kind': lambda x: '%6f'%x})[1:-1] + '\\n'\n\t\t\t\t\toutfile.write(new_line)","def create_embedding_matrix(self):\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\n vocab_size = len(self.vocab)\n result = np.zeros((vocab_size, self.embed_dim))\n unknown_token_set = set()\n\n found_words = 0\n avg = np.zeros(self.embed_dim)\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\n try:\n result[_] = self.pretrained_embedding[self.id2word[_]]\n avg += result[_]\n found_words += 1\n except:\n unknown_token_set.add(_)\n\n avg /= found_words\n for _ in unknown_token_set:\n result[_] = avg\n self.embedding = result\n return found_words, len(self.id2word)","def load_embeddings(emb_file, oovs=[], pads=[], sep=' ', lower=False, case_dim=True):\n word2emb = {}\n word2idx = {}\n\n # read and store all word vectors\n for line in open(emb_file, errors = 'ignore', encoding = 'utf-8'):\n try:\n fields = line.strip().split(sep)\n word = fields[0]\n vec = np.asarray(fields[1:], dtype='float32')\n if case_dim:\n is_upper = float(word[0].isupper())\n vec = np.insert(vec, 0, is_upper, axis=0)\n if lower:\n word = word.lower()\n word2emb[word] = vec\n if word not in word2idx:\n word2idx[word] = len(word2idx)\n except Exception as e:\n print('[WARNING] Exception in `load_embeddings`:', e)\n\n # get dimensions from the last vector added\n emb_dim = word2emb[word].shape[0]\n\n # add custom embeddings for special characters\n mu = 0\n sigma = 0.01\n\n for word in pads:\n if word not in word2idx:\n if case_dim:\n vec = npr.normal(mu, sigma, emb_dim-1)\n vec = np.insert(vec, 0, 0., axis=0)\n else:\n vec = npr.normal(mu, sigma, emb_dim)\n word2emb[word] = vec\n word2idx[word] = len(word2idx)\n else:\n print('[WARNING] Padding item ' + word + ' has an embedding vector')\n\n for word in oovs:\n if word not in word2idx:\n if case_dim:\n vec = npr.normal(mu, sigma, emb_dim-1)\n is_upper = float(word[0].isupper())\n vec = np.insert(vec, 0, is_upper, axis=0)\n else:\n vec = npr.normal(mu, sigma, emb_dim)\n word2emb[word] = vec\n word2idx[word] = len(word2idx)\n else:\n print('[WARNING] OOV alias ' + word + ' has an embedding vector')\n\n # create an embedding matrix\n vocab_size = len(word2emb)\n emb_matrix = np.zeros((vocab_size, emb_dim))\n for word, idx in word2idx.items():\n if word in word2emb:\n vec = word2emb[word]\n if vec is not None and vec.shape[0] == emb_dim:\n emb_matrix[idx] = np.asarray(vec)\n\n # print feedback data and return mappings\n print('[INFO] Embedding vocabulary:', emb_matrix.shape[0], '(lowercase: ' + str(lower) + ')')\n print('[INFO] OOV aliases:', oovs)\n print('[INFO] Padding items:', pads)\n print('[INFO] Embedding dimensions:', emb_dim, '(extra case dimension: ' + str(case_dim) + ')')\n return word2idx, np.asarray(emb_matrix), emb_dim","def get_review_embedding(review):\n review_sentences = nltk_tokenize.sent_tokenize(review)\n sentence_embeddings = list(map(get_sentence_embedding, review_sentences))\n if len(sentence_embeddings) == 0:\n print(\"Sentence_embeddings are empty!\")\n print(review)\n return torch.zeros(1,128)\n if review_embedding_type == \"avg\":\n # avg over all pairs [pairs, 1, 128] => [1, 128]\n mean = torch.mean(torch.stack(sentence_embeddings), axis=0)\n return mean","def word_average(self, sent):\n mean = []\n for word in sent:\n if word in self.word_model.wv.vocab:\n mean.append(self.word_model.wv.get_vector(word))\n\n if not mean: # empty words\n # If a text is empty, return a vector of zeros.\n logging.warning(\n \"cannot compute average owing to no vector for {}\".format(sent))\n return np.zeros(self.vector_size)\n else:\n mean = np.array(mean).mean(axis=0)\n return mean","def smart_procrustes_align_gensim(base_embed, other_embed, words=None):\n # make sure vocabulary and indices are aligned\n in_base_embed, in_other_embed = intersection_align_gensim(base_embed, other_embed, words=words)\n\n # get the embedding matrices\n base_vecs = in_base_embed.wv.syn0norm\n other_vecs = in_other_embed.wv.syn0norm\n\n # just a matrix dot product with numpy\n m = other_vecs.T.dot(base_vecs)\n # SVD method from numpy\n u, _, v = np.linalg.svd(m)\n # another matrix operation\n ortho = u.dot(v)\n # Replace original array with modified one\n # i.e. multiplying the embedding matrix (syn0norm)by \"ortho\"\n other_embed.wv.syn0norm = other_embed.wv.syn0 = (other_embed.wv.syn0norm).dot(ortho)\n return other_embed","def w2v_aggregation(X, length_vector=100):\n global w2v_model\n if w2v_model == None: # lazy load\n w2v_model = Word2Vec.load(os.path.join(os.environ['NOBULL_PATH'], 'model.w2v'))\n num_row = len(X)\n\n max_matrix = np.zeros(shape=(num_row, length_vector))\n average_matrix = np.zeros(shape=(num_row, length_vector))\n\n for row in range(num_row):\n \n temp_text = X[row] \n temp_vector = temp_text.split()\n \n unique_vector = list(set(temp_vector))\n num_index = len(unique_vector)\n \n temp_matrix = np.zeros(shape=(num_index, length_vector))\n \n j = 0\n for word in unique_vector:\n try:\n temp_matrix[j] = w2v_model[word]\n except:\n temp_matrix[j] = np.zeros(shape=(length_vector,))\n j += 1\n\n max_matrix[row] = np.maximum.reduce(temp_matrix)\n average_matrix[row] = np.mean(temp_matrix, axis=0)\n \n result = np.concatenate((average_matrix, max_matrix), axis=1)\n result = sparse.csr_matrix(result)\n \n header = []\n \n for i in range(length_vector):\n temp_string = \"oldw2v_average_\" + str(i) + \"-th\"\n header.append(temp_string)\n \n for i in range(length_vector):\n temp_string = \"oldw2v_maximum_\" + str(i) + \"-th\"\n header.append(temp_string) \n\n return result, header","def intersection_align_gensim(m1,m2, words=None):\n\n # Get the vocab for each model\n vocab_m1 = set(m1.wv.vocab.keys())\n vocab_m2 = set(m2.wv.vocab.keys())\n\n # Find the common vocabulary\n common_vocab = vocab_m1&vocab_m2\n if words: common_vocab&=set(words)\n\n # If no alignment necessary because vocab is identical...\n if not vocab_m1-common_vocab and not vocab_m2-common_vocab:\n return (m1,m2)\n\n # Otherwise sort by frequency (summed for both)\n common_vocab = list(common_vocab)\n common_vocab.sort(key=lambda w: m1.wv.vocab[w].count + m2.wv.vocab[w].count,reverse=True)\n\n # Then for each model...\n for m in [m1,m2]:\n # Replace old syn0norm array with new one (with common vocab)\n indices = [m.wv.vocab[w].index for w in common_vocab]\n old_arr = m.wv.syn0norm\n new_arr = np.array([old_arr[index] for index in indices])\n m.wv.syn0norm = m.wv.syn0 = new_arr\n\n # Replace old vocab dictionary with new one (with common vocab)\n # and old index2word with new one\n m.index2word = common_vocab\n old_vocab = m.wv.vocab\n new_vocab = {}\n for new_index,word in enumerate(common_vocab):\n old_vocab_obj=old_vocab[word]\n new_vocab[word] = gensim.models.word2vec.Vocab(index=new_index, count=old_vocab_obj.count)\n m.wv.vocab = new_vocab\n\n return (m1,m2)","def average_one_hots(sent, word_to_ind):\n known_words = 0\n size = len(word_to_ind.keys())\n sum_vec = np.zeros((size,))\n for token in sent.text: #going over all tokens and summing their embeddings\n if (token in word_to_ind):\n sum_vec += get_one_hot(size, word_to_ind[token])\n known_words += 1\n if (known_words != 0):\n return sum_vec / known_words\n else:\n return sum_vec","def get_mean_emb(self, text):\n return np.mean([self.emb.get(w.lower(), self.emb.get(\"_UNK\")) for w in text.split()], axis=0)","def word_average(self, sent):\n\n mean = []\n for word in sent:\n if word in self.word_model.wv.vocab:\n mean.append(self.word_model.wv.get_vector(word) *\n self.word_idf_weight[word]) # idf weighted\n\n if not mean: # empty words\n # If a text is empty, return a vector of zeros.\n logging.warning(\n \"cannot compute average owing to no vector for {}\".format(sent))\n return np.zeros(self.vector_size)\n else:\n mean = np.array(mean).mean(axis=0)\n return mean","def glove_embedding(self, texts, file):\n self.embedding_dict = dict()\n glove_file = open(file, encoding='utf-8')\n for line in glove_file:\n word_vector = line.split()\n word = word_vector[0]\n word_vector_arr = np.asarray(word_vector[1:], dtype='float32')\n self.embedding_dict[word] = word_vector_arr\n glove_file.close()\n \n i = 0\n with pgb.ProgressBar(max_value=len(texts)) as bar:\n for text in texts:\n vec = []\n text = text.split()\n for t in text:\n try:\n vec.append(self.embedding_dict[t.lower()])\n except KeyError:\n pass\n ## There are no matched words\n if len(vec) == 0:\n print(\"len 0 vec\")\n self.word_vec.append(np.zeros((100)))\n else:\n #print(np.array(vec))\n #print(np.array(vec).shape)\n sentence = self.sentence_vec(np.array(vec))\n #print(sentence)\n #print(sentence.shape)\n self.word_vec.append(sentence)\n i += 1\n bar.update(i)\n self.word_vec = np.array(self.word_vec)\n print(self.word_vec.shape)","def word_analogy(self):\n data = open(\"data/word_analogy_subset.en.ar.txt\").read().split('\\n')\n data = [x for x in data if len(x.split()) == 4]\n cnt = 0\n keys = list(self.embeddings_index.keys())\n vectors = np.array(list(self.embeddings_index.values()))\n norms = np.linalg.norm(vectors, axis=1)\n for i in data:\n i = self.preprocessor(i).split()\n try:\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\n except:\n continue\n unit = v / np.linalg.norm(v)\n dists = np.dot(vectors, unit) / norms\n best = np.argpartition(-dists, 10)[:10 + 1]\n best = best.take(np.argsort((-dists).take(best)))\n result = [(keys[sim], float(dists[sim]))\n for sim in best]\n sbv = result[:10]\n for j in sbv:\n if j[0] == i[3]:\n cnt += 1\n return cnt/ len(data)","def overlap_similarity(vect1, vect2, normalize=False, use_bigrams=False):\n overlap = len(set(vect1).intersection(set(vect2)))\n\n if use_bigrams:\n overlap += len(set(bigrams(vect1)).intersection(set(bigrams(vect2))))\n\n if not normalize:\n return overlap\n \n if overlap == 0:\n return 0\n \n return overlap / (math.log10(len(vect1)) + math.log10(len(vect2)))","def get_sentence_mean_vec(sentence):\n sentence_vecs = numpy.array([])\n \n sent1 = nltk.word_tokenize(sentence)\n for w in sent1: \n w = w.strip(\"'?.,- \")\n if not w in stop_words and w.lower() in glove_model:\n word_vec = numpy.array([glove_model[w.lower()]])\n if sentence_vecs.shape[0] == 0: # Initialize sentence vectors\n sentence_vecs = word_vec\n else:\n sentence_vecs = numpy.vstack((sentence_vecs, word_vec))\n # print(sentence_vecs.shape)\n if sentence_vecs.shape[0] == 0:\n return None\n elif sentence_vecs.shape == (300,):\n return numpy.expand_dims(sentence_vecs, axis=0)\n return numpy.mean(sentence_vecs, axis=0)","def produce_outputs(self):\n # if self.loaded_aggregated:\n # debug(\"Skippping {} mapping due to preloading\".format(self.base_name))\n # return\n # need to calc term numeric index for aggregation\n\n\n # if self.loaded_preprocessed:\n # debug(\"Skippping {} mapping due to preloading\".format(self.base_name))\n # return\n\n bagger = Bag(vocabulary=self.term_list, weighting=self.base_name, ngram_range=self.ngram_range)\n\n self.embeddings = np.ndarray((0, len(self.term_list)), dtype=np.int32)\n for idx in self.indices.get_train_test():\n texts = Text.get_strings(self.text.data.get_slice(idx))\n vecs = bagger.map_collection(texts, fit=False, transform=True)\n self.embeddings = np.append(self.embeddings, vecs, axis=0)\n del texts\n\n # texts = Text.get_strings(self.text.data.get_slice(test_idx))\n # vec_test = bagger.map_collection(texts, fit=do_fit)\n # del texts\n\n # self.embeddings = np.vstack((vec_train, vec_test))\n\n # self.embeddings = np.append(vec_train, vec_test)\n # self.vector_indices = (np.arange(len(train)), np.arange(len(test)))\n\n # set misc required variables\n self.set_constant_elements_per_instance()","def word2vec_generation(self, utterance, with_punctuations):\n vector = []\n\n #words = self.text_preparation(utterance)\n\n words = utterance\n\n #model_ = Word2Vec.load('model.bin')\n #if not self.is_word_in_word2vec_vocabulary(utterance, model_):\n # self.retrain_model([words])\n\n if with_punctuations:\n new_model = Word2Vec.load('./model/model_word2vec.bin')\n else:\n new_model = Word2Vec.load('./model/model_no_punctuation_word2vec.bin')\n\n\n\n # TODO: how generate word2vec vectors for each utterance using the vocabularies in Word2vec model?\n\n #First: average of Word2Vec vectors in each utterance\n for w in words:\n vector.append(new_model.wv[w])\n\n return np.mean(vector, axis=0)","def wordSimilarityRatio(sent_1,sent_2):","def grounding_words(self, w):\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])","def get_word_vector():\n\n patten = r\"[0-9\\s+\\.\\!\\/_,$%^*()?;；:-【】+\\\"\\']+|[+——！，;:。？、~@#￥%……&*（）]+\"\n s1 = input(\"句子1：\").strip()\n s2 = input(\"句子2：\").strip()\n s1 = re.sub(patten, \" \", s1)\n s2 = re.sub(patten, \" \", s2)\n cut1 = jieba.cut(s1)\n cut2 = jieba.cut(s2)\n\n list_word1 = (' '.join(cut1)).split()\n list_word2 = (' '.join(cut2)).split()\n print(list_word1)\n print(list_word2)\n\n key_word = list(set(list_word1 + list_word2)) # 取并集\n print(key_word)\n\n word_vector1 = np.zeros(len(key_word)) # 给定形状和类型的用0填充的矩阵存储向量\n word_vector2 = np.zeros(len(key_word))\n\n for i in range(len(key_word)): # 依次确定向量的每个位置的值\n for j in range(len(list_word1)): # 遍历key_word中每个词在句子中的出现次数\n if key_word[i] == list_word1[j]:\n word_vector1[i] += 1\n for k in range(len(list_word2)):\n if key_word[i] == list_word2[k]:\n word_vector2[i] += 1\n\n print(word_vector1) # 输出向量\n print(word_vector2)\n return word_vector1, word_vector2","def word_overlap2(sentence_a, sentence_b):\n a_set = set(word for word in sentence_a) - config.stop_list\n b_set = set(word for word in sentence_b) - config.stop_list\n score = len(a_set&b_set)/float(len(a_set|b_set))# len(s1&s2)/max(len(s1),len(s2))\n\n return score","def lookup(doc, wv):\n checked = []\n for word in doc:\n try:\n word in wv\n except KeyError:\n log.warning(\"Word not in model: %s\", word)\n continue\n checked.append(wv[word])\n vec = np.mean(checked, axis=0)\n return vec","def _aggregate_vectors(movies, feedback_list=[]):\n movie_vec = []\n for i in movies:\n try:\n m_vec = clf[i] # get the vector for each movie\n if ratings_dict:\n try:\n r = ratings_dict[i] # get user_rating for each movie\n # Use a polynomial to weight the movie by rating.\n # This equation is totally arbitrary. I just fit a polynomial\n # to some weights that look good. The effect is to raise\n # the importance of 1, 9, and 10 star ratings.\n w = ((r**3)*-0.00143) + ((r**2)*0.0533) + (r*-0.4695) + 2.1867\n m_vec = m_vec * w\n except KeyError:\n continue\n movie_vec.append(m_vec)\n except KeyError:\n continue\n if feedback_list:\n for i in feedback_list:\n try:\n f_vec = clf[i]\n movie_vec.append(f_vec*1.8) # weight feedback by adding multiplier here\n except KeyError:\n continue\n return np.mean(movie_vec, axis=0)","def get_word_embeddings(embeddingsPath, allwords, splittype=\" \"):\n word2Idx = {}\n wordEmbeddings = []\n print('Using word embeddings:', embeddingsPath)\n openfile = _get_correct_open(embeddingsPath)\n with openfile(embeddingsPath,'r', encoding='utf-8') as fEmbeddings:\n c = 0\n for line in fEmbeddings:\n c+=1\n split = line.strip().split(splittype)\n if '' in split:\n raise ValueError(\"Error in spacing of word vector file:\"+\n \" bad formatting. Consider using different value of splittype.\")\n word = split[0]\n\n # fastText and Yogatama pre-trained embedding starts with a line\n # with 2 elements that we need to ignore:\n if len(split) <= 5:\n print('Ignoring line '+str(c))\n continue\n\n if len(word2Idx) == 0: #Add padding+unknown\n word2Idx[\"PADDING_TOKEN\"] = len(word2Idx)\n vector = np.zeros(len(split)-1) #Zero vector for 'PADDING' word\n wordEmbeddings.append(vector)\n\n word2Idx[\"UNKNOWN_TOKEN\"] = len(word2Idx)\n vector = np.random.uniform(-0.25, 0.25, len(split)-1)\n wordEmbeddings.append(vector)\n\n if word.lower() in allwords:\n vector = np.array([float(num) for num in split[1:]])\n wordEmbeddings.append(vector)\n word2Idx[word] = len(word2Idx)\n\n wordEmbeddings = np.array(wordEmbeddings)\n return wordEmbeddings, word2Idx","def generate_initial_embs(emb_type):\n def _get_emb_avg(g, lang):\n \"\"\"Compute the embedding of g as the average of its word embeddings\n :param g: the input genre\n :param lang: language\n :return: the embedding and if all words of this genre are known\n \"\"\"\n emb = np.zeros(emb_dims[lang])\n known_words_count = 0\n words = g.split()\n for w in words:\n if w in models[lang]:\n emb += models[lang][w]\n known_words_count += 1\n emb /= len(words)\n return emb, known_words_count > 0\n\n def _get_emb_wavg(g, lang, a=0.001):\n \"\"\"Compute the embeddings of g with a sentence embedding algorithm (average weighted by the word estimated frequencies)\n :param g: the input genre\n :param lang: language\n :param a: a model hyper-parameter (see Arora et al. in the paper)\n :return: the embedding and if all words of this genre are known\n \"\"\"\n emb = np.zeros(emb_dims[lang])\n known_words_count = 0\n words = g.split()\n for w in words:\n if w in models[lang]:\n emb += a / (a + word_freqs[lang][w]) * models[lang][w]\n known_words_count += 1\n emb /= len(words)\n return emb, known_words_count > 0\n\n def _remove_pc(df_embs, npc=1):\n \"\"\"Remove the pc (see Arora at el. in the paper)\n :param df_embs: the input embeddings\n :return: the normalized embeddings\n \"\"\"\n pc = _compute_pc(df_embs, npc)\n if npc == 1:\n df_embs_out = df_embs - df_embs.dot(pc.transpose()) * pc\n else:\n df_embs_out = df_embs - df_embs.dot(pc.transpose()).dot(pc)\n return df_embs_out\n\n def _compute_pc(df_embs, npc=1):\n \"\"\"Compute the pc (see Arora at el. in the paper)\n :param df_embs: the input embeddings\n :return: the principal component\n \"\"\"\n svd = TruncatedSVD(n_components=npc, n_iter=7, random_state=0)\n svd.fit(df_embs)\n return svd.components_\n\n embs = {}\n known = {}\n for g in G.nodes:\n lang = g[:2]\n norm_g = TagManager.normalize_tag_wtokenization(g, tries[lang], prefixed=True)\n if emb_type == 'avg':\n embs[g], known[g] = _get_emb_avg(norm_g, lang)\n else:\n embs[g], known[g] = _get_emb_wavg(norm_g, lang)\n\n embs = pd.DataFrame(embs).T # the embeddings are columns\n if emb_type == 'sif': # the algorithm imposes a normalization\n norm_embs = _remove_pc(embs.to_numpy())\n embs = pd.DataFrame(norm_embs, columns=embs.columns, index=embs.index)\n return embs, known","def _aggregate_text_embedding(self, token_ids, embeddings):\n if self._hparams['obj_text_aggregation'] == 'max':\n # Find valid tokens (not PADDING/EOS/UNK/START).\n valid_token_mask = tf.greater_equal(token_ids, 4)\n # Use large negative bias for invalid tokens.\n invalid_token_bias = tf.cast(\n tf.logical_not(valid_token_mask), tf.float32) * -1e9\n # [batch, node_num, word_num, hidden_size]\n embeddings = embeddings + tf.expand_dims(invalid_token_bias, axis=-1)\n # Max value for each dimension, [batch, node_num, hidden_size].\n embeddings = tf.reduce_max(embeddings, axis=-2)\n # For objects with no text, use 0.\n valid_object_mask = tf.cast(\n tf.reduce_any(valid_token_mask, axis=-1), tf.float32)\n embeddings = embeddings * tf.expand_dims(valid_object_mask, axis=-1)\n\n elif self._hparams['obj_text_aggregation'] == 'sum':\n # [batch, step, #max_obj, #max_token] 0 for padded tokens\n real_objects = tf.cast(tf.greater_equal(token_ids, 4), tf.float32)\n # [batch, step, #max_obj, hidden] 0s for padded objects\n embeddings = tf.reduce_sum(\n input_tensor=embeddings * tf.expand_dims(real_objects, 3), axis=-2)\n\n else:\n raise ValueError('Unrecognized token aggregation %s' %\n (self._hparams['obj_text_aggregation']))\n return embeddings","def get_common(self, other, mapping):\n\n self_oov = defaultdict(lambda: 0)\n other_oov = defaultdict(lambda: 0)\n self_word_id = deepcopy(self.word_id)\n other_word_id = deepcopy(other.word_id)\n new_words = []\n map_ = mapping.map\n for i, w in enumerate(self.word_id):\n if w not in map_:\n self_oov[w] += 1\n del self_word_id[w]\n continue\n\n if map_[w] not in other.word_id:\n other_oov[map_[w]] += 1\n del self_word_id[w]\n\n for i, w in enumerate(other.word_id):\n if w not in map_:\n del other_word_id[w]\n\n logging.info(\"We could not find {} {} words in our dictionary.\".format(\n len(self_oov), self.lang))\n logging.info(\"We could not find {} {} words in our target words.\".format(\n len(other_oov), other.lang))\n logging.info(\"Our {} vocabulary has {} valid words.\".format(\n self.lang, len(self_word_id)))\n\n sorted_self_word_id = Embeddings.sorted_words(self_word_id)\n self_vectors = asarray([self.vectors[i] for w, i in sorted_self_word_id])\n self_words = [w for w, i in sorted_self_word_id]\n new_self = Embeddings(lang=self.lang, vectors=self_vectors, words=self_words)\n\n sorted_other_word_id = Embeddings.sorted_words(other_word_id)\n other_vectors = asarray([other.vectors[i] for w, i in sorted_other_word_id])\n other_words = [w for w, i in sorted_other_word_id]\n new_other = Embeddings(lang=self.lang, vectors=other_vectors, words=other_words)\n\n return (new_self, new_other)","def review_to_vec(words, model, num_features , index2word_set):\n \n feature_vec = np.zeros((num_features), dtype=\"float32\")\n word_count = 0\n \n \n \n for word in words:\n if word in index2word_set: \n word_count += 1\n feature_vec += model[word]\n\n if word_count == 0:\n word_count = 1\n\n feature_vec /= word_count\n\n return feature_vec","def get_word_containement_measure(self,l2,l1):\n count = 0\n found_idfs = []\n unfound_idfs = []\n for w in l1:\n val = self.idf.get_tfidf_val(w)\n if (val > 10):\n val = 10\n if w in l2:\n count += 1\n found_idfs.append(val)\n else:\n unfound_idfs.append(val)\n if (len(found_idfs) == 0):\n avg_found = 0\n else:\n avg_found = np.mean(found_idfs)\n if (len(unfound_idfs) ==0):\n avg_unfound = 0\n else:\n avg_unfound = np.mean(unfound_idfs)\n\n\n\n return count / self.normalize_factor, avg_found, avg_unfound","def _WordSimAveVec(self,df,a):\r\n #Obtain the course description for the course provided and convert the string into a list of individual words.\r\n Description = df['description'][a].split()\r\n #Create a placeholder zero vector of the same size as the vector embedding.\r\n Vector = np.zeros(self.WordVecModel.layer1_size)\r\n wordCount = 0\r\n #Iterate over each word in the description.\r\n for word in Description:\r\n #If the word is in the trained vocabulary, obtain the word vector. \r\n #Continue to add the word vectors to the placeholder vector to get the running sum.\r\n if word in self.WordVecModel.wv.vocab:\r\n vector = self.WordVecModel.wv.get_vector(word)\r\n Vector +=vector\r\n #Keep track of how many word vectors (which were included in the vocabulary) were added.\r\n wordCount +=1\r\n #Calculate the mean by dividing the sum by the number of vectors.\r\n return Vector/wordCount","def processUnigram(word, vector):\n\n unigram, exists = vector.getUnigram(word)\n vector.addUnigram(word)","def neutralize(word, g, word_to_vec_map):\n\n ### START CODE HERE ###\n # Select word vector representation of \"word\". Use word_to_vec_map. (≈ 1 line)\n e = word_to_vec_map[word]\n\n # Compute e_biascomponent using the formula given above. (≈ 1 line)\n e_biascomponent = np.dot(e, g) / np.sum(np.dot(g, g)) * g\n # e_biascomponent = np.sqrt(np.sum(np.dot(e,e))) * cosine_similarity(e, g) * g/np.sqrt(np.sum(np.dot(g,g)))\n # Neutralize e by subtracting e_biascomponent from it\n # e_debiased should be equal to its orthogonal projection. (≈ 1 line)\n e_debiased = e - e_biascomponent\n ### END CODE HERE ###\n\n return e_debiased","def word_similarity(self):\n y_true = []\n y_pred = []\n for i in open(\"data/word_sim_dataset.txt\").read().split('\\n'):\n i = self.preprocessor(i)\n w1 = i.split()[-1]\n w2 = i.split()[-2] \n st = float(i.split()[-3]) / 4 #dataset has scale from 0 to 4\n \n try:\n w1 = self.embeddings_index[w1] \n w2 = self.embeddings_index[w2] \n w1 = w1 / np.linalg.norm(w1)\n w2 = w2 / np.linalg.norm(w2)\n y_pred.append(np.dot(w1,w2))\n y_true.append(st)\n except:\n pass\n if y_true == []:\n return 1.0\n return mean_squared_error(y_true, y_pred, squared=False)","def compute_bias_average_vector(p1: list, p2: list, target:list, model: Word2Vec,\n metric:Callable[[list,list],float] = cosine_sim) -> float:\n av_v1 = average_vector(p1,model); av_v2 = average_vector(p2,model)\n return np.mean([metric(av_v1,model.wv.__getitem__(w)) - \\\n metric(av_v2,model.wv.__getitem__(w)) for w in target \n if w in model.wv])","def word_overlap3(t_raw, h_raw, replacements):\n t_set = set(word for word in t_raw) - config.stop_list\n h_set = set(word for word in h_raw) - config.stop_list\n score = len(t_set & h_set) / float(len(t_set|h_set)) \n highestscore = 0\n\n for replacement in replacements:\n t_set = set(word for word in replacement[2]) - config.stop_list # replacement[1] = t_raw\n h_set = set(word for word in replacement[3]) - config.stop_list # replacement[2] = h_raw\n newScore = len(t_set & h_set) / float(len(t_set|h_set))\n if newScore > highestscore:\n highestscore = newScore\n return (score + highestscore) /2","def word_average_list(self, docs):\n return np.vstack([self.word_average(sent) for sent in docs])","def word_average_list(self, docs):\n return np.vstack([self.word_average(sent) for sent in docs])","def mean(self, words: [str]) -> numpy.ndarray:\n vecs = numpy.array([self[word] for word in words])\n return numpy.mean(vecs, axis=0)","def genre_average(genre_vectors):\n array = [vector for vector in genre_vectors]\n return np.average(array, axis=0)","def AraVec(striped_text: [str], embedding_dimension=100) -> [[int]]:\n\n count_unknown = 0\n words_index = 0\n\n if embedding_dimension == 100:\n if Embedding.t_model == None:\n Embedding.t_model = gensim.models.Word2Vec.load(\n '\\\\'.join([Embedding.project_working_dir, 'models', 'AraVec', 'full_uni_sg_100_wiki.mdl']))\n\n if embedding_dimension == 300:\n if Embedding.t_model == None:\n Embedding.t_model = gensim.models.Word2Vec.load(\n '\\\\'.join([Embedding.project_working_dir, 'models', 'AraVec', 'full_uni_sg_300_wiki.mdl']))\n\n embedded_book_array = np.empty(shape=[len(striped_text), embedding_dimension])\n\n for word in striped_text:\n try:\n embedded_book_array[words_index] = Embedding.t_model.wv[word]\n words_index += 1\n except KeyError:\n # taking words that appear with the litter and in arabic\n # the and litter is removed from the word and then check if it appears in the dictionary\n if str(word)[0] == 'و':\n try:\n embedded_book_array[words_index] = Embedding.t_model.wv[word]\n words_index += 1\n except KeyError:\n # print(word)\n count_unknown += 1\n else:\n # print(word)\n count_unknown += 1\n\n print(\"Total unknown words {0}/{1}, witch is {2}%.\".format(count_unknown,\n len(striped_text),\n int((count_unknown / len(striped_text) * 100))))\n\n return embedded_book_array[0:words_index]","def get_average_vec(tokens_list, vector, generate_missing=False, k=300):\r\n if len(tokens_list)<1:\r\n return np.zeros(k)\r\n \r\n if generate_missing:\r\n vectorized = [vector[word] if word in vector else np.random.rand(k) for word in tokens_list]\r\n else:\r\n vectorized = [vector[word] if word in vector else np.zeros(k) for word in tokens_list]\r\n \r\n length = len(vectorized)\r\n summed = np.sum(vectorized, axis=0)\r\n averaged = np.divide(summed, length)\r\n return averaged","def similarity(self, word1, word2):\n common_vect = +np.ones(self.nEmbed) * 10000\n if word1 not in self.vocab and word2 in self.vocab:\n id_word_2 = self.w2id[word2]\n w1 = common_vect\n w2 = self.U[id_word_2]\n elif word1 in self.vocab and word2 not in self.vocab:\n id_word_1 = self.w2id[word1]\n w1 = self.U[id_word_1]\n w2 = common_vect\n elif word1 not in self.vocab and word2 not in self.vocab:\n w1 = common_vect\n w2 = common_vect\n else:\n id_word_1 = self.w2id[word1]\n id_word_2 = self.w2id[word2]\n w1 = self.U[id_word_1]\n w2 = self.U[id_word_2]\n\n # scalair = w1.dot(w2)/np.linalg.norm(w1,w2)\n similarity = w1.dot(w2) / (np.linalg.norm(w1) * np.linalg.norm(w2))\n # similarity = 1 / (1 + np.exp(-scalair))\n # similarity = scalair / (np.linalg.norm(w1) * np.linalg.norm(w2))\n return similarity","def generate_avg_vector(self, data):\r\n doc=nlp(data)\r\n data_vector = [token.vector for token in doc]\r\n mean_vector = np.mean(data_vector, axis=0)\r\n return mean_vector","def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\r\n input_string_x1=input_string_x1.decode(\"utf-8\")\r\n input_string_x2 = input_string_x2.decode(\"utf-8\")\r\n #1. get blue score vector\r\n feature_list=[]\r\n #get blue score with n-gram\r\n for i in range(n_gram):\r\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\r\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\r\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\r\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\r\n feature_list.append(blue_score_i_1)\r\n feature_list.append(blue_score_i_2)\r\n\r\n #2. get length of questions, difference of length\r\n length1=float(len(input_string_x1))\r\n length2=float(len(input_string_x2))\r\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\r\n feature_list.append(length_diff)\r\n\r\n #3. how many words are same, how many words are unique\r\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\r\n feature_list.extend(sentence_diff_overlap_features_list)\r\n\r\n #4. question 1,2 start with how/why/when\r\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\r\n #print(\"how_why_feature_list:\",how_why_feature_list)\r\n #feature_list.extend(how_why_feature_list)\r\n\r\n #5.edit distance\r\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\r\n feature_list.append(edit_distance)\r\n\r\n #6.cos distance from sentence embedding\r\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\r\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\r\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\r\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\r\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\r\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\r\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\r\n feature_list.extend(distance_list_fasttext)\r\n feature_list.extend(distance_list_word2vec)\r\n #feature_list.extend(list(sentence_diffence))\r\n #feature_list.extend(list(sentence_multiply))\r\n return feature_list","def word_intersection() -> list:\r\n\r\n def count_words(title_pair: np.array) -> float:\r\n \"\"\"Function calculates number of unique words present\r\n in both titles and ratio of that number to the union of unique words.\r\n :param title_pair: Array containing two titles\r\n :return: Ratio of intersecting words to union of unique words\r\n \"\"\"\r\n title_1, title_2 = title_pair\r\n # Transform into sets of words\r\n title_1 = set(title_1.split())\r\n title_2 = set(title_2.split())\r\n # Divide length of intersection by length of union\r\n ratio = len(title_1.intersection(title_2)) / len(title_1.union(title_2))\r\n return ratio\r\n\r\n # Find titles for each pair in the current chunk by their indexes\r\n tmp_df = pd.DataFrame()\r\n tmp_df['title_1'] = data.loc[pairs.loc[:, 'idx_1'].values, 'title'].values\r\n tmp_df['title_2'] = data.loc[pairs.loc[:, 'idx_2'].values, 'title'].values\r\n\r\n # Process title pairs in current chunk and add results to the list\r\n scores = [result for result in map(count_words, tmp_df[['title_1', 'title_2']].values)]\r\n\r\n return scores","def sentence_similarity_asym(sentence1, sentence2):\n # Tokenize and tag\n sentence1 = pos_tag(word_tokenize(sentence1))\n sentence2 = pos_tag(word_tokenize(sentence2))\n \n # Get the synsets for the tagged words\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n \n # Filter out the Nones\n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n \n score, count = 0.0, 0\n\n # For each word in the first sentence\n for synset in synsets1:\n # Get the similarity value of the most similar word in the other sentence\n pathsim = [synset.path_similarity(ss) for ss in synsets2]\n if len(pathsim) == 0:\n #print sentence1, sentence2\n pathsim = [0]\n best_score = max(pathsim)\n \n # Check that the similarity could have been computed\n if best_score is not None:\n score += best_score\n count += 1\n\n if count == 0:\n return 0\n # Average the values\n score /= count\n return score","def bag_of_words(tokenized_sentence, all_words):\n\n tokenized_sentence = [stem(w) for w in tokenized_sentence]\n #print(tokenized_sentence)\n bag = np.zeros_like(all_words, dtype=np.float32)\n for idx, w in enumerate(all_words):\n if w in tokenized_sentence:\n bag[idx] = 1.0\n\n return bag","def _compute_span_pair_embeddings(self,\n top_span_embeddings: torch.FloatTensor,\n antecedent_embeddings: torch.FloatTensor,\n genre_embedding: torch.FloatTensor,\n trigger_same_type_agreement_embeddings: torch.FloatTensor,\n realies_same_type_agreement_embeddings: torch.FloatTensor,\n antecedent_offsets: torch.FloatTensor):\n\n # Shape: (1, max_antecedents, embedding_size)\n antecedent_distance_embeddings = self._distance_embedding(\n util.bucket_values(antecedent_offsets,\n num_total_buckets=self._num_distance_buckets))\n\n # Shape: (1, 1, max_antecedents, embedding_size)\n antecedent_distance_embeddings = antecedent_distance_embeddings.unsqueeze(0)\n\n expanded_distance_embeddings_shape = (antecedent_embeddings.size(0), # batch_size\n antecedent_embeddings.size(1), # num_spans_to_keep\n antecedent_embeddings.size(2), # max_antecedents\n antecedent_distance_embeddings.size(-1)) # embedding_size\n # Shape: (batch_size, num_spans_to_keep, max_antecedents, embedding_size)\n antecedent_distance_embeddings = antecedent_distance_embeddings.expand(*expanded_distance_embeddings_shape)\n antecedent_genre_embeddings = genre_embedding.view(1, 1, 1, -1).expand_as(antecedent_distance_embeddings)\n feature_embeddings = self._dropout(torch.cat(\n [antecedent_genre_embeddings, realies_same_type_agreement_embeddings, trigger_same_type_agreement_embeddings],-1))\n # ], -1))\n\n # [antecedent_distance_embeddings, antecedent_genre_embeddings, trigger_same_type_agreement_embeddings,\n # realies_same_type_agreement_embeddings], -1))\n # feature_embeddings = self._dropout(torch.cat(\n # [antecedent_genre_embeddings, trigger_same_type_agreement_embeddings], -1\n # ))\n\n # Shape: (batch_size, num_spans_to_keep, max_antecedents, embedding_size)\n target_embeddings = top_span_embeddings.unsqueeze(2).expand_as(antecedent_embeddings)\n # Shape: (batch_size, num_spans_to_keep, max_antecedents, embedding_size)\n span_pair_embeddings = torch.cat([target_embeddings,\n antecedent_embeddings,\n antecedent_embeddings * target_embeddings,\n feature_embeddings], -1)\n return span_pair_embeddings","def _add_pre_trained_embedding(self):\n\n if self.embedding_type['type'] == 'glove':\n self.logging.info('use pre-trained glove word2vec')\n # a. load pre trained glove\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\n import os\n import numpy as np\n\n embeddings_index = {}\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\n for line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\n f.close()\n\n self.logging.info('')\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\n\n # b. compute embedding matrix\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n\n elif self.embedding_type['type'] == 'gensim':\n self.logging.info('use pre-trained gensim word2vec')\n\n import gzip\n import gensim\n from keras.layers import Embedding\n import numpy as np\n\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\n\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\n pretrained_weights = model.wv.syn0\n vocab_size, vector_dim = pretrained_weights.shape\n\n method = 3\n if method == 1:\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\n # into our TensorFlow and Keras models\n\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\n for i in range(len(model.wv.vocab)):\n embedding_vector = model.wv[model.wv.index2word[i]]\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\n output_dim=embedding_matrix.shape[1],\n # input_length=self.maxlen,\n weights=[embedding_matrix],\n trainable=False)\n elif method == 2:\n self.logging.info('word2vec simple embedding matching - simple complex')\n embedding_layer = Embedding(input_dim=vocab_size,\n output_dim=vector_dim,\n input_length=self.maxlen,\n weights=[pretrained_weights],\n trainable=False)\n elif method == 3:\n\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\n # b. compute embedding matrix\n\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\n\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\n cnt = 0\n for word, i in self.word_index.items():\n if word in model.wv:\n embedding_vector = model.wv[word]\n embedding_matrix[i] = embedding_vector\n else:\n # self.logging.info('token in train missing in word2vec: ' + str(word))\n cnt += 1\n self.logging.info('total tokens missing: ' + str(cnt))\n\n\n # c. build embedding layer\n from keras.layers import Embedding\n embedding_layer = Embedding(len(self.word_index) + 1,\n self.embedding_size,\n weights=[embedding_matrix],\n input_length=self.maxlen,\n trainable=False)\n else:\n raise ValueError('unknown method value')\n\n else:\n raise ValueError('unknown embedding type')\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\n return embedding_layer","def wordNet_similarity(sentence1, sentence2):\r\n # Tokenize and tag\r\n \r\n # sentence1 = pos_tag(word_tokenize(sentence1))\r\n sentence1=st_tagger.tag(word_tokenize(sentence1))\r\n \r\n # sentence2 = pos_tag(word_tokenize(sentence2))\r\n sentence2=st_tagger.tag(word_tokenize(sentence2))\r\n\r\n \r\n # Get the synsets for the tagged words\r\n #################################################\r\n\r\n # synsets1=[]\r\n # synsets2=[]\r\n # for tagged_word in sentence1:\r\n # print(tagged_word)\r\n # tagged_word = list(tagged_word)\r\n # synsets1.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\r\n # for tagged_word in sentence2:\r\n # print(tagged_word)\r\n # tagged_word = list(tagged_word)\r\n # print(tagged_word)\r\n # synsets2.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\r\n\r\n # The code above is the elaboration of code below\r\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\r\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\r\n \r\n # Filter out the Nones in the synonym set\r\n synsets1 = [ss for ss in synsets1 if ss]\r\n synsets2 = [ss for ss in synsets2 if ss]\r\n \r\n score, count = 0.0, 0\r\n \r\n###########################################################################\r\n # for syn1 in synsets1:\r\n # arr_simi_score = []\r\n # print('=========================================')\r\n # print(syn1)\r\n # print('----------------')\r\n # for syn2 in synsets2:\r\n # print(syn2)\r\n # simi_score = syn1.path_similarity(syn2)\r\n # print(simi_score)\r\n # if simi_score is not None:\r\n # arr_simi_score.append(simi_score)\r\n # print('----------------')\r\n # print(arr_simi_score)\r\n # if(len(arr_simi_score) > 0):\r\n # best = max(arr_simi_score)\r\n # print(best)\r\n # score += best\r\n # count += 1\r\n # # Average the values\r\n # print('score: ', score)\r\n # print('count: ', count)\r\n # score /= count\r\n\r\n###########################################################################\r\n\r\n for syn1 in synsets1:\r\n arr_simi_score = []\r\n # print('=========================================')\r\n print(\"Each word from Synonym se1\",syn1)\r\n # print('----------------')\r\n for syn2 in synsets2:\r\n print(\"Each word from Synonym se2\",syn2)\r\n # simi_score = syn1.path_similarity(syn2)\r\n simi_score = syn1.wup_similarity(syn2)\r\n print(\"word to word path_similarity score\",simi_score)\r\n if simi_score is not None:\r\n arr_simi_score.append(simi_score)\r\n print('----------------')\r\n print(arr_simi_score)\r\n if(len(arr_simi_score) > 0):\r\n best = max(arr_simi_score)\r\n print(\"best score so far\", best)\r\n score += best\r\n count += 1\r\n # Average the values\r\n print('score: ', score)\r\n print('count: ', count)\r\n if count!=0:\r\n score /= count\r\n else:\r\n score=0.0\r\n return score","def word_order_similarity(self,sentence_1, sentence_2):\n\t words_1 = sentence_1.getList_of_words()\n\t words_2 = sentence_2.getList_of_words()\n\t joint_words = list(set(words_1).union(set(words_2)))\n\t windex = {x[1]: x[0] for x in enumerate(joint_words)}\n\t r1 = self.word_order_vector(words_1, joint_words, windex)\n\t r2 = self.word_order_vector(words_2, joint_words, windex)\n\t return 1.0 - (np.linalg.norm(r1 - r2) / np.linalg.norm(r1 + r2))","def get_phrase_embedding(phrase):\r\n \r\n vector = np.zeros([model.vector_size], dtype='float32')\r\n \r\n # 1. lowercase phrase\r\n phrase = phrase.lower()\r\n \r\n # 2. tokenize phrase\r\n phrase_tokens = tokenizer.tokenize(phrase)\r\n \r\n # 3. average word vectors for all words in tokenized phrase, skip words that are not in model's vocabulary\r\n divisor = 0\r\n for word in phrase_tokens:\r\n if word in model.vocab:\r\n divisor += 1\r\n vector = vector + model.get_vector(word)\r\n \r\n if divisor != 0: vector /= divisor\r\n \r\n return vector","def embedding_train(total_corpus,emoteonly_corpus,textonly_corpus,save_fname_emote,save_fname_text,save_fname_intersect):\n wv_model = Word2Vec(min_count=100,size=100,negative=0.75,sg=0,hs=1,window=60)\n wv_model.build_vocab(sentences=total_corpus())\n wv_model2 = copy.deepcopy(wv_model)\n \n # train emoteonly\n wv_model.train(sentences=emoteonly_corpus(),epochs=10,total_examples=wv_model.corpus_count)\n wv_model.save(save_fname_emote)\n # train_textonly\n wv_model2.train(sentences=textonly_corpus(),epochs=10,total_examples=wv_model.corpus_count)\n wv_model2.save(save_fname_text)\n \n src_model = Word2Vec.load(save_fname_emote)\n dest_model = Word2Vec.load(save_fname_text)\n \n src_model.wv.save_word2vec_format(save_fname_intersect)\n dest_model.intersect_word2vec_format(save_fname_intersect, lockf=1.0, binary=False)\n\n dest_model.train(sentences=train_corpus(), total_examples=dest_model.corpus_count, epochs=20)\n dest_model.save(save_fname_intersect)\n return","def vectorize(sentence, embeddings, size_limit, ignore_case=False):\n if ignore_case:\n sentence = sentence.lower()\n tokens = [w for w in sentence.strip().split() if w not in PUNCT]\n tokens = tokens[:size_limit] # truncating sentence\n\n vectors = []\n for t in tokens:\n if t in embeddings:\n vectors.append(embeddings[t])\n else: # OOV word\n random_vector = np.random.uniform(-0.25, 0.25,\n size=embeddings.dimension)\n vectors.append(random_vector)\n vectorized = np.array(vectors).T # dimension lines x len(tokens) columns\n return vectorized","def _get_emb(self, w2v):\n toks = tokenizer(self.opn.lower()) + tokenizer(self.asp.lower())\n self.is_valid = len(toks) > 0\n if not self.is_valid:\n return None\n embs = torch.stack([self._get_tok_emb(tok, w2v) for tok in toks], dim=0)\n return torch.mean(embs, dim=0)","def vectorize_tweet(tweet):\n tweet_vector = np.zeros(100)\n for word in tokenize(tweet.text):\n if word in word2vec.wv.vocab:\n tweet_vector = tweet_vector + word2vec[word]\n\n components = pca.transform(tweet_vector)\n x = components[0, 0]\n y = components[0, 1]\n\n return str(x), str(y)","def compute_paraphrase_vector(w1, w2, paraphrase, model, word2index, UNK):\n paraphrase = paraphrase.replace(w1, '[w1]').replace(w2, '[w2]')\n par_indices = tuple([word2index.get(w, UNK) for w in paraphrase.split()])\n return model.__compute_state__(par_indices, -1).npvalue()","def merge_vocabs(vocabs, min_freq=0, vocab_size=None):\n merged = Counter()\n for vocab in vocabs:\n merged += filter_counter(vocab.freqs, min_freq)\n return torchtext.vocab.Vocab(merged,\n specials=list(special_token_list),\n max_size=vocab_size, min_freq=min_freq)","def embed(self, loader, model):\n print(\" ** Embedding words\")\n\n words = loader.words\n vectors = [model.get_word_vector(word) for word in words]\n\n return [(w, *v) for w, v in zip(words, vectors)]","def average_reviews_similarity(user1, user2):\n similarities = []\n for u1_reviews in user1.values():\n for u2_reviews in user2.values():\n for u1_review in u1_reviews:\n for u2_review in u2_reviews:\n review_similarity = similarity(u1_review['text'], u2_review['text'])\n similarities.append(review_similarity)\n average = sum(similarities, 0.0) / len(similarities)\n return average","def generate_similar_sentences(sentence,w2v,percentage_to_replace=1,max_syn=10,num_outputs=50):\n\n list_of_sentences = []\n\n words = pairwise_tokenize(sentence,w2v,remove_stopwords=False) #This has combined any compound words found in word2vec\n\n #if word contains underscore don't sub in synonyms\n dont_sub_idx = []\n compound_word_idx = []\n deleted_idx = []\n for idx,word in enumerate(words):\n if \"_\" in word or word in stopwords.words('english'):\n dont_sub_idx.append(idx)\n if \"_\" in word:\n compound_word_idx.append(idx)\n deleted_idx.append(idx+1)\n if not word:\n dont_sub_idx.append(idx)\n\n pattern = re.compile('[\\W_]+') \n sentence = pattern.sub(\" \",sentence).lower().strip()\n tagged = pos_tag(sentence.split(\" \")) #Pos_tag needs to use the original sentence to tag parts of speech, we will now delete indices that correspond to words that no longer exist b/c of compound\n \n for idx in reversed(compound_word_idx):\n tagged.pop(idx+1)\n \n for tag in tagged:\n if tag[1] == 'NNP':\n dont_sub_idx.append(idx)\n \n for i in xrange(num_outputs):\n new_words = words\n mask = np.random.random_sample(len(words))\n for j in xrange(len(words)):\n if mask[j] < .5 and j not in dont_sub_idx:\n pos = wordnet_pos_code(tagged[j][1])\n synonyms = get_synonyms(words[j],w2v,pos,max=max_syn)\n if len(synonyms) != 0:\n new_words[j] = synonyms[np.random.randint(0,min(max_syn,len(synonyms)))]\n list_of_sentences.append(\" \".join(new_words))\n\n list_of_sentences = set(list_of_sentences)\n return list(list_of_sentences)","def _compute_span_pair_embeddings(top_span_embeddings: torch.FloatTensor):\n # Shape: (batch_size, num_spans_to_keep, num_spans_to_keep, embedding_size)\n num_candidates = top_span_embeddings.size(1)\n\n embeddings_1_expanded = top_span_embeddings.unsqueeze(2)\n embeddings_1_tiled = embeddings_1_expanded.repeat(1, 1, num_candidates, 1)\n\n embeddings_2_expanded = top_span_embeddings.unsqueeze(1)\n embeddings_2_tiled = embeddings_2_expanded.repeat(1, num_candidates, 1, 1)\n\n similarity_embeddings = embeddings_1_expanded * embeddings_2_expanded\n\n pair_embeddings_list = [embeddings_1_tiled, embeddings_2_tiled, similarity_embeddings]\n pair_embeddings = torch.cat(pair_embeddings_list, dim=3)\n\n return pair_embeddings","def vectorize_text(text):\n\n def remove_punctuation(text):\n \"\"\"Removes special characters from text.\"\"\"\n return re.sub('[,.?\";:\\-!@#$%^&*()]', '', text)\n\n def remove_common_words(text_vector):\n \"\"\"Removes 50 most common words in the uk english.\n\n source: http://www.bckelk.ukfsn.org/words/uk1000n.html\n\n \"\"\"\n common_words = set(['the', 'and', 'to', 'of', 'a', 'I', 'in', 'was',\n 'he', 'that', 'it', 'his', 'her', 'you', 'as', 'had', 'with',\n 'for', 'she', 'not', 'at', 'but', 'be', 'my', 'on', 'have', 'him',\n 'is', 'said', 'me', 'which', 'by', 'so', 'this', 'all', 'from',\n 'they', 'no', 'were', 'if', 'would', 'or', 'when', 'what', 'there',\n 'been', 'one', 'could', 'very', 'an', 'who'])\n return [word for word in text_vector if word not in common_words]\n\n text = text.lower()\n text = remove_punctuation(text)\n words_list = text.split()\n words_list = remove_common_words(words_list)\n\n return words_list","def get_wordpiece_embeddings(og_index, tt, token_embeddings):\n still_oov = True\n index = og_index + 1\n while still_oov:\n token = tt[index]\n if \"##\" not in token:\n break\n index += 1\n # Final set of embeddings\n emb = token_embeddings[og_index:index]\n # return mean across each token (should be (NUM_LAYER, NUM_UNITS) matrix)\n return emb.mean(dim = 0)","def getGloveoCosineSimilarity(question1, question2):\n questions = [question1, question2]\n\n ## for the sentences we need to get the count vectors\n vec = CountVectorizer(max_features=5000, stop_words=None,binary=True)\n count_vectors = vec.fit_transform(questions)\n\n ## get the vocabulary of words from the questions\n vocab_index = vec.vocabulary_\n\n ## get the index of the words and embeddings\n index_word = {v:k for k, v in vocab_index.items()}\n\n ## get the question vectors\n question_vectors = np.zeros((count_vectors.shape[0], 300))\n\n ## iterate through count vectors for each word get the embeddings\n ## for each embedding, we will then average by the number of words\n ## this will be then used for cosine similarity\n for i in range(count_vectors.shape[0]):\n row = count_vectors[i, :].toarray()\n word_ids = np.where(row > 0)[1]\n word_counts = row[:, word_ids][0]\n numWords = np.sum(word_counts)\n\n ## if there are no words, continue\n if numWords == 0:\n continue\n\n ## initialize the word embeddings to 0\n word_embeddings = np.zeros((word_ids.shape[0], 300))\n\n ## update the word embeddings\n for j in range(word_ids.shape[0]):\n word_id = word_ids[j]\n word_embeddings[j, :] = word_counts[j] * gloveDict[index_word[word_id]]\n question_vectors[i, :] = np.sum(word_embeddings, axis=0) / numWords\n\n return(cosine_similarity(question_vectors[0], question_vectors[1])[0][0])","def count_words_and_dublicates(novel):","def gen_embedding(text, model, tokenizer):\n ### Tokenize the texts\n encoded_input = tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors='pt')\n \n ### Encode the tokenized data with model\n with torch.no_grad():\n model_output = model(**encoded_input)\n \n ### Pool the outputs into a single vector\n sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])\n return sentence_embeddings","def align_vocabs(emb_model, tokenizer):\n hi_emb = emb_model['hi']\n logger.info(hi_emb.shape)\n total_unk = 0\n nmax = max(tokenizer.vocab.idx2word.keys()) + 1\n word_matrix = torch.zeros(nmax, hi_emb.shape[-1])\n logger.info(word_matrix.shape)\n\n for k, v in tqdm(tokenizer.vocab.idx2word.items(), total=len(tokenizer)):\n try:\n word_matrix[k] = torch.tensor(emb_model[v])\n except KeyError:\n word_matrix[k] = emb_model['<unk>']\n total_unk += 1\n return word_matrix, total_unk","def get_word_containement_measure(self,l2,l1):\n count = 0\n found_idfs = []\n unfound_idfs = []\n word_count_dict = self.list_to_word_count_dict(l1)\n for w in l2:\n was_found = False\n val = self.idf.get_tfidf_val(w)\n if (val > 10):\n val = 10\n for i,w2 in enumerate(l1):\n if (w2 == w and word_count_dict[(w2,i)] == 0):\n word_count_dict[(w2,i)] = 1\n count += 1\n found_idfs.append(val)\n was_found = True\n break\n if (was_found):\n unfound_idfs.append(val)\n if (len(found_idfs) == 0):\n avg_found = 0\n else:\n avg_found = np.mean(found_idfs)\n if (len(unfound_idfs) ==0):\n avg_unfound = 0\n else:\n avg_unfound = np.mean(unfound_idfs)\n\n # full idf features\n unfound_vec = list(sorted(unfound_idfs, reverse=True))\n found_vec = list(sorted(found_idfs, reverse=True))\n unfound_vec = self.pad_or_cut_vec(unfound_vec, self.LENGTH_MAX)\n found_vec = self.pad_or_cut_vec(found_vec, self.LENGTH_MAX)\n\n return count , avg_found, avg_unfound, found_vec, unfound_vec","def word_overlap_phi(t1, t2):\n overlap = set([w1 for w1 in t1.leaves() if w1 in t2.leaves()])\n return Counter(overlap)","def _merge_main_context(self, W, merge_fun=lambda m, c: np.mean([m, c], axis=0),\n normalize=True):\n\n vocab_size = int(len(W) / 2)\n for i, row in enumerate(W[:vocab_size]):\n merged = merge_fun(row, W[i + vocab_size])\n if normalize:\n merged /= np.linalg.norm(merged)\n W[i, :] = merged\n\n return W[:vocab_size]","def naiveBayes(self, vector):\n \n # Find product of all Unigram and Bigram probabilities, which are already converted to log probabilities\n value = 0 \n for word1 in vector.words.iterkeys():\n unigram, unigramExists = self.getUnigram(word1)\n if unigramExists:\n value += self.words[word1].probability\n else:\n # Use add one smoothing for unseen events, P(unseen) = 1 / (numSeenInstances + sizeVocab) \n value += math.log(1 / (self.numTokens + len(self.words)), 2)\n for word2 in vector.words[word1].bigrams.iterkeys():\n bigram, bigramExists = self.getBigram(word1, word2) \n if bigramExists:\n value += self.words[word1].bigrams[word2].probability\n else:\n # Use add one smoothing for unseen events, P(unseen) = 1 / (numSeenInstances + sizeVocab)\n count = 0 \n if word1 in self.words:\n count = self.words[word1].count \n else:\n count = 1 \n value += math.log(1 / (count + len(self.words)), 2)\n \n return value","def split(self, mapping, ignore_exact=True):\n\n source_oov = defaultdict(lambda: 0)\n target_oov = defaultdict(lambda: 0)\n w_exact = defaultdict(lambda: 0)\n\n source_words = []\n target_words = []\n map_ = mapping.map\n for w, id_ in self.word_id.iteritems():\n if w not in map_:\n source_oov[w] += 1\n continue\n\n if map_[w] not in self.word_id:\n target_oov[map_[w]] += 1\n continue\n\n if w.lower() == map_[w].lower():\n w_exact[w] += 1\n if ignore_exact:\n continue\n\n source_words.append(w)\n target_words.append(map_[w])\n\n logging.debug(\"We could not find {} source words in our dictionary.\".format(\n len(source_oov)))\n logging.debug(\"We could not find {} target words in our target words.\".format(\n len(target_oov)))\n logging.debug(\"{} words are exact between languages\".format(len(w_exact)))\n logging.debug(\"We found {} pairs of words valid for testing.\".format(len(source_words)))\n\n new_s_vectors = asarray([self.vectors[self.word_id[w]] for w in source_words])\n source = Embeddings(vectors=new_s_vectors, words=source_words,\n lang=mapping.s_lang)\n\n new_t_vectors = asarray([self.vectors[self.word_id[w]] for w in target_words])\n target = Embeddings(vectors=new_t_vectors, words=target_words,\n lang=mapping.t_lang)\n new_mapping = Mapping(source=mapping.s_lang, target=mapping.t_lang)\n new_mapping.map = dict(zip(source.words, target.words))\n return (source, target, new_mapping)","def distance_unigrams_same(t1, t2):\n t1_terms = make_terms_from_string(t1)\n t2_terms = make_terms_from_string(t2)\n terms1 = set(t1_terms)\n terms2 = set(t2_terms)\n shared_terms = terms1.intersection(terms2)\n #print(shared_terms)\n all_terms = terms1.union(terms2)\n #print(all_terms)\n dist = 1.0 - (len(shared_terms) / float(len(all_terms)))\n return dist","def question_to_vec(question, embeddings, dim):\r\n\r\n words = question.split()\r\n\r\n counter = 0\r\n res = np.zeros(dim)\r\n for word in words:\r\n if word in embeddings:\r\n res += np.array(embeddings[word])\r\n counter += 1\r\n if counter!=0:\r\n return res/counter # mean of all word embeddings\r\n else:\r\n return res # vector of zeros\r","def processFeature(prevWord, word, vector):\n \n # We add feature whether it exists or not\n unigram, exists = vector.getUnigram(prevWord)\n if not exists:\n vector.addUnigram(prevWord)\n \n \n bigram, exists = vector.getBigram(prevWord, word)\n if not exists:\n vector.addBigram(prevWord, word)","def embedding_similarity(model, validation_pairs):\n scores = dict()\n for pair in validation_pairs:\n author1 = pair[0]\n author2 = pair[1]\n scores[author1 + ' ' +\n author2] = cosine_similarity(model.wv[author1], model.wv[author2])\n return scores","def vectorize_sentence(sentence, model):\n final_vec = np.zeros(300, )\n count = 0\n for word in sentence:\n count += 1\n dummy_vec = np.zeros(300, )\n try:\n temp_vec = get_vector(word, model)\n final_vec += temp_vec\n except:\n final_vec += dummy_vec\n return final_vec / count","def object_similarity(obj_1, obj_2):\n w_list = []\n obj_1_bag_size = sum(obj_1['bag_of_words'].values())\n obj_2_bag_size = sum(obj_2['bag_of_words'].values())\n obj_1_set = obj_1['set_of_words']\n obj_2_set = obj_2['set_of_words']\n obj_1_diff_2_set = obj_1_set - obj_2_set\n obj_2_diff_1_set = obj_2_set - obj_1_set\n w_list.append(weight_calculator(obj_1_bag_size, obj_2_bag_size))\n w_list.append(weight_calculator(len(obj_1_set), len(obj_2_set)))\n w_list.append(weight_calculator(len(obj_1_diff_2_set),\n len(obj_2_diff_1_set)))\n if 'total_lines' in obj_1.keys() and 'total_lines' in obj_2.keys():\n w_list.append(weight_calculator(obj_1['total_lines'],\n obj_2['total_lines']))\n if 'total_conversations' in obj_1.keys() and 'total_conversations' in obj_2.keys():\n w_list.append(weight_calculator(obj_1['total_conversations'],\n obj_2['total_conversations']))\n # Added as observations of genre -> rating relations\n if 'metadata' in obj_1.keys() and 'metadata' in obj_2.keys():\n w_list.append(weight_calculator(eval(obj_1['metadata']['genres']),\n eval(obj_2['metadata']['genres'])))\n return mean(w_list)","def common(self, other):\n\n common_words = []\n for word in self.word_id:\n if word in other.word_id:\n common_words.append(word)\n\n new_self_vectors = []\n new_other_vectors = []\n for word in common_words:\n new_self_vectors.append(self.vectors[self.word_id[word]])\n new_other_vectors.append(other.vectors[other.word_id[word]])\n\n new_self = Embeddings(vectors=asarray(new_self_vectors), words=common_words,\n lang=self.lang)\n\n new_other = Embeddings(vectors=asarray(new_other_vectors), words=common_words,\n lang=self.lang)\n\n return (new_self, new_other)","def weighted_overlap(topic_nasari_vector, paragraph_nasari_vector):\n #function to get item rank in nasari dictionary as key index+1\n item_rank = lambda item, nasari_dict: list(nasari_dict.keys()).index(item) + 1\n \n overlap_keys = list(topic_nasari_vector.keys() & paragraph_nasari_vector.keys())\n\n if len(overlap_keys) > 0:\n # sum 1/(rank() + rank())\n den = sum(1 / (item_rank(q, topic_nasari_vector) +\n item_rank(q, paragraph_nasari_vector)) for q in overlap_keys)\n # sum 1/(2*i), \n num = sum(list(\n map(lambda x: 1 / (2 * x),\n list(range(1, len(overlap_keys) + 1)))))\n return num/den\n return 0","def sentence_similarity(sentence1, sentence2):\n sentence1 = sentence1.tags\n sentence2 = sentence2.tags\n \n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n \n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n \n score, count = 0.0, 0\n \n for synset in synsets1:\n \n li=[synset.path_similarity(ss) for ss in synsets2]\n m=0\n for i in range(len(li)):\n if li[i] is not None and m<li[i]:\n m=li[i]\n if m != 0:\n score += m\n count += 1\n\n if count is 0:\n score = 0\n else:\n score /= count\n return score","def check_word_overlap(tag_1, tag_2):\n position_tracker = 0\n words_found = []\n for t1 in tag_1:\n for t2 in tag_2:\n if t1 == t2:\n words_found.append([t1,position_tracker])\n position_tracker+=1\n return [words_found, len(words_found)]","def omnibus_embedding_pairwise(\n graphs: List[NxGraphType],\n dimensions: int = 100,\n elbow_cut: Optional[int] = None,\n svd_solver_algorithm: SvdAlgorithmType = \"randomized\",\n svd_solver_iterations: int = 5,\n svd_seed: Optional[int] = None,\n weight_attribute: str = \"weight\",\n use_laplacian: bool = False,\n) -> List[Tuple[Embeddings, Embeddings]]:\n check_argument(len(graphs) > 1, \"more than one graph is required\")\n\n check_argument(dimensions >= 1, \"dimensions must be positive\")\n\n check_argument(elbow_cut is None or elbow_cut >= 1, \"elbow_cut must be positive\")\n\n check_argument(\n svd_solver_algorithm in __SVD_SOLVER_TYPES,\n f\"svd_solver_algorithm must be one of the values in {','.join(__SVD_SOLVER_TYPES)}\",\n )\n\n check_argument(svd_solver_iterations >= 1, \"svd_solver_iterations must be positive\")\n\n check_argument(\n svd_seed is None or 0 <= svd_seed <= 2**32 - 1,\n \"svd_seed must be a nonnegative, 32-bit integer\",\n )\n\n used_weight_attribute = _graphs_precondition_checks(graphs, weight_attribute)\n perform_augment_diagonal = not use_laplacian\n\n graph_embeddings = []\n\n # create a graph that contains all nodes and edges across the entire corpus\n union_graph = graphs[0].copy()\n for graph in graphs[1:]:\n union_graph.add_edges_from(graph.edges())\n\n union_graph_lcc: Union[\n nx.Graph, nx.Digraph, nx.OrderedGraph, nx.OrderedDiGraph\n ] = largest_connected_component(union_graph)\n union_graph_lcc_nodes: Set[Any] = set(list(union_graph_lcc.nodes()))\n\n union_node_ids = np.array(list(union_graph_lcc_nodes))\n\n previous_graph = graphs[0].copy()\n\n for graph in graphs[1:]:\n current_graph = graph.copy()\n\n # assure both graphs contain the exact same node set\n # by removing nodes or adding isolates as needed\n _sync_nodes(previous_graph, union_graph_lcc_nodes)\n _sync_nodes(current_graph, union_graph_lcc_nodes)\n\n # remove self loops, run pass to ranks and diagonal augmentation\n previous_graph_augmented = _augment_graph(\n previous_graph,\n union_graph_lcc_nodes,\n used_weight_attribute,\n perform_augment_diagonal=perform_augment_diagonal,\n )\n current_graph_augmented = _augment_graph(\n current_graph,\n union_graph_lcc_nodes,\n used_weight_attribute,\n perform_augment_diagonal=perform_augment_diagonal,\n )\n\n model = OmnibusEmbed(\n n_components=dimensions,\n n_elbows=None, # we will do elbow cuts\n algorithm=svd_solver_algorithm,\n n_iter=svd_solver_iterations,\n check_lcc=False,\n diag_aug=False,\n concat=False,\n svd_seed=svd_seed,\n lse=use_laplacian,\n )\n\n previous_embedding, current_embedding = model.fit_transform(\n graphs=[previous_graph_augmented, current_graph_augmented]\n )\n\n previous_embedding_cut = _elbow_cut_if_needed(\n elbow_cut, graph.is_directed(), model.singular_values_, previous_embedding\n )\n\n current_embedding_cut = _elbow_cut_if_needed(\n elbow_cut, graph.is_directed(), model.singular_values_, current_embedding\n )\n\n graph_embeddings.append(\n (\n Embeddings(union_node_ids, previous_embedding_cut),\n Embeddings(union_node_ids, current_embedding_cut),\n )\n )\n\n return graph_embeddings","def pairwise_tokenize(sentence,w2v,remove_stopwords=True):\n\n ignore_words = stopwords.words('english')\n\n #Remove non-alphanumeric\n pattern = re.compile('[\\W_]+') \n sentence = pattern.sub(\" \",sentence) \n sentence = sentence.strip()\n words = sentence.split(\" \")\n\n compound_word_idx = []\n a_idx = 0\n for a,b in pairwise(words):\n combined = a +\"_\" + b\n try:\n w2v[combined]\n compound_word_idx.append(a_idx) #append the index of the 1st compound word\n a_idx += 1\n except KeyError:\n a_idx += 1\n\n for idx in compound_word_idx:\n words[idx] = words[idx] + \"_\" + words[idx + 1] #compound_word_idx stores index of 1st word, so combine with the next word\n\n #This cannot be combined into another loop to maintain where indices point\n for idx in reversed(compound_word_idx):\n words.pop(idx+1)\n\n if remove_stopwords == True:\n filtered = []\n for word in words:\n word = word.decode(\"utf-8\")\n if word not in ignore_words:\n filtered.append(word)\n\n words = filtered\n\n return words"],"string":"[\n \"def word_averaging(wv, words):\\n all_words, mean = set(), []\\n \\n for word in words:\\n if isinstance(word, np.ndarray):\\n mean.append(word)\\n elif word in wv.vocab:\\n mean.append(wv.vectors_norm[wv.vocab[word].index])\\n all_words.add(wv.vocab[word].index)\\n\\n if not mean:\\n logging.warning(\\\"Cannot compute similarity with no input: %s\\\", words)\\n # Remove these examples in pre-processing...\\n return np.zeros(50,)\\n\\n mean = gensim.matutils.unitvec(np.array(mean).mean(axis=0)).astype(np.float32)\\n \\n return mean\",\n \"def sentence_to_avg(sentence, word_to_vec_map):\\n # Get a valid word contained in the word_to_vec_map. \\n any_word = list(word_to_vec_map.keys())[0]\\n \\n ### START CODE HERE ###\\n # Step 1: Split sentence into list of lower case words (≈ 1 line)\\n words = sentence.lower().split()\\n\\n # Initialize the average word vector, should have the same shape as your word vectors.\\n avg = np.zeros(word_to_vec_map[any_word].shape)\\n \\n # Initialize count to 0\\n count = 0\\n \\n # Step 2: average the word vectors. You can loop over the words in the list \\\"words\\\".\\n for w in words:\\n # Check that word exists in word_to_vec_map\\n if w in word_to_vec_map:\\n avg += word_to_vec_map[w]\\n # Increment count\\n count +=1\\n \\n if count > 0:\\n # Get the average. But only if count > 0\\n avg = avg / count\\n \\n ### END CODE HERE ###\\n \\n return avg\",\n \"def avg_sentence_vector(words, model, num_features, index2word_set):\\n featureVec = np.zeros((num_features,), dtype=\\\"float32\\\")\\n nwords = 0\\n\\n for word in words:\\n if word in index2word_set:\\n nwords = nwords+1\\n featureVec = np.add(featureVec, model.wv[word])\\n # featureVec = np.add(featureVec, model.wv.__getitem__(word))\\n\\n if nwords>0:\\n featureVec = np.divide(featureVec, nwords)\\n return featureVec\",\n \"def compute_avg_w2v_vector(w2v_dict, text_nlp_proc):\\n SIZE = 50 # size of the w2v dimension\\n list_of_word_vectors = [w2v_dict[w] for w in text_nlp_proc if w in w2v_dict.vocab.keys()]\\n if len(list_of_word_vectors) == 0:\\n result = [0.0]*SIZE\\n else:\\n result = np.sum(list_of_word_vectors, axis=0) / len(list_of_word_vectors)\\n return result\",\n \"def _merge_embeddings(self, hidden_states:List[List[float]], indices_subwords:List[List[int]]):\\n embed_output = []\\n # ignore the first and the last tokens which are respectively the [CLS] and [SEP] tokens\\n hidden_states = hidden_states[1:-1 ,:]\\n sentence_output = []\\n for indices_to_merge in indices_subwords:\\n # average the embeddings of the subwords of a word \\n sentence_output.append(torch.mean(hidden_states[indices_to_merge], axis=0))\\n embed_output.append(torch.stack(sentence_output).to(self.device))\\n return embed_output\",\n \"def get_sentence_average_w2v(sent, word_to_vec, embedding_dim):\\n sum_vec = np.zeros((embedding_dim,))\\n known_tokens = 0\\n for token in sent.text:\\n if (token in word_to_vec.dict):\\n known_tokens += 1\\n sum_vec += word_to_vec[token]\\n if (known_tokens != 0):\\n return sum_vec / known_tokens\\n else:\\n return sum_vec\",\n \"def _get_emb_avg(g, lang):\\n emb = np.zeros(emb_dims[lang])\\n known_words_count = 0\\n words = g.split()\\n for w in words:\\n if w in models[lang]:\\n emb += models[lang][w]\\n known_words_count += 1\\n emb /= len(words)\\n return emb, known_words_count > 0\",\n \"def _get_emb_wavg(g, lang, a=0.001):\\n emb = np.zeros(emb_dims[lang])\\n known_words_count = 0\\n words = g.split()\\n for w in words:\\n if w in models[lang]:\\n emb += a / (a + word_freqs[lang][w]) * models[lang][w]\\n known_words_count += 1\\n emb /= len(words)\\n return emb, known_words_count > 0\",\n \"def aggregate_embeddings(list_of_embeddings):\\n\\n return np.mean(list_of_embeddings, axis=0)\",\n \"def w2v_aggregation_letters(X, length_vector=100):\\n global w2v_model_3gram\\n if w2v_model_3gram == None:\\n w2v_model_3gram = gensim.models.KeyedVectors.load_word2vec_format(os.path.join(os.environ['NOBULL_PATH'], 'w2v_char.vec'))\\n X_raw = []\\n for x in X:\\n x_letter = cleanText_letters(x)\\n X_raw.append(x_letter)\\n\\n\\n num_row = len(X_raw)\\n\\n max_matrix = np.zeros(shape=(num_row, length_vector))\\n\\n average_matrix = np.zeros(shape=(num_row, length_vector))\\n\\n for row in range(num_row):\\n \\n temp_text = X_raw[row] \\n temp_vector = temp_text.split()\\n \\n unique_vector = list(set(temp_vector))\\n num_index = len(unique_vector)\\n \\n temp_matrix = np.zeros(shape=(num_index, length_vector))\\n \\n j = 0\\n for word in unique_vector:\\n \\n temp_matrix[j] = get_vector(word, w2v_model_3gram, 100)\\n j += 1\\n\\n max_matrix[row] = np.maximum.reduce(temp_matrix)\\n average_matrix[row] = np.mean(temp_matrix, axis=0)\\n \\n result = np.concatenate((average_matrix, max_matrix), axis=1)\\n result = sparse.csr_matrix(result)\\n \\n header = []\\n \\n for i in range(length_vector):\\n temp_string = \\\"neww2v_average_\\\" + str(i) + \\\"-th\\\"\\n header.append(temp_string)\\n \\n for i in range(length_vector):\\n temp_string = \\\"neww2v_maximum_\\\" + str(i) + \\\"-th\\\"\\n header.append(temp_string)\\n\\n return result, header\",\n \"def word_averaging_list(wv, text_list):\\n return np.vstack([word_averaging(wv, review) for review in text_list])\",\n \"def _get_mean_embedding(self, words):\\n\\n # ensure the size still matches if it's loaded from pretrained word vectors\\n size = self.size\\n if self.w2v is not None:\\n size = next(iter(self.w2v_.values())).size\\n\\n zero = np.zeros(size)\\n if self.tfidf:\\n embedding = np.mean([self.w2v_[w] * self.w2idf_[w]\\n if w in self.w2v_ else zero for w in words], axis = 0)\\n else:\\n embedding = np.mean([self.w2v_.get(w, zero) for w in words], axis = 0)\\n\\n return embedding\",\n \"def get_embeddings(vectors, text, generate_missing=False, k=300):\\r\\n embeddings = text.apply(lambda x: get_average_vec(x, vectors, generate_missing=generate_missing, k=k))\\r\\n return list(embeddings)\",\n \"def compute_user_input_embedding(txt, model):\\r\\n embeddings = []\\r\\n tokens = txt.split(\\\" \\\")\\r\\n for word in tokens:\\r\\n embeddings.append(model.wv[word])\\r\\n sentence_embedding = compute_average(embeddings)\\r\\n return sentence_embedding\",\n \"def analyze_embeddings(emb):\\n dic = {\\\"Hi\\\": 0, \\\"En\\\": 1, \\\"Ot\\\": 2}\\n count = [0, 0, 0, 0]\\n count_zero = [0, 0, 0, 0]\\n for i, j in zip(emb, corpus_trans):\\n for k, l in zip(i, j):\\n count[dic[l[1]]] += 1\\n if sum(k) == 0:\\n count_zero[dic[l[1]]] += 1\\n count[-1] = sum(count)\\n count_zero[-1] - sum(count_zero)\\n print(\\\"hi, en, ot, total\\\")\\n print(\\\"count: \\\", count)\\n print(\\\"zero count: \\\", count_zero)\",\n \"def average_word_vector(vectorfile, outvectorfile):\\n\\twith codecs.open(vectorfile, encoding='utf-8', mode='r') as infile:\\n\\t\\twith codecs.open(outvectorfile, encoding='utf-8', mode='a+') as outfile:\\n\\t\\t\\tfor i, line in enumerate(infile):\\n\\t\\t\\t\\tprint i\\n\\t\\t\\t\\tif i == 0:\\n\\t\\t\\t\\t\\ta, b, c = map(int, line.split()[:3])\\n\\t\\t\\t\\t\\tprint('Number of sememes: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t 'Number of words: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t 'Dimension of vectors: {}'.format(a, b, c))\\n\\t\\t\\t\\t\\toutfile.write(str(b) + ' ' + str(c) + '\\\\n')\\n\\t\\t\\t\\telif i > 462667:\\n\\t\\t\\t\\t\\toutfile.write(line)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tsline = line.split()\\n\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\tsense_num = int(sline[1])\\n\\t\\t\\t\\t\\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\\n\\t\\t\\t\\t\\t# extra = len(vectors) % sense_num\\n\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\tfor start in range(0, len(vectors), c):\\n\\t\\t\\t\\t\\t\\tvector_list.append(list(map(float, vectors[start: start+c])))\\n\\t\\t\\t\\t\\t# print vector_list\\n\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\tvector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t# print np.array2string(vector_mean, max_line_width=200, formatter={'float_kind': lambda x: '%6f'%x})[1:-1].strip('\\\\n')\\n\\t\\t\\t\\t\\tnew_line = word + ' ' + np.array2string(vector_mean, max_line_width=2000, formatter={'float_kind': lambda x: '%6f'%x})[1:-1] + '\\\\n'\\n\\t\\t\\t\\t\\toutfile.write(new_line)\",\n \"def create_embedding_matrix(self):\\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\\n vocab_size = len(self.vocab)\\n result = np.zeros((vocab_size, self.embed_dim))\\n unknown_token_set = set()\\n\\n found_words = 0\\n avg = np.zeros(self.embed_dim)\\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\\n try:\\n result[_] = self.pretrained_embedding[self.id2word[_]]\\n avg += result[_]\\n found_words += 1\\n except:\\n unknown_token_set.add(_)\\n\\n avg /= found_words\\n for _ in unknown_token_set:\\n result[_] = avg\\n self.embedding = result\\n return found_words, len(self.id2word)\",\n \"def load_embeddings(emb_file, oovs=[], pads=[], sep=' ', lower=False, case_dim=True):\\n word2emb = {}\\n word2idx = {}\\n\\n # read and store all word vectors\\n for line in open(emb_file, errors = 'ignore', encoding = 'utf-8'):\\n try:\\n fields = line.strip().split(sep)\\n word = fields[0]\\n vec = np.asarray(fields[1:], dtype='float32')\\n if case_dim:\\n is_upper = float(word[0].isupper())\\n vec = np.insert(vec, 0, is_upper, axis=0)\\n if lower:\\n word = word.lower()\\n word2emb[word] = vec\\n if word not in word2idx:\\n word2idx[word] = len(word2idx)\\n except Exception as e:\\n print('[WARNING] Exception in `load_embeddings`:', e)\\n\\n # get dimensions from the last vector added\\n emb_dim = word2emb[word].shape[0]\\n\\n # add custom embeddings for special characters\\n mu = 0\\n sigma = 0.01\\n\\n for word in pads:\\n if word not in word2idx:\\n if case_dim:\\n vec = npr.normal(mu, sigma, emb_dim-1)\\n vec = np.insert(vec, 0, 0., axis=0)\\n else:\\n vec = npr.normal(mu, sigma, emb_dim)\\n word2emb[word] = vec\\n word2idx[word] = len(word2idx)\\n else:\\n print('[WARNING] Padding item ' + word + ' has an embedding vector')\\n\\n for word in oovs:\\n if word not in word2idx:\\n if case_dim:\\n vec = npr.normal(mu, sigma, emb_dim-1)\\n is_upper = float(word[0].isupper())\\n vec = np.insert(vec, 0, is_upper, axis=0)\\n else:\\n vec = npr.normal(mu, sigma, emb_dim)\\n word2emb[word] = vec\\n word2idx[word] = len(word2idx)\\n else:\\n print('[WARNING] OOV alias ' + word + ' has an embedding vector')\\n\\n # create an embedding matrix\\n vocab_size = len(word2emb)\\n emb_matrix = np.zeros((vocab_size, emb_dim))\\n for word, idx in word2idx.items():\\n if word in word2emb:\\n vec = word2emb[word]\\n if vec is not None and vec.shape[0] == emb_dim:\\n emb_matrix[idx] = np.asarray(vec)\\n\\n # print feedback data and return mappings\\n print('[INFO] Embedding vocabulary:', emb_matrix.shape[0], '(lowercase: ' + str(lower) + ')')\\n print('[INFO] OOV aliases:', oovs)\\n print('[INFO] Padding items:', pads)\\n print('[INFO] Embedding dimensions:', emb_dim, '(extra case dimension: ' + str(case_dim) + ')')\\n return word2idx, np.asarray(emb_matrix), emb_dim\",\n \"def get_review_embedding(review):\\n review_sentences = nltk_tokenize.sent_tokenize(review)\\n sentence_embeddings = list(map(get_sentence_embedding, review_sentences))\\n if len(sentence_embeddings) == 0:\\n print(\\\"Sentence_embeddings are empty!\\\")\\n print(review)\\n return torch.zeros(1,128)\\n if review_embedding_type == \\\"avg\\\":\\n # avg over all pairs [pairs, 1, 128] => [1, 128]\\n mean = torch.mean(torch.stack(sentence_embeddings), axis=0)\\n return mean\",\n \"def word_average(self, sent):\\n mean = []\\n for word in sent:\\n if word in self.word_model.wv.vocab:\\n mean.append(self.word_model.wv.get_vector(word))\\n\\n if not mean: # empty words\\n # If a text is empty, return a vector of zeros.\\n logging.warning(\\n \\\"cannot compute average owing to no vector for {}\\\".format(sent))\\n return np.zeros(self.vector_size)\\n else:\\n mean = np.array(mean).mean(axis=0)\\n return mean\",\n \"def smart_procrustes_align_gensim(base_embed, other_embed, words=None):\\n # make sure vocabulary and indices are aligned\\n in_base_embed, in_other_embed = intersection_align_gensim(base_embed, other_embed, words=words)\\n\\n # get the embedding matrices\\n base_vecs = in_base_embed.wv.syn0norm\\n other_vecs = in_other_embed.wv.syn0norm\\n\\n # just a matrix dot product with numpy\\n m = other_vecs.T.dot(base_vecs)\\n # SVD method from numpy\\n u, _, v = np.linalg.svd(m)\\n # another matrix operation\\n ortho = u.dot(v)\\n # Replace original array with modified one\\n # i.e. multiplying the embedding matrix (syn0norm)by \\\"ortho\\\"\\n other_embed.wv.syn0norm = other_embed.wv.syn0 = (other_embed.wv.syn0norm).dot(ortho)\\n return other_embed\",\n \"def w2v_aggregation(X, length_vector=100):\\n global w2v_model\\n if w2v_model == None: # lazy load\\n w2v_model = Word2Vec.load(os.path.join(os.environ['NOBULL_PATH'], 'model.w2v'))\\n num_row = len(X)\\n\\n max_matrix = np.zeros(shape=(num_row, length_vector))\\n average_matrix = np.zeros(shape=(num_row, length_vector))\\n\\n for row in range(num_row):\\n \\n temp_text = X[row] \\n temp_vector = temp_text.split()\\n \\n unique_vector = list(set(temp_vector))\\n num_index = len(unique_vector)\\n \\n temp_matrix = np.zeros(shape=(num_index, length_vector))\\n \\n j = 0\\n for word in unique_vector:\\n try:\\n temp_matrix[j] = w2v_model[word]\\n except:\\n temp_matrix[j] = np.zeros(shape=(length_vector,))\\n j += 1\\n\\n max_matrix[row] = np.maximum.reduce(temp_matrix)\\n average_matrix[row] = np.mean(temp_matrix, axis=0)\\n \\n result = np.concatenate((average_matrix, max_matrix), axis=1)\\n result = sparse.csr_matrix(result)\\n \\n header = []\\n \\n for i in range(length_vector):\\n temp_string = \\\"oldw2v_average_\\\" + str(i) + \\\"-th\\\"\\n header.append(temp_string)\\n \\n for i in range(length_vector):\\n temp_string = \\\"oldw2v_maximum_\\\" + str(i) + \\\"-th\\\"\\n header.append(temp_string) \\n\\n return result, header\",\n \"def intersection_align_gensim(m1,m2, words=None):\\n\\n # Get the vocab for each model\\n vocab_m1 = set(m1.wv.vocab.keys())\\n vocab_m2 = set(m2.wv.vocab.keys())\\n\\n # Find the common vocabulary\\n common_vocab = vocab_m1&vocab_m2\\n if words: common_vocab&=set(words)\\n\\n # If no alignment necessary because vocab is identical...\\n if not vocab_m1-common_vocab and not vocab_m2-common_vocab:\\n return (m1,m2)\\n\\n # Otherwise sort by frequency (summed for both)\\n common_vocab = list(common_vocab)\\n common_vocab.sort(key=lambda w: m1.wv.vocab[w].count + m2.wv.vocab[w].count,reverse=True)\\n\\n # Then for each model...\\n for m in [m1,m2]:\\n # Replace old syn0norm array with new one (with common vocab)\\n indices = [m.wv.vocab[w].index for w in common_vocab]\\n old_arr = m.wv.syn0norm\\n new_arr = np.array([old_arr[index] for index in indices])\\n m.wv.syn0norm = m.wv.syn0 = new_arr\\n\\n # Replace old vocab dictionary with new one (with common vocab)\\n # and old index2word with new one\\n m.index2word = common_vocab\\n old_vocab = m.wv.vocab\\n new_vocab = {}\\n for new_index,word in enumerate(common_vocab):\\n old_vocab_obj=old_vocab[word]\\n new_vocab[word] = gensim.models.word2vec.Vocab(index=new_index, count=old_vocab_obj.count)\\n m.wv.vocab = new_vocab\\n\\n return (m1,m2)\",\n \"def average_one_hots(sent, word_to_ind):\\n known_words = 0\\n size = len(word_to_ind.keys())\\n sum_vec = np.zeros((size,))\\n for token in sent.text: #going over all tokens and summing their embeddings\\n if (token in word_to_ind):\\n sum_vec += get_one_hot(size, word_to_ind[token])\\n known_words += 1\\n if (known_words != 0):\\n return sum_vec / known_words\\n else:\\n return sum_vec\",\n \"def get_mean_emb(self, text):\\n return np.mean([self.emb.get(w.lower(), self.emb.get(\\\"_UNK\\\")) for w in text.split()], axis=0)\",\n \"def word_average(self, sent):\\n\\n mean = []\\n for word in sent:\\n if word in self.word_model.wv.vocab:\\n mean.append(self.word_model.wv.get_vector(word) *\\n self.word_idf_weight[word]) # idf weighted\\n\\n if not mean: # empty words\\n # If a text is empty, return a vector of zeros.\\n logging.warning(\\n \\\"cannot compute average owing to no vector for {}\\\".format(sent))\\n return np.zeros(self.vector_size)\\n else:\\n mean = np.array(mean).mean(axis=0)\\n return mean\",\n \"def glove_embedding(self, texts, file):\\n self.embedding_dict = dict()\\n glove_file = open(file, encoding='utf-8')\\n for line in glove_file:\\n word_vector = line.split()\\n word = word_vector[0]\\n word_vector_arr = np.asarray(word_vector[1:], dtype='float32')\\n self.embedding_dict[word] = word_vector_arr\\n glove_file.close()\\n \\n i = 0\\n with pgb.ProgressBar(max_value=len(texts)) as bar:\\n for text in texts:\\n vec = []\\n text = text.split()\\n for t in text:\\n try:\\n vec.append(self.embedding_dict[t.lower()])\\n except KeyError:\\n pass\\n ## There are no matched words\\n if len(vec) == 0:\\n print(\\\"len 0 vec\\\")\\n self.word_vec.append(np.zeros((100)))\\n else:\\n #print(np.array(vec))\\n #print(np.array(vec).shape)\\n sentence = self.sentence_vec(np.array(vec))\\n #print(sentence)\\n #print(sentence.shape)\\n self.word_vec.append(sentence)\\n i += 1\\n bar.update(i)\\n self.word_vec = np.array(self.word_vec)\\n print(self.word_vec.shape)\",\n \"def word_analogy(self):\\n data = open(\\\"data/word_analogy_subset.en.ar.txt\\\").read().split('\\\\n')\\n data = [x for x in data if len(x.split()) == 4]\\n cnt = 0\\n keys = list(self.embeddings_index.keys())\\n vectors = np.array(list(self.embeddings_index.values()))\\n norms = np.linalg.norm(vectors, axis=1)\\n for i in data:\\n i = self.preprocessor(i).split()\\n try:\\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\\n except:\\n continue\\n unit = v / np.linalg.norm(v)\\n dists = np.dot(vectors, unit) / norms\\n best = np.argpartition(-dists, 10)[:10 + 1]\\n best = best.take(np.argsort((-dists).take(best)))\\n result = [(keys[sim], float(dists[sim]))\\n for sim in best]\\n sbv = result[:10]\\n for j in sbv:\\n if j[0] == i[3]:\\n cnt += 1\\n return cnt/ len(data)\",\n \"def overlap_similarity(vect1, vect2, normalize=False, use_bigrams=False):\\n overlap = len(set(vect1).intersection(set(vect2)))\\n\\n if use_bigrams:\\n overlap += len(set(bigrams(vect1)).intersection(set(bigrams(vect2))))\\n\\n if not normalize:\\n return overlap\\n \\n if overlap == 0:\\n return 0\\n \\n return overlap / (math.log10(len(vect1)) + math.log10(len(vect2)))\",\n \"def get_sentence_mean_vec(sentence):\\n sentence_vecs = numpy.array([])\\n \\n sent1 = nltk.word_tokenize(sentence)\\n for w in sent1: \\n w = w.strip(\\\"'?.,- \\\")\\n if not w in stop_words and w.lower() in glove_model:\\n word_vec = numpy.array([glove_model[w.lower()]])\\n if sentence_vecs.shape[0] == 0: # Initialize sentence vectors\\n sentence_vecs = word_vec\\n else:\\n sentence_vecs = numpy.vstack((sentence_vecs, word_vec))\\n # print(sentence_vecs.shape)\\n if sentence_vecs.shape[0] == 0:\\n return None\\n elif sentence_vecs.shape == (300,):\\n return numpy.expand_dims(sentence_vecs, axis=0)\\n return numpy.mean(sentence_vecs, axis=0)\",\n \"def produce_outputs(self):\\n # if self.loaded_aggregated:\\n # debug(\\\"Skippping {} mapping due to preloading\\\".format(self.base_name))\\n # return\\n # need to calc term numeric index for aggregation\\n\\n\\n # if self.loaded_preprocessed:\\n # debug(\\\"Skippping {} mapping due to preloading\\\".format(self.base_name))\\n # return\\n\\n bagger = Bag(vocabulary=self.term_list, weighting=self.base_name, ngram_range=self.ngram_range)\\n\\n self.embeddings = np.ndarray((0, len(self.term_list)), dtype=np.int32)\\n for idx in self.indices.get_train_test():\\n texts = Text.get_strings(self.text.data.get_slice(idx))\\n vecs = bagger.map_collection(texts, fit=False, transform=True)\\n self.embeddings = np.append(self.embeddings, vecs, axis=0)\\n del texts\\n\\n # texts = Text.get_strings(self.text.data.get_slice(test_idx))\\n # vec_test = bagger.map_collection(texts, fit=do_fit)\\n # del texts\\n\\n # self.embeddings = np.vstack((vec_train, vec_test))\\n\\n # self.embeddings = np.append(vec_train, vec_test)\\n # self.vector_indices = (np.arange(len(train)), np.arange(len(test)))\\n\\n # set misc required variables\\n self.set_constant_elements_per_instance()\",\n \"def word2vec_generation(self, utterance, with_punctuations):\\n vector = []\\n\\n #words = self.text_preparation(utterance)\\n\\n words = utterance\\n\\n #model_ = Word2Vec.load('model.bin')\\n #if not self.is_word_in_word2vec_vocabulary(utterance, model_):\\n # self.retrain_model([words])\\n\\n if with_punctuations:\\n new_model = Word2Vec.load('./model/model_word2vec.bin')\\n else:\\n new_model = Word2Vec.load('./model/model_no_punctuation_word2vec.bin')\\n\\n\\n\\n # TODO: how generate word2vec vectors for each utterance using the vocabularies in Word2vec model?\\n\\n #First: average of Word2Vec vectors in each utterance\\n for w in words:\\n vector.append(new_model.wv[w])\\n\\n return np.mean(vector, axis=0)\",\n \"def wordSimilarityRatio(sent_1,sent_2):\",\n \"def grounding_words(self, w):\\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])\",\n \"def get_word_vector():\\n\\n patten = r\\\"[0-9\\\\s+\\\\.\\\\!\\\\/_,$%^*()?;；:-【】+\\\\\\\"\\\\']+|[+——！，;:。？、~@#￥%……&*（）]+\\\"\\n s1 = input(\\\"句子1：\\\").strip()\\n s2 = input(\\\"句子2：\\\").strip()\\n s1 = re.sub(patten, \\\" \\\", s1)\\n s2 = re.sub(patten, \\\" \\\", s2)\\n cut1 = jieba.cut(s1)\\n cut2 = jieba.cut(s2)\\n\\n list_word1 = (' '.join(cut1)).split()\\n list_word2 = (' '.join(cut2)).split()\\n print(list_word1)\\n print(list_word2)\\n\\n key_word = list(set(list_word1 + list_word2)) # 取并集\\n print(key_word)\\n\\n word_vector1 = np.zeros(len(key_word)) # 给定形状和类型的用0填充的矩阵存储向量\\n word_vector2 = np.zeros(len(key_word))\\n\\n for i in range(len(key_word)): # 依次确定向量的每个位置的值\\n for j in range(len(list_word1)): # 遍历key_word中每个词在句子中的出现次数\\n if key_word[i] == list_word1[j]:\\n word_vector1[i] += 1\\n for k in range(len(list_word2)):\\n if key_word[i] == list_word2[k]:\\n word_vector2[i] += 1\\n\\n print(word_vector1) # 输出向量\\n print(word_vector2)\\n return word_vector1, word_vector2\",\n \"def word_overlap2(sentence_a, sentence_b):\\n a_set = set(word for word in sentence_a) - config.stop_list\\n b_set = set(word for word in sentence_b) - config.stop_list\\n score = len(a_set&b_set)/float(len(a_set|b_set))# len(s1&s2)/max(len(s1),len(s2))\\n\\n return score\",\n \"def lookup(doc, wv):\\n checked = []\\n for word in doc:\\n try:\\n word in wv\\n except KeyError:\\n log.warning(\\\"Word not in model: %s\\\", word)\\n continue\\n checked.append(wv[word])\\n vec = np.mean(checked, axis=0)\\n return vec\",\n \"def _aggregate_vectors(movies, feedback_list=[]):\\n movie_vec = []\\n for i in movies:\\n try:\\n m_vec = clf[i] # get the vector for each movie\\n if ratings_dict:\\n try:\\n r = ratings_dict[i] # get user_rating for each movie\\n # Use a polynomial to weight the movie by rating.\\n # This equation is totally arbitrary. I just fit a polynomial\\n # to some weights that look good. The effect is to raise\\n # the importance of 1, 9, and 10 star ratings.\\n w = ((r**3)*-0.00143) + ((r**2)*0.0533) + (r*-0.4695) + 2.1867\\n m_vec = m_vec * w\\n except KeyError:\\n continue\\n movie_vec.append(m_vec)\\n except KeyError:\\n continue\\n if feedback_list:\\n for i in feedback_list:\\n try:\\n f_vec = clf[i]\\n movie_vec.append(f_vec*1.8) # weight feedback by adding multiplier here\\n except KeyError:\\n continue\\n return np.mean(movie_vec, axis=0)\",\n \"def get_word_embeddings(embeddingsPath, allwords, splittype=\\\" \\\"):\\n word2Idx = {}\\n wordEmbeddings = []\\n print('Using word embeddings:', embeddingsPath)\\n openfile = _get_correct_open(embeddingsPath)\\n with openfile(embeddingsPath,'r', encoding='utf-8') as fEmbeddings:\\n c = 0\\n for line in fEmbeddings:\\n c+=1\\n split = line.strip().split(splittype)\\n if '' in split:\\n raise ValueError(\\\"Error in spacing of word vector file:\\\"+\\n \\\" bad formatting. Consider using different value of splittype.\\\")\\n word = split[0]\\n\\n # fastText and Yogatama pre-trained embedding starts with a line\\n # with 2 elements that we need to ignore:\\n if len(split) <= 5:\\n print('Ignoring line '+str(c))\\n continue\\n\\n if len(word2Idx) == 0: #Add padding+unknown\\n word2Idx[\\\"PADDING_TOKEN\\\"] = len(word2Idx)\\n vector = np.zeros(len(split)-1) #Zero vector for 'PADDING' word\\n wordEmbeddings.append(vector)\\n\\n word2Idx[\\\"UNKNOWN_TOKEN\\\"] = len(word2Idx)\\n vector = np.random.uniform(-0.25, 0.25, len(split)-1)\\n wordEmbeddings.append(vector)\\n\\n if word.lower() in allwords:\\n vector = np.array([float(num) for num in split[1:]])\\n wordEmbeddings.append(vector)\\n word2Idx[word] = len(word2Idx)\\n\\n wordEmbeddings = np.array(wordEmbeddings)\\n return wordEmbeddings, word2Idx\",\n \"def generate_initial_embs(emb_type):\\n def _get_emb_avg(g, lang):\\n \\\"\\\"\\\"Compute the embedding of g as the average of its word embeddings\\n :param g: the input genre\\n :param lang: language\\n :return: the embedding and if all words of this genre are known\\n \\\"\\\"\\\"\\n emb = np.zeros(emb_dims[lang])\\n known_words_count = 0\\n words = g.split()\\n for w in words:\\n if w in models[lang]:\\n emb += models[lang][w]\\n known_words_count += 1\\n emb /= len(words)\\n return emb, known_words_count > 0\\n\\n def _get_emb_wavg(g, lang, a=0.001):\\n \\\"\\\"\\\"Compute the embeddings of g with a sentence embedding algorithm (average weighted by the word estimated frequencies)\\n :param g: the input genre\\n :param lang: language\\n :param a: a model hyper-parameter (see Arora et al. in the paper)\\n :return: the embedding and if all words of this genre are known\\n \\\"\\\"\\\"\\n emb = np.zeros(emb_dims[lang])\\n known_words_count = 0\\n words = g.split()\\n for w in words:\\n if w in models[lang]:\\n emb += a / (a + word_freqs[lang][w]) * models[lang][w]\\n known_words_count += 1\\n emb /= len(words)\\n return emb, known_words_count > 0\\n\\n def _remove_pc(df_embs, npc=1):\\n \\\"\\\"\\\"Remove the pc (see Arora at el. in the paper)\\n :param df_embs: the input embeddings\\n :return: the normalized embeddings\\n \\\"\\\"\\\"\\n pc = _compute_pc(df_embs, npc)\\n if npc == 1:\\n df_embs_out = df_embs - df_embs.dot(pc.transpose()) * pc\\n else:\\n df_embs_out = df_embs - df_embs.dot(pc.transpose()).dot(pc)\\n return df_embs_out\\n\\n def _compute_pc(df_embs, npc=1):\\n \\\"\\\"\\\"Compute the pc (see Arora at el. in the paper)\\n :param df_embs: the input embeddings\\n :return: the principal component\\n \\\"\\\"\\\"\\n svd = TruncatedSVD(n_components=npc, n_iter=7, random_state=0)\\n svd.fit(df_embs)\\n return svd.components_\\n\\n embs = {}\\n known = {}\\n for g in G.nodes:\\n lang = g[:2]\\n norm_g = TagManager.normalize_tag_wtokenization(g, tries[lang], prefixed=True)\\n if emb_type == 'avg':\\n embs[g], known[g] = _get_emb_avg(norm_g, lang)\\n else:\\n embs[g], known[g] = _get_emb_wavg(norm_g, lang)\\n\\n embs = pd.DataFrame(embs).T # the embeddings are columns\\n if emb_type == 'sif': # the algorithm imposes a normalization\\n norm_embs = _remove_pc(embs.to_numpy())\\n embs = pd.DataFrame(norm_embs, columns=embs.columns, index=embs.index)\\n return embs, known\",\n \"def _aggregate_text_embedding(self, token_ids, embeddings):\\n if self._hparams['obj_text_aggregation'] == 'max':\\n # Find valid tokens (not PADDING/EOS/UNK/START).\\n valid_token_mask = tf.greater_equal(token_ids, 4)\\n # Use large negative bias for invalid tokens.\\n invalid_token_bias = tf.cast(\\n tf.logical_not(valid_token_mask), tf.float32) * -1e9\\n # [batch, node_num, word_num, hidden_size]\\n embeddings = embeddings + tf.expand_dims(invalid_token_bias, axis=-1)\\n # Max value for each dimension, [batch, node_num, hidden_size].\\n embeddings = tf.reduce_max(embeddings, axis=-2)\\n # For objects with no text, use 0.\\n valid_object_mask = tf.cast(\\n tf.reduce_any(valid_token_mask, axis=-1), tf.float32)\\n embeddings = embeddings * tf.expand_dims(valid_object_mask, axis=-1)\\n\\n elif self._hparams['obj_text_aggregation'] == 'sum':\\n # [batch, step, #max_obj, #max_token] 0 for padded tokens\\n real_objects = tf.cast(tf.greater_equal(token_ids, 4), tf.float32)\\n # [batch, step, #max_obj, hidden] 0s for padded objects\\n embeddings = tf.reduce_sum(\\n input_tensor=embeddings * tf.expand_dims(real_objects, 3), axis=-2)\\n\\n else:\\n raise ValueError('Unrecognized token aggregation %s' %\\n (self._hparams['obj_text_aggregation']))\\n return embeddings\",\n \"def get_common(self, other, mapping):\\n\\n self_oov = defaultdict(lambda: 0)\\n other_oov = defaultdict(lambda: 0)\\n self_word_id = deepcopy(self.word_id)\\n other_word_id = deepcopy(other.word_id)\\n new_words = []\\n map_ = mapping.map\\n for i, w in enumerate(self.word_id):\\n if w not in map_:\\n self_oov[w] += 1\\n del self_word_id[w]\\n continue\\n\\n if map_[w] not in other.word_id:\\n other_oov[map_[w]] += 1\\n del self_word_id[w]\\n\\n for i, w in enumerate(other.word_id):\\n if w not in map_:\\n del other_word_id[w]\\n\\n logging.info(\\\"We could not find {} {} words in our dictionary.\\\".format(\\n len(self_oov), self.lang))\\n logging.info(\\\"We could not find {} {} words in our target words.\\\".format(\\n len(other_oov), other.lang))\\n logging.info(\\\"Our {} vocabulary has {} valid words.\\\".format(\\n self.lang, len(self_word_id)))\\n\\n sorted_self_word_id = Embeddings.sorted_words(self_word_id)\\n self_vectors = asarray([self.vectors[i] for w, i in sorted_self_word_id])\\n self_words = [w for w, i in sorted_self_word_id]\\n new_self = Embeddings(lang=self.lang, vectors=self_vectors, words=self_words)\\n\\n sorted_other_word_id = Embeddings.sorted_words(other_word_id)\\n other_vectors = asarray([other.vectors[i] for w, i in sorted_other_word_id])\\n other_words = [w for w, i in sorted_other_word_id]\\n new_other = Embeddings(lang=self.lang, vectors=other_vectors, words=other_words)\\n\\n return (new_self, new_other)\",\n \"def review_to_vec(words, model, num_features , index2word_set):\\n \\n feature_vec = np.zeros((num_features), dtype=\\\"float32\\\")\\n word_count = 0\\n \\n \\n \\n for word in words:\\n if word in index2word_set: \\n word_count += 1\\n feature_vec += model[word]\\n\\n if word_count == 0:\\n word_count = 1\\n\\n feature_vec /= word_count\\n\\n return feature_vec\",\n \"def get_word_containement_measure(self,l2,l1):\\n count = 0\\n found_idfs = []\\n unfound_idfs = []\\n for w in l1:\\n val = self.idf.get_tfidf_val(w)\\n if (val > 10):\\n val = 10\\n if w in l2:\\n count += 1\\n found_idfs.append(val)\\n else:\\n unfound_idfs.append(val)\\n if (len(found_idfs) == 0):\\n avg_found = 0\\n else:\\n avg_found = np.mean(found_idfs)\\n if (len(unfound_idfs) ==0):\\n avg_unfound = 0\\n else:\\n avg_unfound = np.mean(unfound_idfs)\\n\\n\\n\\n return count / self.normalize_factor, avg_found, avg_unfound\",\n \"def _WordSimAveVec(self,df,a):\\r\\n #Obtain the course description for the course provided and convert the string into a list of individual words.\\r\\n Description = df['description'][a].split()\\r\\n #Create a placeholder zero vector of the same size as the vector embedding.\\r\\n Vector = np.zeros(self.WordVecModel.layer1_size)\\r\\n wordCount = 0\\r\\n #Iterate over each word in the description.\\r\\n for word in Description:\\r\\n #If the word is in the trained vocabulary, obtain the word vector. \\r\\n #Continue to add the word vectors to the placeholder vector to get the running sum.\\r\\n if word in self.WordVecModel.wv.vocab:\\r\\n vector = self.WordVecModel.wv.get_vector(word)\\r\\n Vector +=vector\\r\\n #Keep track of how many word vectors (which were included in the vocabulary) were added.\\r\\n wordCount +=1\\r\\n #Calculate the mean by dividing the sum by the number of vectors.\\r\\n return Vector/wordCount\",\n \"def processUnigram(word, vector):\\n\\n unigram, exists = vector.getUnigram(word)\\n vector.addUnigram(word)\",\n \"def neutralize(word, g, word_to_vec_map):\\n\\n ### START CODE HERE ###\\n # Select word vector representation of \\\"word\\\". Use word_to_vec_map. (≈ 1 line)\\n e = word_to_vec_map[word]\\n\\n # Compute e_biascomponent using the formula given above. (≈ 1 line)\\n e_biascomponent = np.dot(e, g) / np.sum(np.dot(g, g)) * g\\n # e_biascomponent = np.sqrt(np.sum(np.dot(e,e))) * cosine_similarity(e, g) * g/np.sqrt(np.sum(np.dot(g,g)))\\n # Neutralize e by subtracting e_biascomponent from it\\n # e_debiased should be equal to its orthogonal projection. (≈ 1 line)\\n e_debiased = e - e_biascomponent\\n ### END CODE HERE ###\\n\\n return e_debiased\",\n \"def word_similarity(self):\\n y_true = []\\n y_pred = []\\n for i in open(\\\"data/word_sim_dataset.txt\\\").read().split('\\\\n'):\\n i = self.preprocessor(i)\\n w1 = i.split()[-1]\\n w2 = i.split()[-2] \\n st = float(i.split()[-3]) / 4 #dataset has scale from 0 to 4\\n \\n try:\\n w1 = self.embeddings_index[w1] \\n w2 = self.embeddings_index[w2] \\n w1 = w1 / np.linalg.norm(w1)\\n w2 = w2 / np.linalg.norm(w2)\\n y_pred.append(np.dot(w1,w2))\\n y_true.append(st)\\n except:\\n pass\\n if y_true == []:\\n return 1.0\\n return mean_squared_error(y_true, y_pred, squared=False)\",\n \"def compute_bias_average_vector(p1: list, p2: list, target:list, model: Word2Vec,\\n metric:Callable[[list,list],float] = cosine_sim) -> float:\\n av_v1 = average_vector(p1,model); av_v2 = average_vector(p2,model)\\n return np.mean([metric(av_v1,model.wv.__getitem__(w)) - \\\\\\n metric(av_v2,model.wv.__getitem__(w)) for w in target \\n if w in model.wv])\",\n \"def word_overlap3(t_raw, h_raw, replacements):\\n t_set = set(word for word in t_raw) - config.stop_list\\n h_set = set(word for word in h_raw) - config.stop_list\\n score = len(t_set & h_set) / float(len(t_set|h_set)) \\n highestscore = 0\\n\\n for replacement in replacements:\\n t_set = set(word for word in replacement[2]) - config.stop_list # replacement[1] = t_raw\\n h_set = set(word for word in replacement[3]) - config.stop_list # replacement[2] = h_raw\\n newScore = len(t_set & h_set) / float(len(t_set|h_set))\\n if newScore > highestscore:\\n highestscore = newScore\\n return (score + highestscore) /2\",\n \"def word_average_list(self, docs):\\n return np.vstack([self.word_average(sent) for sent in docs])\",\n \"def word_average_list(self, docs):\\n return np.vstack([self.word_average(sent) for sent in docs])\",\n \"def mean(self, words: [str]) -> numpy.ndarray:\\n vecs = numpy.array([self[word] for word in words])\\n return numpy.mean(vecs, axis=0)\",\n \"def genre_average(genre_vectors):\\n array = [vector for vector in genre_vectors]\\n return np.average(array, axis=0)\",\n \"def AraVec(striped_text: [str], embedding_dimension=100) -> [[int]]:\\n\\n count_unknown = 0\\n words_index = 0\\n\\n if embedding_dimension == 100:\\n if Embedding.t_model == None:\\n Embedding.t_model = gensim.models.Word2Vec.load(\\n '\\\\\\\\'.join([Embedding.project_working_dir, 'models', 'AraVec', 'full_uni_sg_100_wiki.mdl']))\\n\\n if embedding_dimension == 300:\\n if Embedding.t_model == None:\\n Embedding.t_model = gensim.models.Word2Vec.load(\\n '\\\\\\\\'.join([Embedding.project_working_dir, 'models', 'AraVec', 'full_uni_sg_300_wiki.mdl']))\\n\\n embedded_book_array = np.empty(shape=[len(striped_text), embedding_dimension])\\n\\n for word in striped_text:\\n try:\\n embedded_book_array[words_index] = Embedding.t_model.wv[word]\\n words_index += 1\\n except KeyError:\\n # taking words that appear with the litter and in arabic\\n # the and litter is removed from the word and then check if it appears in the dictionary\\n if str(word)[0] == 'و':\\n try:\\n embedded_book_array[words_index] = Embedding.t_model.wv[word]\\n words_index += 1\\n except KeyError:\\n # print(word)\\n count_unknown += 1\\n else:\\n # print(word)\\n count_unknown += 1\\n\\n print(\\\"Total unknown words {0}/{1}, witch is {2}%.\\\".format(count_unknown,\\n len(striped_text),\\n int((count_unknown / len(striped_text) * 100))))\\n\\n return embedded_book_array[0:words_index]\",\n \"def get_average_vec(tokens_list, vector, generate_missing=False, k=300):\\r\\n if len(tokens_list)<1:\\r\\n return np.zeros(k)\\r\\n \\r\\n if generate_missing:\\r\\n vectorized = [vector[word] if word in vector else np.random.rand(k) for word in tokens_list]\\r\\n else:\\r\\n vectorized = [vector[word] if word in vector else np.zeros(k) for word in tokens_list]\\r\\n \\r\\n length = len(vectorized)\\r\\n summed = np.sum(vectorized, axis=0)\\r\\n averaged = np.divide(summed, length)\\r\\n return averaged\",\n \"def similarity(self, word1, word2):\\n common_vect = +np.ones(self.nEmbed) * 10000\\n if word1 not in self.vocab and word2 in self.vocab:\\n id_word_2 = self.w2id[word2]\\n w1 = common_vect\\n w2 = self.U[id_word_2]\\n elif word1 in self.vocab and word2 not in self.vocab:\\n id_word_1 = self.w2id[word1]\\n w1 = self.U[id_word_1]\\n w2 = common_vect\\n elif word1 not in self.vocab and word2 not in self.vocab:\\n w1 = common_vect\\n w2 = common_vect\\n else:\\n id_word_1 = self.w2id[word1]\\n id_word_2 = self.w2id[word2]\\n w1 = self.U[id_word_1]\\n w2 = self.U[id_word_2]\\n\\n # scalair = w1.dot(w2)/np.linalg.norm(w1,w2)\\n similarity = w1.dot(w2) / (np.linalg.norm(w1) * np.linalg.norm(w2))\\n # similarity = 1 / (1 + np.exp(-scalair))\\n # similarity = scalair / (np.linalg.norm(w1) * np.linalg.norm(w2))\\n return similarity\",\n \"def generate_avg_vector(self, data):\\r\\n doc=nlp(data)\\r\\n data_vector = [token.vector for token in doc]\\r\\n mean_vector = np.mean(data_vector, axis=0)\\r\\n return mean_vector\",\n \"def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\\r\\n input_string_x1=input_string_x1.decode(\\\"utf-8\\\")\\r\\n input_string_x2 = input_string_x2.decode(\\\"utf-8\\\")\\r\\n #1. get blue score vector\\r\\n feature_list=[]\\r\\n #get blue score with n-gram\\r\\n for i in range(n_gram):\\r\\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\\r\\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\\r\\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\\r\\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\\r\\n feature_list.append(blue_score_i_1)\\r\\n feature_list.append(blue_score_i_2)\\r\\n\\r\\n #2. get length of questions, difference of length\\r\\n length1=float(len(input_string_x1))\\r\\n length2=float(len(input_string_x2))\\r\\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\\r\\n feature_list.append(length_diff)\\r\\n\\r\\n #3. how many words are same, how many words are unique\\r\\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\\r\\n feature_list.extend(sentence_diff_overlap_features_list)\\r\\n\\r\\n #4. question 1,2 start with how/why/when\\r\\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\\r\\n #print(\\\"how_why_feature_list:\\\",how_why_feature_list)\\r\\n #feature_list.extend(how_why_feature_list)\\r\\n\\r\\n #5.edit distance\\r\\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\\r\\n feature_list.append(edit_distance)\\r\\n\\r\\n #6.cos distance from sentence embedding\\r\\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\\r\\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\\r\\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\\r\\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\\r\\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\\r\\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\\r\\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\\r\\n feature_list.extend(distance_list_fasttext)\\r\\n feature_list.extend(distance_list_word2vec)\\r\\n #feature_list.extend(list(sentence_diffence))\\r\\n #feature_list.extend(list(sentence_multiply))\\r\\n return feature_list\",\n \"def word_intersection() -> list:\\r\\n\\r\\n def count_words(title_pair: np.array) -> float:\\r\\n \\\"\\\"\\\"Function calculates number of unique words present\\r\\n in both titles and ratio of that number to the union of unique words.\\r\\n :param title_pair: Array containing two titles\\r\\n :return: Ratio of intersecting words to union of unique words\\r\\n \\\"\\\"\\\"\\r\\n title_1, title_2 = title_pair\\r\\n # Transform into sets of words\\r\\n title_1 = set(title_1.split())\\r\\n title_2 = set(title_2.split())\\r\\n # Divide length of intersection by length of union\\r\\n ratio = len(title_1.intersection(title_2)) / len(title_1.union(title_2))\\r\\n return ratio\\r\\n\\r\\n # Find titles for each pair in the current chunk by their indexes\\r\\n tmp_df = pd.DataFrame()\\r\\n tmp_df['title_1'] = data.loc[pairs.loc[:, 'idx_1'].values, 'title'].values\\r\\n tmp_df['title_2'] = data.loc[pairs.loc[:, 'idx_2'].values, 'title'].values\\r\\n\\r\\n # Process title pairs in current chunk and add results to the list\\r\\n scores = [result for result in map(count_words, tmp_df[['title_1', 'title_2']].values)]\\r\\n\\r\\n return scores\",\n \"def sentence_similarity_asym(sentence1, sentence2):\\n # Tokenize and tag\\n sentence1 = pos_tag(word_tokenize(sentence1))\\n sentence2 = pos_tag(word_tokenize(sentence2))\\n \\n # Get the synsets for the tagged words\\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n \\n # Filter out the Nones\\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n \\n score, count = 0.0, 0\\n\\n # For each word in the first sentence\\n for synset in synsets1:\\n # Get the similarity value of the most similar word in the other sentence\\n pathsim = [synset.path_similarity(ss) for ss in synsets2]\\n if len(pathsim) == 0:\\n #print sentence1, sentence2\\n pathsim = [0]\\n best_score = max(pathsim)\\n \\n # Check that the similarity could have been computed\\n if best_score is not None:\\n score += best_score\\n count += 1\\n\\n if count == 0:\\n return 0\\n # Average the values\\n score /= count\\n return score\",\n \"def bag_of_words(tokenized_sentence, all_words):\\n\\n tokenized_sentence = [stem(w) for w in tokenized_sentence]\\n #print(tokenized_sentence)\\n bag = np.zeros_like(all_words, dtype=np.float32)\\n for idx, w in enumerate(all_words):\\n if w in tokenized_sentence:\\n bag[idx] = 1.0\\n\\n return bag\",\n \"def _compute_span_pair_embeddings(self,\\n top_span_embeddings: torch.FloatTensor,\\n antecedent_embeddings: torch.FloatTensor,\\n genre_embedding: torch.FloatTensor,\\n trigger_same_type_agreement_embeddings: torch.FloatTensor,\\n realies_same_type_agreement_embeddings: torch.FloatTensor,\\n antecedent_offsets: torch.FloatTensor):\\n\\n # Shape: (1, max_antecedents, embedding_size)\\n antecedent_distance_embeddings = self._distance_embedding(\\n util.bucket_values(antecedent_offsets,\\n num_total_buckets=self._num_distance_buckets))\\n\\n # Shape: (1, 1, max_antecedents, embedding_size)\\n antecedent_distance_embeddings = antecedent_distance_embeddings.unsqueeze(0)\\n\\n expanded_distance_embeddings_shape = (antecedent_embeddings.size(0), # batch_size\\n antecedent_embeddings.size(1), # num_spans_to_keep\\n antecedent_embeddings.size(2), # max_antecedents\\n antecedent_distance_embeddings.size(-1)) # embedding_size\\n # Shape: (batch_size, num_spans_to_keep, max_antecedents, embedding_size)\\n antecedent_distance_embeddings = antecedent_distance_embeddings.expand(*expanded_distance_embeddings_shape)\\n antecedent_genre_embeddings = genre_embedding.view(1, 1, 1, -1).expand_as(antecedent_distance_embeddings)\\n feature_embeddings = self._dropout(torch.cat(\\n [antecedent_genre_embeddings, realies_same_type_agreement_embeddings, trigger_same_type_agreement_embeddings],-1))\\n # ], -1))\\n\\n # [antecedent_distance_embeddings, antecedent_genre_embeddings, trigger_same_type_agreement_embeddings,\\n # realies_same_type_agreement_embeddings], -1))\\n # feature_embeddings = self._dropout(torch.cat(\\n # [antecedent_genre_embeddings, trigger_same_type_agreement_embeddings], -1\\n # ))\\n\\n # Shape: (batch_size, num_spans_to_keep, max_antecedents, embedding_size)\\n target_embeddings = top_span_embeddings.unsqueeze(2).expand_as(antecedent_embeddings)\\n # Shape: (batch_size, num_spans_to_keep, max_antecedents, embedding_size)\\n span_pair_embeddings = torch.cat([target_embeddings,\\n antecedent_embeddings,\\n antecedent_embeddings * target_embeddings,\\n feature_embeddings], -1)\\n return span_pair_embeddings\",\n \"def _add_pre_trained_embedding(self):\\n\\n if self.embedding_type['type'] == 'glove':\\n self.logging.info('use pre-trained glove word2vec')\\n # a. load pre trained glove\\n GLOVE_DIR = '../data/glove_pretrained/glove.6B'\\n glove_suffix_name = 'glove.6B.' + str(self.embedding_size) + 'd.txt'\\n import os\\n import numpy as np\\n\\n embeddings_index = {}\\n f = open(os.path.join(GLOVE_DIR, glove_suffix_name)) # 'glove.6B.100d.txt'))\\n for line in f:\\n values = line.split()\\n word = values[0]\\n coefs = np.asarray(values[1:], dtype='float32')\\n embeddings_index[word] = coefs\\n f.close()\\n\\n self.logging.info('')\\n self.logging.info('Found %s word vectors.' % len(embeddings_index))\\n\\n # b. compute embedding matrix\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector # words not found in embedding index will be all-zeros.\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt) + ' / ' + str(len(self.word_index)))\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n\\n elif self.embedding_type['type'] == 'gensim':\\n self.logging.info('use pre-trained gensim word2vec')\\n\\n import gzip\\n import gensim\\n from keras.layers import Embedding\\n import numpy as np\\n\\n # fname = '../data/word2vec_pretrained/motors/d_300_k_712904_w_6_e_60_v_motors'\\n # fname = '../data/word2vec_pretrained/fashion/d_300_k_1341062_w_6_e_70_v_fashion'\\n\\n self.logging.info('load word2vec path: ' + str(self.embedding_type['path']))\\n model = gensim.models.Word2Vec.load(self.embedding_type['path'])\\n pretrained_weights = model.wv.syn0\\n vocab_size, vector_dim = pretrained_weights.shape\\n\\n method = 3\\n if method == 1:\\n self.logging.info('word2vec attempt to fit into embedding layer - middle complex')\\n # convert the wv word vectors into a numpy matrix that is suitable for insertion\\n # into our TensorFlow and Keras models\\n\\n embedding_matrix = np.zeros((len(model.wv.vocab), vector_dim))\\n for i in range(len(model.wv.vocab)):\\n embedding_vector = model.wv[model.wv.index2word[i]]\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n embedding_layer = Embedding(input_dim=embedding_matrix.shape[0],\\n output_dim=embedding_matrix.shape[1],\\n # input_length=self.maxlen,\\n weights=[embedding_matrix],\\n trainable=False)\\n elif method == 2:\\n self.logging.info('word2vec simple embedding matching - simple complex')\\n embedding_layer = Embedding(input_dim=vocab_size,\\n output_dim=vector_dim,\\n input_length=self.maxlen,\\n weights=[pretrained_weights],\\n trainable=False)\\n elif method == 3:\\n\\n self.logging.info('word2vec match using word_index from keras tokenizer - as used in glove match above')\\n # b. compute embedding matrix\\n\\n # sd = 1 / np.sqrt(len(self.word_index) + 1)\\n # embedding_matrix = np.random.normal(0, scale=sd, size=(len(self.word_index) + 1, self.embedding_size))\\n\\n embedding_matrix = np.zeros((len(self.word_index) + 1, self.embedding_size))\\n cnt = 0\\n for word, i in self.word_index.items():\\n if word in model.wv:\\n embedding_vector = model.wv[word]\\n embedding_matrix[i] = embedding_vector\\n else:\\n # self.logging.info('token in train missing in word2vec: ' + str(word))\\n cnt += 1\\n self.logging.info('total tokens missing: ' + str(cnt))\\n\\n\\n # c. build embedding layer\\n from keras.layers import Embedding\\n embedding_layer = Embedding(len(self.word_index) + 1,\\n self.embedding_size,\\n weights=[embedding_matrix],\\n input_length=self.maxlen,\\n trainable=False)\\n else:\\n raise ValueError('unknown method value')\\n\\n else:\\n raise ValueError('unknown embedding type')\\n self.logging.info('create glove pre-trained embedding: ' + str(self.embedding_size))\\n return embedding_layer\",\n \"def wordNet_similarity(sentence1, sentence2):\\r\\n # Tokenize and tag\\r\\n \\r\\n # sentence1 = pos_tag(word_tokenize(sentence1))\\r\\n sentence1=st_tagger.tag(word_tokenize(sentence1))\\r\\n \\r\\n # sentence2 = pos_tag(word_tokenize(sentence2))\\r\\n sentence2=st_tagger.tag(word_tokenize(sentence2))\\r\\n\\r\\n \\r\\n # Get the synsets for the tagged words\\r\\n #################################################\\r\\n\\r\\n # synsets1=[]\\r\\n # synsets2=[]\\r\\n # for tagged_word in sentence1:\\r\\n # print(tagged_word)\\r\\n # tagged_word = list(tagged_word)\\r\\n # synsets1.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\\r\\n # for tagged_word in sentence2:\\r\\n # print(tagged_word)\\r\\n # tagged_word = list(tagged_word)\\r\\n # print(tagged_word)\\r\\n # synsets2.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\\r\\n\\r\\n # The code above is the elaboration of code below\\r\\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\r\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\r\\n \\r\\n # Filter out the Nones in the synonym set\\r\\n synsets1 = [ss for ss in synsets1 if ss]\\r\\n synsets2 = [ss for ss in synsets2 if ss]\\r\\n \\r\\n score, count = 0.0, 0\\r\\n \\r\\n###########################################################################\\r\\n # for syn1 in synsets1:\\r\\n # arr_simi_score = []\\r\\n # print('=========================================')\\r\\n # print(syn1)\\r\\n # print('----------------')\\r\\n # for syn2 in synsets2:\\r\\n # print(syn2)\\r\\n # simi_score = syn1.path_similarity(syn2)\\r\\n # print(simi_score)\\r\\n # if simi_score is not None:\\r\\n # arr_simi_score.append(simi_score)\\r\\n # print('----------------')\\r\\n # print(arr_simi_score)\\r\\n # if(len(arr_simi_score) > 0):\\r\\n # best = max(arr_simi_score)\\r\\n # print(best)\\r\\n # score += best\\r\\n # count += 1\\r\\n # # Average the values\\r\\n # print('score: ', score)\\r\\n # print('count: ', count)\\r\\n # score /= count\\r\\n\\r\\n###########################################################################\\r\\n\\r\\n for syn1 in synsets1:\\r\\n arr_simi_score = []\\r\\n # print('=========================================')\\r\\n print(\\\"Each word from Synonym se1\\\",syn1)\\r\\n # print('----------------')\\r\\n for syn2 in synsets2:\\r\\n print(\\\"Each word from Synonym se2\\\",syn2)\\r\\n # simi_score = syn1.path_similarity(syn2)\\r\\n simi_score = syn1.wup_similarity(syn2)\\r\\n print(\\\"word to word path_similarity score\\\",simi_score)\\r\\n if simi_score is not None:\\r\\n arr_simi_score.append(simi_score)\\r\\n print('----------------')\\r\\n print(arr_simi_score)\\r\\n if(len(arr_simi_score) > 0):\\r\\n best = max(arr_simi_score)\\r\\n print(\\\"best score so far\\\", best)\\r\\n score += best\\r\\n count += 1\\r\\n # Average the values\\r\\n print('score: ', score)\\r\\n print('count: ', count)\\r\\n if count!=0:\\r\\n score /= count\\r\\n else:\\r\\n score=0.0\\r\\n return score\",\n \"def word_order_similarity(self,sentence_1, sentence_2):\\n\\t words_1 = sentence_1.getList_of_words()\\n\\t words_2 = sentence_2.getList_of_words()\\n\\t joint_words = list(set(words_1).union(set(words_2)))\\n\\t windex = {x[1]: x[0] for x in enumerate(joint_words)}\\n\\t r1 = self.word_order_vector(words_1, joint_words, windex)\\n\\t r2 = self.word_order_vector(words_2, joint_words, windex)\\n\\t return 1.0 - (np.linalg.norm(r1 - r2) / np.linalg.norm(r1 + r2))\",\n \"def get_phrase_embedding(phrase):\\r\\n \\r\\n vector = np.zeros([model.vector_size], dtype='float32')\\r\\n \\r\\n # 1. lowercase phrase\\r\\n phrase = phrase.lower()\\r\\n \\r\\n # 2. tokenize phrase\\r\\n phrase_tokens = tokenizer.tokenize(phrase)\\r\\n \\r\\n # 3. average word vectors for all words in tokenized phrase, skip words that are not in model's vocabulary\\r\\n divisor = 0\\r\\n for word in phrase_tokens:\\r\\n if word in model.vocab:\\r\\n divisor += 1\\r\\n vector = vector + model.get_vector(word)\\r\\n \\r\\n if divisor != 0: vector /= divisor\\r\\n \\r\\n return vector\",\n \"def embedding_train(total_corpus,emoteonly_corpus,textonly_corpus,save_fname_emote,save_fname_text,save_fname_intersect):\\n wv_model = Word2Vec(min_count=100,size=100,negative=0.75,sg=0,hs=1,window=60)\\n wv_model.build_vocab(sentences=total_corpus())\\n wv_model2 = copy.deepcopy(wv_model)\\n \\n # train emoteonly\\n wv_model.train(sentences=emoteonly_corpus(),epochs=10,total_examples=wv_model.corpus_count)\\n wv_model.save(save_fname_emote)\\n # train_textonly\\n wv_model2.train(sentences=textonly_corpus(),epochs=10,total_examples=wv_model.corpus_count)\\n wv_model2.save(save_fname_text)\\n \\n src_model = Word2Vec.load(save_fname_emote)\\n dest_model = Word2Vec.load(save_fname_text)\\n \\n src_model.wv.save_word2vec_format(save_fname_intersect)\\n dest_model.intersect_word2vec_format(save_fname_intersect, lockf=1.0, binary=False)\\n\\n dest_model.train(sentences=train_corpus(), total_examples=dest_model.corpus_count, epochs=20)\\n dest_model.save(save_fname_intersect)\\n return\",\n \"def vectorize(sentence, embeddings, size_limit, ignore_case=False):\\n if ignore_case:\\n sentence = sentence.lower()\\n tokens = [w for w in sentence.strip().split() if w not in PUNCT]\\n tokens = tokens[:size_limit] # truncating sentence\\n\\n vectors = []\\n for t in tokens:\\n if t in embeddings:\\n vectors.append(embeddings[t])\\n else: # OOV word\\n random_vector = np.random.uniform(-0.25, 0.25,\\n size=embeddings.dimension)\\n vectors.append(random_vector)\\n vectorized = np.array(vectors).T # dimension lines x len(tokens) columns\\n return vectorized\",\n \"def _get_emb(self, w2v):\\n toks = tokenizer(self.opn.lower()) + tokenizer(self.asp.lower())\\n self.is_valid = len(toks) > 0\\n if not self.is_valid:\\n return None\\n embs = torch.stack([self._get_tok_emb(tok, w2v) for tok in toks], dim=0)\\n return torch.mean(embs, dim=0)\",\n \"def vectorize_tweet(tweet):\\n tweet_vector = np.zeros(100)\\n for word in tokenize(tweet.text):\\n if word in word2vec.wv.vocab:\\n tweet_vector = tweet_vector + word2vec[word]\\n\\n components = pca.transform(tweet_vector)\\n x = components[0, 0]\\n y = components[0, 1]\\n\\n return str(x), str(y)\",\n \"def compute_paraphrase_vector(w1, w2, paraphrase, model, word2index, UNK):\\n paraphrase = paraphrase.replace(w1, '[w1]').replace(w2, '[w2]')\\n par_indices = tuple([word2index.get(w, UNK) for w in paraphrase.split()])\\n return model.__compute_state__(par_indices, -1).npvalue()\",\n \"def merge_vocabs(vocabs, min_freq=0, vocab_size=None):\\n merged = Counter()\\n for vocab in vocabs:\\n merged += filter_counter(vocab.freqs, min_freq)\\n return torchtext.vocab.Vocab(merged,\\n specials=list(special_token_list),\\n max_size=vocab_size, min_freq=min_freq)\",\n \"def embed(self, loader, model):\\n print(\\\" ** Embedding words\\\")\\n\\n words = loader.words\\n vectors = [model.get_word_vector(word) for word in words]\\n\\n return [(w, *v) for w, v in zip(words, vectors)]\",\n \"def average_reviews_similarity(user1, user2):\\n similarities = []\\n for u1_reviews in user1.values():\\n for u2_reviews in user2.values():\\n for u1_review in u1_reviews:\\n for u2_review in u2_reviews:\\n review_similarity = similarity(u1_review['text'], u2_review['text'])\\n similarities.append(review_similarity)\\n average = sum(similarities, 0.0) / len(similarities)\\n return average\",\n \"def generate_similar_sentences(sentence,w2v,percentage_to_replace=1,max_syn=10,num_outputs=50):\\n\\n list_of_sentences = []\\n\\n words = pairwise_tokenize(sentence,w2v,remove_stopwords=False) #This has combined any compound words found in word2vec\\n\\n #if word contains underscore don't sub in synonyms\\n dont_sub_idx = []\\n compound_word_idx = []\\n deleted_idx = []\\n for idx,word in enumerate(words):\\n if \\\"_\\\" in word or word in stopwords.words('english'):\\n dont_sub_idx.append(idx)\\n if \\\"_\\\" in word:\\n compound_word_idx.append(idx)\\n deleted_idx.append(idx+1)\\n if not word:\\n dont_sub_idx.append(idx)\\n\\n pattern = re.compile('[\\\\W_]+') \\n sentence = pattern.sub(\\\" \\\",sentence).lower().strip()\\n tagged = pos_tag(sentence.split(\\\" \\\")) #Pos_tag needs to use the original sentence to tag parts of speech, we will now delete indices that correspond to words that no longer exist b/c of compound\\n \\n for idx in reversed(compound_word_idx):\\n tagged.pop(idx+1)\\n \\n for tag in tagged:\\n if tag[1] == 'NNP':\\n dont_sub_idx.append(idx)\\n \\n for i in xrange(num_outputs):\\n new_words = words\\n mask = np.random.random_sample(len(words))\\n for j in xrange(len(words)):\\n if mask[j] < .5 and j not in dont_sub_idx:\\n pos = wordnet_pos_code(tagged[j][1])\\n synonyms = get_synonyms(words[j],w2v,pos,max=max_syn)\\n if len(synonyms) != 0:\\n new_words[j] = synonyms[np.random.randint(0,min(max_syn,len(synonyms)))]\\n list_of_sentences.append(\\\" \\\".join(new_words))\\n\\n list_of_sentences = set(list_of_sentences)\\n return list(list_of_sentences)\",\n \"def _compute_span_pair_embeddings(top_span_embeddings: torch.FloatTensor):\\n # Shape: (batch_size, num_spans_to_keep, num_spans_to_keep, embedding_size)\\n num_candidates = top_span_embeddings.size(1)\\n\\n embeddings_1_expanded = top_span_embeddings.unsqueeze(2)\\n embeddings_1_tiled = embeddings_1_expanded.repeat(1, 1, num_candidates, 1)\\n\\n embeddings_2_expanded = top_span_embeddings.unsqueeze(1)\\n embeddings_2_tiled = embeddings_2_expanded.repeat(1, num_candidates, 1, 1)\\n\\n similarity_embeddings = embeddings_1_expanded * embeddings_2_expanded\\n\\n pair_embeddings_list = [embeddings_1_tiled, embeddings_2_tiled, similarity_embeddings]\\n pair_embeddings = torch.cat(pair_embeddings_list, dim=3)\\n\\n return pair_embeddings\",\n \"def vectorize_text(text):\\n\\n def remove_punctuation(text):\\n \\\"\\\"\\\"Removes special characters from text.\\\"\\\"\\\"\\n return re.sub('[,.?\\\";:\\\\-!@#$%^&*()]', '', text)\\n\\n def remove_common_words(text_vector):\\n \\\"\\\"\\\"Removes 50 most common words in the uk english.\\n\\n source: http://www.bckelk.ukfsn.org/words/uk1000n.html\\n\\n \\\"\\\"\\\"\\n common_words = set(['the', 'and', 'to', 'of', 'a', 'I', 'in', 'was',\\n 'he', 'that', 'it', 'his', 'her', 'you', 'as', 'had', 'with',\\n 'for', 'she', 'not', 'at', 'but', 'be', 'my', 'on', 'have', 'him',\\n 'is', 'said', 'me', 'which', 'by', 'so', 'this', 'all', 'from',\\n 'they', 'no', 'were', 'if', 'would', 'or', 'when', 'what', 'there',\\n 'been', 'one', 'could', 'very', 'an', 'who'])\\n return [word for word in text_vector if word not in common_words]\\n\\n text = text.lower()\\n text = remove_punctuation(text)\\n words_list = text.split()\\n words_list = remove_common_words(words_list)\\n\\n return words_list\",\n \"def get_wordpiece_embeddings(og_index, tt, token_embeddings):\\n still_oov = True\\n index = og_index + 1\\n while still_oov:\\n token = tt[index]\\n if \\\"##\\\" not in token:\\n break\\n index += 1\\n # Final set of embeddings\\n emb = token_embeddings[og_index:index]\\n # return mean across each token (should be (NUM_LAYER, NUM_UNITS) matrix)\\n return emb.mean(dim = 0)\",\n \"def getGloveoCosineSimilarity(question1, question2):\\n questions = [question1, question2]\\n\\n ## for the sentences we need to get the count vectors\\n vec = CountVectorizer(max_features=5000, stop_words=None,binary=True)\\n count_vectors = vec.fit_transform(questions)\\n\\n ## get the vocabulary of words from the questions\\n vocab_index = vec.vocabulary_\\n\\n ## get the index of the words and embeddings\\n index_word = {v:k for k, v in vocab_index.items()}\\n\\n ## get the question vectors\\n question_vectors = np.zeros((count_vectors.shape[0], 300))\\n\\n ## iterate through count vectors for each word get the embeddings\\n ## for each embedding, we will then average by the number of words\\n ## this will be then used for cosine similarity\\n for i in range(count_vectors.shape[0]):\\n row = count_vectors[i, :].toarray()\\n word_ids = np.where(row > 0)[1]\\n word_counts = row[:, word_ids][0]\\n numWords = np.sum(word_counts)\\n\\n ## if there are no words, continue\\n if numWords == 0:\\n continue\\n\\n ## initialize the word embeddings to 0\\n word_embeddings = np.zeros((word_ids.shape[0], 300))\\n\\n ## update the word embeddings\\n for j in range(word_ids.shape[0]):\\n word_id = word_ids[j]\\n word_embeddings[j, :] = word_counts[j] * gloveDict[index_word[word_id]]\\n question_vectors[i, :] = np.sum(word_embeddings, axis=0) / numWords\\n\\n return(cosine_similarity(question_vectors[0], question_vectors[1])[0][0])\",\n \"def count_words_and_dublicates(novel):\",\n \"def gen_embedding(text, model, tokenizer):\\n ### Tokenize the texts\\n encoded_input = tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors='pt')\\n \\n ### Encode the tokenized data with model\\n with torch.no_grad():\\n model_output = model(**encoded_input)\\n \\n ### Pool the outputs into a single vector\\n sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])\\n return sentence_embeddings\",\n \"def align_vocabs(emb_model, tokenizer):\\n hi_emb = emb_model['hi']\\n logger.info(hi_emb.shape)\\n total_unk = 0\\n nmax = max(tokenizer.vocab.idx2word.keys()) + 1\\n word_matrix = torch.zeros(nmax, hi_emb.shape[-1])\\n logger.info(word_matrix.shape)\\n\\n for k, v in tqdm(tokenizer.vocab.idx2word.items(), total=len(tokenizer)):\\n try:\\n word_matrix[k] = torch.tensor(emb_model[v])\\n except KeyError:\\n word_matrix[k] = emb_model['<unk>']\\n total_unk += 1\\n return word_matrix, total_unk\",\n \"def get_word_containement_measure(self,l2,l1):\\n count = 0\\n found_idfs = []\\n unfound_idfs = []\\n word_count_dict = self.list_to_word_count_dict(l1)\\n for w in l2:\\n was_found = False\\n val = self.idf.get_tfidf_val(w)\\n if (val > 10):\\n val = 10\\n for i,w2 in enumerate(l1):\\n if (w2 == w and word_count_dict[(w2,i)] == 0):\\n word_count_dict[(w2,i)] = 1\\n count += 1\\n found_idfs.append(val)\\n was_found = True\\n break\\n if (was_found):\\n unfound_idfs.append(val)\\n if (len(found_idfs) == 0):\\n avg_found = 0\\n else:\\n avg_found = np.mean(found_idfs)\\n if (len(unfound_idfs) ==0):\\n avg_unfound = 0\\n else:\\n avg_unfound = np.mean(unfound_idfs)\\n\\n # full idf features\\n unfound_vec = list(sorted(unfound_idfs, reverse=True))\\n found_vec = list(sorted(found_idfs, reverse=True))\\n unfound_vec = self.pad_or_cut_vec(unfound_vec, self.LENGTH_MAX)\\n found_vec = self.pad_or_cut_vec(found_vec, self.LENGTH_MAX)\\n\\n return count , avg_found, avg_unfound, found_vec, unfound_vec\",\n \"def word_overlap_phi(t1, t2):\\n overlap = set([w1 for w1 in t1.leaves() if w1 in t2.leaves()])\\n return Counter(overlap)\",\n \"def _merge_main_context(self, W, merge_fun=lambda m, c: np.mean([m, c], axis=0),\\n normalize=True):\\n\\n vocab_size = int(len(W) / 2)\\n for i, row in enumerate(W[:vocab_size]):\\n merged = merge_fun(row, W[i + vocab_size])\\n if normalize:\\n merged /= np.linalg.norm(merged)\\n W[i, :] = merged\\n\\n return W[:vocab_size]\",\n \"def naiveBayes(self, vector):\\n \\n # Find product of all Unigram and Bigram probabilities, which are already converted to log probabilities\\n value = 0 \\n for word1 in vector.words.iterkeys():\\n unigram, unigramExists = self.getUnigram(word1)\\n if unigramExists:\\n value += self.words[word1].probability\\n else:\\n # Use add one smoothing for unseen events, P(unseen) = 1 / (numSeenInstances + sizeVocab) \\n value += math.log(1 / (self.numTokens + len(self.words)), 2)\\n for word2 in vector.words[word1].bigrams.iterkeys():\\n bigram, bigramExists = self.getBigram(word1, word2) \\n if bigramExists:\\n value += self.words[word1].bigrams[word2].probability\\n else:\\n # Use add one smoothing for unseen events, P(unseen) = 1 / (numSeenInstances + sizeVocab)\\n count = 0 \\n if word1 in self.words:\\n count = self.words[word1].count \\n else:\\n count = 1 \\n value += math.log(1 / (count + len(self.words)), 2)\\n \\n return value\",\n \"def split(self, mapping, ignore_exact=True):\\n\\n source_oov = defaultdict(lambda: 0)\\n target_oov = defaultdict(lambda: 0)\\n w_exact = defaultdict(lambda: 0)\\n\\n source_words = []\\n target_words = []\\n map_ = mapping.map\\n for w, id_ in self.word_id.iteritems():\\n if w not in map_:\\n source_oov[w] += 1\\n continue\\n\\n if map_[w] not in self.word_id:\\n target_oov[map_[w]] += 1\\n continue\\n\\n if w.lower() == map_[w].lower():\\n w_exact[w] += 1\\n if ignore_exact:\\n continue\\n\\n source_words.append(w)\\n target_words.append(map_[w])\\n\\n logging.debug(\\\"We could not find {} source words in our dictionary.\\\".format(\\n len(source_oov)))\\n logging.debug(\\\"We could not find {} target words in our target words.\\\".format(\\n len(target_oov)))\\n logging.debug(\\\"{} words are exact between languages\\\".format(len(w_exact)))\\n logging.debug(\\\"We found {} pairs of words valid for testing.\\\".format(len(source_words)))\\n\\n new_s_vectors = asarray([self.vectors[self.word_id[w]] for w in source_words])\\n source = Embeddings(vectors=new_s_vectors, words=source_words,\\n lang=mapping.s_lang)\\n\\n new_t_vectors = asarray([self.vectors[self.word_id[w]] for w in target_words])\\n target = Embeddings(vectors=new_t_vectors, words=target_words,\\n lang=mapping.t_lang)\\n new_mapping = Mapping(source=mapping.s_lang, target=mapping.t_lang)\\n new_mapping.map = dict(zip(source.words, target.words))\\n return (source, target, new_mapping)\",\n \"def distance_unigrams_same(t1, t2):\\n t1_terms = make_terms_from_string(t1)\\n t2_terms = make_terms_from_string(t2)\\n terms1 = set(t1_terms)\\n terms2 = set(t2_terms)\\n shared_terms = terms1.intersection(terms2)\\n #print(shared_terms)\\n all_terms = terms1.union(terms2)\\n #print(all_terms)\\n dist = 1.0 - (len(shared_terms) / float(len(all_terms)))\\n return dist\",\n \"def question_to_vec(question, embeddings, dim):\\r\\n\\r\\n words = question.split()\\r\\n\\r\\n counter = 0\\r\\n res = np.zeros(dim)\\r\\n for word in words:\\r\\n if word in embeddings:\\r\\n res += np.array(embeddings[word])\\r\\n counter += 1\\r\\n if counter!=0:\\r\\n return res/counter # mean of all word embeddings\\r\\n else:\\r\\n return res # vector of zeros\\r\",\n \"def processFeature(prevWord, word, vector):\\n \\n # We add feature whether it exists or not\\n unigram, exists = vector.getUnigram(prevWord)\\n if not exists:\\n vector.addUnigram(prevWord)\\n \\n \\n bigram, exists = vector.getBigram(prevWord, word)\\n if not exists:\\n vector.addBigram(prevWord, word)\",\n \"def embedding_similarity(model, validation_pairs):\\n scores = dict()\\n for pair in validation_pairs:\\n author1 = pair[0]\\n author2 = pair[1]\\n scores[author1 + ' ' +\\n author2] = cosine_similarity(model.wv[author1], model.wv[author2])\\n return scores\",\n \"def vectorize_sentence(sentence, model):\\n final_vec = np.zeros(300, )\\n count = 0\\n for word in sentence:\\n count += 1\\n dummy_vec = np.zeros(300, )\\n try:\\n temp_vec = get_vector(word, model)\\n final_vec += temp_vec\\n except:\\n final_vec += dummy_vec\\n return final_vec / count\",\n \"def object_similarity(obj_1, obj_2):\\n w_list = []\\n obj_1_bag_size = sum(obj_1['bag_of_words'].values())\\n obj_2_bag_size = sum(obj_2['bag_of_words'].values())\\n obj_1_set = obj_1['set_of_words']\\n obj_2_set = obj_2['set_of_words']\\n obj_1_diff_2_set = obj_1_set - obj_2_set\\n obj_2_diff_1_set = obj_2_set - obj_1_set\\n w_list.append(weight_calculator(obj_1_bag_size, obj_2_bag_size))\\n w_list.append(weight_calculator(len(obj_1_set), len(obj_2_set)))\\n w_list.append(weight_calculator(len(obj_1_diff_2_set),\\n len(obj_2_diff_1_set)))\\n if 'total_lines' in obj_1.keys() and 'total_lines' in obj_2.keys():\\n w_list.append(weight_calculator(obj_1['total_lines'],\\n obj_2['total_lines']))\\n if 'total_conversations' in obj_1.keys() and 'total_conversations' in obj_2.keys():\\n w_list.append(weight_calculator(obj_1['total_conversations'],\\n obj_2['total_conversations']))\\n # Added as observations of genre -> rating relations\\n if 'metadata' in obj_1.keys() and 'metadata' in obj_2.keys():\\n w_list.append(weight_calculator(eval(obj_1['metadata']['genres']),\\n eval(obj_2['metadata']['genres'])))\\n return mean(w_list)\",\n \"def common(self, other):\\n\\n common_words = []\\n for word in self.word_id:\\n if word in other.word_id:\\n common_words.append(word)\\n\\n new_self_vectors = []\\n new_other_vectors = []\\n for word in common_words:\\n new_self_vectors.append(self.vectors[self.word_id[word]])\\n new_other_vectors.append(other.vectors[other.word_id[word]])\\n\\n new_self = Embeddings(vectors=asarray(new_self_vectors), words=common_words,\\n lang=self.lang)\\n\\n new_other = Embeddings(vectors=asarray(new_other_vectors), words=common_words,\\n lang=self.lang)\\n\\n return (new_self, new_other)\",\n \"def weighted_overlap(topic_nasari_vector, paragraph_nasari_vector):\\n #function to get item rank in nasari dictionary as key index+1\\n item_rank = lambda item, nasari_dict: list(nasari_dict.keys()).index(item) + 1\\n \\n overlap_keys = list(topic_nasari_vector.keys() & paragraph_nasari_vector.keys())\\n\\n if len(overlap_keys) > 0:\\n # sum 1/(rank() + rank())\\n den = sum(1 / (item_rank(q, topic_nasari_vector) +\\n item_rank(q, paragraph_nasari_vector)) for q in overlap_keys)\\n # sum 1/(2*i), \\n num = sum(list(\\n map(lambda x: 1 / (2 * x),\\n list(range(1, len(overlap_keys) + 1)))))\\n return num/den\\n return 0\",\n \"def sentence_similarity(sentence1, sentence2):\\n sentence1 = sentence1.tags\\n sentence2 = sentence2.tags\\n \\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n \\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n \\n score, count = 0.0, 0\\n \\n for synset in synsets1:\\n \\n li=[synset.path_similarity(ss) for ss in synsets2]\\n m=0\\n for i in range(len(li)):\\n if li[i] is not None and m<li[i]:\\n m=li[i]\\n if m != 0:\\n score += m\\n count += 1\\n\\n if count is 0:\\n score = 0\\n else:\\n score /= count\\n return score\",\n \"def check_word_overlap(tag_1, tag_2):\\n position_tracker = 0\\n words_found = []\\n for t1 in tag_1:\\n for t2 in tag_2:\\n if t1 == t2:\\n words_found.append([t1,position_tracker])\\n position_tracker+=1\\n return [words_found, len(words_found)]\",\n \"def omnibus_embedding_pairwise(\\n graphs: List[NxGraphType],\\n dimensions: int = 100,\\n elbow_cut: Optional[int] = None,\\n svd_solver_algorithm: SvdAlgorithmType = \\\"randomized\\\",\\n svd_solver_iterations: int = 5,\\n svd_seed: Optional[int] = None,\\n weight_attribute: str = \\\"weight\\\",\\n use_laplacian: bool = False,\\n) -> List[Tuple[Embeddings, Embeddings]]:\\n check_argument(len(graphs) > 1, \\\"more than one graph is required\\\")\\n\\n check_argument(dimensions >= 1, \\\"dimensions must be positive\\\")\\n\\n check_argument(elbow_cut is None or elbow_cut >= 1, \\\"elbow_cut must be positive\\\")\\n\\n check_argument(\\n svd_solver_algorithm in __SVD_SOLVER_TYPES,\\n f\\\"svd_solver_algorithm must be one of the values in {','.join(__SVD_SOLVER_TYPES)}\\\",\\n )\\n\\n check_argument(svd_solver_iterations >= 1, \\\"svd_solver_iterations must be positive\\\")\\n\\n check_argument(\\n svd_seed is None or 0 <= svd_seed <= 2**32 - 1,\\n \\\"svd_seed must be a nonnegative, 32-bit integer\\\",\\n )\\n\\n used_weight_attribute = _graphs_precondition_checks(graphs, weight_attribute)\\n perform_augment_diagonal = not use_laplacian\\n\\n graph_embeddings = []\\n\\n # create a graph that contains all nodes and edges across the entire corpus\\n union_graph = graphs[0].copy()\\n for graph in graphs[1:]:\\n union_graph.add_edges_from(graph.edges())\\n\\n union_graph_lcc: Union[\\n nx.Graph, nx.Digraph, nx.OrderedGraph, nx.OrderedDiGraph\\n ] = largest_connected_component(union_graph)\\n union_graph_lcc_nodes: Set[Any] = set(list(union_graph_lcc.nodes()))\\n\\n union_node_ids = np.array(list(union_graph_lcc_nodes))\\n\\n previous_graph = graphs[0].copy()\\n\\n for graph in graphs[1:]:\\n current_graph = graph.copy()\\n\\n # assure both graphs contain the exact same node set\\n # by removing nodes or adding isolates as needed\\n _sync_nodes(previous_graph, union_graph_lcc_nodes)\\n _sync_nodes(current_graph, union_graph_lcc_nodes)\\n\\n # remove self loops, run pass to ranks and diagonal augmentation\\n previous_graph_augmented = _augment_graph(\\n previous_graph,\\n union_graph_lcc_nodes,\\n used_weight_attribute,\\n perform_augment_diagonal=perform_augment_diagonal,\\n )\\n current_graph_augmented = _augment_graph(\\n current_graph,\\n union_graph_lcc_nodes,\\n used_weight_attribute,\\n perform_augment_diagonal=perform_augment_diagonal,\\n )\\n\\n model = OmnibusEmbed(\\n n_components=dimensions,\\n n_elbows=None, # we will do elbow cuts\\n algorithm=svd_solver_algorithm,\\n n_iter=svd_solver_iterations,\\n check_lcc=False,\\n diag_aug=False,\\n concat=False,\\n svd_seed=svd_seed,\\n lse=use_laplacian,\\n )\\n\\n previous_embedding, current_embedding = model.fit_transform(\\n graphs=[previous_graph_augmented, current_graph_augmented]\\n )\\n\\n previous_embedding_cut = _elbow_cut_if_needed(\\n elbow_cut, graph.is_directed(), model.singular_values_, previous_embedding\\n )\\n\\n current_embedding_cut = _elbow_cut_if_needed(\\n elbow_cut, graph.is_directed(), model.singular_values_, current_embedding\\n )\\n\\n graph_embeddings.append(\\n (\\n Embeddings(union_node_ids, previous_embedding_cut),\\n Embeddings(union_node_ids, current_embedding_cut),\\n )\\n )\\n\\n return graph_embeddings\",\n \"def pairwise_tokenize(sentence,w2v,remove_stopwords=True):\\n\\n ignore_words = stopwords.words('english')\\n\\n #Remove non-alphanumeric\\n pattern = re.compile('[\\\\W_]+') \\n sentence = pattern.sub(\\\" \\\",sentence) \\n sentence = sentence.strip()\\n words = sentence.split(\\\" \\\")\\n\\n compound_word_idx = []\\n a_idx = 0\\n for a,b in pairwise(words):\\n combined = a +\\\"_\\\" + b\\n try:\\n w2v[combined]\\n compound_word_idx.append(a_idx) #append the index of the 1st compound word\\n a_idx += 1\\n except KeyError:\\n a_idx += 1\\n\\n for idx in compound_word_idx:\\n words[idx] = words[idx] + \\\"_\\\" + words[idx + 1] #compound_word_idx stores index of 1st word, so combine with the next word\\n\\n #This cannot be combined into another loop to maintain where indices point\\n for idx in reversed(compound_word_idx):\\n words.pop(idx+1)\\n\\n if remove_stopwords == True:\\n filtered = []\\n for word in words:\\n word = word.decode(\\\"utf-8\\\")\\n if word not in ignore_words:\\n filtered.append(word)\\n\\n words = filtered\\n\\n return words\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70063585","0.65691555","0.655092","0.65492266","0.64220226","0.63821906","0.6352523","0.63278","0.6304237","0.63029516","0.6285422","0.6161037","0.61082405","0.60827434","0.6066551","0.605643","0.60406655","0.6036333","0.6034815","0.60307336","0.6029545","0.6025003","0.6024141","0.6010553","0.59977245","0.59737885","0.5970411","0.594383","0.5856881","0.58322346","0.5808924","0.5794871","0.57935596","0.5774813","0.575068","0.5746622","0.57129246","0.57004946","0.5682775","0.56707203","0.56616753","0.5659284","0.56433994","0.5642209","0.56386596","0.5631953","0.56187755","0.5586622","0.5585827","0.55786836","0.55741704","0.55741704","0.557123","0.5570769","0.55698603","0.5569657","0.5539941","0.5536616","0.5529745","0.5526523","0.5521284","0.5514266","0.5501569","0.54837465","0.5469052","0.54511374","0.5448486","0.5444392","0.54384774","0.54373723","0.54360664","0.54332304","0.54314697","0.54162383","0.54107505","0.5410366","0.54059833","0.53987485","0.53964084","0.5394892","0.5390398","0.5382161","0.536403","0.5359054","0.5355572","0.53533316","0.5352982","0.5346973","0.53454447","0.53443366","0.5341348","0.5336298","0.53285944","0.53223693","0.53203744","0.531262","0.5308109","0.53015625","0.530117","0.5300474"],"string":"[\n \"0.70063585\",\n \"0.65691555\",\n \"0.655092\",\n \"0.65492266\",\n \"0.64220226\",\n \"0.63821906\",\n \"0.6352523\",\n \"0.63278\",\n \"0.6304237\",\n \"0.63029516\",\n \"0.6285422\",\n \"0.6161037\",\n \"0.61082405\",\n \"0.60827434\",\n \"0.6066551\",\n \"0.605643\",\n \"0.60406655\",\n \"0.6036333\",\n \"0.6034815\",\n \"0.60307336\",\n \"0.6029545\",\n \"0.6025003\",\n \"0.6024141\",\n \"0.6010553\",\n \"0.59977245\",\n \"0.59737885\",\n \"0.5970411\",\n \"0.594383\",\n \"0.5856881\",\n \"0.58322346\",\n \"0.5808924\",\n \"0.5794871\",\n \"0.57935596\",\n \"0.5774813\",\n \"0.575068\",\n \"0.5746622\",\n \"0.57129246\",\n \"0.57004946\",\n \"0.5682775\",\n \"0.56707203\",\n \"0.56616753\",\n \"0.5659284\",\n \"0.56433994\",\n \"0.5642209\",\n \"0.56386596\",\n \"0.5631953\",\n \"0.56187755\",\n \"0.5586622\",\n \"0.5585827\",\n \"0.55786836\",\n \"0.55741704\",\n \"0.55741704\",\n \"0.557123\",\n \"0.5570769\",\n \"0.55698603\",\n \"0.5569657\",\n \"0.5539941\",\n \"0.5536616\",\n \"0.5529745\",\n \"0.5526523\",\n \"0.5521284\",\n \"0.5514266\",\n \"0.5501569\",\n \"0.54837465\",\n \"0.5469052\",\n \"0.54511374\",\n \"0.5448486\",\n \"0.5444392\",\n \"0.54384774\",\n \"0.54373723\",\n \"0.54360664\",\n \"0.54332304\",\n \"0.54314697\",\n \"0.54162383\",\n \"0.54107505\",\n \"0.5410366\",\n \"0.54059833\",\n \"0.53987485\",\n \"0.53964084\",\n \"0.5394892\",\n \"0.5390398\",\n \"0.5382161\",\n \"0.536403\",\n \"0.5359054\",\n \"0.5355572\",\n \"0.53533316\",\n \"0.5352982\",\n \"0.5346973\",\n \"0.53454447\",\n \"0.53443366\",\n \"0.5341348\",\n \"0.5336298\",\n \"0.53285944\",\n \"0.53223693\",\n \"0.53203744\",\n \"0.531262\",\n \"0.5308109\",\n \"0.53015625\",\n \"0.530117\",\n \"0.5300474\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68158096"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84897,"cells":{"query":{"kind":"string","value":"Adds unknown token to word2idx dictionary and computes vector as an average of random sample as suggested by Pennington"},"document":{"kind":"string","value":"def add_unknown_token(self):\n self.load_all()\n sample_idxs = np.random.randint(0, self.embedding.shape[0],\n self.config.embedding_sample_size)\n unknown_vector = np.mean(self.embedding[sample_idxs, :], axis=0)\n\n self.add_embedding(self.config.unknown_token, unknown_vector)\n self.write_all()"},"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_average_vec(tokens_list, vector, generate_missing=False, k=300):\r\n if len(tokens_list)<1:\r\n return np.zeros(k)\r\n \r\n if generate_missing:\r\n vectorized = [vector[word] if word in vector else np.random.rand(k) for word in tokens_list]\r\n else:\r\n vectorized = [vector[word] if word in vector else np.zeros(k) for word in tokens_list]\r\n \r\n length = len(vectorized)\r\n summed = np.sum(vectorized, axis=0)\r\n averaged = np.divide(summed, length)\r\n return averaged","def add_to_dict(self, tokens):\n# TODO: ?add normalization of a token?\n for token in tokens:\n if self.embedding_words and (token not in self.embedding_words):\n continue\n self.freq[token] += 1\n if token not in self.tok2ind:\n index = len(self.tok2ind)\n self.tok2ind[token] = index\n self.ind2tok[index] = token","def avg_sentence_vector(words, model, num_features, index2word_set):\n featureVec = np.zeros((num_features,), dtype=\"float32\")\n nwords = 0\n\n for word in words:\n if word in index2word_set:\n nwords = nwords+1\n featureVec = np.add(featureVec, model.wv[word])\n # featureVec = np.add(featureVec, model.wv.__getitem__(word))\n\n if nwords>0:\n featureVec = np.divide(featureVec, nwords)\n return featureVec","def add_word(self, word, vector=None, low=-2., high=2.):\n if word not in self.w2v_idx:\n self.w2v_idx[word] = len(self.w2v_idx)\n if vector is None:\n vector = np.random.uniform(low=low, high=high, size=(self.w2v_dim,))\n self.w2v_out.append(np.asarray(vector, dtype=np.float32))\n else:\n print(\"word %s already in this word2vec\" % word)","def average_one_hots(sent, word_to_ind):\n known_words = 0\n size = len(word_to_ind.keys())\n sum_vec = np.zeros((size,))\n for token in sent.text: #going over all tokens and summing their embeddings\n if (token in word_to_ind):\n sum_vec += get_one_hot(size, word_to_ind[token])\n known_words += 1\n if (known_words != 0):\n return sum_vec / known_words\n else:\n return sum_vec","def add_unknown_words(word_vecs, vocab, min_df=1, k=300, unk_token=UNK_TOKEN):\n for word in vocab:\n if word not in word_vecs and vocab[word] >= min_df:\n word_vecs[word] = uniform_sample(-0.25,0.25,k) \n word_vecs[unk_token] = uniform_sample(-0.25,0.25,k)","def index_word(self, token):\n if token not in self.word_2_idx:\n idx = len(self.word_2_idx)\n self.word_2_idx[token] = idx\n self.idx_2_word[idx] = token","def random_init_certain_vector(vocab, token='<unk>', mean=0, std=0.5):\n idx = vocab.stoi[token]\n nn.init.normal_(vocab.vectors[idx], mean=mean, std=std)","def add_unknown_words(word_vecs, vocab, k=300):\n for word in vocab:\n if word not in word_vecs:\n word_vecs[word] = np.random.uniform(-1.0, 1.0, k)","def add_unknown_words(word_vecs, vocab, min_df=5000, k=300):\n for word in vocab:\n if word not in word_vecs and vocab[word] >= min_df:\n #print word\n word_vecs[word] = np.random.uniform(-0.25,0.25,k)","def add_unknown_words(word_vecs, vocab, min_df=1, dim=300):\n k=0\n for w in vocab:\n if w not in word_vecs:\n word_vecs[w]=np.asarray(np.random.uniform(-0.25,0.25,dim),dtype=np.float32)\n k+=1\n if k % 10000==0:\n print (\"add_unknow_words %d\" % k)\n return word_vecs","def get_sentence_average_w2v(sent, word_to_vec, embedding_dim):\n sum_vec = np.zeros((embedding_dim,))\n known_tokens = 0\n for token in sent.text:\n if (token in word_to_vec.dict):\n known_tokens += 1\n sum_vec += word_to_vec[token]\n if (known_tokens != 0):\n return sum_vec / known_tokens\n else:\n return sum_vec","def generate_avg_vector(self, data):\r\n doc=nlp(data)\r\n data_vector = [token.vector for token in doc]\r\n mean_vector = np.mean(data_vector, axis=0)\r\n return mean_vector","def sentence_to_avg(sentence, word_to_vec_map):\n # Get a valid word contained in the word_to_vec_map. \n any_word = list(word_to_vec_map.keys())[0]\n \n ### START CODE HERE ###\n # Step 1: Split sentence into list of lower case words (≈ 1 line)\n words = sentence.lower().split()\n\n # Initialize the average word vector, should have the same shape as your word vectors.\n avg = np.zeros(word_to_vec_map[any_word].shape)\n \n # Initialize count to 0\n count = 0\n \n # Step 2: average the word vectors. You can loop over the words in the list \"words\".\n for w in words:\n # Check that word exists in word_to_vec_map\n if w in word_to_vec_map:\n avg += word_to_vec_map[w]\n # Increment count\n count +=1\n \n if count > 0:\n # Get the average. But only if count > 0\n avg = avg / count\n \n ### END CODE HERE ###\n \n return avg","def _add_word(self, word):\n if not word in self._word2idx.keys():\n self._word2idx[word] = self.vocab_size\n self.freqs[word] = 0\n self._idx2word[self.vocab_size] = word\n self.vocab_size += 1\n self.freqs[word] += 1","def add_unknown_words(word_vecs, vocab, min_df=1, k=200):\n for word in vocab:\n if word not in word_vecs and vocab[word] >= min_df:\n word_vecs[word] = np.random.uniform(-0.25,0.25,k)","def word_analogy(self):\n data = open(\"data/word_analogy_subset.en.ar.txt\").read().split('\\n')\n data = [x for x in data if len(x.split()) == 4]\n cnt = 0\n keys = list(self.embeddings_index.keys())\n vectors = np.array(list(self.embeddings_index.values()))\n norms = np.linalg.norm(vectors, axis=1)\n for i in data:\n i = self.preprocessor(i).split()\n try:\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\n except:\n continue\n unit = v / np.linalg.norm(v)\n dists = np.dot(vectors, unit) / norms\n best = np.argpartition(-dists, 10)[:10 + 1]\n best = best.take(np.argsort((-dists).take(best)))\n result = [(keys[sim], float(dists[sim]))\n for sim in best]\n sbv = result[:10]\n for j in sbv:\n if j[0] == i[3]:\n cnt += 1\n return cnt/ len(data)","def add_unknown_words(word_vecs, vocab, min_df=10, k=300):\n for word in vocab:\n if word not in word_vecs and vocab[word] >= min_df:\n word_vecs[word] = np.random.uniform(-0.25, 0.25, k)","def _look_up(self, token):\n if self.args.add_vn:\n return tf.nn.embedding_lookup(self.embedding_matrix + \\\n tf.random.normal(tf.shape(self.embedding_matrix), stddev=0.075), token)\n\n return tf.nn.embedding_lookup(self.embedding_matrix, token)","def _sample_token(self, token):\n dist = tf.distributions.Categorical(logits=token)\n sampled_token = dist.sample(int(1))[0]\n\n return self._look_up(sampled_token)","def add_unknown_words(word_vecs, vocab, min_df=1, k=300):\n for word in vocab:\n if word not in word_vecs and vocab[word] >= min_df:\n word_vecs[word] = np.random.uniform(-0.25, 0.25, k)","def add_unknown_words(word_vecs, vocab, min_df=1, k=300):\n for word in vocab:\n if word not in word_vecs and vocab[word] >= min_df:\n word_vecs[word] = np.random.uniform(-0.25, 0.25, k)","def add_unknown_words(word_vecs, vocab, min_df=1, k=100):\n for word in vocab:\n if word not in word_vecs and vocab[word] >= min_df:\n # print(\"************************\")\n # print(word)\n # print(\"************************\")\n word_vecs[word] = np.random.uniform(-0.25,0.25,k)","def make_bow_vector(query_tokens, words_to_idx):\n bow_vec = torch.zeros(len(words_to_idx), dtype=torch.float)\n\n for tokens in query_tokens:\n if tokens not in words_to_idx:\n tokens = \"unk\"\n bow_vec[words_to_idx[tokens]] += 1\n else:\n bow_vec[words_to_idx[tokens]] += 1\n\n return bow_vec","def add_unknown_words(self, word_vecs, vocab, min_df=3, k=300):\n for word in vocab:\n if word not in word_vecs and vocab[word] >= min_df:\n word_vecs[word] = np.random.uniform(-0.25,0.25,k)","def index_new_tweet(self, id_str, tweet_tokens: list):\n self.tweet_count += 1\n unique_words = set(tweet_tokens)\n unique_word_pairs = set()\n for i in unique_words:\n for j in unique_words - {i}:\n # To us [a, b] = [b, a], and sorting gives us a distinct representation.\n unique_word_pairs.add(tuple(sorted([i, j])))\n for w in unique_words | unique_word_pairs:\n self.index[self.epoch][w] = id_str\n current_freq = self.frequency_map.get(w, 0)\n self.frequency_map[w] = current_freq + 1\n # Get word statistics from hash table\n statistics_present = w in self.stats_map\n if not statistics_present:\n (mu, sigma) = (math.inf, math.inf)\n for h in self.hash_functions:\n c = get_hash(h(), repr(w)) % 2 ** self.bit_count\n if self.buckets[c][\"ewma\"] < mu:\n mu = self.buckets[c][\"ewma\"]\n sigma = self.buckets[c][\"ewmvar\"]\n self.stats_map[w] = (mu, sigma)\n (mu, sigma) = self.stats_map[w]\n # Test for significance threshold\n x = self.frequency_map[w]\n if self._is_frequency_significant(mu, sigma, x):\n self.refinement.append((w, self._get_significance(mu, sigma, x)))\n # if self.refinement:\n # r = self.refinement\n # self.refinement = []\n # return r","def compute_avg_w2v_vector(w2v_dict, text_nlp_proc):\n SIZE = 50 # size of the w2v dimension\n list_of_word_vectors = [w2v_dict[w] for w in text_nlp_proc if w in w2v_dict.vocab.keys()]\n if len(list_of_word_vectors) == 0:\n result = [0.0]*SIZE\n else:\n result = np.sum(list_of_word_vectors, axis=0) / len(list_of_word_vectors)\n return result","def average_word_vector(vectorfile, outvectorfile):\n\twith codecs.open(vectorfile, encoding='utf-8', mode='r') as infile:\n\t\twith codecs.open(outvectorfile, encoding='utf-8', mode='a+') as outfile:\n\t\t\tfor i, line in enumerate(infile):\n\t\t\t\tprint i\n\t\t\t\tif i == 0:\n\t\t\t\t\ta, b, c = map(int, line.split()[:3])\n\t\t\t\t\tprint('Number of sememes: {}\\n'\n\t\t\t\t\t\t 'Number of words: {}\\n'\n\t\t\t\t\t\t 'Dimension of vectors: {}'.format(a, b, c))\n\t\t\t\t\toutfile.write(str(b) + ' ' + str(c) + '\\n')\n\t\t\t\telif i > 462667:\n\t\t\t\t\toutfile.write(line)\n\t\t\t\telse:\n\t\t\t\t\tsline = line.split()\n\t\t\t\t\tword = sline[0]\n\t\t\t\t\tsense_num = int(sline[1])\n\t\t\t\t\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\n\t\t\t\t\t# extra = len(vectors) % sense_num\n\t\t\t\t\tvector_list = []\n\t\t\t\t\tfor start in range(0, len(vectors), c):\n\t\t\t\t\t\tvector_list.append(list(map(float, vectors[start: start+c])))\n\t\t\t\t\t# print vector_list\n\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\tvector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t# print np.array2string(vector_mean, max_line_width=200, formatter={'float_kind': lambda x: '%6f'%x})[1:-1].strip('\\n')\n\t\t\t\t\tnew_line = word + ' ' + np.array2string(vector_mean, max_line_width=2000, formatter={'float_kind': lambda x: '%6f'%x})[1:-1] + '\\n'\n\t\t\t\t\toutfile.write(new_line)","def newInternal(word, deflike):\n\n avedeflike = 0\n denom = len(word)\n for indices, f in fqs(word, 0.5):\n context, numer = internalContext(indices, word)\n if deflike[context]:\n avedeflike += numer/denom * f * deflike[context]\n return avedeflike","def embed(raw_seq, index_dict):\n return np.asarray([index_dict[word.lower()]\n if word.lower() in index_dict\n else index_dict[OOV_TOKEN] for word in raw_seq])","def word_averaging(wv, words):\n all_words, mean = set(), []\n \n for word in words:\n if isinstance(word, np.ndarray):\n mean.append(word)\n elif word in wv.vocab:\n mean.append(wv.vectors_norm[wv.vocab[word].index])\n all_words.add(wv.vocab[word].index)\n\n if not mean:\n logging.warning(\"Cannot compute similarity with no input: %s\", words)\n # Remove these examples in pre-processing...\n return np.zeros(50,)\n\n mean = gensim.matutils.unitvec(np.array(mean).mean(axis=0)).astype(np.float32)\n \n return mean","def lookup(doc, wv):\n checked = []\n for word in doc:\n try:\n word in wv\n except KeyError:\n log.warning(\"Word not in model: %s\", word)\n continue\n checked.append(wv[word])\n vec = np.mean(checked, axis=0)\n return vec","def create_embedding_matrix(self):\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\n vocab_size = len(self.vocab)\n result = np.zeros((vocab_size, self.embed_dim))\n unknown_token_set = set()\n\n found_words = 0\n avg = np.zeros(self.embed_dim)\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\n try:\n result[_] = self.pretrained_embedding[self.id2word[_]]\n avg += result[_]\n found_words += 1\n except:\n unknown_token_set.add(_)\n\n avg /= found_words\n for _ in unknown_token_set:\n result[_] = avg\n self.embedding = result\n return found_words, len(self.id2word)","def imp(term,word_dict,number_of_docs,id):\n\n with open('term_freq.txt', 'rb') as file:\n term_freq = pickle.loads(file.read())\n\n #print(term_freq)\n\n if id+1 in term_freq[term]:\n #print(term_freq[term][id])\n return term_freq[term][id+1]*word_dict[term][1]#idf(term,number_of_docs,index_list)\n else:\n return 0.0","def random_word(tokens, tokenizer, word_mask_rate=0.15):\n output_label = []\n\n for i, token in enumerate(tokens):\n\n prob = random.random()\n\n if prob < word_mask_rate:\n prob /= word_mask_rate\n \n # 80% randomly change token to mask token\n if prob < 0.8:\n tokens[i] = \"[MASK]\"\n\n # 10% randomly change token to random token\n elif prob < 0.9:\n tokens[i] = random.choice(list(tokenizer.vocab.items()))[0]\n\n # -> rest 10% randomly keep current token\n\n # append current token to output (we will predict these later)\n try:\n output_label.append(tokenizer.vocab[token])\n except KeyError:\n # For unknown words (should not occur with BPE vocab)\n output_label.append(tokenizer.vocab[\"[UNK]\"])\n else:\n # no masking token (will be ignored by loss function later)\n output_label.append(-100)\n\n\n return tokens, output_label","def evaluate():\n global dictionary, wv\n count = 0\n # To save the scores by distance and similarity\n scores = np.zeros(6)\n similar = np.zeros(6)\n itr = len(dictionary)\n logging.info('running evaluation for {0} samples'.format(itr))\n for key in dictionary:\n progress = (count / itr) * 100\n d = dictionary[key].split('resource/')\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\n try:\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\n dtype=np.float32)\n except KeyError:\n itr -= 1\n continue\n if np.any(np.isnan(r)):\n itr -= 1\n continue\n else:\n if r.ndim == 2:\n try:\n # Mean of vector containing all word vectors\n # obtained from abstract.\n r = r.mean(axis=0).reshape(1, -1)\n \n # Obtain the vectors for the entity\n mean_vec = mean_encoder(dictionary[key])\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\n mean_dist_vec = distance_encoder(dictionary[key])\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\n title_vec = title_mean(key)\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\n abstract_vec = abstract_encoder(key)\n abstract_vec = abstract_vec.reshape(1, -1)\n abstract_vec = abstract_vec / norm(abstract_vec)\n random_vec = np.random.randn(100).reshape(1, -1)\n zero_vec = np.zeros(100).reshape(1, -1)\n \n # Score the entity vectors\n scores[0] += norm(r - mean_vec)\n scores[1] += norm(r - mean_dist_vec)\n scores[2] += norm(r - title_vec)\n scores[3] += norm(r - abstract_vec)\n scores[4] += norm(r - random_vec)\n scores[5] += norm(r - zero_vec)\n similar[0] += cosine_similarity(r, mean_vec)\n similar[1] += cosine_similarity(r, mean_dist_vec)\n similar[2] += cosine_similarity(r, title_vec)\n similar[3] += cosine_similarity(r, abstract_vec)\n similar[4] += cosine_similarity(r, random_vec)\n similar[5] += cosine_similarity(r, zero_vec)\n count += 1\n print(count, end='\\r')\n except (ValueError, KeyError) as _:\n itr -= 1\n continue\n else:\n itr -= 1\n continue\n # Normalize the scores to get a better\n # comparison against the baselines.\n scores = scores / norm(scores)\n similar = similar / norm(similar)\n print_summary(scores, similar)","def make_idx2word():\n idx2word = {}\n d = train_data.shared['word2idx']\n for word, idx in d.items():\n print(word)\n idx2word[idx] = word\n if config.use_glove_for_unk:\n d2 = train_data.shared['new_word2idx']\n for word, idx in d2.items():\n print(word)\n idx2word[idx+len(d)] = word\n return idx2word","def add(vector, ngram):\n if ngram in vector:\n vector[ngram] += 1\n else:\n vector[ngram] = 1","def __init__(self, word, index):\n self.word = word\n self.index = index\n self.number = 1\n self.idf = 0.0","def get_word_vector(doc_id, corpus):\n inv_index = vsm_retrieval.get_inverted_index(corpus)\n word_vec = np.zeros(len(inv_index))\n for count_vec, word in enumerate(inv_index):\n word_vec[count_vec] = inv_index[word].get(doc_id, {'frequency': 0})['frequency']\n return word_vec","def add_embedding(self, token, embedding):\n self.word2idx[token] = self.vocab_size\n self.vocab_size += 1\n\n self.embedding = np.vstack((self.embedding, embedding))","def process_user_input(user_input, vocab, word_to_idx):\n user_input_tokens = word_tokenize(user_input)\n user_input_tokens = [w.lower() for w in user_input_tokens]\n\n bow_vec = np.zeros(len(word_to_idx), dtype=np.float)\n unk_counter = 0\n\n for word in user_input_tokens:\n if word not in vocab:\n word = \"unk\"\n unk_counter += 1\n bow_vec[word_to_idx[word]] += 1\n else:\n bow_vec[word_to_idx[word]] += 1\n\n unk_percent = round(100*(unk_counter / len(user_input_tokens)),2)\n return user_input_tokens, bow_vec, unk_percent","def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\r\n input_string_x1=input_string_x1.decode(\"utf-8\")\r\n input_string_x2 = input_string_x2.decode(\"utf-8\")\r\n #1. get blue score vector\r\n feature_list=[]\r\n #get blue score with n-gram\r\n for i in range(n_gram):\r\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\r\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\r\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\r\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\r\n feature_list.append(blue_score_i_1)\r\n feature_list.append(blue_score_i_2)\r\n\r\n #2. get length of questions, difference of length\r\n length1=float(len(input_string_x1))\r\n length2=float(len(input_string_x2))\r\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\r\n feature_list.append(length_diff)\r\n\r\n #3. how many words are same, how many words are unique\r\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\r\n feature_list.extend(sentence_diff_overlap_features_list)\r\n\r\n #4. question 1,2 start with how/why/when\r\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\r\n #print(\"how_why_feature_list:\",how_why_feature_list)\r\n #feature_list.extend(how_why_feature_list)\r\n\r\n #5.edit distance\r\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\r\n feature_list.append(edit_distance)\r\n\r\n #6.cos distance from sentence embedding\r\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\r\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\r\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\r\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\r\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\r\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\r\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\r\n feature_list.extend(distance_list_fasttext)\r\n feature_list.extend(distance_list_word2vec)\r\n #feature_list.extend(list(sentence_diffence))\r\n #feature_list.extend(list(sentence_multiply))\r\n return feature_list","def word_frequency( tokenized, dic ):\n print( 'computing word frequencies' )\n start = time.time()\n for i, text in enumerate( tokenized ):\n for token in text:\n if token not in dic:\n dic[ token ] = 1\n else:\n dic[ token ] += 1\n if i % 10000 == 0:\n sys.stdout.write( '\\rprocessed : {}/{} reviews in {}s'.format( i, NO_REVIEWS, time.time() - start ) )\n sys.stdout.write( '\\rprocessed : {}/{} reviews in {}s\\n'.format( i, NO_REVIEWS, time.time() - start ) )","def add_word(self, word):\n if word not in self.word2index:\n self.word2index[word] = self.n_words\n self.word2count[word] = 1\n self.index2word[self.n_words] = word\n self.n_words += 1\n else:\n self.word2count[word] += 1","def add_word(self, word):\n if word not in self.word2index:\n self.word2index[word] = self.n_words\n self.word2count[word] = 1\n self.index2word[self.n_words] = word\n self.n_words += 1\n else:\n self.word2count[word] += 1","def nrc_hashtag_emotion(self, tokens):\n num_features = 10 # 'anger', 'anticipation', 'disgust', 'fear', 'joy', 'negative', 'positive', 'sadness', 'surprise', 'trust'\n sum_vec = [0.0] * num_features\n for token in tokens:\n if token in self.nrc_hashtag_emotion_map:\n sum_vec = [a + b for a, b in zip(sum_vec, self.nrc_hashtag_emotion_map[token])] # sum up the individual word feature vectors\n feature_names = ['anger', 'anticipation', 'disgust', 'fear', 'joy', 'negative', 'positive', 'sadness', 'surprise', 'trust']\n feature_names = ['nrc_hashtag_emotion_' + name for name in feature_names]\n return dict(zip(feature_names, sum_vec))","def _update_feature_vec(fvec, word, tag_ngram):","def processFeature(prevWord, word, vector):\n \n # We add feature whether it exists or not\n unigram, exists = vector.getUnigram(prevWord)\n if not exists:\n vector.addUnigram(prevWord)\n \n \n bigram, exists = vector.getBigram(prevWord, word)\n if not exists:\n vector.addBigram(prevWord, word)","def score(self, sentence):\n score = 0.0\n V = len(self.f1) # vocabulary size\n for token in sentence:\n if token in self.f1: score += self.f1[token]\n else: score -= math.log10(self.total + V)\t\t # OOV \n return score","def getrandom(hist):\n word, freq = random.choice(list(hist.items()))\n return word","def review_to_vec(words, model, num_features , index2word_set):\n \n feature_vec = np.zeros((num_features), dtype=\"float32\")\n word_count = 0\n \n \n \n for word in words:\n if word in index2word_set: \n word_count += 1\n feature_vec += model[word]\n\n if word_count == 0:\n word_count = 1\n\n feature_vec /= word_count\n\n return feature_vec","def word_average(self, sent):\n\n mean = []\n for word in sent:\n if word in self.word_model.wv.vocab:\n mean.append(self.word_model.wv.get_vector(word) *\n self.word_idf_weight[word]) # idf weighted\n\n if not mean: # empty words\n # If a text is empty, return a vector of zeros.\n logging.warning(\n \"cannot compute average owing to no vector for {}\".format(sent))\n return np.zeros(self.vector_size)\n else:\n mean = np.array(mean).mean(axis=0)\n return mean","def train(self, corpus): \n for sentence in corpus.corpus:\n last_token = None\n for datum in sentence.data:\n token = datum.word\n self.ntokens += 1\n self.counts[token] += 1\n if last_token:\n self.counts[(last_token, token)] += 1\n last_token = token\n\n for sentence in corpus.corpus:\n last_token = None\n for datum in sentence.data:\n token = datum.word\n if last_token:\n tup = (last_token, token)\n if self.counts[tup]:\n self.s[tup] = math.log(1.0 * self.counts[tup] / self.counts[last_token])\n else: # backing off\n if self.s[token] == 0:\n self.s[token] = math.log(1.0 * (self.counts[token] + 1) / (self.ntokens * 2))\n self.s[tup] = math.log(0.4 * self.s[token])\n last_token = token","def random_word(hist):\n \n t=[]\n\n for word, freq in hist.items():\n t.extend([word]*freq)\n\n return random.choice(t)","def bag_of_words(tokenized_sentence, all_words):\n\n tokenized_sentence = [stem(w) for w in tokenized_sentence]\n #print(tokenized_sentence)\n bag = np.zeros_like(all_words, dtype=np.float32)\n for idx, w in enumerate(all_words):\n if w in tokenized_sentence:\n bag[idx] = 1.0\n\n return bag","def get_pretrained_weights(idx_word):\n n = len(idx_word)\n embed_dim = 25\n weights = mx.ndarray.zeros((n, embed_dim))\n print('Start downloading pre-trained vectors, this will take some time')\n glov = api.load(\"glove-twitter-25\")\n print('Pre-trained vectors downloading complete')\n not_in_vocab = 0\n for i in range(n):\n word = idx_word[i]\n try:\n weights[i] = glov[word]\n except: #if not in glove vocabulary\n not_in_vocab += 1\n weights[i] = mx.nd.random.normal(0, 0.1, embed_dim)\n if not_in_vocab > 0:\n print('Warning: {} words not in vocab of pretrained embeddings (glove-twitter-25)'.format(not_in_vocab))\n return weights","def create_vectors(list_dict, num_words):\n x = [] # list that will hold data \n\n for d in list_dict:\n # initializing numpy vector\n # it contains 5,000 (number of words) zeros\n temp = np.zeros(num_words, dtype=np.float64)\n for key, val in d.items():\n if key < num_words:\n key -= 1 # indexing in data starts at 1\n temp[key] = 1 # adding word and its frequency to vector \n # temp[key] = val\n x.append(temp) # appends vector to x \n\n return x","def build_index(token_seq, min_freq=100, max_features=1000, downsample=0):\n passes = 4\n if downsample > 0:\n passes += 1\n\n term_vocab = set()\n char_vocab = set([u' '])\n term_freqs = defaultdict(int)\n token_seq_index = defaultdict(list)\n below_min_freq = set()\n\n # Include most of the characters we care about. We add any remaining\n # characters after this loop.\n for charlist in [string.ascii_letters, string.punctuation, range(10)]:\n for ch in charlist:\n char_vocab.add(unicode(str(ch)))\n\n pass_num = 1\n print('pass {pass_num} of {passes}: scanning tokens'.format(\n pass_num=pass_num, passes=passes))\n pass_num += 1\n pbar = progressbar.ProgressBar(term_width=40,\n widgets=[' ', progressbar.Percentage(),\n ' ', progressbar.ETA()],\n maxval=len(token_seq)).start()\n\n for i, token in enumerate(token_seq):\n pbar.update(i+1)\n\n if not is_word(token) or len(token) == 1:\n continue\n\n if term_freqs[token] == 0:\n below_min_freq.add(token)\n elif term_freqs[token] > min_freq:\n try:\n below_min_freq.remove(token)\n except KeyError:\n pass\n\n term_freqs[token] += 1\n token_seq_index[token].append(i)\n\n for ch in token:\n char_vocab.add(unicode(ch))\n\n pbar.finish()\n\n print('# of terms: ' + str(len(term_freqs)))\n\n print('pass {pass_num} of {passes}: removing infrequent terms'.format(\n pass_num=pass_num, passes=passes))\n pass_num += 1\n pbar = progressbar.ProgressBar(term_width=40,\n widgets=[' ', progressbar.Percentage(),\n ' ', progressbar.ETA()],\n maxval=len(term_freqs)).start()\n\n for i, term in enumerate(below_min_freq):\n pbar.update(i+1)\n del term_freqs[term]\n del token_seq_index[term]\n\n pbar.finish()\n print('# of terms: ' + str(len(term_freqs)))\n\n print('pass {pass_num} of {passes}: sorting terms by frequency'.format(\n pass_num=pass_num, passes=passes))\n pass_num += 1\n most_to_least_freq = sorted(term_freqs.iteritems(),\n key=itemgetter(1), reverse=True)\n print('')\n\n term_i = 0\n term_to_index = {}\n index_to_term = {}\n\n print('pass {pass_num} of {passes}: building term index'.format(\n pass_num=pass_num, passes=passes))\n pass_num += 1\n pbar = progressbar.ProgressBar(term_width=40,\n widgets=[' ', progressbar.Percentage(),\n ' ', progressbar.ETA()],\n maxval=len(most_to_least_freq)).start()\n\n for i, (term, freq) in enumerate(most_to_least_freq):\n pbar.update(i+1)\n\n if len(term_vocab) == max_features:\n del token_seq_index[term]\n continue\n\n term_vocab.add(term)\n term_to_index[term] = term_i\n index_to_term[term_i] = term \n term_i += 1\n\n pbar.finish()\n\n if downsample > 0:\n print('pass {pass_num} of {passes}: downsampling'.format(\n pass_num=pass_num, passes=passes))\n pass_num += 1\n pbar = progressbar.ProgressBar(term_width=40,\n widgets=[' ', progressbar.Percentage(),\n ' ', progressbar.ETA()],\n maxval=len(token_seq_index)).start()\n rng = random.Random(17)\n for i, token in enumerate(token_seq_index.keys()):\n pbar.update(i+1)\n indices = token_seq_index[token]\n token_seq_index[token] = random.sample(indices, downsample)\n pbar.finish()\n\n char_to_index = dict((c,i+1) for i,c in enumerate(char_vocab))\n char_to_index['NONCE'] = 0\n\n return token_seq_index, char_to_index, term_to_index","def nrc_affect_intensity(self, tokens): \n num_features = 10 # 'anger', 'anticipation', 'disgust', 'fear', 'joy', 'negative', 'positive', 'sadness', 'surprise', 'trust'\n sum_vec = [0.0] * num_features\n for token in tokens:\n if token in self.nrc_affect_intensity_map:\n sum_vec = [a + b for a, b in zip(sum_vec, self.nrc_affect_intensity_map[token])]\n \n feature_names = ['anger', 'anticipation', 'disgust', 'fear', 'joy', 'negative', 'positive', 'sadness', 'surprise', 'trust']\n feature_names = ['nrc_affect_intensity_' + name for name in feature_names]\n return dict(zip(feature_names, sum_vec))","def short_vector(self, splitted_words, max_array_size=26):# iterate in another way\r\n self.coder=\"An_real_word_vector_algorith_that_uses_the_letter_position_in_a_dictionary\"\r\n storage=[]#create an array storage\r\n not_found=[]#store the unkown words\r\n array=self.create_new_array(shape=(max_array_size,1),replace=True)# build an new arry and fill it with -1s then 0s\r\n array_position=0#set the positon in the array equal to 0; used to move around the array\r\n if len(self.special_characters_dic)>0:# checks if there are items in these dictionary\r\n for i in splitted_words:# iterate thorugh the list of splitted words\r\n for word in i: # iterate through the list of letters\r\n if word in self.general_lower_word_list:# now figure out if the letter is in that dictionary\r\n array[array_position]=self.general_lower_word_list[word]# and replace these with its number at the given array positon\r\n array_position+=1#add one to the positon to move to the next row in the array\r\n elif word in self.general_upper_word_list:\r\n array[array_position]=self.upper_word_dic[word]\r\n array_position+=1\r\n elif word in self.special_letters_dic:\r\n array[array_position]=self.special_letters_dic[word]\r\n array_position+=1\r\n elif word in self.general_numbers_dic:\r\n array[array_position]=self.general_numbers_dic[word]\r\n array_position+=1\r\n elif word in self.special_characters_dic:\r\n array[array_position]=self.special_characters_dic[word]\r\n array_position+=1\r\n else:\r\n print(\"This word is not know by the list: \"+word)\r\n not_found.append(word)\r\n storage.append(array)\r\n array_position=0\r\n array=self.create_new_array(shape=(max_array_size,1),replace=True)\r\n else:\r\n for i in splitted_words:\r\n for word in i:\r\n if word in self.general_lower_word_list:\r\n array[array_position]=self.general_lower_word_list[word]\r\n array_position+=1\r\n #print(array)\r\n elif word in self.upper_word_dic:\r\n array[array_position]=self.upper_word_dic[word]\r\n array_position+=1\r\n #print(array)\r\n elif word in self.special_letters_dic:\r\n array[array_position]=self.special_letters_dic[word]\r\n array_position+=1\r\n #print(array)\r\n elif word in self.general_numbers_dic:\r\n array[array_position]=self.general_numbers_dic[word]\r\n array_position+=1\r\n #print(array)\r\n else:\r\n print(\"This word is not know by the list: \"+word)\r\n not_found.append(word)\r\n pass\r\n storage.append(array)\r\n array_position=0\r\n array=self.create_new_array(shape=(max_array_size,1),replace=True)\r\n return storage,not_found","def get_word():\n word=words_dict[randrange(0,len(words_dict))]\n return word","def get_word():\n word=words_dict[randrange(0,len(words_dict))]\n return word","def get_word():\n word=words_dict[randrange(0,len(words_dict))]\n return word","def _get_mean_embedding(self, words):\n\n # ensure the size still matches if it's loaded from pretrained word vectors\n size = self.size\n if self.w2v is not None:\n size = next(iter(self.w2v_.values())).size\n\n zero = np.zeros(size)\n if self.tfidf:\n embedding = np.mean([self.w2v_[w] * self.w2idf_[w]\n if w in self.w2v_ else zero for w in words], axis = 0)\n else:\n embedding = np.mean([self.w2v_.get(w, zero) for w in words], axis = 0)\n\n return embedding","def build_doc_sense_vec(self):\n\t\twith codecs.open(self.vocab_file, encoding='utf-8', mode='r') as infile:\n\t\t\tline = infile.readline()\n\t\t\ti = 0\n\t\t\twhile line:\n\t\t\t\tword = line.split()[0]\n\t\t\t\tif not self.word2IdVocabulary.has_key(word):\n\t\t\t\t\t# print i, word\n\t\t\t\t\t# else:\n\t\t\t\t\tself.word2IdVocabulary[word] = i\n\t\t\t\tif not self.id2WordVocabulary.has_key(i):\n\t\t\t\t\tself.id2WordVocabulary[i] = word\n\t\t\t\tline = infile.readline()\n\t\t\t\ti += 1\n\t\t\tself.vocab_num = len(self.word2IdVocabulary)\n\t\t\tprint \"vocabulary number:\" + str(self.vocab_num)\n\n\t\twith codecs.open(self.vec_file, encoding='utf-8', mode='r') as vecfile:\n\t\t\twith codecs.open(self.vec_out_file, encoding='utf-8', mode='a+') as vec_outfile:\n\n\t\t\t\tfor i, line in enumerate(vecfile):\n\t\t\t\t\tif i % 10000 == 0:\n\t\t\t\t\t\tprint i\n\t\t\t\t\t# if i > 72:\n\t\t\t\t\t# \tbreak\n\t\t\t\t\tif i == 0:\n\t\t\t\t\t\ta, b, c = map(int, line.split()[:3])\n\t\t\t\t\t\tprint('Number of sememes: {}\\n'\n\t\t\t\t\t\t\t 'Number of words: {}\\n'\n\t\t\t\t\t\t\t 'Dimension of vectors: {}'.format(a, b, c))\n\t\t\t\t\telif i > 462667:\n\t\t\t\t\t\tsline = line.strip('\\n').split()\n\t\t\t\t\t\tword = sline[0]\n\t\t\t\t\t\tvector_list = []\n\t\t\t\t\t\tvector_list.append(sline[1:])\n\t\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\t\tword_id = self.word2IdVocabulary[word]\n\t\t\t\t\t\tif not self.vectors.has_key(word_id):\n\t\t\t\t\t\t\tself.vectors[word_id] = vector_array\n\t\t\t\t\t\t# vector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t\tif not self.vector_mean.has_key(word_id):\n\t\t\t\t\t\t\tself.vector_mean[word_id] = vector_array\n\t\t\t\t\t\t# vec_outfile.write(line)\n\t\t\t\t\telif i > 462887:\n\t\t\t\t\t\tbreak\n\t\t\t\t\telse:\n\t\t\t\t\t\tsline = line.strip('\\n').split()\n\t\t\t\t\t\tword = sline[0]\n\t\t\t\t\t\tsense_num = int(sline[1])\n\t\t\t\t\t\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\n\t\t\t\t\t\tvector_list = []\n\t\t\t\t\t\tfor start in range(0, len(vectors), c):\n\t\t\t\t\t\t\tvector_list.append(list(map(float, vectors[start: start+c])))\n\t\t\t\t\t\tvector_array = np.array(vector_list)\n\t\t\t\t\t\tword_id = self.word2IdVocabulary[word]\n\t\t\t\t\t\tif not self.vectors.has_key(word_id):\n\t\t\t\t\t\t\tself.vectors[word_id] = vector_array\n\t\t\t\t\t\tvector_mean = np.mean(vector_array, axis=0)\n\t\t\t\t\t\tif not self.vector_mean.has_key(word_id):\n\t\t\t\t\t\t\tself.vector_mean[word_id] = vector_mean\n\t\t\t\t\t\t'''j = 0\n\t\t\t\t\t\tfor each_sense_vec in vector_array:\n\t\t\t\t\t\t\tif len(vector_array) > 1:\n\t\t\t\t\t\t\t\tnew_line = word + '_' + str(j) + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tformatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\n'\n\t\t\t\t\t\t\t\tj += 1\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tnew_line = word + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t formatter={'float_kind': lambda\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t x: '%6f' % x})[1:-1] + '\\n'\n\n\t\t\t\t\t\t\tvec_outfile.write(new_line)'''\n\n\t\twith codecs.open(self.doc_file, encoding='utf-8', mode='r') as docfile:\n\t\t\twith codecs.open(self.doc_out_file, encoding='utf-8', mode='a+') as doc_outfile:\n\t\t\t\twith codecs.open(self.vec_out_file_bydoc, encoding='utf-8', mode='a+') as vec_outfile_bydoc:\n\t\t\t\t\tprint \"Processing document file......\"\n\t\t\t\t\tline = docfile.readline().strip('\\n')\n\t\t\t\t\twhile line:\n\t\t\t\t\t\twords = line.split()\n\t\t\t\t\t\tnew_words = [x for x in words]\n\t\t\t\t\t\tfor i in range(len(words)):\n\t\t\t\t\t\t\tword_id = self.word2IdVocabulary[words[i]]\n\t\t\t\t\t\t\tsense_vecs = self.vectors[word_id]\n\t\t\t\t\t\t\tsense_num = len(sense_vecs)\n\t\t\t\t\t\t\tif sense_num > 1:\n\t\t\t\t\t\t\t\tcontext_words = []\n\t\t\t\t\t\t\t\tfor x in range(i-int(self.context_num), i+int(self.context_num)+1):\n\t\t\t\t\t\t\t\t\tif x != i and 0 <= x < len(words):\n\t\t\t\t\t\t\t\t\t\tcontext_words.append(words[x])\n\t\t\t\t\t\t\t\tsense_index = self.select_attention(context_words, sense_vecs)\n\t\t\t\t\t\t\t\tword_vec_i = sense_vecs[sense_index]\n\t\t\t\t\t\t\t\tnew_wordi = words[i] + '_' + str(sense_index)\n\t\t\t\t\t\t\t\tself.vector_word_doc[new_wordi.encode('utf-8')] = word_vec_i\n\t\t\t\t\t\t\t\tnew_words[i] = new_wordi\n\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tword_vec_i = sense_vecs[0]\n\t\t\t\t\t\t\t\tself.vector_word_doc[words[i].encode('utf-8')] = word_vec_i\n\t\t\t\t\t\t\tvec_outfile_bydoc.write(new_words[i] + ' ' + np.array2string(word_vec_i, max_line_width=2000,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t formatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\n')\n\n\t\t\t\t\t\tdoc_outfile.write(' '.join(new_words) + '\\n')\n\n\t\t\t\t\t\tline = docfile.readline()\n\n\t\treturn self.vector_word_doc","def word_average(self, sent):\n mean = []\n for word in sent:\n if word in self.word_model.wv.vocab:\n mean.append(self.word_model.wv.get_vector(word))\n\n if not mean: # empty words\n # If a text is empty, return a vector of zeros.\n logging.warning(\n \"cannot compute average owing to no vector for {}\".format(sent))\n return np.zeros(self.vector_size)\n else:\n mean = np.array(mean).mean(axis=0)\n return mean","def _encode(self, tokens: List[str], mean: bool) -> Union[List[np.ndarray], np.ndarray]:\n if self.vectorizer:\n detokenized_sample = self.tokenizer([tokens])[0] # str\n vectorized_sample = self.vectorizer([detokenized_sample]) # (voc_size,)\n\n weights = np.array([vectorized_sample[0, np.where(self.vocabulary == token)[0][0]]\n if len(np.where(self.vocabulary == token)[0]) else 0.\n for token in tokens])\n else:\n weights = np.array([self.get_weight(max(self.counter_vocab.get(token, 0), self.idf_base_count))\n for token in tokens])\n\n if sum(weights) == 0:\n weights = np.ones(len(tokens))\n\n embedded_tokens = np.array(self.embedder([tokens]))[0, :, :]\n\n if mean is None:\n mean = self.mean\n\n if mean:\n embedded_tokens = np.average(embedded_tokens, weights=weights, axis=0)\n else:\n embedded_tokens = np.array([weights[i] * embedded_tokens[i] for i in range(len(tokens))])\n\n return embedded_tokens","def vectorize_word(word):\n if word in Tfidf_vect.vocabulary_:\n i = Tfidf_vect.vocabulary_[word]\n return Tfidf_vect.idf_[i]\n else:\n return 0","def score(self, sentence):\n # TODO your code here\n\n # initialize count with trained data\n unigram_count = self.count.copy()\n N = self.total\n\n # make a new key for UNK, add-one later\n for token in sentence:\n if token not in unigram_count:\n unigram_count[token] = 0\n\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\n score = 0.0 # P(<s>) = 1\n V = len(unigram_count) # the number of vocab including UNK\n for word in sentence:\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\n score += math.log(prob)\n\n return score","def __add_to_word_dict__(self, word, tag):\n if self.word_dict.get(word, None) is None:\n self.word_dict[word] = defaultdict(int)\n self.word_dict[word][tag] += 1","def add_paragram(self):\n num_new_words = 720000\n new_embeddings = np.empty((num_new_words, self.embedding_size))\n concat_emb = np.zeros((2, self.embedding_size))\n new_word2idx = dict()\n new_words_count = 0\n\n self.load_all()\n fi = open(self.config.word_vec_fi_paragram, \"r\", encoding=\"utf8\",\n errors='ignore')\n embed_gen = self.embeddings_file_gen(fi)\n\n for token, embedding in embed_gen:\n if token not in self.word2idx:\n new_word2idx[token] = self.vocab_size\n new_embeddings[new_words_count, :] = embedding\n self.vocab_size += 1\n new_words_count += 1\n else:\n concat_emb[0, :] = self.embedding[self.word2idx[token]]\n concat_emb[1, :] = embedding\n self.embedding[self.word2idx[token]] = np.mean(\n concat_emb,\n axis=0\n )\n\n self.word2idx.update(new_word2idx)\n self.embedding = np.vstack((\n self.embedding,\n new_embeddings[:new_words_count, :]\n ))\n\n self.write_all()\n fi.close()","def _WordSimAveVec(self,df,a):\r\n #Obtain the course description for the course provided and convert the string into a list of individual words.\r\n Description = df['description'][a].split()\r\n #Create a placeholder zero vector of the same size as the vector embedding.\r\n Vector = np.zeros(self.WordVecModel.layer1_size)\r\n wordCount = 0\r\n #Iterate over each word in the description.\r\n for word in Description:\r\n #If the word is in the trained vocabulary, obtain the word vector. \r\n #Continue to add the word vectors to the placeholder vector to get the running sum.\r\n if word in self.WordVecModel.wv.vocab:\r\n vector = self.WordVecModel.wv.get_vector(word)\r\n Vector +=vector\r\n #Keep track of how many word vectors (which were included in the vocabulary) were added.\r\n wordCount +=1\r\n #Calculate the mean by dividing the sum by the number of vectors.\r\n return Vector/wordCount","def similarity(query,word_dict,dictionary,number_of_docs,id):\n similarity = 0.0\n scalar_leng = 0.0\n for term in query:\n if term in dictionary:\n similarity += word_dict[term][1]*imp(term,word_dict,number_of_docs,id)\n\n for term in dictionary:\n scalar_leng += imp(term, word_dict, number_of_docs, id) ** 2\n\n final_scalar_leng = math.sqrt(scalar_leng)\n similarity = similarity / final_scalar_leng\n #print(similarity)\n return similarity","def _init_vocab(self):\n self._word2idx = {}\n self._idx2word = {}\n self.freqs = {}\n self.vocab_size = 0\n\n self._add_word(self.pad_word)\n self._add_word(self.start_word)\n self._add_word(self.end_word)\n self._add_word(self.unk_word)\n\n self.start_word_idx = self.stoi(self.start_word)\n self.end_word_idx = self.stoi(self.end_word)\n self.unk_word_idx = self.stoi(self.unk_word)\n self.pad_word_idx = self.stoi(self.pad_word)\n\n self._special_tokens = {\n 'bos_token': self.start_word,\n 'cls_token': self.start_word,\n 'eos_token': self.end_word,\n 'sep_token': self.end_word,\n 'pad_token': self.pad_word,\n 'unk_token': self.unk_word,\n }\n\n self._special_ids = {\n 'bos_token_id': self.start_word_idx,\n 'cls_token_id': self.start_word_idx,\n 'eos_token_id': self.end_word_idx,\n 'sep_token_id': self.end_word_idx,\n 'pad_token_id': self.pad_word_idx,\n 'unk_token_id': self.unk_word_idx,\n }\n\n self.cls_token_id = self.bos_token_id = self.start_word_idx\n self.eos_token_id = self.sep_token_id = self.end_word_idx\n self.pad_token_id = self.pad_word_idx\n self.unk_token_id = self.unk_word_idx\n\n self.cls_token = self.bos_token = self.start_word\n self.eos_token = self.sep_token = self.end_word\n self.pad_token = self.pad_word\n self.unk_token = self.unk_word","def _calculate_word_value(self, _word_total, word):\n for each_letter in word:\n _word_total += SCRABBLE_POINT_DICT[each_letter]\n return _word_total","def getReviewsWithToken(self, token):\n\n wordid = self.find_word_in_dictionary(token)\n # word is not in the dictionary\n if wordid == -1:\n print(\"Token is not in the dictionary\")\n return 0\n\n with open(self.doc_to_words_path, 'rb') as bin:\n tup = []\n while bin.tell() != os.fstat(bin.fileno()).st_size:\n # get wordid:\n docid_in_file = int.from_bytes(bin.read(4), 'big')\n # get frequency:\n frequency = int.from_bytes(bin.read(4), 'big')\n # count words:\n count = 0\n for i in range(frequency):\n wordid_in_file = int.from_bytes(bin.read(4), 'big')\n if wordid == wordid_in_file:\n count += 1\n tup.append(docid_in_file)\n tup.append(count)\n return tuple(tup)","def add(self, key, idx=None, count=1):\n key = self.lower_(key)\n if idx is not None:\n self.index2word[idx] = key\n self.word2index[key] = idx\n else:\n if key not in self.word2index:\n idx = len(self.word2index)\n self.index2word[idx] = key\n self.word2index[key] = idx\n\n if key not in self.word_count:\n self.word_count[key] = count\n else:\n self.word_count[key] += count","def preprocessing():\n english_dictionary = nltk.corpus.brown.words()\n slang_vocab = pickle.load(open('vocab_pattern_match_with_freq.pkl', 'rb'))\n\n normalize_english_dict = len(english_dictionary)\n normalize_slang_vocab = 0\n for w, n in slang_vocab.items():\n normalize_slang_vocab += n\n\n words = {}\n for w, n in Counter(english_dictionary).items():\n words[w] = n/normalize_english_dict\n \n for w, n in slang_vocab.items():\n if w not in words:\n words[w] = 0.\n words[w] += n/normalize_slang_vocab\n\n words_by_freq = [w for w,_ in sorted(words.items(), key=lambda x: x[1], reverse=True)]\n\n # Build a cost dictionary, assuming Zipf's law and cost = -math.log(probability).\n #words = open(\"words_by_frequency.txt\").read().split()\n wordcost = dict((k, log((i+1)*log(len(words_by_freq)))) for i,k in enumerate(words_by_freq))\n maxword = max(len(x) for x in words_by_freq)\n return wordcost,maxword","def random_word(hist):\n t = []\n for word, freq in hist.items():\n t.extend([word] * freq)\n\n return random.choice(t)","def train(self, tokens):\n if len(tokens) == 0: # Empty tokens\n return pd.Series(dtype=float).astype(float)\n \n index = pd.Series(tokens).unique() # Word index\n return pd.Series([1 / len(index)] * len(index), index=index)","def __getitem__(self, index):\r\n target_word_index = self.data[index + self.skip_window]\r\n random_index = random.randint(0 , 2*self.skip_window -1)\r\n if random_index >= self.skip_window:\r\n context_word_index = self.data[index + (random_index - self.skip_window + 1)]\r\n else:\r\n context_word_index = self.data[index + (random_index - self.skip_window)]\r\n #print ('getitem:', target_word_index, context_word_index)\r\n \r\n return (target_word_index, context_word_index)\r\n \r\n #raise NotImplementedError('Implement the __getitem__ method of the dataset')\r","def encode_samples(tokenized_samples, word_to_idx):\n features = []\n for sample in tokenized_samples:\n feature = []\n for token in sample:\n if token in word_to_idx:\n feature.append(word_to_idx[token])\n else:\n feature.append(0)\n features.append(feature)\n return features","def add(self, tokens):\n\n for token in tokens:\n self.vocab.add(token)\n\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\n if leader not in self.frequencies:\n self.frequencies[leader] = Frequency()\n\n self.frequencies[leader].add(token)","def embed_token(self, token):\r\n embs, words = [], token.split()\r\n for word in words:\r\n emb_list=[]\r\n for element in word.split('_'):\r\n # If we have a trailing _ we don't want to embed an empty string\r\n if element:\r\n emb,_ = self(element, mean_sequence=True)\r\n emb_list.append(emb)\r\n embs.append(torch.mean(torch.stack(emb_list), dim=0))\r\n\r\n return torch.mean(torch.stack(embs), dim=0)","def known_word():\n global rand_word\n data.remove(rand_word) # Removes the current random word from the data\n to_learn = pandas.DataFrame(data) # Creates a data frame of the updated data\n to_learn.to_csv(\"data/words_to_learn.csv\", index=False) # Creates & Updates the .csv file with updated data\n generate_word()","def get_word_embedding(counter, emb_file, emb_size, vocab_size, vec_size, vocab_file):\n print(\"Generating word embedding...\")\n # load word embeddings\n embedding_dict = {}\n with open(emb_file, \"r\", encoding=\"utf-8\") as fh:\n for line in tqdm(fh, total=emb_size):\n array = line.split()\n word = \"\".join(array[0:-vec_size])\n vector = list(map(float, array[-vec_size:]))\n embedding_dict[word] = vector\n\n TRANSLATE = {\n \"-lsb-\": \"[\", \"-rsb-\": \"]\", \"-lrb-\": \"(\", \"-rrb-\": \")\", \"-lcb-\": \"{\",\n \"-rcb-\": \"}\", \"-LSB-\": \"[\", \"-RSB-\": \"]\", \"-LRB-\": \"(\", \"-RRB-\": \")\",\n \"-LCB-\": \"{\", \"-RCB-\": \"}\"\n }\n SPECIAL_TOKENS = [\"<NULL>\", \"<UNK>\", \"<S>\", \"</S>\"]\n words = list(map(lambda x: x[0], sorted(counter.items(), key=lambda x: x[1], reverse=True)))\n words = SPECIAL_TOKENS + words\n if vocab_size > 0:\n words = words[:vocab_size]\n with open(vocab_file, 'w') as f:\n f.write('\\n'.join(words[1:]))\n embedding = np.random.normal(scale=0.1, size=(len(words), vec_size))\n word2idx_dict = {}\n unknown_count = 0\n for i, word in enumerate(words):\n word2idx_dict[word] = i\n if word in TRANSLATE:\n word = TRANSLATE[word]\n done = False\n for w in (word, word.lower(), word.upper(), word.capitalize()):\n if w in embedding_dict:\n embedding[i] = embedding_dict[w]\n done = True\n break\n if not done:\n unknown_count += 1\n return embedding, word2idx_dict, unknown_count","def word_entropy(self, doc, lemmatized=False):\n # filter out words\n words = [token for token in doc if not token.is_punct and \"'\" not in token.text and not token.is_space]\n # create bag of words\n if lemmatized:\n list_words = [w.lemma_ for w in words]\n else:\n list_words = [w.text for w in words]\n num_words = len(list_words)\n word_freq = Counter(list_words)\n return -sum(\n [\n (word_freq[word] / num_words) * log2(word_freq[word] / num_words)\n for word in word_freq\n ]\n )","def add(self, term, count=1):\n term = term.lower() if self.lower else term\n if term in self.term2id:\n idx = self.term2id[term]\n else:\n idx = len(self.id2term)\n self.id2term[idx] = term\n self.term2id[term] = idx\n if count > 0:\n if term in self.term_frequent:\n self.term_frequent[term] += count\n else:\n self.term_frequent[term] = count\n return idx","def test_score_of_unknown_token(self):\n\n \"\"\"\n Create the test data.\n \"\"\"\n tokenizer = Tokenizer(stem=False)\n posts = [\n \"Erdogan with threats to attack regime forces 'everywhere' in Syria\",\n \"Damascus says Erdogan 'disconnected from reality' after threats\",\n ]\n\n corpus = [ Document(post, tokenizer.tokenize(post)) for post in posts ]\n\n extractor = TokenExtractor()\n scorer = TFIDFScorer({ 'erdogan': 1, 'threats': 2 }, 10)\n candidates = extractor.extract(corpus)\n scores = scorer.score(candidates)\n self.assertFalse(scores.get('unknown'))","def random_word_wwm(tokens, ref_ids, tokenizer):\n output_label = []\n\n for i, (token, ref_id) in enumerate(zip(tokens, ref_ids)):\n\n prob = random.random()\n\n if ref_id == 1:\n\n # 80% randomly change token to mask token\n if prob < 0.8:\n tokens[i] = \"[MASK]\"\n\n # 10% randomly change token to random token\n elif prob < 0.9:\n tokens[i] = random.choice(list(tokenizer.vocab.items()))[0]\n\n # -> rest 10% randomly keep current token\n\n # append current token to output (we will predict these later)\n try:\n output_label.append(tokenizer.vocab[token])\n except KeyError:\n # For unknown words (should not occur with BPE vocab)\n output_label.append(tokenizer.vocab[\"[UNK]\"])\n else:\n # no masking token (will be ignored by loss function later)\n output_label.append(-100)\n\n return tokens, output_label","def _make_feature_vec(self, word_list):\n\n # Pre-initialize an empty numpy array (for speed)\n feature_vec = np.zeros((self.num_features,), dtype=\"float32\")\n\n # index2word is a list that contains the names of the words in\n # the model's vocabulary. Convert it to a set, for speed.\n index2word_set = set(self.w2v_model.index2word)\n\n # Loop over each word in the word_list and, if it is in the model's\n # vocabulary, add its feature vector to the total\n nwords = 0\n for word in word_list:\n # NOTE: Careful there, if all words are in caps in the article,\n # this function will return nan values and blow up the forest.\n word = word.lower()\n if word in index2word_set:\n nwords += 1\n feature_vec = np.add(feature_vec, self.w2v_model[word])\n\n # Divide the result by the number of words to get the average\n feature_vec = np.divide(feature_vec, nwords)\n return feature_vec","def get_mean_emb(self, text):\n return np.mean([self.emb.get(w.lower(), self.emb.get(\"_UNK\")) for w in text.split()], axis=0)","def train(self, corpus): \n for sentence in corpus.corpus: # iterate over sentences in the corpus\n for token in sentence: # iterate over datums in the sentence\n self.unigrams[token] += 1\n self.total += 1\n V = len(self.unigrams) # vocabulary size \n for ug,count in self.unigrams.iteritems():\n \tself.f1[ug] = math.log10(count+1) - math.log10(self.total + V)","def vectorize(sequence, el2idx, max_length, unk_policy=\"random\",\n spell_corrector=None):\n words = numpy.zeros(max_length).astype(int)\n\n # trim tokens after max length\n sequence = sequence[:max_length]\n\n for i, token in enumerate(sequence):\n if token in el2idx:\n words[i] = el2idx[token]\n else:\n if unk_policy == \"random\":\n words[i] = el2idx[\"<unk>\"]\n elif unk_policy == \"zero\":\n words[i] = 0\n elif unk_policy == \"correct\":\n corrected = spell_corrector(token)\n # if corrected != token:\n # print(token, corrected)\n if corrected in el2idx:\n words[i] = el2idx[corrected]\n else:\n words[i] = el2idx[\"<unk>\"]\n\n return words","def add(self, term, count=1):\n term = term.lower() if self.lower else term\n if term in self.term2id:\n idx = self.term2id[term]\n else:\n idx = len(self.id2term)\n self.id2term[idx] = term\n self.term2id[term] = idx\n if count > 0:\n if term in self.term_frequent:\n self.term_frequent[term] += count\n else:\n self.term_frequent[term] = count\n\n if term not in self.initial_terms:\n for char in term:\n if char not in self.char2id.keys():\n idc = len(self.id2char)\n self.id2char[idc] = char\n self.char2id[char] = idc\n return idx","def calculate_tf_idf(self,doc_token_number,document_count):\n for term_ in self.inverted_index.keys():\n postingsList=self.inverted_index[term_]\n len_of_posting_list=postingsList.length\n idf=document_count/len_of_posting_list\n if postingsList.start_node is None:\n print(\"List has no element\")\n return\n else:\n n = postingsList.start_node\n # Start traversal from head, and go on till you reach None\n while n is not None:\n freq=n.term_frequency\n tf=freq/doc_token_number[n.value]\n tf_idf_value=tf*idf\n n.tf_idf=tf_idf_value\n n = n.next","def sample(prediction):\n p = np.zeros(shape=[1, vocabulary_size], dtype=np.float)\n p[0, sample_distribution(prediction[0])] = 1.0\n return p","def sample(prediction):\n p = np.zeros(shape=[1, vocabulary_size], dtype=np.float)\n p[0, sample_distribution(prediction[0])] = 1.0\n return p","def sample(prediction):\n p = np.zeros(shape=[1, vocabulary_size], dtype=np.float)\n p[0, sample_distribution(prediction[0])] = 1.0\n return p"],"string":"[\n \"def get_average_vec(tokens_list, vector, generate_missing=False, k=300):\\r\\n if len(tokens_list)<1:\\r\\n return np.zeros(k)\\r\\n \\r\\n if generate_missing:\\r\\n vectorized = [vector[word] if word in vector else np.random.rand(k) for word in tokens_list]\\r\\n else:\\r\\n vectorized = [vector[word] if word in vector else np.zeros(k) for word in tokens_list]\\r\\n \\r\\n length = len(vectorized)\\r\\n summed = np.sum(vectorized, axis=0)\\r\\n averaged = np.divide(summed, length)\\r\\n return averaged\",\n \"def add_to_dict(self, tokens):\\n# TODO: ?add normalization of a token?\\n for token in tokens:\\n if self.embedding_words and (token not in self.embedding_words):\\n continue\\n self.freq[token] += 1\\n if token not in self.tok2ind:\\n index = len(self.tok2ind)\\n self.tok2ind[token] = index\\n self.ind2tok[index] = token\",\n \"def avg_sentence_vector(words, model, num_features, index2word_set):\\n featureVec = np.zeros((num_features,), dtype=\\\"float32\\\")\\n nwords = 0\\n\\n for word in words:\\n if word in index2word_set:\\n nwords = nwords+1\\n featureVec = np.add(featureVec, model.wv[word])\\n # featureVec = np.add(featureVec, model.wv.__getitem__(word))\\n\\n if nwords>0:\\n featureVec = np.divide(featureVec, nwords)\\n return featureVec\",\n \"def add_word(self, word, vector=None, low=-2., high=2.):\\n if word not in self.w2v_idx:\\n self.w2v_idx[word] = len(self.w2v_idx)\\n if vector is None:\\n vector = np.random.uniform(low=low, high=high, size=(self.w2v_dim,))\\n self.w2v_out.append(np.asarray(vector, dtype=np.float32))\\n else:\\n print(\\\"word %s already in this word2vec\\\" % word)\",\n \"def average_one_hots(sent, word_to_ind):\\n known_words = 0\\n size = len(word_to_ind.keys())\\n sum_vec = np.zeros((size,))\\n for token in sent.text: #going over all tokens and summing their embeddings\\n if (token in word_to_ind):\\n sum_vec += get_one_hot(size, word_to_ind[token])\\n known_words += 1\\n if (known_words != 0):\\n return sum_vec / known_words\\n else:\\n return sum_vec\",\n \"def add_unknown_words(word_vecs, vocab, min_df=1, k=300, unk_token=UNK_TOKEN):\\n for word in vocab:\\n if word not in word_vecs and vocab[word] >= min_df:\\n word_vecs[word] = uniform_sample(-0.25,0.25,k) \\n word_vecs[unk_token] = uniform_sample(-0.25,0.25,k)\",\n \"def index_word(self, token):\\n if token not in self.word_2_idx:\\n idx = len(self.word_2_idx)\\n self.word_2_idx[token] = idx\\n self.idx_2_word[idx] = token\",\n \"def random_init_certain_vector(vocab, token='<unk>', mean=0, std=0.5):\\n idx = vocab.stoi[token]\\n nn.init.normal_(vocab.vectors[idx], mean=mean, std=std)\",\n \"def add_unknown_words(word_vecs, vocab, k=300):\\n for word in vocab:\\n if word not in word_vecs:\\n word_vecs[word] = np.random.uniform(-1.0, 1.0, k)\",\n \"def add_unknown_words(word_vecs, vocab, min_df=5000, k=300):\\n for word in vocab:\\n if word not in word_vecs and vocab[word] >= min_df:\\n #print word\\n word_vecs[word] = np.random.uniform(-0.25,0.25,k)\",\n \"def add_unknown_words(word_vecs, vocab, min_df=1, dim=300):\\n k=0\\n for w in vocab:\\n if w not in word_vecs:\\n word_vecs[w]=np.asarray(np.random.uniform(-0.25,0.25,dim),dtype=np.float32)\\n k+=1\\n if k % 10000==0:\\n print (\\\"add_unknow_words %d\\\" % k)\\n return word_vecs\",\n \"def get_sentence_average_w2v(sent, word_to_vec, embedding_dim):\\n sum_vec = np.zeros((embedding_dim,))\\n known_tokens = 0\\n for token in sent.text:\\n if (token in word_to_vec.dict):\\n known_tokens += 1\\n sum_vec += word_to_vec[token]\\n if (known_tokens != 0):\\n return sum_vec / known_tokens\\n else:\\n return sum_vec\",\n \"def generate_avg_vector(self, data):\\r\\n doc=nlp(data)\\r\\n data_vector = [token.vector for token in doc]\\r\\n mean_vector = np.mean(data_vector, axis=0)\\r\\n return mean_vector\",\n \"def sentence_to_avg(sentence, word_to_vec_map):\\n # Get a valid word contained in the word_to_vec_map. \\n any_word = list(word_to_vec_map.keys())[0]\\n \\n ### START CODE HERE ###\\n # Step 1: Split sentence into list of lower case words (≈ 1 line)\\n words = sentence.lower().split()\\n\\n # Initialize the average word vector, should have the same shape as your word vectors.\\n avg = np.zeros(word_to_vec_map[any_word].shape)\\n \\n # Initialize count to 0\\n count = 0\\n \\n # Step 2: average the word vectors. You can loop over the words in the list \\\"words\\\".\\n for w in words:\\n # Check that word exists in word_to_vec_map\\n if w in word_to_vec_map:\\n avg += word_to_vec_map[w]\\n # Increment count\\n count +=1\\n \\n if count > 0:\\n # Get the average. But only if count > 0\\n avg = avg / count\\n \\n ### END CODE HERE ###\\n \\n return avg\",\n \"def _add_word(self, word):\\n if not word in self._word2idx.keys():\\n self._word2idx[word] = self.vocab_size\\n self.freqs[word] = 0\\n self._idx2word[self.vocab_size] = word\\n self.vocab_size += 1\\n self.freqs[word] += 1\",\n \"def add_unknown_words(word_vecs, vocab, min_df=1, k=200):\\n for word in vocab:\\n if word not in word_vecs and vocab[word] >= min_df:\\n word_vecs[word] = np.random.uniform(-0.25,0.25,k)\",\n \"def word_analogy(self):\\n data = open(\\\"data/word_analogy_subset.en.ar.txt\\\").read().split('\\\\n')\\n data = [x for x in data if len(x.split()) == 4]\\n cnt = 0\\n keys = list(self.embeddings_index.keys())\\n vectors = np.array(list(self.embeddings_index.values()))\\n norms = np.linalg.norm(vectors, axis=1)\\n for i in data:\\n i = self.preprocessor(i).split()\\n try:\\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\\n except:\\n continue\\n unit = v / np.linalg.norm(v)\\n dists = np.dot(vectors, unit) / norms\\n best = np.argpartition(-dists, 10)[:10 + 1]\\n best = best.take(np.argsort((-dists).take(best)))\\n result = [(keys[sim], float(dists[sim]))\\n for sim in best]\\n sbv = result[:10]\\n for j in sbv:\\n if j[0] == i[3]:\\n cnt += 1\\n return cnt/ len(data)\",\n \"def add_unknown_words(word_vecs, vocab, min_df=10, k=300):\\n for word in vocab:\\n if word not in word_vecs and vocab[word] >= min_df:\\n word_vecs[word] = np.random.uniform(-0.25, 0.25, k)\",\n \"def _look_up(self, token):\\n if self.args.add_vn:\\n return tf.nn.embedding_lookup(self.embedding_matrix + \\\\\\n tf.random.normal(tf.shape(self.embedding_matrix), stddev=0.075), token)\\n\\n return tf.nn.embedding_lookup(self.embedding_matrix, token)\",\n \"def _sample_token(self, token):\\n dist = tf.distributions.Categorical(logits=token)\\n sampled_token = dist.sample(int(1))[0]\\n\\n return self._look_up(sampled_token)\",\n \"def add_unknown_words(word_vecs, vocab, min_df=1, k=300):\\n for word in vocab:\\n if word not in word_vecs and vocab[word] >= min_df:\\n word_vecs[word] = np.random.uniform(-0.25, 0.25, k)\",\n \"def add_unknown_words(word_vecs, vocab, min_df=1, k=300):\\n for word in vocab:\\n if word not in word_vecs and vocab[word] >= min_df:\\n word_vecs[word] = np.random.uniform(-0.25, 0.25, k)\",\n \"def add_unknown_words(word_vecs, vocab, min_df=1, k=100):\\n for word in vocab:\\n if word not in word_vecs and vocab[word] >= min_df:\\n # print(\\\"************************\\\")\\n # print(word)\\n # print(\\\"************************\\\")\\n word_vecs[word] = np.random.uniform(-0.25,0.25,k)\",\n \"def make_bow_vector(query_tokens, words_to_idx):\\n bow_vec = torch.zeros(len(words_to_idx), dtype=torch.float)\\n\\n for tokens in query_tokens:\\n if tokens not in words_to_idx:\\n tokens = \\\"unk\\\"\\n bow_vec[words_to_idx[tokens]] += 1\\n else:\\n bow_vec[words_to_idx[tokens]] += 1\\n\\n return bow_vec\",\n \"def add_unknown_words(self, word_vecs, vocab, min_df=3, k=300):\\n for word in vocab:\\n if word not in word_vecs and vocab[word] >= min_df:\\n word_vecs[word] = np.random.uniform(-0.25,0.25,k)\",\n \"def index_new_tweet(self, id_str, tweet_tokens: list):\\n self.tweet_count += 1\\n unique_words = set(tweet_tokens)\\n unique_word_pairs = set()\\n for i in unique_words:\\n for j in unique_words - {i}:\\n # To us [a, b] = [b, a], and sorting gives us a distinct representation.\\n unique_word_pairs.add(tuple(sorted([i, j])))\\n for w in unique_words | unique_word_pairs:\\n self.index[self.epoch][w] = id_str\\n current_freq = self.frequency_map.get(w, 0)\\n self.frequency_map[w] = current_freq + 1\\n # Get word statistics from hash table\\n statistics_present = w in self.stats_map\\n if not statistics_present:\\n (mu, sigma) = (math.inf, math.inf)\\n for h in self.hash_functions:\\n c = get_hash(h(), repr(w)) % 2 ** self.bit_count\\n if self.buckets[c][\\\"ewma\\\"] < mu:\\n mu = self.buckets[c][\\\"ewma\\\"]\\n sigma = self.buckets[c][\\\"ewmvar\\\"]\\n self.stats_map[w] = (mu, sigma)\\n (mu, sigma) = self.stats_map[w]\\n # Test for significance threshold\\n x = self.frequency_map[w]\\n if self._is_frequency_significant(mu, sigma, x):\\n self.refinement.append((w, self._get_significance(mu, sigma, x)))\\n # if self.refinement:\\n # r = self.refinement\\n # self.refinement = []\\n # return r\",\n \"def compute_avg_w2v_vector(w2v_dict, text_nlp_proc):\\n SIZE = 50 # size of the w2v dimension\\n list_of_word_vectors = [w2v_dict[w] for w in text_nlp_proc if w in w2v_dict.vocab.keys()]\\n if len(list_of_word_vectors) == 0:\\n result = [0.0]*SIZE\\n else:\\n result = np.sum(list_of_word_vectors, axis=0) / len(list_of_word_vectors)\\n return result\",\n \"def average_word_vector(vectorfile, outvectorfile):\\n\\twith codecs.open(vectorfile, encoding='utf-8', mode='r') as infile:\\n\\t\\twith codecs.open(outvectorfile, encoding='utf-8', mode='a+') as outfile:\\n\\t\\t\\tfor i, line in enumerate(infile):\\n\\t\\t\\t\\tprint i\\n\\t\\t\\t\\tif i == 0:\\n\\t\\t\\t\\t\\ta, b, c = map(int, line.split()[:3])\\n\\t\\t\\t\\t\\tprint('Number of sememes: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t 'Number of words: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t 'Dimension of vectors: {}'.format(a, b, c))\\n\\t\\t\\t\\t\\toutfile.write(str(b) + ' ' + str(c) + '\\\\n')\\n\\t\\t\\t\\telif i > 462667:\\n\\t\\t\\t\\t\\toutfile.write(line)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tsline = line.split()\\n\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\tsense_num = int(sline[1])\\n\\t\\t\\t\\t\\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\\n\\t\\t\\t\\t\\t# extra = len(vectors) % sense_num\\n\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\tfor start in range(0, len(vectors), c):\\n\\t\\t\\t\\t\\t\\tvector_list.append(list(map(float, vectors[start: start+c])))\\n\\t\\t\\t\\t\\t# print vector_list\\n\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\tvector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t# print np.array2string(vector_mean, max_line_width=200, formatter={'float_kind': lambda x: '%6f'%x})[1:-1].strip('\\\\n')\\n\\t\\t\\t\\t\\tnew_line = word + ' ' + np.array2string(vector_mean, max_line_width=2000, formatter={'float_kind': lambda x: '%6f'%x})[1:-1] + '\\\\n'\\n\\t\\t\\t\\t\\toutfile.write(new_line)\",\n \"def newInternal(word, deflike):\\n\\n avedeflike = 0\\n denom = len(word)\\n for indices, f in fqs(word, 0.5):\\n context, numer = internalContext(indices, word)\\n if deflike[context]:\\n avedeflike += numer/denom * f * deflike[context]\\n return avedeflike\",\n \"def embed(raw_seq, index_dict):\\n return np.asarray([index_dict[word.lower()]\\n if word.lower() in index_dict\\n else index_dict[OOV_TOKEN] for word in raw_seq])\",\n \"def word_averaging(wv, words):\\n all_words, mean = set(), []\\n \\n for word in words:\\n if isinstance(word, np.ndarray):\\n mean.append(word)\\n elif word in wv.vocab:\\n mean.append(wv.vectors_norm[wv.vocab[word].index])\\n all_words.add(wv.vocab[word].index)\\n\\n if not mean:\\n logging.warning(\\\"Cannot compute similarity with no input: %s\\\", words)\\n # Remove these examples in pre-processing...\\n return np.zeros(50,)\\n\\n mean = gensim.matutils.unitvec(np.array(mean).mean(axis=0)).astype(np.float32)\\n \\n return mean\",\n \"def lookup(doc, wv):\\n checked = []\\n for word in doc:\\n try:\\n word in wv\\n except KeyError:\\n log.warning(\\\"Word not in model: %s\\\", word)\\n continue\\n checked.append(wv[word])\\n vec = np.mean(checked, axis=0)\\n return vec\",\n \"def create_embedding_matrix(self):\\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\\n vocab_size = len(self.vocab)\\n result = np.zeros((vocab_size, self.embed_dim))\\n unknown_token_set = set()\\n\\n found_words = 0\\n avg = np.zeros(self.embed_dim)\\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\\n try:\\n result[_] = self.pretrained_embedding[self.id2word[_]]\\n avg += result[_]\\n found_words += 1\\n except:\\n unknown_token_set.add(_)\\n\\n avg /= found_words\\n for _ in unknown_token_set:\\n result[_] = avg\\n self.embedding = result\\n return found_words, len(self.id2word)\",\n \"def imp(term,word_dict,number_of_docs,id):\\n\\n with open('term_freq.txt', 'rb') as file:\\n term_freq = pickle.loads(file.read())\\n\\n #print(term_freq)\\n\\n if id+1 in term_freq[term]:\\n #print(term_freq[term][id])\\n return term_freq[term][id+1]*word_dict[term][1]#idf(term,number_of_docs,index_list)\\n else:\\n return 0.0\",\n \"def random_word(tokens, tokenizer, word_mask_rate=0.15):\\n output_label = []\\n\\n for i, token in enumerate(tokens):\\n\\n prob = random.random()\\n\\n if prob < word_mask_rate:\\n prob /= word_mask_rate\\n \\n # 80% randomly change token to mask token\\n if prob < 0.8:\\n tokens[i] = \\\"[MASK]\\\"\\n\\n # 10% randomly change token to random token\\n elif prob < 0.9:\\n tokens[i] = random.choice(list(tokenizer.vocab.items()))[0]\\n\\n # -> rest 10% randomly keep current token\\n\\n # append current token to output (we will predict these later)\\n try:\\n output_label.append(tokenizer.vocab[token])\\n except KeyError:\\n # For unknown words (should not occur with BPE vocab)\\n output_label.append(tokenizer.vocab[\\\"[UNK]\\\"])\\n else:\\n # no masking token (will be ignored by loss function later)\\n output_label.append(-100)\\n\\n\\n return tokens, output_label\",\n \"def evaluate():\\n global dictionary, wv\\n count = 0\\n # To save the scores by distance and similarity\\n scores = np.zeros(6)\\n similar = np.zeros(6)\\n itr = len(dictionary)\\n logging.info('running evaluation for {0} samples'.format(itr))\\n for key in dictionary:\\n progress = (count / itr) * 100\\n d = dictionary[key].split('resource/')\\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\\n try:\\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\\n dtype=np.float32)\\n except KeyError:\\n itr -= 1\\n continue\\n if np.any(np.isnan(r)):\\n itr -= 1\\n continue\\n else:\\n if r.ndim == 2:\\n try:\\n # Mean of vector containing all word vectors\\n # obtained from abstract.\\n r = r.mean(axis=0).reshape(1, -1)\\n \\n # Obtain the vectors for the entity\\n mean_vec = mean_encoder(dictionary[key])\\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\\n mean_dist_vec = distance_encoder(dictionary[key])\\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\\n title_vec = title_mean(key)\\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\\n abstract_vec = abstract_encoder(key)\\n abstract_vec = abstract_vec.reshape(1, -1)\\n abstract_vec = abstract_vec / norm(abstract_vec)\\n random_vec = np.random.randn(100).reshape(1, -1)\\n zero_vec = np.zeros(100).reshape(1, -1)\\n \\n # Score the entity vectors\\n scores[0] += norm(r - mean_vec)\\n scores[1] += norm(r - mean_dist_vec)\\n scores[2] += norm(r - title_vec)\\n scores[3] += norm(r - abstract_vec)\\n scores[4] += norm(r - random_vec)\\n scores[5] += norm(r - zero_vec)\\n similar[0] += cosine_similarity(r, mean_vec)\\n similar[1] += cosine_similarity(r, mean_dist_vec)\\n similar[2] += cosine_similarity(r, title_vec)\\n similar[3] += cosine_similarity(r, abstract_vec)\\n similar[4] += cosine_similarity(r, random_vec)\\n similar[5] += cosine_similarity(r, zero_vec)\\n count += 1\\n print(count, end='\\\\r')\\n except (ValueError, KeyError) as _:\\n itr -= 1\\n continue\\n else:\\n itr -= 1\\n continue\\n # Normalize the scores to get a better\\n # comparison against the baselines.\\n scores = scores / norm(scores)\\n similar = similar / norm(similar)\\n print_summary(scores, similar)\",\n \"def make_idx2word():\\n idx2word = {}\\n d = train_data.shared['word2idx']\\n for word, idx in d.items():\\n print(word)\\n idx2word[idx] = word\\n if config.use_glove_for_unk:\\n d2 = train_data.shared['new_word2idx']\\n for word, idx in d2.items():\\n print(word)\\n idx2word[idx+len(d)] = word\\n return idx2word\",\n \"def add(vector, ngram):\\n if ngram in vector:\\n vector[ngram] += 1\\n else:\\n vector[ngram] = 1\",\n \"def __init__(self, word, index):\\n self.word = word\\n self.index = index\\n self.number = 1\\n self.idf = 0.0\",\n \"def get_word_vector(doc_id, corpus):\\n inv_index = vsm_retrieval.get_inverted_index(corpus)\\n word_vec = np.zeros(len(inv_index))\\n for count_vec, word in enumerate(inv_index):\\n word_vec[count_vec] = inv_index[word].get(doc_id, {'frequency': 0})['frequency']\\n return word_vec\",\n \"def add_embedding(self, token, embedding):\\n self.word2idx[token] = self.vocab_size\\n self.vocab_size += 1\\n\\n self.embedding = np.vstack((self.embedding, embedding))\",\n \"def process_user_input(user_input, vocab, word_to_idx):\\n user_input_tokens = word_tokenize(user_input)\\n user_input_tokens = [w.lower() for w in user_input_tokens]\\n\\n bow_vec = np.zeros(len(word_to_idx), dtype=np.float)\\n unk_counter = 0\\n\\n for word in user_input_tokens:\\n if word not in vocab:\\n word = \\\"unk\\\"\\n unk_counter += 1\\n bow_vec[word_to_idx[word]] += 1\\n else:\\n bow_vec[word_to_idx[word]] += 1\\n\\n unk_percent = round(100*(unk_counter / len(user_input_tokens)),2)\\n return user_input_tokens, bow_vec, unk_percent\",\n \"def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\\r\\n input_string_x1=input_string_x1.decode(\\\"utf-8\\\")\\r\\n input_string_x2 = input_string_x2.decode(\\\"utf-8\\\")\\r\\n #1. get blue score vector\\r\\n feature_list=[]\\r\\n #get blue score with n-gram\\r\\n for i in range(n_gram):\\r\\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\\r\\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\\r\\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\\r\\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\\r\\n feature_list.append(blue_score_i_1)\\r\\n feature_list.append(blue_score_i_2)\\r\\n\\r\\n #2. get length of questions, difference of length\\r\\n length1=float(len(input_string_x1))\\r\\n length2=float(len(input_string_x2))\\r\\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\\r\\n feature_list.append(length_diff)\\r\\n\\r\\n #3. how many words are same, how many words are unique\\r\\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\\r\\n feature_list.extend(sentence_diff_overlap_features_list)\\r\\n\\r\\n #4. question 1,2 start with how/why/when\\r\\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\\r\\n #print(\\\"how_why_feature_list:\\\",how_why_feature_list)\\r\\n #feature_list.extend(how_why_feature_list)\\r\\n\\r\\n #5.edit distance\\r\\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\\r\\n feature_list.append(edit_distance)\\r\\n\\r\\n #6.cos distance from sentence embedding\\r\\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\\r\\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\\r\\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\\r\\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\\r\\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\\r\\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\\r\\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\\r\\n feature_list.extend(distance_list_fasttext)\\r\\n feature_list.extend(distance_list_word2vec)\\r\\n #feature_list.extend(list(sentence_diffence))\\r\\n #feature_list.extend(list(sentence_multiply))\\r\\n return feature_list\",\n \"def word_frequency( tokenized, dic ):\\n print( 'computing word frequencies' )\\n start = time.time()\\n for i, text in enumerate( tokenized ):\\n for token in text:\\n if token not in dic:\\n dic[ token ] = 1\\n else:\\n dic[ token ] += 1\\n if i % 10000 == 0:\\n sys.stdout.write( '\\\\rprocessed : {}/{} reviews in {}s'.format( i, NO_REVIEWS, time.time() - start ) )\\n sys.stdout.write( '\\\\rprocessed : {}/{} reviews in {}s\\\\n'.format( i, NO_REVIEWS, time.time() - start ) )\",\n \"def add_word(self, word):\\n if word not in self.word2index:\\n self.word2index[word] = self.n_words\\n self.word2count[word] = 1\\n self.index2word[self.n_words] = word\\n self.n_words += 1\\n else:\\n self.word2count[word] += 1\",\n \"def add_word(self, word):\\n if word not in self.word2index:\\n self.word2index[word] = self.n_words\\n self.word2count[word] = 1\\n self.index2word[self.n_words] = word\\n self.n_words += 1\\n else:\\n self.word2count[word] += 1\",\n \"def nrc_hashtag_emotion(self, tokens):\\n num_features = 10 # 'anger', 'anticipation', 'disgust', 'fear', 'joy', 'negative', 'positive', 'sadness', 'surprise', 'trust'\\n sum_vec = [0.0] * num_features\\n for token in tokens:\\n if token in self.nrc_hashtag_emotion_map:\\n sum_vec = [a + b for a, b in zip(sum_vec, self.nrc_hashtag_emotion_map[token])] # sum up the individual word feature vectors\\n feature_names = ['anger', 'anticipation', 'disgust', 'fear', 'joy', 'negative', 'positive', 'sadness', 'surprise', 'trust']\\n feature_names = ['nrc_hashtag_emotion_' + name for name in feature_names]\\n return dict(zip(feature_names, sum_vec))\",\n \"def _update_feature_vec(fvec, word, tag_ngram):\",\n \"def processFeature(prevWord, word, vector):\\n \\n # We add feature whether it exists or not\\n unigram, exists = vector.getUnigram(prevWord)\\n if not exists:\\n vector.addUnigram(prevWord)\\n \\n \\n bigram, exists = vector.getBigram(prevWord, word)\\n if not exists:\\n vector.addBigram(prevWord, word)\",\n \"def score(self, sentence):\\n score = 0.0\\n V = len(self.f1) # vocabulary size\\n for token in sentence:\\n if token in self.f1: score += self.f1[token]\\n else: score -= math.log10(self.total + V)\\t\\t # OOV \\n return score\",\n \"def getrandom(hist):\\n word, freq = random.choice(list(hist.items()))\\n return word\",\n \"def review_to_vec(words, model, num_features , index2word_set):\\n \\n feature_vec = np.zeros((num_features), dtype=\\\"float32\\\")\\n word_count = 0\\n \\n \\n \\n for word in words:\\n if word in index2word_set: \\n word_count += 1\\n feature_vec += model[word]\\n\\n if word_count == 0:\\n word_count = 1\\n\\n feature_vec /= word_count\\n\\n return feature_vec\",\n \"def word_average(self, sent):\\n\\n mean = []\\n for word in sent:\\n if word in self.word_model.wv.vocab:\\n mean.append(self.word_model.wv.get_vector(word) *\\n self.word_idf_weight[word]) # idf weighted\\n\\n if not mean: # empty words\\n # If a text is empty, return a vector of zeros.\\n logging.warning(\\n \\\"cannot compute average owing to no vector for {}\\\".format(sent))\\n return np.zeros(self.vector_size)\\n else:\\n mean = np.array(mean).mean(axis=0)\\n return mean\",\n \"def train(self, corpus): \\n for sentence in corpus.corpus:\\n last_token = None\\n for datum in sentence.data:\\n token = datum.word\\n self.ntokens += 1\\n self.counts[token] += 1\\n if last_token:\\n self.counts[(last_token, token)] += 1\\n last_token = token\\n\\n for sentence in corpus.corpus:\\n last_token = None\\n for datum in sentence.data:\\n token = datum.word\\n if last_token:\\n tup = (last_token, token)\\n if self.counts[tup]:\\n self.s[tup] = math.log(1.0 * self.counts[tup] / self.counts[last_token])\\n else: # backing off\\n if self.s[token] == 0:\\n self.s[token] = math.log(1.0 * (self.counts[token] + 1) / (self.ntokens * 2))\\n self.s[tup] = math.log(0.4 * self.s[token])\\n last_token = token\",\n \"def random_word(hist):\\n \\n t=[]\\n\\n for word, freq in hist.items():\\n t.extend([word]*freq)\\n\\n return random.choice(t)\",\n \"def bag_of_words(tokenized_sentence, all_words):\\n\\n tokenized_sentence = [stem(w) for w in tokenized_sentence]\\n #print(tokenized_sentence)\\n bag = np.zeros_like(all_words, dtype=np.float32)\\n for idx, w in enumerate(all_words):\\n if w in tokenized_sentence:\\n bag[idx] = 1.0\\n\\n return bag\",\n \"def get_pretrained_weights(idx_word):\\n n = len(idx_word)\\n embed_dim = 25\\n weights = mx.ndarray.zeros((n, embed_dim))\\n print('Start downloading pre-trained vectors, this will take some time')\\n glov = api.load(\\\"glove-twitter-25\\\")\\n print('Pre-trained vectors downloading complete')\\n not_in_vocab = 0\\n for i in range(n):\\n word = idx_word[i]\\n try:\\n weights[i] = glov[word]\\n except: #if not in glove vocabulary\\n not_in_vocab += 1\\n weights[i] = mx.nd.random.normal(0, 0.1, embed_dim)\\n if not_in_vocab > 0:\\n print('Warning: {} words not in vocab of pretrained embeddings (glove-twitter-25)'.format(not_in_vocab))\\n return weights\",\n \"def create_vectors(list_dict, num_words):\\n x = [] # list that will hold data \\n\\n for d in list_dict:\\n # initializing numpy vector\\n # it contains 5,000 (number of words) zeros\\n temp = np.zeros(num_words, dtype=np.float64)\\n for key, val in d.items():\\n if key < num_words:\\n key -= 1 # indexing in data starts at 1\\n temp[key] = 1 # adding word and its frequency to vector \\n # temp[key] = val\\n x.append(temp) # appends vector to x \\n\\n return x\",\n \"def build_index(token_seq, min_freq=100, max_features=1000, downsample=0):\\n passes = 4\\n if downsample > 0:\\n passes += 1\\n\\n term_vocab = set()\\n char_vocab = set([u' '])\\n term_freqs = defaultdict(int)\\n token_seq_index = defaultdict(list)\\n below_min_freq = set()\\n\\n # Include most of the characters we care about. We add any remaining\\n # characters after this loop.\\n for charlist in [string.ascii_letters, string.punctuation, range(10)]:\\n for ch in charlist:\\n char_vocab.add(unicode(str(ch)))\\n\\n pass_num = 1\\n print('pass {pass_num} of {passes}: scanning tokens'.format(\\n pass_num=pass_num, passes=passes))\\n pass_num += 1\\n pbar = progressbar.ProgressBar(term_width=40,\\n widgets=[' ', progressbar.Percentage(),\\n ' ', progressbar.ETA()],\\n maxval=len(token_seq)).start()\\n\\n for i, token in enumerate(token_seq):\\n pbar.update(i+1)\\n\\n if not is_word(token) or len(token) == 1:\\n continue\\n\\n if term_freqs[token] == 0:\\n below_min_freq.add(token)\\n elif term_freqs[token] > min_freq:\\n try:\\n below_min_freq.remove(token)\\n except KeyError:\\n pass\\n\\n term_freqs[token] += 1\\n token_seq_index[token].append(i)\\n\\n for ch in token:\\n char_vocab.add(unicode(ch))\\n\\n pbar.finish()\\n\\n print('# of terms: ' + str(len(term_freqs)))\\n\\n print('pass {pass_num} of {passes}: removing infrequent terms'.format(\\n pass_num=pass_num, passes=passes))\\n pass_num += 1\\n pbar = progressbar.ProgressBar(term_width=40,\\n widgets=[' ', progressbar.Percentage(),\\n ' ', progressbar.ETA()],\\n maxval=len(term_freqs)).start()\\n\\n for i, term in enumerate(below_min_freq):\\n pbar.update(i+1)\\n del term_freqs[term]\\n del token_seq_index[term]\\n\\n pbar.finish()\\n print('# of terms: ' + str(len(term_freqs)))\\n\\n print('pass {pass_num} of {passes}: sorting terms by frequency'.format(\\n pass_num=pass_num, passes=passes))\\n pass_num += 1\\n most_to_least_freq = sorted(term_freqs.iteritems(),\\n key=itemgetter(1), reverse=True)\\n print('')\\n\\n term_i = 0\\n term_to_index = {}\\n index_to_term = {}\\n\\n print('pass {pass_num} of {passes}: building term index'.format(\\n pass_num=pass_num, passes=passes))\\n pass_num += 1\\n pbar = progressbar.ProgressBar(term_width=40,\\n widgets=[' ', progressbar.Percentage(),\\n ' ', progressbar.ETA()],\\n maxval=len(most_to_least_freq)).start()\\n\\n for i, (term, freq) in enumerate(most_to_least_freq):\\n pbar.update(i+1)\\n\\n if len(term_vocab) == max_features:\\n del token_seq_index[term]\\n continue\\n\\n term_vocab.add(term)\\n term_to_index[term] = term_i\\n index_to_term[term_i] = term \\n term_i += 1\\n\\n pbar.finish()\\n\\n if downsample > 0:\\n print('pass {pass_num} of {passes}: downsampling'.format(\\n pass_num=pass_num, passes=passes))\\n pass_num += 1\\n pbar = progressbar.ProgressBar(term_width=40,\\n widgets=[' ', progressbar.Percentage(),\\n ' ', progressbar.ETA()],\\n maxval=len(token_seq_index)).start()\\n rng = random.Random(17)\\n for i, token in enumerate(token_seq_index.keys()):\\n pbar.update(i+1)\\n indices = token_seq_index[token]\\n token_seq_index[token] = random.sample(indices, downsample)\\n pbar.finish()\\n\\n char_to_index = dict((c,i+1) for i,c in enumerate(char_vocab))\\n char_to_index['NONCE'] = 0\\n\\n return token_seq_index, char_to_index, term_to_index\",\n \"def nrc_affect_intensity(self, tokens): \\n num_features = 10 # 'anger', 'anticipation', 'disgust', 'fear', 'joy', 'negative', 'positive', 'sadness', 'surprise', 'trust'\\n sum_vec = [0.0] * num_features\\n for token in tokens:\\n if token in self.nrc_affect_intensity_map:\\n sum_vec = [a + b for a, b in zip(sum_vec, self.nrc_affect_intensity_map[token])]\\n \\n feature_names = ['anger', 'anticipation', 'disgust', 'fear', 'joy', 'negative', 'positive', 'sadness', 'surprise', 'trust']\\n feature_names = ['nrc_affect_intensity_' + name for name in feature_names]\\n return dict(zip(feature_names, sum_vec))\",\n \"def short_vector(self, splitted_words, max_array_size=26):# iterate in another way\\r\\n self.coder=\\\"An_real_word_vector_algorith_that_uses_the_letter_position_in_a_dictionary\\\"\\r\\n storage=[]#create an array storage\\r\\n not_found=[]#store the unkown words\\r\\n array=self.create_new_array(shape=(max_array_size,1),replace=True)# build an new arry and fill it with -1s then 0s\\r\\n array_position=0#set the positon in the array equal to 0; used to move around the array\\r\\n if len(self.special_characters_dic)>0:# checks if there are items in these dictionary\\r\\n for i in splitted_words:# iterate thorugh the list of splitted words\\r\\n for word in i: # iterate through the list of letters\\r\\n if word in self.general_lower_word_list:# now figure out if the letter is in that dictionary\\r\\n array[array_position]=self.general_lower_word_list[word]# and replace these with its number at the given array positon\\r\\n array_position+=1#add one to the positon to move to the next row in the array\\r\\n elif word in self.general_upper_word_list:\\r\\n array[array_position]=self.upper_word_dic[word]\\r\\n array_position+=1\\r\\n elif word in self.special_letters_dic:\\r\\n array[array_position]=self.special_letters_dic[word]\\r\\n array_position+=1\\r\\n elif word in self.general_numbers_dic:\\r\\n array[array_position]=self.general_numbers_dic[word]\\r\\n array_position+=1\\r\\n elif word in self.special_characters_dic:\\r\\n array[array_position]=self.special_characters_dic[word]\\r\\n array_position+=1\\r\\n else:\\r\\n print(\\\"This word is not know by the list: \\\"+word)\\r\\n not_found.append(word)\\r\\n storage.append(array)\\r\\n array_position=0\\r\\n array=self.create_new_array(shape=(max_array_size,1),replace=True)\\r\\n else:\\r\\n for i in splitted_words:\\r\\n for word in i:\\r\\n if word in self.general_lower_word_list:\\r\\n array[array_position]=self.general_lower_word_list[word]\\r\\n array_position+=1\\r\\n #print(array)\\r\\n elif word in self.upper_word_dic:\\r\\n array[array_position]=self.upper_word_dic[word]\\r\\n array_position+=1\\r\\n #print(array)\\r\\n elif word in self.special_letters_dic:\\r\\n array[array_position]=self.special_letters_dic[word]\\r\\n array_position+=1\\r\\n #print(array)\\r\\n elif word in self.general_numbers_dic:\\r\\n array[array_position]=self.general_numbers_dic[word]\\r\\n array_position+=1\\r\\n #print(array)\\r\\n else:\\r\\n print(\\\"This word is not know by the list: \\\"+word)\\r\\n not_found.append(word)\\r\\n pass\\r\\n storage.append(array)\\r\\n array_position=0\\r\\n array=self.create_new_array(shape=(max_array_size,1),replace=True)\\r\\n return storage,not_found\",\n \"def get_word():\\n word=words_dict[randrange(0,len(words_dict))]\\n return word\",\n \"def get_word():\\n word=words_dict[randrange(0,len(words_dict))]\\n return word\",\n \"def get_word():\\n word=words_dict[randrange(0,len(words_dict))]\\n return word\",\n \"def _get_mean_embedding(self, words):\\n\\n # ensure the size still matches if it's loaded from pretrained word vectors\\n size = self.size\\n if self.w2v is not None:\\n size = next(iter(self.w2v_.values())).size\\n\\n zero = np.zeros(size)\\n if self.tfidf:\\n embedding = np.mean([self.w2v_[w] * self.w2idf_[w]\\n if w in self.w2v_ else zero for w in words], axis = 0)\\n else:\\n embedding = np.mean([self.w2v_.get(w, zero) for w in words], axis = 0)\\n\\n return embedding\",\n \"def build_doc_sense_vec(self):\\n\\t\\twith codecs.open(self.vocab_file, encoding='utf-8', mode='r') as infile:\\n\\t\\t\\tline = infile.readline()\\n\\t\\t\\ti = 0\\n\\t\\t\\twhile line:\\n\\t\\t\\t\\tword = line.split()[0]\\n\\t\\t\\t\\tif not self.word2IdVocabulary.has_key(word):\\n\\t\\t\\t\\t\\t# print i, word\\n\\t\\t\\t\\t\\t# else:\\n\\t\\t\\t\\t\\tself.word2IdVocabulary[word] = i\\n\\t\\t\\t\\tif not self.id2WordVocabulary.has_key(i):\\n\\t\\t\\t\\t\\tself.id2WordVocabulary[i] = word\\n\\t\\t\\t\\tline = infile.readline()\\n\\t\\t\\t\\ti += 1\\n\\t\\t\\tself.vocab_num = len(self.word2IdVocabulary)\\n\\t\\t\\tprint \\\"vocabulary number:\\\" + str(self.vocab_num)\\n\\n\\t\\twith codecs.open(self.vec_file, encoding='utf-8', mode='r') as vecfile:\\n\\t\\t\\twith codecs.open(self.vec_out_file, encoding='utf-8', mode='a+') as vec_outfile:\\n\\n\\t\\t\\t\\tfor i, line in enumerate(vecfile):\\n\\t\\t\\t\\t\\tif i % 10000 == 0:\\n\\t\\t\\t\\t\\t\\tprint i\\n\\t\\t\\t\\t\\t# if i > 72:\\n\\t\\t\\t\\t\\t# \\tbreak\\n\\t\\t\\t\\t\\tif i == 0:\\n\\t\\t\\t\\t\\t\\ta, b, c = map(int, line.split()[:3])\\n\\t\\t\\t\\t\\t\\tprint('Number of sememes: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t 'Number of words: {}\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t 'Dimension of vectors: {}'.format(a, b, c))\\n\\t\\t\\t\\t\\telif i > 462667:\\n\\t\\t\\t\\t\\t\\tsline = line.strip('\\\\n').split()\\n\\t\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\t\\tvector_list.append(sline[1:])\\n\\t\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[word]\\n\\t\\t\\t\\t\\t\\tif not self.vectors.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vectors[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\t# vector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t\\tif not self.vector_mean.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vector_mean[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\t# vec_outfile.write(line)\\n\\t\\t\\t\\t\\telif i > 462887:\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tsline = line.strip('\\\\n').split()\\n\\t\\t\\t\\t\\t\\tword = sline[0]\\n\\t\\t\\t\\t\\t\\tsense_num = int(sline[1])\\n\\t\\t\\t\\t\\t\\tvectors = sline[2:sense_num*c+2] # (sense_num*c+2)\\n\\t\\t\\t\\t\\t\\tvector_list = []\\n\\t\\t\\t\\t\\t\\tfor start in range(0, len(vectors), c):\\n\\t\\t\\t\\t\\t\\t\\tvector_list.append(list(map(float, vectors[start: start+c])))\\n\\t\\t\\t\\t\\t\\tvector_array = np.array(vector_list)\\n\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[word]\\n\\t\\t\\t\\t\\t\\tif not self.vectors.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vectors[word_id] = vector_array\\n\\t\\t\\t\\t\\t\\tvector_mean = np.mean(vector_array, axis=0)\\n\\t\\t\\t\\t\\t\\tif not self.vector_mean.has_key(word_id):\\n\\t\\t\\t\\t\\t\\t\\tself.vector_mean[word_id] = vector_mean\\n\\t\\t\\t\\t\\t\\t'''j = 0\\n\\t\\t\\t\\t\\t\\tfor each_sense_vec in vector_array:\\n\\t\\t\\t\\t\\t\\t\\tif len(vector_array) > 1:\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_line = word + '_' + str(j) + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tformatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\\\n'\\n\\t\\t\\t\\t\\t\\t\\t\\tj += 1\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_line = word + ' ' + np.array2string(each_sense_vec, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter={'float_kind': lambda\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t x: '%6f' % x})[1:-1] + '\\\\n'\\n\\n\\t\\t\\t\\t\\t\\t\\tvec_outfile.write(new_line)'''\\n\\n\\t\\twith codecs.open(self.doc_file, encoding='utf-8', mode='r') as docfile:\\n\\t\\t\\twith codecs.open(self.doc_out_file, encoding='utf-8', mode='a+') as doc_outfile:\\n\\t\\t\\t\\twith codecs.open(self.vec_out_file_bydoc, encoding='utf-8', mode='a+') as vec_outfile_bydoc:\\n\\t\\t\\t\\t\\tprint \\\"Processing document file......\\\"\\n\\t\\t\\t\\t\\tline = docfile.readline().strip('\\\\n')\\n\\t\\t\\t\\t\\twhile line:\\n\\t\\t\\t\\t\\t\\twords = line.split()\\n\\t\\t\\t\\t\\t\\tnew_words = [x for x in words]\\n\\t\\t\\t\\t\\t\\tfor i in range(len(words)):\\n\\t\\t\\t\\t\\t\\t\\tword_id = self.word2IdVocabulary[words[i]]\\n\\t\\t\\t\\t\\t\\t\\tsense_vecs = self.vectors[word_id]\\n\\t\\t\\t\\t\\t\\t\\tsense_num = len(sense_vecs)\\n\\t\\t\\t\\t\\t\\t\\tif sense_num > 1:\\n\\t\\t\\t\\t\\t\\t\\t\\tcontext_words = []\\n\\t\\t\\t\\t\\t\\t\\t\\tfor x in range(i-int(self.context_num), i+int(self.context_num)+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif x != i and 0 <= x < len(words):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tcontext_words.append(words[x])\\n\\t\\t\\t\\t\\t\\t\\t\\tsense_index = self.select_attention(context_words, sense_vecs)\\n\\t\\t\\t\\t\\t\\t\\t\\tword_vec_i = sense_vecs[sense_index]\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_wordi = words[i] + '_' + str(sense_index)\\n\\t\\t\\t\\t\\t\\t\\t\\tself.vector_word_doc[new_wordi.encode('utf-8')] = word_vec_i\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_words[i] = new_wordi\\n\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tword_vec_i = sense_vecs[0]\\n\\t\\t\\t\\t\\t\\t\\t\\tself.vector_word_doc[words[i].encode('utf-8')] = word_vec_i\\n\\t\\t\\t\\t\\t\\t\\tvec_outfile_bydoc.write(new_words[i] + ' ' + np.array2string(word_vec_i, max_line_width=2000,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t formatter={'float_kind': lambda x: '%6f' % x})[1:-1] + '\\\\n')\\n\\n\\t\\t\\t\\t\\t\\tdoc_outfile.write(' '.join(new_words) + '\\\\n')\\n\\n\\t\\t\\t\\t\\t\\tline = docfile.readline()\\n\\n\\t\\treturn self.vector_word_doc\",\n \"def word_average(self, sent):\\n mean = []\\n for word in sent:\\n if word in self.word_model.wv.vocab:\\n mean.append(self.word_model.wv.get_vector(word))\\n\\n if not mean: # empty words\\n # If a text is empty, return a vector of zeros.\\n logging.warning(\\n \\\"cannot compute average owing to no vector for {}\\\".format(sent))\\n return np.zeros(self.vector_size)\\n else:\\n mean = np.array(mean).mean(axis=0)\\n return mean\",\n \"def _encode(self, tokens: List[str], mean: bool) -> Union[List[np.ndarray], np.ndarray]:\\n if self.vectorizer:\\n detokenized_sample = self.tokenizer([tokens])[0] # str\\n vectorized_sample = self.vectorizer([detokenized_sample]) # (voc_size,)\\n\\n weights = np.array([vectorized_sample[0, np.where(self.vocabulary == token)[0][0]]\\n if len(np.where(self.vocabulary == token)[0]) else 0.\\n for token in tokens])\\n else:\\n weights = np.array([self.get_weight(max(self.counter_vocab.get(token, 0), self.idf_base_count))\\n for token in tokens])\\n\\n if sum(weights) == 0:\\n weights = np.ones(len(tokens))\\n\\n embedded_tokens = np.array(self.embedder([tokens]))[0, :, :]\\n\\n if mean is None:\\n mean = self.mean\\n\\n if mean:\\n embedded_tokens = np.average(embedded_tokens, weights=weights, axis=0)\\n else:\\n embedded_tokens = np.array([weights[i] * embedded_tokens[i] for i in range(len(tokens))])\\n\\n return embedded_tokens\",\n \"def vectorize_word(word):\\n if word in Tfidf_vect.vocabulary_:\\n i = Tfidf_vect.vocabulary_[word]\\n return Tfidf_vect.idf_[i]\\n else:\\n return 0\",\n \"def score(self, sentence):\\n # TODO your code here\\n\\n # initialize count with trained data\\n unigram_count = self.count.copy()\\n N = self.total\\n\\n # make a new key for UNK, add-one later\\n for token in sentence:\\n if token not in unigram_count:\\n unigram_count[token] = 0\\n\\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\\n score = 0.0 # P(<s>) = 1\\n V = len(unigram_count) # the number of vocab including UNK\\n for word in sentence:\\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\\n score += math.log(prob)\\n\\n return score\",\n \"def __add_to_word_dict__(self, word, tag):\\n if self.word_dict.get(word, None) is None:\\n self.word_dict[word] = defaultdict(int)\\n self.word_dict[word][tag] += 1\",\n \"def add_paragram(self):\\n num_new_words = 720000\\n new_embeddings = np.empty((num_new_words, self.embedding_size))\\n concat_emb = np.zeros((2, self.embedding_size))\\n new_word2idx = dict()\\n new_words_count = 0\\n\\n self.load_all()\\n fi = open(self.config.word_vec_fi_paragram, \\\"r\\\", encoding=\\\"utf8\\\",\\n errors='ignore')\\n embed_gen = self.embeddings_file_gen(fi)\\n\\n for token, embedding in embed_gen:\\n if token not in self.word2idx:\\n new_word2idx[token] = self.vocab_size\\n new_embeddings[new_words_count, :] = embedding\\n self.vocab_size += 1\\n new_words_count += 1\\n else:\\n concat_emb[0, :] = self.embedding[self.word2idx[token]]\\n concat_emb[1, :] = embedding\\n self.embedding[self.word2idx[token]] = np.mean(\\n concat_emb,\\n axis=0\\n )\\n\\n self.word2idx.update(new_word2idx)\\n self.embedding = np.vstack((\\n self.embedding,\\n new_embeddings[:new_words_count, :]\\n ))\\n\\n self.write_all()\\n fi.close()\",\n \"def _WordSimAveVec(self,df,a):\\r\\n #Obtain the course description for the course provided and convert the string into a list of individual words.\\r\\n Description = df['description'][a].split()\\r\\n #Create a placeholder zero vector of the same size as the vector embedding.\\r\\n Vector = np.zeros(self.WordVecModel.layer1_size)\\r\\n wordCount = 0\\r\\n #Iterate over each word in the description.\\r\\n for word in Description:\\r\\n #If the word is in the trained vocabulary, obtain the word vector. \\r\\n #Continue to add the word vectors to the placeholder vector to get the running sum.\\r\\n if word in self.WordVecModel.wv.vocab:\\r\\n vector = self.WordVecModel.wv.get_vector(word)\\r\\n Vector +=vector\\r\\n #Keep track of how many word vectors (which were included in the vocabulary) were added.\\r\\n wordCount +=1\\r\\n #Calculate the mean by dividing the sum by the number of vectors.\\r\\n return Vector/wordCount\",\n \"def similarity(query,word_dict,dictionary,number_of_docs,id):\\n similarity = 0.0\\n scalar_leng = 0.0\\n for term in query:\\n if term in dictionary:\\n similarity += word_dict[term][1]*imp(term,word_dict,number_of_docs,id)\\n\\n for term in dictionary:\\n scalar_leng += imp(term, word_dict, number_of_docs, id) ** 2\\n\\n final_scalar_leng = math.sqrt(scalar_leng)\\n similarity = similarity / final_scalar_leng\\n #print(similarity)\\n return similarity\",\n \"def _init_vocab(self):\\n self._word2idx = {}\\n self._idx2word = {}\\n self.freqs = {}\\n self.vocab_size = 0\\n\\n self._add_word(self.pad_word)\\n self._add_word(self.start_word)\\n self._add_word(self.end_word)\\n self._add_word(self.unk_word)\\n\\n self.start_word_idx = self.stoi(self.start_word)\\n self.end_word_idx = self.stoi(self.end_word)\\n self.unk_word_idx = self.stoi(self.unk_word)\\n self.pad_word_idx = self.stoi(self.pad_word)\\n\\n self._special_tokens = {\\n 'bos_token': self.start_word,\\n 'cls_token': self.start_word,\\n 'eos_token': self.end_word,\\n 'sep_token': self.end_word,\\n 'pad_token': self.pad_word,\\n 'unk_token': self.unk_word,\\n }\\n\\n self._special_ids = {\\n 'bos_token_id': self.start_word_idx,\\n 'cls_token_id': self.start_word_idx,\\n 'eos_token_id': self.end_word_idx,\\n 'sep_token_id': self.end_word_idx,\\n 'pad_token_id': self.pad_word_idx,\\n 'unk_token_id': self.unk_word_idx,\\n }\\n\\n self.cls_token_id = self.bos_token_id = self.start_word_idx\\n self.eos_token_id = self.sep_token_id = self.end_word_idx\\n self.pad_token_id = self.pad_word_idx\\n self.unk_token_id = self.unk_word_idx\\n\\n self.cls_token = self.bos_token = self.start_word\\n self.eos_token = self.sep_token = self.end_word\\n self.pad_token = self.pad_word\\n self.unk_token = self.unk_word\",\n \"def _calculate_word_value(self, _word_total, word):\\n for each_letter in word:\\n _word_total += SCRABBLE_POINT_DICT[each_letter]\\n return _word_total\",\n \"def getReviewsWithToken(self, token):\\n\\n wordid = self.find_word_in_dictionary(token)\\n # word is not in the dictionary\\n if wordid == -1:\\n print(\\\"Token is not in the dictionary\\\")\\n return 0\\n\\n with open(self.doc_to_words_path, 'rb') as bin:\\n tup = []\\n while bin.tell() != os.fstat(bin.fileno()).st_size:\\n # get wordid:\\n docid_in_file = int.from_bytes(bin.read(4), 'big')\\n # get frequency:\\n frequency = int.from_bytes(bin.read(4), 'big')\\n # count words:\\n count = 0\\n for i in range(frequency):\\n wordid_in_file = int.from_bytes(bin.read(4), 'big')\\n if wordid == wordid_in_file:\\n count += 1\\n tup.append(docid_in_file)\\n tup.append(count)\\n return tuple(tup)\",\n \"def add(self, key, idx=None, count=1):\\n key = self.lower_(key)\\n if idx is not None:\\n self.index2word[idx] = key\\n self.word2index[key] = idx\\n else:\\n if key not in self.word2index:\\n idx = len(self.word2index)\\n self.index2word[idx] = key\\n self.word2index[key] = idx\\n\\n if key not in self.word_count:\\n self.word_count[key] = count\\n else:\\n self.word_count[key] += count\",\n \"def preprocessing():\\n english_dictionary = nltk.corpus.brown.words()\\n slang_vocab = pickle.load(open('vocab_pattern_match_with_freq.pkl', 'rb'))\\n\\n normalize_english_dict = len(english_dictionary)\\n normalize_slang_vocab = 0\\n for w, n in slang_vocab.items():\\n normalize_slang_vocab += n\\n\\n words = {}\\n for w, n in Counter(english_dictionary).items():\\n words[w] = n/normalize_english_dict\\n \\n for w, n in slang_vocab.items():\\n if w not in words:\\n words[w] = 0.\\n words[w] += n/normalize_slang_vocab\\n\\n words_by_freq = [w for w,_ in sorted(words.items(), key=lambda x: x[1], reverse=True)]\\n\\n # Build a cost dictionary, assuming Zipf's law and cost = -math.log(probability).\\n #words = open(\\\"words_by_frequency.txt\\\").read().split()\\n wordcost = dict((k, log((i+1)*log(len(words_by_freq)))) for i,k in enumerate(words_by_freq))\\n maxword = max(len(x) for x in words_by_freq)\\n return wordcost,maxword\",\n \"def random_word(hist):\\n t = []\\n for word, freq in hist.items():\\n t.extend([word] * freq)\\n\\n return random.choice(t)\",\n \"def train(self, tokens):\\n if len(tokens) == 0: # Empty tokens\\n return pd.Series(dtype=float).astype(float)\\n \\n index = pd.Series(tokens).unique() # Word index\\n return pd.Series([1 / len(index)] * len(index), index=index)\",\n \"def __getitem__(self, index):\\r\\n target_word_index = self.data[index + self.skip_window]\\r\\n random_index = random.randint(0 , 2*self.skip_window -1)\\r\\n if random_index >= self.skip_window:\\r\\n context_word_index = self.data[index + (random_index - self.skip_window + 1)]\\r\\n else:\\r\\n context_word_index = self.data[index + (random_index - self.skip_window)]\\r\\n #print ('getitem:', target_word_index, context_word_index)\\r\\n \\r\\n return (target_word_index, context_word_index)\\r\\n \\r\\n #raise NotImplementedError('Implement the __getitem__ method of the dataset')\\r\",\n \"def encode_samples(tokenized_samples, word_to_idx):\\n features = []\\n for sample in tokenized_samples:\\n feature = []\\n for token in sample:\\n if token in word_to_idx:\\n feature.append(word_to_idx[token])\\n else:\\n feature.append(0)\\n features.append(feature)\\n return features\",\n \"def add(self, tokens):\\n\\n for token in tokens:\\n self.vocab.add(token)\\n\\n for leader, token in generate_ngrams(tokens, self.size, include_terminator = self.size != 1):\\n if leader not in self.frequencies:\\n self.frequencies[leader] = Frequency()\\n\\n self.frequencies[leader].add(token)\",\n \"def embed_token(self, token):\\r\\n embs, words = [], token.split()\\r\\n for word in words:\\r\\n emb_list=[]\\r\\n for element in word.split('_'):\\r\\n # If we have a trailing _ we don't want to embed an empty string\\r\\n if element:\\r\\n emb,_ = self(element, mean_sequence=True)\\r\\n emb_list.append(emb)\\r\\n embs.append(torch.mean(torch.stack(emb_list), dim=0))\\r\\n\\r\\n return torch.mean(torch.stack(embs), dim=0)\",\n \"def known_word():\\n global rand_word\\n data.remove(rand_word) # Removes the current random word from the data\\n to_learn = pandas.DataFrame(data) # Creates a data frame of the updated data\\n to_learn.to_csv(\\\"data/words_to_learn.csv\\\", index=False) # Creates & Updates the .csv file with updated data\\n generate_word()\",\n \"def get_word_embedding(counter, emb_file, emb_size, vocab_size, vec_size, vocab_file):\\n print(\\\"Generating word embedding...\\\")\\n # load word embeddings\\n embedding_dict = {}\\n with open(emb_file, \\\"r\\\", encoding=\\\"utf-8\\\") as fh:\\n for line in tqdm(fh, total=emb_size):\\n array = line.split()\\n word = \\\"\\\".join(array[0:-vec_size])\\n vector = list(map(float, array[-vec_size:]))\\n embedding_dict[word] = vector\\n\\n TRANSLATE = {\\n \\\"-lsb-\\\": \\\"[\\\", \\\"-rsb-\\\": \\\"]\\\", \\\"-lrb-\\\": \\\"(\\\", \\\"-rrb-\\\": \\\")\\\", \\\"-lcb-\\\": \\\"{\\\",\\n \\\"-rcb-\\\": \\\"}\\\", \\\"-LSB-\\\": \\\"[\\\", \\\"-RSB-\\\": \\\"]\\\", \\\"-LRB-\\\": \\\"(\\\", \\\"-RRB-\\\": \\\")\\\",\\n \\\"-LCB-\\\": \\\"{\\\", \\\"-RCB-\\\": \\\"}\\\"\\n }\\n SPECIAL_TOKENS = [\\\"<NULL>\\\", \\\"<UNK>\\\", \\\"<S>\\\", \\\"</S>\\\"]\\n words = list(map(lambda x: x[0], sorted(counter.items(), key=lambda x: x[1], reverse=True)))\\n words = SPECIAL_TOKENS + words\\n if vocab_size > 0:\\n words = words[:vocab_size]\\n with open(vocab_file, 'w') as f:\\n f.write('\\\\n'.join(words[1:]))\\n embedding = np.random.normal(scale=0.1, size=(len(words), vec_size))\\n word2idx_dict = {}\\n unknown_count = 0\\n for i, word in enumerate(words):\\n word2idx_dict[word] = i\\n if word in TRANSLATE:\\n word = TRANSLATE[word]\\n done = False\\n for w in (word, word.lower(), word.upper(), word.capitalize()):\\n if w in embedding_dict:\\n embedding[i] = embedding_dict[w]\\n done = True\\n break\\n if not done:\\n unknown_count += 1\\n return embedding, word2idx_dict, unknown_count\",\n \"def word_entropy(self, doc, lemmatized=False):\\n # filter out words\\n words = [token for token in doc if not token.is_punct and \\\"'\\\" not in token.text and not token.is_space]\\n # create bag of words\\n if lemmatized:\\n list_words = [w.lemma_ for w in words]\\n else:\\n list_words = [w.text for w in words]\\n num_words = len(list_words)\\n word_freq = Counter(list_words)\\n return -sum(\\n [\\n (word_freq[word] / num_words) * log2(word_freq[word] / num_words)\\n for word in word_freq\\n ]\\n )\",\n \"def add(self, term, count=1):\\n term = term.lower() if self.lower else term\\n if term in self.term2id:\\n idx = self.term2id[term]\\n else:\\n idx = len(self.id2term)\\n self.id2term[idx] = term\\n self.term2id[term] = idx\\n if count > 0:\\n if term in self.term_frequent:\\n self.term_frequent[term] += count\\n else:\\n self.term_frequent[term] = count\\n return idx\",\n \"def test_score_of_unknown_token(self):\\n\\n \\\"\\\"\\\"\\n Create the test data.\\n \\\"\\\"\\\"\\n tokenizer = Tokenizer(stem=False)\\n posts = [\\n \\\"Erdogan with threats to attack regime forces 'everywhere' in Syria\\\",\\n \\\"Damascus says Erdogan 'disconnected from reality' after threats\\\",\\n ]\\n\\n corpus = [ Document(post, tokenizer.tokenize(post)) for post in posts ]\\n\\n extractor = TokenExtractor()\\n scorer = TFIDFScorer({ 'erdogan': 1, 'threats': 2 }, 10)\\n candidates = extractor.extract(corpus)\\n scores = scorer.score(candidates)\\n self.assertFalse(scores.get('unknown'))\",\n \"def random_word_wwm(tokens, ref_ids, tokenizer):\\n output_label = []\\n\\n for i, (token, ref_id) in enumerate(zip(tokens, ref_ids)):\\n\\n prob = random.random()\\n\\n if ref_id == 1:\\n\\n # 80% randomly change token to mask token\\n if prob < 0.8:\\n tokens[i] = \\\"[MASK]\\\"\\n\\n # 10% randomly change token to random token\\n elif prob < 0.9:\\n tokens[i] = random.choice(list(tokenizer.vocab.items()))[0]\\n\\n # -> rest 10% randomly keep current token\\n\\n # append current token to output (we will predict these later)\\n try:\\n output_label.append(tokenizer.vocab[token])\\n except KeyError:\\n # For unknown words (should not occur with BPE vocab)\\n output_label.append(tokenizer.vocab[\\\"[UNK]\\\"])\\n else:\\n # no masking token (will be ignored by loss function later)\\n output_label.append(-100)\\n\\n return tokens, output_label\",\n \"def _make_feature_vec(self, word_list):\\n\\n # Pre-initialize an empty numpy array (for speed)\\n feature_vec = np.zeros((self.num_features,), dtype=\\\"float32\\\")\\n\\n # index2word is a list that contains the names of the words in\\n # the model's vocabulary. Convert it to a set, for speed.\\n index2word_set = set(self.w2v_model.index2word)\\n\\n # Loop over each word in the word_list and, if it is in the model's\\n # vocabulary, add its feature vector to the total\\n nwords = 0\\n for word in word_list:\\n # NOTE: Careful there, if all words are in caps in the article,\\n # this function will return nan values and blow up the forest.\\n word = word.lower()\\n if word in index2word_set:\\n nwords += 1\\n feature_vec = np.add(feature_vec, self.w2v_model[word])\\n\\n # Divide the result by the number of words to get the average\\n feature_vec = np.divide(feature_vec, nwords)\\n return feature_vec\",\n \"def get_mean_emb(self, text):\\n return np.mean([self.emb.get(w.lower(), self.emb.get(\\\"_UNK\\\")) for w in text.split()], axis=0)\",\n \"def train(self, corpus): \\n for sentence in corpus.corpus: # iterate over sentences in the corpus\\n for token in sentence: # iterate over datums in the sentence\\n self.unigrams[token] += 1\\n self.total += 1\\n V = len(self.unigrams) # vocabulary size \\n for ug,count in self.unigrams.iteritems():\\n \\tself.f1[ug] = math.log10(count+1) - math.log10(self.total + V)\",\n \"def vectorize(sequence, el2idx, max_length, unk_policy=\\\"random\\\",\\n spell_corrector=None):\\n words = numpy.zeros(max_length).astype(int)\\n\\n # trim tokens after max length\\n sequence = sequence[:max_length]\\n\\n for i, token in enumerate(sequence):\\n if token in el2idx:\\n words[i] = el2idx[token]\\n else:\\n if unk_policy == \\\"random\\\":\\n words[i] = el2idx[\\\"<unk>\\\"]\\n elif unk_policy == \\\"zero\\\":\\n words[i] = 0\\n elif unk_policy == \\\"correct\\\":\\n corrected = spell_corrector(token)\\n # if corrected != token:\\n # print(token, corrected)\\n if corrected in el2idx:\\n words[i] = el2idx[corrected]\\n else:\\n words[i] = el2idx[\\\"<unk>\\\"]\\n\\n return words\",\n \"def add(self, term, count=1):\\n term = term.lower() if self.lower else term\\n if term in self.term2id:\\n idx = self.term2id[term]\\n else:\\n idx = len(self.id2term)\\n self.id2term[idx] = term\\n self.term2id[term] = idx\\n if count > 0:\\n if term in self.term_frequent:\\n self.term_frequent[term] += count\\n else:\\n self.term_frequent[term] = count\\n\\n if term not in self.initial_terms:\\n for char in term:\\n if char not in self.char2id.keys():\\n idc = len(self.id2char)\\n self.id2char[idc] = char\\n self.char2id[char] = idc\\n return idx\",\n \"def calculate_tf_idf(self,doc_token_number,document_count):\\n for term_ in self.inverted_index.keys():\\n postingsList=self.inverted_index[term_]\\n len_of_posting_list=postingsList.length\\n idf=document_count/len_of_posting_list\\n if postingsList.start_node is None:\\n print(\\\"List has no element\\\")\\n return\\n else:\\n n = postingsList.start_node\\n # Start traversal from head, and go on till you reach None\\n while n is not None:\\n freq=n.term_frequency\\n tf=freq/doc_token_number[n.value]\\n tf_idf_value=tf*idf\\n n.tf_idf=tf_idf_value\\n n = n.next\",\n \"def sample(prediction):\\n p = np.zeros(shape=[1, vocabulary_size], dtype=np.float)\\n p[0, sample_distribution(prediction[0])] = 1.0\\n return p\",\n \"def sample(prediction):\\n p = np.zeros(shape=[1, vocabulary_size], dtype=np.float)\\n p[0, sample_distribution(prediction[0])] = 1.0\\n return p\",\n \"def sample(prediction):\\n p = np.zeros(shape=[1, vocabulary_size], dtype=np.float)\\n p[0, sample_distribution(prediction[0])] = 1.0\\n return p\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6838759","0.65651834","0.6410613","0.6106581","0.6086365","0.6085573","0.6080259","0.6050455","0.6035664","0.5996665","0.59961116","0.5990178","0.5940137","0.5930811","0.59277254","0.5890196","0.588386","0.58830386","0.58822876","0.58559144","0.5849721","0.5849721","0.5844867","0.5843105","0.5781211","0.57432115","0.5728364","0.5713788","0.5704089","0.5685889","0.5682922","0.5672087","0.5657129","0.5639502","0.55859965","0.55854803","0.558067","0.5578437","0.5573994","0.55732423","0.5567005","0.5566384","0.55629396","0.55475473","0.55459446","0.55459446","0.5522053","0.5512898","0.55091715","0.55061394","0.55026054","0.5502283","0.5499426","0.54964054","0.549154","0.5479789","0.5461762","0.5461335","0.5454002","0.5451833","0.5451705","0.54479384","0.54479384","0.54479384","0.54260737","0.5417071","0.54107654","0.5395761","0.5382759","0.5376458","0.5368713","0.5366265","0.5357404","0.5356283","0.5355111","0.535183","0.5349486","0.53442377","0.53348833","0.5334148","0.53309864","0.53300744","0.5326914","0.5320356","0.5304954","0.5300247","0.52896786","0.52798617","0.5277393","0.5276287","0.52742773","0.52740616","0.5273655","0.5261585","0.52539504","0.52370614","0.52342546","0.52304214","0.52304214","0.52304214"],"string":"[\n \"0.6838759\",\n \"0.65651834\",\n \"0.6410613\",\n \"0.6106581\",\n \"0.6086365\",\n \"0.6085573\",\n \"0.6080259\",\n \"0.6050455\",\n \"0.6035664\",\n \"0.5996665\",\n \"0.59961116\",\n \"0.5990178\",\n \"0.5940137\",\n \"0.5930811\",\n \"0.59277254\",\n \"0.5890196\",\n \"0.588386\",\n \"0.58830386\",\n \"0.58822876\",\n \"0.58559144\",\n \"0.5849721\",\n \"0.5849721\",\n \"0.5844867\",\n \"0.5843105\",\n \"0.5781211\",\n \"0.57432115\",\n \"0.5728364\",\n \"0.5713788\",\n \"0.5704089\",\n \"0.5685889\",\n \"0.5682922\",\n \"0.5672087\",\n \"0.5657129\",\n \"0.5639502\",\n \"0.55859965\",\n \"0.55854803\",\n \"0.558067\",\n \"0.5578437\",\n \"0.5573994\",\n \"0.55732423\",\n \"0.5567005\",\n \"0.5566384\",\n \"0.55629396\",\n \"0.55475473\",\n \"0.55459446\",\n \"0.55459446\",\n \"0.5522053\",\n \"0.5512898\",\n \"0.55091715\",\n \"0.55061394\",\n \"0.55026054\",\n \"0.5502283\",\n \"0.5499426\",\n \"0.54964054\",\n \"0.549154\",\n \"0.5479789\",\n \"0.5461762\",\n \"0.5461335\",\n \"0.5454002\",\n \"0.5451833\",\n \"0.5451705\",\n \"0.54479384\",\n \"0.54479384\",\n \"0.54479384\",\n \"0.54260737\",\n \"0.5417071\",\n \"0.54107654\",\n \"0.5395761\",\n \"0.5382759\",\n \"0.5376458\",\n \"0.5368713\",\n \"0.5366265\",\n \"0.5357404\",\n \"0.5356283\",\n \"0.5355111\",\n \"0.535183\",\n \"0.5349486\",\n \"0.53442377\",\n \"0.53348833\",\n \"0.5334148\",\n \"0.53309864\",\n \"0.53300744\",\n \"0.5326914\",\n \"0.5320356\",\n \"0.5304954\",\n \"0.5300247\",\n \"0.52896786\",\n \"0.52798617\",\n \"0.5277393\",\n \"0.5276287\",\n \"0.52742773\",\n \"0.52740616\",\n \"0.5273655\",\n \"0.5261585\",\n \"0.52539504\",\n \"0.52370614\",\n \"0.52342546\",\n \"0.52304214\",\n \"0.52304214\",\n \"0.52304214\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69098496"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84898,"cells":{"query":{"kind":"string","value":"Replaces each Quora question with indexes corressponding to respective position of tokens in embedding matrix. If include_unknown is true, then replaces with corressponding index, ignores otherwise."},"document":{"kind":"string","value":"def sentences_2_idxs(self):\n fo_pos = open(self.config.parsed_train_file_pos, 'w')\n fo_neg = open(self.config.parsed_train_file_neg, 'w')\n self.load_dicts()\n labels = pd.read_csv(self.config.train_file, usecols=[\"target\"])\n\n labels = list(labels.values[:, 0])\n questions = pd.read_csv(self.config.train_file,\n usecols=[\"question_text\"], index_col=False)\n unk_idx = self.word2idx.get(self.config.unknown_token)\n\n for label, quest in zip(labels, questions.question_text):\n tokens = preprocess_text(quest)\n\n if self.config.include_unknown:\n idxs = [self.word2idx.get(token, unk_idx) for token in\n tokens]\n else:\n idxs = [self.word2idx.get(token) for token in tokens]\n idxs = [idx for idx in idxs if idx]\n out_line = (str(\" \".join(str(num) for num in idxs)) + \"\\n\")\n if label == 1:\n fo_pos.write(out_line)\n else:\n fo_neg.write(out_line)"},"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 embed(raw_seq, index_dict):\n return np.asarray([index_dict[word.lower()]\n if word.lower() in index_dict\n else index_dict[OOV_TOKEN] for word in raw_seq])","def convert_questions_to_features(examples, tokenizer, max_query_length=None):\n\n unique_id = 1000000000\n question_features = []\n\n for (example_index, example) in enumerate(tqdm(examples, desc='Converting questions')):\n\n query_tokens = tokenizer.tokenize(example.question_text)\n if max_query_length is None:\n max_query_length = len(query_tokens)\n if len(query_tokens) > max_query_length:\n query_tokens = query_tokens[0:max_query_length]\n\n for _ in enumerate(range(1)):\n tokens_ = []\n tokens_.append(\"[CLS]\")\n for token in query_tokens:\n tokens_.append(token)\n tokens_.append(\"[SEP]\")\n\n input_ids_ = tokenizer.convert_tokens_to_ids(tokens_)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask_ = [1] * len(input_ids_)\n\n # Zero-pad up to the sequence length.\n while len(input_ids_) < max_query_length + 2:\n input_ids_.append(0)\n input_mask_.append(0)\n\n assert len(input_ids_) == max_query_length + 2\n assert len(input_mask_) == max_query_length + 2\n\n if example_index < 1:\n # logger.info(\"*** Example ***\")\n # logger.info(\"unique_id: %s\" % (unique_id))\n # logger.info(\"example_index: %s\" % (example_index))\n logger.info(\"tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in query_tokens]))\n # logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids_]))\n # logger.info(\n # \"input_mask: %s\" % \" \".join([str(x) for x in input_mask_]))\n\n question_features.append(\n QuestionFeatures(\n unique_id=unique_id,\n example_index=example_index,\n tokens_=tokens_,\n input_ids=input_ids_,\n input_mask=input_mask_))\n unique_id += 1\n\n return question_features","def qa_ctx_attention(self, qa_embed, ctx_embed, qa_mask, ctx_mask, noun_mask, non_visual_vectors):\n num_img, num_region = ctx_mask.shape[2:]\n u_a, raw_s, s_mask, s_normalized = self.str_attn(qa_embed, ctx_embed, qa_mask, ctx_mask, noun_mask=noun_mask, void_vector=non_visual_vectors)\n qa_embed = qa_embed.repeat(1, 1, num_img, 1, 1)\n mixed = torch.cat([qa_embed, u_a, qa_embed * u_a], dim=-1)\n mixed = self.c2q_down_projection(mixed)\n mixed_mask = (s_mask.sum(-1) != 0).float()\n return mixed, mixed_mask, raw_s, s_normalized","def _lost_answers_indexes(self, df, tokenized_contexts):\n whole_answers_start = df[\"answer_start\"].tolist()\n whole_answers_end = df[\"answer_end\"].tolist()\n lost_dirty, lost_truncated = [], []\n for i, (c, s, e) in enumerate(\n zip(tokenized_contexts, whole_answers_start, whole_answers_end)\n ):\n mask = (\n torch.tensor(c.attention_mask, device=self.device).bool()\n & ~torch.tensor(c.special_tokens_mask, device=self.device).bool()\n )\n offsets = torch.tensor(c.offsets, device=self.device)[mask]\n start_index = torch.nonzero(offsets[:, 0] == s)\n end_index = torch.nonzero(offsets[:, 1] == e)\n if len(start_index) == 0 or len(end_index) == 0:\n if s > offsets[-1, 0] or e > offsets[-1, 1]:\n lost_truncated.append(i)\n else:\n lost_dirty.append(i)\n\n return lost_truncated, lost_dirty","def predict_sentences_2_idxs(self):\n fo = open(self.config.parsed_predict_file, 'w')\n self.load_dicts()\n\n questions = pd.read_csv(self.config.predict_file,\n usecols=[\"question_text\"], index_col=False)\n unk_idx = self.word2idx[self.config.unknown_token]\n\n for quest in questions.question_text:\n tokens = preprocess_text(quest)\n if self.config.include_unknown:\n idxs = [self.word2idx.get(token, unk_idx) for token in\n tokens]\n else:\n idxs = [self.word2idx.get(token) for token in tokens]\n idxs = [idx for idx in idxs if idx]\n fo.write((str(\" \".join(str(num) for num in idxs)) + \"\\n\"))","def enseemble_results_extra(self, questions, topn):\n ok_vocab = self.get_vocabulary()\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\n new_vocab = {w.upper(): v for w, v in new_vocab}\n new_vocab = dict(new_vocab)\n\n results = []\n for line_no, line in enumerate(utils.smart_open(questions)):\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\n line = utils.to_unicode(line)\n if line.startswith(': '):\n continue\n else:\n\n try:\n a, b, c, expected = [word.upper() for word in line.split()]\n except ValueError:\n logger.info(\"skipping invalid line #%i in %s\", line_no, questions)\n continue\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\n \"\"\"if a not in new_vocab:\n print(\"Dont know: \" + a)\n if b not in new_vocab:\n print(\"Dont know: \" + b)\n if c not in new_vocab:\n print(\"Dont know: \" + c)\n if expected not in new_vocab:\n print(\"Dont know: \" + expected)\n \"\"\"\n logger.debug(\"skipping line #%i with OOV words: %s\", line_no, line.strip())\n results.append(None)\n continue\n\n original_vocab = self.get_vocabulary()\n self.set_vocabulary(new_vocab)\n ignore = {a, b, c} # input words to be ignored\n #print('topn')\n #print(topn)\n # find the most likely prediction, ignoring OOV words and input words\n sims = self.most_similar(positive_words=[b, c], negative_words=[a], topn = topn)\n # print(\"sims\")\n #print(sims)\n self.set_vocabulary(original_vocab)\n inner_results = []\n for predict in sims:\n predicted = predict[0]\n predicted = predicted.upper()\n predicted_tuple = (predicted, predict[1])\n #print(predicted_tuple)\n inner_results.append(predicted_tuple)\n #print(predicted)\n results.append(inner_results)\n #print(results)\n\n return results","def parse_question(question):\n\tcontext = question['support']\n\tanswer = question['correct_answer']\n\ttarget = question['question']\n\n\tcontext_words = context.split(\" \")[0: 510]\n\ttarget_words = target.split(\" \")\n\n\tpunc_filter = str.maketrans('', '', string.punctuation)\n\n\tcontext_words = [word.translate(punc_filter) for word in context_words]\n\ttarget_words = [word.translate(punc_filter) for word in target_words]\n\tanswer_words = [word.translate(punc_filter) for word in answer.split(\" \")]\n\n\tbio_embeddings = [EMBEDER['O']]\n\tinside_answer = False\n\tanswer_index = 0\n\tcan_be_inside_answer = True\n\n\t# The following loop and above code does:\n\t# -Find where the answer is and place a B tag\n\t# -While still in the answer (the answer is more than one word) put an I tag\n\t# -Outside of the answer place a O tag\n\t# -Start and end with an O tag for BERT's automatic\n\t# -start token and end token representing the start and end of a sentence.\n\tfor word in context_words:\n\t\tif word.lower() == answer_words[0].lower() and can_be_inside_answer:\n\t\t\tbio_embeddings.append(EMBEDER[\"B\"])\n\t\t\tanswer_index += 1\n\t\t\tinside_answer = True\n\t\t\tcan_be_inside_answer = False\n\t\telif inside_answer:\n\t\t\tif len(answer_words) > 1:\n\t\t\t\tif word.lower() != answer_words[answer_index]:\n\t\t\t\t\tinside_answer = False\n\t\t\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\t\t\t\telse:\n\t\t\t\t\tbio_embeddings.append(EMBEDER[\"I\"])\n\t\t\telse:\n\t\t\t\tinside_answer = False\n\t\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\t\telse:\n\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\tbio_embeddings.append(EMBEDER[\"O\"])\n\n\tground_truth = torch.tensor([BERT_TOKENIZER.encode(target_words)])\n\tcontext_words = torch.tensor([BERT_TOKENIZER.encode(context_words)])\n\n\tassert len(bio_embeddings) == len(context_words[0]), f'The BIO tags are not equal in length to the embeddings! ' \\\n\t f'{None} & {len(bio_embeddings)} & {len(context_words[0])}'\n\treturn context_words, bio_embeddings, ground_truth","def replace_q_indices(circuit, q_nums, qr):\n\n new_circuit = qiskit.QuantumCircuit(qr)\n for op in circuit.data:\n original_qubits = op.qargs\n new_op = copy.deepcopy(op)\n new_op.qargs = [(qr, q_nums[x]) for x in [arg[1] for arg in original_qubits]]\n new_circuit.data.append(new_op)\n\n return new_circuit","def replace_canonical_referents(self, **kwargs):\n replaced_count = 0\n for doc in self.annotation_documents:\n for sen in doc.sentences:\n for part in sen.participants:\n replaced_count += part.replace_by_canonical_referent(**kwargs) #this will replace in-place in project, but returns a count too.\n\n return replaced_count","def process_question_for_prediction(question):\n question = __set_has_hexadecimal(question)\n question = __set_has_numeric(question)\n homework_list = constants.HOMEWORK_SYNONMS_LIST\n homework_list.sort(key=len, reverse=True)\n replacement_text = constants.QUESTION_HAS_HOMEWORK_KEY\n question = __set_has_homework_or_assignment(question, replacement_text, homework_list)\n question = stem_training_data(question)\n return question","def preprocess_dataset(dataset, tokenizer):\n eos = torch.tensor([tokenizer.eos_token_id], dtype=torch.long)\n q_start = torch.tensor(tokenizer.encode('question:'), dtype=torch.long)\n q_end = torch.tensor(tokenizer.encode(':question'), dtype=torch.long)\n\n tensors = [[] for i in range(3)]\n for i in trange(len(dataset)):\n example = dataset[i]\n\n context_start_idx = (example[2] == 1).nonzero()[0].item()\n if example[1][-1] == 1:\n context_end_idx = len(example[1]) - 1\n else:\n context_end_idx = (example[1] == 0).nonzero()[0].item()\n ans_start = example[3] - context_start_idx\n ans_end = example[4] - context_start_idx\n\n context = example[0][context_start_idx: context_end_idx]\n question = example[0][: context_start_idx]\n answer = example[0][example[3]: example[4] + 1]\n\n input_ids = torch.cat([\n context,\n eos,\n answer,\n eos,\n q_start,\n question,\n q_end,\n eos\n ])\n\n attention_mask = torch.ones_like(input_ids, dtype=torch.long)\n token_type_ids = torch.cat([\n torch.zeros(len(context) + 1, dtype=torch.long),\n torch.ones(len(answer) + 1, dtype=torch.long),\n 2 * torch.ones(len(question) + 3, dtype=torch.long)\n ])\n token_type_ids[ans_start: ans_end + 1] = 1\n\n tensors[0].append(input_ids)\n tensors[1].append(attention_mask)\n tensors[2].append(token_type_ids)\n\n tensors_padded = []\n for i, sequences in enumerate(tqdm(tensors)):\n padded = pad_sequence(sequences, batch_first=True)\n tensors_padded.append(padded)\n\n new_dataset = TensorDataset(*tensors_padded)\n return new_dataset","def substitute_num(self, numbers, qa3_answer):\n question = self\n for match in re.finditer('[0-9]+', question):\n num = match.group(0)\n i = qa3_answer.index_by_chunk(num)\n if i is None or qa3_answer.result[i].get_type() != 'refYear':\n if num not in numbers:\n numbers.append(num)\n question = re.sub(num, '<NUM' + string.ascii_uppercase[numbers.index(num)] + '>', question, 1)\n return Qa3Question(question)","def rearrange_indices(self):\n num_fixed_words = 2\n other_words = [w for w in self.word2index if w not in self.equivariant_words]\n for idx, word in enumerate(self.equivariant_words):\n w_idx = idx + num_fixed_words\n self.word2index[word] = w_idx\n self.index2word[w_idx] = word\n for idx, word in enumerate(sorted(other_words)):\n w_idx = idx + num_fixed_words + self.num_equivariant_words\n self.word2index[word] = w_idx\n self.index2word[w_idx] = word","def replace_by_canonical_referent(self, cross_sentence=True):\n replaced_count = 0\n\n # replace the participant in their containers\n def replace_in_containers(myobj, replacing):\n containers = {\n \"event\": \"participants\",\n \"sentiment_expression\": \"targets\",\n \"sentence\": \"participants\",\n }\n for c_name, attrib_n in containers.items():\n c_name = f\"in_{c_name}\"\n if hasattr(myobj, c_name):\n for c in getattr(myobj, c_name):\n to_replace_in = getattr(c, attrib_n)\n to_replace_in.append(replacing)\n if myobj in to_replace_in:\n to_replace_in.remove(myobj)\n to_replace_in.sort(key=lambda x: x.begin)\n\n if self.canonical_referents and self.canonical_referents != \"from_canonref\":\n # sometimes there are multiple canonrefs tagged\n # this can be a) annotation mistake or\n # b) multiple reference to a group, e.g. \"all\" refers to three companies.\n for canonref in self.canonical_referents:\n # check whether canonical referent is in same sentence\n same_sentence = [s.element_id for s in self.in_sentence] == [\n s.element_id for s in canonref.in_sentence\n ]\n # always replace when cross_sentence is true\n # if cross_sentence is False (disallowed) only replace when canonref is in same sentence\n if cross_sentence or same_sentence:\n # replace element\n replacing_participant = Participant(\n canonref.text,\n canonref.begin,\n canonref.end,\n canonref.element_id,\n canonref.annotator_id,\n canonref.document_title,\n canonref.in_document,\n self.role,\n \"from_canonref\",\n self.link_id,\n canonref.tokens,\n )\n replacing_participant.in_sentence = self.in_sentence\n replacing_participant.in_document = self.in_document\n if hasattr(self, \"in_sentiment_expression\"):\n replacing_participant.in_sentiment_expression = (\n self.in_sentiment_expression\n )\n replacing_participant.from_original_participant = copy(self)\n print(\n f\"Replaced {self} with {canonref}. (in same sentence:{same_sentence})\"\n )\n\n replace_in_containers(self, replacing_participant)\n\n # replace on document\n self.in_document.participants.append(replacing_participant)\n if self in self.in_document.participants:\n self.in_document.participants.remove(self)\n\n replaced_count += 1\n return replaced_count","def enseemble_results(self, questions, topn):\n ok_vocab = self.get_vocabulary()\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\n new_vocab = {w.upper(): v for w, v in new_vocab}\n new_vocab = dict(new_vocab)\n\n results = []\n for line_no, line in enumerate(utils.smart_open(questions)):\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\n line = utils.to_unicode(line)\n if line.startswith(': '):\n continue\n else:\n\n try:\n a, b, c, expected = [word.upper() for word in line.split()]\n except ValueError:\n logger.info(\"skipping invalid line #%i in %s\", line_no, questions)\n continue\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\n \"\"\"if a not in new_vocab:\n print(\"Dont know: \" + a)\n if b not in new_vocab:\n print(\"Dont know: \" + b)\n if c not in new_vocab:\n print(\"Dont know: \" + c)\n if expected not in new_vocab:\n print(\"Dont know: \" + expected)\n \"\"\"\n logger.debug(\"skipping line #%i with OOV words: %s\", line_no, line.strip())\n results.append(None)\n continue\n\n original_vocab = self.get_vocabulary()\n self.set_vocabulary(new_vocab)\n ignore = {a, b, c} # input words to be ignored\n #print('topn')\n #print(topn)\n # find the most likely prediction, ignoring OOV words and input words\n sims = self.most_similar(positive_words=[b, c], negative_words=[a], topn = topn)\n # print(\"sims\")\n #print(sims)\n self.set_vocabulary(original_vocab)\n inner_results = []\n for predict in sims:\n predicted = predict[0]\n predicted = predicted.upper()\n\n inner_results.append(predicted)\n #print(predicted)\n results.append(inner_results)\n #print(results)\n\n return results","def preprocess(self, sequence, word2idx):\n story = [word2idx[word] if word in word2idx else UNK_token for word in sequence.split()]\n story = torch.Tensor(story)\n return story","def preprocess(self, sequence, word2idx):\n context = [word2idx[word]\n if word in word2idx else UNK_token for word in sequence.split()]\n context = torch.Tensor(context)\n return context","def __getitem__(self, idx):\n\n ############ 1.9 TODO\n # figure out the idx-th item of dataset from the VQA API\n image_id_from_idx = self._vqa.questions['questions'][idx]['image_id']\n question_id_from_idx = self._vqa.questions['questions'][idx]['question_id']\n question_sentence = self._vqa.questions['questions'][idx]['question']\n answer_sentences = [ans['answer'] for ans in self._vqa.qa[question_id_from_idx]['answers']]\n\n # import pdb; pdb.set_trace()\n\n ############\n\n # if self._cache_location is not None and self._pre_encoder is not None:\n # ############ 3.2 TODO\n # # implement your caching and loading logic here\n\n # ############\n # raise NotImplementedError()\n # else:\n ############ 1.9 TODO\n # load the image from disk, apply self._transform (if not None)\n # import ipdb; ipdb.set_trace()\n image_id_from_idx_string = self.fixed_str + str(image_id_from_idx)\n truncated_image_id_from_idx = image_id_from_idx_string[-12:]\n img_file_path = self._image_dir + '/' + self._image_filename_pattern.format(truncated_image_id_from_idx)\n image = Image.open(img_file_path)\n image = image.convert(\"RGB\")\n image = self._transform(image)\n ############\n # raise NotImplementedError()\n\n ############ 1.9 TODO\n # load and encode the question and answers, convert to torch tensors\n question_encoding = torch.zeros(self._max_question_length, self.question_word_list_length)\n answer_encoding = torch.zeros(10,self.answer_list_length)\n\n question_word_list = self._create_word_list(question_sentence)\n # print(idx,question_word_list)\n # print(len(self.question_word_to_id_map.keys()))\n # quit()\n for i, word in enumerate(question_word_list):\n # import ipdb; ipdb.set_trace()\n # print(i,word)\n # quit()\n if i >= self._max_question_length:\n break\n if word not in self.question_word_to_id_map.keys():\n map_idx = self.unknown_question_word_index\n else:\n map_idx = self.question_word_to_id_map[word]\n question_encoding[i][map_idx] = 1\n\n # answer_sentence_list = self._create_word_list(answer_sentences)\n for i, answer in enumerate(answer_sentences):\n if answer not in self.answer_to_id_map.keys():\n map_idx = self.unknown_answer_index\n else:\n map_idx = self.answer_to_id_map[answer]\n answer_encoding[i][map_idx] = 1\n \n data = {'image':image, 'question':question_encoding, 'answer':answer_encoding}\n return data\n\n ############\n # raise NotImplementedError()","def _filter_unanswerable_samples(self):\n a = []\n q = []\n annotations = []\n for i in range(len(self.answers)):\n if len(self.answers[i].nonzero()) > 0:\n a.append(self.answers[i])\n q.append(self.questions[i])\n\n annotations.append(self.annotations[i])\n self.answers = a\n self.questions = q\n self.annotations = annotations","def dynamic(question_quantized_dfs):\n all_transitions = {}\n\n for i, qdf in enumerate(question_quantized_dfs):\n q = qdf.iloc[:, utils.SKIP_COLUMNS:] # don't work on audio_rms column\n\n all_transitions[i] = OrderedDict()\n\n for au in q:\n all_transitions[i][au] = np.zeros((4, 4))\n\n for (x, y), c in Counter(zip(q[au], q[au][1:])).items():\n all_transitions[i][au][x - 1, y - 1] += c # TODO some warning about non-integer index\n\n # Concatenate all AU triples right, then all question down\n temp1 = []\n for k, q_transitions in all_transitions.items():\n temp2 = []\n\n for au, trans in q_transitions.items():\n trans_features = list(transition_features(trans))\n trans_index = [au + '_change_ratio', au + '_slow_change_ratio', au + '_fast_change_ratio']\n\n temp2.append(pd.DataFrame(trans_features, index=trans_index).T)\n temp1.append(pd.concat(temp2, axis=1))\n\n question_dynamic_features = pd.concat(temp1, axis=0)\n\n # Fix index\n question_dynamic_features.index = range(len(question_quantized_dfs))\n\n return question_dynamic_features","def process_question(qu):\n\n ## global ranking\n rank_info = {}\n rank_info_k = [\"viewcount\",\"score\",\"favoritecount\"]\n for k in rank_info_k:\n rank_info[k] = int(qu[k])\n qu.pop(k,None)\n\n rank_info[\"creationdate\"] = qu[\"creationdate\"]\n\n if qu[\"acceptedanswer\"]:\n qu[\"acceptedanswer\"] = list(qu[\"acceptedanswer\"])\n else:\n qu[\"acceptedanswer\"] = []\n\n qu.pop('comments',None) # discard comments, maybe add back later\n qu[\"rank_info\"] = rank_info\n\n return qu","def replace_special_token(self, tokenizer_fields: Dict[str, torch.Tensor], positions: List[int], replace_id: int):\n token_ids, offsets = tokenizer_fields[\"token_ids\"], tokenizer_fields[\"offsets\"]\n for pos in positions:\n offset = offsets[pos].numpy().tolist()\n if offset[0] != offset[1]:\n warnings.warn(f\"replace normally expect token in `positions` has not been split to pieces.\"\n f\"This warning should NOT happen unless during batch prediction at evaluation\")\n token_ids[offset[0]] = replace_id","def _encode_question(self, question):\n \n inputs = self.tokenizer.encode_plus(\n question,\n None,\n add_special_tokens=True,\n max_length=self.max_len,\n )\n\n ids = inputs[\"input_ids\"]\n mask = inputs[\"attention_mask\"]\n token_type_ids = inputs[\"token_type_ids\"]\n\n padding_length = self.max_len - len(ids)\n ids += ([0]*padding_length)\n mask += ([0]*padding_length)\n token_type_ids += ([0]*padding_length)\n \n return {\n 'ids': torch.tensor(ids, dtype=torch.long),\n 'mask': torch.tensor(mask, dtype=torch.long),\n 'token_type_ids': torch.tensor(token_type_ids, dtype=torch.long),\n \n }","def preprocess_seq(self, sequence, word2idx):\n story = []\n for value in sequence:\n #v = [word2idx[word] if word in word2idx else UNK_token for word in value.split()] + [EOS_token]\n story.append(word2idx[value] if value in word2idx else UNK_token)\n story = torch.Tensor(story)\n return story","def convert_single_example(example, tokenizer, is_training, args):\n tok_to_orig_index = []\n orig_to_tok_index = []\n all_doc_tokens = [] # all subtokens of original doc after tokenizing\n features = []\n for (i, token) in enumerate(example['paragraph_tokens']):\n orig_to_tok_index.append(len(all_doc_tokens))\n sub_tokens = albert_tokenize(tokenizer, token)\n tok_to_orig_index.extend([i] * len(sub_tokens))\n all_doc_tokens.extend(sub_tokens)\n\n # 特别注意！由于在paragraph_tokens中我们的token已经映射过一次了\n # 这里wordpiece等于又映射了一遍，所以这里的操作是二次映射\n if example['position_map']:\n tok_to_orig_index = [example['position_map'][index] for index in tok_to_orig_index]\n\n # QUERY\n query_tokens = []\n query_tokens.append(\"[Q]\")\n query_tokens.extend(albert_tokenize(tokenizer, example['question_text']))\n if len(query_tokens) > args.max_query_length:\n query_tokens = query_tokens[-args.max_query_length:]\n\n # ANSWER 预处理的时候先长短分开\n tok_start_position = -1\n tok_end_position = -1\n # 这里终点是必然在para_tokens内的\n if is_training:\n # 现阶段，有短答案预测短答案，否则预测长答案\n if example['answer_type'] != AnswerType['UNKNOWN']:\n tok_long_start_position = orig_to_tok_index[example['long_start']]\n if example['long_end'] == len(orig_to_tok_index):\n tok_long_end_position = orig_to_tok_index[-1]\n else:\n tok_long_end_position = orig_to_tok_index[example['long_end']] - 1\n tok_start_position = tok_long_start_position\n tok_end_position = tok_long_end_position\n if example['answer_type'] == AnswerType['SHORT']:\n tok_short_start_position = orig_to_tok_index[example['short_start']]\n if example['short_end'] == len(orig_to_tok_index):\n tok_short_end_position = orig_to_tok_index[-1]\n else:\n tok_short_end_position = orig_to_tok_index[example['short_end']] - 1\n tok_start_position = tok_short_start_position\n tok_end_position = tok_short_end_position\n\n # Get max tokens number for original doc,\n # should minus query tokens number and 3 special tokens\n # The -3 accounts for [CLS], [SEP] and [SEP]\n max_tokens_for_doc = args.max_seq_length - len(query_tokens) - 3\n\n # We can have documents that are longer than the maximum sequence length.\n # To deal with this we do a sliding window approach, where we take chunks\n # of up to our max length with a stride of `doc_stride`.\n _DocSpan = collections.namedtuple(\"DocSpan\", [\"start\", \"length\"])\n doc_spans = []\n start_offset = 0\n while start_offset < len(all_doc_tokens):\n length = len(all_doc_tokens) - start_offset # compute number of tokens remaining unsliding\n length = min(length, max_tokens_for_doc) # determine current sliding window size\n doc_spans.append(_DocSpan(start=start_offset, length=length))\n\n # Consider case for reaching end of original doc\n if start_offset + length == len(all_doc_tokens):\n break\n start_offset += min(length, args.doc_stride)\n\n # Convert window + query + special tokens to feature\n for (doc_span_index, doc_span) in enumerate(doc_spans):\n tokens = []\n token_to_orig_map = {}\n token_is_max_context = {}\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n tokens.extend(query_tokens)\n segment_ids.extend([0] * len(query_tokens))\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n\n for i in range(doc_span.length):\n split_token_index = doc_span.start + i\n token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\n\n is_max_context = check_is_max_context(doc_spans, doc_span_index, split_token_index)\n token_is_max_context[len(tokens)] = is_max_context\n tokens.append(all_doc_tokens[split_token_index])\n segment_ids.append(1)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n assert len(tokens) == len(segment_ids)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (args.max_seq_length - len(input_ids))\n input_ids.extend(padding)\n input_mask.extend(padding)\n segment_ids.extend(padding)\n\n assert len(input_ids) == args.max_seq_length\n assert len(input_mask) == args.max_seq_length\n assert len(segment_ids) == args.max_seq_length\n\n start_position = None\n end_position = None\n answer_type = None\n answer_text = \"\"\n if is_training:\n doc_start = doc_span.start\n doc_end = doc_span.start + doc_span.length - 1\n # For training, if our document chunk does not contain an annotation\n # we throw it out, since there is nothing to predict.\n contains_an_annotation = (tok_start_position >= doc_start and tok_end_position <= doc_end)\n # 负样本需要经过采样，且目标为[CLS]\n if (not contains_an_annotation) or example['answer_type'] == AnswerType['UNKNOWN']:\n if args.include_unknowns < 0 or random.random() > args.include_unknowns:\n continue\n start_position = 0\n end_position = 0\n answer_type = AnswerType['UNKNOWN']\n else:\n doc_offset = len(query_tokens) + 2\n start_position = tok_start_position - doc_start + doc_offset\n end_position = tok_end_position - doc_start + doc_offset\n answer_type = example['answer_type']\n\n # 如果是短答案，对一下答案是否正确\n if example['answer_type'] == AnswerType['SHORT']:\n answer_text = \" \".join(tokens[start_position:(end_position + 1)])\n answer_text = answer_text.replace(' ', '').replace(u\"▁\", ' ').strip()\n gt_answer = example['short_answer_text'].lower()\n answer_text_chars = [c for c in answer_text if c not in \" \\t\\r\\n\" and ord(c) != 0x202F]\n gt_answer_chars = [c for c in gt_answer if c not in \" \\t\\r\\n\" and ord(c) != 0x202F]\n if \"\".join(answer_text_chars) != \"\".join(gt_answer_chars):\n print(answer_text, 'V.S.', gt_answer)\n\n feature = InputFeatures(\n unique_id=None,\n example_index=None,\n doc_span_index=doc_span_index,\n tokens=tokens,\n token_to_orig_map=token_to_orig_map,\n token_is_max_context=token_is_max_context,\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n start_position=start_position,\n end_position=end_position,\n answer_text=answer_text,\n answer_type=answer_type)\n\n features.append(feature)\n\n return features","def convert_examples_to_features(examples, tokenizer, max_seq_length):\n \n features = []\n num_tokens_article = []\n count = 0\n masking_token_id = tokenizer.convert_tokens_to_ids(['[MASK]'])[0]\n # padding_token_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)\n for example_index, example in enumerate(examples):\n article_tokens = tokenizer.tokenize(example['article'])\n ques_tokens = tokenizer.tokenize(example['question'].replace(\"@placeholder\", \"_\"))\n masked_index = ques_tokens.index('_')\n ques_tokens[masked_index] = '[MASK]'\n \n# options = example['options']\n options = tokenizer.convert_tokens_to_ids(example['options'])\n# print(options, '\\n')\n\n choices_features = []\n _truncate_seq_pair(article_tokens, ques_tokens, max_seq_length - 3)\n\n# tokens = [\"[CLS]\"] + ques_tokens + [\"[SEP]\"] + article_tokens + [\"[SEP]\"]\n tokens = ques_tokens + [\"[SEP]\"] + article_tokens + [\"[SEP]\"]\n\n# segment_ids = [0] * (len(ques_tokens) + 2) + [1] * (len(article_tokens) + 1)\n segment_ids = [0] * (len(ques_tokens) + 1) + [1] * (len(article_tokens) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\t\n candidates = example['options']\n candidates_ids = tokenizer.convert_tokens_to_ids(candidates)\n# print(tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0])\n\n lm_labels = [-1 if t_id != masking_token_id else tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0] for t_id in input_ids]\n# lm_labels = [t_id if t_id != 0 else -1 for t_id in input_ids]\n# for i, t_id in enumerate(lm_labels) :\n# if(t_id == masking_token_id):\n# lm_labels[i] = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\n\n# print(lm_labels, '\\n')\n # tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n assert len(lm_labels) == max_seq_length\n\n choices_features.append((tokens, input_ids, input_mask, segment_ids))\n\n features.append(\n InputFeatures(\n choices_features = choices_features,\n lm_labels = lm_labels,\n options = options,\n label = example['label']\n )\n )\n \n return features","def words_to_tensor(words, words_lookup_index, include_eos=True, numbers_replace=True, unknown_replace=True):\n if type(words) != list: raise Exception(\"Expected a list (not a string etc)\")\n tensor_length = len(words) + 1 if include_eos else len(words)\n # tensor = np.zeros((1, tensor_length, len(words_lookup_index)), dtype=np.float32)\n tensor = torch.zeros(1, tensor_length, len(words_lookup_index))\n\n for i, w in enumerate(words):\n if w in words_lookup_index:\n tensor[0, i, words_lookup_index[w]] = 1\n elif numbers_replace and re_includes_numbers.search(w):\n tensor[0, i, words_lookup_index[NUMBER_WORD_TOKEN]] = 1\n elif unknown_replace:\n tensor[0, i, words_lookup_index[UNKNOWN_WORD_TOKEN]] = 1\n else:\n raise Exception(\"Did not find item in index\")\n\n if include_eos:\n tensor[0, -1, words_lookup_index[EOS_TOKEN]] = 1\n return tensor","def answerer(embeddings, tuples: tf.Variable, scoring=multilinear):\n n_data, n_slots, rank = [d.value for d in embeddings.get_shape()]\n n_data, n_tuples, order = [d.value for d in tuples.get_shape()]\n\n shift_indices = tf.constant(np.reshape(\n np.outer(range(n_data), np.ones(n_tuples * n_slots)) * n_slots, (n_data, n_tuples, n_slots)), dtype='int64')\n questions_shifted = tuples + shift_indices\n\n preds = scoring(\n tf.reshape(embeddings, (n_data * n_slots, rank)),\n tf.reshape(questions_shifted, (n_data * n_tuples, order)))\n\n return tf.reshape(preds, (n_data, n_tuples))","def substitute_from_qa3(self, result, index, dataset):\n question = self\n if re.search(result.chunk, question):\n if result.is_dataset(dataset):\n question = re.sub(result.chunk, '<DATASET>', question)\n elif result.is_type('refYear'):\n question = re.sub(result.chunk, '<YEAR' + str(index) + '>', question)\n elif result.is_identifier():\n question = re.sub(result.chunk, '<PROP' + str(index) + '>', question)\n else:\n question = re.sub(result.chunk, '<VALUE' + str(index) + '>', question)\n return Qa3Question(question)","def additional_text_preprocessing_with_pos(pos_dict):\n\n tags_to_lemmatize = ['a', 'n', 'v', 'r']\n\n pos_dict = TextPreprocessor.find_named_entities(pos_dict)\n if pos_dict is None:\n return None, None\n prepro = list()\n contains_spelling_mistake = False\n for t in pos_dict:\n token = t['token']\n tag = t['tag'].lower()\n if token not in TextPreprocessor.PUNCTUATION and tag != \",\":\n\n token = TextPreprocessor.replace_user_mentions(token)\n token = TextPreprocessor.replace_urls(token)\n replaced = [token]\n for i in replaced:\n\n i = TextPreprocessor.replace_all_punctuation(i)\n if i.lower() not in TextPreprocessor.STOPWORDS and i != 'URL' and i!= 'USERMENTION':\n if i != \"\" and not re.match('\\B#\\w*[a-zA-Z]+\\w*', i):\n before = i\n i = TextPreprocessor.SPELL_CHECKER.correct(i, tag)\n if i != before:\n contains_spelling_mistake = True\n if tag in tags_to_lemmatize:\n i = TextPreprocessor.lemmatize(i, tag)\n i = TextPreprocessor.stem(i, tag)\n # check again, since stemming, lemmatization or spelling correction can produce stopwords\n # if i.lower() not in TextPreprocessor.STOPWORDS:\n if i != 'URL' and i!= 'USERMENTION' and i!='':\n i = i.lower()\n if re.match(\".*[a-zA-Z]'\", i):\n i = i[:-1]\n prepro.append(i)\n return prepro, contains_spelling_mistake","def filter_ordered_questions_by_concepts(questions, item_params, target_concept, concept_map): \n \n def get_parents(target, concept_map):\n \"\"\"\n Given a target concept, return a list of concept IDs for parent concepts\n \"\"\"\n parents = []\n target_index = concept_map[CONCEPTS_STR].index(target)\n for row in range(len(concept_map[ADJ_MAT_STR])): \n # get value in adjMat for each row at target concept's col\n val = concept_map[ADJ_MAT_STR][row][target_index] \n if val > 0 and target_index != row: # don't care concepts are their own parents\n # print('parent found at {}, {}'.format(row, target_index)) # TODO remove\n parents.append(concept_map[CONCEPTS_STR][row])\n return parents\n\n def get_children(target, concept_map):\n \"\"\"\n Given a target concept, return a list of concept IDs for all child concepts\n \"\"\"\n child_inds = []\n target_index = concept_map[CONCEPTS_STR].index(target)\n target_row = concept_map[ADJ_MAT_STR][target_index]\n for ind in range(len(target_row)): # for each ind in row of adj mat\n val = target_row[ind]\n if(val>0 and ind != target_index): # don't care concept is child of itself\n child_inds.append(ind)\n return list(map(lambda ind: concept_map[CONCEPTS_STR][ind], child_inds))\n\n def get_concept(eid, item_params):\n \"\"\"\n Given a question/exercise eid (String) and item_params (pd.DataFrame),\n return the concept that exercise corresponds to.\n\n Assumes eid is unique (maps to exactly 1 row)\n \"\"\"\n\n concept = item_params[item_params[EID]==eid][CONCEPT]\n\n if len(concept) < 1: # TODO: make this filter \"!= 1\" to be more strict\n raise Exception(\"Exercise ID does not map to any exercises. eid: {}\".format(eid))\n else:\n return concept.iloc[0] # to get actual value\n \n df_item_params = pd.DataFrame.from_dict(item_params)\n\n rec_eids = []\n\n # get all recommendations from target, its children, parents\n rec_eids += list(filter(lambda q: get_concept(q, df_item_params) in \n [target_concept] + \n get_children(target_concept, concept_map) +\n get_parents(target_concept, concept_map), questions))\n \n # # GET TOP FOR EACH RELATIONSHIP\n # # add max_num_target questions of same concept to rec_eids\n # rec_target = list(filter(lambda q: get_concept(q, df_item_params) == target_concept, \n # questions))[:max_num_target]\n # # print(\"For target, added {}\".format(rec_target))\n # rec_eids += rec_target\n \n\n # # add max_num_child questions of child concepts to rec_eids\n # rec_child = list(filter(lambda q: get_concept(q, df_item_params) in get_children(target_concept, concept_map), \n # questions))[:max_num_child]\n # # print(\"For children, added {}\".format(rec_child ))\n # rec_eids += rec_child\n\n # # add max_num_parent questions of parent concepts to rec_eids\n # rec_parent = list(filter(lambda q: get_concept(q, df_item_params) in get_parents(target_concept, concept_map), \n # questions))[:max_num_parent] \n # # print(\"For parents, added {}\".format(rec_parent))\n # rec_eids += rec_parent \n\n # want order of recommendations to stay same & only grab from top half of recommendations\n # return list(filter(lambda eid: eid in rec_eids, questions[:int(len(questions)/2)+1])) \n\n # want order of recommendations to stay same\n return list(filter(lambda eid: eid in rec_eids, questions))","def vectorize(ex, model, single_answer=False):\r\n word_dict = model.word_dict\r\n tgt_dict = model.tgt_dict\r\n\r\n if model.args.use_elmo:\r\n # Index words\r\n document = torch.from_numpy(np.asarray(elmo_sent_mapper(ex['document']), dtype=np.int))\r\n if(model.args.reader_type!='summarizer'):\r\n question = torch.from_numpy(np.asarray(elmo_sent_mapper(ex['question']), dtype=np.int))\r\n\r\n # When using elmo, char representations are not required\r\n document_chars, question_chars = -1, -1\r\n else:\r\n # Index words\r\n document = torch.LongTensor([word_dict[w] for w in ex['document']])\r\n if(model.args.reader_type!='summarizer'):\r\n question = torch.LongTensor([word_dict[w] for w in ex['question']])\r\n\r\n # Index chars\r\n if model.args.reader_type == 'mlstm' or \\\r\n model.args.reader_type == 'areader':\r\n document_chars, question_chars = -2, -2\r\n else:\r\n document_chars = torch.LongTensor([word_dict.word_to_char_ids(w).tolist() for w in ex['document']])\r\n if(model.args.reader_type!='summarizer'):\r\n question_chars = torch.LongTensor([word_dict.word_to_char_ids(w).tolist() for w in ex['question']])\r\n\r\n # ...or with target(s) (might still be empty if answers is empty)\r\n # handle if questions are unanswerable [SQuAD v2.0]\r\n if(model.args.reader_type!='summarizer'):\r\n \r\n if single_answer:\r\n assert (len(ex['answers']) > 0)\r\n answer = torch.LongTensor([tgt_dict[w] for w in ex['answers'][0]])\r\n else:\r\n # FIXME: multiple answers are possible, fix batchify also.\r\n # answer = [torch.LongTensor([word_dict[w] for w in ans]) for ans in ex['answers']]\r\n answer = torch.LongTensor([tgt_dict[w] for w in ex['answers'][0]])\r\n else:\r\n summary = torch.LongTensor([tgt_dict[w] for w in ex['summary']])\r\n\r\n\r\n if(model.args.reader_type!='summarizer'):\r\n return document, document_chars, question, question_chars, answer, \\\r\n ex['id'], ex['document'], ex['question'], ex['answers'], \\\r\n ex['src_vocab']\r\n else:\r\n return document, document_chars, summary, ex['id'], ex['document'], ex['summary'], ex['src_vocab']","def own_accuracy(self, questions):\n ok_vocab = self.get_vocabulary()\n print(\"ok vocab\")\n #print(ok_vocab)\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\n print(\"not dict\")\n #new_vocab = [w.upper() for w in ok_vocab]\n #print(new_vocab)\n new_vocab = {w.upper(): v for w, v in new_vocab}\n new_vocab = dict(new_vocab)\n #print(new_vocab)\n\n\n\n\n sections, section = [], None\n wrong_predictions = []\n for line_no, line in enumerate(utils.smart_open(questions)):\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\n line = utils.to_unicode(line)\n if line.startswith(': '):\n # a new section starts => store the old section\n if section:\n sections.append(section)\n self.log_accuracy(section)\n section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}\n else:\n if not section:\n raise ValueError(\"missing section header before line #%i in %s\" % (line_no, questions))\n try:\n a, b, c, expected = [word.upper() for word in line.split()]\n except ValueError:\n logger.info(\"skipping invalid line #%i in %s\", line_no, questions)\n continue\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\n if a not in new_vocab:\n print(\"Dont know: \" + a)\n if b not in new_vocab:\n print(\"Dont know: \" + b)\n if c not in new_vocab:\n print(\"Dont know: \" + c)\n if expected not in new_vocab:\n print(\"Dont know: \" + expected)\n logger.debug(\"skipping line #%i with OOV words: %s\", line_no, line.strip())\n continue\n\n original_vocab = self.get_vocabulary()\n self.set_vocabulary(new_vocab)\n ignore = {a, b, c} # input words to be ignored\n\n # find the most likely prediction, ignoring OOV words and input words\n sims = self.most_similar(positive_words=[b, c], negative_words=[a])\n #print(\"sims\")\n #print(sims)\n self.set_vocabulary(original_vocab)\n\n predicted = sims[0][0]\n predicted = predicted.upper()\n #print(predicted)\n if predicted == expected:\n section['correct'].append((a, b, c, expected))\n else:\n wrong_message = a + \" \" + b + \" \" + c + \", predicted: \" + predicted + \", should have been: \" + expected\n section['incorrect'].append((a, b, c, expected))\n wrong_predictions.append(wrong_message)\n if section:\n # store the last section, too\n sections.append(section)\n self.log_accuracy(section)\n\n total = {\n 'section': 'total',\n 'correct': sum((s['correct'] for s in sections), []),\n 'incorrect': sum((s['incorrect'] for s in sections), []),\n }\n self.log_accuracy(total)\n sections.append(total)\n print(wrong_predictions)\n return sections","def fix_keyword_detection_issues(\n dset: List, organ2ind: Dict\n): \n \n \"\"\"SOLVE CARDIA\"\"\" \n\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if (\n \"cardiac\" in keywords\n and \"stomach\" in occ_organ_names\n and any(\n [\n item in organ_names\n for item in [\"atrium\", \"ventricle\", \"myocardium\", \"pericardium\"]\n ]\n )\n ):\n occ_organ_indices.remove(organ2ind[\"stomach\"])\n occ_organ_names.remove(\"stomach\")\n if (\n \"cardia\" in keywords\n and \"myocardium\" in occ_organ_names\n and any([item in organ_names for item in [\"stomach\"]])\n ):\n occ_organ_indices.remove(organ2ind[\"myocardium\"])\n occ_organ_names.remove(\"myocardium\")\n abstract[\"occ_organ_indices\"] = occ_organ_indices\n abstract[\"occ_organ_names\"] = occ_organ_names\n\n inds = []\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if \"cardiac\" in keywords and \"stomach\" in occ_organ_names:\n inds.append(ind)\n\n \"\"\"SOLVE THE LIVER - DELIVER PROBLEM\"\"\"\n\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if (\n any(\n [\n keyword in keywords\n for keyword in [\"delivery\", \"delivered\", \"deliver\", \"delivering\"]\n ]\n )\n and \"liver\" not in organ_names\n ):\n occ_organ_indices.remove(organ2ind[\"liver\"])\n occ_organ_names.remove(\"liver\")\n keywords = [\n keyword\n for keyword in keywords\n if keyword not in [\"delivery\", \"delivered\", \"deliver\", \"delivering\"]\n ]\n abstract[\"occ_organ_indices\"] = occ_organ_indices\n abstract[\"occ_organ_names\"] = occ_organ_names\n abstract[\"keywords\"] = keywords\n\n \"\"\"SOLVE THE COLON - COLONISE PROBLEM\"\"\"\n\n inds = []\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if (\n any(\n [\n keyword in keywords\n for keyword in [\n \"colonize\",\n \"colonise\",\n \"colonized\",\n \"colonised\",\n \"colonies\",\n ]\n ]\n )\n and \"colon\" not in organ_names\n ):\n occ_organ_indices.remove(organ2ind[\"colon\"])\n occ_organ_names.remove(\"colon\")\n keywords = [\n keyword\n for keyword in keywords\n if keyword\n not in [\"colonize\", \"colonise\", \"colonized\", \"colonised\", \"colonies\"]\n ]\n abstract[\"occ_organ_indices\"] = occ_organ_indices\n abstract[\"occ_organ_names\"] = occ_organ_names\n abstract[\"keywords\"] = keywords\n\n \"\"\"SOLVE THE BLADDER - GALLBLADDER PROBLEM\"\"\"\n\n \"\"\"Gallbladder doesn't cause the bladder keyword\"\"\"\n \"\"\"Bladder does cause problems\"\"\"\n\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if (\n any([keyword in keywords for keyword in [\"bladder\", \"bladders\"]])\n and any(\n [\n keyword in keywords\n for keyword in [\n \"gall\",\n \"gallbladder\",\n \"gall-bladder\",\n \"gallbladders\",\n \"gall-bladders\",\n ]\n ]\n )\n and \"gallbladder\" in organ_names\n ):\n occ_organ_indices.remove(organ2ind[\"urinary bladder\"])\n occ_organ_names.remove(\"urinary bladder\")\n keywords = [\n keyword\n for keyword in keywords\n if keyword not in [\"bladder\", \"bladders\"]\n ]\n abstract[\"occ_organ_indices\"] = occ_organ_indices\n abstract[\"occ_organ_names\"] = occ_organ_names\n abstract[\"keywords\"] = keywords\n\n return dset","def _process_row(self, question):\n\n # this returns a list, e.g. [('today', 'DATE'), ('Patrick', 'PERSON')]\n ent_lst = self.text_preprocessor.compute_ner(question.context)\n\n ent_dct = {}\n for ent_str, ner_category in ent_lst:\n # perform uncasing\n ent_dct[ent_str.lower()] = ner_category\n\n new_answers = []\n for ans_struct in question.answers:\n ans_text = ans_struct['text'].lower() # perform uncasing\n if ans_text not in ent_dct:\n continue\n\n ans_struct['ner_category'] = ent_dct[ans_text]\n new_answers.append(ans_struct)\n\n question.answers = new_answers\n return question","def replace_oov_words_by_unk(tokenized_sentences, vocabulary, unknown_token=\"<unk>\"):\r\n \r\n # Place vocabulary into a set for faster search\r\n vocabulary = set(vocabulary)\r\n \r\n # Initialize a list that will hold the sentences\r\n # after less frequent words are replaced by the unknown token\r\n replaced_tokenized_sentences = []\r\n \r\n for sentence in tokenized_sentences:\r\n \r\n\r\n replaced_sentence = []\r\n\r\n for token in sentence: \r\n \r\n if token in vocabulary:\r\n replaced_sentence.append(token)\r\n else:\r\n replaced_sentence.append(unknown_token)\r\n \r\n # Append the list of tokens to the list of lists\r\n replaced_tokenized_sentences.append(replaced_sentence)\r\n \r\n return replaced_tokenized_sentences","def _compute_question_ids(self):\n if self._origin.question_ids:\n # lines to keep: those with already sent emails or registrations\n questions_tokeep_ids = self.env['event.registration.answer'].search(\n [('question_id', 'in', self._origin.question_ids.ids)]\n ).question_id.ids\n else:\n questions_tokeep_ids = []\n for event in self:\n if not event.event_type_id and not event.question_ids:\n event.question_ids = False\n continue\n\n if questions_tokeep_ids:\n questions_toremove = event._origin.question_ids.filtered(lambda question: question.id not in questions_tokeep_ids)\n command = [(3, question.id) for question in questions_toremove]\n else:\n command = [(5, 0)]\n if event.event_type_id.use_mail_schedule:\n command += [\n (0, 0, {\n 'title': question.title,\n 'question_type': question.question_type,\n 'sequence': question.sequence,\n 'once_per_order': question.once_per_order,\n 'answer_ids': [(0, 0, {\n 'name': answer.name,\n 'sequence': answer.sequence\n }) for answer in question.answer_ids],\n }) for question in event.event_type_id.question_ids\n ]\n event.question_ids = command","def question_new_translate():","def special_danish_accuracy(self, questions):\n ok_vocab = self.get_vocabulary()\n print(\"ok vocab\")\n #print(ok_vocab)\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\n print(\"not dict\")\n #new_vocab = [w.upper() for w in ok_vocab]\n #print(new_vocab)\n new_vocab = {w.upper(): v for w, v in new_vocab}\n new_vocab = dict(new_vocab)\n #print(new_vocab)\n\n\n\n\n sections, section = [], None\n wrong_predictions = []\n for line_no, line in enumerate(utils.smart_open(questions)):\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\n line = utils.to_unicode(line)\n if line.startswith(': '):\n # a new section starts => store the old section\n if section:\n sections.append(section)\n self.log_accuracy(section)\n section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}\n else:\n if not section:\n raise ValueError(\"missing section header before line #%i in %s\" % (line_no, questions))\n try:\n a, b, c, d, e, expected = [word.upper() for word in line.split()]\n except ValueError:\n logger.info(\"skipping invalid line #%i in %s\", line_no, questions)\n continue\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or d not in new_vocab or e not in new_vocab or expected not in new_vocab:\n #print('not in vocab')\n logger.debug(\"skipping line #%i with OOV words: %s\", line_no, line.strip())\n continue\n\n original_vocab = self.get_vocabulary()\n self.set_vocabulary(new_vocab)\n ignore = {a, b, c, d, e} # input words to be ignored\n\n # find the most likely prediction, ignoring OOV words and input words\n sims = self.most_similar(positive_words=[c, d, e], negative_words=[a, b])\n #print(\"sims\")\n #print(sims)\n self.set_vocabulary(original_vocab)\n\n predicted = sims[0][0]\n predicted = predicted.upper()\n #print(predicted)\n if predicted == expected:\n section['correct'].append((a, b, c, d, e, expected))\n else:\n wrong_message = a + \" \" + b + \" \" + c + \" \" + d + \" \" + e + \", predicted: \" + predicted + \", should have been: \" + expected\n section['incorrect'].append((a, b, c, d, e, expected))\n wrong_predictions.append(wrong_message)\n if section:\n # store the last section, too\n sections.append(section)\n self.log_accuracy(section)\n\n total = {\n 'section': 'total',\n 'correct': sum((s['correct'] for s in sections), []),\n 'incorrect': sum((s['incorrect'] for s in sections), []),\n }\n self.log_accuracy(total)\n sections.append(total)\n print(wrong_predictions)\n return sections","def _tokenize_replace_pos(text, language_code, replace_pos):\n seq = annotool.raw2basicseq(text, language_code, pos=True)\n word_seq = seq['word']\n pos_seq = seq['pos']\n for i, pos in enumerate(pos_seq):\n if pos in replace_pos:\n word_seq[i] = '[{}]'.format(pos)\n return word_seq","def encode_answers(df, schema):\n encoders = get_encoders(schema)\n\n for question in schema.questions:\n df[question.prediction_encoded] = encoders[question.name].transform(df[question.prediction])\n\n return df","def encode_decode_TD(self, n_step, idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ ):\r\n\r\n actor_embedding = embed_seq(input_seq=self.input_, from_=self.dimension, to_= self.input_embed, is_training=self.is_training, BN=True, initializer=self.initializer)\r\n actor_encoding = encode_seq(input_seq=actor_embedding, input_dim=self.input_embed, num_stacks=self.num_stacks, num_heads=self.num_heads, num_neurons=self.num_neurons, is_training=self.is_training)\r\n \r\n if self.is_training == False:\r\n actor_encoding = tf.tile(actor_encoding,[self.batch_size,1,1])\r\n \r\n idx_list = copy(idx_list_previous)\r\n log_probs = copy(log_probs_previous)\r\n entropies = copy(entropies_previous)\r\n \r\n\r\n mask = copy(mask_previous)\r\n \r\n n_hidden = actor_encoding.get_shape().as_list()[2] # input_embed\r\n W_ref = tf.get_variable(\"W_ref\",[1, n_hidden, self.num_units],initializer=self.initializer)\r\n W_q = tf.get_variable(\"W_q\",[self.query_dim, self.num_units],initializer=self.initializer)\r\n v = tf.get_variable(\"v\",[self.num_units],initializer=self.initializer)\r\n \r\n encoded_ref = tf.nn.conv1d(actor_encoding, W_ref, 1, \"VALID\") # actor_encoding is the ref for actions [Batch size, seq_length, n_hidden]\r\n \r\n query1 = copy( query1_previous)\r\n query2 = copy( query2_previous)\r\n query3 = copy( query3_previous)\r\n idx_copy = copy(idx_)\r\n \r\n W_1 =tf.get_variable(\"W_1\",[n_hidden, self.query_dim],initializer=self.initializer) # update trajectory (state)\r\n W_2 =tf.get_variable(\"W_2\",[n_hidden, self.query_dim],initializer=self.initializer)\r\n W_3 =tf.get_variable(\"W_3\",[n_hidden, self.query_dim],initializer=self.initializer)\r\n \r\n \r\n \"\"\"\r\n # sample from POINTER from the perspective of the Actor\r\n \"\"\"\r\n for step in range(n_step + 1 ): \r\n query = tf.nn.relu(tf.matmul(query1, W_1) + tf.matmul(query2, W_2) + tf.matmul(query3, W_3))\r\n logits = pointer(encoded_ref=encoded_ref, query=query, mask=mask, W_ref=W_ref, W_q=W_q, v=v, C=config.C, temperature=config.temperature)\r\n prob = distr.Categorical(logits) # logits = masked_scores\r\n idx = prob.sample()\r\n\r\n idx_list.append(idx) # tour index\r\n idx_list_previous.append(idx)\r\n \r\n log_probs.append(prob.log_prob(idx)) # log prob\r\n log_probs_previous.append(prob.log_prob(idx))\r\n \r\n entropies.append(prob.entropy()) # entropies\r\n entropies_previous.append(prob.entropy())\r\n \r\n mask = mask + tf.one_hot(idx, self.max_length) # mask\r\n mask_previous = mask_previous + tf.one_hot(idx, self.max_length)\r\n\r\n idx_copy = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \r\n idx_ = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \r\n query3 = query2\r\n query2 = query1\r\n query1 = tf.gather_nd(actor_encoding, idx_) # update trajectory (state)\r\n \r\n query3_previous = query2_previous\r\n query2_previous = query1_previous\r\n query1_previous = tf.gather_nd(actor_encoding, idx_) # update trajectory (state) \r\n\r\n if (len(idx_list) >= self.max_length): break #leave the loop if reach the end of the episode\r\n\r\n \"\"\"\r\n # sample from POINTER from the perspective of the Critic\r\n make q_t vector = 0\r\n \"\"\"\r\n while(len(idx_list) < self.max_length): \r\n \r\n logits = pointer_critic(encoded_ref=encoded_ref, mask=mask, W_ref=W_ref, v=v, C=config.C, temperature=config.temperature)\r\n prob = distr.Categorical(logits) # logits = masked_scores\r\n idx = prob.sample()\r\n\r\n idx_list.append(idx) # tour index\r\n log_probs.append(prob.log_prob(idx)) # log prob\r\n entropies.append(prob.entropy()) # entropies\r\n mask = mask + tf.one_hot(idx, self.max_length) # mask\r\n\r\n idx_copy = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \r\n #idx_ = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \r\n query3 = query2\r\n query2 = query1\r\n query1 = tf.gather_nd(actor_encoding, idx_copy) # update trajectory (state)\r\n \r\n idx_list.append(idx_list[0]) # return to start\r\n self.tour =tf.stack(idx_list, axis=1) # permutations\r\n self.log_prob = tf.add_n(log_probs) # corresponding log-probability for backprop\r\n self.entropies = tf.add_n(entropies)\r\n tf.summary.scalar('log_prob_mean', tf.reduce_mean(self.log_prob))\r\n tf.summary.scalar('entropies_mean', tf.reduce_mean(self.entropies))\r\n \r\n return idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ #returns variables necessary for the next loop\r","def map_question_linked_abstracts(include_no_abstracts):\r\n\tif load_common_map():\r\n\t\treturn\r\n\t\t\r\n\tglobal question_map, abstract_map, common_map\r\n\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict\r\n\r\n\tprint('\\nmapping question to answers')\r\n\t\r\n\tcommon_map = collections.defaultdict(list)\r\n\t\r\n\tno_abstract_count = 0\r\n\t\t\r\n\tfor i,v in question_map.items():\r\n\t\tprint(i)\r\n\t\tabstracts = linked_abstracts_dict[i]\r\n\t\tfor a in abstracts:\r\n\t\t\tif (a != 'NO_ABSTRACT') and (a in abstract_map.keys()):\r\n\t\t\t\tcommon_map[i].append([v,abstract_map[a]])\r\n\t\t\telse:\r\n\t\t\t\tif include_no_abstracts:\r\n\t\t\t\t\tcommon_map[i].append([v,()])\r\n\t\t\t\tno_abstract_count += 1\r\n\t\r\n\tprint('\\nabstractless : ' + str(no_abstract_count))\r\n\t\r\n\tprint(len(question_map))\r\n\tprint(len(abstract_map))\r\n\tprint(len(common_map))\r\n\t\r\n\tpickle.dump(common_map,open(paths.path_data_map_common_pickle,\"wb\"))","def set_encodings(questions, candidates,\n question_encoder, response_encoder):\n for i, chunk in enumerate(chunks(questions, 100)):\n question_strs = [q.question for q in chunk]\n question_encodings = np.array(question_encoder(question_strs))\n\n for j in range(question_encodings.shape[0]):\n questions[i * 100 + j].encoding = question_encodings[j]\n if i % 50 == 0:\n print(\"Questions: encoded %s of %s...\" % (i * 100, len(questions)))\n\n for i, chunk in enumerate(chunks(candidates, 50)):\n candidate_strs = [(c.sentence, c.context) for c in chunk]\n candidate_encodings = np.array(response_encoder(candidate_strs))\n for j in range(candidate_encodings.shape[0]):\n candidates[i * 50 + j].encoding = candidate_encodings[j]\n if i % 100 == 0:\n print(\"Candidates: encoded %s of %s...\" % (i * 50, len(candidates)))","def match(self, passage_encodes, question_encodes, p_length, q_length):\n with tf.variable_scope('bidaf'):\n if self.use_complex_s:\n p_length=tf.shape(passage_encodes)[1]\n q_length=tf.shape(question_encodes)[1]\n hp=tf.tile(tf.expand_dims(passage_encodes,2),[1,1,q_length,1])\n hq=tf.tile(tf.expand_dims(question_encodes,1),[1,p_length,1,1])\n fusion=tf.concat([hp,hq,hp*hq],-1)\n sim_matrix=tf.squeeze(tf.contrib.layers.fully_connected(fusion,num_outputs=1,activation_fn=None),-1)\n else:\n sim_matrix = tf.matmul(passage_encodes, question_encodes, transpose_b=True)\n context2question_attn = tf.matmul(tf.nn.softmax(sim_matrix, -1), question_encodes)\n b = tf.nn.softmax(tf.expand_dims(tf.reduce_max(sim_matrix, 2), 1), -1)\n question2context_attn = tf.tile(tf.matmul(b, passage_encodes),\n [1, tf.shape(passage_encodes)[1], 1])\n concat_outputs = tf.concat([passage_encodes, context2question_attn,\n passage_encodes * context2question_attn,\n passage_encodes * question2context_attn], -1)\n return concat_outputs, None","def combine_corpus(include_whole_abstracts=False):\r\n\tif load_combined_corpus_maps():\r\n\t\treturn\r\n\t\r\n\tglobal gensim_dictionary\r\n\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict, abstracts_dict\r\n\tglobal common_corpus_list, question_map, abstract_map, abstract_whole_map\r\n\tglobal corpus_layout\r\n\t\r\n\tprint('\\nbuilding common corpus')\r\n\t\r\n\tcommon_corpus_list = list()\r\n\tquestion_map = dict()\r\n\tabstract_map = dict()\r\n\tabstract_whole_map = dict()\r\n\t\r\n\tsentence_count = 0\r\n\t\r\n\tcorpus_layout = []\r\n\t\r\n\tfor qi,qv in search_criteria_dict.items():\r\n\t\tquestions = qv\r\n\t\t\r\n\t\tsentence_incr = len(questions)\r\n\t\tquestion_map[qi] = (sentence_count,sentence_count + sentence_incr)\r\n\t\tsentence_count += sentence_incr\r\n\t\t\r\n\t\tfor st in questions:\r\n\t\t\tcommon_corpus_list.append(st)\r\n\t\r\n\tcorpus_layout.append(('Q',sentence_count))\r\n\t\r\n\tfor ai,av in abstracts_dict.items():\r\n\t\tabstract = av\r\n\t\t\r\n\t\tsentence_incr = len(abstract)\r\n\t\tabstract_map[ai] = (sentence_count,sentence_count + sentence_incr)\r\n\t\tsentence_count += sentence_incr\r\n\r\n\t\tfor st in abstract:\r\n\t\t\tcommon_corpus_list.append(st)\r\n\t\r\n\tcorpus_layout.append(('A',sentence_count))\r\n\r\n\tif include_whole_abstracts:\r\n\t\tfor ai,av in abstracts_dict.items():\r\n\t\t\tabstract = av\r\n\t\t\t\r\n\t\t\tabstract_whole_map[ai] = (sentence_count,sentence_count + 1)\r\n\t\t\tsentence_count += 1\r\n\r\n\t\t\tst = tuple('\\n'.join(s) for s in zip(*abstract))\r\n\t\t\tif len(st) < 2:\r\n\t\t\t\tst = ('','')\r\n\r\n\t\t\tcommon_corpus_list.append(st)\r\n\t\t\r\n\t\tcorpus_layout.append(('W',sentence_count))\r\n\t\r\n\tpickle.dump(question_map,open(paths.path_data_map_questions_pickle,\"wb\"))\r\n\tpickle.dump(abstract_map,open(paths.path_data_map_abstracts_pickle,\"wb\"))\r\n\tpickle.dump(abstract_whole_map,open(paths.path_data_map_abstracts_whole_pickle,\"wb\"))\t\r\n\tpickle.dump(common_corpus_list,open(paths.path_data_corpus_pickle,\"wb\"))\r\n\tpickle.dump(corpus_layout,open(paths.path_data_corpus_layout_pickle,\"wb\"))","def preprocess(self, df, maxlen = 169):\n \n vocabs = self.tk.word_index.keys()\n \n df1 = self.treat_na(df)\n df2 = self.remove_punc_sw(df1)\n df3 = self.remove_numbers(df2)\n df4 = self.lemma_pos(df3)\n df5 = self.bigram(df4)\n df6 = self.combine_bigrams(df5)\n \n new_docs = []\n \n for word_list in df6:\n \n if len(word_list) == 2 and word_list[0].lower() == 'noinfo' and word_list[1].lower() == 'noinfo':\n new_docs.append(list(np.zeros(maxlen)))\n \n else:\n new_word_list = []\n for word in word_list:\n if word not in vocabs:\n word = 'UNKNOWN_TOKEN'\n new_word_list.append(word)\n \n sequence = \" \".join(new_word_list)\n vectors = self.tk.texts_to_sequences([sequence])\n padded_vectors = pad_sequences(vectors, maxlen=maxlen, padding='post', truncating='post')\n \n new_docs.append(list(padded_vectors[0]))\n \n return new_docs","def disambiguate_all_not_disambiguated(\n celery_batch_size, total_records, indexing_queue_limit, disambiguation_queue_limit\n):\n with current_celery_app.connection_or_acquire() as conn:\n indexer_queue = conn.default_channel.queue_declare(\n queue=\"indexer_task\", passive=True\n )\n disambiguation_queue = conn.default_channel.queue_declare(\n queue=\"disambiguation\", passive=True\n )\n if (\n disambiguation_queue.message_count > disambiguation_queue_limit\n or indexer_queue.message_count > indexing_queue_limit\n ):\n click.echo(\"MQ queues are full, can't run disambiguation\")\n return\n not_disambiguated_records_search = _get_all_not_disambiguated_records_search()\n documents = not_disambiguated_records_search.scan()\n if total_records:\n documents = islice(documents, total_records)\n uuids = (document.meta.id for document in documents)\n _send_celery_group_disambiguation_task(uuids, celery_batch_size)","def rewritten_queries(question):\n # rewrites = []\n # tq = tokenize(question)\n # verb = tq[1] # 目前只处理 谁是XXX类 问题\n # rewrites.append(\n # RewrittenQuery(\"\\\"%s %s\\\"\" % (verb, \" \".join(tq[2:])),\n # QUOTED_QUERY_SCORE))\n # for j in range(2, len(tq)):\n # rewrites.append(\n # RewrittenQuery(\n # \"\\\"%s %s %s\\\"\" % (\n # \" \".join(tq[2:j + 1]), verb, \" \".join(tq[j + 1:])),\n # QUOTED_QUERY_SCORE))\n # rewrites.append(RewrittenQuery(\" \".join(tq[2:]), UNQUOTED_QUERY_SCORE))\n return [RewrittenQuery(question, 1)]","def w_question(analysis):\n if analysis.sv:\n #Opinion is a what question so we have to make some changes\n if analysis.sv[0].vrb_main[0].endswith('like'):\n verb = analysis.sv[0].vrb_main[0]\n analysis.sv[0].vrb_main[0] = verb[:len(verb) - 4] + 'think+of'\n\n #processing as yes or no question\n phrase = y_o_question(analysis)\n\n #Specific processing for invitation\n if analysis.aim == 'invitation':\n return ['how', 'about'] + phrase[1:]\n\n #Specific processing for classification\n if analysis.aim.startswith('classification'):\n aim_question = other_functions.list_rebuilding(analysis.aim)\n return ['what', 'kind', 'of'] + aim_question[1:] + phrase\n\n #It is an how question\n if other_functions.is_an_adj(analysis.aim) == 1:\n return ['how'] + [analysis.aim] + phrase\n elif analysis.aim == 'manner':\n return ['how'] + phrase\n\n if analysis.aim == 'thing' or analysis.aim == 'situation' or analysis.aim == 'explication' or analysis.aim == 'opinion':\n return ['what'] + phrase\n return ['what'] + [analysis.aim] + phrase","def auto_corr(sent, target_pos):\n for pos in target_pos:\n target_v = None\n t0 = time.time()\n if len(sent) > 1:\n context_v = model.context2vec(sent, pos) \n context_v = context_v / xp.sqrt((context_v * context_v).sum())\n else:\n context_v = None\n\n if target_v is not None and context_v is not None:\n similarity = mult_sim(w, target_v, context_v)\n else:\n if target_v is not None:\n v = target_v\n elif context_v is not None:\n v = context_v \n else:\n raise Exception(\"Can't find a target nor context.\") \n similarity = (w.dot(v)+1.0)/2 # Cosine similarity can be negative, mapping similarity to [0,1]\n\n old_word = sent[pos]\n if STATE == 'manual':\n print \"\\n>> For the correction of word: \", old_word\n print \">>>> Calculating the candidates ... ...\"\n candidats = candidates(old_word)\n\n l = []\n count = 0\n\n if len(candidats)!=0:\n for i in (-similarity).argsort():\n if index2word[i] not in candidats:\n continue\n else:\n count += 1\n if STATE == 'manual':\n print \"candidate %d:\\t\"%count, index2word[i], \", similarity:\\t\", similarity[i]\n l.append(i)\n if count == N_RESULT:\n break \n else:\n for i in (-similarity).argsort():\n if np.isnan(similarity[i]):\n continue\n #print sent[pos], index2word[i]\n dist = levenshtein(index2word[i], sent[pos])\n if dist <= LEVEN_DIST:\n count += 1\n if STATE == 'manual':\n print \"candidate %d:\\t\"%count, index2word[i],\", similarity:\\t\", similarity[i], \", levenshtein distance:\\t\", dist\n l.append(i)\n if count == N_RESULT:\n break \n if len(l) == 0:\n continue\n \n if STATE == 'manual':\n print \"Time: %.2fs\"%(time.time()-t0)\n print \"Please choose the replacement, enter the number of the candidate: (Enter 0 for no replacement)\"\n choice = six.moves.input('>> ')\n c = int(choice)\n if c == 0:\n continue # no change made\n elif c > 0:\n idx = l[c - 1]\n else:\n raise Exception(\"Invalid input!\") \n elif STATE == 'auto':\n idx = l[0]\n corr_word = index2word[idx]\n\n \n print \">>>> \\t\", old_word, \"\\t--->\\t\", corr_word\n sent[pos] = corr_word\n return sent","def generate_question_inter(path):\n\n\t# Function to compute vocabulary intersection\n\tdef q1_q2_intersect(row):\n\t return(len(set(q_dict[row['question1']]).intersection(set(q_dict[row['question2']]))))\n\n\t# Load training and test set\n\ttrain_orig =pd.read_csv(os.path.join(path,'train.csv'), sep=',',names = [\"id\", \"qid1\", \"qid2\", \"question1\",\"question2\",\"is_duplicate\"])\n\ttest_orig = pd.read_csv(os.path.join(path,'test.csv'), sep=',',names = [\"id\", \"qid1\", \"qid2\", \"question1\",\"question2\"])\n\n\t# Concatenation\n\tques = pd.concat([train_orig[['question1', 'question2']], test_orig[['question1', 'question2']]], axis=0).reset_index(drop='index')\n\n\n\tq_dict = defaultdict(set)\n\tfor i in range(ques.shape[0]):\n\t q_dict[ques.question1[i]].add(ques.question2[i])\n\t q_dict[ques.question2[i]].add(ques.question1[i])\n\n\t# Compute vocabulary intersection\n\ttrain_orig['q1_q2_intersect'] = train_orig.apply(q1_q2_intersect, axis=1, raw=True)\n\ttest_orig['q1_q2_intersect'] = test_orig.apply(q1_q2_intersect, axis=1, raw=True)\n\n\ttrain_feat = train_orig[['q1_q2_intersect']]\n\ttest_feat = test_orig[['q1_q2_intersect']]\n\n\tprint('Writing train features...')\n\ttrain_feat.to_csv(os.path.join(path,'train_question_inter.csv'))\n\n\tprint('Writing test features...') \n\ttest_feat.to_csv(os.path.join(path,'test_question_inter.csv'))\n\n\tprint('CSV written ! see: ', path, \" | suffix: \", \"_question_inter.csv\")","def find_explanation_regression_based(user_question_list, global_patterns, global_patterns_dict,\n cat_sim, num_dis_norm, agg_col, conn, cur, pat_table_name, res_table_name):\n answer = [[] for i in range(len(user_question_list))]\n local_pattern_loading_time = 0\n question_validating_time = 0\n score_computing_time = 0\n score_computing_time_list = []\n local_patterns_list = []\n\n for j, uq in enumerate(user_question_list):\n dir = uq['dir']\n topK_heap = TopkHeap(ExplConfig.TOP_K)\n marked = {}\n\n t = dict(uq['target_tuple'])\n\n uq['global_patterns'] = find_patterns_relevant(\n global_patterns_dict, uq['target_tuple'], conn, cur, res_table_name, pat_table_name, cat_sim)\n\n top_k_lists = [[] for i in range(len(uq['global_patterns']))]\n local_patterns = []\n\n ExplConfig.VISITED_DICT = dict()\n score_computing_start = time.time()\n\n for i in range(0, len(uq['global_patterns'])):\n top_k_lists[i] = [4, uq['global_patterns'][i], t, []]\n local_patterns.append(None)\n F_key = str(sorted(uq['global_patterns'][i][0]))\n V_key = str(sorted(uq['global_patterns'][i][1]))\n pat_key = F_key + '|,|' + V_key + '|,|' + uq['global_patterns'][i][2] + '|,|' + uq['global_patterns'][i][3]\n if pat_key in ExplConfig.VISITED_DICT:\n continue\n ExplConfig.VISITED_DICT[pat_key] = True\n\n tF = get_F_value(uq['global_patterns'][i][0], t)\n local_pattern_query_fixed = '''SELECT * FROM {} \n WHERE array_to_string(fixed, ', ')='{}' AND \n REPLACE(array_to_string(fixed_value, ', '), '.0', '')='{}' AND\n array_to_string(variable, ', ')='{}' AND \n agg='{}' AND model='{}'\n ORDER BY theta;\n '''.format(\n pat_table_name + '_local',\n str(uq['global_patterns'][i][0]).replace(\"\\'\", '').replace('[', '').replace(']', ''),\n str(tF)[1:-1].replace(\"\\'\", ''),\n str(uq['global_patterns'][i][1]).replace(\"\\'\", '').replace('[', '').replace(']', ''),\n uq['global_patterns'][i][2], uq['global_patterns'][i][3]\n )\n cur.execute(local_pattern_query_fixed)\n res_fixed = cur.fetchall()\n\n if len(res_fixed) == 0:\n continue\n\n local_patterns[i] = res_fixed[0]\n T_set = set(t.keys()).difference(set(['lambda', uq['global_patterns'][i][2]]))\n agg_col = local_patterns[i][3]\n start = time.time()\n t_t_list, agg_range, t_t_dict = get_tuples_by_F_V(local_patterns[i], local_patterns[i],\n get_F_value(local_patterns[i][0], t),\n # [get_V_value(local_patterns[i][2], t), [[-3, 3]]],\n None,\n conn, cur, res_table_name, cat_sim)\n\n dist_lb = 1e10\n dev_ub = 0\n for t_t in t_t_list:\n if compare_tuple(t_t, t) == 0:\n s = score_of_explanation(t_t, t, cat_sim, num_dis_norm, dir, t_t[agg_col], local_patterns[i],\n local_patterns[i])\n if str(t_t) not in marked:\n marked[str(t_t)] = True\n topK_heap.Push(Explanation(0, s[0], s[1], s[2], s[3], uq['dir'],\n # list(map(lambda y: y[1], sorted(t_t.items(), key=lambda x: x[0]))),\n dict(t_t),\n ExplConfig.TOP_K, local_patterns[i], None))\n\n top_k_lists[i][-1].append(Explanation(0, s[0], s[1], s[2], s[3], uq['dir'],\n dict(t_t),\n ExplConfig.TOP_K, local_patterns[i], None))\n if s[-1] < dist_lb:\n dist_lb = s[-1]\n # use raw distance (without penalty on missing attributes) as the lower bound\n if abs(s[2]) > dev_ub:\n dev_ub = abs(s[2])\n if dist_lb < 1e-10:\n dist_lb = 0.01\n\n end = time.time()\n question_validating_time += end - start\n\n F_set = set(local_patterns[i][0])\n V_set = set(local_patterns[i][2])\n\n # F union V \\subsetneq G\n t_coarser_copy = list(t_t_list)\n norm_lb = min(list(map(lambda x: x[agg_col], t_coarser_copy)))\n\n k_score = topK_heap.MinValue()\n # prune\n if topK_heap.HeapSize() == ExplConfig.TOP_K and 100 * float(dev_ub) / (dist_lb * float(norm_lb)) <= k_score:\n continue\n top_k_lists[i][-1] += DrillDown(global_patterns_dict, local_patterns[i],\n F_set, T_set.difference(F_set.union(V_set)), V_set, t_coarser_copy,\n t_coarser_copy, t, t,\n conn, cur, pat_table_name, res_table_name, cat_sim, num_dis_norm,\n dir, uq['query_result'],\n norm_lb, dist_lb, topK_heap)\n for tk in top_k_lists[i][-1]:\n if str(tk.tuple_value) not in marked:\n marked[str(tk.tuple_value)] = True\n topK_heap.Push(tk)\n\n score_computing_end = time.time()\n score_computing_time_cur_uq = score_computing_end - score_computing_start\n\n answer[j] = topK_heap.TopK()\n score_computing_time_list.append([t, score_computing_time_cur_uq])\n\n print('Local pattern loading time: ' + str(local_pattern_loading_time) + 'seconds')\n print('Score computing time: ' + str(score_computing_time) + 'seconds')\n return answer, local_patterns_list, score_computing_time_list","def convert_examples_to_features(examples, tokenizer, max_seq_length,\n doc_stride, max_query_length, return_answers, skip_no_answer,\n verbose=False, save_with_prob=False, msg=\"Converting examples\"):\n\n unique_id = 1000000000\n features = []\n question_features = []\n\n for (example_index, example) in enumerate(tqdm(examples, desc=msg)):\n\n # Tokenize query into (sub)tokens\n query_tokens = tokenizer.tokenize(example.question_text)\n if len(query_tokens) > max_query_length:\n query_tokens = query_tokens[0:max_query_length]\n\n # Creating a map between word <=> (sub)token\n tok_to_word_index = []\n word_to_tok_index = [] # word to (start of) subtokens\n all_doc_tokens = []\n for (i, word) in enumerate(example.doc_words):\n word_to_tok_index.append(len(all_doc_tokens))\n sub_tokens = tokenizer.tokenize(word)\n for sub_token in sub_tokens:\n tok_to_word_index.append(i)\n all_doc_tokens.append(sub_token)\n\n # The -2 accounts for [CLS], [SEP]\n max_tokens_for_doc = max_seq_length - 2\n\n # Split sequence by max_seq_len with doc_stride, _DocSpan is based on tokens without [CLS], [SEP]\n _DocSpan = collections.namedtuple( # pylint: disable=invalid-name\n \"DocSpan\", [\"start\", \"length\"])\n doc_spans = []\n start_tok_offset = 0 # From all_doc_tokens\n\n # Get doc_spans with stride and offset\n while start_tok_offset < len(all_doc_tokens):\n length = len(all_doc_tokens) - start_tok_offset\n if length > max_tokens_for_doc:\n length = max_tokens_for_doc\n doc_spans.append(_DocSpan(start=start_tok_offset, length=length))\n if start_tok_offset + length == len(all_doc_tokens):\n break\n start_tok_offset += min(length, doc_stride) # seems to prefer doc_stride always\n assert doc_stride < length, \"length is no larger than doc_stride for {}\".format(doc_spans)\n\n # Iterate each doc_span and make out_tokens\n for (doc_span_index, doc_span) in enumerate(doc_spans):\n\n # Find answer position based on new out_tokens\n start_position = None\n end_position = None\n\n # For no_answer, same (-1, -1) applies\n if example.start_position is not None and example.start_position < 0:\n assert example.start_position == -1 and example.end_position == -1\n start_position, end_position = NO_ANS, NO_ANS\n\n # For existing answers, find answers if exist\n elif return_answers:\n\n # Get token-level start/end position\n tok_start_position = word_to_tok_index[example.start_position]\n if example.end_position < len(example.doc_words) - 1:\n tok_end_position = word_to_tok_index[example.end_position + 1] - 1 # By backwarding from next word\n else:\n assert example.end_position == len(example.doc_words) - 1\n tok_end_position = len(all_doc_tokens) - 1\n\n # Improve answer span by subword-level\n (tok_start_position, tok_end_position) = _improve_answer_span(\n all_doc_tokens, tok_start_position, tok_end_position, tokenizer,\n example.orig_answer_text)\n\n # Throw away training samples without answers (due to doc_span split)\n doc_start = doc_span.start\n doc_end = doc_span.start + doc_span.length - 1\n if (tok_start_position < doc_start or tok_end_position < doc_start or\n tok_start_position > doc_end or tok_end_position > doc_end):\n if skip_no_answer:\n continue\n else:\n # For NQ, only add this in 2% (50 times downsample)\n if save_with_prob:\n if np.random.randint(100) < 2:\n start_position, end_position = NO_ANS, NO_ANS\n else:\n continue\n else:\n start_position, end_position = NO_ANS, NO_ANS\n\n # Training samples with answers\n else:\n doc_offset = 1 # For [CLS]\n start_position = tok_start_position - doc_start + doc_offset\n end_position = tok_end_position - doc_start + doc_offset\n assert start_position >= 0 and end_position >= 0, (start_position, end_position)\n\n out_tokens = [] # doc\n out_tokens_ = [] # quesry\n out_tokens.append(\"[CLS]\")\n out_tokens_.append(\"[CLS]\")\n token_to_word_map = {} # The difference with tok_to_word_index is it includes special tokens\n token_is_max_context = {}\n\n # For query tokens, just copy and add [SEP]\n for token in query_tokens:\n out_tokens_.append(token)\n out_tokens_.append(\"[SEP]\")\n\n # For each doc token, create token_to_word_map and is_max_context, and add to out_tokens\n for i in range(doc_span.length):\n split_token_index = doc_span.start + i\n token_to_word_map[len(out_tokens)] = tok_to_word_index[split_token_index]\n is_max_context = _check_is_max_context(doc_spans, doc_span_index, split_token_index)\n token_is_max_context[len(out_tokens)] = is_max_context\n out_tokens.append(all_doc_tokens[split_token_index])\n out_tokens.append(\"[SEP]\")\n\n # Convert to ids and masks\n input_ids = tokenizer.convert_tokens_to_ids(out_tokens)\n input_ids_ = tokenizer.convert_tokens_to_ids(out_tokens_)\n input_mask = [1] * len(input_ids)\n input_mask_ = [1] * len(input_ids_)\n\n # Zero-pad up to the sequence length.\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n while len(input_ids_) < max_query_length + 2: # +2 for [CLS], [SEP]\n input_ids_.append(0)\n input_mask_.append(0)\n assert len(input_ids_) == max_query_length + 2\n assert len(input_mask_) == max_query_length + 2\n\n # Printing for debug\n if example_index < 1 and verbose:\n logger.info(\"*** Example ***\")\n logger.info(\"unique_id: %s\" % (unique_id))\n logger.info(\"example_index: %s\" % (example_index))\n logger.info(\"doc_span_index: %s\" % (doc_span_index))\n logger.info(\"tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in out_tokens]))\n logger.info(\"q tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in out_tokens_]))\n logger.info(\"token_to_word_map: %s\" % \" \".join(\n [\"%d:%d\" % (x, y) for (x, y) in six.iteritems(token_to_word_map)]))\n logger.info(\"token_is_max_context: %s\" % \" \".join([\n \"%d:%s\" % (x, y) for (x, y) in six.iteritems(token_is_max_context)\n ]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\n \"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n if return_answers:\n answer_text = \" \".join(out_tokens[start_position:(end_position + 1)])\n logger.info(\"start_position: %d\" % (start_position))\n logger.info(\"end_position: %d\" % (end_position))\n logger.info(\n \"answer: %s\" % (tokenization.printable_text(answer_text)))\n\n # Append feature\n features.append(\n ContextFeatures(\n unique_id=unique_id,\n example_index=example_index,\n doc_span_index=doc_span_index,\n tokens=out_tokens,\n token_to_word_map=token_to_word_map,\n token_is_max_context=token_is_max_context,\n input_ids=input_ids,\n input_mask=input_mask,\n start_position=start_position,\n end_position=end_position))\n question_features.append(\n QuestionFeatures(\n unique_id=unique_id,\n example_index=example_index,\n tokens_=out_tokens_,\n input_ids=input_ids_,\n input_mask=input_mask_))\n\n # Check validity of answer\n if return_answers:\n if start_position <= NO_ANS:\n assert start_position == NO_ANS and end_position == NO_ANS, (start_position, end_position)\n else:\n assert out_tokens[start_position:end_position+1] == \\\n all_doc_tokens[tok_start_position:tok_end_position+1]\n orig_text, start_pos, end_pos = get_final_text_(\n example, features[-1], start_position, end_position, True, False)\n phrase = orig_text[start_pos:end_pos]\n try:\n assert phrase == example.orig_answer_text\n except Exception as e:\n # print('diff ans [%s]/[%s]'%(phrase, example.orig_answer_text))\n pass\n unique_id += 1\n\n return features, question_features","def test_replace_question_mark_with_nan(raw_data: pd.DataFrame):\n\n raw_data_nan = replace_question_mark_with_nan(raw_data)\n\n # Check the existence of NaN values\n assert check_null_values(raw_data_nan)\n\n # Check that there are no more question marks\n assert not check_question_mark_as_null(raw_data_nan)","def reindex(self):\n self._index = {w: i for i, w in enumerate(self._words)}\n self.n, self.d = self._vecs.shape\n assert self.n == len(self._words) == len(self._index)\n self._neighbors = None","def ques_lstm(self, word_embeddings):\n nlayer = self.config.nrnn_layer\n lstm_cell = tf.contrib.rnn.BasicLSTMCell(\n num_units=self.config.rnn_size, state_is_tuple=True)\n lstm_cell = tf.contrib.rnn.MultiRNNCell(\n [lstm_cell] * nlayer, state_is_tuple=True)\n\n with tf.variable_scope(\n 'ques_lstm', initializer=self.initializer) as scope:\n # Run the batch of sequence embeddings through the LSTM.\n assert (self.feed_per_seq_length != None)\n _, lstm_state = tf.nn.dynamic_rnn(\n cell=lstm_cell,\n inputs=word_embeddings,\n sequence_length=self.feed_per_seq_length,\n dtype=tf.float32)\n\n # extract c and h, then concat them all\n ques_encoding_lis = []\n for i in range(nlayer):\n ques_encoding_lis = ques_encoding_lis + [\n lstm_state[i].c, lstm_state[i].h\n ]\n ques_encoding = tf.concat(ques_encoding_lis, axis=1)\n\n assert (ques_encoding.shape[1] == self.config.rnnout_dim)\n\n return ques_encoding","def transform_answers(self, stim_dict: dict):\n new_ind = [resp.name for resp in RESPONSES]\n for stim in stim_dict:\n df = stim_dict[stim][\"responses\"]\n df = df.fillna(\"empty\")\n new_df = pd.DataFrame(columns=df.columns, index=new_ind)\n for col in new_df.columns:\n for row in new_df.index:\n new_df[col][row] = 0\n for subj in df.index:\n if row in df[col][subj]:\n new_df[col][row] += 1\n new_df.columns = [\"Feelings\", \"Familiarity\"]\n stim_dict[stim][\"transformed_responses\"] = new_df\n self.stim_dict = stim_dict","def simplify_ques(question, debug=False):\n if not isinstance(question, str):\n raise TypeError('Please provide a string for a question.')\n\n if debug is True:\n load_json()\n\n neg = False\n qwords = question.lower().split()\n for i in qwords:\n if i in NEGATIVE_WORDS:\n neg = True\n\n cleanwords = [word for word in qwords if word.lower() not in REMOVE_WORDS]\n temp = ' '.join(cleanwords)\n\n clean_question = \"\"\n for letter in temp:\n if letter != \"?\" or letter != \"\\\"\" or letter != \"\\'\":\n clean_question = clean_question + letter\n\n return clean_question.lower(), neg","def reindex_metadata_tags(self):\r\n previous_position_values = None\r\n\r\n for position_index, position in enumerate(self.required_fields_index):\r\n if position_index > 0:\r\n position.reindex(previous_position_values)\r\n\r\n previous_position_values = position.current_values()","def _postprocess_embeddings(self, prediction_dict, y_indices, x_indices):\n embedding_predictions = prediction_dict[TRACK_REID][-1]\n embeddings = predicted_embeddings_at_object_centers(\n embedding_predictions, y_indices, x_indices)\n embeddings, _ = tf.linalg.normalize(embeddings, axis=-1)\n\n return embeddings","def load_as_raw(self):\n\n # Q & A\n questions, answers = self.get_questions_answers()\n\n # Get vocabs\n\n # Step 4: cleaning the questions\n pprint('---- Step 4 cleaning questions ----')\n\n clean_questions = []\n for question in questions:\n clean_questions.append(clean_text(question))\n\n pprint(clean_questions, stream=Head(5))\n print('\\n\\n')\n \"\"\"\n Step 5: Clean the answers\n \"\"\"\n\n pprint('---- Step 5 cleaning answers ----')\n clean_answers = []\n for answer in answers:\n clean_answers.append(clean_text(answer))\n\n pprint(clean_answers, stream=Head(5))\n print('\\n\\n')\n \"\"\"\n Step 6: Creating a dictionary that maps each word to its number of occurences\n \"\"\"\n\n word2count = {}\n pprint('------ Step 6: counting words in questions ----')\n\n word2count = convert_word_to_count(word2count, clean_questions)\n\n pprint(word2count, stream=Head(5))\n print('\\n\\n')\n \"\"\"\n Step 7:\n For example, for a question: can we make this quick roxanne korrine and andrew barrett are having an incredibly horrendous public break up on the quad again\n It counts each word occurence such as \"can\" and accumulates the count into word2count dict\n \"\"\"\n pprint('------ Step 6: counting words in answers ----')\n\n word2count = convert_word_to_count(word2count, clean_answers)\n\n pprint(word2count, stream=Head(5))\n print('\\n\\n')\n\n keys = ['<unk>', '<s>', '</s>']\n\n \"\"\"\n Step 8: Creating word 2 int(count) by filtering words that are greater than the threshold\n \"\"\"\n\n pprint(\n '------ Step 8: questions_vocabs filtered by threshold (>) ----')\n threshold_questions = 20\n questions_vocabs = [] + keys\n for word, count in word2count.items():\n if count >= threshold_questions:\n if not word in questions_vocabs:\n questions_vocabs.append(word)\n\n pprint(questions_vocabs, stream=Head(5))\n print('\\n\\n')\n \"\"\"\n Step 9: Same as step 8 but for answers\n \"\"\"\n pprint(\n '------ Step 9: answers_vocabs filtered by threshold (>) ----')\n threshold_answers = 20\n answers_vocabs = [] + keys\n for word, count in word2count.items():\n if count >= threshold_answers:\n if not word in answers_vocabs:\n answers_vocabs.append(word)\n\n pprint(answers_vocabs, stream=Head(5))\n\n return questions, answers, questions_vocabs, answers_vocabs","def word_analogy(self):\n data = open(\"data/word_analogy_subset.en.ar.txt\").read().split('\\n')\n data = [x for x in data if len(x.split()) == 4]\n cnt = 0\n keys = list(self.embeddings_index.keys())\n vectors = np.array(list(self.embeddings_index.values()))\n norms = np.linalg.norm(vectors, axis=1)\n for i in data:\n i = self.preprocessor(i).split()\n try:\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\n except:\n continue\n unit = v / np.linalg.norm(v)\n dists = np.dot(vectors, unit) / norms\n best = np.argpartition(-dists, 10)[:10 + 1]\n best = best.take(np.argsort((-dists).take(best)))\n result = [(keys[sim], float(dists[sim]))\n for sim in best]\n sbv = result[:10]\n for j in sbv:\n if j[0] == i[3]:\n cnt += 1\n return cnt/ len(data)","def replace_waveforms(self, waveform_dict):\n for waveform, value in waveform_dict.items():\n\n if waveform not in self.unresolved_placeholders:\n self.hd.log.error(f\"Placeholder {waveform} not found in sequence.\")\n\n waveform_wrapped = f\"{self.marker_string}{waveform}{self.marker_string}\"\n waveform_vector = 'vect(' + ','.join([str(x) for x in value]) + ')'\n self.sequence = self.sequence.replace(f\"{waveform_wrapped}\", str(waveform_vector))\n self.unresolved_placeholders.discard(waveform)","def replace_errors(suggestion_num, sequence_switched, end_matches, offset_list):\n if len(end_matches) != 0:\n # Initialize Variables\n new_list = initialize_suggestion_list(suggestion_num)\n tokenizer, model = edf.initialize_tokenizer_variables()\n\n # Swapping masks with corrections section\n if len(end_matches) > 1:\n k = 0\n j = 0\n current = 0\n keep_going = True\n\n while keep_going:\n # Determine what section to locate mask token in\n mask_str = section_decision(j, sequence_switched, offset_list, end_matches)\n\n new_list = replace_tokens(mask_str, sequence_switched, new_list, j, tokenizer, model, suggestion_num)\n\n # If end of sentence, return j to 0, else continue iterations\n if j == (len(end_matches) - 1):\n # Update variables\n j = 0\n current += 1\n keep_going = False\n\n else:\n j += 1\n\n k += 1\n\n else:\n new_list = replace_tokens(sequence_switched, sequence_switched, new_list, 0, tokenizer, model,\n suggestion_num)\n\n return new_list\n\n else:\n return []","def forward(self, aligned_feat):\n n, t, c, h, w = aligned_feat.size()\n # temporal attention\n embedding_ref = self.temporal_attn1(\n aligned_feat[:, self.center_frame_idx, :, :, :].clone())\n emb = self.temporal_attn2(aligned_feat.view(-1, c, h, w))\n emb = emb.view(n, t, -1, h, w) # (n, t, c, h, w)\n\n corr_l = [] # correlation list\n for i in range(t):\n emb_neighbor = emb[:, i, :, :, :]\n corr = torch.sum(emb_neighbor * embedding_ref, 1) # (n, h, w)\n corr_l.append(corr.unsqueeze(1)) # (n, 1, h, w)\n corr_prob = torch.sigmoid(torch.cat(corr_l, dim=1)) # (n, t, h, w)\n corr_prob = corr_prob.unsqueeze(2).expand(n, t, c, h, w)\n corr_prob = corr_prob.contiguous().view(n, -1, h, w) # (n, t*c, h, w)\n aligned_feat = aligned_feat.view(n, -1, h, w) * corr_prob\n\n # fusion\n feat = self.feat_fusion(aligned_feat)\n\n # spatial attention\n attn = self.spatial_attn1(aligned_feat)\n attn_max = self.max_pool(attn)\n attn_avg = self.avg_pool(attn)\n attn = self.spatial_attn2(torch.cat([attn_max, attn_avg], dim=1))\n # pyramid levels\n attn_level = self.spatial_attn_l1(attn)\n attn_max = self.max_pool(attn_level)\n attn_avg = self.avg_pool(attn_level)\n attn_level = self.spatial_attn_l2(\n torch.cat([attn_max, attn_avg], dim=1))\n attn_level = self.spatial_attn_l3(attn_level)\n attn_level = self.upsample(attn_level)\n\n attn = self.spatial_attn3(attn) + attn_level\n attn = self.spatial_attn4(attn)\n attn = self.upsample(attn)\n attn = self.spatial_attn5(attn)\n attn_add = self.spatial_attn_add2(self.spatial_attn_add1(attn))\n attn = torch.sigmoid(attn)\n\n # after initialization, * 2 makes (attn * 2) to be close to 1.\n feat = feat * attn * 2 + attn_add\n return feat","def batchify_QA(batch):\r\n\r\n if type(batch[0][1]) != torch.LongTensor:\r\n no_elmo, use_char = (True, False) if batch[0][1] == -2 else (False, False)\r\n else:\r\n no_elmo, use_char = True, True\r\n\r\n docs = [ex[0] for ex in batch]\r\n docs_char = [ex[1] for ex in batch]\r\n ques = [ex[2] for ex in batch]\r\n questions_char = [ex[3] for ex in batch]\r\n answers = [ex[4] for ex in batch]\r\n\r\n # Batch documents\r\n max_doc_length = max([d.size(0) for d in docs])\r\n x1_len = torch.LongTensor(len(docs)).zero_()\r\n x1 = torch.LongTensor(len(docs),\r\n max_doc_length).zero_() if no_elmo else torch.LongTensor(len(docs),\r\n max_doc_length,\r\n 50).zero_()\r\n x1_char = torch.LongTensor(len(docs),\r\n max_doc_length,\r\n docs_char[0].size(1)).zero_() if (no_elmo and use_char) else None\r\n for i, d in enumerate(docs):\r\n x1_len[i] = d.size(0)\r\n x1[i, :d.size(0)].copy_(d)\r\n if not no_elmo:\r\n x1_char[i, :d.size(0), :].copy_(docs_char[i])\r\n\r\n # Batch questions\r\n max_ques_length = max([q.size(0) for q in ques])\r\n x2_len = torch.LongTensor(len(ques)).zero_()\r\n x2 = torch.LongTensor(len(ques), max_ques_length).zero_() if no_elmo else torch.LongTensor(len(ques),\r\n max_ques_length,\r\n 50).zero_()\r\n x2_char = torch.LongTensor(len(ques),\r\n max_ques_length,\r\n questions_char[0].size(1)).zero_() if (no_elmo and use_char) else None\r\n for i, q in enumerate(ques):\r\n x2_len[i] = q.size(0)\r\n x2[i, :q.size(0)].copy_(q)\r\n if not no_elmo:\r\n x2_char[i, :q.size(0), :].copy_(questions_char[i])\r\n\r\n # Batch answers\r\n max_ans_length = max([a.size(0) for a in answers])\r\n ans_len = torch.LongTensor(len(answers)).zero_()\r\n ans = torch.LongTensor(len(answers), max_ans_length).zero_()\r\n for i, a in enumerate(answers):\r\n ans_len[i] = a.size(0)\r\n ans[i, :a.size(0)].copy_(a)\r\n\r\n ids = [ex[5] for ex in batch]\r\n contexts = [ex[6] for ex in batch]\r\n # FIXME: multiple answers are possible, fix vectorize also.\r\n targets = [ex[8][0] for ex in batch]\r\n src_vocabs = [ex[9] for ex in batch]\r\n source_maps = []\r\n alignments = []\r\n\r\n # Prepare source vocabs, alignment [required for Copy Attention]\r\n for eid, context, target, (token2idx, idx2token) in \\\r\n zip(ids, contexts, targets, src_vocabs):\r\n # Mapping source tokens to indices in the dynamic dict.\r\n src_map = torch.LongTensor([token2idx[w] for w in context])\r\n source_maps.append(src_map)\r\n\r\n # TODO: does skipping the first and last token in answer valid?\r\n mask = torch.LongTensor([token2idx[w] if w in token2idx\r\n else UNK for w in target])\r\n alignments.append(mask)\r\n\r\n return {'doc_rep': x1,\r\n 'doc_char_rep': x1_char,\r\n 'doc_len': x1_len,\r\n 'que_rep': x2,\r\n 'que_char_rep': x2_char,\r\n 'que_len': x2_len,\r\n 'ans_rep': ans,\r\n 'ans_len': ans_len,\r\n 'ids': ids,\r\n 'documents': contexts,\r\n 'questions': [ex[7] for ex in batch],\r\n 'answers': targets,\r\n 'source_vocabs': src_vocabs,\r\n 'src_map': source_maps,\r\n 'alignment': alignments}","def intent_of_text_LnDOR(ChapterTextS, TargetQuestionsD, TestS, StopWords):\n \n # Chapter Text - stokenize\n StokensCT = stokenize(ChapterTextS, StopWords) \n\n # Test question - stokenize\n StokensTest = stokenize(TestS, StopWords)\n\n # Knowledge Base Dict - stokenize\n KBD_structure = stokenizeKBD(TargetQuestionsD, StopWords)\n\n # List (because list is mutable, set is not) of all stokens in document\n StokensDoc = StokensCT[:] # from chapter text\n StokensDoc.extend(StokensTest[:]) # += Test string\n\n # extend list of stokens in Doc\n for i in TargetQuestionsD:\n StokensDoc.extend(TargetQuestionsD[i][\"mq stokens\"][:]) # += KB target [matched Q]s\n StokensDoc.extend(TargetQuestionsD[i][\"ans stokens\"][:]) # += KB answers\n \n StokensTestV = set(StokensTest)\n StokensDocV = set(StokensDoc)\n StokensAntiTgtV = StokensDocV\n \n # Complement of all targets\n for i in TargetQuestionsD:\n StokensAntiTgtV = StokensAntiTgtV.difference(set(TargetQuestionsD[i][\"mq stokens\"]))\n \n # calculate confusion matrix and DOR etc.\n LnDORD = {}\n # Anti Target\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensAntiTgtV, StokensTestV) \n LnDOR = lndor(TP, FP, FN, TN) \n someAngle = angleDOR(TP, FP, FN, TN) \n \n LnDORD[\"AntiTgt\"] = {'lndor': LnDOR, 'theta': someAngle}\n\n # total occurences\n total_occ = 0\n for i in TargetQuestionsD:\n total_occ += TargetQuestionsD[i]['count']\n\n for i in TargetQuestionsD:\n StokensTgtV = set(TargetQuestionsD[i][\"mq stokens\"][:])\n\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensTgtV, StokensTestV) \n priorOR = TargetQuestionsD[i]['count'] / total_occ\n\n LnDOR = lndor(TP, FP, FN, TN) \n someAngle = angleDOR(TP, FP, FN, TN, priorOR) \n \n LnDORD[i] = {'lndor': LnDOR, 'theta': someAngle}\n # LnDORD = {i: {'lndor': , 'theta': }}, KB indices + \"AntiTgt\"\n\n return LnDORD","def qualify_words():\n config = get_config()\n\n all_feature_matrices = []\n all_opinion_matrices = []\n\n # first 5 parts are labeled, thus are useful\n all_feature_label_vectors = []\n all_opinion_label_vectors = []\n\n for fname in config.file_names:\n feature_X, feature_dims = load_feature_matrices(fname)\n opinion_X, opinion_dims = load_opinion_matrices(fname)\n feature_y = load_feature_labels(fname)\n opinion_y = load_opinion_labels(fname)\n\n # append to all collector\n all_feature_matrices.append(feature_X)\n all_feature_label_vectors.append(feature_y)\n all_opinion_matrices.append(opinion_X)\n all_opinion_label_vectors.append(opinion_y)\n # use first 5 for training\n # stack first 5\n feature_training_X = []\n feature_training_y = []\n opinion_training_X = []\n opinion_training_y = []\n for i in range(5):\n feature_training_X.append(all_feature_matrices[i])\n feature_training_y.append(all_feature_label_vectors[i])\n opinion_training_X.append(all_opinion_matrices[i])\n opinion_training_y.append(all_opinion_label_vectors[i])\n\n feature_training_X = np.hstack(feature_training_X)\n feature_training_y = np.hstack(feature_training_y)\n opinion_training_X = np.hstack(opinion_training_X)\n opinion_training_y = np.hstack(opinion_training_y)\n\n # using combination of rule and ranking score as features\n feature_model = MultinomialNB()\n opinion_model = MultinomialNB()\n\n # training\n feature_model.fit(np.transpose(feature_training_X), feature_training_y.ravel())\n opinion_model.fit(np.transpose(opinion_training_X), opinion_training_y.ravel())\n\n # predicting on candidate aspects and opinions, extracted from amazon reviews\n for i in range(5, len(config.file_names)):\n fname = config.file_names[i]\n feature_pred = feature_model.predict_proba(\n np.transpose(all_feature_matrices[i]))[:,1]\n opinion_pred = opinion_model.predict_proba(\n np.transpose(all_opinion_matrices[i]))[:,1]\n # pickle the prediction results\n with open('../results/' + fname + '_feature_pred_score.pickle', 'wb') as f:\n pickle.dump(feature_pred, f)\n with open('../results/' + fname + '_opinion_pred_score.pickle', 'wb') as f:\n pickle.dump(opinion_pred, f)","def encode_samples(tokenized_samples, word_to_idx):\n features = []\n for sample in tokenized_samples:\n feature = []\n for token in sample:\n if token in word_to_idx:\n feature.append(word_to_idx[token])\n else:\n feature.append(0)\n features.append(feature)\n return features","def compute_query_repr(annots_df, qaid, invindex, aggregate=False, alpha=3, thresh=0):\n if utool.VERBOSE:\n print('[smk_index] Query Repr qaid=%r' % (qaid,))\n wx2_idf = invindex.wx2_idf\n words = invindex.words\n wordflann = invindex.wordflann\n if WITH_PANDAS:\n qfx2_vec = annots_df['vecs'][qaid]\n else:\n qfx2_vec = pdh.ensure_values(annots_df['vecs'][qaid])\n # Assign query to words\n wx2_qfxs1, wx2_weights, qfx2_wxs = assign_to_words_(\n wordflann, words, qfx2_vec, idx_name='fx', dense=False) # 71.9 %\n # Hack to make implementing asmk easier, very redundant\n #qfx2_aid = pdh.IntSeries([qaid] * len(qfx2_wx), index=qfx2_wx.index, name='qfx2_aid')\n #qfx2_aid = pdh.IntSeries([qaid] * len(qfx2_wx), name='qfx2_aid')\n qfx2_aid = np.array([qaid] * len(qfx2_wxs), dtype=INTEGER_TYPE)\n if WITH_PANDAS:\n qfx2_qfx = qfx2_vec.index\n else:\n qfx2_qfx = np.arange(len(qfx2_vec))\n # Compute query residuals\n wx2_qrvecs, wx2_qaids, wx2_qfxs = compute_residuals_(\n words, wx2_qfxs1, qfx2_vec, qfx2_aid, qfx2_qfx, aggregate) # 24.8\n # Compute query gamma\n if utool.VERBOSE:\n print('[smk_index] Query Gamma alpha=%r, thresh=%r' % (alpha, thresh))\n wx_sublist = pdh.ensure_index(wx2_qrvecs).astype(np.int32)\n idf_list = pdh.ensure_values_subset(wx2_idf, wx_sublist)\n rvecs_list = pdh.ensure_values_subset(wx2_qrvecs, wx_sublist)\n query_gamma = smk_core.gamma_summation2(rvecs_list, idf_list, alpha, thresh)\n assert query_gamma > 0, 'query gamma is not positive!'\n return wx2_qrvecs, wx2_qaids, wx2_qfxs, query_gamma","def replace_token_with_index(self, tokenized_tweet, max_length_dictionary):\n\n # should be replacing each token in a list of tokens by their corresponding index\n # Source: https://github.com/stanfordnlp/GloVe\n # Source: https://towardsdatascience.com/word-embeddings-for-sentiment-analysis-65f42ea5d26e\n\n if self.mode == \"zip\":\n for idx, word in enumerate(tokenized_tweet):\n if word not in self.corpus:\n tokenized_tweet[idx] = \"<unknown>\"\n else:\n for idx, word in enumerate(tokenized_tweet):\n if word not in self.corpus:\n tokenized_tweet[idx] = \"<unk>\"\n return [self.corpus.index(x) for x in tokenized_tweet]","def match(self, passage_encodes, question_encodes, p_length, q_length):\n with tf.variable_scope('bidaf'):\n sim_matrix = tf.matmul(\n passage_encodes, question_encodes, transpose_b=True)\n context2question_attn = tf.matmul(\n tf.nn.softmax(sim_matrix, -1), question_encodes)\n b = tf.nn.softmax(tf.expand_dims(\n tf.reduce_max(sim_matrix, 2), 1), -1)\n question2context_attn = tf.tile(tf.matmul(b, passage_encodes),\n [1, tf.shape(passage_encodes)[1], 1])\n concat_outputs = tf.concat([passage_encodes, context2question_attn,\n passage_encodes * context2question_attn,\n passage_encodes * question2context_attn], -1)\n return concat_outputs, None","def fix_annotmatch_pzmaster1():\n import wbia\n\n ibs = wbia.opendb('PZ_Master1')\n infr = wbia.AnnotInference(ibs=ibs, aids=ibs.get_valid_aids(), verbose=5)\n infr.initialize_graph()\n annots = ibs.annots()\n aid_to_nid = ut.dzip(annots.aids, annots.nids)\n\n if False:\n infr.reset_feedback()\n infr.ensure_mst()\n infr.apply_feedback_edges()\n infr.relabel_using_reviews()\n infr.start_qt_interface()\n\n # Get annotmatch rowids that agree with current labeling\n if False:\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\n import pandas as pd\n\n flags1 = pd.isnull(annotmatch['annotmatch_evidence_decision'])\n flags2 = annotmatch['annotmatch_tag_text'] == ''\n bad_part = annotmatch[flags1 & flags2]\n rowids = bad_part.index.tolist()\n ibs.delete_annotmatch(rowids)\n\n if False:\n # Delete bidirectional annotmatches\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\n df = annotmatch.set_index(['annot_rowid1', 'annot_rowid2'])\n\n # Find entires that have both directions\n pairs1 = annotmatch[['annot_rowid1', 'annot_rowid2']].values\n f_edges = {tuple(p) for p in pairs1}\n b_edges = {tuple(p[::-1]) for p in pairs1}\n isect_edges = {tuple(sorted(p)) for p in b_edges.intersection(f_edges)}\n isect_edges1 = list(isect_edges)\n isect_edges2 = [p[::-1] for p in isect_edges]\n\n # cols = ['annotmatch_evidence_decision', 'annotmatch_tag_text']\n import pandas as pd\n\n custom_ = {\n (559, 4909): (False, ['photobomb']),\n (7918, 8041): (False, ['photobomb']),\n (6634, 6754): (False, ['photobomb']),\n (3707, 3727): (False, ['photobomb']),\n (86, 103): (False, ['photobomb']),\n }\n extra_ = {}\n\n fixme_edges = []\n\n d1 = df.loc[isect_edges1].reset_index(drop=False)\n d2 = df.loc[isect_edges2].reset_index(drop=False)\n flags = d1['annotmatch_evidence_decision'] != d2['annotmatch_evidence_decision']\n from wbia.tag_funcs import _parse_tags\n\n for f, r1, r2 in zip(flags, d1.iterrows(), d2.iterrows()):\n v1, v2 = r1[1], r2[1]\n aid1 = v1['annot_rowid1']\n aid2 = v1['annot_rowid2']\n truth_real = (\n ibs.const.EVIDENCE_DECISION.POSITIVE\n if aid_to_nid[aid1] == aid_to_nid[aid2]\n else ibs.const.EVIDENCE_DECISION.NEGATIVE\n )\n truth1 = v1['annotmatch_evidence_decision']\n truth2 = v2['annotmatch_evidence_decision']\n t1 = _parse_tags(v1['annotmatch_tag_text'])\n t2 = _parse_tags(v2['annotmatch_tag_text'])\n newtag = ut.union_ordered(t1, t2)\n if (aid1, aid2) in custom_:\n continue\n fixme_flag = False\n if not pd.isnull(truth1):\n if truth_real != truth1:\n fixme_flag = True\n if not pd.isnull(truth2):\n if truth_real != truth2:\n fixme_flag = True\n if fixme_flag:\n logger.info('newtag = {!r}'.format(newtag))\n logger.info('truth_real = {!r}'.format(truth_real))\n logger.info('truth1 = {!r}'.format(truth1))\n logger.info('truth2 = {!r}'.format(truth2))\n logger.info('aid1 = {!r}'.format(aid1))\n logger.info('aid2 = {!r}'.format(aid2))\n fixme_edges.append((aid1, aid2))\n else:\n extra_[(aid1, aid2)] = (truth_real, newtag)\n\n extra_.update(custom_)\n new_pairs = extra_.keys()\n new_truths = ut.take_column(ut.dict_take(extra_, new_pairs), 0)\n new_tags = ut.take_column(ut.dict_take(extra_, new_pairs), 1)\n new_tag_texts = [';'.join(t) for t in new_tags]\n aids1, aids2 = ut.listT(new_pairs)\n\n # Delete the old\n ibs.delete_annotmatch(\n d1['annotmatch_rowid'].values.tolist()\n + d2['annotmatch_rowid'].values.tolist()\n )\n\n # Add the new\n ams = ibs.add_annotmatch_undirected(aids1, aids2)\n ibs.set_annotmatch_evidence_decision(ams, new_truths)\n ibs.set_annotmatch_tag_text(ams, new_tag_texts)\n\n if False:\n import wbia.guitool as gt\n\n gt.ensure_qapp()\n ut.qtensure()\n from wbia.gui import inspect_gui\n\n inspect_gui.show_vsone_tuner(ibs, aid1, aid2)\n\n # pairs2 = pairs1.T[::-1].T\n # idx1, idx2 = ut.isect_indices(list(map(tuple, pairs1)),\n # list(map(tuple, pairs2)))\n # r_edges = list(set(map(tuple, map(sorted, pairs1[idx1]))))\n # unique_pairs = list(set(map(tuple, map(sorted, pairs1[idx1]))))\n # df = annotmatch.set_index(['annot_rowid1', 'annot_rowid2'])\n\n x = ut.ddict(list)\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\n import ubelt as ub\n\n _iter = annotmatch.iterrows()\n prog = ub.ProgIter(_iter, length=len(annotmatch))\n for k, m in prog:\n aid1 = m['annot_rowid1']\n aid2 = m['annot_rowid2']\n if m['annotmatch_evidence_decision'] == ibs.const.EVIDENCE_DECISION.POSITIVE:\n if aid_to_nid[aid1] == aid_to_nid[aid2]:\n x['agree1'].append(k)\n else:\n x['disagree1'].append(k)\n elif m['annotmatch_evidence_decision'] == ibs.const.EVIDENCE_DECISION.NEGATIVE:\n if aid_to_nid[aid1] == aid_to_nid[aid2]:\n x['disagree2'].append(k)\n else:\n x['agree2'].append(k)\n\n ub.map_vals(len, x)\n ut.dict_hist(annotmatch.loc[x['disagree1']]['annotmatch_tag_text'])\n\n disagree1 = annotmatch.loc[x['disagree1']]\n pb_disagree1 = disagree1[disagree1['annotmatch_tag_text'] == 'photobomb']\n aids1 = pb_disagree1['annot_rowid1'].values.tolist()\n aids2 = pb_disagree1['annot_rowid2'].values.tolist()\n aid_pairs = list(zip(aids1, aids2))\n infr = wbia.AnnotInference.from_pairs(aid_pairs, ibs=ibs, verbose=5)\n if False:\n feedback = infr.read_wbia_annotmatch_feedback(edges=infr.edges())\n infr.external_feedback = feedback\n infr.apply_feedback_edges()\n infr.start_qt_interface(loop=False)\n\n # Delete these values\n if False:\n nonpb_disagree1 = disagree1[disagree1['annotmatch_tag_text'] != 'photobomb']\n disagree2 = annotmatch.loc[x['disagree2']]\n ibs.delete_annotmatch(nonpb_disagree1['annotmatch_rowid'])\n ibs.delete_annotmatch(disagree2['annotmatch_rowid'])\n\n # ut.dict_hist(disagree1['annotmatch_tag_text'])\n import networkx as nx\n\n graph = nx.Graph()\n graph.add_edges_from(zip(pb_disagree1['annot_rowid1'], pb_disagree1['annot_rowid2']))\n list(nx.connected_components(graph))\n\n set(annotmatch.loc[x['disagree2']]['annotmatch_tag_text'])\n\n # aid1, aid2 = 2585, 1875\n # # pd.unique(annotmatch['annotmatch_evidence_decision'])\n # from wbia.gui import inspect_gui\n # inspect_gui.show_vsone_tuner(ibs, aid1, aid2)\n # from vtool import inspect_matches\n\n # aid1, aid2 = 2108, 2040\n\n # pd.unique(annotmatch['annotmatch_tag_text'])\n\n # infr.reset_feedback()\n # infr.relabel_using_reviews()","def compute(db, detected_chords_by_song):\n detected = {}\n ground = {}\n detected_chords = []\n ground_chords = []\n\n for s in detected_chords_by_song:\n detected[s['title']] = s['detected_chords']\n\n for s in db:\n ground[s['title']] = s['chord_vector']\n\n for k, v in ground.items():\n if k in detected:\n if len(v) == len(detected[k]):\n detected_chords.extend(detected[k])\n ground_chords.extend(v)\n\n # ignore chors represented with dash given that are not suppoted by the algorithm\n ground = []\n detected = []\n i = 0\n while i < len(ground_chords): \n if '-' != ground_chords[i]:\n ground.append(ground_chords[i])\n detected.append(detected_chords[i])\n i += 1\n\n fig, ax = plt.subplots()\n tick_marks = np.arange(len(EXISTING_NOTES))\n plt.xticks(tick_marks, EXISTING_NOTES, rotation=45)\n plt.yticks(tick_marks, EXISTING_NOTES)\n\n matrix = confusion_matrix(ground, detected, labels=EXISTING_NOTES)\n thresh = 500\n\n for i, j in itertools.product(range(matrix.shape[0]), range(matrix.shape[1])):\n plt.text(j, i, matrix[i, j],\n horizontalalignment=\"center\",\n size=5,\n color=\"black\" if matrix[i, j] > thresh else \"white\")\n plt.ylabel('True chords')\n plt.xlabel('Predicted chords')\n plt.tight_layout()\n\n fname = (\n os.path.join(\n settings.IMG_DIR,\n 'initial_diagnose', 'total_accuracy_confusion_matrix.png'))\n\n plt.imshow(matrix, interpolation='nearest')\n plt.colorbar()\n plt.savefig(fname)","def build_dataset(token_seq, token_seq_index, term_to_index, char_to_index, max_token_length=15, leading_context_size=10, trailing_context_size=10, leading_separator='{', trailing_separator='}', n_examples_per_context=10, n_errors_per_token=[1], n_errors_per_context=[0], dictionary=enchant.Dict('en_US'), seed=17):\n if isinstance(seed, RandomState):\n rng = seed\n else:\n rng = RandomState(seed=seed)\n\n n_contexts = sum([len(token_seq_index[t]) for t in token_seq_index.keys() if len(t) <= max_token_length])\n n_examples = n_examples_per_context * n_contexts\n max_inserts_per_token = max(n_errors_per_token)\n max_inserts_per_context = 2*max(n_errors_per_context)\n max_chars_in_window = leading_context_size + max_token_length + trailing_context_size + len(leading_separator) + len(trailing_separator) + max_inserts_per_token + max_inserts_per_context\n\n error_examples = np.zeros((n_examples, max_chars_in_window), dtype=np.int32)\n error_examples.fill(char_to_index[' '])\n\n leading_contexts = np.zeros((n_examples, leading_context_size + max_inserts_per_context))\n leading_contexts.fill(char_to_index[' '])\n spelling_errors = np.zeros((n_examples, max_token_length + max_inserts_per_token))\n spelling_errors.fill(char_to_index[' '])\n trailing_contexts = np.zeros((n_examples, trailing_context_size + max_inserts_per_context))\n trailing_contexts.fill(char_to_index[' '])\n\n correct_tokens = []\n corrupt_tokens = []\n corrections = np.zeros(n_examples, dtype=np.int32)\n error_types = []\n context_ids = []\n example_ids = []\n term_lens = []\n edit_distance_to_nearest_term = []\n nearest_term = []\n\n print('starting to construct {n_examples} examples'.format(\n n_examples=n_examples))\n\n pbar = progressbar.ProgressBar(term_width=40,\n widgets=[' ', progressbar.Percentage(),\n ' ', progressbar.ETA()],\n maxval=n_examples).start()\n n = 0\n\n index_to_char = dict((i,c) for c,i in char_to_index.iteritems())\n if 63 not in index_to_char.keys():\n # A workaround for now. Delete ASAP.\n index_to_char[63] = '^'\n\n def add_chars_to_array(n, array, chars, default_char=' '):\n for k, ch in enumerate(chars):\n try:\n array[n, k] = char_to_index[ch]\n except KeyError, e:\n array[n, k] = char_to_index[default_char]\n\n for token in token_seq_index.keys():\n if len(token) > max_token_length:\n continue\n\n term_len = len(token)\n distances = min_dictionary_edit_distance([token], dictionary)\n distance = distances[token]['distance']\n term = distances[token]['accepted']\n\n for i in token_seq_index[token]:\n for j in six.moves.range(n_examples_per_context):\n pbar.update(n+1)\n corruptor = rng.choice([insert_characters, delete_characters,\n replace_characters, transpose_characters])\n n_token_errors = rng.choice(n_errors_per_token)\n corrupt_token = corruptor(token, index_to_char, n=n_token_errors, seed=rng)\n\n n_context_errors = rng.choice(n_errors_per_context)\n leading = leading_context(token_seq, i, leading_context_size)\n leading = corruptor(leading, index_to_char, n=n_context_errors, seed=rng)\n trailing = trailing_context(token_seq, i, trailing_context_size)\n trailing = corruptor(trailing, index_to_char, n=n_context_errors, seed=rng)\n\n window = ''.join([leading, leading_separator,\n corrupt_token, trailing_separator, trailing])\n\n add_chars_to_array(n, error_examples, window)\n add_chars_to_array(n, leading_contexts, leading)\n add_chars_to_array(n, spelling_errors, corrupt_token)\n add_chars_to_array(n, trailing_contexts, trailing)\n\n correct_tokens.append(token)\n corrections[n] = term_to_index[token]\n corrupt_tokens.append(corrupt_token)\n error_types.append(corruptor.__name__)\n context_ids.append(i)\n example_ids.append(n)\n edit_distance_to_nearest_term.append(distance)\n nearest_term.append(term)\n term_lens.append(term_len)\n\n n += 1\n\n pbar.finish()\n\n df = pd.DataFrame({\n 'correction': corrections,\n 'error_type': error_types,\n 'context_id': context_ids,\n 'example_id': example_ids,\n 'edit_distance_to_nearest_term': edit_distance_to_nearest_term,\n 'nearest': nearest_term,\n 'term_length': term_lens,\n 'correct_token': correct_tokens,\n 'corrupt_token': corrupt_tokens\n })\n\n def add_columns(df, array, colname_prefix):\n colwidth = int(np.log10(array.shape[1]))+1\n colfmt = colname_prefix + '{col:0' + str(colwidth) + 'd}'\n for col in np.arange(array.shape[1]):\n colname = colfmt.format(col=col)\n df[colname] = array[:, col]\n\n add_columns(df, error_examples, 'full_error')\n add_columns(df, leading_contexts, 'leading_context')\n add_columns(df, spelling_errors, 'spelling_error')\n add_columns(df, trailing_contexts, 'trailing_context')\n\n return df","async def respond(self, ctx, index, *, response):\n try:\n config = self.bot.db['questions'][str(ctx.guild.id)][str(ctx.channel.id)]\n except KeyError:\n return\n if not response:\n await hf.safe_send(ctx, \"You need to type something for your response.\")\n return\n if len(response.split()) == 1:\n try:\n msg = await ctx.channel.fetch_message(int(response))\n await ctx.message.add_reaction('⤴')\n ctx.message = msg\n ctx.author = msg.author\n response = msg.content\n except (discord.NotFound, ValueError):\n pass\n if index not in config['questions']:\n await hf.safe_send(ctx, \"Invalid question index. Make sure you're typing this command in the channel \"\n \"the question was originally made in.\")\n return\n\n try:\n log_channel = ctx.guild.get_channel(config['log_channel'])\n except discord.NotFound:\n await hf.safe_send(ctx, \"The original log channel can't be found (type `;q setup`)\")\n return\n try:\n log_message = await log_channel.fetch_message(config['questions'][index]['log_message'])\n except discord.NotFound:\n await hf.safe_send(ctx, \"The original question log message could not be found. Type `;q a <index>` to \"\n \"close the question and clear it.\")\n return\n\n emb: discord.Embed = log_message.embeds[0]\n value_text = f\"\\n[Jump URL]({ctx.message.jump_url})\"\n emb.add_field(name=f\"Response by {ctx.author.name}#{ctx.author.discriminator}\",\n value=value_text.replace('', response[:1024-len(value_text)]))\n await log_message.edit(embed=emb)\n config['questions'][index].setdefault('responses', []).append(ctx.message.jump_url)\n await self._delete_log(ctx)\n await self._post_log(ctx)\n await ctx.message.add_reaction('✅')","def get_embeddings_from_raw_image(recognizer, frame):\n # detect faces, original frame and face boxes\n a, boxes = detector.find_face(frame, recognizer.ort_session, recognizer.input_name)\n\n\n # align facesq\n aligned_faces = []\n boxes[boxes < 0] = 0\n for i in range(boxes.shape[0]):\n box = boxes[i, :]\n f = np.copy(frame)\n y = align_face(recognizer, f, box)\n aligned_faces.append(y)\n\n embs = []\n for i in range(boxes.shape[0]):\n aligned_face = aligned_faces[i]\n embs.append(face_embedding(recognizer, aligned_face))\n\n return embs","def replace_tokens(self, tokens):\n details = []\n idx = 0\n if len(tokens) >= min_token_num:\n for i in range(len(tokens)):\n old_token = tokens[i]\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\n tokens[i] = self.get_insert_token(tokens[i])\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\n idx += len(tokens[i])\n return tokens, details","def forward(self, input_features, review_qid):\n\n # items that are not padded\n src_mask = (input_features[\"qid\"] != 0).unsqueeze(-2)\n\n encoder_output = self.encoder(\n self.src_embed(input_features),\n src_mask,\n )\n review_embedding = self.embedding_by_feature[\"qid\"](review_qid)\n\n output = self.review_generator(encoder_output, src_mask, review_embedding)\n\n return output","def fix_answer_values(answers):\n answers_fixed = answers.copy()\n answers_fixed = np.where(answers_fixed==1, 3, answers_fixed) # move \"no\" away temporarily\n answers_fixed = np.where(answers_fixed==2, 1, answers_fixed) # set \"no opinion\" value to 1\n answers_fixed = np.where(answers_fixed==3, 2, answers_fixed) # set temporary value 3 (meaning \"no\") to 2\n return answers_fixed","def find_corresponding_question(chat, tagged_user, prev_mod_index, index, q, unique_users):\n\n # searches from the previous message sent by the moderator\n for i in range(index, prev_mod_index[1], -1):\n message = chat[i]\n if message['user'] == tagged_user:\n question = is_question(message, unique_users, q)\n if question != None:\n return question\n \n # expanding the search space ft. some additional checks\n for i in range(prev_mod_index[1], prev_mod_index[0], -1):\n message = chat[i]\n \n if message['user'] == tagged_user:\n question = find_question_expanded(message, unique_users, q)\n \n if question != None:\n return question\n\n return None","def tag_conjunction_entities(annotated_pages):\n for page_id in annotated_pages:\n page = Page.objects(id=page_id).first()\n #page = db_conn.pages.find_one({\"_id\":page_id}) # TODO: refactor\n annotation_ids = [p.id for p in page[\"annotations_ids\"]]\n all_annotations = list(Annotation.objects(id__in=annotation_ids))\n # retrieve meta-annotations from that page\n meta_annotations = list(Annotation.objects(id__in=annotation_ids, entity_type=\"meta-annotation\"))\n #all_annotations = list(db_conn.annotations.find({\"_id\":{\"$in\":annotation_ids}})) # TODO: refactor\n #meta_annotations = list(db_conn.annotations.find({\"_id\":{\"$in\":annotation_ids} # TODO: refactor\n # ,\"entity_type\":\"meta-annotation\"}))\n if(len(meta_annotations)>0):\n logger.debug(\"Meta-annotations: %s\"%meta_annotations)\n for meta_annotation in meta_annotations:\n logger.info(\"Processing meta-annotation %s\"%meta_annotation[\"id\"])\n line_span = sorted(list(set([(position[\"page_id\"], position[\"line_n\"]) \n for position in meta_annotation[\"positions\"]])))\n top_entities_ids = [ann.id for ann in meta_annotation[\"top_entities\"]]\n top_entities = list(Annotation.objects(id__in=top_entities_ids))\n #top_entities = [db_conn.annotations.find_one({\"_id\":top_annotation_id}) \n # for top_annotation_id in meta_annotation[\"top_entities\"]]\n tokens = []\n for page_obj, line_n in line_span:\n page = Page.objects(id=page_obj.id).first()\n #page = db_conn.pages.find_one({\"_id\":page_id})\n for line in page[\"lines\"]:\n if line[\"line_number\"]==line_n:\n tokens.append((page_obj,line_n,line[\"tokens\"]))\n try:\n for entity in top_entities:\n assert entity is not None\n true_conjunctions = []\n meta_annotation_start = (top_entities[0][\"positions\"][0][\"page_id\"]\n ,top_entities[0][\"positions\"][0][\"line_n\"]\n ,top_entities[0][\"positions\"][0][\"start\"])\n meta_annotation_end = (top_entities[-1][\"positions\"][-1][\"page_id\"]\n ,top_entities[-1][\"positions\"][-1][\"line_n\"]\n ,top_entities[-1][\"positions\"][-1][\"end\"])\n conjunctions = [(token,page,line) for page,line,toks in tokens for token in toks\n if(token[\"offset_start\"] >= meta_annotation_start[2] and token[\"offset_end\"] <= meta_annotation_end[2])]\n true_conjunctions += [(page,line,token) for token,page,line in conjunctions \n if not is_annotated(page,line,token,all_annotations)]\n if(len(true_conjunctions)>0):\n logger.debug(\"Conjunctions found: %s\"%true_conjunctions)\n conjunction_annotations = []\n all_ann_ids = [annotation[\"ann_id\"] for annotation in all_annotations \n if '+' not in annotation[\"ann_id\"] ]\n identifier_counter = int(sorted(all_ann_ids, key=lambda x: int(x.replace('T','')))[-1].replace(\"T\",\"\"))\n logger.debug(sorted(all_ann_ids, key=lambda x: int(x.replace('T','')))[-1])\n for page_obj, line_n, token in true_conjunctions:\n identifier_counter += 1\n conjunction_annotation = Annotation(entity_type=\"conjunction\"\n , ingestion_timestamp=datetime.utcnow()\n , annotation_ingester_version=__version__\n , pageid=meta_annotation.pageid\n , filename=meta_annotation.filename\n , bid=meta_annotation.bid)\n conjunction_annotation.surface = token[\"surface\"]\n conjunction_annotation.ann_id = \"T%i\"%identifier_counter\n conjunction_annotation.positions.append(PagePosition(page_id = page_obj\n , start = token[\"offset_start\"]\n , end = token[\"offset_end\"]\n , line_n = line_n))\n conjunction_annotation.save()\n conjunction_annotations.append(conjunction_annotation)\n logger.info(\"(Page: %s) %i conjunction annotations were created and stored in MongoDB\"%(page_obj.id\n , len(conjunction_annotations)))\n logger.debug(\"N %i of top entities before adding conjunction entities\"%len(meta_annotation[\"top_entities\"]))\n meta_annotation[\"top_entities\"] += conjunction_annotations\n logger.debug(\"N %i of top entities after adding conjunction entities\"%len(meta_annotation[\"top_entities\"]))\n Annotation.objects(id=meta_annotation.id).update_one(set__top_entities = meta_annotation[\"top_entities\"])\n for conj_annotation in conjunction_annotations:\n for position in conj_annotation[\"positions\"]:\n page = Page.objects(id=position.page_id.id).first()\n page[\"annotations_ids\"].append(conj_annotation)\n page.save()\n except AssertionError as e:\n #raise e\n logger.warning(\"The meta-annotation %s has no top-level entities and generated the following error: %s\"%(meta_annotation[\"_id\"],e))\n except Exception as e:\n raise e","def make_correction_matrix(isotracer, formuladict, na_dict, indist_elems, autodetect, corr_limit):\n lookup_dict = {'O':['O16','O17','O18'], 'S':['S32','S33','S34'], 'Si':['Si28','Si29','Si30']}\n trac_atom = get_isotope_element(isotracer)\n if (isotracer == 'O18' or isotracer == 'S34' or isotracer == 'Si30'):\n \tM = make_expected_na_matrix_heavy(formuladict.get(trac_atom, 0), na_dict[trac_atom])\n else:\n \tM = make_expected_na_matrix(formuladict.get(trac_atom, 0), na_dict[trac_atom])\n M_indist = []\n\n indist_elems_copy = copy(indist_elems)\n na_dict_copy = copy(na_dict)\n for e in indist_elems:\n if e in indist_elems_copy:\n e2 = get_isotope_element(e)\n if e2 in formuladict:\n try:\n if(lookup_dict[e2][1] in indist_elems_copy) and (lookup_dict[e2][2] in indist_elems_copy):\n corr_limit_1 = int(corr_limit[lookup_dict[e2][1]])\n corr_limit_2 = int(corr_limit[lookup_dict[e2][2]])\n M_indist.append(add_indistinguishable_element_for_autodetect_heavy(M, formuladict[e2], na_dict_copy[e2], corr_limit_1, corr_limit_2))\n indist_elems_copy.remove(lookup_dict[e2][1])\n indist_elems_copy.remove(lookup_dict[e2][2])\n\n elif ((lookup_dict[e2][1] in indist_elems_copy) and (lookup_dict[e2][2] not in indist_elems_copy)) or \\\n ((lookup_dict[e2][1] not in indist_elems_copy) and (lookup_dict[e2][2] in indist_elems_copy)):\n pos = lookup_dict[e2].index(str(e))\n list_values = [0]*3\n list_values[0]= na_dict_copy[e2][0]\n list_values[pos]= na_dict_copy[e2][pos]\n na_dict_copy[str(e)]=list_values \n corr_limit_1 = int(corr_limit[e])\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\n\n else:\n corr_limit_1 = int(corr_limit[e])\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\n\n except Exception, exception_str:\n corr_limit_1 = int(corr_limit[e])\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\n\n if M_indist:\n i = np.eye(M.shape[1])\n for m in M_indist:\n m = np.matmul(m, i)\n i=m\n M = np.matmul(i, M)\n return pinv(M)","def remove_extra_index_from_context_actions(context_action_dict):\n keys_to_keep = {'initial_value', 'replacement_value'}\n for question in context_action_dict:\n for obj_dct in context_action_dict[question]:\n total_keys = set(obj_dct.keys())\n keys_to_remove = total_keys - keys_to_keep\n for key in keys_to_remove:\n obj_dct.pop(key)\n return context_action_dict","def process_replies(self, process_scores_only=False) -> None:\n if self._data.empty:\n logger.warning(msg=\"No survey replies found.\")\n return\n\n self._data[cons.SURVEY_REPLY].replace('', np.nan, inplace=True)\n self._data[cons.SURVEY_REPLY].replace('--deleted-content--', np.nan, inplace=True)\n survey_replies_with_content = self._data.dropna(subset=[cons.SURVEY_REPLY]).reset_index(\n drop=True)\n\n for row in survey_replies_with_content.itertuples(index=False):\n comment = self._clean_comments(comment=row.comment)\n period = \"%s_%s\" % (row.iteration_week, row.iteration_year)\n\n if self._process_prefix and comment is not None:\n\n if row.company_id not in self._result:\n self._result[row.company_id] = {}\n if period not in self._result[row.company_id]:\n self._result[row.company_id][period] = {}\n\n text = self.__attach_question_to_comment(comment, row, cons.lang_english)\n score, sentiment = self._process_sentiment(company_id=row.company_id, text=text)\n\n reply_data = {}\n\n if process_scores_only:\n reply_data.update(score=score)\n else:\n entities_text, entities_type = self._process_entities(comment)\n\n reply_data.update(dimension=row.dimension_description)\n reply_data.update(text=row.comment)\n reply_data.update(sentiment=sentiment)\n reply_data.update(entities_text=entities_text,\n entities_type=list(set(entities_type)))\n\n self._result[row.company_id][period][row.survey_reply_id] = {}\n self._result[row.company_id][period][row.survey_reply_id] = reply_data\n\n time.sleep(0.5)","def replace_char(line_copy, index_candidates): \n for idx in index_candidates:\n line_copy[idx] = idx_vocab[random.choice(range(100, 10000))]\n\n return line_copy","def batchify(batch):\n\n\tquestion_len = list()\n\tlabel_list = list()\n\tfor ex in batch:\n\t\tquestion_len.append(len(ex[0]))\n\t\tlabel_list.append(ex[1])\n\n\t'''\n\tPadding the labels - unequal length sequences for sequenial data like we have. \n\tSince actual labels are 0/1 - we pad with -1, and will use this when 'masking' labels during loss and\n\taccuracy evaluation.\n\t'''\n\ttarget_labels = torch.nn.utils.rnn.pad_sequence([torch.tensor(y) for y in label_list], padding_value=-1).t()\n\n\t# dimension is dimension of every feature vector = n_guesses in this homework setting\n\tdim = batch[0][0].shape[1]\n\n\t# similar padding happens for the feature vectors, with vector of all zeros appended.\n\tx1 = torch.FloatTensor(len(question_len), max(question_len), dim).zero_()\n\tfor i in range(len(question_len)):\n\t\tquestion_feature_vec = batch[i][0]\n\t\tvec = torch.FloatTensor(question_feature_vec)\n\t\tx1[i, :len(question_feature_vec)].copy_(vec)\n\tq_batch = {'feature_vec': x1, 'len': torch.FloatTensor(question_len), 'labels': target_labels}\n\treturn q_batch","def __getitem__(self, index):\n idx = self.available_idx[index]\n qn = self.questions[idx]\n qid = qn['id']\n house = qn['house']\n attr, room_attr = self.question_to_attribute(qn)\n\n # encode question and answer\n qe = self.encoded_questions[qn['h5_id']]\n ae = self.encoded_questions[qn['h5_id']]\n\n # choose path_ix\n path_ix = random.choice(range(qn['num_paths'])) if self.split == 'train' else 0 \n path_feats_h5 = h5py.File(osp.join(self.path_feats_dir, qn['path_name']+'.h5'), 'r')\n raw_ego_feats = path_feats_h5['ego_rgb%s' % path_ix][...].reshape(-1, 3200) # (L, 32, 10, 10)\n raw_path_len = raw_ego_feats.shape[0]\n raw_actions = qn['path_actions'][path_ix] # (L, )\n raw_pos_queue = qn['path_positions'][path_ix] # list of L positions\n if self.requires_imgs:\n path_images_h5 = h5py.File(osp.join(self.path_images_dir, qn['path_name']+'.h5'), 'r')\n raw_ego_imgs = path_images_h5['ego_rgb%s' % path_ix] # (L, 224, 224, 3)\n nav_ego_imgs = []\n\n # nav_phrases, nav_phrase_embs\n nav_pgs = [pg for pg in qn['program'] if 'nav' in pg['function']]\n nav_ids = [pg['id'][0] for pg in qn['program'] if 'nav' in pg['function']]\n nav_types = [pg['function'][4:] for pg in qn['program'] if 'nav' in pg['function']]\n nav_phrases = [pg['value_inputs'][0] for pg in qn['program'] if 'nav' in pg['function']]\n nav_phrase_embs = []\n for phrase in nav_phrases:\n nav_phrase_embs.append(np.array([self.wtov[wd] for wd in phrase.split()]).mean(0).astype(np.float32)) # (300, )\n nav_phrase_embs = np.array(nav_phrase_embs) # (#targets, 300)\n\n # For each segment path: feats + actions + pos_queue\n raw_key_ixs = qn['key_ixs_set'][path_ix]\n nav_ego_feats = []\n nav_action_inputs = []\n nav_action_outputs = []\n nav_pos_queues = []\n for i, key_ix in enumerate(raw_key_ixs):\n start_ix = 0 if i == 0 else raw_key_ixs[i-1] # we use last key_ix moment as start (spawn location)\n end_ix = raw_key_ixs[i]+1\n ego_feats = raw_ego_feats[start_ix:end_ix]\n action_inputs = np.array([4] + raw_actions[start_ix:end_ix][:-1], dtype=np.int64)\n action_outputs = np.array(raw_actions[start_ix:end_ix-1] + [3], dtype=np.int64)\n pos_queue = raw_pos_queue[start_ix:end_ix]\n assert ego_feats.shape[0] == len(pos_queue) == action_inputs.shape[0]\n # add to list\n nav_ego_feats.append(ego_feats)\n nav_action_inputs.append(action_inputs)\n nav_action_outputs.append(action_outputs)\n nav_pos_queues.append(pos_queue)\n if self.requires_imgs:\n nav_ego_imgs.append(raw_ego_imgs[start_ix:end_ix])\n\n # cache\n if self.to_cache and index not in self.img_data_cache:\n self.img_data_cache[index] = True # TODO: replace with ego_feats \n\n # private variable\n self.episode_house = self.env_loaded[house]\n self.nav_pos_queues = nav_pos_queues\n self.path_len = raw_path_len\n\n # return\n data = {}\n data['idx'] = idx\n data['qid'] = qid\n data['house'] = qn['house']\n data['question'] = qn['question']\n data['answer'] = qn['answer']\n data['type'] = qn['type']\n data['attr'] = attr\n data['qe'] = qe\n data['ae'] = ae\n data['path_name'] = qn['path_name']\n data['path_ix'] = path_ix\n data['nav_ids'] = nav_ids\n data['nav_types'] = nav_types\n data['nav_phrases'] = nav_phrases\n data['nav_phrase_embs'] = nav_phrase_embs\n data['nav_ego_feats'] = nav_ego_feats\n data['nav_action_inputs'] = nav_action_inputs\n data['nav_action_outputs'] = nav_action_outputs\n if self.requires_imgs:\n data['nav_ego_imgs'] = nav_ego_imgs\n return data","def tokenize_replace_pos(doc_list, language_code, replace_pos,\n core_num=multiprocessing.cpu_count()):\n param = [[d, language_code, replace_pos] for d in doc_list]\n pool = multiprocessing.Pool(core_num)\n return pool.map(_tokenize_replace_pos4map, param)","def q_attention(decoder_state, coverage=None):\n with variable_scope.variable_scope(\"Question_Attention\"):\n # Pass the decoder state through a linear layer (this is W_s s_t + b_attn in the paper)\n decoder_features = linear(decoder_state, attention_vec_size, True) # shape (batch_size, attention_vec_size)\n decoder_features = tf.expand_dims(tf.expand_dims(decoder_features, 1), 1) # reshape to (batch_size, 1, 1, attention_vec_size)\n\n if use_coverage and coverage is not None: # non-first step of coverage\n # Multiply coverage vector by w_c to get coverage_features.\n coverage_features = nn_ops.conv2d(coverage, w_q_c, [1, 1, 1, 1], \"SAME\") # c has shape (batch_size, attn_length, 1, attention_vec_size)\n\n # Calculate v^T tanh(W_h h_i + W_s s_t + w_c c_i^t + b_attn)\n e = math_ops.reduce_sum(v_q * math_ops.tanh(question_features + decoder_features + coverage_features), [2, 3]) # shape (batch_size,attn_length)\n\n # Calculate attention distribution\n attn_dist = masked_attention_q(e, q_padding_mask)\n\n # Update coverage vector\n coverage += array_ops.reshape(attn_dist, [batch_size, -1, 1, 1])\n else:\n # Calculate v^T tanh(W_h h_i + W_s s_t + b_attn)\n e = math_ops.reduce_sum(v_q * math_ops.tanh(question_features + decoder_features), [2, 3]) # calculate e\n\n # Calculate attention distribution\n attn_dist = masked_attention_q(e, q_padding_mask)\n\n if use_coverage: # first step of training\n coverage = tf.expand_dims(tf.expand_dims(attn_dist,2),2) # initialize coverage\n\n # Calculate the context vector from attn_dist and encoder_states\n context_vector = math_ops.reduce_sum(array_ops.reshape(attn_dist, [batch_size, -1, 1, 1]) * question_states, [1, 2]) # shape (batch_size, attn_size).\n context_vector = array_ops.reshape(context_vector, [-1, attn_size])\n\n return context_vector, attn_dist, coverage","def replace_tokens(self, tokens):\n details = []\n idx = 0\n if len(tokens) >= min_token_num:\n for i in range(len(tokens)):\n old_token = tokens[i]\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\n tokens[i] = self.get_delete_token()\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\n idx += len(tokens[i])\n return tokens, details","def prepare_for_supervised(embeddings):\n \n X, y = [], []\n for problem in embeddings:\n pairs = [np.concatenate((problem['question'], problem[i])) \n for i in ('choice_0', 'choice_1', 'choice_2', 'choice_3')]\n correct_answer = problem['correct_answer']\n \n labels = [0, 0, 0, 0]\n labels[correct_answer] = 1\n X.extend(pairs)\n y.extend(labels)\n return X, y","def pose_qa(self, specificity_sector=0, n_qas=4, n_diff_sectors=3,\n n_incorrect = 3, plan_file=None, save_posed=True):\n def test_ans_length(ans, indexes):\n la = len(ans)\n if la > indexes.max():\n return np.array(ans)[indexes]\n else:\n return np.array(ans)\n\n assert specificity_sector < n_diff_sectors, ('The specificity sector'\n ' goes from 0 to {}'.format(n_diff_sectors - 1))\n diff_sector_means = list(map(np.mean, \n np.array_split(\n np.array(\n list(range(10))) / 10.0,\n n_diff_sectors)))\n bn_parameter = diff_sector_means[specificity_sector]\n q_size = self.n_topics * self.n_top_sentences\n a_size = self.n_top_words\n ques_idx = np.random.binomial(n=q_size, p=bn_parameter, size=n_qas)\n anss_idx = np.random.binomial(n=a_size, p=bn_parameter, size=n_qas)\n\n if not plan_file is None:\n self.qa_plan = pd.read_csv(plan_file)\n self.qa_plan['answers'] = self.qa_plan['answers'] \\\n .apply(ast.literal_eval)\n\n ques = self.qa_plan['QA'][ques_idx]\n anss = [test_ans_length(a, anss_idx)\n for a in self.qa_plan['answers'][ques_idx]]\n posed_qas = []\n for que, ans in zip(ques, anss):\n if len(ans) >= n_incorrect:\n for a in ans:\n correct = tuple(a)\n q = que.replace(a[0], '_' * len(a[0]))\n tans = list(map(tuple, ans))\n tans.pop(tans.index(correct))\n posed_qas.append(\n (q, correct, tans)\n )\n if save_posed:\n pd.DataFrame(posed_qas,\n columns=['question', 'answer', 'bait']) \\\n .to_csv('qa_' + plan_file.split('.')[0] + '.csv',\n index=False)\n else:\n return pd.DataFrame(posed_qas,\n columns=['question', 'answer', 'bait'])\n else:\n plan_qas = {}\n for i in list(self.qa_plan.keys()):\n ques = self.qa_plan[i]['QA'][ques_idx]\n anss = [test_ans_length(a, anss_idx)\n for a in self.qa_plan[i]['answers'][ques_idx]]\n #q_tokenized = ' '.join(self.qa_plan[i]['QA'].values.tolist())\n int_bow = dict(self.interest_bower[i] \\\n .doc2bow(sum(self.int_sentences[i], [])))\n posed_qas = []\n for que, ans in zip(ques, anss):\n if len(ans) >= n_incorrect:\n for a in ans:\n correct = tuple(a)\n q = que.replace(a[0], '_' * len(a[0]))\n tans = list(map(tuple, ans))\n tans.pop(tans.index(correct))\n correct_id = self.interest_bower[i] \\\n .token2id[correct[0]]\n correct = correct + (int_bow[correct_id], )\n posed_qas.append((q, correct, tans))\n\n if save_posed:\n pd.DataFrame(posed_qas,\n columns=['question', 'answer', 'bait']) \\\n .to_csv('qa_for_' + i.replace(' ', '_') + '.csv',\n index=False)\n else:\n plan_qas[i] = pd.DataFrame(posed_qas,\n columns=['question', 'answer', 'bait'])\n return plan_qas","def insert_values():\n merged_df = pd.read_csv(\"merged_fuzzy_df.csv\")\n df = pd.read_csv(\"df.csv\")\n story_entity_df = pd.read_csv(\"story_entity_df.csv\")\n\n merged_df['entity_id'] = merged_df['entity_id'].apply(str)\n\n # find and input new types\n TYPES = get_types_ids(list(story_entity_df[\"label\"].unique()))\n\n new_parents = {}\n new_alias = {}\n\n merged_df[\"wiki\"].fillna(\"\", inplace=True)\n\n # if score = -2, it needs new alias as well as new parents\n for index, row in merged_df[merged_df[\"score\"] == -2].iterrows():\n\n # create a new parent\n if row[\"text\"] not in new_parents:\n new_parents[row[\"text\"]] = [\n str(uuid.uuid4()),\n row[\"text\"],\n TYPES[row[\"label\"]],\n row[\"wiki\"],\n True,\n str(datetime.utcnow())\n ]\n\n merged_df.at[index,\n \"entity_id\"] = new_parents[row[\"text\"]][0]\n\n # add alias with corresponding parent ID\n if row[\"text\"] not in new_alias:\n new_alias[row[\"text\"]] = [\n str(uuid.uuid4()),\n row[\"text\"],\n row[\"wiki\"],\n row[\"score\"],\n str(datetime.utcnow()),\n new_parents[row[\"text\"]][0],\n TYPES[row[\"label\"]]\n ]\n\n for index, row in merged_df[merged_df[\"score\"] >= -1].iterrows():\n # if score >= -1, it needs new alias\n if row[\"text\"] not in new_alias:\n new_alias[row[\"text\"]] = [\n str(uuid.uuid4()),\n row[\"text\"],\n row[\"wiki\"],\n row[\"score\"],\n str(datetime.utcnow()),\n row[\"entity_ref_id\"],\n TYPES[row[\"label\"]]\n ]\n\n merged_df.at[index,\n \"entity_id\"] = row[\"entity_ref_id\"]\n\n # if already matched, write story_entity_id into entity_id for mapping\n for index, row in merged_df[merged_df[\"score\"].isnull()].iterrows():\n merged_df.at[index,\n \"entity_id\"] = row[\"entity_ref_id\"]\n\n for _, value in new_parents.items():\n STORY_REF_INPUTS.append(value)\n\n for _, value in new_alias.items():\n ENTITY_ALIAS_INPUTS.append(value)\n\n logging.info(\"parents: {}\".format(len(STORY_REF_INPUTS)))\n logging.info(\"alias: {}\".format(len(ENTITY_ALIAS_INPUTS)))\n\n columns_to_drop = [\"legal_name\", \"wiki\", \"label\",\n \"entity_ref_id\", \"entity_name\",\n \"text\", \"score\"]\n merged_df.drop(columns_to_drop, axis=1, inplace=True)\n\n # generate uuids for story_map\n uuids = []\n for _ in range(len(merged_df)):\n uuids.append(str(uuid.uuid4()))\n\n logging.info(\"check na {}\".format(merged_df.isnull().values.any()))\n\n # input new_entites to table\n # using entity UUID and story UUID to apis_story_enity_map table\n\n merged_df[\"uuid\"] = uuids\n merged_df[\"created_at\"] = str(datetime.utcnow())\n\n merged_df = merged_df[[\"uuid\", \"entity_id\",\n \"story_uuid\", \"mentions\",\n \"salience\", \"created_at\"]]\n\n STORY_MAP_INPUTS = [tuple(row)\n for row in merged_df.itertuples(index=False)]\n\n # see if there are apis_entity elements in the stories\n match_manual_entity_to_story(df)\n\n insert_story_entity_ref(STORY_REF_INPUTS)\n insert_entity_alias(ENTITY_ALIAS_INPUTS)\n insert_story_entity_map(STORY_MAP_INPUTS)\n\n logging.info(\"finished\")\n\n logging.info(\"delete articles without entities\")\n articles_without_entities(df, story_entity_df)","def forward(self, passage, question):\n # Mask: FloatTensor with 0 in positions that are\n # padding (word index 0) and 1 in positions with actual words.\n # Make a mask for the passage. Shape: ?\n # TODO: Your code here.\n\n passage_mask = (passage != 0).type(\n torch.cuda.FloatTensor if passage.is_cuda else\n torch.FloatTensor)\n\n # Make a mask for the question. Shape: ?\n # TODO: Your code here.\n\n question_mask = (question != 0).type(\n torch.cuda.FloatTensor if question.is_cuda else\n torch.FloatTensor)\n\n\n # Make a LongTensor with the length (number non-padding words\n # in) each passage.\n # Shape: ?\n # TODO: Your code here.\n\n # Sum along dim 1 to get length of non-padding words for passage\n passageLengths = passage_mask.sum(dim=1)\n\n # Make a LongTensor with the length (number non-padding words\n # in) each question.\n # Shape: ?\n # TODO: Your code here.\n \n # Sum along dim 1 to get length of non-padding words for questions\n questionLengths = question_mask.sum(dim=1)\n\n # Part 1: Embed the passages and the questions.\n # 1.1 Embed the passage.\n # TODO: Your code here.\n # Shape: ?\n\n # Get passage embedding\n embedded_passage = self.embedding(passage)\n\n # 1.2. Embed the question.\n # TODO: Your code here.\n # Shape: ?\n\n # Get question embedding\n embedded_question = self.embedding(question)\n\n # Part 2. Encode the embedded passages with the RNN.\n # 2.1. Sort embedded passages by decreasing order of passage_lengths.\n # Hint: allennlp.nn.util.sort_batch_by_length might be helpful.\n # TODO: Your code here.\n\n # Sort training batch with allennlp function with passage and lengths as parameters\n sorted_passage, sorted_passage_lengths, passage_restoration, _ = sort_batch_by_length(embedded_passage, passageLengths)\n\n # 2.2. Pack the passages with torch.nn.utils.rnn.pack_padded_sequence.\n # Hint: Make sure you have the proper value for batch_first.\n # TODO: Your code here.\n\n # pack sequence based on non-padding words\n packed_passage = pack_padded_sequence(sorted_passage, sorted_passage_lengths, batch_first = True)\n\n # 2.3. Encode the packed passages with the RNN.\n # TODO: Your code here.\n\n # get passage representation from GRU\n passageEncoding, passageHidden = self.gruPassage(packed_passage)\n\n # 2.4. Unpack (pad) the passages with\n # torch.nn.utils.rnn.pad_packed_sequence.\n # Hint: Make sure you have the proper value for batch_first.\n # Shape: ?\n # TODO: Your code here.\n\n # Unpack sequence based on padding words\n passage_unpacked, lens_unpacked = pad_packed_sequence(passageEncoding, batch_first=True)\n\n # 2.5. Unsort the unpacked, encoded passage to restore the\n # initial ordering.\n # Hint: Look into torch.index_select or NumPy/PyTorch fancy indexing.\n # Shape: ?\n # TODO: Your code here.\n\n # get unsorted passage using restoration indices\n unsorted_passage = passage_unpacked.index_select(0, passage_restoration)\n\n # Part 3. Encode the embedded questions with the RNN.\n # 3.1. Sort the embedded questions by decreasing order\n # of question_lengths.\n # Hint: allennlp.nn.util.sort_batch_by_length might be helpful.\n # TODO: Your code here.\n\n # Sort question batches\n sorted_question, sorted_question_lengths, question_restoration, _ = sort_batch_by_length(embedded_question, questionLengths)\n\n # 3.2. Pack the questions with pack_padded_sequence.\n # Hint: Make sure you have the proper value for batch_first.\n # TODO: Your code here.\n\n # pack questions based on padding words\n packed_question = pack_padded_sequence(sorted_question, sorted_question_lengths, batch_first = True)\n\n # 3.3. Encode the questions with the RNN.\n # TODO: Your code here.\n\n # Get question representation from GRU\n questionEncoding, questionHidden = self.gruQuestion(packed_question)\n\n # 3.4. Unpack (pad) the questions with pad_packed_sequence.\n # Hint: Make sure you have the proper value for batch_first.\n # Shape: ?\n # TODO: Your code here.\n\n # Unpack question representation based on padding words\n question_unpacked, lens_unpacked = pad_packed_sequence(questionEncoding, batch_first = True)\n\n # 3.5. Unsort the unpacked, encoded question to restore the\n # initial ordering.\n # Hint: Look into torch.index_select or NumPy/PyTorch fancy indexing.\n # Shape: ?\n # TODO: Your code here.\n\n # restore original question ordering using restoration indices\n unsorted_question = question_unpacked.index_select(0, question_restoration)\n\n\n # Part 4. Calculate attention weights and attend to question.\n\n # use softmax to convert weights to probabilities, use those probabilites by multiplying questions to get weighted average\n # another affine transformation to get the weights from the passages, trainable parameter\n # define another matrix for attention and multiply that by tensor to get logits, then do softmax from logits to get probability\n # then computed weighted average from that probability\n\n # 4.1. Expand the encoded question to shape suitable for attention.\n # Hint: Think carefully about what the shape of the attention\n # input vector should be. torch.unsqueeze and torch.expand\n # might be useful.\n # Shape: (batch_size, passage_len, question_len, hidden_dim) (64, 15, 124, 512)\n # need to get question and passage shape the same\n # TODO: Your code here.\n\n # Goal: (batch_size, passage_len, question_len, hidden_dim) (64, 15, 124, 512)\n\n # unsorted question shape is (batch_size, question_len, hidden_dim) (64, , 15 x 512)\n # passage_mask.size(1) gets max passage size for the mask\n maxPassageSize = passage_mask.size(1)\n\n # Use -1 index within expand to keep original dimensions same and only add passage dimension\n expanded_question = unsorted_question.unsqueeze(dim=1).expand(-1, maxPassageSize, -1, -1)\n\n # 4.2. Expand the encoded passage to shape suitable for attention.\n # Hint: Think carefully about what the shape of the attention\n # input vector should be. torch.unsqueeze and torch.expand\n # might be useful.\n # Shape: ?\n # TODO: Your code here.\n\n # Get max question size\n maxQuestionSize = question_mask.size(1)\n\n # unsorted pasage shape is (batch_size, passage_len, hidden_dim) (64, 124, 512)\n # Add question dimension using expand and max question size\n\n # Keep all other dimensions the same with -1 index\n # Unsqueeze adds singleton dimension at place to insert new values\n expanded_passage = unsorted_passage.unsqueeze(dim=2).expand(-1, -1, maxQuestionSize,-1)\n\n\n # 4.3. Build attention_input. This is the tensor passed through\n # the affine transform.\n # Hint: Think carefully what the shape of this tensor should be.\n # torch.cat might be useful.\n # Shape: ?\n\n # attention_input is the concatenating of 4.1 and 4.2\n # pass in attention input to affine transformation\n # use affine_transform function and pass in the concatenated matrix\n # TODO: Your code here.\n\n # concatenate along the last dimension -1 with expanded passages and questions\n attention_input = torch.cat([expanded_passage, expanded_question,\n expanded_passage * expanded_question], dim=-1)\n\n # 4.4. Apply affine transform to attention input to get\n # attention logits. You will need to slightly reshape it\n # into a tensor of the shape you expect.\n # Shape: \n # TODO: Your code here.\n\n # apply attention transform layer, reshape the last dimension to so logits works with mask\n attention_logits = self.attention_transform(attention_input).squeeze(-1)\n\n # 4.5. Masked-softmax the attention logits over the last dimension\n # to normalize and make the attention logits a proper\n # probability distribution.\n # Hint: allennlp.nn.util.last_dim_softmax might be helpful.\n # Shape: ?\n # TODO: Your code here.\n\n # Get probabilty distribution from logits using softmax, default dim = -1 for last dimension\n prob_dist = masked_softmax(attention_logits, question_mask)\n\n # 4.6. Use the attention weights to get a weighted average\n # of the RNN output from encoding the question for each\n # passage word.\n # Hint: torch.bmm might be helpful.\n # Shape: ?\n # use torch.bmm with question to add weights\n # TODO: Your code here.\n\n # compute weighted average using matrix product with bmm\n # Weighted average = P(event) * event \n attentionWeights = torch.bmm(prob_dist, unsorted_question)\n\n # Part 5: Combine the passage and question representations by\n # concatenating the passage and question representations with\n # their product.\n # 5.1. Concatenate to make the combined representation.\n # Hint: Use torch.cat\n # Shape: ?\n # TODO: Your code here.\n\n # Get combined representation using formula to add passage representation, weighted average, and element-wise product\n # Concatenate over last dimension\n combinedRepresent = torch.cat([unsorted_passage, attentionWeights,\n unsorted_passage * attentionWeights], dim=-1)\n\n # Part 6: Compute logits for answer start index.\n\n # 6.1. Apply the affine transformation, and edit the shape.\n # Shape after affine transformation: ?\n # Shape after editing shape: ?\n # TODO: Your code here.\n\n # Get start projection using combined representation\n start_logits = self.start_output_projection(combinedRepresent).squeeze(-1)\n\n # 6.2. Replace the masked values so they have a very low score (-1e7).\n # This tensor is your start_logits.\n # Hint: allennlp.nn.util.replace_masked_values might be helpful.\n # Shape: ?\n # TODO: Your code here.\n\n start_logits = replace_masked_values(start_logits, passage_mask, -1e7)\n\n\n # 6.3. Apply a padding-aware log-softmax to normalize.\n # This tensor is your softmax_start_logits.\n # Hint: allennlp.nn.util.masked_log_softmax might be helpful.\n # Shape: ?\n # TODO: Your code here.\n \n softmax_start_logits = masked_log_softmax(start_logits, passage_mask)\n\n # Part 7: Compute logits for answer end index.\n\n # 7.1. Apply the affine transformation, and edit the shape.\n # Shape after affine transformation: ?\n # Shape after editing shape: ?\n # TODO: Your code here.\n\n end_logits = self.end_output_projection(combinedRepresent).squeeze(-1)\n\n # 7.2. Replace the masked values so they have a very low score (-1e7).\n # This tensor is your end_logits.\n # Hint: allennlp.nn.util.replace_masked_values might be helpful.\n # Shape: ?\n # TODO: Your code here.\n\n end_logits = replace_masked_values(end_logits, passage_mask, -1e7)\n\n # 7.3. Apply a padding-aware log-softmax to normalize.\n # This tensor is your softmax_end_logits.\n # Hint: allennlp.nn.util.masked_log_softmax might be helpful.\n # Shape: ?\n # TODO: Your code here.\n\n softmax_end_logits = masked_log_softmax(end_logits, passage_mask)\n\n # Part 8: Output a dictionary with the start_logits, end_logits,\n # softmax_start_logits, softmax_end_logits.\n # TODO: Your code here. Remove the NotImplementedError below.\n \n return {\n \"start_logits\": start_logits,\n \"end_logits\": end_logits,\n \"softmax_start_logits\": softmax_start_logits,\n \"softmax_end_logits\": softmax_end_logits\n }","def preprocess_nn(json_df, articles_df, vectorizer, max_seq_len, spellcheck=None, use_ngrams=True, credibility_model=None):\n\n # Raw Data\n uids = list(json_df[const.PKL_CLAIM_ID])\n claims = json_df[const.PKL_CLAIM]\n claimants = json_df[const.PKL_CLAIMANT]\n labels = json_df[const.PKL_LABEL]\n related_articles = json_df[const.PKL_RELATED_ARTICLES]\n\n # Processed Data\n processed_claims = []\n supporting_info = []\n credibilities = []\n final_labels = []\n\n start_time = time.time() # Used for tracking only\n\n '''\n Loop through all the claims and their article ID's\n '''\n for j, (str_claim, str_claimant, article_ids, label) in enumerate(zip(claims, claimants, related_articles, labels)):\n\n # Tracking use only\n if j % 1000 == 0 and j != 0:\n now = time.time()\n log(f\"Processing claim {j} | Last 1000 claims took {now - start_time} seconds\")\n start_time = now\n\n '''\n Process Claim: \n Final Claim = Claimant + Claim\n - Convert numbers to string representation\n - Take out all non-alphanumeric\n - Keep case - may be important\n '''\n claim = str_claimant + ' ' + str_claim\n claim = clean_txt(claim, spellcheck)\n\n '''\n Process articles\n - Get all articles from the dataframe by ID\n - Get relevant info from the article, truncated to max_seq_len # of words\n '''\n # Get list of article bodies from the dataframe\n article_ids = [str(article_id) for article_id in article_ids] # Need to lookup by string\n # Get the articles with the given article ID's and only extract the text column\n articles = articles_df.loc[articles_df[const.PKL_ARTICLE_ID].isin(article_ids), const.PKL_ARTICLE_TXT]\n\n # If using credibility, we separate the articles\n if credibility_model is not None:\n for article in articles:\n credibility = get_credibility(article, credibility_model)\n support_txt = get_relevant_info(claim, [article], vectorizer, max_seq_len, spellcheck, use_ngrams)\n # Add to list\n credibilities.append(credibility)\n processed_claims.append(claim)\n supporting_info.append(support_txt)\n final_labels.append(label)\n\n else:\n # If we are not using credibility model, construct support text from all articles\n support_txt = get_relevant_info(claim, articles, vectorizer, max_seq_len, spellcheck, use_ngrams)\n # Add to list\n processed_claims.append(claim)\n supporting_info.append(support_txt)\n final_labels.append(label)\n\n # Return what's appropriate\n if credibility_model is not None:\n return uids, processed_claims, supporting_info, final_labels, credibilities\n else:\n return uids, processed_claims, supporting_info, final_labels","def batch_inference(question,context): \n inputs = tokenizer(question, context, \n return_tensors='pt', \n truncation=True, \n padding=True)\n \n # Move data to GPU\n inputs = inputs.to(device)\n \n # Feed data through the model\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Q&A model outputs the two logit scores for each word.\n # One for its chance of being the start of the answer\n # and one for its chance of being the end\n start_logits = outputs.start_logits\n end_logits = outputs.end_logits\n \n # Find the words with the highest score\n # argmax(dim=1) means argmax with each sample\n start = start_logits.argmax(dim=1)\n end = end_logits.argmax(dim=1)\n \n # Return the answers\n # This is the point where we move the prediction back to main memory with .cpu()\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\"input_ids\"].cpu().numpy()]\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]","def __getitem__(self, idx):\n pos_pid = self.valid_passage_ids[idx]\n psg = self.passage_sent_dict[pos_pid]\n assert(len(psg) > 1)\n\n # randomly select a sentence as the question\n qid = random.choice(range(len(psg)))\n query = psg[qid]\n query_tokens = self.tokenizer.encode(query)\n\n # remove the selected sentence with 1 - sent_keep probability, this psg is the positive psg.\n sent_remove_flag = random.random() > self.sent_keep\n pos_psg = \" \".join(psg[:qid] + psg[qid+sent_remove_flag:])\n postive_psg_tokens = self.tokenizer.encode(pos_psg)\n\n # randomly sample from the rest to get negative samples.\n\n # extract a percentage of hard examples\n hard_k = int(self.sampled_softmax_n * self.hard_negative_rate)\n passage_set = self.passageids_set - set([pos_pid])\n hard_negatives = set([item for item in passage_set if item.split('.')[0] == pos_pid.split('.')[0]])\n\n # handle edge case for \n if len(hard_negatives) >= hard_k:\n npids_hard = random.sample(hard_negatives, k=hard_k)\n else:\n npids_hard = []\n hard_k = 0\n\n # extract a percentage of easy examples\n rest_k = self.sampled_softmax_n - hard_k\n npids_rest = random.sample(self.passageids_set - set([pos_pid]) - set(npids_hard), k=rest_k)\n\n # putting it all together\n npids = npids_hard + npids_rest\n negative_psg_tokens_list = [self.passage_dict[pid] for pid in npids]\n\n return query_tokens, postive_psg_tokens, negative_psg_tokens_list, pos_pid, npids","def vectorize_data(data, word_idx, sentence_size, memory_size,answer_size):\n S = []\n Q = []\n AS = []\n L = []\n label_nums = set([len(dt[2]) for dt in data])\n assert(len(label_nums) == 1)\n label_num = list(label_nums)[0]\n for story, query, answer, label in data:\n lq = max(0, sentence_size - len(query))\n q = [word_idx[w] for w in query] + [0] * lq\n\n ss = []\n for i, sentence in enumerate(story, 1):\n ls = max(0, sentence_size - len(sentence))\n ss.append([word_idx[w] for w in sentence] + [0] * ls)\n\n if len(ss) > memory_size:\n # Use Jaccard similarity to determine the most relevant sentences\n q_words = set(q)\n least_like_q = sorted(ss, cmp = lambda x, y: jaccard(set(x), q_words) < jaccard(set(y), q_words))[:len(ss)-memory_size]\n for sent in least_like_q:\n # Remove the first occurrence of sent. A list comprehension as in [sent for sent in ss if sent not in least_like_q]\n # should not be used, as it would remove multiple occurrences of the same sentence, some of which might actually make the cutoff.\n ss.remove(sent)\n else:\n # pad to memory_size\n lm = max(0, memory_size - len(ss))\n for _ in range(lm):\n ss.append([0] * sentence_size)\n\n y = np.zeros(len(word_idx) + 1) # 0 is reserved for nil word\n\n sa = []\n for i, sentence in enumerate(answer, 1):\n ls = max(0, answer_size - len(sentence))\n sa.append([word_idx[w] for w in sentence] + [0] * ls)\n\n lb = np.zeros(label_num)\n lb[int(label)] = 1\n\n S.append(ss)\n Q.append(q)\n AS.append(sa)\n L.append(lb)\n Q = pad_sequences(Q, sentence_size)\n\n return np.array(S), np.array(Q), np.array(AS), np.array(L)"],"string":"[\n \"def embed(raw_seq, index_dict):\\n return np.asarray([index_dict[word.lower()]\\n if word.lower() in index_dict\\n else index_dict[OOV_TOKEN] for word in raw_seq])\",\n \"def convert_questions_to_features(examples, tokenizer, max_query_length=None):\\n\\n unique_id = 1000000000\\n question_features = []\\n\\n for (example_index, example) in enumerate(tqdm(examples, desc='Converting questions')):\\n\\n query_tokens = tokenizer.tokenize(example.question_text)\\n if max_query_length is None:\\n max_query_length = len(query_tokens)\\n if len(query_tokens) > max_query_length:\\n query_tokens = query_tokens[0:max_query_length]\\n\\n for _ in enumerate(range(1)):\\n tokens_ = []\\n tokens_.append(\\\"[CLS]\\\")\\n for token in query_tokens:\\n tokens_.append(token)\\n tokens_.append(\\\"[SEP]\\\")\\n\\n input_ids_ = tokenizer.convert_tokens_to_ids(tokens_)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask_ = [1] * len(input_ids_)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids_) < max_query_length + 2:\\n input_ids_.append(0)\\n input_mask_.append(0)\\n\\n assert len(input_ids_) == max_query_length + 2\\n assert len(input_mask_) == max_query_length + 2\\n\\n if example_index < 1:\\n # logger.info(\\\"*** Example ***\\\")\\n # logger.info(\\\"unique_id: %s\\\" % (unique_id))\\n # logger.info(\\\"example_index: %s\\\" % (example_index))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in query_tokens]))\\n # logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids_]))\\n # logger.info(\\n # \\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask_]))\\n\\n question_features.append(\\n QuestionFeatures(\\n unique_id=unique_id,\\n example_index=example_index,\\n tokens_=tokens_,\\n input_ids=input_ids_,\\n input_mask=input_mask_))\\n unique_id += 1\\n\\n return question_features\",\n \"def qa_ctx_attention(self, qa_embed, ctx_embed, qa_mask, ctx_mask, noun_mask, non_visual_vectors):\\n num_img, num_region = ctx_mask.shape[2:]\\n u_a, raw_s, s_mask, s_normalized = self.str_attn(qa_embed, ctx_embed, qa_mask, ctx_mask, noun_mask=noun_mask, void_vector=non_visual_vectors)\\n qa_embed = qa_embed.repeat(1, 1, num_img, 1, 1)\\n mixed = torch.cat([qa_embed, u_a, qa_embed * u_a], dim=-1)\\n mixed = self.c2q_down_projection(mixed)\\n mixed_mask = (s_mask.sum(-1) != 0).float()\\n return mixed, mixed_mask, raw_s, s_normalized\",\n \"def _lost_answers_indexes(self, df, tokenized_contexts):\\n whole_answers_start = df[\\\"answer_start\\\"].tolist()\\n whole_answers_end = df[\\\"answer_end\\\"].tolist()\\n lost_dirty, lost_truncated = [], []\\n for i, (c, s, e) in enumerate(\\n zip(tokenized_contexts, whole_answers_start, whole_answers_end)\\n ):\\n mask = (\\n torch.tensor(c.attention_mask, device=self.device).bool()\\n & ~torch.tensor(c.special_tokens_mask, device=self.device).bool()\\n )\\n offsets = torch.tensor(c.offsets, device=self.device)[mask]\\n start_index = torch.nonzero(offsets[:, 0] == s)\\n end_index = torch.nonzero(offsets[:, 1] == e)\\n if len(start_index) == 0 or len(end_index) == 0:\\n if s > offsets[-1, 0] or e > offsets[-1, 1]:\\n lost_truncated.append(i)\\n else:\\n lost_dirty.append(i)\\n\\n return lost_truncated, lost_dirty\",\n \"def predict_sentences_2_idxs(self):\\n fo = open(self.config.parsed_predict_file, 'w')\\n self.load_dicts()\\n\\n questions = pd.read_csv(self.config.predict_file,\\n usecols=[\\\"question_text\\\"], index_col=False)\\n unk_idx = self.word2idx[self.config.unknown_token]\\n\\n for quest in questions.question_text:\\n tokens = preprocess_text(quest)\\n if self.config.include_unknown:\\n idxs = [self.word2idx.get(token, unk_idx) for token in\\n tokens]\\n else:\\n idxs = [self.word2idx.get(token) for token in tokens]\\n idxs = [idx for idx in idxs if idx]\\n fo.write((str(\\\" \\\".join(str(num) for num in idxs)) + \\\"\\\\n\\\"))\",\n \"def enseemble_results_extra(self, questions, topn):\\n ok_vocab = self.get_vocabulary()\\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\\n new_vocab = {w.upper(): v for w, v in new_vocab}\\n new_vocab = dict(new_vocab)\\n\\n results = []\\n for line_no, line in enumerate(utils.smart_open(questions)):\\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\\n line = utils.to_unicode(line)\\n if line.startswith(': '):\\n continue\\n else:\\n\\n try:\\n a, b, c, expected = [word.upper() for word in line.split()]\\n except ValueError:\\n logger.info(\\\"skipping invalid line #%i in %s\\\", line_no, questions)\\n continue\\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\\n \\\"\\\"\\\"if a not in new_vocab:\\n print(\\\"Dont know: \\\" + a)\\n if b not in new_vocab:\\n print(\\\"Dont know: \\\" + b)\\n if c not in new_vocab:\\n print(\\\"Dont know: \\\" + c)\\n if expected not in new_vocab:\\n print(\\\"Dont know: \\\" + expected)\\n \\\"\\\"\\\"\\n logger.debug(\\\"skipping line #%i with OOV words: %s\\\", line_no, line.strip())\\n results.append(None)\\n continue\\n\\n original_vocab = self.get_vocabulary()\\n self.set_vocabulary(new_vocab)\\n ignore = {a, b, c} # input words to be ignored\\n #print('topn')\\n #print(topn)\\n # find the most likely prediction, ignoring OOV words and input words\\n sims = self.most_similar(positive_words=[b, c], negative_words=[a], topn = topn)\\n # print(\\\"sims\\\")\\n #print(sims)\\n self.set_vocabulary(original_vocab)\\n inner_results = []\\n for predict in sims:\\n predicted = predict[0]\\n predicted = predicted.upper()\\n predicted_tuple = (predicted, predict[1])\\n #print(predicted_tuple)\\n inner_results.append(predicted_tuple)\\n #print(predicted)\\n results.append(inner_results)\\n #print(results)\\n\\n return results\",\n \"def parse_question(question):\\n\\tcontext = question['support']\\n\\tanswer = question['correct_answer']\\n\\ttarget = question['question']\\n\\n\\tcontext_words = context.split(\\\" \\\")[0: 510]\\n\\ttarget_words = target.split(\\\" \\\")\\n\\n\\tpunc_filter = str.maketrans('', '', string.punctuation)\\n\\n\\tcontext_words = [word.translate(punc_filter) for word in context_words]\\n\\ttarget_words = [word.translate(punc_filter) for word in target_words]\\n\\tanswer_words = [word.translate(punc_filter) for word in answer.split(\\\" \\\")]\\n\\n\\tbio_embeddings = [EMBEDER['O']]\\n\\tinside_answer = False\\n\\tanswer_index = 0\\n\\tcan_be_inside_answer = True\\n\\n\\t# The following loop and above code does:\\n\\t# -Find where the answer is and place a B tag\\n\\t# -While still in the answer (the answer is more than one word) put an I tag\\n\\t# -Outside of the answer place a O tag\\n\\t# -Start and end with an O tag for BERT's automatic\\n\\t# -start token and end token representing the start and end of a sentence.\\n\\tfor word in context_words:\\n\\t\\tif word.lower() == answer_words[0].lower() and can_be_inside_answer:\\n\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"B\\\"])\\n\\t\\t\\tanswer_index += 1\\n\\t\\t\\tinside_answer = True\\n\\t\\t\\tcan_be_inside_answer = False\\n\\t\\telif inside_answer:\\n\\t\\t\\tif len(answer_words) > 1:\\n\\t\\t\\t\\tif word.lower() != answer_words[answer_index]:\\n\\t\\t\\t\\t\\tinside_answer = False\\n\\t\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"I\\\"])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tinside_answer = False\\n\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\t\\telse:\\n\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\n\\tground_truth = torch.tensor([BERT_TOKENIZER.encode(target_words)])\\n\\tcontext_words = torch.tensor([BERT_TOKENIZER.encode(context_words)])\\n\\n\\tassert len(bio_embeddings) == len(context_words[0]), f'The BIO tags are not equal in length to the embeddings! ' \\\\\\n\\t f'{None} & {len(bio_embeddings)} & {len(context_words[0])}'\\n\\treturn context_words, bio_embeddings, ground_truth\",\n \"def replace_q_indices(circuit, q_nums, qr):\\n\\n new_circuit = qiskit.QuantumCircuit(qr)\\n for op in circuit.data:\\n original_qubits = op.qargs\\n new_op = copy.deepcopy(op)\\n new_op.qargs = [(qr, q_nums[x]) for x in [arg[1] for arg in original_qubits]]\\n new_circuit.data.append(new_op)\\n\\n return new_circuit\",\n \"def replace_canonical_referents(self, **kwargs):\\n replaced_count = 0\\n for doc in self.annotation_documents:\\n for sen in doc.sentences:\\n for part in sen.participants:\\n replaced_count += part.replace_by_canonical_referent(**kwargs) #this will replace in-place in project, but returns a count too.\\n\\n return replaced_count\",\n \"def process_question_for_prediction(question):\\n question = __set_has_hexadecimal(question)\\n question = __set_has_numeric(question)\\n homework_list = constants.HOMEWORK_SYNONMS_LIST\\n homework_list.sort(key=len, reverse=True)\\n replacement_text = constants.QUESTION_HAS_HOMEWORK_KEY\\n question = __set_has_homework_or_assignment(question, replacement_text, homework_list)\\n question = stem_training_data(question)\\n return question\",\n \"def preprocess_dataset(dataset, tokenizer):\\n eos = torch.tensor([tokenizer.eos_token_id], dtype=torch.long)\\n q_start = torch.tensor(tokenizer.encode('question:'), dtype=torch.long)\\n q_end = torch.tensor(tokenizer.encode(':question'), dtype=torch.long)\\n\\n tensors = [[] for i in range(3)]\\n for i in trange(len(dataset)):\\n example = dataset[i]\\n\\n context_start_idx = (example[2] == 1).nonzero()[0].item()\\n if example[1][-1] == 1:\\n context_end_idx = len(example[1]) - 1\\n else:\\n context_end_idx = (example[1] == 0).nonzero()[0].item()\\n ans_start = example[3] - context_start_idx\\n ans_end = example[4] - context_start_idx\\n\\n context = example[0][context_start_idx: context_end_idx]\\n question = example[0][: context_start_idx]\\n answer = example[0][example[3]: example[4] + 1]\\n\\n input_ids = torch.cat([\\n context,\\n eos,\\n answer,\\n eos,\\n q_start,\\n question,\\n q_end,\\n eos\\n ])\\n\\n attention_mask = torch.ones_like(input_ids, dtype=torch.long)\\n token_type_ids = torch.cat([\\n torch.zeros(len(context) + 1, dtype=torch.long),\\n torch.ones(len(answer) + 1, dtype=torch.long),\\n 2 * torch.ones(len(question) + 3, dtype=torch.long)\\n ])\\n token_type_ids[ans_start: ans_end + 1] = 1\\n\\n tensors[0].append(input_ids)\\n tensors[1].append(attention_mask)\\n tensors[2].append(token_type_ids)\\n\\n tensors_padded = []\\n for i, sequences in enumerate(tqdm(tensors)):\\n padded = pad_sequence(sequences, batch_first=True)\\n tensors_padded.append(padded)\\n\\n new_dataset = TensorDataset(*tensors_padded)\\n return new_dataset\",\n \"def substitute_num(self, numbers, qa3_answer):\\n question = self\\n for match in re.finditer('[0-9]+', question):\\n num = match.group(0)\\n i = qa3_answer.index_by_chunk(num)\\n if i is None or qa3_answer.result[i].get_type() != 'refYear':\\n if num not in numbers:\\n numbers.append(num)\\n question = re.sub(num, '<NUM' + string.ascii_uppercase[numbers.index(num)] + '>', question, 1)\\n return Qa3Question(question)\",\n \"def rearrange_indices(self):\\n num_fixed_words = 2\\n other_words = [w for w in self.word2index if w not in self.equivariant_words]\\n for idx, word in enumerate(self.equivariant_words):\\n w_idx = idx + num_fixed_words\\n self.word2index[word] = w_idx\\n self.index2word[w_idx] = word\\n for idx, word in enumerate(sorted(other_words)):\\n w_idx = idx + num_fixed_words + self.num_equivariant_words\\n self.word2index[word] = w_idx\\n self.index2word[w_idx] = word\",\n \"def replace_by_canonical_referent(self, cross_sentence=True):\\n replaced_count = 0\\n\\n # replace the participant in their containers\\n def replace_in_containers(myobj, replacing):\\n containers = {\\n \\\"event\\\": \\\"participants\\\",\\n \\\"sentiment_expression\\\": \\\"targets\\\",\\n \\\"sentence\\\": \\\"participants\\\",\\n }\\n for c_name, attrib_n in containers.items():\\n c_name = f\\\"in_{c_name}\\\"\\n if hasattr(myobj, c_name):\\n for c in getattr(myobj, c_name):\\n to_replace_in = getattr(c, attrib_n)\\n to_replace_in.append(replacing)\\n if myobj in to_replace_in:\\n to_replace_in.remove(myobj)\\n to_replace_in.sort(key=lambda x: x.begin)\\n\\n if self.canonical_referents and self.canonical_referents != \\\"from_canonref\\\":\\n # sometimes there are multiple canonrefs tagged\\n # this can be a) annotation mistake or\\n # b) multiple reference to a group, e.g. \\\"all\\\" refers to three companies.\\n for canonref in self.canonical_referents:\\n # check whether canonical referent is in same sentence\\n same_sentence = [s.element_id for s in self.in_sentence] == [\\n s.element_id for s in canonref.in_sentence\\n ]\\n # always replace when cross_sentence is true\\n # if cross_sentence is False (disallowed) only replace when canonref is in same sentence\\n if cross_sentence or same_sentence:\\n # replace element\\n replacing_participant = Participant(\\n canonref.text,\\n canonref.begin,\\n canonref.end,\\n canonref.element_id,\\n canonref.annotator_id,\\n canonref.document_title,\\n canonref.in_document,\\n self.role,\\n \\\"from_canonref\\\",\\n self.link_id,\\n canonref.tokens,\\n )\\n replacing_participant.in_sentence = self.in_sentence\\n replacing_participant.in_document = self.in_document\\n if hasattr(self, \\\"in_sentiment_expression\\\"):\\n replacing_participant.in_sentiment_expression = (\\n self.in_sentiment_expression\\n )\\n replacing_participant.from_original_participant = copy(self)\\n print(\\n f\\\"Replaced {self} with {canonref}. (in same sentence:{same_sentence})\\\"\\n )\\n\\n replace_in_containers(self, replacing_participant)\\n\\n # replace on document\\n self.in_document.participants.append(replacing_participant)\\n if self in self.in_document.participants:\\n self.in_document.participants.remove(self)\\n\\n replaced_count += 1\\n return replaced_count\",\n \"def enseemble_results(self, questions, topn):\\n ok_vocab = self.get_vocabulary()\\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\\n new_vocab = {w.upper(): v for w, v in new_vocab}\\n new_vocab = dict(new_vocab)\\n\\n results = []\\n for line_no, line in enumerate(utils.smart_open(questions)):\\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\\n line = utils.to_unicode(line)\\n if line.startswith(': '):\\n continue\\n else:\\n\\n try:\\n a, b, c, expected = [word.upper() for word in line.split()]\\n except ValueError:\\n logger.info(\\\"skipping invalid line #%i in %s\\\", line_no, questions)\\n continue\\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\\n \\\"\\\"\\\"if a not in new_vocab:\\n print(\\\"Dont know: \\\" + a)\\n if b not in new_vocab:\\n print(\\\"Dont know: \\\" + b)\\n if c not in new_vocab:\\n print(\\\"Dont know: \\\" + c)\\n if expected not in new_vocab:\\n print(\\\"Dont know: \\\" + expected)\\n \\\"\\\"\\\"\\n logger.debug(\\\"skipping line #%i with OOV words: %s\\\", line_no, line.strip())\\n results.append(None)\\n continue\\n\\n original_vocab = self.get_vocabulary()\\n self.set_vocabulary(new_vocab)\\n ignore = {a, b, c} # input words to be ignored\\n #print('topn')\\n #print(topn)\\n # find the most likely prediction, ignoring OOV words and input words\\n sims = self.most_similar(positive_words=[b, c], negative_words=[a], topn = topn)\\n # print(\\\"sims\\\")\\n #print(sims)\\n self.set_vocabulary(original_vocab)\\n inner_results = []\\n for predict in sims:\\n predicted = predict[0]\\n predicted = predicted.upper()\\n\\n inner_results.append(predicted)\\n #print(predicted)\\n results.append(inner_results)\\n #print(results)\\n\\n return results\",\n \"def preprocess(self, sequence, word2idx):\\n story = [word2idx[word] if word in word2idx else UNK_token for word in sequence.split()]\\n story = torch.Tensor(story)\\n return story\",\n \"def preprocess(self, sequence, word2idx):\\n context = [word2idx[word]\\n if word in word2idx else UNK_token for word in sequence.split()]\\n context = torch.Tensor(context)\\n return context\",\n \"def __getitem__(self, idx):\\n\\n ############ 1.9 TODO\\n # figure out the idx-th item of dataset from the VQA API\\n image_id_from_idx = self._vqa.questions['questions'][idx]['image_id']\\n question_id_from_idx = self._vqa.questions['questions'][idx]['question_id']\\n question_sentence = self._vqa.questions['questions'][idx]['question']\\n answer_sentences = [ans['answer'] for ans in self._vqa.qa[question_id_from_idx]['answers']]\\n\\n # import pdb; pdb.set_trace()\\n\\n ############\\n\\n # if self._cache_location is not None and self._pre_encoder is not None:\\n # ############ 3.2 TODO\\n # # implement your caching and loading logic here\\n\\n # ############\\n # raise NotImplementedError()\\n # else:\\n ############ 1.9 TODO\\n # load the image from disk, apply self._transform (if not None)\\n # import ipdb; ipdb.set_trace()\\n image_id_from_idx_string = self.fixed_str + str(image_id_from_idx)\\n truncated_image_id_from_idx = image_id_from_idx_string[-12:]\\n img_file_path = self._image_dir + '/' + self._image_filename_pattern.format(truncated_image_id_from_idx)\\n image = Image.open(img_file_path)\\n image = image.convert(\\\"RGB\\\")\\n image = self._transform(image)\\n ############\\n # raise NotImplementedError()\\n\\n ############ 1.9 TODO\\n # load and encode the question and answers, convert to torch tensors\\n question_encoding = torch.zeros(self._max_question_length, self.question_word_list_length)\\n answer_encoding = torch.zeros(10,self.answer_list_length)\\n\\n question_word_list = self._create_word_list(question_sentence)\\n # print(idx,question_word_list)\\n # print(len(self.question_word_to_id_map.keys()))\\n # quit()\\n for i, word in enumerate(question_word_list):\\n # import ipdb; ipdb.set_trace()\\n # print(i,word)\\n # quit()\\n if i >= self._max_question_length:\\n break\\n if word not in self.question_word_to_id_map.keys():\\n map_idx = self.unknown_question_word_index\\n else:\\n map_idx = self.question_word_to_id_map[word]\\n question_encoding[i][map_idx] = 1\\n\\n # answer_sentence_list = self._create_word_list(answer_sentences)\\n for i, answer in enumerate(answer_sentences):\\n if answer not in self.answer_to_id_map.keys():\\n map_idx = self.unknown_answer_index\\n else:\\n map_idx = self.answer_to_id_map[answer]\\n answer_encoding[i][map_idx] = 1\\n \\n data = {'image':image, 'question':question_encoding, 'answer':answer_encoding}\\n return data\\n\\n ############\\n # raise NotImplementedError()\",\n \"def _filter_unanswerable_samples(self):\\n a = []\\n q = []\\n annotations = []\\n for i in range(len(self.answers)):\\n if len(self.answers[i].nonzero()) > 0:\\n a.append(self.answers[i])\\n q.append(self.questions[i])\\n\\n annotations.append(self.annotations[i])\\n self.answers = a\\n self.questions = q\\n self.annotations = annotations\",\n \"def dynamic(question_quantized_dfs):\\n all_transitions = {}\\n\\n for i, qdf in enumerate(question_quantized_dfs):\\n q = qdf.iloc[:, utils.SKIP_COLUMNS:] # don't work on audio_rms column\\n\\n all_transitions[i] = OrderedDict()\\n\\n for au in q:\\n all_transitions[i][au] = np.zeros((4, 4))\\n\\n for (x, y), c in Counter(zip(q[au], q[au][1:])).items():\\n all_transitions[i][au][x - 1, y - 1] += c # TODO some warning about non-integer index\\n\\n # Concatenate all AU triples right, then all question down\\n temp1 = []\\n for k, q_transitions in all_transitions.items():\\n temp2 = []\\n\\n for au, trans in q_transitions.items():\\n trans_features = list(transition_features(trans))\\n trans_index = [au + '_change_ratio', au + '_slow_change_ratio', au + '_fast_change_ratio']\\n\\n temp2.append(pd.DataFrame(trans_features, index=trans_index).T)\\n temp1.append(pd.concat(temp2, axis=1))\\n\\n question_dynamic_features = pd.concat(temp1, axis=0)\\n\\n # Fix index\\n question_dynamic_features.index = range(len(question_quantized_dfs))\\n\\n return question_dynamic_features\",\n \"def process_question(qu):\\n\\n ## global ranking\\n rank_info = {}\\n rank_info_k = [\\\"viewcount\\\",\\\"score\\\",\\\"favoritecount\\\"]\\n for k in rank_info_k:\\n rank_info[k] = int(qu[k])\\n qu.pop(k,None)\\n\\n rank_info[\\\"creationdate\\\"] = qu[\\\"creationdate\\\"]\\n\\n if qu[\\\"acceptedanswer\\\"]:\\n qu[\\\"acceptedanswer\\\"] = list(qu[\\\"acceptedanswer\\\"])\\n else:\\n qu[\\\"acceptedanswer\\\"] = []\\n\\n qu.pop('comments',None) # discard comments, maybe add back later\\n qu[\\\"rank_info\\\"] = rank_info\\n\\n return qu\",\n \"def replace_special_token(self, tokenizer_fields: Dict[str, torch.Tensor], positions: List[int], replace_id: int):\\n token_ids, offsets = tokenizer_fields[\\\"token_ids\\\"], tokenizer_fields[\\\"offsets\\\"]\\n for pos in positions:\\n offset = offsets[pos].numpy().tolist()\\n if offset[0] != offset[1]:\\n warnings.warn(f\\\"replace normally expect token in `positions` has not been split to pieces.\\\"\\n f\\\"This warning should NOT happen unless during batch prediction at evaluation\\\")\\n token_ids[offset[0]] = replace_id\",\n \"def _encode_question(self, question):\\n \\n inputs = self.tokenizer.encode_plus(\\n question,\\n None,\\n add_special_tokens=True,\\n max_length=self.max_len,\\n )\\n\\n ids = inputs[\\\"input_ids\\\"]\\n mask = inputs[\\\"attention_mask\\\"]\\n token_type_ids = inputs[\\\"token_type_ids\\\"]\\n\\n padding_length = self.max_len - len(ids)\\n ids += ([0]*padding_length)\\n mask += ([0]*padding_length)\\n token_type_ids += ([0]*padding_length)\\n \\n return {\\n 'ids': torch.tensor(ids, dtype=torch.long),\\n 'mask': torch.tensor(mask, dtype=torch.long),\\n 'token_type_ids': torch.tensor(token_type_ids, dtype=torch.long),\\n \\n }\",\n \"def preprocess_seq(self, sequence, word2idx):\\n story = []\\n for value in sequence:\\n #v = [word2idx[word] if word in word2idx else UNK_token for word in value.split()] + [EOS_token]\\n story.append(word2idx[value] if value in word2idx else UNK_token)\\n story = torch.Tensor(story)\\n return story\",\n \"def convert_single_example(example, tokenizer, is_training, args):\\n tok_to_orig_index = []\\n orig_to_tok_index = []\\n all_doc_tokens = [] # all subtokens of original doc after tokenizing\\n features = []\\n for (i, token) in enumerate(example['paragraph_tokens']):\\n orig_to_tok_index.append(len(all_doc_tokens))\\n sub_tokens = albert_tokenize(tokenizer, token)\\n tok_to_orig_index.extend([i] * len(sub_tokens))\\n all_doc_tokens.extend(sub_tokens)\\n\\n # 特别注意！由于在paragraph_tokens中我们的token已经映射过一次了\\n # 这里wordpiece等于又映射了一遍，所以这里的操作是二次映射\\n if example['position_map']:\\n tok_to_orig_index = [example['position_map'][index] for index in tok_to_orig_index]\\n\\n # QUERY\\n query_tokens = []\\n query_tokens.append(\\\"[Q]\\\")\\n query_tokens.extend(albert_tokenize(tokenizer, example['question_text']))\\n if len(query_tokens) > args.max_query_length:\\n query_tokens = query_tokens[-args.max_query_length:]\\n\\n # ANSWER 预处理的时候先长短分开\\n tok_start_position = -1\\n tok_end_position = -1\\n # 这里终点是必然在para_tokens内的\\n if is_training:\\n # 现阶段，有短答案预测短答案，否则预测长答案\\n if example['answer_type'] != AnswerType['UNKNOWN']:\\n tok_long_start_position = orig_to_tok_index[example['long_start']]\\n if example['long_end'] == len(orig_to_tok_index):\\n tok_long_end_position = orig_to_tok_index[-1]\\n else:\\n tok_long_end_position = orig_to_tok_index[example['long_end']] - 1\\n tok_start_position = tok_long_start_position\\n tok_end_position = tok_long_end_position\\n if example['answer_type'] == AnswerType['SHORT']:\\n tok_short_start_position = orig_to_tok_index[example['short_start']]\\n if example['short_end'] == len(orig_to_tok_index):\\n tok_short_end_position = orig_to_tok_index[-1]\\n else:\\n tok_short_end_position = orig_to_tok_index[example['short_end']] - 1\\n tok_start_position = tok_short_start_position\\n tok_end_position = tok_short_end_position\\n\\n # Get max tokens number for original doc,\\n # should minus query tokens number and 3 special tokens\\n # The -3 accounts for [CLS], [SEP] and [SEP]\\n max_tokens_for_doc = args.max_seq_length - len(query_tokens) - 3\\n\\n # We can have documents that are longer than the maximum sequence length.\\n # To deal with this we do a sliding window approach, where we take chunks\\n # of up to our max length with a stride of `doc_stride`.\\n _DocSpan = collections.namedtuple(\\\"DocSpan\\\", [\\\"start\\\", \\\"length\\\"])\\n doc_spans = []\\n start_offset = 0\\n while start_offset < len(all_doc_tokens):\\n length = len(all_doc_tokens) - start_offset # compute number of tokens remaining unsliding\\n length = min(length, max_tokens_for_doc) # determine current sliding window size\\n doc_spans.append(_DocSpan(start=start_offset, length=length))\\n\\n # Consider case for reaching end of original doc\\n if start_offset + length == len(all_doc_tokens):\\n break\\n start_offset += min(length, args.doc_stride)\\n\\n # Convert window + query + special tokens to feature\\n for (doc_span_index, doc_span) in enumerate(doc_spans):\\n tokens = []\\n token_to_orig_map = {}\\n token_is_max_context = {}\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n tokens.extend(query_tokens)\\n segment_ids.extend([0] * len(query_tokens))\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n\\n for i in range(doc_span.length):\\n split_token_index = doc_span.start + i\\n token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\\n\\n is_max_context = check_is_max_context(doc_spans, doc_span_index, split_token_index)\\n token_is_max_context[len(tokens)] = is_max_context\\n tokens.append(all_doc_tokens[split_token_index])\\n segment_ids.append(1)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n assert len(tokens) == len(segment_ids)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (args.max_seq_length - len(input_ids))\\n input_ids.extend(padding)\\n input_mask.extend(padding)\\n segment_ids.extend(padding)\\n\\n assert len(input_ids) == args.max_seq_length\\n assert len(input_mask) == args.max_seq_length\\n assert len(segment_ids) == args.max_seq_length\\n\\n start_position = None\\n end_position = None\\n answer_type = None\\n answer_text = \\\"\\\"\\n if is_training:\\n doc_start = doc_span.start\\n doc_end = doc_span.start + doc_span.length - 1\\n # For training, if our document chunk does not contain an annotation\\n # we throw it out, since there is nothing to predict.\\n contains_an_annotation = (tok_start_position >= doc_start and tok_end_position <= doc_end)\\n # 负样本需要经过采样，且目标为[CLS]\\n if (not contains_an_annotation) or example['answer_type'] == AnswerType['UNKNOWN']:\\n if args.include_unknowns < 0 or random.random() > args.include_unknowns:\\n continue\\n start_position = 0\\n end_position = 0\\n answer_type = AnswerType['UNKNOWN']\\n else:\\n doc_offset = len(query_tokens) + 2\\n start_position = tok_start_position - doc_start + doc_offset\\n end_position = tok_end_position - doc_start + doc_offset\\n answer_type = example['answer_type']\\n\\n # 如果是短答案，对一下答案是否正确\\n if example['answer_type'] == AnswerType['SHORT']:\\n answer_text = \\\" \\\".join(tokens[start_position:(end_position + 1)])\\n answer_text = answer_text.replace(' ', '').replace(u\\\"▁\\\", ' ').strip()\\n gt_answer = example['short_answer_text'].lower()\\n answer_text_chars = [c for c in answer_text if c not in \\\" \\\\t\\\\r\\\\n\\\" and ord(c) != 0x202F]\\n gt_answer_chars = [c for c in gt_answer if c not in \\\" \\\\t\\\\r\\\\n\\\" and ord(c) != 0x202F]\\n if \\\"\\\".join(answer_text_chars) != \\\"\\\".join(gt_answer_chars):\\n print(answer_text, 'V.S.', gt_answer)\\n\\n feature = InputFeatures(\\n unique_id=None,\\n example_index=None,\\n doc_span_index=doc_span_index,\\n tokens=tokens,\\n token_to_orig_map=token_to_orig_map,\\n token_is_max_context=token_is_max_context,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n start_position=start_position,\\n end_position=end_position,\\n answer_text=answer_text,\\n answer_type=answer_type)\\n\\n features.append(feature)\\n\\n return features\",\n \"def convert_examples_to_features(examples, tokenizer, max_seq_length):\\n \\n features = []\\n num_tokens_article = []\\n count = 0\\n masking_token_id = tokenizer.convert_tokens_to_ids(['[MASK]'])[0]\\n # padding_token_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)\\n for example_index, example in enumerate(examples):\\n article_tokens = tokenizer.tokenize(example['article'])\\n ques_tokens = tokenizer.tokenize(example['question'].replace(\\\"@placeholder\\\", \\\"_\\\"))\\n masked_index = ques_tokens.index('_')\\n ques_tokens[masked_index] = '[MASK]'\\n \\n# options = example['options']\\n options = tokenizer.convert_tokens_to_ids(example['options'])\\n# print(options, '\\\\n')\\n\\n choices_features = []\\n _truncate_seq_pair(article_tokens, ques_tokens, max_seq_length - 3)\\n\\n# tokens = [\\\"[CLS]\\\"] + ques_tokens + [\\\"[SEP]\\\"] + article_tokens + [\\\"[SEP]\\\"]\\n tokens = ques_tokens + [\\\"[SEP]\\\"] + article_tokens + [\\\"[SEP]\\\"]\\n\\n# segment_ids = [0] * (len(ques_tokens) + 2) + [1] * (len(article_tokens) + 1)\\n segment_ids = [0] * (len(ques_tokens) + 1) + [1] * (len(article_tokens) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\t\\n candidates = example['options']\\n candidates_ids = tokenizer.convert_tokens_to_ids(candidates)\\n# print(tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0])\\n\\n lm_labels = [-1 if t_id != masking_token_id else tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0] for t_id in input_ids]\\n# lm_labels = [t_id if t_id != 0 else -1 for t_id in input_ids]\\n# for i, t_id in enumerate(lm_labels) :\\n# if(t_id == masking_token_id):\\n# lm_labels[i] = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\\n\\n# print(lm_labels, '\\\\n')\\n # tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n assert len(lm_labels) == max_seq_length\\n\\n choices_features.append((tokens, input_ids, input_mask, segment_ids))\\n\\n features.append(\\n InputFeatures(\\n choices_features = choices_features,\\n lm_labels = lm_labels,\\n options = options,\\n label = example['label']\\n )\\n )\\n \\n return features\",\n \"def words_to_tensor(words, words_lookup_index, include_eos=True, numbers_replace=True, unknown_replace=True):\\n if type(words) != list: raise Exception(\\\"Expected a list (not a string etc)\\\")\\n tensor_length = len(words) + 1 if include_eos else len(words)\\n # tensor = np.zeros((1, tensor_length, len(words_lookup_index)), dtype=np.float32)\\n tensor = torch.zeros(1, tensor_length, len(words_lookup_index))\\n\\n for i, w in enumerate(words):\\n if w in words_lookup_index:\\n tensor[0, i, words_lookup_index[w]] = 1\\n elif numbers_replace and re_includes_numbers.search(w):\\n tensor[0, i, words_lookup_index[NUMBER_WORD_TOKEN]] = 1\\n elif unknown_replace:\\n tensor[0, i, words_lookup_index[UNKNOWN_WORD_TOKEN]] = 1\\n else:\\n raise Exception(\\\"Did not find item in index\\\")\\n\\n if include_eos:\\n tensor[0, -1, words_lookup_index[EOS_TOKEN]] = 1\\n return tensor\",\n \"def answerer(embeddings, tuples: tf.Variable, scoring=multilinear):\\n n_data, n_slots, rank = [d.value for d in embeddings.get_shape()]\\n n_data, n_tuples, order = [d.value for d in tuples.get_shape()]\\n\\n shift_indices = tf.constant(np.reshape(\\n np.outer(range(n_data), np.ones(n_tuples * n_slots)) * n_slots, (n_data, n_tuples, n_slots)), dtype='int64')\\n questions_shifted = tuples + shift_indices\\n\\n preds = scoring(\\n tf.reshape(embeddings, (n_data * n_slots, rank)),\\n tf.reshape(questions_shifted, (n_data * n_tuples, order)))\\n\\n return tf.reshape(preds, (n_data, n_tuples))\",\n \"def substitute_from_qa3(self, result, index, dataset):\\n question = self\\n if re.search(result.chunk, question):\\n if result.is_dataset(dataset):\\n question = re.sub(result.chunk, '<DATASET>', question)\\n elif result.is_type('refYear'):\\n question = re.sub(result.chunk, '<YEAR' + str(index) + '>', question)\\n elif result.is_identifier():\\n question = re.sub(result.chunk, '<PROP' + str(index) + '>', question)\\n else:\\n question = re.sub(result.chunk, '<VALUE' + str(index) + '>', question)\\n return Qa3Question(question)\",\n \"def additional_text_preprocessing_with_pos(pos_dict):\\n\\n tags_to_lemmatize = ['a', 'n', 'v', 'r']\\n\\n pos_dict = TextPreprocessor.find_named_entities(pos_dict)\\n if pos_dict is None:\\n return None, None\\n prepro = list()\\n contains_spelling_mistake = False\\n for t in pos_dict:\\n token = t['token']\\n tag = t['tag'].lower()\\n if token not in TextPreprocessor.PUNCTUATION and tag != \\\",\\\":\\n\\n token = TextPreprocessor.replace_user_mentions(token)\\n token = TextPreprocessor.replace_urls(token)\\n replaced = [token]\\n for i in replaced:\\n\\n i = TextPreprocessor.replace_all_punctuation(i)\\n if i.lower() not in TextPreprocessor.STOPWORDS and i != 'URL' and i!= 'USERMENTION':\\n if i != \\\"\\\" and not re.match('\\\\B#\\\\w*[a-zA-Z]+\\\\w*', i):\\n before = i\\n i = TextPreprocessor.SPELL_CHECKER.correct(i, tag)\\n if i != before:\\n contains_spelling_mistake = True\\n if tag in tags_to_lemmatize:\\n i = TextPreprocessor.lemmatize(i, tag)\\n i = TextPreprocessor.stem(i, tag)\\n # check again, since stemming, lemmatization or spelling correction can produce stopwords\\n # if i.lower() not in TextPreprocessor.STOPWORDS:\\n if i != 'URL' and i!= 'USERMENTION' and i!='':\\n i = i.lower()\\n if re.match(\\\".*[a-zA-Z]'\\\", i):\\n i = i[:-1]\\n prepro.append(i)\\n return prepro, contains_spelling_mistake\",\n \"def filter_ordered_questions_by_concepts(questions, item_params, target_concept, concept_map): \\n \\n def get_parents(target, concept_map):\\n \\\"\\\"\\\"\\n Given a target concept, return a list of concept IDs for parent concepts\\n \\\"\\\"\\\"\\n parents = []\\n target_index = concept_map[CONCEPTS_STR].index(target)\\n for row in range(len(concept_map[ADJ_MAT_STR])): \\n # get value in adjMat for each row at target concept's col\\n val = concept_map[ADJ_MAT_STR][row][target_index] \\n if val > 0 and target_index != row: # don't care concepts are their own parents\\n # print('parent found at {}, {}'.format(row, target_index)) # TODO remove\\n parents.append(concept_map[CONCEPTS_STR][row])\\n return parents\\n\\n def get_children(target, concept_map):\\n \\\"\\\"\\\"\\n Given a target concept, return a list of concept IDs for all child concepts\\n \\\"\\\"\\\"\\n child_inds = []\\n target_index = concept_map[CONCEPTS_STR].index(target)\\n target_row = concept_map[ADJ_MAT_STR][target_index]\\n for ind in range(len(target_row)): # for each ind in row of adj mat\\n val = target_row[ind]\\n if(val>0 and ind != target_index): # don't care concept is child of itself\\n child_inds.append(ind)\\n return list(map(lambda ind: concept_map[CONCEPTS_STR][ind], child_inds))\\n\\n def get_concept(eid, item_params):\\n \\\"\\\"\\\"\\n Given a question/exercise eid (String) and item_params (pd.DataFrame),\\n return the concept that exercise corresponds to.\\n\\n Assumes eid is unique (maps to exactly 1 row)\\n \\\"\\\"\\\"\\n\\n concept = item_params[item_params[EID]==eid][CONCEPT]\\n\\n if len(concept) < 1: # TODO: make this filter \\\"!= 1\\\" to be more strict\\n raise Exception(\\\"Exercise ID does not map to any exercises. eid: {}\\\".format(eid))\\n else:\\n return concept.iloc[0] # to get actual value\\n \\n df_item_params = pd.DataFrame.from_dict(item_params)\\n\\n rec_eids = []\\n\\n # get all recommendations from target, its children, parents\\n rec_eids += list(filter(lambda q: get_concept(q, df_item_params) in \\n [target_concept] + \\n get_children(target_concept, concept_map) +\\n get_parents(target_concept, concept_map), questions))\\n \\n # # GET TOP FOR EACH RELATIONSHIP\\n # # add max_num_target questions of same concept to rec_eids\\n # rec_target = list(filter(lambda q: get_concept(q, df_item_params) == target_concept, \\n # questions))[:max_num_target]\\n # # print(\\\"For target, added {}\\\".format(rec_target))\\n # rec_eids += rec_target\\n \\n\\n # # add max_num_child questions of child concepts to rec_eids\\n # rec_child = list(filter(lambda q: get_concept(q, df_item_params) in get_children(target_concept, concept_map), \\n # questions))[:max_num_child]\\n # # print(\\\"For children, added {}\\\".format(rec_child ))\\n # rec_eids += rec_child\\n\\n # # add max_num_parent questions of parent concepts to rec_eids\\n # rec_parent = list(filter(lambda q: get_concept(q, df_item_params) in get_parents(target_concept, concept_map), \\n # questions))[:max_num_parent] \\n # # print(\\\"For parents, added {}\\\".format(rec_parent))\\n # rec_eids += rec_parent \\n\\n # want order of recommendations to stay same & only grab from top half of recommendations\\n # return list(filter(lambda eid: eid in rec_eids, questions[:int(len(questions)/2)+1])) \\n\\n # want order of recommendations to stay same\\n return list(filter(lambda eid: eid in rec_eids, questions))\",\n \"def vectorize(ex, model, single_answer=False):\\r\\n word_dict = model.word_dict\\r\\n tgt_dict = model.tgt_dict\\r\\n\\r\\n if model.args.use_elmo:\\r\\n # Index words\\r\\n document = torch.from_numpy(np.asarray(elmo_sent_mapper(ex['document']), dtype=np.int))\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n question = torch.from_numpy(np.asarray(elmo_sent_mapper(ex['question']), dtype=np.int))\\r\\n\\r\\n # When using elmo, char representations are not required\\r\\n document_chars, question_chars = -1, -1\\r\\n else:\\r\\n # Index words\\r\\n document = torch.LongTensor([word_dict[w] for w in ex['document']])\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n question = torch.LongTensor([word_dict[w] for w in ex['question']])\\r\\n\\r\\n # Index chars\\r\\n if model.args.reader_type == 'mlstm' or \\\\\\r\\n model.args.reader_type == 'areader':\\r\\n document_chars, question_chars = -2, -2\\r\\n else:\\r\\n document_chars = torch.LongTensor([word_dict.word_to_char_ids(w).tolist() for w in ex['document']])\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n question_chars = torch.LongTensor([word_dict.word_to_char_ids(w).tolist() for w in ex['question']])\\r\\n\\r\\n # ...or with target(s) (might still be empty if answers is empty)\\r\\n # handle if questions are unanswerable [SQuAD v2.0]\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n \\r\\n if single_answer:\\r\\n assert (len(ex['answers']) > 0)\\r\\n answer = torch.LongTensor([tgt_dict[w] for w in ex['answers'][0]])\\r\\n else:\\r\\n # FIXME: multiple answers are possible, fix batchify also.\\r\\n # answer = [torch.LongTensor([word_dict[w] for w in ans]) for ans in ex['answers']]\\r\\n answer = torch.LongTensor([tgt_dict[w] for w in ex['answers'][0]])\\r\\n else:\\r\\n summary = torch.LongTensor([tgt_dict[w] for w in ex['summary']])\\r\\n\\r\\n\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n return document, document_chars, question, question_chars, answer, \\\\\\r\\n ex['id'], ex['document'], ex['question'], ex['answers'], \\\\\\r\\n ex['src_vocab']\\r\\n else:\\r\\n return document, document_chars, summary, ex['id'], ex['document'], ex['summary'], ex['src_vocab']\",\n \"def own_accuracy(self, questions):\\n ok_vocab = self.get_vocabulary()\\n print(\\\"ok vocab\\\")\\n #print(ok_vocab)\\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\\n print(\\\"not dict\\\")\\n #new_vocab = [w.upper() for w in ok_vocab]\\n #print(new_vocab)\\n new_vocab = {w.upper(): v for w, v in new_vocab}\\n new_vocab = dict(new_vocab)\\n #print(new_vocab)\\n\\n\\n\\n\\n sections, section = [], None\\n wrong_predictions = []\\n for line_no, line in enumerate(utils.smart_open(questions)):\\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\\n line = utils.to_unicode(line)\\n if line.startswith(': '):\\n # a new section starts => store the old section\\n if section:\\n sections.append(section)\\n self.log_accuracy(section)\\n section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}\\n else:\\n if not section:\\n raise ValueError(\\\"missing section header before line #%i in %s\\\" % (line_no, questions))\\n try:\\n a, b, c, expected = [word.upper() for word in line.split()]\\n except ValueError:\\n logger.info(\\\"skipping invalid line #%i in %s\\\", line_no, questions)\\n continue\\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\\n if a not in new_vocab:\\n print(\\\"Dont know: \\\" + a)\\n if b not in new_vocab:\\n print(\\\"Dont know: \\\" + b)\\n if c not in new_vocab:\\n print(\\\"Dont know: \\\" + c)\\n if expected not in new_vocab:\\n print(\\\"Dont know: \\\" + expected)\\n logger.debug(\\\"skipping line #%i with OOV words: %s\\\", line_no, line.strip())\\n continue\\n\\n original_vocab = self.get_vocabulary()\\n self.set_vocabulary(new_vocab)\\n ignore = {a, b, c} # input words to be ignored\\n\\n # find the most likely prediction, ignoring OOV words and input words\\n sims = self.most_similar(positive_words=[b, c], negative_words=[a])\\n #print(\\\"sims\\\")\\n #print(sims)\\n self.set_vocabulary(original_vocab)\\n\\n predicted = sims[0][0]\\n predicted = predicted.upper()\\n #print(predicted)\\n if predicted == expected:\\n section['correct'].append((a, b, c, expected))\\n else:\\n wrong_message = a + \\\" \\\" + b + \\\" \\\" + c + \\\", predicted: \\\" + predicted + \\\", should have been: \\\" + expected\\n section['incorrect'].append((a, b, c, expected))\\n wrong_predictions.append(wrong_message)\\n if section:\\n # store the last section, too\\n sections.append(section)\\n self.log_accuracy(section)\\n\\n total = {\\n 'section': 'total',\\n 'correct': sum((s['correct'] for s in sections), []),\\n 'incorrect': sum((s['incorrect'] for s in sections), []),\\n }\\n self.log_accuracy(total)\\n sections.append(total)\\n print(wrong_predictions)\\n return sections\",\n \"def fix_keyword_detection_issues(\\n dset: List, organ2ind: Dict\\n): \\n \\n \\\"\\\"\\\"SOLVE CARDIA\\\"\\\"\\\" \\n\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if (\\n \\\"cardiac\\\" in keywords\\n and \\\"stomach\\\" in occ_organ_names\\n and any(\\n [\\n item in organ_names\\n for item in [\\\"atrium\\\", \\\"ventricle\\\", \\\"myocardium\\\", \\\"pericardium\\\"]\\n ]\\n )\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"stomach\\\"])\\n occ_organ_names.remove(\\\"stomach\\\")\\n if (\\n \\\"cardia\\\" in keywords\\n and \\\"myocardium\\\" in occ_organ_names\\n and any([item in organ_names for item in [\\\"stomach\\\"]])\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"myocardium\\\"])\\n occ_organ_names.remove(\\\"myocardium\\\")\\n abstract[\\\"occ_organ_indices\\\"] = occ_organ_indices\\n abstract[\\\"occ_organ_names\\\"] = occ_organ_names\\n\\n inds = []\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if \\\"cardiac\\\" in keywords and \\\"stomach\\\" in occ_organ_names:\\n inds.append(ind)\\n\\n \\\"\\\"\\\"SOLVE THE LIVER - DELIVER PROBLEM\\\"\\\"\\\"\\n\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if (\\n any(\\n [\\n keyword in keywords\\n for keyword in [\\\"delivery\\\", \\\"delivered\\\", \\\"deliver\\\", \\\"delivering\\\"]\\n ]\\n )\\n and \\\"liver\\\" not in organ_names\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"liver\\\"])\\n occ_organ_names.remove(\\\"liver\\\")\\n keywords = [\\n keyword\\n for keyword in keywords\\n if keyword not in [\\\"delivery\\\", \\\"delivered\\\", \\\"deliver\\\", \\\"delivering\\\"]\\n ]\\n abstract[\\\"occ_organ_indices\\\"] = occ_organ_indices\\n abstract[\\\"occ_organ_names\\\"] = occ_organ_names\\n abstract[\\\"keywords\\\"] = keywords\\n\\n \\\"\\\"\\\"SOLVE THE COLON - COLONISE PROBLEM\\\"\\\"\\\"\\n\\n inds = []\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if (\\n any(\\n [\\n keyword in keywords\\n for keyword in [\\n \\\"colonize\\\",\\n \\\"colonise\\\",\\n \\\"colonized\\\",\\n \\\"colonised\\\",\\n \\\"colonies\\\",\\n ]\\n ]\\n )\\n and \\\"colon\\\" not in organ_names\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"colon\\\"])\\n occ_organ_names.remove(\\\"colon\\\")\\n keywords = [\\n keyword\\n for keyword in keywords\\n if keyword\\n not in [\\\"colonize\\\", \\\"colonise\\\", \\\"colonized\\\", \\\"colonised\\\", \\\"colonies\\\"]\\n ]\\n abstract[\\\"occ_organ_indices\\\"] = occ_organ_indices\\n abstract[\\\"occ_organ_names\\\"] = occ_organ_names\\n abstract[\\\"keywords\\\"] = keywords\\n\\n \\\"\\\"\\\"SOLVE THE BLADDER - GALLBLADDER PROBLEM\\\"\\\"\\\"\\n\\n \\\"\\\"\\\"Gallbladder doesn't cause the bladder keyword\\\"\\\"\\\"\\n \\\"\\\"\\\"Bladder does cause problems\\\"\\\"\\\"\\n\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if (\\n any([keyword in keywords for keyword in [\\\"bladder\\\", \\\"bladders\\\"]])\\n and any(\\n [\\n keyword in keywords\\n for keyword in [\\n \\\"gall\\\",\\n \\\"gallbladder\\\",\\n \\\"gall-bladder\\\",\\n \\\"gallbladders\\\",\\n \\\"gall-bladders\\\",\\n ]\\n ]\\n )\\n and \\\"gallbladder\\\" in organ_names\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"urinary bladder\\\"])\\n occ_organ_names.remove(\\\"urinary bladder\\\")\\n keywords = [\\n keyword\\n for keyword in keywords\\n if keyword not in [\\\"bladder\\\", \\\"bladders\\\"]\\n ]\\n abstract[\\\"occ_organ_indices\\\"] = occ_organ_indices\\n abstract[\\\"occ_organ_names\\\"] = occ_organ_names\\n abstract[\\\"keywords\\\"] = keywords\\n\\n return dset\",\n \"def _process_row(self, question):\\n\\n # this returns a list, e.g. [('today', 'DATE'), ('Patrick', 'PERSON')]\\n ent_lst = self.text_preprocessor.compute_ner(question.context)\\n\\n ent_dct = {}\\n for ent_str, ner_category in ent_lst:\\n # perform uncasing\\n ent_dct[ent_str.lower()] = ner_category\\n\\n new_answers = []\\n for ans_struct in question.answers:\\n ans_text = ans_struct['text'].lower() # perform uncasing\\n if ans_text not in ent_dct:\\n continue\\n\\n ans_struct['ner_category'] = ent_dct[ans_text]\\n new_answers.append(ans_struct)\\n\\n question.answers = new_answers\\n return question\",\n \"def replace_oov_words_by_unk(tokenized_sentences, vocabulary, unknown_token=\\\"<unk>\\\"):\\r\\n \\r\\n # Place vocabulary into a set for faster search\\r\\n vocabulary = set(vocabulary)\\r\\n \\r\\n # Initialize a list that will hold the sentences\\r\\n # after less frequent words are replaced by the unknown token\\r\\n replaced_tokenized_sentences = []\\r\\n \\r\\n for sentence in tokenized_sentences:\\r\\n \\r\\n\\r\\n replaced_sentence = []\\r\\n\\r\\n for token in sentence: \\r\\n \\r\\n if token in vocabulary:\\r\\n replaced_sentence.append(token)\\r\\n else:\\r\\n replaced_sentence.append(unknown_token)\\r\\n \\r\\n # Append the list of tokens to the list of lists\\r\\n replaced_tokenized_sentences.append(replaced_sentence)\\r\\n \\r\\n return replaced_tokenized_sentences\",\n \"def _compute_question_ids(self):\\n if self._origin.question_ids:\\n # lines to keep: those with already sent emails or registrations\\n questions_tokeep_ids = self.env['event.registration.answer'].search(\\n [('question_id', 'in', self._origin.question_ids.ids)]\\n ).question_id.ids\\n else:\\n questions_tokeep_ids = []\\n for event in self:\\n if not event.event_type_id and not event.question_ids:\\n event.question_ids = False\\n continue\\n\\n if questions_tokeep_ids:\\n questions_toremove = event._origin.question_ids.filtered(lambda question: question.id not in questions_tokeep_ids)\\n command = [(3, question.id) for question in questions_toremove]\\n else:\\n command = [(5, 0)]\\n if event.event_type_id.use_mail_schedule:\\n command += [\\n (0, 0, {\\n 'title': question.title,\\n 'question_type': question.question_type,\\n 'sequence': question.sequence,\\n 'once_per_order': question.once_per_order,\\n 'answer_ids': [(0, 0, {\\n 'name': answer.name,\\n 'sequence': answer.sequence\\n }) for answer in question.answer_ids],\\n }) for question in event.event_type_id.question_ids\\n ]\\n event.question_ids = command\",\n \"def question_new_translate():\",\n \"def special_danish_accuracy(self, questions):\\n ok_vocab = self.get_vocabulary()\\n print(\\\"ok vocab\\\")\\n #print(ok_vocab)\\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\\n print(\\\"not dict\\\")\\n #new_vocab = [w.upper() for w in ok_vocab]\\n #print(new_vocab)\\n new_vocab = {w.upper(): v for w, v in new_vocab}\\n new_vocab = dict(new_vocab)\\n #print(new_vocab)\\n\\n\\n\\n\\n sections, section = [], None\\n wrong_predictions = []\\n for line_no, line in enumerate(utils.smart_open(questions)):\\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\\n line = utils.to_unicode(line)\\n if line.startswith(': '):\\n # a new section starts => store the old section\\n if section:\\n sections.append(section)\\n self.log_accuracy(section)\\n section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}\\n else:\\n if not section:\\n raise ValueError(\\\"missing section header before line #%i in %s\\\" % (line_no, questions))\\n try:\\n a, b, c, d, e, expected = [word.upper() for word in line.split()]\\n except ValueError:\\n logger.info(\\\"skipping invalid line #%i in %s\\\", line_no, questions)\\n continue\\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or d not in new_vocab or e not in new_vocab or expected not in new_vocab:\\n #print('not in vocab')\\n logger.debug(\\\"skipping line #%i with OOV words: %s\\\", line_no, line.strip())\\n continue\\n\\n original_vocab = self.get_vocabulary()\\n self.set_vocabulary(new_vocab)\\n ignore = {a, b, c, d, e} # input words to be ignored\\n\\n # find the most likely prediction, ignoring OOV words and input words\\n sims = self.most_similar(positive_words=[c, d, e], negative_words=[a, b])\\n #print(\\\"sims\\\")\\n #print(sims)\\n self.set_vocabulary(original_vocab)\\n\\n predicted = sims[0][0]\\n predicted = predicted.upper()\\n #print(predicted)\\n if predicted == expected:\\n section['correct'].append((a, b, c, d, e, expected))\\n else:\\n wrong_message = a + \\\" \\\" + b + \\\" \\\" + c + \\\" \\\" + d + \\\" \\\" + e + \\\", predicted: \\\" + predicted + \\\", should have been: \\\" + expected\\n section['incorrect'].append((a, b, c, d, e, expected))\\n wrong_predictions.append(wrong_message)\\n if section:\\n # store the last section, too\\n sections.append(section)\\n self.log_accuracy(section)\\n\\n total = {\\n 'section': 'total',\\n 'correct': sum((s['correct'] for s in sections), []),\\n 'incorrect': sum((s['incorrect'] for s in sections), []),\\n }\\n self.log_accuracy(total)\\n sections.append(total)\\n print(wrong_predictions)\\n return sections\",\n \"def _tokenize_replace_pos(text, language_code, replace_pos):\\n seq = annotool.raw2basicseq(text, language_code, pos=True)\\n word_seq = seq['word']\\n pos_seq = seq['pos']\\n for i, pos in enumerate(pos_seq):\\n if pos in replace_pos:\\n word_seq[i] = '[{}]'.format(pos)\\n return word_seq\",\n \"def encode_answers(df, schema):\\n encoders = get_encoders(schema)\\n\\n for question in schema.questions:\\n df[question.prediction_encoded] = encoders[question.name].transform(df[question.prediction])\\n\\n return df\",\n \"def encode_decode_TD(self, n_step, idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ ):\\r\\n\\r\\n actor_embedding = embed_seq(input_seq=self.input_, from_=self.dimension, to_= self.input_embed, is_training=self.is_training, BN=True, initializer=self.initializer)\\r\\n actor_encoding = encode_seq(input_seq=actor_embedding, input_dim=self.input_embed, num_stacks=self.num_stacks, num_heads=self.num_heads, num_neurons=self.num_neurons, is_training=self.is_training)\\r\\n \\r\\n if self.is_training == False:\\r\\n actor_encoding = tf.tile(actor_encoding,[self.batch_size,1,1])\\r\\n \\r\\n idx_list = copy(idx_list_previous)\\r\\n log_probs = copy(log_probs_previous)\\r\\n entropies = copy(entropies_previous)\\r\\n \\r\\n\\r\\n mask = copy(mask_previous)\\r\\n \\r\\n n_hidden = actor_encoding.get_shape().as_list()[2] # input_embed\\r\\n W_ref = tf.get_variable(\\\"W_ref\\\",[1, n_hidden, self.num_units],initializer=self.initializer)\\r\\n W_q = tf.get_variable(\\\"W_q\\\",[self.query_dim, self.num_units],initializer=self.initializer)\\r\\n v = tf.get_variable(\\\"v\\\",[self.num_units],initializer=self.initializer)\\r\\n \\r\\n encoded_ref = tf.nn.conv1d(actor_encoding, W_ref, 1, \\\"VALID\\\") # actor_encoding is the ref for actions [Batch size, seq_length, n_hidden]\\r\\n \\r\\n query1 = copy( query1_previous)\\r\\n query2 = copy( query2_previous)\\r\\n query3 = copy( query3_previous)\\r\\n idx_copy = copy(idx_)\\r\\n \\r\\n W_1 =tf.get_variable(\\\"W_1\\\",[n_hidden, self.query_dim],initializer=self.initializer) # update trajectory (state)\\r\\n W_2 =tf.get_variable(\\\"W_2\\\",[n_hidden, self.query_dim],initializer=self.initializer)\\r\\n W_3 =tf.get_variable(\\\"W_3\\\",[n_hidden, self.query_dim],initializer=self.initializer)\\r\\n \\r\\n \\r\\n \\\"\\\"\\\"\\r\\n # sample from POINTER from the perspective of the Actor\\r\\n \\\"\\\"\\\"\\r\\n for step in range(n_step + 1 ): \\r\\n query = tf.nn.relu(tf.matmul(query1, W_1) + tf.matmul(query2, W_2) + tf.matmul(query3, W_3))\\r\\n logits = pointer(encoded_ref=encoded_ref, query=query, mask=mask, W_ref=W_ref, W_q=W_q, v=v, C=config.C, temperature=config.temperature)\\r\\n prob = distr.Categorical(logits) # logits = masked_scores\\r\\n idx = prob.sample()\\r\\n\\r\\n idx_list.append(idx) # tour index\\r\\n idx_list_previous.append(idx)\\r\\n \\r\\n log_probs.append(prob.log_prob(idx)) # log prob\\r\\n log_probs_previous.append(prob.log_prob(idx))\\r\\n \\r\\n entropies.append(prob.entropy()) # entropies\\r\\n entropies_previous.append(prob.entropy())\\r\\n \\r\\n mask = mask + tf.one_hot(idx, self.max_length) # mask\\r\\n mask_previous = mask_previous + tf.one_hot(idx, self.max_length)\\r\\n\\r\\n idx_copy = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \\r\\n idx_ = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \\r\\n query3 = query2\\r\\n query2 = query1\\r\\n query1 = tf.gather_nd(actor_encoding, idx_) # update trajectory (state)\\r\\n \\r\\n query3_previous = query2_previous\\r\\n query2_previous = query1_previous\\r\\n query1_previous = tf.gather_nd(actor_encoding, idx_) # update trajectory (state) \\r\\n\\r\\n if (len(idx_list) >= self.max_length): break #leave the loop if reach the end of the episode\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n # sample from POINTER from the perspective of the Critic\\r\\n make q_t vector = 0\\r\\n \\\"\\\"\\\"\\r\\n while(len(idx_list) < self.max_length): \\r\\n \\r\\n logits = pointer_critic(encoded_ref=encoded_ref, mask=mask, W_ref=W_ref, v=v, C=config.C, temperature=config.temperature)\\r\\n prob = distr.Categorical(logits) # logits = masked_scores\\r\\n idx = prob.sample()\\r\\n\\r\\n idx_list.append(idx) # tour index\\r\\n log_probs.append(prob.log_prob(idx)) # log prob\\r\\n entropies.append(prob.entropy()) # entropies\\r\\n mask = mask + tf.one_hot(idx, self.max_length) # mask\\r\\n\\r\\n idx_copy = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \\r\\n #idx_ = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \\r\\n query3 = query2\\r\\n query2 = query1\\r\\n query1 = tf.gather_nd(actor_encoding, idx_copy) # update trajectory (state)\\r\\n \\r\\n idx_list.append(idx_list[0]) # return to start\\r\\n self.tour =tf.stack(idx_list, axis=1) # permutations\\r\\n self.log_prob = tf.add_n(log_probs) # corresponding log-probability for backprop\\r\\n self.entropies = tf.add_n(entropies)\\r\\n tf.summary.scalar('log_prob_mean', tf.reduce_mean(self.log_prob))\\r\\n tf.summary.scalar('entropies_mean', tf.reduce_mean(self.entropies))\\r\\n \\r\\n return idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ #returns variables necessary for the next loop\\r\",\n \"def map_question_linked_abstracts(include_no_abstracts):\\r\\n\\tif load_common_map():\\r\\n\\t\\treturn\\r\\n\\t\\t\\r\\n\\tglobal question_map, abstract_map, common_map\\r\\n\\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict\\r\\n\\r\\n\\tprint('\\\\nmapping question to answers')\\r\\n\\t\\r\\n\\tcommon_map = collections.defaultdict(list)\\r\\n\\t\\r\\n\\tno_abstract_count = 0\\r\\n\\t\\t\\r\\n\\tfor i,v in question_map.items():\\r\\n\\t\\tprint(i)\\r\\n\\t\\tabstracts = linked_abstracts_dict[i]\\r\\n\\t\\tfor a in abstracts:\\r\\n\\t\\t\\tif (a != 'NO_ABSTRACT') and (a in abstract_map.keys()):\\r\\n\\t\\t\\t\\tcommon_map[i].append([v,abstract_map[a]])\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tif include_no_abstracts:\\r\\n\\t\\t\\t\\t\\tcommon_map[i].append([v,()])\\r\\n\\t\\t\\t\\tno_abstract_count += 1\\r\\n\\t\\r\\n\\tprint('\\\\nabstractless : ' + str(no_abstract_count))\\r\\n\\t\\r\\n\\tprint(len(question_map))\\r\\n\\tprint(len(abstract_map))\\r\\n\\tprint(len(common_map))\\r\\n\\t\\r\\n\\tpickle.dump(common_map,open(paths.path_data_map_common_pickle,\\\"wb\\\"))\",\n \"def set_encodings(questions, candidates,\\n question_encoder, response_encoder):\\n for i, chunk in enumerate(chunks(questions, 100)):\\n question_strs = [q.question for q in chunk]\\n question_encodings = np.array(question_encoder(question_strs))\\n\\n for j in range(question_encodings.shape[0]):\\n questions[i * 100 + j].encoding = question_encodings[j]\\n if i % 50 == 0:\\n print(\\\"Questions: encoded %s of %s...\\\" % (i * 100, len(questions)))\\n\\n for i, chunk in enumerate(chunks(candidates, 50)):\\n candidate_strs = [(c.sentence, c.context) for c in chunk]\\n candidate_encodings = np.array(response_encoder(candidate_strs))\\n for j in range(candidate_encodings.shape[0]):\\n candidates[i * 50 + j].encoding = candidate_encodings[j]\\n if i % 100 == 0:\\n print(\\\"Candidates: encoded %s of %s...\\\" % (i * 50, len(candidates)))\",\n \"def match(self, passage_encodes, question_encodes, p_length, q_length):\\n with tf.variable_scope('bidaf'):\\n if self.use_complex_s:\\n p_length=tf.shape(passage_encodes)[1]\\n q_length=tf.shape(question_encodes)[1]\\n hp=tf.tile(tf.expand_dims(passage_encodes,2),[1,1,q_length,1])\\n hq=tf.tile(tf.expand_dims(question_encodes,1),[1,p_length,1,1])\\n fusion=tf.concat([hp,hq,hp*hq],-1)\\n sim_matrix=tf.squeeze(tf.contrib.layers.fully_connected(fusion,num_outputs=1,activation_fn=None),-1)\\n else:\\n sim_matrix = tf.matmul(passage_encodes, question_encodes, transpose_b=True)\\n context2question_attn = tf.matmul(tf.nn.softmax(sim_matrix, -1), question_encodes)\\n b = tf.nn.softmax(tf.expand_dims(tf.reduce_max(sim_matrix, 2), 1), -1)\\n question2context_attn = tf.tile(tf.matmul(b, passage_encodes),\\n [1, tf.shape(passage_encodes)[1], 1])\\n concat_outputs = tf.concat([passage_encodes, context2question_attn,\\n passage_encodes * context2question_attn,\\n passage_encodes * question2context_attn], -1)\\n return concat_outputs, None\",\n \"def combine_corpus(include_whole_abstracts=False):\\r\\n\\tif load_combined_corpus_maps():\\r\\n\\t\\treturn\\r\\n\\t\\r\\n\\tglobal gensim_dictionary\\r\\n\\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict, abstracts_dict\\r\\n\\tglobal common_corpus_list, question_map, abstract_map, abstract_whole_map\\r\\n\\tglobal corpus_layout\\r\\n\\t\\r\\n\\tprint('\\\\nbuilding common corpus')\\r\\n\\t\\r\\n\\tcommon_corpus_list = list()\\r\\n\\tquestion_map = dict()\\r\\n\\tabstract_map = dict()\\r\\n\\tabstract_whole_map = dict()\\r\\n\\t\\r\\n\\tsentence_count = 0\\r\\n\\t\\r\\n\\tcorpus_layout = []\\r\\n\\t\\r\\n\\tfor qi,qv in search_criteria_dict.items():\\r\\n\\t\\tquestions = qv\\r\\n\\t\\t\\r\\n\\t\\tsentence_incr = len(questions)\\r\\n\\t\\tquestion_map[qi] = (sentence_count,sentence_count + sentence_incr)\\r\\n\\t\\tsentence_count += sentence_incr\\r\\n\\t\\t\\r\\n\\t\\tfor st in questions:\\r\\n\\t\\t\\tcommon_corpus_list.append(st)\\r\\n\\t\\r\\n\\tcorpus_layout.append(('Q',sentence_count))\\r\\n\\t\\r\\n\\tfor ai,av in abstracts_dict.items():\\r\\n\\t\\tabstract = av\\r\\n\\t\\t\\r\\n\\t\\tsentence_incr = len(abstract)\\r\\n\\t\\tabstract_map[ai] = (sentence_count,sentence_count + sentence_incr)\\r\\n\\t\\tsentence_count += sentence_incr\\r\\n\\r\\n\\t\\tfor st in abstract:\\r\\n\\t\\t\\tcommon_corpus_list.append(st)\\r\\n\\t\\r\\n\\tcorpus_layout.append(('A',sentence_count))\\r\\n\\r\\n\\tif include_whole_abstracts:\\r\\n\\t\\tfor ai,av in abstracts_dict.items():\\r\\n\\t\\t\\tabstract = av\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tabstract_whole_map[ai] = (sentence_count,sentence_count + 1)\\r\\n\\t\\t\\tsentence_count += 1\\r\\n\\r\\n\\t\\t\\tst = tuple('\\\\n'.join(s) for s in zip(*abstract))\\r\\n\\t\\t\\tif len(st) < 2:\\r\\n\\t\\t\\t\\tst = ('','')\\r\\n\\r\\n\\t\\t\\tcommon_corpus_list.append(st)\\r\\n\\t\\t\\r\\n\\t\\tcorpus_layout.append(('W',sentence_count))\\r\\n\\t\\r\\n\\tpickle.dump(question_map,open(paths.path_data_map_questions_pickle,\\\"wb\\\"))\\r\\n\\tpickle.dump(abstract_map,open(paths.path_data_map_abstracts_pickle,\\\"wb\\\"))\\r\\n\\tpickle.dump(abstract_whole_map,open(paths.path_data_map_abstracts_whole_pickle,\\\"wb\\\"))\\t\\r\\n\\tpickle.dump(common_corpus_list,open(paths.path_data_corpus_pickle,\\\"wb\\\"))\\r\\n\\tpickle.dump(corpus_layout,open(paths.path_data_corpus_layout_pickle,\\\"wb\\\"))\",\n \"def preprocess(self, df, maxlen = 169):\\n \\n vocabs = self.tk.word_index.keys()\\n \\n df1 = self.treat_na(df)\\n df2 = self.remove_punc_sw(df1)\\n df3 = self.remove_numbers(df2)\\n df4 = self.lemma_pos(df3)\\n df5 = self.bigram(df4)\\n df6 = self.combine_bigrams(df5)\\n \\n new_docs = []\\n \\n for word_list in df6:\\n \\n if len(word_list) == 2 and word_list[0].lower() == 'noinfo' and word_list[1].lower() == 'noinfo':\\n new_docs.append(list(np.zeros(maxlen)))\\n \\n else:\\n new_word_list = []\\n for word in word_list:\\n if word not in vocabs:\\n word = 'UNKNOWN_TOKEN'\\n new_word_list.append(word)\\n \\n sequence = \\\" \\\".join(new_word_list)\\n vectors = self.tk.texts_to_sequences([sequence])\\n padded_vectors = pad_sequences(vectors, maxlen=maxlen, padding='post', truncating='post')\\n \\n new_docs.append(list(padded_vectors[0]))\\n \\n return new_docs\",\n \"def disambiguate_all_not_disambiguated(\\n celery_batch_size, total_records, indexing_queue_limit, disambiguation_queue_limit\\n):\\n with current_celery_app.connection_or_acquire() as conn:\\n indexer_queue = conn.default_channel.queue_declare(\\n queue=\\\"indexer_task\\\", passive=True\\n )\\n disambiguation_queue = conn.default_channel.queue_declare(\\n queue=\\\"disambiguation\\\", passive=True\\n )\\n if (\\n disambiguation_queue.message_count > disambiguation_queue_limit\\n or indexer_queue.message_count > indexing_queue_limit\\n ):\\n click.echo(\\\"MQ queues are full, can't run disambiguation\\\")\\n return\\n not_disambiguated_records_search = _get_all_not_disambiguated_records_search()\\n documents = not_disambiguated_records_search.scan()\\n if total_records:\\n documents = islice(documents, total_records)\\n uuids = (document.meta.id for document in documents)\\n _send_celery_group_disambiguation_task(uuids, celery_batch_size)\",\n \"def rewritten_queries(question):\\n # rewrites = []\\n # tq = tokenize(question)\\n # verb = tq[1] # 目前只处理 谁是XXX类 问题\\n # rewrites.append(\\n # RewrittenQuery(\\\"\\\\\\\"%s %s\\\\\\\"\\\" % (verb, \\\" \\\".join(tq[2:])),\\n # QUOTED_QUERY_SCORE))\\n # for j in range(2, len(tq)):\\n # rewrites.append(\\n # RewrittenQuery(\\n # \\\"\\\\\\\"%s %s %s\\\\\\\"\\\" % (\\n # \\\" \\\".join(tq[2:j + 1]), verb, \\\" \\\".join(tq[j + 1:])),\\n # QUOTED_QUERY_SCORE))\\n # rewrites.append(RewrittenQuery(\\\" \\\".join(tq[2:]), UNQUOTED_QUERY_SCORE))\\n return [RewrittenQuery(question, 1)]\",\n \"def w_question(analysis):\\n if analysis.sv:\\n #Opinion is a what question so we have to make some changes\\n if analysis.sv[0].vrb_main[0].endswith('like'):\\n verb = analysis.sv[0].vrb_main[0]\\n analysis.sv[0].vrb_main[0] = verb[:len(verb) - 4] + 'think+of'\\n\\n #processing as yes or no question\\n phrase = y_o_question(analysis)\\n\\n #Specific processing for invitation\\n if analysis.aim == 'invitation':\\n return ['how', 'about'] + phrase[1:]\\n\\n #Specific processing for classification\\n if analysis.aim.startswith('classification'):\\n aim_question = other_functions.list_rebuilding(analysis.aim)\\n return ['what', 'kind', 'of'] + aim_question[1:] + phrase\\n\\n #It is an how question\\n if other_functions.is_an_adj(analysis.aim) == 1:\\n return ['how'] + [analysis.aim] + phrase\\n elif analysis.aim == 'manner':\\n return ['how'] + phrase\\n\\n if analysis.aim == 'thing' or analysis.aim == 'situation' or analysis.aim == 'explication' or analysis.aim == 'opinion':\\n return ['what'] + phrase\\n return ['what'] + [analysis.aim] + phrase\",\n \"def auto_corr(sent, target_pos):\\n for pos in target_pos:\\n target_v = None\\n t0 = time.time()\\n if len(sent) > 1:\\n context_v = model.context2vec(sent, pos) \\n context_v = context_v / xp.sqrt((context_v * context_v).sum())\\n else:\\n context_v = None\\n\\n if target_v is not None and context_v is not None:\\n similarity = mult_sim(w, target_v, context_v)\\n else:\\n if target_v is not None:\\n v = target_v\\n elif context_v is not None:\\n v = context_v \\n else:\\n raise Exception(\\\"Can't find a target nor context.\\\") \\n similarity = (w.dot(v)+1.0)/2 # Cosine similarity can be negative, mapping similarity to [0,1]\\n\\n old_word = sent[pos]\\n if STATE == 'manual':\\n print \\\"\\\\n>> For the correction of word: \\\", old_word\\n print \\\">>>> Calculating the candidates ... ...\\\"\\n candidats = candidates(old_word)\\n\\n l = []\\n count = 0\\n\\n if len(candidats)!=0:\\n for i in (-similarity).argsort():\\n if index2word[i] not in candidats:\\n continue\\n else:\\n count += 1\\n if STATE == 'manual':\\n print \\\"candidate %d:\\\\t\\\"%count, index2word[i], \\\", similarity:\\\\t\\\", similarity[i]\\n l.append(i)\\n if count == N_RESULT:\\n break \\n else:\\n for i in (-similarity).argsort():\\n if np.isnan(similarity[i]):\\n continue\\n #print sent[pos], index2word[i]\\n dist = levenshtein(index2word[i], sent[pos])\\n if dist <= LEVEN_DIST:\\n count += 1\\n if STATE == 'manual':\\n print \\\"candidate %d:\\\\t\\\"%count, index2word[i],\\\", similarity:\\\\t\\\", similarity[i], \\\", levenshtein distance:\\\\t\\\", dist\\n l.append(i)\\n if count == N_RESULT:\\n break \\n if len(l) == 0:\\n continue\\n \\n if STATE == 'manual':\\n print \\\"Time: %.2fs\\\"%(time.time()-t0)\\n print \\\"Please choose the replacement, enter the number of the candidate: (Enter 0 for no replacement)\\\"\\n choice = six.moves.input('>> ')\\n c = int(choice)\\n if c == 0:\\n continue # no change made\\n elif c > 0:\\n idx = l[c - 1]\\n else:\\n raise Exception(\\\"Invalid input!\\\") \\n elif STATE == 'auto':\\n idx = l[0]\\n corr_word = index2word[idx]\\n\\n \\n print \\\">>>> \\\\t\\\", old_word, \\\"\\\\t--->\\\\t\\\", corr_word\\n sent[pos] = corr_word\\n return sent\",\n \"def generate_question_inter(path):\\n\\n\\t# Function to compute vocabulary intersection\\n\\tdef q1_q2_intersect(row):\\n\\t return(len(set(q_dict[row['question1']]).intersection(set(q_dict[row['question2']]))))\\n\\n\\t# Load training and test set\\n\\ttrain_orig =pd.read_csv(os.path.join(path,'train.csv'), sep=',',names = [\\\"id\\\", \\\"qid1\\\", \\\"qid2\\\", \\\"question1\\\",\\\"question2\\\",\\\"is_duplicate\\\"])\\n\\ttest_orig = pd.read_csv(os.path.join(path,'test.csv'), sep=',',names = [\\\"id\\\", \\\"qid1\\\", \\\"qid2\\\", \\\"question1\\\",\\\"question2\\\"])\\n\\n\\t# Concatenation\\n\\tques = pd.concat([train_orig[['question1', 'question2']], test_orig[['question1', 'question2']]], axis=0).reset_index(drop='index')\\n\\n\\n\\tq_dict = defaultdict(set)\\n\\tfor i in range(ques.shape[0]):\\n\\t q_dict[ques.question1[i]].add(ques.question2[i])\\n\\t q_dict[ques.question2[i]].add(ques.question1[i])\\n\\n\\t# Compute vocabulary intersection\\n\\ttrain_orig['q1_q2_intersect'] = train_orig.apply(q1_q2_intersect, axis=1, raw=True)\\n\\ttest_orig['q1_q2_intersect'] = test_orig.apply(q1_q2_intersect, axis=1, raw=True)\\n\\n\\ttrain_feat = train_orig[['q1_q2_intersect']]\\n\\ttest_feat = test_orig[['q1_q2_intersect']]\\n\\n\\tprint('Writing train features...')\\n\\ttrain_feat.to_csv(os.path.join(path,'train_question_inter.csv'))\\n\\n\\tprint('Writing test features...') \\n\\ttest_feat.to_csv(os.path.join(path,'test_question_inter.csv'))\\n\\n\\tprint('CSV written ! see: ', path, \\\" | suffix: \\\", \\\"_question_inter.csv\\\")\",\n \"def find_explanation_regression_based(user_question_list, global_patterns, global_patterns_dict,\\n cat_sim, num_dis_norm, agg_col, conn, cur, pat_table_name, res_table_name):\\n answer = [[] for i in range(len(user_question_list))]\\n local_pattern_loading_time = 0\\n question_validating_time = 0\\n score_computing_time = 0\\n score_computing_time_list = []\\n local_patterns_list = []\\n\\n for j, uq in enumerate(user_question_list):\\n dir = uq['dir']\\n topK_heap = TopkHeap(ExplConfig.TOP_K)\\n marked = {}\\n\\n t = dict(uq['target_tuple'])\\n\\n uq['global_patterns'] = find_patterns_relevant(\\n global_patterns_dict, uq['target_tuple'], conn, cur, res_table_name, pat_table_name, cat_sim)\\n\\n top_k_lists = [[] for i in range(len(uq['global_patterns']))]\\n local_patterns = []\\n\\n ExplConfig.VISITED_DICT = dict()\\n score_computing_start = time.time()\\n\\n for i in range(0, len(uq['global_patterns'])):\\n top_k_lists[i] = [4, uq['global_patterns'][i], t, []]\\n local_patterns.append(None)\\n F_key = str(sorted(uq['global_patterns'][i][0]))\\n V_key = str(sorted(uq['global_patterns'][i][1]))\\n pat_key = F_key + '|,|' + V_key + '|,|' + uq['global_patterns'][i][2] + '|,|' + uq['global_patterns'][i][3]\\n if pat_key in ExplConfig.VISITED_DICT:\\n continue\\n ExplConfig.VISITED_DICT[pat_key] = True\\n\\n tF = get_F_value(uq['global_patterns'][i][0], t)\\n local_pattern_query_fixed = '''SELECT * FROM {} \\n WHERE array_to_string(fixed, ', ')='{}' AND \\n REPLACE(array_to_string(fixed_value, ', '), '.0', '')='{}' AND\\n array_to_string(variable, ', ')='{}' AND \\n agg='{}' AND model='{}'\\n ORDER BY theta;\\n '''.format(\\n pat_table_name + '_local',\\n str(uq['global_patterns'][i][0]).replace(\\\"\\\\'\\\", '').replace('[', '').replace(']', ''),\\n str(tF)[1:-1].replace(\\\"\\\\'\\\", ''),\\n str(uq['global_patterns'][i][1]).replace(\\\"\\\\'\\\", '').replace('[', '').replace(']', ''),\\n uq['global_patterns'][i][2], uq['global_patterns'][i][3]\\n )\\n cur.execute(local_pattern_query_fixed)\\n res_fixed = cur.fetchall()\\n\\n if len(res_fixed) == 0:\\n continue\\n\\n local_patterns[i] = res_fixed[0]\\n T_set = set(t.keys()).difference(set(['lambda', uq['global_patterns'][i][2]]))\\n agg_col = local_patterns[i][3]\\n start = time.time()\\n t_t_list, agg_range, t_t_dict = get_tuples_by_F_V(local_patterns[i], local_patterns[i],\\n get_F_value(local_patterns[i][0], t),\\n # [get_V_value(local_patterns[i][2], t), [[-3, 3]]],\\n None,\\n conn, cur, res_table_name, cat_sim)\\n\\n dist_lb = 1e10\\n dev_ub = 0\\n for t_t in t_t_list:\\n if compare_tuple(t_t, t) == 0:\\n s = score_of_explanation(t_t, t, cat_sim, num_dis_norm, dir, t_t[agg_col], local_patterns[i],\\n local_patterns[i])\\n if str(t_t) not in marked:\\n marked[str(t_t)] = True\\n topK_heap.Push(Explanation(0, s[0], s[1], s[2], s[3], uq['dir'],\\n # list(map(lambda y: y[1], sorted(t_t.items(), key=lambda x: x[0]))),\\n dict(t_t),\\n ExplConfig.TOP_K, local_patterns[i], None))\\n\\n top_k_lists[i][-1].append(Explanation(0, s[0], s[1], s[2], s[3], uq['dir'],\\n dict(t_t),\\n ExplConfig.TOP_K, local_patterns[i], None))\\n if s[-1] < dist_lb:\\n dist_lb = s[-1]\\n # use raw distance (without penalty on missing attributes) as the lower bound\\n if abs(s[2]) > dev_ub:\\n dev_ub = abs(s[2])\\n if dist_lb < 1e-10:\\n dist_lb = 0.01\\n\\n end = time.time()\\n question_validating_time += end - start\\n\\n F_set = set(local_patterns[i][0])\\n V_set = set(local_patterns[i][2])\\n\\n # F union V \\\\subsetneq G\\n t_coarser_copy = list(t_t_list)\\n norm_lb = min(list(map(lambda x: x[agg_col], t_coarser_copy)))\\n\\n k_score = topK_heap.MinValue()\\n # prune\\n if topK_heap.HeapSize() == ExplConfig.TOP_K and 100 * float(dev_ub) / (dist_lb * float(norm_lb)) <= k_score:\\n continue\\n top_k_lists[i][-1] += DrillDown(global_patterns_dict, local_patterns[i],\\n F_set, T_set.difference(F_set.union(V_set)), V_set, t_coarser_copy,\\n t_coarser_copy, t, t,\\n conn, cur, pat_table_name, res_table_name, cat_sim, num_dis_norm,\\n dir, uq['query_result'],\\n norm_lb, dist_lb, topK_heap)\\n for tk in top_k_lists[i][-1]:\\n if str(tk.tuple_value) not in marked:\\n marked[str(tk.tuple_value)] = True\\n topK_heap.Push(tk)\\n\\n score_computing_end = time.time()\\n score_computing_time_cur_uq = score_computing_end - score_computing_start\\n\\n answer[j] = topK_heap.TopK()\\n score_computing_time_list.append([t, score_computing_time_cur_uq])\\n\\n print('Local pattern loading time: ' + str(local_pattern_loading_time) + 'seconds')\\n print('Score computing time: ' + str(score_computing_time) + 'seconds')\\n return answer, local_patterns_list, score_computing_time_list\",\n \"def convert_examples_to_features(examples, tokenizer, max_seq_length,\\n doc_stride, max_query_length, return_answers, skip_no_answer,\\n verbose=False, save_with_prob=False, msg=\\\"Converting examples\\\"):\\n\\n unique_id = 1000000000\\n features = []\\n question_features = []\\n\\n for (example_index, example) in enumerate(tqdm(examples, desc=msg)):\\n\\n # Tokenize query into (sub)tokens\\n query_tokens = tokenizer.tokenize(example.question_text)\\n if len(query_tokens) > max_query_length:\\n query_tokens = query_tokens[0:max_query_length]\\n\\n # Creating a map between word <=> (sub)token\\n tok_to_word_index = []\\n word_to_tok_index = [] # word to (start of) subtokens\\n all_doc_tokens = []\\n for (i, word) in enumerate(example.doc_words):\\n word_to_tok_index.append(len(all_doc_tokens))\\n sub_tokens = tokenizer.tokenize(word)\\n for sub_token in sub_tokens:\\n tok_to_word_index.append(i)\\n all_doc_tokens.append(sub_token)\\n\\n # The -2 accounts for [CLS], [SEP]\\n max_tokens_for_doc = max_seq_length - 2\\n\\n # Split sequence by max_seq_len with doc_stride, _DocSpan is based on tokens without [CLS], [SEP]\\n _DocSpan = collections.namedtuple( # pylint: disable=invalid-name\\n \\\"DocSpan\\\", [\\\"start\\\", \\\"length\\\"])\\n doc_spans = []\\n start_tok_offset = 0 # From all_doc_tokens\\n\\n # Get doc_spans with stride and offset\\n while start_tok_offset < len(all_doc_tokens):\\n length = len(all_doc_tokens) - start_tok_offset\\n if length > max_tokens_for_doc:\\n length = max_tokens_for_doc\\n doc_spans.append(_DocSpan(start=start_tok_offset, length=length))\\n if start_tok_offset + length == len(all_doc_tokens):\\n break\\n start_tok_offset += min(length, doc_stride) # seems to prefer doc_stride always\\n assert doc_stride < length, \\\"length is no larger than doc_stride for {}\\\".format(doc_spans)\\n\\n # Iterate each doc_span and make out_tokens\\n for (doc_span_index, doc_span) in enumerate(doc_spans):\\n\\n # Find answer position based on new out_tokens\\n start_position = None\\n end_position = None\\n\\n # For no_answer, same (-1, -1) applies\\n if example.start_position is not None and example.start_position < 0:\\n assert example.start_position == -1 and example.end_position == -1\\n start_position, end_position = NO_ANS, NO_ANS\\n\\n # For existing answers, find answers if exist\\n elif return_answers:\\n\\n # Get token-level start/end position\\n tok_start_position = word_to_tok_index[example.start_position]\\n if example.end_position < len(example.doc_words) - 1:\\n tok_end_position = word_to_tok_index[example.end_position + 1] - 1 # By backwarding from next word\\n else:\\n assert example.end_position == len(example.doc_words) - 1\\n tok_end_position = len(all_doc_tokens) - 1\\n\\n # Improve answer span by subword-level\\n (tok_start_position, tok_end_position) = _improve_answer_span(\\n all_doc_tokens, tok_start_position, tok_end_position, tokenizer,\\n example.orig_answer_text)\\n\\n # Throw away training samples without answers (due to doc_span split)\\n doc_start = doc_span.start\\n doc_end = doc_span.start + doc_span.length - 1\\n if (tok_start_position < doc_start or tok_end_position < doc_start or\\n tok_start_position > doc_end or tok_end_position > doc_end):\\n if skip_no_answer:\\n continue\\n else:\\n # For NQ, only add this in 2% (50 times downsample)\\n if save_with_prob:\\n if np.random.randint(100) < 2:\\n start_position, end_position = NO_ANS, NO_ANS\\n else:\\n continue\\n else:\\n start_position, end_position = NO_ANS, NO_ANS\\n\\n # Training samples with answers\\n else:\\n doc_offset = 1 # For [CLS]\\n start_position = tok_start_position - doc_start + doc_offset\\n end_position = tok_end_position - doc_start + doc_offset\\n assert start_position >= 0 and end_position >= 0, (start_position, end_position)\\n\\n out_tokens = [] # doc\\n out_tokens_ = [] # quesry\\n out_tokens.append(\\\"[CLS]\\\")\\n out_tokens_.append(\\\"[CLS]\\\")\\n token_to_word_map = {} # The difference with tok_to_word_index is it includes special tokens\\n token_is_max_context = {}\\n\\n # For query tokens, just copy and add [SEP]\\n for token in query_tokens:\\n out_tokens_.append(token)\\n out_tokens_.append(\\\"[SEP]\\\")\\n\\n # For each doc token, create token_to_word_map and is_max_context, and add to out_tokens\\n for i in range(doc_span.length):\\n split_token_index = doc_span.start + i\\n token_to_word_map[len(out_tokens)] = tok_to_word_index[split_token_index]\\n is_max_context = _check_is_max_context(doc_spans, doc_span_index, split_token_index)\\n token_is_max_context[len(out_tokens)] = is_max_context\\n out_tokens.append(all_doc_tokens[split_token_index])\\n out_tokens.append(\\\"[SEP]\\\")\\n\\n # Convert to ids and masks\\n input_ids = tokenizer.convert_tokens_to_ids(out_tokens)\\n input_ids_ = tokenizer.convert_tokens_to_ids(out_tokens_)\\n input_mask = [1] * len(input_ids)\\n input_mask_ = [1] * len(input_ids_)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n while len(input_ids_) < max_query_length + 2: # +2 for [CLS], [SEP]\\n input_ids_.append(0)\\n input_mask_.append(0)\\n assert len(input_ids_) == max_query_length + 2\\n assert len(input_mask_) == max_query_length + 2\\n\\n # Printing for debug\\n if example_index < 1 and verbose:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"unique_id: %s\\\" % (unique_id))\\n logger.info(\\\"example_index: %s\\\" % (example_index))\\n logger.info(\\\"doc_span_index: %s\\\" % (doc_span_index))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in out_tokens]))\\n logger.info(\\\"q tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in out_tokens_]))\\n logger.info(\\\"token_to_word_map: %s\\\" % \\\" \\\".join(\\n [\\\"%d:%d\\\" % (x, y) for (x, y) in six.iteritems(token_to_word_map)]))\\n logger.info(\\\"token_is_max_context: %s\\\" % \\\" \\\".join([\\n \\\"%d:%s\\\" % (x, y) for (x, y) in six.iteritems(token_is_max_context)\\n ]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\n \\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n if return_answers:\\n answer_text = \\\" \\\".join(out_tokens[start_position:(end_position + 1)])\\n logger.info(\\\"start_position: %d\\\" % (start_position))\\n logger.info(\\\"end_position: %d\\\" % (end_position))\\n logger.info(\\n \\\"answer: %s\\\" % (tokenization.printable_text(answer_text)))\\n\\n # Append feature\\n features.append(\\n ContextFeatures(\\n unique_id=unique_id,\\n example_index=example_index,\\n doc_span_index=doc_span_index,\\n tokens=out_tokens,\\n token_to_word_map=token_to_word_map,\\n token_is_max_context=token_is_max_context,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n start_position=start_position,\\n end_position=end_position))\\n question_features.append(\\n QuestionFeatures(\\n unique_id=unique_id,\\n example_index=example_index,\\n tokens_=out_tokens_,\\n input_ids=input_ids_,\\n input_mask=input_mask_))\\n\\n # Check validity of answer\\n if return_answers:\\n if start_position <= NO_ANS:\\n assert start_position == NO_ANS and end_position == NO_ANS, (start_position, end_position)\\n else:\\n assert out_tokens[start_position:end_position+1] == \\\\\\n all_doc_tokens[tok_start_position:tok_end_position+1]\\n orig_text, start_pos, end_pos = get_final_text_(\\n example, features[-1], start_position, end_position, True, False)\\n phrase = orig_text[start_pos:end_pos]\\n try:\\n assert phrase == example.orig_answer_text\\n except Exception as e:\\n # print('diff ans [%s]/[%s]'%(phrase, example.orig_answer_text))\\n pass\\n unique_id += 1\\n\\n return features, question_features\",\n \"def test_replace_question_mark_with_nan(raw_data: pd.DataFrame):\\n\\n raw_data_nan = replace_question_mark_with_nan(raw_data)\\n\\n # Check the existence of NaN values\\n assert check_null_values(raw_data_nan)\\n\\n # Check that there are no more question marks\\n assert not check_question_mark_as_null(raw_data_nan)\",\n \"def reindex(self):\\n self._index = {w: i for i, w in enumerate(self._words)}\\n self.n, self.d = self._vecs.shape\\n assert self.n == len(self._words) == len(self._index)\\n self._neighbors = None\",\n \"def ques_lstm(self, word_embeddings):\\n nlayer = self.config.nrnn_layer\\n lstm_cell = tf.contrib.rnn.BasicLSTMCell(\\n num_units=self.config.rnn_size, state_is_tuple=True)\\n lstm_cell = tf.contrib.rnn.MultiRNNCell(\\n [lstm_cell] * nlayer, state_is_tuple=True)\\n\\n with tf.variable_scope(\\n 'ques_lstm', initializer=self.initializer) as scope:\\n # Run the batch of sequence embeddings through the LSTM.\\n assert (self.feed_per_seq_length != None)\\n _, lstm_state = tf.nn.dynamic_rnn(\\n cell=lstm_cell,\\n inputs=word_embeddings,\\n sequence_length=self.feed_per_seq_length,\\n dtype=tf.float32)\\n\\n # extract c and h, then concat them all\\n ques_encoding_lis = []\\n for i in range(nlayer):\\n ques_encoding_lis = ques_encoding_lis + [\\n lstm_state[i].c, lstm_state[i].h\\n ]\\n ques_encoding = tf.concat(ques_encoding_lis, axis=1)\\n\\n assert (ques_encoding.shape[1] == self.config.rnnout_dim)\\n\\n return ques_encoding\",\n \"def transform_answers(self, stim_dict: dict):\\n new_ind = [resp.name for resp in RESPONSES]\\n for stim in stim_dict:\\n df = stim_dict[stim][\\\"responses\\\"]\\n df = df.fillna(\\\"empty\\\")\\n new_df = pd.DataFrame(columns=df.columns, index=new_ind)\\n for col in new_df.columns:\\n for row in new_df.index:\\n new_df[col][row] = 0\\n for subj in df.index:\\n if row in df[col][subj]:\\n new_df[col][row] += 1\\n new_df.columns = [\\\"Feelings\\\", \\\"Familiarity\\\"]\\n stim_dict[stim][\\\"transformed_responses\\\"] = new_df\\n self.stim_dict = stim_dict\",\n \"def simplify_ques(question, debug=False):\\n if not isinstance(question, str):\\n raise TypeError('Please provide a string for a question.')\\n\\n if debug is True:\\n load_json()\\n\\n neg = False\\n qwords = question.lower().split()\\n for i in qwords:\\n if i in NEGATIVE_WORDS:\\n neg = True\\n\\n cleanwords = [word for word in qwords if word.lower() not in REMOVE_WORDS]\\n temp = ' '.join(cleanwords)\\n\\n clean_question = \\\"\\\"\\n for letter in temp:\\n if letter != \\\"?\\\" or letter != \\\"\\\\\\\"\\\" or letter != \\\"\\\\'\\\":\\n clean_question = clean_question + letter\\n\\n return clean_question.lower(), neg\",\n \"def reindex_metadata_tags(self):\\r\\n previous_position_values = None\\r\\n\\r\\n for position_index, position in enumerate(self.required_fields_index):\\r\\n if position_index > 0:\\r\\n position.reindex(previous_position_values)\\r\\n\\r\\n previous_position_values = position.current_values()\",\n \"def _postprocess_embeddings(self, prediction_dict, y_indices, x_indices):\\n embedding_predictions = prediction_dict[TRACK_REID][-1]\\n embeddings = predicted_embeddings_at_object_centers(\\n embedding_predictions, y_indices, x_indices)\\n embeddings, _ = tf.linalg.normalize(embeddings, axis=-1)\\n\\n return embeddings\",\n \"def load_as_raw(self):\\n\\n # Q & A\\n questions, answers = self.get_questions_answers()\\n\\n # Get vocabs\\n\\n # Step 4: cleaning the questions\\n pprint('---- Step 4 cleaning questions ----')\\n\\n clean_questions = []\\n for question in questions:\\n clean_questions.append(clean_text(question))\\n\\n pprint(clean_questions, stream=Head(5))\\n print('\\\\n\\\\n')\\n \\\"\\\"\\\"\\n Step 5: Clean the answers\\n \\\"\\\"\\\"\\n\\n pprint('---- Step 5 cleaning answers ----')\\n clean_answers = []\\n for answer in answers:\\n clean_answers.append(clean_text(answer))\\n\\n pprint(clean_answers, stream=Head(5))\\n print('\\\\n\\\\n')\\n \\\"\\\"\\\"\\n Step 6: Creating a dictionary that maps each word to its number of occurences\\n \\\"\\\"\\\"\\n\\n word2count = {}\\n pprint('------ Step 6: counting words in questions ----')\\n\\n word2count = convert_word_to_count(word2count, clean_questions)\\n\\n pprint(word2count, stream=Head(5))\\n print('\\\\n\\\\n')\\n \\\"\\\"\\\"\\n Step 7:\\n For example, for a question: can we make this quick roxanne korrine and andrew barrett are having an incredibly horrendous public break up on the quad again\\n It counts each word occurence such as \\\"can\\\" and accumulates the count into word2count dict\\n \\\"\\\"\\\"\\n pprint('------ Step 6: counting words in answers ----')\\n\\n word2count = convert_word_to_count(word2count, clean_answers)\\n\\n pprint(word2count, stream=Head(5))\\n print('\\\\n\\\\n')\\n\\n keys = ['<unk>', '<s>', '</s>']\\n\\n \\\"\\\"\\\"\\n Step 8: Creating word 2 int(count) by filtering words that are greater than the threshold\\n \\\"\\\"\\\"\\n\\n pprint(\\n '------ Step 8: questions_vocabs filtered by threshold (>) ----')\\n threshold_questions = 20\\n questions_vocabs = [] + keys\\n for word, count in word2count.items():\\n if count >= threshold_questions:\\n if not word in questions_vocabs:\\n questions_vocabs.append(word)\\n\\n pprint(questions_vocabs, stream=Head(5))\\n print('\\\\n\\\\n')\\n \\\"\\\"\\\"\\n Step 9: Same as step 8 but for answers\\n \\\"\\\"\\\"\\n pprint(\\n '------ Step 9: answers_vocabs filtered by threshold (>) ----')\\n threshold_answers = 20\\n answers_vocabs = [] + keys\\n for word, count in word2count.items():\\n if count >= threshold_answers:\\n if not word in answers_vocabs:\\n answers_vocabs.append(word)\\n\\n pprint(answers_vocabs, stream=Head(5))\\n\\n return questions, answers, questions_vocabs, answers_vocabs\",\n \"def word_analogy(self):\\n data = open(\\\"data/word_analogy_subset.en.ar.txt\\\").read().split('\\\\n')\\n data = [x for x in data if len(x.split()) == 4]\\n cnt = 0\\n keys = list(self.embeddings_index.keys())\\n vectors = np.array(list(self.embeddings_index.values()))\\n norms = np.linalg.norm(vectors, axis=1)\\n for i in data:\\n i = self.preprocessor(i).split()\\n try:\\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\\n except:\\n continue\\n unit = v / np.linalg.norm(v)\\n dists = np.dot(vectors, unit) / norms\\n best = np.argpartition(-dists, 10)[:10 + 1]\\n best = best.take(np.argsort((-dists).take(best)))\\n result = [(keys[sim], float(dists[sim]))\\n for sim in best]\\n sbv = result[:10]\\n for j in sbv:\\n if j[0] == i[3]:\\n cnt += 1\\n return cnt/ len(data)\",\n \"def replace_waveforms(self, waveform_dict):\\n for waveform, value in waveform_dict.items():\\n\\n if waveform not in self.unresolved_placeholders:\\n self.hd.log.error(f\\\"Placeholder {waveform} not found in sequence.\\\")\\n\\n waveform_wrapped = f\\\"{self.marker_string}{waveform}{self.marker_string}\\\"\\n waveform_vector = 'vect(' + ','.join([str(x) for x in value]) + ')'\\n self.sequence = self.sequence.replace(f\\\"{waveform_wrapped}\\\", str(waveform_vector))\\n self.unresolved_placeholders.discard(waveform)\",\n \"def replace_errors(suggestion_num, sequence_switched, end_matches, offset_list):\\n if len(end_matches) != 0:\\n # Initialize Variables\\n new_list = initialize_suggestion_list(suggestion_num)\\n tokenizer, model = edf.initialize_tokenizer_variables()\\n\\n # Swapping masks with corrections section\\n if len(end_matches) > 1:\\n k = 0\\n j = 0\\n current = 0\\n keep_going = True\\n\\n while keep_going:\\n # Determine what section to locate mask token in\\n mask_str = section_decision(j, sequence_switched, offset_list, end_matches)\\n\\n new_list = replace_tokens(mask_str, sequence_switched, new_list, j, tokenizer, model, suggestion_num)\\n\\n # If end of sentence, return j to 0, else continue iterations\\n if j == (len(end_matches) - 1):\\n # Update variables\\n j = 0\\n current += 1\\n keep_going = False\\n\\n else:\\n j += 1\\n\\n k += 1\\n\\n else:\\n new_list = replace_tokens(sequence_switched, sequence_switched, new_list, 0, tokenizer, model,\\n suggestion_num)\\n\\n return new_list\\n\\n else:\\n return []\",\n \"def forward(self, aligned_feat):\\n n, t, c, h, w = aligned_feat.size()\\n # temporal attention\\n embedding_ref = self.temporal_attn1(\\n aligned_feat[:, self.center_frame_idx, :, :, :].clone())\\n emb = self.temporal_attn2(aligned_feat.view(-1, c, h, w))\\n emb = emb.view(n, t, -1, h, w) # (n, t, c, h, w)\\n\\n corr_l = [] # correlation list\\n for i in range(t):\\n emb_neighbor = emb[:, i, :, :, :]\\n corr = torch.sum(emb_neighbor * embedding_ref, 1) # (n, h, w)\\n corr_l.append(corr.unsqueeze(1)) # (n, 1, h, w)\\n corr_prob = torch.sigmoid(torch.cat(corr_l, dim=1)) # (n, t, h, w)\\n corr_prob = corr_prob.unsqueeze(2).expand(n, t, c, h, w)\\n corr_prob = corr_prob.contiguous().view(n, -1, h, w) # (n, t*c, h, w)\\n aligned_feat = aligned_feat.view(n, -1, h, w) * corr_prob\\n\\n # fusion\\n feat = self.feat_fusion(aligned_feat)\\n\\n # spatial attention\\n attn = self.spatial_attn1(aligned_feat)\\n attn_max = self.max_pool(attn)\\n attn_avg = self.avg_pool(attn)\\n attn = self.spatial_attn2(torch.cat([attn_max, attn_avg], dim=1))\\n # pyramid levels\\n attn_level = self.spatial_attn_l1(attn)\\n attn_max = self.max_pool(attn_level)\\n attn_avg = self.avg_pool(attn_level)\\n attn_level = self.spatial_attn_l2(\\n torch.cat([attn_max, attn_avg], dim=1))\\n attn_level = self.spatial_attn_l3(attn_level)\\n attn_level = self.upsample(attn_level)\\n\\n attn = self.spatial_attn3(attn) + attn_level\\n attn = self.spatial_attn4(attn)\\n attn = self.upsample(attn)\\n attn = self.spatial_attn5(attn)\\n attn_add = self.spatial_attn_add2(self.spatial_attn_add1(attn))\\n attn = torch.sigmoid(attn)\\n\\n # after initialization, * 2 makes (attn * 2) to be close to 1.\\n feat = feat * attn * 2 + attn_add\\n return feat\",\n \"def batchify_QA(batch):\\r\\n\\r\\n if type(batch[0][1]) != torch.LongTensor:\\r\\n no_elmo, use_char = (True, False) if batch[0][1] == -2 else (False, False)\\r\\n else:\\r\\n no_elmo, use_char = True, True\\r\\n\\r\\n docs = [ex[0] for ex in batch]\\r\\n docs_char = [ex[1] for ex in batch]\\r\\n ques = [ex[2] for ex in batch]\\r\\n questions_char = [ex[3] for ex in batch]\\r\\n answers = [ex[4] for ex in batch]\\r\\n\\r\\n # Batch documents\\r\\n max_doc_length = max([d.size(0) for d in docs])\\r\\n x1_len = torch.LongTensor(len(docs)).zero_()\\r\\n x1 = torch.LongTensor(len(docs),\\r\\n max_doc_length).zero_() if no_elmo else torch.LongTensor(len(docs),\\r\\n max_doc_length,\\r\\n 50).zero_()\\r\\n x1_char = torch.LongTensor(len(docs),\\r\\n max_doc_length,\\r\\n docs_char[0].size(1)).zero_() if (no_elmo and use_char) else None\\r\\n for i, d in enumerate(docs):\\r\\n x1_len[i] = d.size(0)\\r\\n x1[i, :d.size(0)].copy_(d)\\r\\n if not no_elmo:\\r\\n x1_char[i, :d.size(0), :].copy_(docs_char[i])\\r\\n\\r\\n # Batch questions\\r\\n max_ques_length = max([q.size(0) for q in ques])\\r\\n x2_len = torch.LongTensor(len(ques)).zero_()\\r\\n x2 = torch.LongTensor(len(ques), max_ques_length).zero_() if no_elmo else torch.LongTensor(len(ques),\\r\\n max_ques_length,\\r\\n 50).zero_()\\r\\n x2_char = torch.LongTensor(len(ques),\\r\\n max_ques_length,\\r\\n questions_char[0].size(1)).zero_() if (no_elmo and use_char) else None\\r\\n for i, q in enumerate(ques):\\r\\n x2_len[i] = q.size(0)\\r\\n x2[i, :q.size(0)].copy_(q)\\r\\n if not no_elmo:\\r\\n x2_char[i, :q.size(0), :].copy_(questions_char[i])\\r\\n\\r\\n # Batch answers\\r\\n max_ans_length = max([a.size(0) for a in answers])\\r\\n ans_len = torch.LongTensor(len(answers)).zero_()\\r\\n ans = torch.LongTensor(len(answers), max_ans_length).zero_()\\r\\n for i, a in enumerate(answers):\\r\\n ans_len[i] = a.size(0)\\r\\n ans[i, :a.size(0)].copy_(a)\\r\\n\\r\\n ids = [ex[5] for ex in batch]\\r\\n contexts = [ex[6] for ex in batch]\\r\\n # FIXME: multiple answers are possible, fix vectorize also.\\r\\n targets = [ex[8][0] for ex in batch]\\r\\n src_vocabs = [ex[9] for ex in batch]\\r\\n source_maps = []\\r\\n alignments = []\\r\\n\\r\\n # Prepare source vocabs, alignment [required for Copy Attention]\\r\\n for eid, context, target, (token2idx, idx2token) in \\\\\\r\\n zip(ids, contexts, targets, src_vocabs):\\r\\n # Mapping source tokens to indices in the dynamic dict.\\r\\n src_map = torch.LongTensor([token2idx[w] for w in context])\\r\\n source_maps.append(src_map)\\r\\n\\r\\n # TODO: does skipping the first and last token in answer valid?\\r\\n mask = torch.LongTensor([token2idx[w] if w in token2idx\\r\\n else UNK for w in target])\\r\\n alignments.append(mask)\\r\\n\\r\\n return {'doc_rep': x1,\\r\\n 'doc_char_rep': x1_char,\\r\\n 'doc_len': x1_len,\\r\\n 'que_rep': x2,\\r\\n 'que_char_rep': x2_char,\\r\\n 'que_len': x2_len,\\r\\n 'ans_rep': ans,\\r\\n 'ans_len': ans_len,\\r\\n 'ids': ids,\\r\\n 'documents': contexts,\\r\\n 'questions': [ex[7] for ex in batch],\\r\\n 'answers': targets,\\r\\n 'source_vocabs': src_vocabs,\\r\\n 'src_map': source_maps,\\r\\n 'alignment': alignments}\",\n \"def intent_of_text_LnDOR(ChapterTextS, TargetQuestionsD, TestS, StopWords):\\n \\n # Chapter Text - stokenize\\n StokensCT = stokenize(ChapterTextS, StopWords) \\n\\n # Test question - stokenize\\n StokensTest = stokenize(TestS, StopWords)\\n\\n # Knowledge Base Dict - stokenize\\n KBD_structure = stokenizeKBD(TargetQuestionsD, StopWords)\\n\\n # List (because list is mutable, set is not) of all stokens in document\\n StokensDoc = StokensCT[:] # from chapter text\\n StokensDoc.extend(StokensTest[:]) # += Test string\\n\\n # extend list of stokens in Doc\\n for i in TargetQuestionsD:\\n StokensDoc.extend(TargetQuestionsD[i][\\\"mq stokens\\\"][:]) # += KB target [matched Q]s\\n StokensDoc.extend(TargetQuestionsD[i][\\\"ans stokens\\\"][:]) # += KB answers\\n \\n StokensTestV = set(StokensTest)\\n StokensDocV = set(StokensDoc)\\n StokensAntiTgtV = StokensDocV\\n \\n # Complement of all targets\\n for i in TargetQuestionsD:\\n StokensAntiTgtV = StokensAntiTgtV.difference(set(TargetQuestionsD[i][\\\"mq stokens\\\"]))\\n \\n # calculate confusion matrix and DOR etc.\\n LnDORD = {}\\n # Anti Target\\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensAntiTgtV, StokensTestV) \\n LnDOR = lndor(TP, FP, FN, TN) \\n someAngle = angleDOR(TP, FP, FN, TN) \\n \\n LnDORD[\\\"AntiTgt\\\"] = {'lndor': LnDOR, 'theta': someAngle}\\n\\n # total occurences\\n total_occ = 0\\n for i in TargetQuestionsD:\\n total_occ += TargetQuestionsD[i]['count']\\n\\n for i in TargetQuestionsD:\\n StokensTgtV = set(TargetQuestionsD[i][\\\"mq stokens\\\"][:])\\n\\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensTgtV, StokensTestV) \\n priorOR = TargetQuestionsD[i]['count'] / total_occ\\n\\n LnDOR = lndor(TP, FP, FN, TN) \\n someAngle = angleDOR(TP, FP, FN, TN, priorOR) \\n \\n LnDORD[i] = {'lndor': LnDOR, 'theta': someAngle}\\n # LnDORD = {i: {'lndor': , 'theta': }}, KB indices + \\\"AntiTgt\\\"\\n\\n return LnDORD\",\n \"def qualify_words():\\n config = get_config()\\n\\n all_feature_matrices = []\\n all_opinion_matrices = []\\n\\n # first 5 parts are labeled, thus are useful\\n all_feature_label_vectors = []\\n all_opinion_label_vectors = []\\n\\n for fname in config.file_names:\\n feature_X, feature_dims = load_feature_matrices(fname)\\n opinion_X, opinion_dims = load_opinion_matrices(fname)\\n feature_y = load_feature_labels(fname)\\n opinion_y = load_opinion_labels(fname)\\n\\n # append to all collector\\n all_feature_matrices.append(feature_X)\\n all_feature_label_vectors.append(feature_y)\\n all_opinion_matrices.append(opinion_X)\\n all_opinion_label_vectors.append(opinion_y)\\n # use first 5 for training\\n # stack first 5\\n feature_training_X = []\\n feature_training_y = []\\n opinion_training_X = []\\n opinion_training_y = []\\n for i in range(5):\\n feature_training_X.append(all_feature_matrices[i])\\n feature_training_y.append(all_feature_label_vectors[i])\\n opinion_training_X.append(all_opinion_matrices[i])\\n opinion_training_y.append(all_opinion_label_vectors[i])\\n\\n feature_training_X = np.hstack(feature_training_X)\\n feature_training_y = np.hstack(feature_training_y)\\n opinion_training_X = np.hstack(opinion_training_X)\\n opinion_training_y = np.hstack(opinion_training_y)\\n\\n # using combination of rule and ranking score as features\\n feature_model = MultinomialNB()\\n opinion_model = MultinomialNB()\\n\\n # training\\n feature_model.fit(np.transpose(feature_training_X), feature_training_y.ravel())\\n opinion_model.fit(np.transpose(opinion_training_X), opinion_training_y.ravel())\\n\\n # predicting on candidate aspects and opinions, extracted from amazon reviews\\n for i in range(5, len(config.file_names)):\\n fname = config.file_names[i]\\n feature_pred = feature_model.predict_proba(\\n np.transpose(all_feature_matrices[i]))[:,1]\\n opinion_pred = opinion_model.predict_proba(\\n np.transpose(all_opinion_matrices[i]))[:,1]\\n # pickle the prediction results\\n with open('../results/' + fname + '_feature_pred_score.pickle', 'wb') as f:\\n pickle.dump(feature_pred, f)\\n with open('../results/' + fname + '_opinion_pred_score.pickle', 'wb') as f:\\n pickle.dump(opinion_pred, f)\",\n \"def encode_samples(tokenized_samples, word_to_idx):\\n features = []\\n for sample in tokenized_samples:\\n feature = []\\n for token in sample:\\n if token in word_to_idx:\\n feature.append(word_to_idx[token])\\n else:\\n feature.append(0)\\n features.append(feature)\\n return features\",\n \"def compute_query_repr(annots_df, qaid, invindex, aggregate=False, alpha=3, thresh=0):\\n if utool.VERBOSE:\\n print('[smk_index] Query Repr qaid=%r' % (qaid,))\\n wx2_idf = invindex.wx2_idf\\n words = invindex.words\\n wordflann = invindex.wordflann\\n if WITH_PANDAS:\\n qfx2_vec = annots_df['vecs'][qaid]\\n else:\\n qfx2_vec = pdh.ensure_values(annots_df['vecs'][qaid])\\n # Assign query to words\\n wx2_qfxs1, wx2_weights, qfx2_wxs = assign_to_words_(\\n wordflann, words, qfx2_vec, idx_name='fx', dense=False) # 71.9 %\\n # Hack to make implementing asmk easier, very redundant\\n #qfx2_aid = pdh.IntSeries([qaid] * len(qfx2_wx), index=qfx2_wx.index, name='qfx2_aid')\\n #qfx2_aid = pdh.IntSeries([qaid] * len(qfx2_wx), name='qfx2_aid')\\n qfx2_aid = np.array([qaid] * len(qfx2_wxs), dtype=INTEGER_TYPE)\\n if WITH_PANDAS:\\n qfx2_qfx = qfx2_vec.index\\n else:\\n qfx2_qfx = np.arange(len(qfx2_vec))\\n # Compute query residuals\\n wx2_qrvecs, wx2_qaids, wx2_qfxs = compute_residuals_(\\n words, wx2_qfxs1, qfx2_vec, qfx2_aid, qfx2_qfx, aggregate) # 24.8\\n # Compute query gamma\\n if utool.VERBOSE:\\n print('[smk_index] Query Gamma alpha=%r, thresh=%r' % (alpha, thresh))\\n wx_sublist = pdh.ensure_index(wx2_qrvecs).astype(np.int32)\\n idf_list = pdh.ensure_values_subset(wx2_idf, wx_sublist)\\n rvecs_list = pdh.ensure_values_subset(wx2_qrvecs, wx_sublist)\\n query_gamma = smk_core.gamma_summation2(rvecs_list, idf_list, alpha, thresh)\\n assert query_gamma > 0, 'query gamma is not positive!'\\n return wx2_qrvecs, wx2_qaids, wx2_qfxs, query_gamma\",\n \"def replace_token_with_index(self, tokenized_tweet, max_length_dictionary):\\n\\n # should be replacing each token in a list of tokens by their corresponding index\\n # Source: https://github.com/stanfordnlp/GloVe\\n # Source: https://towardsdatascience.com/word-embeddings-for-sentiment-analysis-65f42ea5d26e\\n\\n if self.mode == \\\"zip\\\":\\n for idx, word in enumerate(tokenized_tweet):\\n if word not in self.corpus:\\n tokenized_tweet[idx] = \\\"<unknown>\\\"\\n else:\\n for idx, word in enumerate(tokenized_tweet):\\n if word not in self.corpus:\\n tokenized_tweet[idx] = \\\"<unk>\\\"\\n return [self.corpus.index(x) for x in tokenized_tweet]\",\n \"def match(self, passage_encodes, question_encodes, p_length, q_length):\\n with tf.variable_scope('bidaf'):\\n sim_matrix = tf.matmul(\\n passage_encodes, question_encodes, transpose_b=True)\\n context2question_attn = tf.matmul(\\n tf.nn.softmax(sim_matrix, -1), question_encodes)\\n b = tf.nn.softmax(tf.expand_dims(\\n tf.reduce_max(sim_matrix, 2), 1), -1)\\n question2context_attn = tf.tile(tf.matmul(b, passage_encodes),\\n [1, tf.shape(passage_encodes)[1], 1])\\n concat_outputs = tf.concat([passage_encodes, context2question_attn,\\n passage_encodes * context2question_attn,\\n passage_encodes * question2context_attn], -1)\\n return concat_outputs, None\",\n \"def fix_annotmatch_pzmaster1():\\n import wbia\\n\\n ibs = wbia.opendb('PZ_Master1')\\n infr = wbia.AnnotInference(ibs=ibs, aids=ibs.get_valid_aids(), verbose=5)\\n infr.initialize_graph()\\n annots = ibs.annots()\\n aid_to_nid = ut.dzip(annots.aids, annots.nids)\\n\\n if False:\\n infr.reset_feedback()\\n infr.ensure_mst()\\n infr.apply_feedback_edges()\\n infr.relabel_using_reviews()\\n infr.start_qt_interface()\\n\\n # Get annotmatch rowids that agree with current labeling\\n if False:\\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\\n import pandas as pd\\n\\n flags1 = pd.isnull(annotmatch['annotmatch_evidence_decision'])\\n flags2 = annotmatch['annotmatch_tag_text'] == ''\\n bad_part = annotmatch[flags1 & flags2]\\n rowids = bad_part.index.tolist()\\n ibs.delete_annotmatch(rowids)\\n\\n if False:\\n # Delete bidirectional annotmatches\\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\\n df = annotmatch.set_index(['annot_rowid1', 'annot_rowid2'])\\n\\n # Find entires that have both directions\\n pairs1 = annotmatch[['annot_rowid1', 'annot_rowid2']].values\\n f_edges = {tuple(p) for p in pairs1}\\n b_edges = {tuple(p[::-1]) for p in pairs1}\\n isect_edges = {tuple(sorted(p)) for p in b_edges.intersection(f_edges)}\\n isect_edges1 = list(isect_edges)\\n isect_edges2 = [p[::-1] for p in isect_edges]\\n\\n # cols = ['annotmatch_evidence_decision', 'annotmatch_tag_text']\\n import pandas as pd\\n\\n custom_ = {\\n (559, 4909): (False, ['photobomb']),\\n (7918, 8041): (False, ['photobomb']),\\n (6634, 6754): (False, ['photobomb']),\\n (3707, 3727): (False, ['photobomb']),\\n (86, 103): (False, ['photobomb']),\\n }\\n extra_ = {}\\n\\n fixme_edges = []\\n\\n d1 = df.loc[isect_edges1].reset_index(drop=False)\\n d2 = df.loc[isect_edges2].reset_index(drop=False)\\n flags = d1['annotmatch_evidence_decision'] != d2['annotmatch_evidence_decision']\\n from wbia.tag_funcs import _parse_tags\\n\\n for f, r1, r2 in zip(flags, d1.iterrows(), d2.iterrows()):\\n v1, v2 = r1[1], r2[1]\\n aid1 = v1['annot_rowid1']\\n aid2 = v1['annot_rowid2']\\n truth_real = (\\n ibs.const.EVIDENCE_DECISION.POSITIVE\\n if aid_to_nid[aid1] == aid_to_nid[aid2]\\n else ibs.const.EVIDENCE_DECISION.NEGATIVE\\n )\\n truth1 = v1['annotmatch_evidence_decision']\\n truth2 = v2['annotmatch_evidence_decision']\\n t1 = _parse_tags(v1['annotmatch_tag_text'])\\n t2 = _parse_tags(v2['annotmatch_tag_text'])\\n newtag = ut.union_ordered(t1, t2)\\n if (aid1, aid2) in custom_:\\n continue\\n fixme_flag = False\\n if not pd.isnull(truth1):\\n if truth_real != truth1:\\n fixme_flag = True\\n if not pd.isnull(truth2):\\n if truth_real != truth2:\\n fixme_flag = True\\n if fixme_flag:\\n logger.info('newtag = {!r}'.format(newtag))\\n logger.info('truth_real = {!r}'.format(truth_real))\\n logger.info('truth1 = {!r}'.format(truth1))\\n logger.info('truth2 = {!r}'.format(truth2))\\n logger.info('aid1 = {!r}'.format(aid1))\\n logger.info('aid2 = {!r}'.format(aid2))\\n fixme_edges.append((aid1, aid2))\\n else:\\n extra_[(aid1, aid2)] = (truth_real, newtag)\\n\\n extra_.update(custom_)\\n new_pairs = extra_.keys()\\n new_truths = ut.take_column(ut.dict_take(extra_, new_pairs), 0)\\n new_tags = ut.take_column(ut.dict_take(extra_, new_pairs), 1)\\n new_tag_texts = [';'.join(t) for t in new_tags]\\n aids1, aids2 = ut.listT(new_pairs)\\n\\n # Delete the old\\n ibs.delete_annotmatch(\\n d1['annotmatch_rowid'].values.tolist()\\n + d2['annotmatch_rowid'].values.tolist()\\n )\\n\\n # Add the new\\n ams = ibs.add_annotmatch_undirected(aids1, aids2)\\n ibs.set_annotmatch_evidence_decision(ams, new_truths)\\n ibs.set_annotmatch_tag_text(ams, new_tag_texts)\\n\\n if False:\\n import wbia.guitool as gt\\n\\n gt.ensure_qapp()\\n ut.qtensure()\\n from wbia.gui import inspect_gui\\n\\n inspect_gui.show_vsone_tuner(ibs, aid1, aid2)\\n\\n # pairs2 = pairs1.T[::-1].T\\n # idx1, idx2 = ut.isect_indices(list(map(tuple, pairs1)),\\n # list(map(tuple, pairs2)))\\n # r_edges = list(set(map(tuple, map(sorted, pairs1[idx1]))))\\n # unique_pairs = list(set(map(tuple, map(sorted, pairs1[idx1]))))\\n # df = annotmatch.set_index(['annot_rowid1', 'annot_rowid2'])\\n\\n x = ut.ddict(list)\\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\\n import ubelt as ub\\n\\n _iter = annotmatch.iterrows()\\n prog = ub.ProgIter(_iter, length=len(annotmatch))\\n for k, m in prog:\\n aid1 = m['annot_rowid1']\\n aid2 = m['annot_rowid2']\\n if m['annotmatch_evidence_decision'] == ibs.const.EVIDENCE_DECISION.POSITIVE:\\n if aid_to_nid[aid1] == aid_to_nid[aid2]:\\n x['agree1'].append(k)\\n else:\\n x['disagree1'].append(k)\\n elif m['annotmatch_evidence_decision'] == ibs.const.EVIDENCE_DECISION.NEGATIVE:\\n if aid_to_nid[aid1] == aid_to_nid[aid2]:\\n x['disagree2'].append(k)\\n else:\\n x['agree2'].append(k)\\n\\n ub.map_vals(len, x)\\n ut.dict_hist(annotmatch.loc[x['disagree1']]['annotmatch_tag_text'])\\n\\n disagree1 = annotmatch.loc[x['disagree1']]\\n pb_disagree1 = disagree1[disagree1['annotmatch_tag_text'] == 'photobomb']\\n aids1 = pb_disagree1['annot_rowid1'].values.tolist()\\n aids2 = pb_disagree1['annot_rowid2'].values.tolist()\\n aid_pairs = list(zip(aids1, aids2))\\n infr = wbia.AnnotInference.from_pairs(aid_pairs, ibs=ibs, verbose=5)\\n if False:\\n feedback = infr.read_wbia_annotmatch_feedback(edges=infr.edges())\\n infr.external_feedback = feedback\\n infr.apply_feedback_edges()\\n infr.start_qt_interface(loop=False)\\n\\n # Delete these values\\n if False:\\n nonpb_disagree1 = disagree1[disagree1['annotmatch_tag_text'] != 'photobomb']\\n disagree2 = annotmatch.loc[x['disagree2']]\\n ibs.delete_annotmatch(nonpb_disagree1['annotmatch_rowid'])\\n ibs.delete_annotmatch(disagree2['annotmatch_rowid'])\\n\\n # ut.dict_hist(disagree1['annotmatch_tag_text'])\\n import networkx as nx\\n\\n graph = nx.Graph()\\n graph.add_edges_from(zip(pb_disagree1['annot_rowid1'], pb_disagree1['annot_rowid2']))\\n list(nx.connected_components(graph))\\n\\n set(annotmatch.loc[x['disagree2']]['annotmatch_tag_text'])\\n\\n # aid1, aid2 = 2585, 1875\\n # # pd.unique(annotmatch['annotmatch_evidence_decision'])\\n # from wbia.gui import inspect_gui\\n # inspect_gui.show_vsone_tuner(ibs, aid1, aid2)\\n # from vtool import inspect_matches\\n\\n # aid1, aid2 = 2108, 2040\\n\\n # pd.unique(annotmatch['annotmatch_tag_text'])\\n\\n # infr.reset_feedback()\\n # infr.relabel_using_reviews()\",\n \"def compute(db, detected_chords_by_song):\\n detected = {}\\n ground = {}\\n detected_chords = []\\n ground_chords = []\\n\\n for s in detected_chords_by_song:\\n detected[s['title']] = s['detected_chords']\\n\\n for s in db:\\n ground[s['title']] = s['chord_vector']\\n\\n for k, v in ground.items():\\n if k in detected:\\n if len(v) == len(detected[k]):\\n detected_chords.extend(detected[k])\\n ground_chords.extend(v)\\n\\n # ignore chors represented with dash given that are not suppoted by the algorithm\\n ground = []\\n detected = []\\n i = 0\\n while i < len(ground_chords): \\n if '-' != ground_chords[i]:\\n ground.append(ground_chords[i])\\n detected.append(detected_chords[i])\\n i += 1\\n\\n fig, ax = plt.subplots()\\n tick_marks = np.arange(len(EXISTING_NOTES))\\n plt.xticks(tick_marks, EXISTING_NOTES, rotation=45)\\n plt.yticks(tick_marks, EXISTING_NOTES)\\n\\n matrix = confusion_matrix(ground, detected, labels=EXISTING_NOTES)\\n thresh = 500\\n\\n for i, j in itertools.product(range(matrix.shape[0]), range(matrix.shape[1])):\\n plt.text(j, i, matrix[i, j],\\n horizontalalignment=\\\"center\\\",\\n size=5,\\n color=\\\"black\\\" if matrix[i, j] > thresh else \\\"white\\\")\\n plt.ylabel('True chords')\\n plt.xlabel('Predicted chords')\\n plt.tight_layout()\\n\\n fname = (\\n os.path.join(\\n settings.IMG_DIR,\\n 'initial_diagnose', 'total_accuracy_confusion_matrix.png'))\\n\\n plt.imshow(matrix, interpolation='nearest')\\n plt.colorbar()\\n plt.savefig(fname)\",\n \"def build_dataset(token_seq, token_seq_index, term_to_index, char_to_index, max_token_length=15, leading_context_size=10, trailing_context_size=10, leading_separator='{', trailing_separator='}', n_examples_per_context=10, n_errors_per_token=[1], n_errors_per_context=[0], dictionary=enchant.Dict('en_US'), seed=17):\\n if isinstance(seed, RandomState):\\n rng = seed\\n else:\\n rng = RandomState(seed=seed)\\n\\n n_contexts = sum([len(token_seq_index[t]) for t in token_seq_index.keys() if len(t) <= max_token_length])\\n n_examples = n_examples_per_context * n_contexts\\n max_inserts_per_token = max(n_errors_per_token)\\n max_inserts_per_context = 2*max(n_errors_per_context)\\n max_chars_in_window = leading_context_size + max_token_length + trailing_context_size + len(leading_separator) + len(trailing_separator) + max_inserts_per_token + max_inserts_per_context\\n\\n error_examples = np.zeros((n_examples, max_chars_in_window), dtype=np.int32)\\n error_examples.fill(char_to_index[' '])\\n\\n leading_contexts = np.zeros((n_examples, leading_context_size + max_inserts_per_context))\\n leading_contexts.fill(char_to_index[' '])\\n spelling_errors = np.zeros((n_examples, max_token_length + max_inserts_per_token))\\n spelling_errors.fill(char_to_index[' '])\\n trailing_contexts = np.zeros((n_examples, trailing_context_size + max_inserts_per_context))\\n trailing_contexts.fill(char_to_index[' '])\\n\\n correct_tokens = []\\n corrupt_tokens = []\\n corrections = np.zeros(n_examples, dtype=np.int32)\\n error_types = []\\n context_ids = []\\n example_ids = []\\n term_lens = []\\n edit_distance_to_nearest_term = []\\n nearest_term = []\\n\\n print('starting to construct {n_examples} examples'.format(\\n n_examples=n_examples))\\n\\n pbar = progressbar.ProgressBar(term_width=40,\\n widgets=[' ', progressbar.Percentage(),\\n ' ', progressbar.ETA()],\\n maxval=n_examples).start()\\n n = 0\\n\\n index_to_char = dict((i,c) for c,i in char_to_index.iteritems())\\n if 63 not in index_to_char.keys():\\n # A workaround for now. Delete ASAP.\\n index_to_char[63] = '^'\\n\\n def add_chars_to_array(n, array, chars, default_char=' '):\\n for k, ch in enumerate(chars):\\n try:\\n array[n, k] = char_to_index[ch]\\n except KeyError, e:\\n array[n, k] = char_to_index[default_char]\\n\\n for token in token_seq_index.keys():\\n if len(token) > max_token_length:\\n continue\\n\\n term_len = len(token)\\n distances = min_dictionary_edit_distance([token], dictionary)\\n distance = distances[token]['distance']\\n term = distances[token]['accepted']\\n\\n for i in token_seq_index[token]:\\n for j in six.moves.range(n_examples_per_context):\\n pbar.update(n+1)\\n corruptor = rng.choice([insert_characters, delete_characters,\\n replace_characters, transpose_characters])\\n n_token_errors = rng.choice(n_errors_per_token)\\n corrupt_token = corruptor(token, index_to_char, n=n_token_errors, seed=rng)\\n\\n n_context_errors = rng.choice(n_errors_per_context)\\n leading = leading_context(token_seq, i, leading_context_size)\\n leading = corruptor(leading, index_to_char, n=n_context_errors, seed=rng)\\n trailing = trailing_context(token_seq, i, trailing_context_size)\\n trailing = corruptor(trailing, index_to_char, n=n_context_errors, seed=rng)\\n\\n window = ''.join([leading, leading_separator,\\n corrupt_token, trailing_separator, trailing])\\n\\n add_chars_to_array(n, error_examples, window)\\n add_chars_to_array(n, leading_contexts, leading)\\n add_chars_to_array(n, spelling_errors, corrupt_token)\\n add_chars_to_array(n, trailing_contexts, trailing)\\n\\n correct_tokens.append(token)\\n corrections[n] = term_to_index[token]\\n corrupt_tokens.append(corrupt_token)\\n error_types.append(corruptor.__name__)\\n context_ids.append(i)\\n example_ids.append(n)\\n edit_distance_to_nearest_term.append(distance)\\n nearest_term.append(term)\\n term_lens.append(term_len)\\n\\n n += 1\\n\\n pbar.finish()\\n\\n df = pd.DataFrame({\\n 'correction': corrections,\\n 'error_type': error_types,\\n 'context_id': context_ids,\\n 'example_id': example_ids,\\n 'edit_distance_to_nearest_term': edit_distance_to_nearest_term,\\n 'nearest': nearest_term,\\n 'term_length': term_lens,\\n 'correct_token': correct_tokens,\\n 'corrupt_token': corrupt_tokens\\n })\\n\\n def add_columns(df, array, colname_prefix):\\n colwidth = int(np.log10(array.shape[1]))+1\\n colfmt = colname_prefix + '{col:0' + str(colwidth) + 'd}'\\n for col in np.arange(array.shape[1]):\\n colname = colfmt.format(col=col)\\n df[colname] = array[:, col]\\n\\n add_columns(df, error_examples, 'full_error')\\n add_columns(df, leading_contexts, 'leading_context')\\n add_columns(df, spelling_errors, 'spelling_error')\\n add_columns(df, trailing_contexts, 'trailing_context')\\n\\n return df\",\n \"async def respond(self, ctx, index, *, response):\\n try:\\n config = self.bot.db['questions'][str(ctx.guild.id)][str(ctx.channel.id)]\\n except KeyError:\\n return\\n if not response:\\n await hf.safe_send(ctx, \\\"You need to type something for your response.\\\")\\n return\\n if len(response.split()) == 1:\\n try:\\n msg = await ctx.channel.fetch_message(int(response))\\n await ctx.message.add_reaction('⤴')\\n ctx.message = msg\\n ctx.author = msg.author\\n response = msg.content\\n except (discord.NotFound, ValueError):\\n pass\\n if index not in config['questions']:\\n await hf.safe_send(ctx, \\\"Invalid question index. Make sure you're typing this command in the channel \\\"\\n \\\"the question was originally made in.\\\")\\n return\\n\\n try:\\n log_channel = ctx.guild.get_channel(config['log_channel'])\\n except discord.NotFound:\\n await hf.safe_send(ctx, \\\"The original log channel can't be found (type `;q setup`)\\\")\\n return\\n try:\\n log_message = await log_channel.fetch_message(config['questions'][index]['log_message'])\\n except discord.NotFound:\\n await hf.safe_send(ctx, \\\"The original question log message could not be found. Type `;q a <index>` to \\\"\\n \\\"close the question and clear it.\\\")\\n return\\n\\n emb: discord.Embed = log_message.embeds[0]\\n value_text = f\\\"\\\\n[Jump URL]({ctx.message.jump_url})\\\"\\n emb.add_field(name=f\\\"Response by {ctx.author.name}#{ctx.author.discriminator}\\\",\\n value=value_text.replace('', response[:1024-len(value_text)]))\\n await log_message.edit(embed=emb)\\n config['questions'][index].setdefault('responses', []).append(ctx.message.jump_url)\\n await self._delete_log(ctx)\\n await self._post_log(ctx)\\n await ctx.message.add_reaction('✅')\",\n \"def get_embeddings_from_raw_image(recognizer, frame):\\n # detect faces, original frame and face boxes\\n a, boxes = detector.find_face(frame, recognizer.ort_session, recognizer.input_name)\\n\\n\\n # align facesq\\n aligned_faces = []\\n boxes[boxes < 0] = 0\\n for i in range(boxes.shape[0]):\\n box = boxes[i, :]\\n f = np.copy(frame)\\n y = align_face(recognizer, f, box)\\n aligned_faces.append(y)\\n\\n embs = []\\n for i in range(boxes.shape[0]):\\n aligned_face = aligned_faces[i]\\n embs.append(face_embedding(recognizer, aligned_face))\\n\\n return embs\",\n \"def replace_tokens(self, tokens):\\n details = []\\n idx = 0\\n if len(tokens) >= min_token_num:\\n for i in range(len(tokens)):\\n old_token = tokens[i]\\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\\n tokens[i] = self.get_insert_token(tokens[i])\\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\\n idx += len(tokens[i])\\n return tokens, details\",\n \"def forward(self, input_features, review_qid):\\n\\n # items that are not padded\\n src_mask = (input_features[\\\"qid\\\"] != 0).unsqueeze(-2)\\n\\n encoder_output = self.encoder(\\n self.src_embed(input_features),\\n src_mask,\\n )\\n review_embedding = self.embedding_by_feature[\\\"qid\\\"](review_qid)\\n\\n output = self.review_generator(encoder_output, src_mask, review_embedding)\\n\\n return output\",\n \"def fix_answer_values(answers):\\n answers_fixed = answers.copy()\\n answers_fixed = np.where(answers_fixed==1, 3, answers_fixed) # move \\\"no\\\" away temporarily\\n answers_fixed = np.where(answers_fixed==2, 1, answers_fixed) # set \\\"no opinion\\\" value to 1\\n answers_fixed = np.where(answers_fixed==3, 2, answers_fixed) # set temporary value 3 (meaning \\\"no\\\") to 2\\n return answers_fixed\",\n \"def find_corresponding_question(chat, tagged_user, prev_mod_index, index, q, unique_users):\\n\\n # searches from the previous message sent by the moderator\\n for i in range(index, prev_mod_index[1], -1):\\n message = chat[i]\\n if message['user'] == tagged_user:\\n question = is_question(message, unique_users, q)\\n if question != None:\\n return question\\n \\n # expanding the search space ft. some additional checks\\n for i in range(prev_mod_index[1], prev_mod_index[0], -1):\\n message = chat[i]\\n \\n if message['user'] == tagged_user:\\n question = find_question_expanded(message, unique_users, q)\\n \\n if question != None:\\n return question\\n\\n return None\",\n \"def tag_conjunction_entities(annotated_pages):\\n for page_id in annotated_pages:\\n page = Page.objects(id=page_id).first()\\n #page = db_conn.pages.find_one({\\\"_id\\\":page_id}) # TODO: refactor\\n annotation_ids = [p.id for p in page[\\\"annotations_ids\\\"]]\\n all_annotations = list(Annotation.objects(id__in=annotation_ids))\\n # retrieve meta-annotations from that page\\n meta_annotations = list(Annotation.objects(id__in=annotation_ids, entity_type=\\\"meta-annotation\\\"))\\n #all_annotations = list(db_conn.annotations.find({\\\"_id\\\":{\\\"$in\\\":annotation_ids}})) # TODO: refactor\\n #meta_annotations = list(db_conn.annotations.find({\\\"_id\\\":{\\\"$in\\\":annotation_ids} # TODO: refactor\\n # ,\\\"entity_type\\\":\\\"meta-annotation\\\"}))\\n if(len(meta_annotations)>0):\\n logger.debug(\\\"Meta-annotations: %s\\\"%meta_annotations)\\n for meta_annotation in meta_annotations:\\n logger.info(\\\"Processing meta-annotation %s\\\"%meta_annotation[\\\"id\\\"])\\n line_span = sorted(list(set([(position[\\\"page_id\\\"], position[\\\"line_n\\\"]) \\n for position in meta_annotation[\\\"positions\\\"]])))\\n top_entities_ids = [ann.id for ann in meta_annotation[\\\"top_entities\\\"]]\\n top_entities = list(Annotation.objects(id__in=top_entities_ids))\\n #top_entities = [db_conn.annotations.find_one({\\\"_id\\\":top_annotation_id}) \\n # for top_annotation_id in meta_annotation[\\\"top_entities\\\"]]\\n tokens = []\\n for page_obj, line_n in line_span:\\n page = Page.objects(id=page_obj.id).first()\\n #page = db_conn.pages.find_one({\\\"_id\\\":page_id})\\n for line in page[\\\"lines\\\"]:\\n if line[\\\"line_number\\\"]==line_n:\\n tokens.append((page_obj,line_n,line[\\\"tokens\\\"]))\\n try:\\n for entity in top_entities:\\n assert entity is not None\\n true_conjunctions = []\\n meta_annotation_start = (top_entities[0][\\\"positions\\\"][0][\\\"page_id\\\"]\\n ,top_entities[0][\\\"positions\\\"][0][\\\"line_n\\\"]\\n ,top_entities[0][\\\"positions\\\"][0][\\\"start\\\"])\\n meta_annotation_end = (top_entities[-1][\\\"positions\\\"][-1][\\\"page_id\\\"]\\n ,top_entities[-1][\\\"positions\\\"][-1][\\\"line_n\\\"]\\n ,top_entities[-1][\\\"positions\\\"][-1][\\\"end\\\"])\\n conjunctions = [(token,page,line) for page,line,toks in tokens for token in toks\\n if(token[\\\"offset_start\\\"] >= meta_annotation_start[2] and token[\\\"offset_end\\\"] <= meta_annotation_end[2])]\\n true_conjunctions += [(page,line,token) for token,page,line in conjunctions \\n if not is_annotated(page,line,token,all_annotations)]\\n if(len(true_conjunctions)>0):\\n logger.debug(\\\"Conjunctions found: %s\\\"%true_conjunctions)\\n conjunction_annotations = []\\n all_ann_ids = [annotation[\\\"ann_id\\\"] for annotation in all_annotations \\n if '+' not in annotation[\\\"ann_id\\\"] ]\\n identifier_counter = int(sorted(all_ann_ids, key=lambda x: int(x.replace('T','')))[-1].replace(\\\"T\\\",\\\"\\\"))\\n logger.debug(sorted(all_ann_ids, key=lambda x: int(x.replace('T','')))[-1])\\n for page_obj, line_n, token in true_conjunctions:\\n identifier_counter += 1\\n conjunction_annotation = Annotation(entity_type=\\\"conjunction\\\"\\n , ingestion_timestamp=datetime.utcnow()\\n , annotation_ingester_version=__version__\\n , pageid=meta_annotation.pageid\\n , filename=meta_annotation.filename\\n , bid=meta_annotation.bid)\\n conjunction_annotation.surface = token[\\\"surface\\\"]\\n conjunction_annotation.ann_id = \\\"T%i\\\"%identifier_counter\\n conjunction_annotation.positions.append(PagePosition(page_id = page_obj\\n , start = token[\\\"offset_start\\\"]\\n , end = token[\\\"offset_end\\\"]\\n , line_n = line_n))\\n conjunction_annotation.save()\\n conjunction_annotations.append(conjunction_annotation)\\n logger.info(\\\"(Page: %s) %i conjunction annotations were created and stored in MongoDB\\\"%(page_obj.id\\n , len(conjunction_annotations)))\\n logger.debug(\\\"N %i of top entities before adding conjunction entities\\\"%len(meta_annotation[\\\"top_entities\\\"]))\\n meta_annotation[\\\"top_entities\\\"] += conjunction_annotations\\n logger.debug(\\\"N %i of top entities after adding conjunction entities\\\"%len(meta_annotation[\\\"top_entities\\\"]))\\n Annotation.objects(id=meta_annotation.id).update_one(set__top_entities = meta_annotation[\\\"top_entities\\\"])\\n for conj_annotation in conjunction_annotations:\\n for position in conj_annotation[\\\"positions\\\"]:\\n page = Page.objects(id=position.page_id.id).first()\\n page[\\\"annotations_ids\\\"].append(conj_annotation)\\n page.save()\\n except AssertionError as e:\\n #raise e\\n logger.warning(\\\"The meta-annotation %s has no top-level entities and generated the following error: %s\\\"%(meta_annotation[\\\"_id\\\"],e))\\n except Exception as e:\\n raise e\",\n \"def make_correction_matrix(isotracer, formuladict, na_dict, indist_elems, autodetect, corr_limit):\\n lookup_dict = {'O':['O16','O17','O18'], 'S':['S32','S33','S34'], 'Si':['Si28','Si29','Si30']}\\n trac_atom = get_isotope_element(isotracer)\\n if (isotracer == 'O18' or isotracer == 'S34' or isotracer == 'Si30'):\\n \\tM = make_expected_na_matrix_heavy(formuladict.get(trac_atom, 0), na_dict[trac_atom])\\n else:\\n \\tM = make_expected_na_matrix(formuladict.get(trac_atom, 0), na_dict[trac_atom])\\n M_indist = []\\n\\n indist_elems_copy = copy(indist_elems)\\n na_dict_copy = copy(na_dict)\\n for e in indist_elems:\\n if e in indist_elems_copy:\\n e2 = get_isotope_element(e)\\n if e2 in formuladict:\\n try:\\n if(lookup_dict[e2][1] in indist_elems_copy) and (lookup_dict[e2][2] in indist_elems_copy):\\n corr_limit_1 = int(corr_limit[lookup_dict[e2][1]])\\n corr_limit_2 = int(corr_limit[lookup_dict[e2][2]])\\n M_indist.append(add_indistinguishable_element_for_autodetect_heavy(M, formuladict[e2], na_dict_copy[e2], corr_limit_1, corr_limit_2))\\n indist_elems_copy.remove(lookup_dict[e2][1])\\n indist_elems_copy.remove(lookup_dict[e2][2])\\n\\n elif ((lookup_dict[e2][1] in indist_elems_copy) and (lookup_dict[e2][2] not in indist_elems_copy)) or \\\\\\n ((lookup_dict[e2][1] not in indist_elems_copy) and (lookup_dict[e2][2] in indist_elems_copy)):\\n pos = lookup_dict[e2].index(str(e))\\n list_values = [0]*3\\n list_values[0]= na_dict_copy[e2][0]\\n list_values[pos]= na_dict_copy[e2][pos]\\n na_dict_copy[str(e)]=list_values \\n corr_limit_1 = int(corr_limit[e])\\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\\n\\n else:\\n corr_limit_1 = int(corr_limit[e])\\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\\n\\n except Exception, exception_str:\\n corr_limit_1 = int(corr_limit[e])\\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\\n\\n if M_indist:\\n i = np.eye(M.shape[1])\\n for m in M_indist:\\n m = np.matmul(m, i)\\n i=m\\n M = np.matmul(i, M)\\n return pinv(M)\",\n \"def remove_extra_index_from_context_actions(context_action_dict):\\n keys_to_keep = {'initial_value', 'replacement_value'}\\n for question in context_action_dict:\\n for obj_dct in context_action_dict[question]:\\n total_keys = set(obj_dct.keys())\\n keys_to_remove = total_keys - keys_to_keep\\n for key in keys_to_remove:\\n obj_dct.pop(key)\\n return context_action_dict\",\n \"def process_replies(self, process_scores_only=False) -> None:\\n if self._data.empty:\\n logger.warning(msg=\\\"No survey replies found.\\\")\\n return\\n\\n self._data[cons.SURVEY_REPLY].replace('', np.nan, inplace=True)\\n self._data[cons.SURVEY_REPLY].replace('--deleted-content--', np.nan, inplace=True)\\n survey_replies_with_content = self._data.dropna(subset=[cons.SURVEY_REPLY]).reset_index(\\n drop=True)\\n\\n for row in survey_replies_with_content.itertuples(index=False):\\n comment = self._clean_comments(comment=row.comment)\\n period = \\\"%s_%s\\\" % (row.iteration_week, row.iteration_year)\\n\\n if self._process_prefix and comment is not None:\\n\\n if row.company_id not in self._result:\\n self._result[row.company_id] = {}\\n if period not in self._result[row.company_id]:\\n self._result[row.company_id][period] = {}\\n\\n text = self.__attach_question_to_comment(comment, row, cons.lang_english)\\n score, sentiment = self._process_sentiment(company_id=row.company_id, text=text)\\n\\n reply_data = {}\\n\\n if process_scores_only:\\n reply_data.update(score=score)\\n else:\\n entities_text, entities_type = self._process_entities(comment)\\n\\n reply_data.update(dimension=row.dimension_description)\\n reply_data.update(text=row.comment)\\n reply_data.update(sentiment=sentiment)\\n reply_data.update(entities_text=entities_text,\\n entities_type=list(set(entities_type)))\\n\\n self._result[row.company_id][period][row.survey_reply_id] = {}\\n self._result[row.company_id][period][row.survey_reply_id] = reply_data\\n\\n time.sleep(0.5)\",\n \"def replace_char(line_copy, index_candidates): \\n for idx in index_candidates:\\n line_copy[idx] = idx_vocab[random.choice(range(100, 10000))]\\n\\n return line_copy\",\n \"def batchify(batch):\\n\\n\\tquestion_len = list()\\n\\tlabel_list = list()\\n\\tfor ex in batch:\\n\\t\\tquestion_len.append(len(ex[0]))\\n\\t\\tlabel_list.append(ex[1])\\n\\n\\t'''\\n\\tPadding the labels - unequal length sequences for sequenial data like we have. \\n\\tSince actual labels are 0/1 - we pad with -1, and will use this when 'masking' labels during loss and\\n\\taccuracy evaluation.\\n\\t'''\\n\\ttarget_labels = torch.nn.utils.rnn.pad_sequence([torch.tensor(y) for y in label_list], padding_value=-1).t()\\n\\n\\t# dimension is dimension of every feature vector = n_guesses in this homework setting\\n\\tdim = batch[0][0].shape[1]\\n\\n\\t# similar padding happens for the feature vectors, with vector of all zeros appended.\\n\\tx1 = torch.FloatTensor(len(question_len), max(question_len), dim).zero_()\\n\\tfor i in range(len(question_len)):\\n\\t\\tquestion_feature_vec = batch[i][0]\\n\\t\\tvec = torch.FloatTensor(question_feature_vec)\\n\\t\\tx1[i, :len(question_feature_vec)].copy_(vec)\\n\\tq_batch = {'feature_vec': x1, 'len': torch.FloatTensor(question_len), 'labels': target_labels}\\n\\treturn q_batch\",\n \"def __getitem__(self, index):\\n idx = self.available_idx[index]\\n qn = self.questions[idx]\\n qid = qn['id']\\n house = qn['house']\\n attr, room_attr = self.question_to_attribute(qn)\\n\\n # encode question and answer\\n qe = self.encoded_questions[qn['h5_id']]\\n ae = self.encoded_questions[qn['h5_id']]\\n\\n # choose path_ix\\n path_ix = random.choice(range(qn['num_paths'])) if self.split == 'train' else 0 \\n path_feats_h5 = h5py.File(osp.join(self.path_feats_dir, qn['path_name']+'.h5'), 'r')\\n raw_ego_feats = path_feats_h5['ego_rgb%s' % path_ix][...].reshape(-1, 3200) # (L, 32, 10, 10)\\n raw_path_len = raw_ego_feats.shape[0]\\n raw_actions = qn['path_actions'][path_ix] # (L, )\\n raw_pos_queue = qn['path_positions'][path_ix] # list of L positions\\n if self.requires_imgs:\\n path_images_h5 = h5py.File(osp.join(self.path_images_dir, qn['path_name']+'.h5'), 'r')\\n raw_ego_imgs = path_images_h5['ego_rgb%s' % path_ix] # (L, 224, 224, 3)\\n nav_ego_imgs = []\\n\\n # nav_phrases, nav_phrase_embs\\n nav_pgs = [pg for pg in qn['program'] if 'nav' in pg['function']]\\n nav_ids = [pg['id'][0] for pg in qn['program'] if 'nav' in pg['function']]\\n nav_types = [pg['function'][4:] for pg in qn['program'] if 'nav' in pg['function']]\\n nav_phrases = [pg['value_inputs'][0] for pg in qn['program'] if 'nav' in pg['function']]\\n nav_phrase_embs = []\\n for phrase in nav_phrases:\\n nav_phrase_embs.append(np.array([self.wtov[wd] for wd in phrase.split()]).mean(0).astype(np.float32)) # (300, )\\n nav_phrase_embs = np.array(nav_phrase_embs) # (#targets, 300)\\n\\n # For each segment path: feats + actions + pos_queue\\n raw_key_ixs = qn['key_ixs_set'][path_ix]\\n nav_ego_feats = []\\n nav_action_inputs = []\\n nav_action_outputs = []\\n nav_pos_queues = []\\n for i, key_ix in enumerate(raw_key_ixs):\\n start_ix = 0 if i == 0 else raw_key_ixs[i-1] # we use last key_ix moment as start (spawn location)\\n end_ix = raw_key_ixs[i]+1\\n ego_feats = raw_ego_feats[start_ix:end_ix]\\n action_inputs = np.array([4] + raw_actions[start_ix:end_ix][:-1], dtype=np.int64)\\n action_outputs = np.array(raw_actions[start_ix:end_ix-1] + [3], dtype=np.int64)\\n pos_queue = raw_pos_queue[start_ix:end_ix]\\n assert ego_feats.shape[0] == len(pos_queue) == action_inputs.shape[0]\\n # add to list\\n nav_ego_feats.append(ego_feats)\\n nav_action_inputs.append(action_inputs)\\n nav_action_outputs.append(action_outputs)\\n nav_pos_queues.append(pos_queue)\\n if self.requires_imgs:\\n nav_ego_imgs.append(raw_ego_imgs[start_ix:end_ix])\\n\\n # cache\\n if self.to_cache and index not in self.img_data_cache:\\n self.img_data_cache[index] = True # TODO: replace with ego_feats \\n\\n # private variable\\n self.episode_house = self.env_loaded[house]\\n self.nav_pos_queues = nav_pos_queues\\n self.path_len = raw_path_len\\n\\n # return\\n data = {}\\n data['idx'] = idx\\n data['qid'] = qid\\n data['house'] = qn['house']\\n data['question'] = qn['question']\\n data['answer'] = qn['answer']\\n data['type'] = qn['type']\\n data['attr'] = attr\\n data['qe'] = qe\\n data['ae'] = ae\\n data['path_name'] = qn['path_name']\\n data['path_ix'] = path_ix\\n data['nav_ids'] = nav_ids\\n data['nav_types'] = nav_types\\n data['nav_phrases'] = nav_phrases\\n data['nav_phrase_embs'] = nav_phrase_embs\\n data['nav_ego_feats'] = nav_ego_feats\\n data['nav_action_inputs'] = nav_action_inputs\\n data['nav_action_outputs'] = nav_action_outputs\\n if self.requires_imgs:\\n data['nav_ego_imgs'] = nav_ego_imgs\\n return data\",\n \"def tokenize_replace_pos(doc_list, language_code, replace_pos,\\n core_num=multiprocessing.cpu_count()):\\n param = [[d, language_code, replace_pos] for d in doc_list]\\n pool = multiprocessing.Pool(core_num)\\n return pool.map(_tokenize_replace_pos4map, param)\",\n \"def q_attention(decoder_state, coverage=None):\\n with variable_scope.variable_scope(\\\"Question_Attention\\\"):\\n # Pass the decoder state through a linear layer (this is W_s s_t + b_attn in the paper)\\n decoder_features = linear(decoder_state, attention_vec_size, True) # shape (batch_size, attention_vec_size)\\n decoder_features = tf.expand_dims(tf.expand_dims(decoder_features, 1), 1) # reshape to (batch_size, 1, 1, attention_vec_size)\\n\\n if use_coverage and coverage is not None: # non-first step of coverage\\n # Multiply coverage vector by w_c to get coverage_features.\\n coverage_features = nn_ops.conv2d(coverage, w_q_c, [1, 1, 1, 1], \\\"SAME\\\") # c has shape (batch_size, attn_length, 1, attention_vec_size)\\n\\n # Calculate v^T tanh(W_h h_i + W_s s_t + w_c c_i^t + b_attn)\\n e = math_ops.reduce_sum(v_q * math_ops.tanh(question_features + decoder_features + coverage_features), [2, 3]) # shape (batch_size,attn_length)\\n\\n # Calculate attention distribution\\n attn_dist = masked_attention_q(e, q_padding_mask)\\n\\n # Update coverage vector\\n coverage += array_ops.reshape(attn_dist, [batch_size, -1, 1, 1])\\n else:\\n # Calculate v^T tanh(W_h h_i + W_s s_t + b_attn)\\n e = math_ops.reduce_sum(v_q * math_ops.tanh(question_features + decoder_features), [2, 3]) # calculate e\\n\\n # Calculate attention distribution\\n attn_dist = masked_attention_q(e, q_padding_mask)\\n\\n if use_coverage: # first step of training\\n coverage = tf.expand_dims(tf.expand_dims(attn_dist,2),2) # initialize coverage\\n\\n # Calculate the context vector from attn_dist and encoder_states\\n context_vector = math_ops.reduce_sum(array_ops.reshape(attn_dist, [batch_size, -1, 1, 1]) * question_states, [1, 2]) # shape (batch_size, attn_size).\\n context_vector = array_ops.reshape(context_vector, [-1, attn_size])\\n\\n return context_vector, attn_dist, coverage\",\n \"def replace_tokens(self, tokens):\\n details = []\\n idx = 0\\n if len(tokens) >= min_token_num:\\n for i in range(len(tokens)):\\n old_token = tokens[i]\\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\\n tokens[i] = self.get_delete_token()\\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\\n idx += len(tokens[i])\\n return tokens, details\",\n \"def prepare_for_supervised(embeddings):\\n \\n X, y = [], []\\n for problem in embeddings:\\n pairs = [np.concatenate((problem['question'], problem[i])) \\n for i in ('choice_0', 'choice_1', 'choice_2', 'choice_3')]\\n correct_answer = problem['correct_answer']\\n \\n labels = [0, 0, 0, 0]\\n labels[correct_answer] = 1\\n X.extend(pairs)\\n y.extend(labels)\\n return X, y\",\n \"def pose_qa(self, specificity_sector=0, n_qas=4, n_diff_sectors=3,\\n n_incorrect = 3, plan_file=None, save_posed=True):\\n def test_ans_length(ans, indexes):\\n la = len(ans)\\n if la > indexes.max():\\n return np.array(ans)[indexes]\\n else:\\n return np.array(ans)\\n\\n assert specificity_sector < n_diff_sectors, ('The specificity sector'\\n ' goes from 0 to {}'.format(n_diff_sectors - 1))\\n diff_sector_means = list(map(np.mean, \\n np.array_split(\\n np.array(\\n list(range(10))) / 10.0,\\n n_diff_sectors)))\\n bn_parameter = diff_sector_means[specificity_sector]\\n q_size = self.n_topics * self.n_top_sentences\\n a_size = self.n_top_words\\n ques_idx = np.random.binomial(n=q_size, p=bn_parameter, size=n_qas)\\n anss_idx = np.random.binomial(n=a_size, p=bn_parameter, size=n_qas)\\n\\n if not plan_file is None:\\n self.qa_plan = pd.read_csv(plan_file)\\n self.qa_plan['answers'] = self.qa_plan['answers'] \\\\\\n .apply(ast.literal_eval)\\n\\n ques = self.qa_plan['QA'][ques_idx]\\n anss = [test_ans_length(a, anss_idx)\\n for a in self.qa_plan['answers'][ques_idx]]\\n posed_qas = []\\n for que, ans in zip(ques, anss):\\n if len(ans) >= n_incorrect:\\n for a in ans:\\n correct = tuple(a)\\n q = que.replace(a[0], '_' * len(a[0]))\\n tans = list(map(tuple, ans))\\n tans.pop(tans.index(correct))\\n posed_qas.append(\\n (q, correct, tans)\\n )\\n if save_posed:\\n pd.DataFrame(posed_qas,\\n columns=['question', 'answer', 'bait']) \\\\\\n .to_csv('qa_' + plan_file.split('.')[0] + '.csv',\\n index=False)\\n else:\\n return pd.DataFrame(posed_qas,\\n columns=['question', 'answer', 'bait'])\\n else:\\n plan_qas = {}\\n for i in list(self.qa_plan.keys()):\\n ques = self.qa_plan[i]['QA'][ques_idx]\\n anss = [test_ans_length(a, anss_idx)\\n for a in self.qa_plan[i]['answers'][ques_idx]]\\n #q_tokenized = ' '.join(self.qa_plan[i]['QA'].values.tolist())\\n int_bow = dict(self.interest_bower[i] \\\\\\n .doc2bow(sum(self.int_sentences[i], [])))\\n posed_qas = []\\n for que, ans in zip(ques, anss):\\n if len(ans) >= n_incorrect:\\n for a in ans:\\n correct = tuple(a)\\n q = que.replace(a[0], '_' * len(a[0]))\\n tans = list(map(tuple, ans))\\n tans.pop(tans.index(correct))\\n correct_id = self.interest_bower[i] \\\\\\n .token2id[correct[0]]\\n correct = correct + (int_bow[correct_id], )\\n posed_qas.append((q, correct, tans))\\n\\n if save_posed:\\n pd.DataFrame(posed_qas,\\n columns=['question', 'answer', 'bait']) \\\\\\n .to_csv('qa_for_' + i.replace(' ', '_') + '.csv',\\n index=False)\\n else:\\n plan_qas[i] = pd.DataFrame(posed_qas,\\n columns=['question', 'answer', 'bait'])\\n return plan_qas\",\n \"def insert_values():\\n merged_df = pd.read_csv(\\\"merged_fuzzy_df.csv\\\")\\n df = pd.read_csv(\\\"df.csv\\\")\\n story_entity_df = pd.read_csv(\\\"story_entity_df.csv\\\")\\n\\n merged_df['entity_id'] = merged_df['entity_id'].apply(str)\\n\\n # find and input new types\\n TYPES = get_types_ids(list(story_entity_df[\\\"label\\\"].unique()))\\n\\n new_parents = {}\\n new_alias = {}\\n\\n merged_df[\\\"wiki\\\"].fillna(\\\"\\\", inplace=True)\\n\\n # if score = -2, it needs new alias as well as new parents\\n for index, row in merged_df[merged_df[\\\"score\\\"] == -2].iterrows():\\n\\n # create a new parent\\n if row[\\\"text\\\"] not in new_parents:\\n new_parents[row[\\\"text\\\"]] = [\\n str(uuid.uuid4()),\\n row[\\\"text\\\"],\\n TYPES[row[\\\"label\\\"]],\\n row[\\\"wiki\\\"],\\n True,\\n str(datetime.utcnow())\\n ]\\n\\n merged_df.at[index,\\n \\\"entity_id\\\"] = new_parents[row[\\\"text\\\"]][0]\\n\\n # add alias with corresponding parent ID\\n if row[\\\"text\\\"] not in new_alias:\\n new_alias[row[\\\"text\\\"]] = [\\n str(uuid.uuid4()),\\n row[\\\"text\\\"],\\n row[\\\"wiki\\\"],\\n row[\\\"score\\\"],\\n str(datetime.utcnow()),\\n new_parents[row[\\\"text\\\"]][0],\\n TYPES[row[\\\"label\\\"]]\\n ]\\n\\n for index, row in merged_df[merged_df[\\\"score\\\"] >= -1].iterrows():\\n # if score >= -1, it needs new alias\\n if row[\\\"text\\\"] not in new_alias:\\n new_alias[row[\\\"text\\\"]] = [\\n str(uuid.uuid4()),\\n row[\\\"text\\\"],\\n row[\\\"wiki\\\"],\\n row[\\\"score\\\"],\\n str(datetime.utcnow()),\\n row[\\\"entity_ref_id\\\"],\\n TYPES[row[\\\"label\\\"]]\\n ]\\n\\n merged_df.at[index,\\n \\\"entity_id\\\"] = row[\\\"entity_ref_id\\\"]\\n\\n # if already matched, write story_entity_id into entity_id for mapping\\n for index, row in merged_df[merged_df[\\\"score\\\"].isnull()].iterrows():\\n merged_df.at[index,\\n \\\"entity_id\\\"] = row[\\\"entity_ref_id\\\"]\\n\\n for _, value in new_parents.items():\\n STORY_REF_INPUTS.append(value)\\n\\n for _, value in new_alias.items():\\n ENTITY_ALIAS_INPUTS.append(value)\\n\\n logging.info(\\\"parents: {}\\\".format(len(STORY_REF_INPUTS)))\\n logging.info(\\\"alias: {}\\\".format(len(ENTITY_ALIAS_INPUTS)))\\n\\n columns_to_drop = [\\\"legal_name\\\", \\\"wiki\\\", \\\"label\\\",\\n \\\"entity_ref_id\\\", \\\"entity_name\\\",\\n \\\"text\\\", \\\"score\\\"]\\n merged_df.drop(columns_to_drop, axis=1, inplace=True)\\n\\n # generate uuids for story_map\\n uuids = []\\n for _ in range(len(merged_df)):\\n uuids.append(str(uuid.uuid4()))\\n\\n logging.info(\\\"check na {}\\\".format(merged_df.isnull().values.any()))\\n\\n # input new_entites to table\\n # using entity UUID and story UUID to apis_story_enity_map table\\n\\n merged_df[\\\"uuid\\\"] = uuids\\n merged_df[\\\"created_at\\\"] = str(datetime.utcnow())\\n\\n merged_df = merged_df[[\\\"uuid\\\", \\\"entity_id\\\",\\n \\\"story_uuid\\\", \\\"mentions\\\",\\n \\\"salience\\\", \\\"created_at\\\"]]\\n\\n STORY_MAP_INPUTS = [tuple(row)\\n for row in merged_df.itertuples(index=False)]\\n\\n # see if there are apis_entity elements in the stories\\n match_manual_entity_to_story(df)\\n\\n insert_story_entity_ref(STORY_REF_INPUTS)\\n insert_entity_alias(ENTITY_ALIAS_INPUTS)\\n insert_story_entity_map(STORY_MAP_INPUTS)\\n\\n logging.info(\\\"finished\\\")\\n\\n logging.info(\\\"delete articles without entities\\\")\\n articles_without_entities(df, story_entity_df)\",\n \"def forward(self, passage, question):\\n # Mask: FloatTensor with 0 in positions that are\\n # padding (word index 0) and 1 in positions with actual words.\\n # Make a mask for the passage. Shape: ?\\n # TODO: Your code here.\\n\\n passage_mask = (passage != 0).type(\\n torch.cuda.FloatTensor if passage.is_cuda else\\n torch.FloatTensor)\\n\\n # Make a mask for the question. Shape: ?\\n # TODO: Your code here.\\n\\n question_mask = (question != 0).type(\\n torch.cuda.FloatTensor if question.is_cuda else\\n torch.FloatTensor)\\n\\n\\n # Make a LongTensor with the length (number non-padding words\\n # in) each passage.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Sum along dim 1 to get length of non-padding words for passage\\n passageLengths = passage_mask.sum(dim=1)\\n\\n # Make a LongTensor with the length (number non-padding words\\n # in) each question.\\n # Shape: ?\\n # TODO: Your code here.\\n \\n # Sum along dim 1 to get length of non-padding words for questions\\n questionLengths = question_mask.sum(dim=1)\\n\\n # Part 1: Embed the passages and the questions.\\n # 1.1 Embed the passage.\\n # TODO: Your code here.\\n # Shape: ?\\n\\n # Get passage embedding\\n embedded_passage = self.embedding(passage)\\n\\n # 1.2. Embed the question.\\n # TODO: Your code here.\\n # Shape: ?\\n\\n # Get question embedding\\n embedded_question = self.embedding(question)\\n\\n # Part 2. Encode the embedded passages with the RNN.\\n # 2.1. Sort embedded passages by decreasing order of passage_lengths.\\n # Hint: allennlp.nn.util.sort_batch_by_length might be helpful.\\n # TODO: Your code here.\\n\\n # Sort training batch with allennlp function with passage and lengths as parameters\\n sorted_passage, sorted_passage_lengths, passage_restoration, _ = sort_batch_by_length(embedded_passage, passageLengths)\\n\\n # 2.2. Pack the passages with torch.nn.utils.rnn.pack_padded_sequence.\\n # Hint: Make sure you have the proper value for batch_first.\\n # TODO: Your code here.\\n\\n # pack sequence based on non-padding words\\n packed_passage = pack_padded_sequence(sorted_passage, sorted_passage_lengths, batch_first = True)\\n\\n # 2.3. Encode the packed passages with the RNN.\\n # TODO: Your code here.\\n\\n # get passage representation from GRU\\n passageEncoding, passageHidden = self.gruPassage(packed_passage)\\n\\n # 2.4. Unpack (pad) the passages with\\n # torch.nn.utils.rnn.pad_packed_sequence.\\n # Hint: Make sure you have the proper value for batch_first.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Unpack sequence based on padding words\\n passage_unpacked, lens_unpacked = pad_packed_sequence(passageEncoding, batch_first=True)\\n\\n # 2.5. Unsort the unpacked, encoded passage to restore the\\n # initial ordering.\\n # Hint: Look into torch.index_select or NumPy/PyTorch fancy indexing.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # get unsorted passage using restoration indices\\n unsorted_passage = passage_unpacked.index_select(0, passage_restoration)\\n\\n # Part 3. Encode the embedded questions with the RNN.\\n # 3.1. Sort the embedded questions by decreasing order\\n # of question_lengths.\\n # Hint: allennlp.nn.util.sort_batch_by_length might be helpful.\\n # TODO: Your code here.\\n\\n # Sort question batches\\n sorted_question, sorted_question_lengths, question_restoration, _ = sort_batch_by_length(embedded_question, questionLengths)\\n\\n # 3.2. Pack the questions with pack_padded_sequence.\\n # Hint: Make sure you have the proper value for batch_first.\\n # TODO: Your code here.\\n\\n # pack questions based on padding words\\n packed_question = pack_padded_sequence(sorted_question, sorted_question_lengths, batch_first = True)\\n\\n # 3.3. Encode the questions with the RNN.\\n # TODO: Your code here.\\n\\n # Get question representation from GRU\\n questionEncoding, questionHidden = self.gruQuestion(packed_question)\\n\\n # 3.4. Unpack (pad) the questions with pad_packed_sequence.\\n # Hint: Make sure you have the proper value for batch_first.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Unpack question representation based on padding words\\n question_unpacked, lens_unpacked = pad_packed_sequence(questionEncoding, batch_first = True)\\n\\n # 3.5. Unsort the unpacked, encoded question to restore the\\n # initial ordering.\\n # Hint: Look into torch.index_select or NumPy/PyTorch fancy indexing.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # restore original question ordering using restoration indices\\n unsorted_question = question_unpacked.index_select(0, question_restoration)\\n\\n\\n # Part 4. Calculate attention weights and attend to question.\\n\\n # use softmax to convert weights to probabilities, use those probabilites by multiplying questions to get weighted average\\n # another affine transformation to get the weights from the passages, trainable parameter\\n # define another matrix for attention and multiply that by tensor to get logits, then do softmax from logits to get probability\\n # then computed weighted average from that probability\\n\\n # 4.1. Expand the encoded question to shape suitable for attention.\\n # Hint: Think carefully about what the shape of the attention\\n # input vector should be. torch.unsqueeze and torch.expand\\n # might be useful.\\n # Shape: (batch_size, passage_len, question_len, hidden_dim) (64, 15, 124, 512)\\n # need to get question and passage shape the same\\n # TODO: Your code here.\\n\\n # Goal: (batch_size, passage_len, question_len, hidden_dim) (64, 15, 124, 512)\\n\\n # unsorted question shape is (batch_size, question_len, hidden_dim) (64, , 15 x 512)\\n # passage_mask.size(1) gets max passage size for the mask\\n maxPassageSize = passage_mask.size(1)\\n\\n # Use -1 index within expand to keep original dimensions same and only add passage dimension\\n expanded_question = unsorted_question.unsqueeze(dim=1).expand(-1, maxPassageSize, -1, -1)\\n\\n # 4.2. Expand the encoded passage to shape suitable for attention.\\n # Hint: Think carefully about what the shape of the attention\\n # input vector should be. torch.unsqueeze and torch.expand\\n # might be useful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Get max question size\\n maxQuestionSize = question_mask.size(1)\\n\\n # unsorted pasage shape is (batch_size, passage_len, hidden_dim) (64, 124, 512)\\n # Add question dimension using expand and max question size\\n\\n # Keep all other dimensions the same with -1 index\\n # Unsqueeze adds singleton dimension at place to insert new values\\n expanded_passage = unsorted_passage.unsqueeze(dim=2).expand(-1, -1, maxQuestionSize,-1)\\n\\n\\n # 4.3. Build attention_input. This is the tensor passed through\\n # the affine transform.\\n # Hint: Think carefully what the shape of this tensor should be.\\n # torch.cat might be useful.\\n # Shape: ?\\n\\n # attention_input is the concatenating of 4.1 and 4.2\\n # pass in attention input to affine transformation\\n # use affine_transform function and pass in the concatenated matrix\\n # TODO: Your code here.\\n\\n # concatenate along the last dimension -1 with expanded passages and questions\\n attention_input = torch.cat([expanded_passage, expanded_question,\\n expanded_passage * expanded_question], dim=-1)\\n\\n # 4.4. Apply affine transform to attention input to get\\n # attention logits. You will need to slightly reshape it\\n # into a tensor of the shape you expect.\\n # Shape: \\n # TODO: Your code here.\\n\\n # apply attention transform layer, reshape the last dimension to so logits works with mask\\n attention_logits = self.attention_transform(attention_input).squeeze(-1)\\n\\n # 4.5. Masked-softmax the attention logits over the last dimension\\n # to normalize and make the attention logits a proper\\n # probability distribution.\\n # Hint: allennlp.nn.util.last_dim_softmax might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Get probabilty distribution from logits using softmax, default dim = -1 for last dimension\\n prob_dist = masked_softmax(attention_logits, question_mask)\\n\\n # 4.6. Use the attention weights to get a weighted average\\n # of the RNN output from encoding the question for each\\n # passage word.\\n # Hint: torch.bmm might be helpful.\\n # Shape: ?\\n # use torch.bmm with question to add weights\\n # TODO: Your code here.\\n\\n # compute weighted average using matrix product with bmm\\n # Weighted average = P(event) * event \\n attentionWeights = torch.bmm(prob_dist, unsorted_question)\\n\\n # Part 5: Combine the passage and question representations by\\n # concatenating the passage and question representations with\\n # their product.\\n # 5.1. Concatenate to make the combined representation.\\n # Hint: Use torch.cat\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Get combined representation using formula to add passage representation, weighted average, and element-wise product\\n # Concatenate over last dimension\\n combinedRepresent = torch.cat([unsorted_passage, attentionWeights,\\n unsorted_passage * attentionWeights], dim=-1)\\n\\n # Part 6: Compute logits for answer start index.\\n\\n # 6.1. Apply the affine transformation, and edit the shape.\\n # Shape after affine transformation: ?\\n # Shape after editing shape: ?\\n # TODO: Your code here.\\n\\n # Get start projection using combined representation\\n start_logits = self.start_output_projection(combinedRepresent).squeeze(-1)\\n\\n # 6.2. Replace the masked values so they have a very low score (-1e7).\\n # This tensor is your start_logits.\\n # Hint: allennlp.nn.util.replace_masked_values might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n start_logits = replace_masked_values(start_logits, passage_mask, -1e7)\\n\\n\\n # 6.3. Apply a padding-aware log-softmax to normalize.\\n # This tensor is your softmax_start_logits.\\n # Hint: allennlp.nn.util.masked_log_softmax might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n \\n softmax_start_logits = masked_log_softmax(start_logits, passage_mask)\\n\\n # Part 7: Compute logits for answer end index.\\n\\n # 7.1. Apply the affine transformation, and edit the shape.\\n # Shape after affine transformation: ?\\n # Shape after editing shape: ?\\n # TODO: Your code here.\\n\\n end_logits = self.end_output_projection(combinedRepresent).squeeze(-1)\\n\\n # 7.2. Replace the masked values so they have a very low score (-1e7).\\n # This tensor is your end_logits.\\n # Hint: allennlp.nn.util.replace_masked_values might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n end_logits = replace_masked_values(end_logits, passage_mask, -1e7)\\n\\n # 7.3. Apply a padding-aware log-softmax to normalize.\\n # This tensor is your softmax_end_logits.\\n # Hint: allennlp.nn.util.masked_log_softmax might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n softmax_end_logits = masked_log_softmax(end_logits, passage_mask)\\n\\n # Part 8: Output a dictionary with the start_logits, end_logits,\\n # softmax_start_logits, softmax_end_logits.\\n # TODO: Your code here. Remove the NotImplementedError below.\\n \\n return {\\n \\\"start_logits\\\": start_logits,\\n \\\"end_logits\\\": end_logits,\\n \\\"softmax_start_logits\\\": softmax_start_logits,\\n \\\"softmax_end_logits\\\": softmax_end_logits\\n }\",\n \"def preprocess_nn(json_df, articles_df, vectorizer, max_seq_len, spellcheck=None, use_ngrams=True, credibility_model=None):\\n\\n # Raw Data\\n uids = list(json_df[const.PKL_CLAIM_ID])\\n claims = json_df[const.PKL_CLAIM]\\n claimants = json_df[const.PKL_CLAIMANT]\\n labels = json_df[const.PKL_LABEL]\\n related_articles = json_df[const.PKL_RELATED_ARTICLES]\\n\\n # Processed Data\\n processed_claims = []\\n supporting_info = []\\n credibilities = []\\n final_labels = []\\n\\n start_time = time.time() # Used for tracking only\\n\\n '''\\n Loop through all the claims and their article ID's\\n '''\\n for j, (str_claim, str_claimant, article_ids, label) in enumerate(zip(claims, claimants, related_articles, labels)):\\n\\n # Tracking use only\\n if j % 1000 == 0 and j != 0:\\n now = time.time()\\n log(f\\\"Processing claim {j} | Last 1000 claims took {now - start_time} seconds\\\")\\n start_time = now\\n\\n '''\\n Process Claim: \\n Final Claim = Claimant + Claim\\n - Convert numbers to string representation\\n - Take out all non-alphanumeric\\n - Keep case - may be important\\n '''\\n claim = str_claimant + ' ' + str_claim\\n claim = clean_txt(claim, spellcheck)\\n\\n '''\\n Process articles\\n - Get all articles from the dataframe by ID\\n - Get relevant info from the article, truncated to max_seq_len # of words\\n '''\\n # Get list of article bodies from the dataframe\\n article_ids = [str(article_id) for article_id in article_ids] # Need to lookup by string\\n # Get the articles with the given article ID's and only extract the text column\\n articles = articles_df.loc[articles_df[const.PKL_ARTICLE_ID].isin(article_ids), const.PKL_ARTICLE_TXT]\\n\\n # If using credibility, we separate the articles\\n if credibility_model is not None:\\n for article in articles:\\n credibility = get_credibility(article, credibility_model)\\n support_txt = get_relevant_info(claim, [article], vectorizer, max_seq_len, spellcheck, use_ngrams)\\n # Add to list\\n credibilities.append(credibility)\\n processed_claims.append(claim)\\n supporting_info.append(support_txt)\\n final_labels.append(label)\\n\\n else:\\n # If we are not using credibility model, construct support text from all articles\\n support_txt = get_relevant_info(claim, articles, vectorizer, max_seq_len, spellcheck, use_ngrams)\\n # Add to list\\n processed_claims.append(claim)\\n supporting_info.append(support_txt)\\n final_labels.append(label)\\n\\n # Return what's appropriate\\n if credibility_model is not None:\\n return uids, processed_claims, supporting_info, final_labels, credibilities\\n else:\\n return uids, processed_claims, supporting_info, final_labels\",\n \"def batch_inference(question,context): \\n inputs = tokenizer(question, context, \\n return_tensors='pt', \\n truncation=True, \\n padding=True)\\n \\n # Move data to GPU\\n inputs = inputs.to(device)\\n \\n # Feed data through the model\\n with torch.no_grad():\\n outputs = model(**inputs)\\n\\n # Q&A model outputs the two logit scores for each word.\\n # One for its chance of being the start of the answer\\n # and one for its chance of being the end\\n start_logits = outputs.start_logits\\n end_logits = outputs.end_logits\\n \\n # Find the words with the highest score\\n # argmax(dim=1) means argmax with each sample\\n start = start_logits.argmax(dim=1)\\n end = end_logits.argmax(dim=1)\\n \\n # Return the answers\\n # This is the point where we move the prediction back to main memory with .cpu()\\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\\\"input_ids\\\"].cpu().numpy()]\\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]\",\n \"def __getitem__(self, idx):\\n pos_pid = self.valid_passage_ids[idx]\\n psg = self.passage_sent_dict[pos_pid]\\n assert(len(psg) > 1)\\n\\n # randomly select a sentence as the question\\n qid = random.choice(range(len(psg)))\\n query = psg[qid]\\n query_tokens = self.tokenizer.encode(query)\\n\\n # remove the selected sentence with 1 - sent_keep probability, this psg is the positive psg.\\n sent_remove_flag = random.random() > self.sent_keep\\n pos_psg = \\\" \\\".join(psg[:qid] + psg[qid+sent_remove_flag:])\\n postive_psg_tokens = self.tokenizer.encode(pos_psg)\\n\\n # randomly sample from the rest to get negative samples.\\n\\n # extract a percentage of hard examples\\n hard_k = int(self.sampled_softmax_n * self.hard_negative_rate)\\n passage_set = self.passageids_set - set([pos_pid])\\n hard_negatives = set([item for item in passage_set if item.split('.')[0] == pos_pid.split('.')[0]])\\n\\n # handle edge case for \\n if len(hard_negatives) >= hard_k:\\n npids_hard = random.sample(hard_negatives, k=hard_k)\\n else:\\n npids_hard = []\\n hard_k = 0\\n\\n # extract a percentage of easy examples\\n rest_k = self.sampled_softmax_n - hard_k\\n npids_rest = random.sample(self.passageids_set - set([pos_pid]) - set(npids_hard), k=rest_k)\\n\\n # putting it all together\\n npids = npids_hard + npids_rest\\n negative_psg_tokens_list = [self.passage_dict[pid] for pid in npids]\\n\\n return query_tokens, postive_psg_tokens, negative_psg_tokens_list, pos_pid, npids\",\n \"def vectorize_data(data, word_idx, sentence_size, memory_size,answer_size):\\n S = []\\n Q = []\\n AS = []\\n L = []\\n label_nums = set([len(dt[2]) for dt in data])\\n assert(len(label_nums) == 1)\\n label_num = list(label_nums)[0]\\n for story, query, answer, label in data:\\n lq = max(0, sentence_size - len(query))\\n q = [word_idx[w] for w in query] + [0] * lq\\n\\n ss = []\\n for i, sentence in enumerate(story, 1):\\n ls = max(0, sentence_size - len(sentence))\\n ss.append([word_idx[w] for w in sentence] + [0] * ls)\\n\\n if len(ss) > memory_size:\\n # Use Jaccard similarity to determine the most relevant sentences\\n q_words = set(q)\\n least_like_q = sorted(ss, cmp = lambda x, y: jaccard(set(x), q_words) < jaccard(set(y), q_words))[:len(ss)-memory_size]\\n for sent in least_like_q:\\n # Remove the first occurrence of sent. A list comprehension as in [sent for sent in ss if sent not in least_like_q]\\n # should not be used, as it would remove multiple occurrences of the same sentence, some of which might actually make the cutoff.\\n ss.remove(sent)\\n else:\\n # pad to memory_size\\n lm = max(0, memory_size - len(ss))\\n for _ in range(lm):\\n ss.append([0] * sentence_size)\\n\\n y = np.zeros(len(word_idx) + 1) # 0 is reserved for nil word\\n\\n sa = []\\n for i, sentence in enumerate(answer, 1):\\n ls = max(0, answer_size - len(sentence))\\n sa.append([word_idx[w] for w in sentence] + [0] * ls)\\n\\n lb = np.zeros(label_num)\\n lb[int(label)] = 1\\n\\n S.append(ss)\\n Q.append(q)\\n AS.append(sa)\\n L.append(lb)\\n Q = pad_sequences(Q, sentence_size)\\n\\n return np.array(S), np.array(Q), np.array(AS), np.array(L)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5196209","0.508824","0.50696385","0.50494385","0.50279325","0.49846712","0.4941945","0.493053","0.49194095","0.49090177","0.4737878","0.47329834","0.47198913","0.46659964","0.46623522","0.46447614","0.46400312","0.46255264","0.4593311","0.4577011","0.4553052","0.45498338","0.4548689","0.45354375","0.45288414","0.45238003","0.45065495","0.44846725","0.4481304","0.44753987","0.44639072","0.44572785","0.44568098","0.4431633","0.44185036","0.441168","0.44094327","0.4407664","0.44074914","0.44073004","0.44055083","0.4400589","0.43871143","0.43829027","0.43802086","0.4375181","0.43739763","0.43618247","0.43611413","0.43589005","0.435177","0.43426263","0.43323213","0.4314521","0.43107873","0.43044996","0.43002355","0.4296221","0.42889526","0.42856315","0.4281862","0.42746022","0.42686355","0.42669868","0.4263383","0.42335358","0.42327407","0.4226592","0.4223583","0.42146176","0.4213192","0.4202993","0.42000648","0.4199991","0.41975492","0.41908944","0.4189647","0.41855648","0.4183359","0.41825318","0.41789722","0.41774544","0.41735446","0.41673192","0.41618085","0.41614327","0.41581964","0.41574174","0.41550848","0.41485822","0.41420832","0.4140182","0.41392487","0.41363537","0.41258305","0.41244397","0.4112953","0.41097352","0.4109385","0.4108247"],"string":"[\n \"0.5196209\",\n \"0.508824\",\n \"0.50696385\",\n \"0.50494385\",\n \"0.50279325\",\n \"0.49846712\",\n \"0.4941945\",\n \"0.493053\",\n \"0.49194095\",\n \"0.49090177\",\n \"0.4737878\",\n \"0.47329834\",\n \"0.47198913\",\n \"0.46659964\",\n \"0.46623522\",\n \"0.46447614\",\n \"0.46400312\",\n \"0.46255264\",\n \"0.4593311\",\n \"0.4577011\",\n \"0.4553052\",\n \"0.45498338\",\n \"0.4548689\",\n \"0.45354375\",\n \"0.45288414\",\n \"0.45238003\",\n \"0.45065495\",\n \"0.44846725\",\n \"0.4481304\",\n \"0.44753987\",\n \"0.44639072\",\n \"0.44572785\",\n \"0.44568098\",\n \"0.4431633\",\n \"0.44185036\",\n \"0.441168\",\n \"0.44094327\",\n \"0.4407664\",\n \"0.44074914\",\n \"0.44073004\",\n \"0.44055083\",\n \"0.4400589\",\n \"0.43871143\",\n \"0.43829027\",\n \"0.43802086\",\n \"0.4375181\",\n \"0.43739763\",\n \"0.43618247\",\n \"0.43611413\",\n \"0.43589005\",\n \"0.435177\",\n \"0.43426263\",\n \"0.43323213\",\n \"0.4314521\",\n \"0.43107873\",\n \"0.43044996\",\n \"0.43002355\",\n \"0.4296221\",\n \"0.42889526\",\n \"0.42856315\",\n \"0.4281862\",\n \"0.42746022\",\n \"0.42686355\",\n \"0.42669868\",\n \"0.4263383\",\n \"0.42335358\",\n \"0.42327407\",\n \"0.4226592\",\n \"0.4223583\",\n \"0.42146176\",\n \"0.4213192\",\n \"0.4202993\",\n \"0.42000648\",\n \"0.4199991\",\n \"0.41975492\",\n \"0.41908944\",\n \"0.4189647\",\n \"0.41855648\",\n \"0.4183359\",\n \"0.41825318\",\n \"0.41789722\",\n \"0.41774544\",\n \"0.41735446\",\n \"0.41673192\",\n \"0.41618085\",\n \"0.41614327\",\n \"0.41581964\",\n \"0.41574174\",\n \"0.41550848\",\n \"0.41485822\",\n \"0.41420832\",\n \"0.4140182\",\n \"0.41392487\",\n \"0.41363537\",\n \"0.41258305\",\n \"0.41244397\",\n \"0.4112953\",\n \"0.41097352\",\n \"0.4109385\",\n \"0.4108247\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.48166406"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":84899,"cells":{"query":{"kind":"string","value":"Replaces each Quora question with indexes corressponding to respective position of tokens in embedding matrix. If include_unknown is true, then replaces with corressponding index, ignores otherwise."},"document":{"kind":"string","value":"def predict_sentences_2_idxs(self):\n fo = open(self.config.parsed_predict_file, 'w')\n self.load_dicts()\n\n questions = pd.read_csv(self.config.predict_file,\n usecols=[\"question_text\"], index_col=False)\n unk_idx = self.word2idx[self.config.unknown_token]\n\n for quest in questions.question_text:\n tokens = preprocess_text(quest)\n if self.config.include_unknown:\n idxs = [self.word2idx.get(token, unk_idx) for token in\n tokens]\n else:\n idxs = [self.word2idx.get(token) for token in tokens]\n idxs = [idx for idx in idxs if idx]\n fo.write((str(\" \".join(str(num) for num in idxs)) + \"\\n\"))"},"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 embed(raw_seq, index_dict):\n return np.asarray([index_dict[word.lower()]\n if word.lower() in index_dict\n else index_dict[OOV_TOKEN] for word in raw_seq])","def convert_questions_to_features(examples, tokenizer, max_query_length=None):\n\n unique_id = 1000000000\n question_features = []\n\n for (example_index, example) in enumerate(tqdm(examples, desc='Converting questions')):\n\n query_tokens = tokenizer.tokenize(example.question_text)\n if max_query_length is None:\n max_query_length = len(query_tokens)\n if len(query_tokens) > max_query_length:\n query_tokens = query_tokens[0:max_query_length]\n\n for _ in enumerate(range(1)):\n tokens_ = []\n tokens_.append(\"[CLS]\")\n for token in query_tokens:\n tokens_.append(token)\n tokens_.append(\"[SEP]\")\n\n input_ids_ = tokenizer.convert_tokens_to_ids(tokens_)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask_ = [1] * len(input_ids_)\n\n # Zero-pad up to the sequence length.\n while len(input_ids_) < max_query_length + 2:\n input_ids_.append(0)\n input_mask_.append(0)\n\n assert len(input_ids_) == max_query_length + 2\n assert len(input_mask_) == max_query_length + 2\n\n if example_index < 1:\n # logger.info(\"*** Example ***\")\n # logger.info(\"unique_id: %s\" % (unique_id))\n # logger.info(\"example_index: %s\" % (example_index))\n logger.info(\"tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in query_tokens]))\n # logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids_]))\n # logger.info(\n # \"input_mask: %s\" % \" \".join([str(x) for x in input_mask_]))\n\n question_features.append(\n QuestionFeatures(\n unique_id=unique_id,\n example_index=example_index,\n tokens_=tokens_,\n input_ids=input_ids_,\n input_mask=input_mask_))\n unique_id += 1\n\n return question_features","def qa_ctx_attention(self, qa_embed, ctx_embed, qa_mask, ctx_mask, noun_mask, non_visual_vectors):\n num_img, num_region = ctx_mask.shape[2:]\n u_a, raw_s, s_mask, s_normalized = self.str_attn(qa_embed, ctx_embed, qa_mask, ctx_mask, noun_mask=noun_mask, void_vector=non_visual_vectors)\n qa_embed = qa_embed.repeat(1, 1, num_img, 1, 1)\n mixed = torch.cat([qa_embed, u_a, qa_embed * u_a], dim=-1)\n mixed = self.c2q_down_projection(mixed)\n mixed_mask = (s_mask.sum(-1) != 0).float()\n return mixed, mixed_mask, raw_s, s_normalized","def _lost_answers_indexes(self, df, tokenized_contexts):\n whole_answers_start = df[\"answer_start\"].tolist()\n whole_answers_end = df[\"answer_end\"].tolist()\n lost_dirty, lost_truncated = [], []\n for i, (c, s, e) in enumerate(\n zip(tokenized_contexts, whole_answers_start, whole_answers_end)\n ):\n mask = (\n torch.tensor(c.attention_mask, device=self.device).bool()\n & ~torch.tensor(c.special_tokens_mask, device=self.device).bool()\n )\n offsets = torch.tensor(c.offsets, device=self.device)[mask]\n start_index = torch.nonzero(offsets[:, 0] == s)\n end_index = torch.nonzero(offsets[:, 1] == e)\n if len(start_index) == 0 or len(end_index) == 0:\n if s > offsets[-1, 0] or e > offsets[-1, 1]:\n lost_truncated.append(i)\n else:\n lost_dirty.append(i)\n\n return lost_truncated, lost_dirty","def enseemble_results_extra(self, questions, topn):\n ok_vocab = self.get_vocabulary()\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\n new_vocab = {w.upper(): v for w, v in new_vocab}\n new_vocab = dict(new_vocab)\n\n results = []\n for line_no, line in enumerate(utils.smart_open(questions)):\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\n line = utils.to_unicode(line)\n if line.startswith(': '):\n continue\n else:\n\n try:\n a, b, c, expected = [word.upper() for word in line.split()]\n except ValueError:\n logger.info(\"skipping invalid line #%i in %s\", line_no, questions)\n continue\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\n \"\"\"if a not in new_vocab:\n print(\"Dont know: \" + a)\n if b not in new_vocab:\n print(\"Dont know: \" + b)\n if c not in new_vocab:\n print(\"Dont know: \" + c)\n if expected not in new_vocab:\n print(\"Dont know: \" + expected)\n \"\"\"\n logger.debug(\"skipping line #%i with OOV words: %s\", line_no, line.strip())\n results.append(None)\n continue\n\n original_vocab = self.get_vocabulary()\n self.set_vocabulary(new_vocab)\n ignore = {a, b, c} # input words to be ignored\n #print('topn')\n #print(topn)\n # find the most likely prediction, ignoring OOV words and input words\n sims = self.most_similar(positive_words=[b, c], negative_words=[a], topn = topn)\n # print(\"sims\")\n #print(sims)\n self.set_vocabulary(original_vocab)\n inner_results = []\n for predict in sims:\n predicted = predict[0]\n predicted = predicted.upper()\n predicted_tuple = (predicted, predict[1])\n #print(predicted_tuple)\n inner_results.append(predicted_tuple)\n #print(predicted)\n results.append(inner_results)\n #print(results)\n\n return results","def parse_question(question):\n\tcontext = question['support']\n\tanswer = question['correct_answer']\n\ttarget = question['question']\n\n\tcontext_words = context.split(\" \")[0: 510]\n\ttarget_words = target.split(\" \")\n\n\tpunc_filter = str.maketrans('', '', string.punctuation)\n\n\tcontext_words = [word.translate(punc_filter) for word in context_words]\n\ttarget_words = [word.translate(punc_filter) for word in target_words]\n\tanswer_words = [word.translate(punc_filter) for word in answer.split(\" \")]\n\n\tbio_embeddings = [EMBEDER['O']]\n\tinside_answer = False\n\tanswer_index = 0\n\tcan_be_inside_answer = True\n\n\t# The following loop and above code does:\n\t# -Find where the answer is and place a B tag\n\t# -While still in the answer (the answer is more than one word) put an I tag\n\t# -Outside of the answer place a O tag\n\t# -Start and end with an O tag for BERT's automatic\n\t# -start token and end token representing the start and end of a sentence.\n\tfor word in context_words:\n\t\tif word.lower() == answer_words[0].lower() and can_be_inside_answer:\n\t\t\tbio_embeddings.append(EMBEDER[\"B\"])\n\t\t\tanswer_index += 1\n\t\t\tinside_answer = True\n\t\t\tcan_be_inside_answer = False\n\t\telif inside_answer:\n\t\t\tif len(answer_words) > 1:\n\t\t\t\tif word.lower() != answer_words[answer_index]:\n\t\t\t\t\tinside_answer = False\n\t\t\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\t\t\t\telse:\n\t\t\t\t\tbio_embeddings.append(EMBEDER[\"I\"])\n\t\t\telse:\n\t\t\t\tinside_answer = False\n\t\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\t\telse:\n\t\t\tbio_embeddings.append(EMBEDER[\"O\"])\n\tbio_embeddings.append(EMBEDER[\"O\"])\n\n\tground_truth = torch.tensor([BERT_TOKENIZER.encode(target_words)])\n\tcontext_words = torch.tensor([BERT_TOKENIZER.encode(context_words)])\n\n\tassert len(bio_embeddings) == len(context_words[0]), f'The BIO tags are not equal in length to the embeddings! ' \\\n\t f'{None} & {len(bio_embeddings)} & {len(context_words[0])}'\n\treturn context_words, bio_embeddings, ground_truth","def replace_q_indices(circuit, q_nums, qr):\n\n new_circuit = qiskit.QuantumCircuit(qr)\n for op in circuit.data:\n original_qubits = op.qargs\n new_op = copy.deepcopy(op)\n new_op.qargs = [(qr, q_nums[x]) for x in [arg[1] for arg in original_qubits]]\n new_circuit.data.append(new_op)\n\n return new_circuit","def replace_canonical_referents(self, **kwargs):\n replaced_count = 0\n for doc in self.annotation_documents:\n for sen in doc.sentences:\n for part in sen.participants:\n replaced_count += part.replace_by_canonical_referent(**kwargs) #this will replace in-place in project, but returns a count too.\n\n return replaced_count","def process_question_for_prediction(question):\n question = __set_has_hexadecimal(question)\n question = __set_has_numeric(question)\n homework_list = constants.HOMEWORK_SYNONMS_LIST\n homework_list.sort(key=len, reverse=True)\n replacement_text = constants.QUESTION_HAS_HOMEWORK_KEY\n question = __set_has_homework_or_assignment(question, replacement_text, homework_list)\n question = stem_training_data(question)\n return question","def sentences_2_idxs(self):\n fo_pos = open(self.config.parsed_train_file_pos, 'w')\n fo_neg = open(self.config.parsed_train_file_neg, 'w')\n self.load_dicts()\n labels = pd.read_csv(self.config.train_file, usecols=[\"target\"])\n\n labels = list(labels.values[:, 0])\n questions = pd.read_csv(self.config.train_file,\n usecols=[\"question_text\"], index_col=False)\n unk_idx = self.word2idx.get(self.config.unknown_token)\n\n for label, quest in zip(labels, questions.question_text):\n tokens = preprocess_text(quest)\n\n if self.config.include_unknown:\n idxs = [self.word2idx.get(token, unk_idx) for token in\n tokens]\n else:\n idxs = [self.word2idx.get(token) for token in tokens]\n idxs = [idx for idx in idxs if idx]\n out_line = (str(\" \".join(str(num) for num in idxs)) + \"\\n\")\n if label == 1:\n fo_pos.write(out_line)\n else:\n fo_neg.write(out_line)","def preprocess_dataset(dataset, tokenizer):\n eos = torch.tensor([tokenizer.eos_token_id], dtype=torch.long)\n q_start = torch.tensor(tokenizer.encode('question:'), dtype=torch.long)\n q_end = torch.tensor(tokenizer.encode(':question'), dtype=torch.long)\n\n tensors = [[] for i in range(3)]\n for i in trange(len(dataset)):\n example = dataset[i]\n\n context_start_idx = (example[2] == 1).nonzero()[0].item()\n if example[1][-1] == 1:\n context_end_idx = len(example[1]) - 1\n else:\n context_end_idx = (example[1] == 0).nonzero()[0].item()\n ans_start = example[3] - context_start_idx\n ans_end = example[4] - context_start_idx\n\n context = example[0][context_start_idx: context_end_idx]\n question = example[0][: context_start_idx]\n answer = example[0][example[3]: example[4] + 1]\n\n input_ids = torch.cat([\n context,\n eos,\n answer,\n eos,\n q_start,\n question,\n q_end,\n eos\n ])\n\n attention_mask = torch.ones_like(input_ids, dtype=torch.long)\n token_type_ids = torch.cat([\n torch.zeros(len(context) + 1, dtype=torch.long),\n torch.ones(len(answer) + 1, dtype=torch.long),\n 2 * torch.ones(len(question) + 3, dtype=torch.long)\n ])\n token_type_ids[ans_start: ans_end + 1] = 1\n\n tensors[0].append(input_ids)\n tensors[1].append(attention_mask)\n tensors[2].append(token_type_ids)\n\n tensors_padded = []\n for i, sequences in enumerate(tqdm(tensors)):\n padded = pad_sequence(sequences, batch_first=True)\n tensors_padded.append(padded)\n\n new_dataset = TensorDataset(*tensors_padded)\n return new_dataset","def substitute_num(self, numbers, qa3_answer):\n question = self\n for match in re.finditer('[0-9]+', question):\n num = match.group(0)\n i = qa3_answer.index_by_chunk(num)\n if i is None or qa3_answer.result[i].get_type() != 'refYear':\n if num not in numbers:\n numbers.append(num)\n question = re.sub(num, '<NUM' + string.ascii_uppercase[numbers.index(num)] + '>', question, 1)\n return Qa3Question(question)","def rearrange_indices(self):\n num_fixed_words = 2\n other_words = [w for w in self.word2index if w not in self.equivariant_words]\n for idx, word in enumerate(self.equivariant_words):\n w_idx = idx + num_fixed_words\n self.word2index[word] = w_idx\n self.index2word[w_idx] = word\n for idx, word in enumerate(sorted(other_words)):\n w_idx = idx + num_fixed_words + self.num_equivariant_words\n self.word2index[word] = w_idx\n self.index2word[w_idx] = word","def replace_by_canonical_referent(self, cross_sentence=True):\n replaced_count = 0\n\n # replace the participant in their containers\n def replace_in_containers(myobj, replacing):\n containers = {\n \"event\": \"participants\",\n \"sentiment_expression\": \"targets\",\n \"sentence\": \"participants\",\n }\n for c_name, attrib_n in containers.items():\n c_name = f\"in_{c_name}\"\n if hasattr(myobj, c_name):\n for c in getattr(myobj, c_name):\n to_replace_in = getattr(c, attrib_n)\n to_replace_in.append(replacing)\n if myobj in to_replace_in:\n to_replace_in.remove(myobj)\n to_replace_in.sort(key=lambda x: x.begin)\n\n if self.canonical_referents and self.canonical_referents != \"from_canonref\":\n # sometimes there are multiple canonrefs tagged\n # this can be a) annotation mistake or\n # b) multiple reference to a group, e.g. \"all\" refers to three companies.\n for canonref in self.canonical_referents:\n # check whether canonical referent is in same sentence\n same_sentence = [s.element_id for s in self.in_sentence] == [\n s.element_id for s in canonref.in_sentence\n ]\n # always replace when cross_sentence is true\n # if cross_sentence is False (disallowed) only replace when canonref is in same sentence\n if cross_sentence or same_sentence:\n # replace element\n replacing_participant = Participant(\n canonref.text,\n canonref.begin,\n canonref.end,\n canonref.element_id,\n canonref.annotator_id,\n canonref.document_title,\n canonref.in_document,\n self.role,\n \"from_canonref\",\n self.link_id,\n canonref.tokens,\n )\n replacing_participant.in_sentence = self.in_sentence\n replacing_participant.in_document = self.in_document\n if hasattr(self, \"in_sentiment_expression\"):\n replacing_participant.in_sentiment_expression = (\n self.in_sentiment_expression\n )\n replacing_participant.from_original_participant = copy(self)\n print(\n f\"Replaced {self} with {canonref}. (in same sentence:{same_sentence})\"\n )\n\n replace_in_containers(self, replacing_participant)\n\n # replace on document\n self.in_document.participants.append(replacing_participant)\n if self in self.in_document.participants:\n self.in_document.participants.remove(self)\n\n replaced_count += 1\n return replaced_count","def enseemble_results(self, questions, topn):\n ok_vocab = self.get_vocabulary()\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\n new_vocab = {w.upper(): v for w, v in new_vocab}\n new_vocab = dict(new_vocab)\n\n results = []\n for line_no, line in enumerate(utils.smart_open(questions)):\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\n line = utils.to_unicode(line)\n if line.startswith(': '):\n continue\n else:\n\n try:\n a, b, c, expected = [word.upper() for word in line.split()]\n except ValueError:\n logger.info(\"skipping invalid line #%i in %s\", line_no, questions)\n continue\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\n \"\"\"if a not in new_vocab:\n print(\"Dont know: \" + a)\n if b not in new_vocab:\n print(\"Dont know: \" + b)\n if c not in new_vocab:\n print(\"Dont know: \" + c)\n if expected not in new_vocab:\n print(\"Dont know: \" + expected)\n \"\"\"\n logger.debug(\"skipping line #%i with OOV words: %s\", line_no, line.strip())\n results.append(None)\n continue\n\n original_vocab = self.get_vocabulary()\n self.set_vocabulary(new_vocab)\n ignore = {a, b, c} # input words to be ignored\n #print('topn')\n #print(topn)\n # find the most likely prediction, ignoring OOV words and input words\n sims = self.most_similar(positive_words=[b, c], negative_words=[a], topn = topn)\n # print(\"sims\")\n #print(sims)\n self.set_vocabulary(original_vocab)\n inner_results = []\n for predict in sims:\n predicted = predict[0]\n predicted = predicted.upper()\n\n inner_results.append(predicted)\n #print(predicted)\n results.append(inner_results)\n #print(results)\n\n return results","def preprocess(self, sequence, word2idx):\n story = [word2idx[word] if word in word2idx else UNK_token for word in sequence.split()]\n story = torch.Tensor(story)\n return story","def preprocess(self, sequence, word2idx):\n context = [word2idx[word]\n if word in word2idx else UNK_token for word in sequence.split()]\n context = torch.Tensor(context)\n return context","def __getitem__(self, idx):\n\n ############ 1.9 TODO\n # figure out the idx-th item of dataset from the VQA API\n image_id_from_idx = self._vqa.questions['questions'][idx]['image_id']\n question_id_from_idx = self._vqa.questions['questions'][idx]['question_id']\n question_sentence = self._vqa.questions['questions'][idx]['question']\n answer_sentences = [ans['answer'] for ans in self._vqa.qa[question_id_from_idx]['answers']]\n\n # import pdb; pdb.set_trace()\n\n ############\n\n # if self._cache_location is not None and self._pre_encoder is not None:\n # ############ 3.2 TODO\n # # implement your caching and loading logic here\n\n # ############\n # raise NotImplementedError()\n # else:\n ############ 1.9 TODO\n # load the image from disk, apply self._transform (if not None)\n # import ipdb; ipdb.set_trace()\n image_id_from_idx_string = self.fixed_str + str(image_id_from_idx)\n truncated_image_id_from_idx = image_id_from_idx_string[-12:]\n img_file_path = self._image_dir + '/' + self._image_filename_pattern.format(truncated_image_id_from_idx)\n image = Image.open(img_file_path)\n image = image.convert(\"RGB\")\n image = self._transform(image)\n ############\n # raise NotImplementedError()\n\n ############ 1.9 TODO\n # load and encode the question and answers, convert to torch tensors\n question_encoding = torch.zeros(self._max_question_length, self.question_word_list_length)\n answer_encoding = torch.zeros(10,self.answer_list_length)\n\n question_word_list = self._create_word_list(question_sentence)\n # print(idx,question_word_list)\n # print(len(self.question_word_to_id_map.keys()))\n # quit()\n for i, word in enumerate(question_word_list):\n # import ipdb; ipdb.set_trace()\n # print(i,word)\n # quit()\n if i >= self._max_question_length:\n break\n if word not in self.question_word_to_id_map.keys():\n map_idx = self.unknown_question_word_index\n else:\n map_idx = self.question_word_to_id_map[word]\n question_encoding[i][map_idx] = 1\n\n # answer_sentence_list = self._create_word_list(answer_sentences)\n for i, answer in enumerate(answer_sentences):\n if answer not in self.answer_to_id_map.keys():\n map_idx = self.unknown_answer_index\n else:\n map_idx = self.answer_to_id_map[answer]\n answer_encoding[i][map_idx] = 1\n \n data = {'image':image, 'question':question_encoding, 'answer':answer_encoding}\n return data\n\n ############\n # raise NotImplementedError()","def _filter_unanswerable_samples(self):\n a = []\n q = []\n annotations = []\n for i in range(len(self.answers)):\n if len(self.answers[i].nonzero()) > 0:\n a.append(self.answers[i])\n q.append(self.questions[i])\n\n annotations.append(self.annotations[i])\n self.answers = a\n self.questions = q\n self.annotations = annotations","def dynamic(question_quantized_dfs):\n all_transitions = {}\n\n for i, qdf in enumerate(question_quantized_dfs):\n q = qdf.iloc[:, utils.SKIP_COLUMNS:] # don't work on audio_rms column\n\n all_transitions[i] = OrderedDict()\n\n for au in q:\n all_transitions[i][au] = np.zeros((4, 4))\n\n for (x, y), c in Counter(zip(q[au], q[au][1:])).items():\n all_transitions[i][au][x - 1, y - 1] += c # TODO some warning about non-integer index\n\n # Concatenate all AU triples right, then all question down\n temp1 = []\n for k, q_transitions in all_transitions.items():\n temp2 = []\n\n for au, trans in q_transitions.items():\n trans_features = list(transition_features(trans))\n trans_index = [au + '_change_ratio', au + '_slow_change_ratio', au + '_fast_change_ratio']\n\n temp2.append(pd.DataFrame(trans_features, index=trans_index).T)\n temp1.append(pd.concat(temp2, axis=1))\n\n question_dynamic_features = pd.concat(temp1, axis=0)\n\n # Fix index\n question_dynamic_features.index = range(len(question_quantized_dfs))\n\n return question_dynamic_features","def process_question(qu):\n\n ## global ranking\n rank_info = {}\n rank_info_k = [\"viewcount\",\"score\",\"favoritecount\"]\n for k in rank_info_k:\n rank_info[k] = int(qu[k])\n qu.pop(k,None)\n\n rank_info[\"creationdate\"] = qu[\"creationdate\"]\n\n if qu[\"acceptedanswer\"]:\n qu[\"acceptedanswer\"] = list(qu[\"acceptedanswer\"])\n else:\n qu[\"acceptedanswer\"] = []\n\n qu.pop('comments',None) # discard comments, maybe add back later\n qu[\"rank_info\"] = rank_info\n\n return qu","def replace_special_token(self, tokenizer_fields: Dict[str, torch.Tensor], positions: List[int], replace_id: int):\n token_ids, offsets = tokenizer_fields[\"token_ids\"], tokenizer_fields[\"offsets\"]\n for pos in positions:\n offset = offsets[pos].numpy().tolist()\n if offset[0] != offset[1]:\n warnings.warn(f\"replace normally expect token in `positions` has not been split to pieces.\"\n f\"This warning should NOT happen unless during batch prediction at evaluation\")\n token_ids[offset[0]] = replace_id","def _encode_question(self, question):\n \n inputs = self.tokenizer.encode_plus(\n question,\n None,\n add_special_tokens=True,\n max_length=self.max_len,\n )\n\n ids = inputs[\"input_ids\"]\n mask = inputs[\"attention_mask\"]\n token_type_ids = inputs[\"token_type_ids\"]\n\n padding_length = self.max_len - len(ids)\n ids += ([0]*padding_length)\n mask += ([0]*padding_length)\n token_type_ids += ([0]*padding_length)\n \n return {\n 'ids': torch.tensor(ids, dtype=torch.long),\n 'mask': torch.tensor(mask, dtype=torch.long),\n 'token_type_ids': torch.tensor(token_type_ids, dtype=torch.long),\n \n }","def preprocess_seq(self, sequence, word2idx):\n story = []\n for value in sequence:\n #v = [word2idx[word] if word in word2idx else UNK_token for word in value.split()] + [EOS_token]\n story.append(word2idx[value] if value in word2idx else UNK_token)\n story = torch.Tensor(story)\n return story","def convert_single_example(example, tokenizer, is_training, args):\n tok_to_orig_index = []\n orig_to_tok_index = []\n all_doc_tokens = [] # all subtokens of original doc after tokenizing\n features = []\n for (i, token) in enumerate(example['paragraph_tokens']):\n orig_to_tok_index.append(len(all_doc_tokens))\n sub_tokens = albert_tokenize(tokenizer, token)\n tok_to_orig_index.extend([i] * len(sub_tokens))\n all_doc_tokens.extend(sub_tokens)\n\n # 特别注意！由于在paragraph_tokens中我们的token已经映射过一次了\n # 这里wordpiece等于又映射了一遍，所以这里的操作是二次映射\n if example['position_map']:\n tok_to_orig_index = [example['position_map'][index] for index in tok_to_orig_index]\n\n # QUERY\n query_tokens = []\n query_tokens.append(\"[Q]\")\n query_tokens.extend(albert_tokenize(tokenizer, example['question_text']))\n if len(query_tokens) > args.max_query_length:\n query_tokens = query_tokens[-args.max_query_length:]\n\n # ANSWER 预处理的时候先长短分开\n tok_start_position = -1\n tok_end_position = -1\n # 这里终点是必然在para_tokens内的\n if is_training:\n # 现阶段，有短答案预测短答案，否则预测长答案\n if example['answer_type'] != AnswerType['UNKNOWN']:\n tok_long_start_position = orig_to_tok_index[example['long_start']]\n if example['long_end'] == len(orig_to_tok_index):\n tok_long_end_position = orig_to_tok_index[-1]\n else:\n tok_long_end_position = orig_to_tok_index[example['long_end']] - 1\n tok_start_position = tok_long_start_position\n tok_end_position = tok_long_end_position\n if example['answer_type'] == AnswerType['SHORT']:\n tok_short_start_position = orig_to_tok_index[example['short_start']]\n if example['short_end'] == len(orig_to_tok_index):\n tok_short_end_position = orig_to_tok_index[-1]\n else:\n tok_short_end_position = orig_to_tok_index[example['short_end']] - 1\n tok_start_position = tok_short_start_position\n tok_end_position = tok_short_end_position\n\n # Get max tokens number for original doc,\n # should minus query tokens number and 3 special tokens\n # The -3 accounts for [CLS], [SEP] and [SEP]\n max_tokens_for_doc = args.max_seq_length - len(query_tokens) - 3\n\n # We can have documents that are longer than the maximum sequence length.\n # To deal with this we do a sliding window approach, where we take chunks\n # of up to our max length with a stride of `doc_stride`.\n _DocSpan = collections.namedtuple(\"DocSpan\", [\"start\", \"length\"])\n doc_spans = []\n start_offset = 0\n while start_offset < len(all_doc_tokens):\n length = len(all_doc_tokens) - start_offset # compute number of tokens remaining unsliding\n length = min(length, max_tokens_for_doc) # determine current sliding window size\n doc_spans.append(_DocSpan(start=start_offset, length=length))\n\n # Consider case for reaching end of original doc\n if start_offset + length == len(all_doc_tokens):\n break\n start_offset += min(length, args.doc_stride)\n\n # Convert window + query + special tokens to feature\n for (doc_span_index, doc_span) in enumerate(doc_spans):\n tokens = []\n token_to_orig_map = {}\n token_is_max_context = {}\n segment_ids = []\n tokens.append(\"[CLS]\")\n segment_ids.append(0)\n tokens.extend(query_tokens)\n segment_ids.extend([0] * len(query_tokens))\n tokens.append(\"[SEP]\")\n segment_ids.append(0)\n\n for i in range(doc_span.length):\n split_token_index = doc_span.start + i\n token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\n\n is_max_context = check_is_max_context(doc_spans, doc_span_index, split_token_index)\n token_is_max_context[len(tokens)] = is_max_context\n tokens.append(all_doc_tokens[split_token_index])\n segment_ids.append(1)\n tokens.append(\"[SEP]\")\n segment_ids.append(1)\n assert len(tokens) == len(segment_ids)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (args.max_seq_length - len(input_ids))\n input_ids.extend(padding)\n input_mask.extend(padding)\n segment_ids.extend(padding)\n\n assert len(input_ids) == args.max_seq_length\n assert len(input_mask) == args.max_seq_length\n assert len(segment_ids) == args.max_seq_length\n\n start_position = None\n end_position = None\n answer_type = None\n answer_text = \"\"\n if is_training:\n doc_start = doc_span.start\n doc_end = doc_span.start + doc_span.length - 1\n # For training, if our document chunk does not contain an annotation\n # we throw it out, since there is nothing to predict.\n contains_an_annotation = (tok_start_position >= doc_start and tok_end_position <= doc_end)\n # 负样本需要经过采样，且目标为[CLS]\n if (not contains_an_annotation) or example['answer_type'] == AnswerType['UNKNOWN']:\n if args.include_unknowns < 0 or random.random() > args.include_unknowns:\n continue\n start_position = 0\n end_position = 0\n answer_type = AnswerType['UNKNOWN']\n else:\n doc_offset = len(query_tokens) + 2\n start_position = tok_start_position - doc_start + doc_offset\n end_position = tok_end_position - doc_start + doc_offset\n answer_type = example['answer_type']\n\n # 如果是短答案，对一下答案是否正确\n if example['answer_type'] == AnswerType['SHORT']:\n answer_text = \" \".join(tokens[start_position:(end_position + 1)])\n answer_text = answer_text.replace(' ', '').replace(u\"▁\", ' ').strip()\n gt_answer = example['short_answer_text'].lower()\n answer_text_chars = [c for c in answer_text if c not in \" \\t\\r\\n\" and ord(c) != 0x202F]\n gt_answer_chars = [c for c in gt_answer if c not in \" \\t\\r\\n\" and ord(c) != 0x202F]\n if \"\".join(answer_text_chars) != \"\".join(gt_answer_chars):\n print(answer_text, 'V.S.', gt_answer)\n\n feature = InputFeatures(\n unique_id=None,\n example_index=None,\n doc_span_index=doc_span_index,\n tokens=tokens,\n token_to_orig_map=token_to_orig_map,\n token_is_max_context=token_is_max_context,\n input_ids=input_ids,\n input_mask=input_mask,\n segment_ids=segment_ids,\n start_position=start_position,\n end_position=end_position,\n answer_text=answer_text,\n answer_type=answer_type)\n\n features.append(feature)\n\n return features","def convert_examples_to_features(examples, tokenizer, max_seq_length):\n \n features = []\n num_tokens_article = []\n count = 0\n masking_token_id = tokenizer.convert_tokens_to_ids(['[MASK]'])[0]\n # padding_token_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)\n for example_index, example in enumerate(examples):\n article_tokens = tokenizer.tokenize(example['article'])\n ques_tokens = tokenizer.tokenize(example['question'].replace(\"@placeholder\", \"_\"))\n masked_index = ques_tokens.index('_')\n ques_tokens[masked_index] = '[MASK]'\n \n# options = example['options']\n options = tokenizer.convert_tokens_to_ids(example['options'])\n# print(options, '\\n')\n\n choices_features = []\n _truncate_seq_pair(article_tokens, ques_tokens, max_seq_length - 3)\n\n# tokens = [\"[CLS]\"] + ques_tokens + [\"[SEP]\"] + article_tokens + [\"[SEP]\"]\n tokens = ques_tokens + [\"[SEP]\"] + article_tokens + [\"[SEP]\"]\n\n# segment_ids = [0] * (len(ques_tokens) + 2) + [1] * (len(article_tokens) + 1)\n segment_ids = [0] * (len(ques_tokens) + 1) + [1] * (len(article_tokens) + 1)\n\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\n input_mask = [1] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding = [0] * (max_seq_length - len(input_ids))\n input_ids += padding\n input_mask += padding\n segment_ids += padding\n\t\n candidates = example['options']\n candidates_ids = tokenizer.convert_tokens_to_ids(candidates)\n# print(tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0])\n\n lm_labels = [-1 if t_id != masking_token_id else tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0] for t_id in input_ids]\n# lm_labels = [t_id if t_id != 0 else -1 for t_id in input_ids]\n# for i, t_id in enumerate(lm_labels) :\n# if(t_id == masking_token_id):\n# lm_labels[i] = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\n\n# print(lm_labels, '\\n')\n # tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n assert len(segment_ids) == max_seq_length\n assert len(lm_labels) == max_seq_length\n\n choices_features.append((tokens, input_ids, input_mask, segment_ids))\n\n features.append(\n InputFeatures(\n choices_features = choices_features,\n lm_labels = lm_labels,\n options = options,\n label = example['label']\n )\n )\n \n return features","def words_to_tensor(words, words_lookup_index, include_eos=True, numbers_replace=True, unknown_replace=True):\n if type(words) != list: raise Exception(\"Expected a list (not a string etc)\")\n tensor_length = len(words) + 1 if include_eos else len(words)\n # tensor = np.zeros((1, tensor_length, len(words_lookup_index)), dtype=np.float32)\n tensor = torch.zeros(1, tensor_length, len(words_lookup_index))\n\n for i, w in enumerate(words):\n if w in words_lookup_index:\n tensor[0, i, words_lookup_index[w]] = 1\n elif numbers_replace and re_includes_numbers.search(w):\n tensor[0, i, words_lookup_index[NUMBER_WORD_TOKEN]] = 1\n elif unknown_replace:\n tensor[0, i, words_lookup_index[UNKNOWN_WORD_TOKEN]] = 1\n else:\n raise Exception(\"Did not find item in index\")\n\n if include_eos:\n tensor[0, -1, words_lookup_index[EOS_TOKEN]] = 1\n return tensor","def answerer(embeddings, tuples: tf.Variable, scoring=multilinear):\n n_data, n_slots, rank = [d.value for d in embeddings.get_shape()]\n n_data, n_tuples, order = [d.value for d in tuples.get_shape()]\n\n shift_indices = tf.constant(np.reshape(\n np.outer(range(n_data), np.ones(n_tuples * n_slots)) * n_slots, (n_data, n_tuples, n_slots)), dtype='int64')\n questions_shifted = tuples + shift_indices\n\n preds = scoring(\n tf.reshape(embeddings, (n_data * n_slots, rank)),\n tf.reshape(questions_shifted, (n_data * n_tuples, order)))\n\n return tf.reshape(preds, (n_data, n_tuples))","def substitute_from_qa3(self, result, index, dataset):\n question = self\n if re.search(result.chunk, question):\n if result.is_dataset(dataset):\n question = re.sub(result.chunk, '<DATASET>', question)\n elif result.is_type('refYear'):\n question = re.sub(result.chunk, '<YEAR' + str(index) + '>', question)\n elif result.is_identifier():\n question = re.sub(result.chunk, '<PROP' + str(index) + '>', question)\n else:\n question = re.sub(result.chunk, '<VALUE' + str(index) + '>', question)\n return Qa3Question(question)","def additional_text_preprocessing_with_pos(pos_dict):\n\n tags_to_lemmatize = ['a', 'n', 'v', 'r']\n\n pos_dict = TextPreprocessor.find_named_entities(pos_dict)\n if pos_dict is None:\n return None, None\n prepro = list()\n contains_spelling_mistake = False\n for t in pos_dict:\n token = t['token']\n tag = t['tag'].lower()\n if token not in TextPreprocessor.PUNCTUATION and tag != \",\":\n\n token = TextPreprocessor.replace_user_mentions(token)\n token = TextPreprocessor.replace_urls(token)\n replaced = [token]\n for i in replaced:\n\n i = TextPreprocessor.replace_all_punctuation(i)\n if i.lower() not in TextPreprocessor.STOPWORDS and i != 'URL' and i!= 'USERMENTION':\n if i != \"\" and not re.match('\\B#\\w*[a-zA-Z]+\\w*', i):\n before = i\n i = TextPreprocessor.SPELL_CHECKER.correct(i, tag)\n if i != before:\n contains_spelling_mistake = True\n if tag in tags_to_lemmatize:\n i = TextPreprocessor.lemmatize(i, tag)\n i = TextPreprocessor.stem(i, tag)\n # check again, since stemming, lemmatization or spelling correction can produce stopwords\n # if i.lower() not in TextPreprocessor.STOPWORDS:\n if i != 'URL' and i!= 'USERMENTION' and i!='':\n i = i.lower()\n if re.match(\".*[a-zA-Z]'\", i):\n i = i[:-1]\n prepro.append(i)\n return prepro, contains_spelling_mistake","def filter_ordered_questions_by_concepts(questions, item_params, target_concept, concept_map): \n \n def get_parents(target, concept_map):\n \"\"\"\n Given a target concept, return a list of concept IDs for parent concepts\n \"\"\"\n parents = []\n target_index = concept_map[CONCEPTS_STR].index(target)\n for row in range(len(concept_map[ADJ_MAT_STR])): \n # get value in adjMat for each row at target concept's col\n val = concept_map[ADJ_MAT_STR][row][target_index] \n if val > 0 and target_index != row: # don't care concepts are their own parents\n # print('parent found at {}, {}'.format(row, target_index)) # TODO remove\n parents.append(concept_map[CONCEPTS_STR][row])\n return parents\n\n def get_children(target, concept_map):\n \"\"\"\n Given a target concept, return a list of concept IDs for all child concepts\n \"\"\"\n child_inds = []\n target_index = concept_map[CONCEPTS_STR].index(target)\n target_row = concept_map[ADJ_MAT_STR][target_index]\n for ind in range(len(target_row)): # for each ind in row of adj mat\n val = target_row[ind]\n if(val>0 and ind != target_index): # don't care concept is child of itself\n child_inds.append(ind)\n return list(map(lambda ind: concept_map[CONCEPTS_STR][ind], child_inds))\n\n def get_concept(eid, item_params):\n \"\"\"\n Given a question/exercise eid (String) and item_params (pd.DataFrame),\n return the concept that exercise corresponds to.\n\n Assumes eid is unique (maps to exactly 1 row)\n \"\"\"\n\n concept = item_params[item_params[EID]==eid][CONCEPT]\n\n if len(concept) < 1: # TODO: make this filter \"!= 1\" to be more strict\n raise Exception(\"Exercise ID does not map to any exercises. eid: {}\".format(eid))\n else:\n return concept.iloc[0] # to get actual value\n \n df_item_params = pd.DataFrame.from_dict(item_params)\n\n rec_eids = []\n\n # get all recommendations from target, its children, parents\n rec_eids += list(filter(lambda q: get_concept(q, df_item_params) in \n [target_concept] + \n get_children(target_concept, concept_map) +\n get_parents(target_concept, concept_map), questions))\n \n # # GET TOP FOR EACH RELATIONSHIP\n # # add max_num_target questions of same concept to rec_eids\n # rec_target = list(filter(lambda q: get_concept(q, df_item_params) == target_concept, \n # questions))[:max_num_target]\n # # print(\"For target, added {}\".format(rec_target))\n # rec_eids += rec_target\n \n\n # # add max_num_child questions of child concepts to rec_eids\n # rec_child = list(filter(lambda q: get_concept(q, df_item_params) in get_children(target_concept, concept_map), \n # questions))[:max_num_child]\n # # print(\"For children, added {}\".format(rec_child ))\n # rec_eids += rec_child\n\n # # add max_num_parent questions of parent concepts to rec_eids\n # rec_parent = list(filter(lambda q: get_concept(q, df_item_params) in get_parents(target_concept, concept_map), \n # questions))[:max_num_parent] \n # # print(\"For parents, added {}\".format(rec_parent))\n # rec_eids += rec_parent \n\n # want order of recommendations to stay same & only grab from top half of recommendations\n # return list(filter(lambda eid: eid in rec_eids, questions[:int(len(questions)/2)+1])) \n\n # want order of recommendations to stay same\n return list(filter(lambda eid: eid in rec_eids, questions))","def vectorize(ex, model, single_answer=False):\r\n word_dict = model.word_dict\r\n tgt_dict = model.tgt_dict\r\n\r\n if model.args.use_elmo:\r\n # Index words\r\n document = torch.from_numpy(np.asarray(elmo_sent_mapper(ex['document']), dtype=np.int))\r\n if(model.args.reader_type!='summarizer'):\r\n question = torch.from_numpy(np.asarray(elmo_sent_mapper(ex['question']), dtype=np.int))\r\n\r\n # When using elmo, char representations are not required\r\n document_chars, question_chars = -1, -1\r\n else:\r\n # Index words\r\n document = torch.LongTensor([word_dict[w] for w in ex['document']])\r\n if(model.args.reader_type!='summarizer'):\r\n question = torch.LongTensor([word_dict[w] for w in ex['question']])\r\n\r\n # Index chars\r\n if model.args.reader_type == 'mlstm' or \\\r\n model.args.reader_type == 'areader':\r\n document_chars, question_chars = -2, -2\r\n else:\r\n document_chars = torch.LongTensor([word_dict.word_to_char_ids(w).tolist() for w in ex['document']])\r\n if(model.args.reader_type!='summarizer'):\r\n question_chars = torch.LongTensor([word_dict.word_to_char_ids(w).tolist() for w in ex['question']])\r\n\r\n # ...or with target(s) (might still be empty if answers is empty)\r\n # handle if questions are unanswerable [SQuAD v2.0]\r\n if(model.args.reader_type!='summarizer'):\r\n \r\n if single_answer:\r\n assert (len(ex['answers']) > 0)\r\n answer = torch.LongTensor([tgt_dict[w] for w in ex['answers'][0]])\r\n else:\r\n # FIXME: multiple answers are possible, fix batchify also.\r\n # answer = [torch.LongTensor([word_dict[w] for w in ans]) for ans in ex['answers']]\r\n answer = torch.LongTensor([tgt_dict[w] for w in ex['answers'][0]])\r\n else:\r\n summary = torch.LongTensor([tgt_dict[w] for w in ex['summary']])\r\n\r\n\r\n if(model.args.reader_type!='summarizer'):\r\n return document, document_chars, question, question_chars, answer, \\\r\n ex['id'], ex['document'], ex['question'], ex['answers'], \\\r\n ex['src_vocab']\r\n else:\r\n return document, document_chars, summary, ex['id'], ex['document'], ex['summary'], ex['src_vocab']","def own_accuracy(self, questions):\n ok_vocab = self.get_vocabulary()\n print(\"ok vocab\")\n #print(ok_vocab)\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\n print(\"not dict\")\n #new_vocab = [w.upper() for w in ok_vocab]\n #print(new_vocab)\n new_vocab = {w.upper(): v for w, v in new_vocab}\n new_vocab = dict(new_vocab)\n #print(new_vocab)\n\n\n\n\n sections, section = [], None\n wrong_predictions = []\n for line_no, line in enumerate(utils.smart_open(questions)):\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\n line = utils.to_unicode(line)\n if line.startswith(': '):\n # a new section starts => store the old section\n if section:\n sections.append(section)\n self.log_accuracy(section)\n section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}\n else:\n if not section:\n raise ValueError(\"missing section header before line #%i in %s\" % (line_no, questions))\n try:\n a, b, c, expected = [word.upper() for word in line.split()]\n except ValueError:\n logger.info(\"skipping invalid line #%i in %s\", line_no, questions)\n continue\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\n if a not in new_vocab:\n print(\"Dont know: \" + a)\n if b not in new_vocab:\n print(\"Dont know: \" + b)\n if c not in new_vocab:\n print(\"Dont know: \" + c)\n if expected not in new_vocab:\n print(\"Dont know: \" + expected)\n logger.debug(\"skipping line #%i with OOV words: %s\", line_no, line.strip())\n continue\n\n original_vocab = self.get_vocabulary()\n self.set_vocabulary(new_vocab)\n ignore = {a, b, c} # input words to be ignored\n\n # find the most likely prediction, ignoring OOV words and input words\n sims = self.most_similar(positive_words=[b, c], negative_words=[a])\n #print(\"sims\")\n #print(sims)\n self.set_vocabulary(original_vocab)\n\n predicted = sims[0][0]\n predicted = predicted.upper()\n #print(predicted)\n if predicted == expected:\n section['correct'].append((a, b, c, expected))\n else:\n wrong_message = a + \" \" + b + \" \" + c + \", predicted: \" + predicted + \", should have been: \" + expected\n section['incorrect'].append((a, b, c, expected))\n wrong_predictions.append(wrong_message)\n if section:\n # store the last section, too\n sections.append(section)\n self.log_accuracy(section)\n\n total = {\n 'section': 'total',\n 'correct': sum((s['correct'] for s in sections), []),\n 'incorrect': sum((s['incorrect'] for s in sections), []),\n }\n self.log_accuracy(total)\n sections.append(total)\n print(wrong_predictions)\n return sections","def fix_keyword_detection_issues(\n dset: List, organ2ind: Dict\n): \n \n \"\"\"SOLVE CARDIA\"\"\" \n\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if (\n \"cardiac\" in keywords\n and \"stomach\" in occ_organ_names\n and any(\n [\n item in organ_names\n for item in [\"atrium\", \"ventricle\", \"myocardium\", \"pericardium\"]\n ]\n )\n ):\n occ_organ_indices.remove(organ2ind[\"stomach\"])\n occ_organ_names.remove(\"stomach\")\n if (\n \"cardia\" in keywords\n and \"myocardium\" in occ_organ_names\n and any([item in organ_names for item in [\"stomach\"]])\n ):\n occ_organ_indices.remove(organ2ind[\"myocardium\"])\n occ_organ_names.remove(\"myocardium\")\n abstract[\"occ_organ_indices\"] = occ_organ_indices\n abstract[\"occ_organ_names\"] = occ_organ_names\n\n inds = []\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if \"cardiac\" in keywords and \"stomach\" in occ_organ_names:\n inds.append(ind)\n\n \"\"\"SOLVE THE LIVER - DELIVER PROBLEM\"\"\"\n\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if (\n any(\n [\n keyword in keywords\n for keyword in [\"delivery\", \"delivered\", \"deliver\", \"delivering\"]\n ]\n )\n and \"liver\" not in organ_names\n ):\n occ_organ_indices.remove(organ2ind[\"liver\"])\n occ_organ_names.remove(\"liver\")\n keywords = [\n keyword\n for keyword in keywords\n if keyword not in [\"delivery\", \"delivered\", \"deliver\", \"delivering\"]\n ]\n abstract[\"occ_organ_indices\"] = occ_organ_indices\n abstract[\"occ_organ_names\"] = occ_organ_names\n abstract[\"keywords\"] = keywords\n\n \"\"\"SOLVE THE COLON - COLONISE PROBLEM\"\"\"\n\n inds = []\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if (\n any(\n [\n keyword in keywords\n for keyword in [\n \"colonize\",\n \"colonise\",\n \"colonized\",\n \"colonised\",\n \"colonies\",\n ]\n ]\n )\n and \"colon\" not in organ_names\n ):\n occ_organ_indices.remove(organ2ind[\"colon\"])\n occ_organ_names.remove(\"colon\")\n keywords = [\n keyword\n for keyword in keywords\n if keyword\n not in [\"colonize\", \"colonise\", \"colonized\", \"colonised\", \"colonies\"]\n ]\n abstract[\"occ_organ_indices\"] = occ_organ_indices\n abstract[\"occ_organ_names\"] = occ_organ_names\n abstract[\"keywords\"] = keywords\n\n \"\"\"SOLVE THE BLADDER - GALLBLADDER PROBLEM\"\"\"\n\n \"\"\"Gallbladder doesn't cause the bladder keyword\"\"\"\n \"\"\"Bladder does cause problems\"\"\"\n\n for ind, abstract in tqdm(enumerate(dset)):\n keywords = abstract[\"keywords\"]\n occ_organ_indices = abstract[\"occ_organ_indices\"]\n occ_organ_names = abstract[\"occ_organ_names\"]\n organ_names = abstract[\"organ_names\"]\n if (\n any([keyword in keywords for keyword in [\"bladder\", \"bladders\"]])\n and any(\n [\n keyword in keywords\n for keyword in [\n \"gall\",\n \"gallbladder\",\n \"gall-bladder\",\n \"gallbladders\",\n \"gall-bladders\",\n ]\n ]\n )\n and \"gallbladder\" in organ_names\n ):\n occ_organ_indices.remove(organ2ind[\"urinary bladder\"])\n occ_organ_names.remove(\"urinary bladder\")\n keywords = [\n keyword\n for keyword in keywords\n if keyword not in [\"bladder\", \"bladders\"]\n ]\n abstract[\"occ_organ_indices\"] = occ_organ_indices\n abstract[\"occ_organ_names\"] = occ_organ_names\n abstract[\"keywords\"] = keywords\n\n return dset","def _process_row(self, question):\n\n # this returns a list, e.g. [('today', 'DATE'), ('Patrick', 'PERSON')]\n ent_lst = self.text_preprocessor.compute_ner(question.context)\n\n ent_dct = {}\n for ent_str, ner_category in ent_lst:\n # perform uncasing\n ent_dct[ent_str.lower()] = ner_category\n\n new_answers = []\n for ans_struct in question.answers:\n ans_text = ans_struct['text'].lower() # perform uncasing\n if ans_text not in ent_dct:\n continue\n\n ans_struct['ner_category'] = ent_dct[ans_text]\n new_answers.append(ans_struct)\n\n question.answers = new_answers\n return question","def replace_oov_words_by_unk(tokenized_sentences, vocabulary, unknown_token=\"<unk>\"):\r\n \r\n # Place vocabulary into a set for faster search\r\n vocabulary = set(vocabulary)\r\n \r\n # Initialize a list that will hold the sentences\r\n # after less frequent words are replaced by the unknown token\r\n replaced_tokenized_sentences = []\r\n \r\n for sentence in tokenized_sentences:\r\n \r\n\r\n replaced_sentence = []\r\n\r\n for token in sentence: \r\n \r\n if token in vocabulary:\r\n replaced_sentence.append(token)\r\n else:\r\n replaced_sentence.append(unknown_token)\r\n \r\n # Append the list of tokens to the list of lists\r\n replaced_tokenized_sentences.append(replaced_sentence)\r\n \r\n return replaced_tokenized_sentences","def _compute_question_ids(self):\n if self._origin.question_ids:\n # lines to keep: those with already sent emails or registrations\n questions_tokeep_ids = self.env['event.registration.answer'].search(\n [('question_id', 'in', self._origin.question_ids.ids)]\n ).question_id.ids\n else:\n questions_tokeep_ids = []\n for event in self:\n if not event.event_type_id and not event.question_ids:\n event.question_ids = False\n continue\n\n if questions_tokeep_ids:\n questions_toremove = event._origin.question_ids.filtered(lambda question: question.id not in questions_tokeep_ids)\n command = [(3, question.id) for question in questions_toremove]\n else:\n command = [(5, 0)]\n if event.event_type_id.use_mail_schedule:\n command += [\n (0, 0, {\n 'title': question.title,\n 'question_type': question.question_type,\n 'sequence': question.sequence,\n 'once_per_order': question.once_per_order,\n 'answer_ids': [(0, 0, {\n 'name': answer.name,\n 'sequence': answer.sequence\n }) for answer in question.answer_ids],\n }) for question in event.event_type_id.question_ids\n ]\n event.question_ids = command","def question_new_translate():","def encode_answers(df, schema):\n encoders = get_encoders(schema)\n\n for question in schema.questions:\n df[question.prediction_encoded] = encoders[question.name].transform(df[question.prediction])\n\n return df","def special_danish_accuracy(self, questions):\n ok_vocab = self.get_vocabulary()\n print(\"ok vocab\")\n #print(ok_vocab)\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\n print(\"not dict\")\n #new_vocab = [w.upper() for w in ok_vocab]\n #print(new_vocab)\n new_vocab = {w.upper(): v for w, v in new_vocab}\n new_vocab = dict(new_vocab)\n #print(new_vocab)\n\n\n\n\n sections, section = [], None\n wrong_predictions = []\n for line_no, line in enumerate(utils.smart_open(questions)):\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\n line = utils.to_unicode(line)\n if line.startswith(': '):\n # a new section starts => store the old section\n if section:\n sections.append(section)\n self.log_accuracy(section)\n section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}\n else:\n if not section:\n raise ValueError(\"missing section header before line #%i in %s\" % (line_no, questions))\n try:\n a, b, c, d, e, expected = [word.upper() for word in line.split()]\n except ValueError:\n logger.info(\"skipping invalid line #%i in %s\", line_no, questions)\n continue\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or d not in new_vocab or e not in new_vocab or expected not in new_vocab:\n #print('not in vocab')\n logger.debug(\"skipping line #%i with OOV words: %s\", line_no, line.strip())\n continue\n\n original_vocab = self.get_vocabulary()\n self.set_vocabulary(new_vocab)\n ignore = {a, b, c, d, e} # input words to be ignored\n\n # find the most likely prediction, ignoring OOV words and input words\n sims = self.most_similar(positive_words=[c, d, e], negative_words=[a, b])\n #print(\"sims\")\n #print(sims)\n self.set_vocabulary(original_vocab)\n\n predicted = sims[0][0]\n predicted = predicted.upper()\n #print(predicted)\n if predicted == expected:\n section['correct'].append((a, b, c, d, e, expected))\n else:\n wrong_message = a + \" \" + b + \" \" + c + \" \" + d + \" \" + e + \", predicted: \" + predicted + \", should have been: \" + expected\n section['incorrect'].append((a, b, c, d, e, expected))\n wrong_predictions.append(wrong_message)\n if section:\n # store the last section, too\n sections.append(section)\n self.log_accuracy(section)\n\n total = {\n 'section': 'total',\n 'correct': sum((s['correct'] for s in sections), []),\n 'incorrect': sum((s['incorrect'] for s in sections), []),\n }\n self.log_accuracy(total)\n sections.append(total)\n print(wrong_predictions)\n return sections","def _tokenize_replace_pos(text, language_code, replace_pos):\n seq = annotool.raw2basicseq(text, language_code, pos=True)\n word_seq = seq['word']\n pos_seq = seq['pos']\n for i, pos in enumerate(pos_seq):\n if pos in replace_pos:\n word_seq[i] = '[{}]'.format(pos)\n return word_seq","def encode_decode_TD(self, n_step, idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ ):\r\n\r\n actor_embedding = embed_seq(input_seq=self.input_, from_=self.dimension, to_= self.input_embed, is_training=self.is_training, BN=True, initializer=self.initializer)\r\n actor_encoding = encode_seq(input_seq=actor_embedding, input_dim=self.input_embed, num_stacks=self.num_stacks, num_heads=self.num_heads, num_neurons=self.num_neurons, is_training=self.is_training)\r\n \r\n if self.is_training == False:\r\n actor_encoding = tf.tile(actor_encoding,[self.batch_size,1,1])\r\n \r\n idx_list = copy(idx_list_previous)\r\n log_probs = copy(log_probs_previous)\r\n entropies = copy(entropies_previous)\r\n \r\n\r\n mask = copy(mask_previous)\r\n \r\n n_hidden = actor_encoding.get_shape().as_list()[2] # input_embed\r\n W_ref = tf.get_variable(\"W_ref\",[1, n_hidden, self.num_units],initializer=self.initializer)\r\n W_q = tf.get_variable(\"W_q\",[self.query_dim, self.num_units],initializer=self.initializer)\r\n v = tf.get_variable(\"v\",[self.num_units],initializer=self.initializer)\r\n \r\n encoded_ref = tf.nn.conv1d(actor_encoding, W_ref, 1, \"VALID\") # actor_encoding is the ref for actions [Batch size, seq_length, n_hidden]\r\n \r\n query1 = copy( query1_previous)\r\n query2 = copy( query2_previous)\r\n query3 = copy( query3_previous)\r\n idx_copy = copy(idx_)\r\n \r\n W_1 =tf.get_variable(\"W_1\",[n_hidden, self.query_dim],initializer=self.initializer) # update trajectory (state)\r\n W_2 =tf.get_variable(\"W_2\",[n_hidden, self.query_dim],initializer=self.initializer)\r\n W_3 =tf.get_variable(\"W_3\",[n_hidden, self.query_dim],initializer=self.initializer)\r\n \r\n \r\n \"\"\"\r\n # sample from POINTER from the perspective of the Actor\r\n \"\"\"\r\n for step in range(n_step + 1 ): \r\n query = tf.nn.relu(tf.matmul(query1, W_1) + tf.matmul(query2, W_2) + tf.matmul(query3, W_3))\r\n logits = pointer(encoded_ref=encoded_ref, query=query, mask=mask, W_ref=W_ref, W_q=W_q, v=v, C=config.C, temperature=config.temperature)\r\n prob = distr.Categorical(logits) # logits = masked_scores\r\n idx = prob.sample()\r\n\r\n idx_list.append(idx) # tour index\r\n idx_list_previous.append(idx)\r\n \r\n log_probs.append(prob.log_prob(idx)) # log prob\r\n log_probs_previous.append(prob.log_prob(idx))\r\n \r\n entropies.append(prob.entropy()) # entropies\r\n entropies_previous.append(prob.entropy())\r\n \r\n mask = mask + tf.one_hot(idx, self.max_length) # mask\r\n mask_previous = mask_previous + tf.one_hot(idx, self.max_length)\r\n\r\n idx_copy = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \r\n idx_ = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \r\n query3 = query2\r\n query2 = query1\r\n query1 = tf.gather_nd(actor_encoding, idx_) # update trajectory (state)\r\n \r\n query3_previous = query2_previous\r\n query2_previous = query1_previous\r\n query1_previous = tf.gather_nd(actor_encoding, idx_) # update trajectory (state) \r\n\r\n if (len(idx_list) >= self.max_length): break #leave the loop if reach the end of the episode\r\n\r\n \"\"\"\r\n # sample from POINTER from the perspective of the Critic\r\n make q_t vector = 0\r\n \"\"\"\r\n while(len(idx_list) < self.max_length): \r\n \r\n logits = pointer_critic(encoded_ref=encoded_ref, mask=mask, W_ref=W_ref, v=v, C=config.C, temperature=config.temperature)\r\n prob = distr.Categorical(logits) # logits = masked_scores\r\n idx = prob.sample()\r\n\r\n idx_list.append(idx) # tour index\r\n log_probs.append(prob.log_prob(idx)) # log prob\r\n entropies.append(prob.entropy()) # entropies\r\n mask = mask + tf.one_hot(idx, self.max_length) # mask\r\n\r\n idx_copy = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \r\n #idx_ = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \r\n query3 = query2\r\n query2 = query1\r\n query1 = tf.gather_nd(actor_encoding, idx_copy) # update trajectory (state)\r\n \r\n idx_list.append(idx_list[0]) # return to start\r\n self.tour =tf.stack(idx_list, axis=1) # permutations\r\n self.log_prob = tf.add_n(log_probs) # corresponding log-probability for backprop\r\n self.entropies = tf.add_n(entropies)\r\n tf.summary.scalar('log_prob_mean', tf.reduce_mean(self.log_prob))\r\n tf.summary.scalar('entropies_mean', tf.reduce_mean(self.entropies))\r\n \r\n return idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ #returns variables necessary for the next loop\r","def map_question_linked_abstracts(include_no_abstracts):\r\n\tif load_common_map():\r\n\t\treturn\r\n\t\t\r\n\tglobal question_map, abstract_map, common_map\r\n\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict\r\n\r\n\tprint('\\nmapping question to answers')\r\n\t\r\n\tcommon_map = collections.defaultdict(list)\r\n\t\r\n\tno_abstract_count = 0\r\n\t\t\r\n\tfor i,v in question_map.items():\r\n\t\tprint(i)\r\n\t\tabstracts = linked_abstracts_dict[i]\r\n\t\tfor a in abstracts:\r\n\t\t\tif (a != 'NO_ABSTRACT') and (a in abstract_map.keys()):\r\n\t\t\t\tcommon_map[i].append([v,abstract_map[a]])\r\n\t\t\telse:\r\n\t\t\t\tif include_no_abstracts:\r\n\t\t\t\t\tcommon_map[i].append([v,()])\r\n\t\t\t\tno_abstract_count += 1\r\n\t\r\n\tprint('\\nabstractless : ' + str(no_abstract_count))\r\n\t\r\n\tprint(len(question_map))\r\n\tprint(len(abstract_map))\r\n\tprint(len(common_map))\r\n\t\r\n\tpickle.dump(common_map,open(paths.path_data_map_common_pickle,\"wb\"))","def set_encodings(questions, candidates,\n question_encoder, response_encoder):\n for i, chunk in enumerate(chunks(questions, 100)):\n question_strs = [q.question for q in chunk]\n question_encodings = np.array(question_encoder(question_strs))\n\n for j in range(question_encodings.shape[0]):\n questions[i * 100 + j].encoding = question_encodings[j]\n if i % 50 == 0:\n print(\"Questions: encoded %s of %s...\" % (i * 100, len(questions)))\n\n for i, chunk in enumerate(chunks(candidates, 50)):\n candidate_strs = [(c.sentence, c.context) for c in chunk]\n candidate_encodings = np.array(response_encoder(candidate_strs))\n for j in range(candidate_encodings.shape[0]):\n candidates[i * 50 + j].encoding = candidate_encodings[j]\n if i % 100 == 0:\n print(\"Candidates: encoded %s of %s...\" % (i * 50, len(candidates)))","def match(self, passage_encodes, question_encodes, p_length, q_length):\n with tf.variable_scope('bidaf'):\n if self.use_complex_s:\n p_length=tf.shape(passage_encodes)[1]\n q_length=tf.shape(question_encodes)[1]\n hp=tf.tile(tf.expand_dims(passage_encodes,2),[1,1,q_length,1])\n hq=tf.tile(tf.expand_dims(question_encodes,1),[1,p_length,1,1])\n fusion=tf.concat([hp,hq,hp*hq],-1)\n sim_matrix=tf.squeeze(tf.contrib.layers.fully_connected(fusion,num_outputs=1,activation_fn=None),-1)\n else:\n sim_matrix = tf.matmul(passage_encodes, question_encodes, transpose_b=True)\n context2question_attn = tf.matmul(tf.nn.softmax(sim_matrix, -1), question_encodes)\n b = tf.nn.softmax(tf.expand_dims(tf.reduce_max(sim_matrix, 2), 1), -1)\n question2context_attn = tf.tile(tf.matmul(b, passage_encodes),\n [1, tf.shape(passage_encodes)[1], 1])\n concat_outputs = tf.concat([passage_encodes, context2question_attn,\n passage_encodes * context2question_attn,\n passage_encodes * question2context_attn], -1)\n return concat_outputs, None","def combine_corpus(include_whole_abstracts=False):\r\n\tif load_combined_corpus_maps():\r\n\t\treturn\r\n\t\r\n\tglobal gensim_dictionary\r\n\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict, abstracts_dict\r\n\tglobal common_corpus_list, question_map, abstract_map, abstract_whole_map\r\n\tglobal corpus_layout\r\n\t\r\n\tprint('\\nbuilding common corpus')\r\n\t\r\n\tcommon_corpus_list = list()\r\n\tquestion_map = dict()\r\n\tabstract_map = dict()\r\n\tabstract_whole_map = dict()\r\n\t\r\n\tsentence_count = 0\r\n\t\r\n\tcorpus_layout = []\r\n\t\r\n\tfor qi,qv in search_criteria_dict.items():\r\n\t\tquestions = qv\r\n\t\t\r\n\t\tsentence_incr = len(questions)\r\n\t\tquestion_map[qi] = (sentence_count,sentence_count + sentence_incr)\r\n\t\tsentence_count += sentence_incr\r\n\t\t\r\n\t\tfor st in questions:\r\n\t\t\tcommon_corpus_list.append(st)\r\n\t\r\n\tcorpus_layout.append(('Q',sentence_count))\r\n\t\r\n\tfor ai,av in abstracts_dict.items():\r\n\t\tabstract = av\r\n\t\t\r\n\t\tsentence_incr = len(abstract)\r\n\t\tabstract_map[ai] = (sentence_count,sentence_count + sentence_incr)\r\n\t\tsentence_count += sentence_incr\r\n\r\n\t\tfor st in abstract:\r\n\t\t\tcommon_corpus_list.append(st)\r\n\t\r\n\tcorpus_layout.append(('A',sentence_count))\r\n\r\n\tif include_whole_abstracts:\r\n\t\tfor ai,av in abstracts_dict.items():\r\n\t\t\tabstract = av\r\n\t\t\t\r\n\t\t\tabstract_whole_map[ai] = (sentence_count,sentence_count + 1)\r\n\t\t\tsentence_count += 1\r\n\r\n\t\t\tst = tuple('\\n'.join(s) for s in zip(*abstract))\r\n\t\t\tif len(st) < 2:\r\n\t\t\t\tst = ('','')\r\n\r\n\t\t\tcommon_corpus_list.append(st)\r\n\t\t\r\n\t\tcorpus_layout.append(('W',sentence_count))\r\n\t\r\n\tpickle.dump(question_map,open(paths.path_data_map_questions_pickle,\"wb\"))\r\n\tpickle.dump(abstract_map,open(paths.path_data_map_abstracts_pickle,\"wb\"))\r\n\tpickle.dump(abstract_whole_map,open(paths.path_data_map_abstracts_whole_pickle,\"wb\"))\t\r\n\tpickle.dump(common_corpus_list,open(paths.path_data_corpus_pickle,\"wb\"))\r\n\tpickle.dump(corpus_layout,open(paths.path_data_corpus_layout_pickle,\"wb\"))","def preprocess(self, df, maxlen = 169):\n \n vocabs = self.tk.word_index.keys()\n \n df1 = self.treat_na(df)\n df2 = self.remove_punc_sw(df1)\n df3 = self.remove_numbers(df2)\n df4 = self.lemma_pos(df3)\n df5 = self.bigram(df4)\n df6 = self.combine_bigrams(df5)\n \n new_docs = []\n \n for word_list in df6:\n \n if len(word_list) == 2 and word_list[0].lower() == 'noinfo' and word_list[1].lower() == 'noinfo':\n new_docs.append(list(np.zeros(maxlen)))\n \n else:\n new_word_list = []\n for word in word_list:\n if word not in vocabs:\n word = 'UNKNOWN_TOKEN'\n new_word_list.append(word)\n \n sequence = \" \".join(new_word_list)\n vectors = self.tk.texts_to_sequences([sequence])\n padded_vectors = pad_sequences(vectors, maxlen=maxlen, padding='post', truncating='post')\n \n new_docs.append(list(padded_vectors[0]))\n \n return new_docs","def disambiguate_all_not_disambiguated(\n celery_batch_size, total_records, indexing_queue_limit, disambiguation_queue_limit\n):\n with current_celery_app.connection_or_acquire() as conn:\n indexer_queue = conn.default_channel.queue_declare(\n queue=\"indexer_task\", passive=True\n )\n disambiguation_queue = conn.default_channel.queue_declare(\n queue=\"disambiguation\", passive=True\n )\n if (\n disambiguation_queue.message_count > disambiguation_queue_limit\n or indexer_queue.message_count > indexing_queue_limit\n ):\n click.echo(\"MQ queues are full, can't run disambiguation\")\n return\n not_disambiguated_records_search = _get_all_not_disambiguated_records_search()\n documents = not_disambiguated_records_search.scan()\n if total_records:\n documents = islice(documents, total_records)\n uuids = (document.meta.id for document in documents)\n _send_celery_group_disambiguation_task(uuids, celery_batch_size)","def rewritten_queries(question):\n # rewrites = []\n # tq = tokenize(question)\n # verb = tq[1] # 目前只处理 谁是XXX类 问题\n # rewrites.append(\n # RewrittenQuery(\"\\\"%s %s\\\"\" % (verb, \" \".join(tq[2:])),\n # QUOTED_QUERY_SCORE))\n # for j in range(2, len(tq)):\n # rewrites.append(\n # RewrittenQuery(\n # \"\\\"%s %s %s\\\"\" % (\n # \" \".join(tq[2:j + 1]), verb, \" \".join(tq[j + 1:])),\n # QUOTED_QUERY_SCORE))\n # rewrites.append(RewrittenQuery(\" \".join(tq[2:]), UNQUOTED_QUERY_SCORE))\n return [RewrittenQuery(question, 1)]","def w_question(analysis):\n if analysis.sv:\n #Opinion is a what question so we have to make some changes\n if analysis.sv[0].vrb_main[0].endswith('like'):\n verb = analysis.sv[0].vrb_main[0]\n analysis.sv[0].vrb_main[0] = verb[:len(verb) - 4] + 'think+of'\n\n #processing as yes or no question\n phrase = y_o_question(analysis)\n\n #Specific processing for invitation\n if analysis.aim == 'invitation':\n return ['how', 'about'] + phrase[1:]\n\n #Specific processing for classification\n if analysis.aim.startswith('classification'):\n aim_question = other_functions.list_rebuilding(analysis.aim)\n return ['what', 'kind', 'of'] + aim_question[1:] + phrase\n\n #It is an how question\n if other_functions.is_an_adj(analysis.aim) == 1:\n return ['how'] + [analysis.aim] + phrase\n elif analysis.aim == 'manner':\n return ['how'] + phrase\n\n if analysis.aim == 'thing' or analysis.aim == 'situation' or analysis.aim == 'explication' or analysis.aim == 'opinion':\n return ['what'] + phrase\n return ['what'] + [analysis.aim] + phrase","def auto_corr(sent, target_pos):\n for pos in target_pos:\n target_v = None\n t0 = time.time()\n if len(sent) > 1:\n context_v = model.context2vec(sent, pos) \n context_v = context_v / xp.sqrt((context_v * context_v).sum())\n else:\n context_v = None\n\n if target_v is not None and context_v is not None:\n similarity = mult_sim(w, target_v, context_v)\n else:\n if target_v is not None:\n v = target_v\n elif context_v is not None:\n v = context_v \n else:\n raise Exception(\"Can't find a target nor context.\") \n similarity = (w.dot(v)+1.0)/2 # Cosine similarity can be negative, mapping similarity to [0,1]\n\n old_word = sent[pos]\n if STATE == 'manual':\n print \"\\n>> For the correction of word: \", old_word\n print \">>>> Calculating the candidates ... ...\"\n candidats = candidates(old_word)\n\n l = []\n count = 0\n\n if len(candidats)!=0:\n for i in (-similarity).argsort():\n if index2word[i] not in candidats:\n continue\n else:\n count += 1\n if STATE == 'manual':\n print \"candidate %d:\\t\"%count, index2word[i], \", similarity:\\t\", similarity[i]\n l.append(i)\n if count == N_RESULT:\n break \n else:\n for i in (-similarity).argsort():\n if np.isnan(similarity[i]):\n continue\n #print sent[pos], index2word[i]\n dist = levenshtein(index2word[i], sent[pos])\n if dist <= LEVEN_DIST:\n count += 1\n if STATE == 'manual':\n print \"candidate %d:\\t\"%count, index2word[i],\", similarity:\\t\", similarity[i], \", levenshtein distance:\\t\", dist\n l.append(i)\n if count == N_RESULT:\n break \n if len(l) == 0:\n continue\n \n if STATE == 'manual':\n print \"Time: %.2fs\"%(time.time()-t0)\n print \"Please choose the replacement, enter the number of the candidate: (Enter 0 for no replacement)\"\n choice = six.moves.input('>> ')\n c = int(choice)\n if c == 0:\n continue # no change made\n elif c > 0:\n idx = l[c - 1]\n else:\n raise Exception(\"Invalid input!\") \n elif STATE == 'auto':\n idx = l[0]\n corr_word = index2word[idx]\n\n \n print \">>>> \\t\", old_word, \"\\t--->\\t\", corr_word\n sent[pos] = corr_word\n return sent","def generate_question_inter(path):\n\n\t# Function to compute vocabulary intersection\n\tdef q1_q2_intersect(row):\n\t return(len(set(q_dict[row['question1']]).intersection(set(q_dict[row['question2']]))))\n\n\t# Load training and test set\n\ttrain_orig =pd.read_csv(os.path.join(path,'train.csv'), sep=',',names = [\"id\", \"qid1\", \"qid2\", \"question1\",\"question2\",\"is_duplicate\"])\n\ttest_orig = pd.read_csv(os.path.join(path,'test.csv'), sep=',',names = [\"id\", \"qid1\", \"qid2\", \"question1\",\"question2\"])\n\n\t# Concatenation\n\tques = pd.concat([train_orig[['question1', 'question2']], test_orig[['question1', 'question2']]], axis=0).reset_index(drop='index')\n\n\n\tq_dict = defaultdict(set)\n\tfor i in range(ques.shape[0]):\n\t q_dict[ques.question1[i]].add(ques.question2[i])\n\t q_dict[ques.question2[i]].add(ques.question1[i])\n\n\t# Compute vocabulary intersection\n\ttrain_orig['q1_q2_intersect'] = train_orig.apply(q1_q2_intersect, axis=1, raw=True)\n\ttest_orig['q1_q2_intersect'] = test_orig.apply(q1_q2_intersect, axis=1, raw=True)\n\n\ttrain_feat = train_orig[['q1_q2_intersect']]\n\ttest_feat = test_orig[['q1_q2_intersect']]\n\n\tprint('Writing train features...')\n\ttrain_feat.to_csv(os.path.join(path,'train_question_inter.csv'))\n\n\tprint('Writing test features...') \n\ttest_feat.to_csv(os.path.join(path,'test_question_inter.csv'))\n\n\tprint('CSV written ! see: ', path, \" | suffix: \", \"_question_inter.csv\")","def find_explanation_regression_based(user_question_list, global_patterns, global_patterns_dict,\n cat_sim, num_dis_norm, agg_col, conn, cur, pat_table_name, res_table_name):\n answer = [[] for i in range(len(user_question_list))]\n local_pattern_loading_time = 0\n question_validating_time = 0\n score_computing_time = 0\n score_computing_time_list = []\n local_patterns_list = []\n\n for j, uq in enumerate(user_question_list):\n dir = uq['dir']\n topK_heap = TopkHeap(ExplConfig.TOP_K)\n marked = {}\n\n t = dict(uq['target_tuple'])\n\n uq['global_patterns'] = find_patterns_relevant(\n global_patterns_dict, uq['target_tuple'], conn, cur, res_table_name, pat_table_name, cat_sim)\n\n top_k_lists = [[] for i in range(len(uq['global_patterns']))]\n local_patterns = []\n\n ExplConfig.VISITED_DICT = dict()\n score_computing_start = time.time()\n\n for i in range(0, len(uq['global_patterns'])):\n top_k_lists[i] = [4, uq['global_patterns'][i], t, []]\n local_patterns.append(None)\n F_key = str(sorted(uq['global_patterns'][i][0]))\n V_key = str(sorted(uq['global_patterns'][i][1]))\n pat_key = F_key + '|,|' + V_key + '|,|' + uq['global_patterns'][i][2] + '|,|' + uq['global_patterns'][i][3]\n if pat_key in ExplConfig.VISITED_DICT:\n continue\n ExplConfig.VISITED_DICT[pat_key] = True\n\n tF = get_F_value(uq['global_patterns'][i][0], t)\n local_pattern_query_fixed = '''SELECT * FROM {} \n WHERE array_to_string(fixed, ', ')='{}' AND \n REPLACE(array_to_string(fixed_value, ', '), '.0', '')='{}' AND\n array_to_string(variable, ', ')='{}' AND \n agg='{}' AND model='{}'\n ORDER BY theta;\n '''.format(\n pat_table_name + '_local',\n str(uq['global_patterns'][i][0]).replace(\"\\'\", '').replace('[', '').replace(']', ''),\n str(tF)[1:-1].replace(\"\\'\", ''),\n str(uq['global_patterns'][i][1]).replace(\"\\'\", '').replace('[', '').replace(']', ''),\n uq['global_patterns'][i][2], uq['global_patterns'][i][3]\n )\n cur.execute(local_pattern_query_fixed)\n res_fixed = cur.fetchall()\n\n if len(res_fixed) == 0:\n continue\n\n local_patterns[i] = res_fixed[0]\n T_set = set(t.keys()).difference(set(['lambda', uq['global_patterns'][i][2]]))\n agg_col = local_patterns[i][3]\n start = time.time()\n t_t_list, agg_range, t_t_dict = get_tuples_by_F_V(local_patterns[i], local_patterns[i],\n get_F_value(local_patterns[i][0], t),\n # [get_V_value(local_patterns[i][2], t), [[-3, 3]]],\n None,\n conn, cur, res_table_name, cat_sim)\n\n dist_lb = 1e10\n dev_ub = 0\n for t_t in t_t_list:\n if compare_tuple(t_t, t) == 0:\n s = score_of_explanation(t_t, t, cat_sim, num_dis_norm, dir, t_t[agg_col], local_patterns[i],\n local_patterns[i])\n if str(t_t) not in marked:\n marked[str(t_t)] = True\n topK_heap.Push(Explanation(0, s[0], s[1], s[2], s[3], uq['dir'],\n # list(map(lambda y: y[1], sorted(t_t.items(), key=lambda x: x[0]))),\n dict(t_t),\n ExplConfig.TOP_K, local_patterns[i], None))\n\n top_k_lists[i][-1].append(Explanation(0, s[0], s[1], s[2], s[3], uq['dir'],\n dict(t_t),\n ExplConfig.TOP_K, local_patterns[i], None))\n if s[-1] < dist_lb:\n dist_lb = s[-1]\n # use raw distance (without penalty on missing attributes) as the lower bound\n if abs(s[2]) > dev_ub:\n dev_ub = abs(s[2])\n if dist_lb < 1e-10:\n dist_lb = 0.01\n\n end = time.time()\n question_validating_time += end - start\n\n F_set = set(local_patterns[i][0])\n V_set = set(local_patterns[i][2])\n\n # F union V \\subsetneq G\n t_coarser_copy = list(t_t_list)\n norm_lb = min(list(map(lambda x: x[agg_col], t_coarser_copy)))\n\n k_score = topK_heap.MinValue()\n # prune\n if topK_heap.HeapSize() == ExplConfig.TOP_K and 100 * float(dev_ub) / (dist_lb * float(norm_lb)) <= k_score:\n continue\n top_k_lists[i][-1] += DrillDown(global_patterns_dict, local_patterns[i],\n F_set, T_set.difference(F_set.union(V_set)), V_set, t_coarser_copy,\n t_coarser_copy, t, t,\n conn, cur, pat_table_name, res_table_name, cat_sim, num_dis_norm,\n dir, uq['query_result'],\n norm_lb, dist_lb, topK_heap)\n for tk in top_k_lists[i][-1]:\n if str(tk.tuple_value) not in marked:\n marked[str(tk.tuple_value)] = True\n topK_heap.Push(tk)\n\n score_computing_end = time.time()\n score_computing_time_cur_uq = score_computing_end - score_computing_start\n\n answer[j] = topK_heap.TopK()\n score_computing_time_list.append([t, score_computing_time_cur_uq])\n\n print('Local pattern loading time: ' + str(local_pattern_loading_time) + 'seconds')\n print('Score computing time: ' + str(score_computing_time) + 'seconds')\n return answer, local_patterns_list, score_computing_time_list","def convert_examples_to_features(examples, tokenizer, max_seq_length,\n doc_stride, max_query_length, return_answers, skip_no_answer,\n verbose=False, save_with_prob=False, msg=\"Converting examples\"):\n\n unique_id = 1000000000\n features = []\n question_features = []\n\n for (example_index, example) in enumerate(tqdm(examples, desc=msg)):\n\n # Tokenize query into (sub)tokens\n query_tokens = tokenizer.tokenize(example.question_text)\n if len(query_tokens) > max_query_length:\n query_tokens = query_tokens[0:max_query_length]\n\n # Creating a map between word <=> (sub)token\n tok_to_word_index = []\n word_to_tok_index = [] # word to (start of) subtokens\n all_doc_tokens = []\n for (i, word) in enumerate(example.doc_words):\n word_to_tok_index.append(len(all_doc_tokens))\n sub_tokens = tokenizer.tokenize(word)\n for sub_token in sub_tokens:\n tok_to_word_index.append(i)\n all_doc_tokens.append(sub_token)\n\n # The -2 accounts for [CLS], [SEP]\n max_tokens_for_doc = max_seq_length - 2\n\n # Split sequence by max_seq_len with doc_stride, _DocSpan is based on tokens without [CLS], [SEP]\n _DocSpan = collections.namedtuple( # pylint: disable=invalid-name\n \"DocSpan\", [\"start\", \"length\"])\n doc_spans = []\n start_tok_offset = 0 # From all_doc_tokens\n\n # Get doc_spans with stride and offset\n while start_tok_offset < len(all_doc_tokens):\n length = len(all_doc_tokens) - start_tok_offset\n if length > max_tokens_for_doc:\n length = max_tokens_for_doc\n doc_spans.append(_DocSpan(start=start_tok_offset, length=length))\n if start_tok_offset + length == len(all_doc_tokens):\n break\n start_tok_offset += min(length, doc_stride) # seems to prefer doc_stride always\n assert doc_stride < length, \"length is no larger than doc_stride for {}\".format(doc_spans)\n\n # Iterate each doc_span and make out_tokens\n for (doc_span_index, doc_span) in enumerate(doc_spans):\n\n # Find answer position based on new out_tokens\n start_position = None\n end_position = None\n\n # For no_answer, same (-1, -1) applies\n if example.start_position is not None and example.start_position < 0:\n assert example.start_position == -1 and example.end_position == -1\n start_position, end_position = NO_ANS, NO_ANS\n\n # For existing answers, find answers if exist\n elif return_answers:\n\n # Get token-level start/end position\n tok_start_position = word_to_tok_index[example.start_position]\n if example.end_position < len(example.doc_words) - 1:\n tok_end_position = word_to_tok_index[example.end_position + 1] - 1 # By backwarding from next word\n else:\n assert example.end_position == len(example.doc_words) - 1\n tok_end_position = len(all_doc_tokens) - 1\n\n # Improve answer span by subword-level\n (tok_start_position, tok_end_position) = _improve_answer_span(\n all_doc_tokens, tok_start_position, tok_end_position, tokenizer,\n example.orig_answer_text)\n\n # Throw away training samples without answers (due to doc_span split)\n doc_start = doc_span.start\n doc_end = doc_span.start + doc_span.length - 1\n if (tok_start_position < doc_start or tok_end_position < doc_start or\n tok_start_position > doc_end or tok_end_position > doc_end):\n if skip_no_answer:\n continue\n else:\n # For NQ, only add this in 2% (50 times downsample)\n if save_with_prob:\n if np.random.randint(100) < 2:\n start_position, end_position = NO_ANS, NO_ANS\n else:\n continue\n else:\n start_position, end_position = NO_ANS, NO_ANS\n\n # Training samples with answers\n else:\n doc_offset = 1 # For [CLS]\n start_position = tok_start_position - doc_start + doc_offset\n end_position = tok_end_position - doc_start + doc_offset\n assert start_position >= 0 and end_position >= 0, (start_position, end_position)\n\n out_tokens = [] # doc\n out_tokens_ = [] # quesry\n out_tokens.append(\"[CLS]\")\n out_tokens_.append(\"[CLS]\")\n token_to_word_map = {} # The difference with tok_to_word_index is it includes special tokens\n token_is_max_context = {}\n\n # For query tokens, just copy and add [SEP]\n for token in query_tokens:\n out_tokens_.append(token)\n out_tokens_.append(\"[SEP]\")\n\n # For each doc token, create token_to_word_map and is_max_context, and add to out_tokens\n for i in range(doc_span.length):\n split_token_index = doc_span.start + i\n token_to_word_map[len(out_tokens)] = tok_to_word_index[split_token_index]\n is_max_context = _check_is_max_context(doc_spans, doc_span_index, split_token_index)\n token_is_max_context[len(out_tokens)] = is_max_context\n out_tokens.append(all_doc_tokens[split_token_index])\n out_tokens.append(\"[SEP]\")\n\n # Convert to ids and masks\n input_ids = tokenizer.convert_tokens_to_ids(out_tokens)\n input_ids_ = tokenizer.convert_tokens_to_ids(out_tokens_)\n input_mask = [1] * len(input_ids)\n input_mask_ = [1] * len(input_ids_)\n\n # Zero-pad up to the sequence length.\n while len(input_ids) < max_seq_length:\n input_ids.append(0)\n input_mask.append(0)\n assert len(input_ids) == max_seq_length\n assert len(input_mask) == max_seq_length\n while len(input_ids_) < max_query_length + 2: # +2 for [CLS], [SEP]\n input_ids_.append(0)\n input_mask_.append(0)\n assert len(input_ids_) == max_query_length + 2\n assert len(input_mask_) == max_query_length + 2\n\n # Printing for debug\n if example_index < 1 and verbose:\n logger.info(\"*** Example ***\")\n logger.info(\"unique_id: %s\" % (unique_id))\n logger.info(\"example_index: %s\" % (example_index))\n logger.info(\"doc_span_index: %s\" % (doc_span_index))\n logger.info(\"tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in out_tokens]))\n logger.info(\"q tokens: %s\" % \" \".join(\n [tokenization.printable_text(x) for x in out_tokens_]))\n logger.info(\"token_to_word_map: %s\" % \" \".join(\n [\"%d:%d\" % (x, y) for (x, y) in six.iteritems(token_to_word_map)]))\n logger.info(\"token_is_max_context: %s\" % \" \".join([\n \"%d:%s\" % (x, y) for (x, y) in six.iteritems(token_is_max_context)\n ]))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\n \"input_mask: %s\" % \" \".join([str(x) for x in input_mask]))\n if return_answers:\n answer_text = \" \".join(out_tokens[start_position:(end_position + 1)])\n logger.info(\"start_position: %d\" % (start_position))\n logger.info(\"end_position: %d\" % (end_position))\n logger.info(\n \"answer: %s\" % (tokenization.printable_text(answer_text)))\n\n # Append feature\n features.append(\n ContextFeatures(\n unique_id=unique_id,\n example_index=example_index,\n doc_span_index=doc_span_index,\n tokens=out_tokens,\n token_to_word_map=token_to_word_map,\n token_is_max_context=token_is_max_context,\n input_ids=input_ids,\n input_mask=input_mask,\n start_position=start_position,\n end_position=end_position))\n question_features.append(\n QuestionFeatures(\n unique_id=unique_id,\n example_index=example_index,\n tokens_=out_tokens_,\n input_ids=input_ids_,\n input_mask=input_mask_))\n\n # Check validity of answer\n if return_answers:\n if start_position <= NO_ANS:\n assert start_position == NO_ANS and end_position == NO_ANS, (start_position, end_position)\n else:\n assert out_tokens[start_position:end_position+1] == \\\n all_doc_tokens[tok_start_position:tok_end_position+1]\n orig_text, start_pos, end_pos = get_final_text_(\n example, features[-1], start_position, end_position, True, False)\n phrase = orig_text[start_pos:end_pos]\n try:\n assert phrase == example.orig_answer_text\n except Exception as e:\n # print('diff ans [%s]/[%s]'%(phrase, example.orig_answer_text))\n pass\n unique_id += 1\n\n return features, question_features","def test_replace_question_mark_with_nan(raw_data: pd.DataFrame):\n\n raw_data_nan = replace_question_mark_with_nan(raw_data)\n\n # Check the existence of NaN values\n assert check_null_values(raw_data_nan)\n\n # Check that there are no more question marks\n assert not check_question_mark_as_null(raw_data_nan)","def reindex(self):\n self._index = {w: i for i, w in enumerate(self._words)}\n self.n, self.d = self._vecs.shape\n assert self.n == len(self._words) == len(self._index)\n self._neighbors = None","def ques_lstm(self, word_embeddings):\n nlayer = self.config.nrnn_layer\n lstm_cell = tf.contrib.rnn.BasicLSTMCell(\n num_units=self.config.rnn_size, state_is_tuple=True)\n lstm_cell = tf.contrib.rnn.MultiRNNCell(\n [lstm_cell] * nlayer, state_is_tuple=True)\n\n with tf.variable_scope(\n 'ques_lstm', initializer=self.initializer) as scope:\n # Run the batch of sequence embeddings through the LSTM.\n assert (self.feed_per_seq_length != None)\n _, lstm_state = tf.nn.dynamic_rnn(\n cell=lstm_cell,\n inputs=word_embeddings,\n sequence_length=self.feed_per_seq_length,\n dtype=tf.float32)\n\n # extract c and h, then concat them all\n ques_encoding_lis = []\n for i in range(nlayer):\n ques_encoding_lis = ques_encoding_lis + [\n lstm_state[i].c, lstm_state[i].h\n ]\n ques_encoding = tf.concat(ques_encoding_lis, axis=1)\n\n assert (ques_encoding.shape[1] == self.config.rnnout_dim)\n\n return ques_encoding","def transform_answers(self, stim_dict: dict):\n new_ind = [resp.name for resp in RESPONSES]\n for stim in stim_dict:\n df = stim_dict[stim][\"responses\"]\n df = df.fillna(\"empty\")\n new_df = pd.DataFrame(columns=df.columns, index=new_ind)\n for col in new_df.columns:\n for row in new_df.index:\n new_df[col][row] = 0\n for subj in df.index:\n if row in df[col][subj]:\n new_df[col][row] += 1\n new_df.columns = [\"Feelings\", \"Familiarity\"]\n stim_dict[stim][\"transformed_responses\"] = new_df\n self.stim_dict = stim_dict","def simplify_ques(question, debug=False):\n if not isinstance(question, str):\n raise TypeError('Please provide a string for a question.')\n\n if debug is True:\n load_json()\n\n neg = False\n qwords = question.lower().split()\n for i in qwords:\n if i in NEGATIVE_WORDS:\n neg = True\n\n cleanwords = [word for word in qwords if word.lower() not in REMOVE_WORDS]\n temp = ' '.join(cleanwords)\n\n clean_question = \"\"\n for letter in temp:\n if letter != \"?\" or letter != \"\\\"\" or letter != \"\\'\":\n clean_question = clean_question + letter\n\n return clean_question.lower(), neg","def _postprocess_embeddings(self, prediction_dict, y_indices, x_indices):\n embedding_predictions = prediction_dict[TRACK_REID][-1]\n embeddings = predicted_embeddings_at_object_centers(\n embedding_predictions, y_indices, x_indices)\n embeddings, _ = tf.linalg.normalize(embeddings, axis=-1)\n\n return embeddings","def reindex_metadata_tags(self):\r\n previous_position_values = None\r\n\r\n for position_index, position in enumerate(self.required_fields_index):\r\n if position_index > 0:\r\n position.reindex(previous_position_values)\r\n\r\n previous_position_values = position.current_values()","def load_as_raw(self):\n\n # Q & A\n questions, answers = self.get_questions_answers()\n\n # Get vocabs\n\n # Step 4: cleaning the questions\n pprint('---- Step 4 cleaning questions ----')\n\n clean_questions = []\n for question in questions:\n clean_questions.append(clean_text(question))\n\n pprint(clean_questions, stream=Head(5))\n print('\\n\\n')\n \"\"\"\n Step 5: Clean the answers\n \"\"\"\n\n pprint('---- Step 5 cleaning answers ----')\n clean_answers = []\n for answer in answers:\n clean_answers.append(clean_text(answer))\n\n pprint(clean_answers, stream=Head(5))\n print('\\n\\n')\n \"\"\"\n Step 6: Creating a dictionary that maps each word to its number of occurences\n \"\"\"\n\n word2count = {}\n pprint('------ Step 6: counting words in questions ----')\n\n word2count = convert_word_to_count(word2count, clean_questions)\n\n pprint(word2count, stream=Head(5))\n print('\\n\\n')\n \"\"\"\n Step 7:\n For example, for a question: can we make this quick roxanne korrine and andrew barrett are having an incredibly horrendous public break up on the quad again\n It counts each word occurence such as \"can\" and accumulates the count into word2count dict\n \"\"\"\n pprint('------ Step 6: counting words in answers ----')\n\n word2count = convert_word_to_count(word2count, clean_answers)\n\n pprint(word2count, stream=Head(5))\n print('\\n\\n')\n\n keys = ['<unk>', '<s>', '</s>']\n\n \"\"\"\n Step 8: Creating word 2 int(count) by filtering words that are greater than the threshold\n \"\"\"\n\n pprint(\n '------ Step 8: questions_vocabs filtered by threshold (>) ----')\n threshold_questions = 20\n questions_vocabs = [] + keys\n for word, count in word2count.items():\n if count >= threshold_questions:\n if not word in questions_vocabs:\n questions_vocabs.append(word)\n\n pprint(questions_vocabs, stream=Head(5))\n print('\\n\\n')\n \"\"\"\n Step 9: Same as step 8 but for answers\n \"\"\"\n pprint(\n '------ Step 9: answers_vocabs filtered by threshold (>) ----')\n threshold_answers = 20\n answers_vocabs = [] + keys\n for word, count in word2count.items():\n if count >= threshold_answers:\n if not word in answers_vocabs:\n answers_vocabs.append(word)\n\n pprint(answers_vocabs, stream=Head(5))\n\n return questions, answers, questions_vocabs, answers_vocabs","def replace_waveforms(self, waveform_dict):\n for waveform, value in waveform_dict.items():\n\n if waveform not in self.unresolved_placeholders:\n self.hd.log.error(f\"Placeholder {waveform} not found in sequence.\")\n\n waveform_wrapped = f\"{self.marker_string}{waveform}{self.marker_string}\"\n waveform_vector = 'vect(' + ','.join([str(x) for x in value]) + ')'\n self.sequence = self.sequence.replace(f\"{waveform_wrapped}\", str(waveform_vector))\n self.unresolved_placeholders.discard(waveform)","def word_analogy(self):\n data = open(\"data/word_analogy_subset.en.ar.txt\").read().split('\\n')\n data = [x for x in data if len(x.split()) == 4]\n cnt = 0\n keys = list(self.embeddings_index.keys())\n vectors = np.array(list(self.embeddings_index.values()))\n norms = np.linalg.norm(vectors, axis=1)\n for i in data:\n i = self.preprocessor(i).split()\n try:\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\n except:\n continue\n unit = v / np.linalg.norm(v)\n dists = np.dot(vectors, unit) / norms\n best = np.argpartition(-dists, 10)[:10 + 1]\n best = best.take(np.argsort((-dists).take(best)))\n result = [(keys[sim], float(dists[sim]))\n for sim in best]\n sbv = result[:10]\n for j in sbv:\n if j[0] == i[3]:\n cnt += 1\n return cnt/ len(data)","def replace_errors(suggestion_num, sequence_switched, end_matches, offset_list):\n if len(end_matches) != 0:\n # Initialize Variables\n new_list = initialize_suggestion_list(suggestion_num)\n tokenizer, model = edf.initialize_tokenizer_variables()\n\n # Swapping masks with corrections section\n if len(end_matches) > 1:\n k = 0\n j = 0\n current = 0\n keep_going = True\n\n while keep_going:\n # Determine what section to locate mask token in\n mask_str = section_decision(j, sequence_switched, offset_list, end_matches)\n\n new_list = replace_tokens(mask_str, sequence_switched, new_list, j, tokenizer, model, suggestion_num)\n\n # If end of sentence, return j to 0, else continue iterations\n if j == (len(end_matches) - 1):\n # Update variables\n j = 0\n current += 1\n keep_going = False\n\n else:\n j += 1\n\n k += 1\n\n else:\n new_list = replace_tokens(sequence_switched, sequence_switched, new_list, 0, tokenizer, model,\n suggestion_num)\n\n return new_list\n\n else:\n return []","def forward(self, aligned_feat):\n n, t, c, h, w = aligned_feat.size()\n # temporal attention\n embedding_ref = self.temporal_attn1(\n aligned_feat[:, self.center_frame_idx, :, :, :].clone())\n emb = self.temporal_attn2(aligned_feat.view(-1, c, h, w))\n emb = emb.view(n, t, -1, h, w) # (n, t, c, h, w)\n\n corr_l = [] # correlation list\n for i in range(t):\n emb_neighbor = emb[:, i, :, :, :]\n corr = torch.sum(emb_neighbor * embedding_ref, 1) # (n, h, w)\n corr_l.append(corr.unsqueeze(1)) # (n, 1, h, w)\n corr_prob = torch.sigmoid(torch.cat(corr_l, dim=1)) # (n, t, h, w)\n corr_prob = corr_prob.unsqueeze(2).expand(n, t, c, h, w)\n corr_prob = corr_prob.contiguous().view(n, -1, h, w) # (n, t*c, h, w)\n aligned_feat = aligned_feat.view(n, -1, h, w) * corr_prob\n\n # fusion\n feat = self.feat_fusion(aligned_feat)\n\n # spatial attention\n attn = self.spatial_attn1(aligned_feat)\n attn_max = self.max_pool(attn)\n attn_avg = self.avg_pool(attn)\n attn = self.spatial_attn2(torch.cat([attn_max, attn_avg], dim=1))\n # pyramid levels\n attn_level = self.spatial_attn_l1(attn)\n attn_max = self.max_pool(attn_level)\n attn_avg = self.avg_pool(attn_level)\n attn_level = self.spatial_attn_l2(\n torch.cat([attn_max, attn_avg], dim=1))\n attn_level = self.spatial_attn_l3(attn_level)\n attn_level = self.upsample(attn_level)\n\n attn = self.spatial_attn3(attn) + attn_level\n attn = self.spatial_attn4(attn)\n attn = self.upsample(attn)\n attn = self.spatial_attn5(attn)\n attn_add = self.spatial_attn_add2(self.spatial_attn_add1(attn))\n attn = torch.sigmoid(attn)\n\n # after initialization, * 2 makes (attn * 2) to be close to 1.\n feat = feat * attn * 2 + attn_add\n return feat","def batchify_QA(batch):\r\n\r\n if type(batch[0][1]) != torch.LongTensor:\r\n no_elmo, use_char = (True, False) if batch[0][1] == -2 else (False, False)\r\n else:\r\n no_elmo, use_char = True, True\r\n\r\n docs = [ex[0] for ex in batch]\r\n docs_char = [ex[1] for ex in batch]\r\n ques = [ex[2] for ex in batch]\r\n questions_char = [ex[3] for ex in batch]\r\n answers = [ex[4] for ex in batch]\r\n\r\n # Batch documents\r\n max_doc_length = max([d.size(0) for d in docs])\r\n x1_len = torch.LongTensor(len(docs)).zero_()\r\n x1 = torch.LongTensor(len(docs),\r\n max_doc_length).zero_() if no_elmo else torch.LongTensor(len(docs),\r\n max_doc_length,\r\n 50).zero_()\r\n x1_char = torch.LongTensor(len(docs),\r\n max_doc_length,\r\n docs_char[0].size(1)).zero_() if (no_elmo and use_char) else None\r\n for i, d in enumerate(docs):\r\n x1_len[i] = d.size(0)\r\n x1[i, :d.size(0)].copy_(d)\r\n if not no_elmo:\r\n x1_char[i, :d.size(0), :].copy_(docs_char[i])\r\n\r\n # Batch questions\r\n max_ques_length = max([q.size(0) for q in ques])\r\n x2_len = torch.LongTensor(len(ques)).zero_()\r\n x2 = torch.LongTensor(len(ques), max_ques_length).zero_() if no_elmo else torch.LongTensor(len(ques),\r\n max_ques_length,\r\n 50).zero_()\r\n x2_char = torch.LongTensor(len(ques),\r\n max_ques_length,\r\n questions_char[0].size(1)).zero_() if (no_elmo and use_char) else None\r\n for i, q in enumerate(ques):\r\n x2_len[i] = q.size(0)\r\n x2[i, :q.size(0)].copy_(q)\r\n if not no_elmo:\r\n x2_char[i, :q.size(0), :].copy_(questions_char[i])\r\n\r\n # Batch answers\r\n max_ans_length = max([a.size(0) for a in answers])\r\n ans_len = torch.LongTensor(len(answers)).zero_()\r\n ans = torch.LongTensor(len(answers), max_ans_length).zero_()\r\n for i, a in enumerate(answers):\r\n ans_len[i] = a.size(0)\r\n ans[i, :a.size(0)].copy_(a)\r\n\r\n ids = [ex[5] for ex in batch]\r\n contexts = [ex[6] for ex in batch]\r\n # FIXME: multiple answers are possible, fix vectorize also.\r\n targets = [ex[8][0] for ex in batch]\r\n src_vocabs = [ex[9] for ex in batch]\r\n source_maps = []\r\n alignments = []\r\n\r\n # Prepare source vocabs, alignment [required for Copy Attention]\r\n for eid, context, target, (token2idx, idx2token) in \\\r\n zip(ids, contexts, targets, src_vocabs):\r\n # Mapping source tokens to indices in the dynamic dict.\r\n src_map = torch.LongTensor([token2idx[w] for w in context])\r\n source_maps.append(src_map)\r\n\r\n # TODO: does skipping the first and last token in answer valid?\r\n mask = torch.LongTensor([token2idx[w] if w in token2idx\r\n else UNK for w in target])\r\n alignments.append(mask)\r\n\r\n return {'doc_rep': x1,\r\n 'doc_char_rep': x1_char,\r\n 'doc_len': x1_len,\r\n 'que_rep': x2,\r\n 'que_char_rep': x2_char,\r\n 'que_len': x2_len,\r\n 'ans_rep': ans,\r\n 'ans_len': ans_len,\r\n 'ids': ids,\r\n 'documents': contexts,\r\n 'questions': [ex[7] for ex in batch],\r\n 'answers': targets,\r\n 'source_vocabs': src_vocabs,\r\n 'src_map': source_maps,\r\n 'alignment': alignments}","def intent_of_text_LnDOR(ChapterTextS, TargetQuestionsD, TestS, StopWords):\n \n # Chapter Text - stokenize\n StokensCT = stokenize(ChapterTextS, StopWords) \n\n # Test question - stokenize\n StokensTest = stokenize(TestS, StopWords)\n\n # Knowledge Base Dict - stokenize\n KBD_structure = stokenizeKBD(TargetQuestionsD, StopWords)\n\n # List (because list is mutable, set is not) of all stokens in document\n StokensDoc = StokensCT[:] # from chapter text\n StokensDoc.extend(StokensTest[:]) # += Test string\n\n # extend list of stokens in Doc\n for i in TargetQuestionsD:\n StokensDoc.extend(TargetQuestionsD[i][\"mq stokens\"][:]) # += KB target [matched Q]s\n StokensDoc.extend(TargetQuestionsD[i][\"ans stokens\"][:]) # += KB answers\n \n StokensTestV = set(StokensTest)\n StokensDocV = set(StokensDoc)\n StokensAntiTgtV = StokensDocV\n \n # Complement of all targets\n for i in TargetQuestionsD:\n StokensAntiTgtV = StokensAntiTgtV.difference(set(TargetQuestionsD[i][\"mq stokens\"]))\n \n # calculate confusion matrix and DOR etc.\n LnDORD = {}\n # Anti Target\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensAntiTgtV, StokensTestV) \n LnDOR = lndor(TP, FP, FN, TN) \n someAngle = angleDOR(TP, FP, FN, TN) \n \n LnDORD[\"AntiTgt\"] = {'lndor': LnDOR, 'theta': someAngle}\n\n # total occurences\n total_occ = 0\n for i in TargetQuestionsD:\n total_occ += TargetQuestionsD[i]['count']\n\n for i in TargetQuestionsD:\n StokensTgtV = set(TargetQuestionsD[i][\"mq stokens\"][:])\n\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensTgtV, StokensTestV) \n priorOR = TargetQuestionsD[i]['count'] / total_occ\n\n LnDOR = lndor(TP, FP, FN, TN) \n someAngle = angleDOR(TP, FP, FN, TN, priorOR) \n \n LnDORD[i] = {'lndor': LnDOR, 'theta': someAngle}\n # LnDORD = {i: {'lndor': , 'theta': }}, KB indices + \"AntiTgt\"\n\n return LnDORD","def qualify_words():\n config = get_config()\n\n all_feature_matrices = []\n all_opinion_matrices = []\n\n # first 5 parts are labeled, thus are useful\n all_feature_label_vectors = []\n all_opinion_label_vectors = []\n\n for fname in config.file_names:\n feature_X, feature_dims = load_feature_matrices(fname)\n opinion_X, opinion_dims = load_opinion_matrices(fname)\n feature_y = load_feature_labels(fname)\n opinion_y = load_opinion_labels(fname)\n\n # append to all collector\n all_feature_matrices.append(feature_X)\n all_feature_label_vectors.append(feature_y)\n all_opinion_matrices.append(opinion_X)\n all_opinion_label_vectors.append(opinion_y)\n # use first 5 for training\n # stack first 5\n feature_training_X = []\n feature_training_y = []\n opinion_training_X = []\n opinion_training_y = []\n for i in range(5):\n feature_training_X.append(all_feature_matrices[i])\n feature_training_y.append(all_feature_label_vectors[i])\n opinion_training_X.append(all_opinion_matrices[i])\n opinion_training_y.append(all_opinion_label_vectors[i])\n\n feature_training_X = np.hstack(feature_training_X)\n feature_training_y = np.hstack(feature_training_y)\n opinion_training_X = np.hstack(opinion_training_X)\n opinion_training_y = np.hstack(opinion_training_y)\n\n # using combination of rule and ranking score as features\n feature_model = MultinomialNB()\n opinion_model = MultinomialNB()\n\n # training\n feature_model.fit(np.transpose(feature_training_X), feature_training_y.ravel())\n opinion_model.fit(np.transpose(opinion_training_X), opinion_training_y.ravel())\n\n # predicting on candidate aspects and opinions, extracted from amazon reviews\n for i in range(5, len(config.file_names)):\n fname = config.file_names[i]\n feature_pred = feature_model.predict_proba(\n np.transpose(all_feature_matrices[i]))[:,1]\n opinion_pred = opinion_model.predict_proba(\n np.transpose(all_opinion_matrices[i]))[:,1]\n # pickle the prediction results\n with open('../results/' + fname + '_feature_pred_score.pickle', 'wb') as f:\n pickle.dump(feature_pred, f)\n with open('../results/' + fname + '_opinion_pred_score.pickle', 'wb') as f:\n pickle.dump(opinion_pred, f)","def compute_query_repr(annots_df, qaid, invindex, aggregate=False, alpha=3, thresh=0):\n if utool.VERBOSE:\n print('[smk_index] Query Repr qaid=%r' % (qaid,))\n wx2_idf = invindex.wx2_idf\n words = invindex.words\n wordflann = invindex.wordflann\n if WITH_PANDAS:\n qfx2_vec = annots_df['vecs'][qaid]\n else:\n qfx2_vec = pdh.ensure_values(annots_df['vecs'][qaid])\n # Assign query to words\n wx2_qfxs1, wx2_weights, qfx2_wxs = assign_to_words_(\n wordflann, words, qfx2_vec, idx_name='fx', dense=False) # 71.9 %\n # Hack to make implementing asmk easier, very redundant\n #qfx2_aid = pdh.IntSeries([qaid] * len(qfx2_wx), index=qfx2_wx.index, name='qfx2_aid')\n #qfx2_aid = pdh.IntSeries([qaid] * len(qfx2_wx), name='qfx2_aid')\n qfx2_aid = np.array([qaid] * len(qfx2_wxs), dtype=INTEGER_TYPE)\n if WITH_PANDAS:\n qfx2_qfx = qfx2_vec.index\n else:\n qfx2_qfx = np.arange(len(qfx2_vec))\n # Compute query residuals\n wx2_qrvecs, wx2_qaids, wx2_qfxs = compute_residuals_(\n words, wx2_qfxs1, qfx2_vec, qfx2_aid, qfx2_qfx, aggregate) # 24.8\n # Compute query gamma\n if utool.VERBOSE:\n print('[smk_index] Query Gamma alpha=%r, thresh=%r' % (alpha, thresh))\n wx_sublist = pdh.ensure_index(wx2_qrvecs).astype(np.int32)\n idf_list = pdh.ensure_values_subset(wx2_idf, wx_sublist)\n rvecs_list = pdh.ensure_values_subset(wx2_qrvecs, wx_sublist)\n query_gamma = smk_core.gamma_summation2(rvecs_list, idf_list, alpha, thresh)\n assert query_gamma > 0, 'query gamma is not positive!'\n return wx2_qrvecs, wx2_qaids, wx2_qfxs, query_gamma","def encode_samples(tokenized_samples, word_to_idx):\n features = []\n for sample in tokenized_samples:\n feature = []\n for token in sample:\n if token in word_to_idx:\n feature.append(word_to_idx[token])\n else:\n feature.append(0)\n features.append(feature)\n return features","def match(self, passage_encodes, question_encodes, p_length, q_length):\n with tf.variable_scope('bidaf'):\n sim_matrix = tf.matmul(\n passage_encodes, question_encodes, transpose_b=True)\n context2question_attn = tf.matmul(\n tf.nn.softmax(sim_matrix, -1), question_encodes)\n b = tf.nn.softmax(tf.expand_dims(\n tf.reduce_max(sim_matrix, 2), 1), -1)\n question2context_attn = tf.tile(tf.matmul(b, passage_encodes),\n [1, tf.shape(passage_encodes)[1], 1])\n concat_outputs = tf.concat([passage_encodes, context2question_attn,\n passage_encodes * context2question_attn,\n passage_encodes * question2context_attn], -1)\n return concat_outputs, None","def replace_token_with_index(self, tokenized_tweet, max_length_dictionary):\n\n # should be replacing each token in a list of tokens by their corresponding index\n # Source: https://github.com/stanfordnlp/GloVe\n # Source: https://towardsdatascience.com/word-embeddings-for-sentiment-analysis-65f42ea5d26e\n\n if self.mode == \"zip\":\n for idx, word in enumerate(tokenized_tweet):\n if word not in self.corpus:\n tokenized_tweet[idx] = \"<unknown>\"\n else:\n for idx, word in enumerate(tokenized_tweet):\n if word not in self.corpus:\n tokenized_tweet[idx] = \"<unk>\"\n return [self.corpus.index(x) for x in tokenized_tweet]","def fix_annotmatch_pzmaster1():\n import wbia\n\n ibs = wbia.opendb('PZ_Master1')\n infr = wbia.AnnotInference(ibs=ibs, aids=ibs.get_valid_aids(), verbose=5)\n infr.initialize_graph()\n annots = ibs.annots()\n aid_to_nid = ut.dzip(annots.aids, annots.nids)\n\n if False:\n infr.reset_feedback()\n infr.ensure_mst()\n infr.apply_feedback_edges()\n infr.relabel_using_reviews()\n infr.start_qt_interface()\n\n # Get annotmatch rowids that agree with current labeling\n if False:\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\n import pandas as pd\n\n flags1 = pd.isnull(annotmatch['annotmatch_evidence_decision'])\n flags2 = annotmatch['annotmatch_tag_text'] == ''\n bad_part = annotmatch[flags1 & flags2]\n rowids = bad_part.index.tolist()\n ibs.delete_annotmatch(rowids)\n\n if False:\n # Delete bidirectional annotmatches\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\n df = annotmatch.set_index(['annot_rowid1', 'annot_rowid2'])\n\n # Find entires that have both directions\n pairs1 = annotmatch[['annot_rowid1', 'annot_rowid2']].values\n f_edges = {tuple(p) for p in pairs1}\n b_edges = {tuple(p[::-1]) for p in pairs1}\n isect_edges = {tuple(sorted(p)) for p in b_edges.intersection(f_edges)}\n isect_edges1 = list(isect_edges)\n isect_edges2 = [p[::-1] for p in isect_edges]\n\n # cols = ['annotmatch_evidence_decision', 'annotmatch_tag_text']\n import pandas as pd\n\n custom_ = {\n (559, 4909): (False, ['photobomb']),\n (7918, 8041): (False, ['photobomb']),\n (6634, 6754): (False, ['photobomb']),\n (3707, 3727): (False, ['photobomb']),\n (86, 103): (False, ['photobomb']),\n }\n extra_ = {}\n\n fixme_edges = []\n\n d1 = df.loc[isect_edges1].reset_index(drop=False)\n d2 = df.loc[isect_edges2].reset_index(drop=False)\n flags = d1['annotmatch_evidence_decision'] != d2['annotmatch_evidence_decision']\n from wbia.tag_funcs import _parse_tags\n\n for f, r1, r2 in zip(flags, d1.iterrows(), d2.iterrows()):\n v1, v2 = r1[1], r2[1]\n aid1 = v1['annot_rowid1']\n aid2 = v1['annot_rowid2']\n truth_real = (\n ibs.const.EVIDENCE_DECISION.POSITIVE\n if aid_to_nid[aid1] == aid_to_nid[aid2]\n else ibs.const.EVIDENCE_DECISION.NEGATIVE\n )\n truth1 = v1['annotmatch_evidence_decision']\n truth2 = v2['annotmatch_evidence_decision']\n t1 = _parse_tags(v1['annotmatch_tag_text'])\n t2 = _parse_tags(v2['annotmatch_tag_text'])\n newtag = ut.union_ordered(t1, t2)\n if (aid1, aid2) in custom_:\n continue\n fixme_flag = False\n if not pd.isnull(truth1):\n if truth_real != truth1:\n fixme_flag = True\n if not pd.isnull(truth2):\n if truth_real != truth2:\n fixme_flag = True\n if fixme_flag:\n logger.info('newtag = {!r}'.format(newtag))\n logger.info('truth_real = {!r}'.format(truth_real))\n logger.info('truth1 = {!r}'.format(truth1))\n logger.info('truth2 = {!r}'.format(truth2))\n logger.info('aid1 = {!r}'.format(aid1))\n logger.info('aid2 = {!r}'.format(aid2))\n fixme_edges.append((aid1, aid2))\n else:\n extra_[(aid1, aid2)] = (truth_real, newtag)\n\n extra_.update(custom_)\n new_pairs = extra_.keys()\n new_truths = ut.take_column(ut.dict_take(extra_, new_pairs), 0)\n new_tags = ut.take_column(ut.dict_take(extra_, new_pairs), 1)\n new_tag_texts = [';'.join(t) for t in new_tags]\n aids1, aids2 = ut.listT(new_pairs)\n\n # Delete the old\n ibs.delete_annotmatch(\n d1['annotmatch_rowid'].values.tolist()\n + d2['annotmatch_rowid'].values.tolist()\n )\n\n # Add the new\n ams = ibs.add_annotmatch_undirected(aids1, aids2)\n ibs.set_annotmatch_evidence_decision(ams, new_truths)\n ibs.set_annotmatch_tag_text(ams, new_tag_texts)\n\n if False:\n import wbia.guitool as gt\n\n gt.ensure_qapp()\n ut.qtensure()\n from wbia.gui import inspect_gui\n\n inspect_gui.show_vsone_tuner(ibs, aid1, aid2)\n\n # pairs2 = pairs1.T[::-1].T\n # idx1, idx2 = ut.isect_indices(list(map(tuple, pairs1)),\n # list(map(tuple, pairs2)))\n # r_edges = list(set(map(tuple, map(sorted, pairs1[idx1]))))\n # unique_pairs = list(set(map(tuple, map(sorted, pairs1[idx1]))))\n # df = annotmatch.set_index(['annot_rowid1', 'annot_rowid2'])\n\n x = ut.ddict(list)\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\n import ubelt as ub\n\n _iter = annotmatch.iterrows()\n prog = ub.ProgIter(_iter, length=len(annotmatch))\n for k, m in prog:\n aid1 = m['annot_rowid1']\n aid2 = m['annot_rowid2']\n if m['annotmatch_evidence_decision'] == ibs.const.EVIDENCE_DECISION.POSITIVE:\n if aid_to_nid[aid1] == aid_to_nid[aid2]:\n x['agree1'].append(k)\n else:\n x['disagree1'].append(k)\n elif m['annotmatch_evidence_decision'] == ibs.const.EVIDENCE_DECISION.NEGATIVE:\n if aid_to_nid[aid1] == aid_to_nid[aid2]:\n x['disagree2'].append(k)\n else:\n x['agree2'].append(k)\n\n ub.map_vals(len, x)\n ut.dict_hist(annotmatch.loc[x['disagree1']]['annotmatch_tag_text'])\n\n disagree1 = annotmatch.loc[x['disagree1']]\n pb_disagree1 = disagree1[disagree1['annotmatch_tag_text'] == 'photobomb']\n aids1 = pb_disagree1['annot_rowid1'].values.tolist()\n aids2 = pb_disagree1['annot_rowid2'].values.tolist()\n aid_pairs = list(zip(aids1, aids2))\n infr = wbia.AnnotInference.from_pairs(aid_pairs, ibs=ibs, verbose=5)\n if False:\n feedback = infr.read_wbia_annotmatch_feedback(edges=infr.edges())\n infr.external_feedback = feedback\n infr.apply_feedback_edges()\n infr.start_qt_interface(loop=False)\n\n # Delete these values\n if False:\n nonpb_disagree1 = disagree1[disagree1['annotmatch_tag_text'] != 'photobomb']\n disagree2 = annotmatch.loc[x['disagree2']]\n ibs.delete_annotmatch(nonpb_disagree1['annotmatch_rowid'])\n ibs.delete_annotmatch(disagree2['annotmatch_rowid'])\n\n # ut.dict_hist(disagree1['annotmatch_tag_text'])\n import networkx as nx\n\n graph = nx.Graph()\n graph.add_edges_from(zip(pb_disagree1['annot_rowid1'], pb_disagree1['annot_rowid2']))\n list(nx.connected_components(graph))\n\n set(annotmatch.loc[x['disagree2']]['annotmatch_tag_text'])\n\n # aid1, aid2 = 2585, 1875\n # # pd.unique(annotmatch['annotmatch_evidence_decision'])\n # from wbia.gui import inspect_gui\n # inspect_gui.show_vsone_tuner(ibs, aid1, aid2)\n # from vtool import inspect_matches\n\n # aid1, aid2 = 2108, 2040\n\n # pd.unique(annotmatch['annotmatch_tag_text'])\n\n # infr.reset_feedback()\n # infr.relabel_using_reviews()","def compute(db, detected_chords_by_song):\n detected = {}\n ground = {}\n detected_chords = []\n ground_chords = []\n\n for s in detected_chords_by_song:\n detected[s['title']] = s['detected_chords']\n\n for s in db:\n ground[s['title']] = s['chord_vector']\n\n for k, v in ground.items():\n if k in detected:\n if len(v) == len(detected[k]):\n detected_chords.extend(detected[k])\n ground_chords.extend(v)\n\n # ignore chors represented with dash given that are not suppoted by the algorithm\n ground = []\n detected = []\n i = 0\n while i < len(ground_chords): \n if '-' != ground_chords[i]:\n ground.append(ground_chords[i])\n detected.append(detected_chords[i])\n i += 1\n\n fig, ax = plt.subplots()\n tick_marks = np.arange(len(EXISTING_NOTES))\n plt.xticks(tick_marks, EXISTING_NOTES, rotation=45)\n plt.yticks(tick_marks, EXISTING_NOTES)\n\n matrix = confusion_matrix(ground, detected, labels=EXISTING_NOTES)\n thresh = 500\n\n for i, j in itertools.product(range(matrix.shape[0]), range(matrix.shape[1])):\n plt.text(j, i, matrix[i, j],\n horizontalalignment=\"center\",\n size=5,\n color=\"black\" if matrix[i, j] > thresh else \"white\")\n plt.ylabel('True chords')\n plt.xlabel('Predicted chords')\n plt.tight_layout()\n\n fname = (\n os.path.join(\n settings.IMG_DIR,\n 'initial_diagnose', 'total_accuracy_confusion_matrix.png'))\n\n plt.imshow(matrix, interpolation='nearest')\n plt.colorbar()\n plt.savefig(fname)","def build_dataset(token_seq, token_seq_index, term_to_index, char_to_index, max_token_length=15, leading_context_size=10, trailing_context_size=10, leading_separator='{', trailing_separator='}', n_examples_per_context=10, n_errors_per_token=[1], n_errors_per_context=[0], dictionary=enchant.Dict('en_US'), seed=17):\n if isinstance(seed, RandomState):\n rng = seed\n else:\n rng = RandomState(seed=seed)\n\n n_contexts = sum([len(token_seq_index[t]) for t in token_seq_index.keys() if len(t) <= max_token_length])\n n_examples = n_examples_per_context * n_contexts\n max_inserts_per_token = max(n_errors_per_token)\n max_inserts_per_context = 2*max(n_errors_per_context)\n max_chars_in_window = leading_context_size + max_token_length + trailing_context_size + len(leading_separator) + len(trailing_separator) + max_inserts_per_token + max_inserts_per_context\n\n error_examples = np.zeros((n_examples, max_chars_in_window), dtype=np.int32)\n error_examples.fill(char_to_index[' '])\n\n leading_contexts = np.zeros((n_examples, leading_context_size + max_inserts_per_context))\n leading_contexts.fill(char_to_index[' '])\n spelling_errors = np.zeros((n_examples, max_token_length + max_inserts_per_token))\n spelling_errors.fill(char_to_index[' '])\n trailing_contexts = np.zeros((n_examples, trailing_context_size + max_inserts_per_context))\n trailing_contexts.fill(char_to_index[' '])\n\n correct_tokens = []\n corrupt_tokens = []\n corrections = np.zeros(n_examples, dtype=np.int32)\n error_types = []\n context_ids = []\n example_ids = []\n term_lens = []\n edit_distance_to_nearest_term = []\n nearest_term = []\n\n print('starting to construct {n_examples} examples'.format(\n n_examples=n_examples))\n\n pbar = progressbar.ProgressBar(term_width=40,\n widgets=[' ', progressbar.Percentage(),\n ' ', progressbar.ETA()],\n maxval=n_examples).start()\n n = 0\n\n index_to_char = dict((i,c) for c,i in char_to_index.iteritems())\n if 63 not in index_to_char.keys():\n # A workaround for now. Delete ASAP.\n index_to_char[63] = '^'\n\n def add_chars_to_array(n, array, chars, default_char=' '):\n for k, ch in enumerate(chars):\n try:\n array[n, k] = char_to_index[ch]\n except KeyError, e:\n array[n, k] = char_to_index[default_char]\n\n for token in token_seq_index.keys():\n if len(token) > max_token_length:\n continue\n\n term_len = len(token)\n distances = min_dictionary_edit_distance([token], dictionary)\n distance = distances[token]['distance']\n term = distances[token]['accepted']\n\n for i in token_seq_index[token]:\n for j in six.moves.range(n_examples_per_context):\n pbar.update(n+1)\n corruptor = rng.choice([insert_characters, delete_characters,\n replace_characters, transpose_characters])\n n_token_errors = rng.choice(n_errors_per_token)\n corrupt_token = corruptor(token, index_to_char, n=n_token_errors, seed=rng)\n\n n_context_errors = rng.choice(n_errors_per_context)\n leading = leading_context(token_seq, i, leading_context_size)\n leading = corruptor(leading, index_to_char, n=n_context_errors, seed=rng)\n trailing = trailing_context(token_seq, i, trailing_context_size)\n trailing = corruptor(trailing, index_to_char, n=n_context_errors, seed=rng)\n\n window = ''.join([leading, leading_separator,\n corrupt_token, trailing_separator, trailing])\n\n add_chars_to_array(n, error_examples, window)\n add_chars_to_array(n, leading_contexts, leading)\n add_chars_to_array(n, spelling_errors, corrupt_token)\n add_chars_to_array(n, trailing_contexts, trailing)\n\n correct_tokens.append(token)\n corrections[n] = term_to_index[token]\n corrupt_tokens.append(corrupt_token)\n error_types.append(corruptor.__name__)\n context_ids.append(i)\n example_ids.append(n)\n edit_distance_to_nearest_term.append(distance)\n nearest_term.append(term)\n term_lens.append(term_len)\n\n n += 1\n\n pbar.finish()\n\n df = pd.DataFrame({\n 'correction': corrections,\n 'error_type': error_types,\n 'context_id': context_ids,\n 'example_id': example_ids,\n 'edit_distance_to_nearest_term': edit_distance_to_nearest_term,\n 'nearest': nearest_term,\n 'term_length': term_lens,\n 'correct_token': correct_tokens,\n 'corrupt_token': corrupt_tokens\n })\n\n def add_columns(df, array, colname_prefix):\n colwidth = int(np.log10(array.shape[1]))+1\n colfmt = colname_prefix + '{col:0' + str(colwidth) + 'd}'\n for col in np.arange(array.shape[1]):\n colname = colfmt.format(col=col)\n df[colname] = array[:, col]\n\n add_columns(df, error_examples, 'full_error')\n add_columns(df, leading_contexts, 'leading_context')\n add_columns(df, spelling_errors, 'spelling_error')\n add_columns(df, trailing_contexts, 'trailing_context')\n\n return df","async def respond(self, ctx, index, *, response):\n try:\n config = self.bot.db['questions'][str(ctx.guild.id)][str(ctx.channel.id)]\n except KeyError:\n return\n if not response:\n await hf.safe_send(ctx, \"You need to type something for your response.\")\n return\n if len(response.split()) == 1:\n try:\n msg = await ctx.channel.fetch_message(int(response))\n await ctx.message.add_reaction('⤴')\n ctx.message = msg\n ctx.author = msg.author\n response = msg.content\n except (discord.NotFound, ValueError):\n pass\n if index not in config['questions']:\n await hf.safe_send(ctx, \"Invalid question index. Make sure you're typing this command in the channel \"\n \"the question was originally made in.\")\n return\n\n try:\n log_channel = ctx.guild.get_channel(config['log_channel'])\n except discord.NotFound:\n await hf.safe_send(ctx, \"The original log channel can't be found (type `;q setup`)\")\n return\n try:\n log_message = await log_channel.fetch_message(config['questions'][index]['log_message'])\n except discord.NotFound:\n await hf.safe_send(ctx, \"The original question log message could not be found. Type `;q a <index>` to \"\n \"close the question and clear it.\")\n return\n\n emb: discord.Embed = log_message.embeds[0]\n value_text = f\"\\n[Jump URL]({ctx.message.jump_url})\"\n emb.add_field(name=f\"Response by {ctx.author.name}#{ctx.author.discriminator}\",\n value=value_text.replace('', response[:1024-len(value_text)]))\n await log_message.edit(embed=emb)\n config['questions'][index].setdefault('responses', []).append(ctx.message.jump_url)\n await self._delete_log(ctx)\n await self._post_log(ctx)\n await ctx.message.add_reaction('✅')","def get_embeddings_from_raw_image(recognizer, frame):\n # detect faces, original frame and face boxes\n a, boxes = detector.find_face(frame, recognizer.ort_session, recognizer.input_name)\n\n\n # align facesq\n aligned_faces = []\n boxes[boxes < 0] = 0\n for i in range(boxes.shape[0]):\n box = boxes[i, :]\n f = np.copy(frame)\n y = align_face(recognizer, f, box)\n aligned_faces.append(y)\n\n embs = []\n for i in range(boxes.shape[0]):\n aligned_face = aligned_faces[i]\n embs.append(face_embedding(recognizer, aligned_face))\n\n return embs","def forward(self, input_features, review_qid):\n\n # items that are not padded\n src_mask = (input_features[\"qid\"] != 0).unsqueeze(-2)\n\n encoder_output = self.encoder(\n self.src_embed(input_features),\n src_mask,\n )\n review_embedding = self.embedding_by_feature[\"qid\"](review_qid)\n\n output = self.review_generator(encoder_output, src_mask, review_embedding)\n\n return output","def replace_tokens(self, tokens):\n details = []\n idx = 0\n if len(tokens) >= min_token_num:\n for i in range(len(tokens)):\n old_token = tokens[i]\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\n tokens[i] = self.get_insert_token(tokens[i])\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\n idx += len(tokens[i])\n return tokens, details","def fix_answer_values(answers):\n answers_fixed = answers.copy()\n answers_fixed = np.where(answers_fixed==1, 3, answers_fixed) # move \"no\" away temporarily\n answers_fixed = np.where(answers_fixed==2, 1, answers_fixed) # set \"no opinion\" value to 1\n answers_fixed = np.where(answers_fixed==3, 2, answers_fixed) # set temporary value 3 (meaning \"no\") to 2\n return answers_fixed","def find_corresponding_question(chat, tagged_user, prev_mod_index, index, q, unique_users):\n\n # searches from the previous message sent by the moderator\n for i in range(index, prev_mod_index[1], -1):\n message = chat[i]\n if message['user'] == tagged_user:\n question = is_question(message, unique_users, q)\n if question != None:\n return question\n \n # expanding the search space ft. some additional checks\n for i in range(prev_mod_index[1], prev_mod_index[0], -1):\n message = chat[i]\n \n if message['user'] == tagged_user:\n question = find_question_expanded(message, unique_users, q)\n \n if question != None:\n return question\n\n return None","def tag_conjunction_entities(annotated_pages):\n for page_id in annotated_pages:\n page = Page.objects(id=page_id).first()\n #page = db_conn.pages.find_one({\"_id\":page_id}) # TODO: refactor\n annotation_ids = [p.id for p in page[\"annotations_ids\"]]\n all_annotations = list(Annotation.objects(id__in=annotation_ids))\n # retrieve meta-annotations from that page\n meta_annotations = list(Annotation.objects(id__in=annotation_ids, entity_type=\"meta-annotation\"))\n #all_annotations = list(db_conn.annotations.find({\"_id\":{\"$in\":annotation_ids}})) # TODO: refactor\n #meta_annotations = list(db_conn.annotations.find({\"_id\":{\"$in\":annotation_ids} # TODO: refactor\n # ,\"entity_type\":\"meta-annotation\"}))\n if(len(meta_annotations)>0):\n logger.debug(\"Meta-annotations: %s\"%meta_annotations)\n for meta_annotation in meta_annotations:\n logger.info(\"Processing meta-annotation %s\"%meta_annotation[\"id\"])\n line_span = sorted(list(set([(position[\"page_id\"], position[\"line_n\"]) \n for position in meta_annotation[\"positions\"]])))\n top_entities_ids = [ann.id for ann in meta_annotation[\"top_entities\"]]\n top_entities = list(Annotation.objects(id__in=top_entities_ids))\n #top_entities = [db_conn.annotations.find_one({\"_id\":top_annotation_id}) \n # for top_annotation_id in meta_annotation[\"top_entities\"]]\n tokens = []\n for page_obj, line_n in line_span:\n page = Page.objects(id=page_obj.id).first()\n #page = db_conn.pages.find_one({\"_id\":page_id})\n for line in page[\"lines\"]:\n if line[\"line_number\"]==line_n:\n tokens.append((page_obj,line_n,line[\"tokens\"]))\n try:\n for entity in top_entities:\n assert entity is not None\n true_conjunctions = []\n meta_annotation_start = (top_entities[0][\"positions\"][0][\"page_id\"]\n ,top_entities[0][\"positions\"][0][\"line_n\"]\n ,top_entities[0][\"positions\"][0][\"start\"])\n meta_annotation_end = (top_entities[-1][\"positions\"][-1][\"page_id\"]\n ,top_entities[-1][\"positions\"][-1][\"line_n\"]\n ,top_entities[-1][\"positions\"][-1][\"end\"])\n conjunctions = [(token,page,line) for page,line,toks in tokens for token in toks\n if(token[\"offset_start\"] >= meta_annotation_start[2] and token[\"offset_end\"] <= meta_annotation_end[2])]\n true_conjunctions += [(page,line,token) for token,page,line in conjunctions \n if not is_annotated(page,line,token,all_annotations)]\n if(len(true_conjunctions)>0):\n logger.debug(\"Conjunctions found: %s\"%true_conjunctions)\n conjunction_annotations = []\n all_ann_ids = [annotation[\"ann_id\"] for annotation in all_annotations \n if '+' not in annotation[\"ann_id\"] ]\n identifier_counter = int(sorted(all_ann_ids, key=lambda x: int(x.replace('T','')))[-1].replace(\"T\",\"\"))\n logger.debug(sorted(all_ann_ids, key=lambda x: int(x.replace('T','')))[-1])\n for page_obj, line_n, token in true_conjunctions:\n identifier_counter += 1\n conjunction_annotation = Annotation(entity_type=\"conjunction\"\n , ingestion_timestamp=datetime.utcnow()\n , annotation_ingester_version=__version__\n , pageid=meta_annotation.pageid\n , filename=meta_annotation.filename\n , bid=meta_annotation.bid)\n conjunction_annotation.surface = token[\"surface\"]\n conjunction_annotation.ann_id = \"T%i\"%identifier_counter\n conjunction_annotation.positions.append(PagePosition(page_id = page_obj\n , start = token[\"offset_start\"]\n , end = token[\"offset_end\"]\n , line_n = line_n))\n conjunction_annotation.save()\n conjunction_annotations.append(conjunction_annotation)\n logger.info(\"(Page: %s) %i conjunction annotations were created and stored in MongoDB\"%(page_obj.id\n , len(conjunction_annotations)))\n logger.debug(\"N %i of top entities before adding conjunction entities\"%len(meta_annotation[\"top_entities\"]))\n meta_annotation[\"top_entities\"] += conjunction_annotations\n logger.debug(\"N %i of top entities after adding conjunction entities\"%len(meta_annotation[\"top_entities\"]))\n Annotation.objects(id=meta_annotation.id).update_one(set__top_entities = meta_annotation[\"top_entities\"])\n for conj_annotation in conjunction_annotations:\n for position in conj_annotation[\"positions\"]:\n page = Page.objects(id=position.page_id.id).first()\n page[\"annotations_ids\"].append(conj_annotation)\n page.save()\n except AssertionError as e:\n #raise e\n logger.warning(\"The meta-annotation %s has no top-level entities and generated the following error: %s\"%(meta_annotation[\"_id\"],e))\n except Exception as e:\n raise e","def make_correction_matrix(isotracer, formuladict, na_dict, indist_elems, autodetect, corr_limit):\n lookup_dict = {'O':['O16','O17','O18'], 'S':['S32','S33','S34'], 'Si':['Si28','Si29','Si30']}\n trac_atom = get_isotope_element(isotracer)\n if (isotracer == 'O18' or isotracer == 'S34' or isotracer == 'Si30'):\n \tM = make_expected_na_matrix_heavy(formuladict.get(trac_atom, 0), na_dict[trac_atom])\n else:\n \tM = make_expected_na_matrix(formuladict.get(trac_atom, 0), na_dict[trac_atom])\n M_indist = []\n\n indist_elems_copy = copy(indist_elems)\n na_dict_copy = copy(na_dict)\n for e in indist_elems:\n if e in indist_elems_copy:\n e2 = get_isotope_element(e)\n if e2 in formuladict:\n try:\n if(lookup_dict[e2][1] in indist_elems_copy) and (lookup_dict[e2][2] in indist_elems_copy):\n corr_limit_1 = int(corr_limit[lookup_dict[e2][1]])\n corr_limit_2 = int(corr_limit[lookup_dict[e2][2]])\n M_indist.append(add_indistinguishable_element_for_autodetect_heavy(M, formuladict[e2], na_dict_copy[e2], corr_limit_1, corr_limit_2))\n indist_elems_copy.remove(lookup_dict[e2][1])\n indist_elems_copy.remove(lookup_dict[e2][2])\n\n elif ((lookup_dict[e2][1] in indist_elems_copy) and (lookup_dict[e2][2] not in indist_elems_copy)) or \\\n ((lookup_dict[e2][1] not in indist_elems_copy) and (lookup_dict[e2][2] in indist_elems_copy)):\n pos = lookup_dict[e2].index(str(e))\n list_values = [0]*3\n list_values[0]= na_dict_copy[e2][0]\n list_values[pos]= na_dict_copy[e2][pos]\n na_dict_copy[str(e)]=list_values \n corr_limit_1 = int(corr_limit[e])\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\n\n else:\n corr_limit_1 = int(corr_limit[e])\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\n\n except Exception, exception_str:\n corr_limit_1 = int(corr_limit[e])\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\n\n if M_indist:\n i = np.eye(M.shape[1])\n for m in M_indist:\n m = np.matmul(m, i)\n i=m\n M = np.matmul(i, M)\n return pinv(M)","def process_replies(self, process_scores_only=False) -> None:\n if self._data.empty:\n logger.warning(msg=\"No survey replies found.\")\n return\n\n self._data[cons.SURVEY_REPLY].replace('', np.nan, inplace=True)\n self._data[cons.SURVEY_REPLY].replace('--deleted-content--', np.nan, inplace=True)\n survey_replies_with_content = self._data.dropna(subset=[cons.SURVEY_REPLY]).reset_index(\n drop=True)\n\n for row in survey_replies_with_content.itertuples(index=False):\n comment = self._clean_comments(comment=row.comment)\n period = \"%s_%s\" % (row.iteration_week, row.iteration_year)\n\n if self._process_prefix and comment is not None:\n\n if row.company_id not in self._result:\n self._result[row.company_id] = {}\n if period not in self._result[row.company_id]:\n self._result[row.company_id][period] = {}\n\n text = self.__attach_question_to_comment(comment, row, cons.lang_english)\n score, sentiment = self._process_sentiment(company_id=row.company_id, text=text)\n\n reply_data = {}\n\n if process_scores_only:\n reply_data.update(score=score)\n else:\n entities_text, entities_type = self._process_entities(comment)\n\n reply_data.update(dimension=row.dimension_description)\n reply_data.update(text=row.comment)\n reply_data.update(sentiment=sentiment)\n reply_data.update(entities_text=entities_text,\n entities_type=list(set(entities_type)))\n\n self._result[row.company_id][period][row.survey_reply_id] = {}\n self._result[row.company_id][period][row.survey_reply_id] = reply_data\n\n time.sleep(0.5)","def remove_extra_index_from_context_actions(context_action_dict):\n keys_to_keep = {'initial_value', 'replacement_value'}\n for question in context_action_dict:\n for obj_dct in context_action_dict[question]:\n total_keys = set(obj_dct.keys())\n keys_to_remove = total_keys - keys_to_keep\n for key in keys_to_remove:\n obj_dct.pop(key)\n return context_action_dict","def batchify(batch):\n\n\tquestion_len = list()\n\tlabel_list = list()\n\tfor ex in batch:\n\t\tquestion_len.append(len(ex[0]))\n\t\tlabel_list.append(ex[1])\n\n\t'''\n\tPadding the labels - unequal length sequences for sequenial data like we have. \n\tSince actual labels are 0/1 - we pad with -1, and will use this when 'masking' labels during loss and\n\taccuracy evaluation.\n\t'''\n\ttarget_labels = torch.nn.utils.rnn.pad_sequence([torch.tensor(y) for y in label_list], padding_value=-1).t()\n\n\t# dimension is dimension of every feature vector = n_guesses in this homework setting\n\tdim = batch[0][0].shape[1]\n\n\t# similar padding happens for the feature vectors, with vector of all zeros appended.\n\tx1 = torch.FloatTensor(len(question_len), max(question_len), dim).zero_()\n\tfor i in range(len(question_len)):\n\t\tquestion_feature_vec = batch[i][0]\n\t\tvec = torch.FloatTensor(question_feature_vec)\n\t\tx1[i, :len(question_feature_vec)].copy_(vec)\n\tq_batch = {'feature_vec': x1, 'len': torch.FloatTensor(question_len), 'labels': target_labels}\n\treturn q_batch","def replace_char(line_copy, index_candidates): \n for idx in index_candidates:\n line_copy[idx] = idx_vocab[random.choice(range(100, 10000))]\n\n return line_copy","def __getitem__(self, index):\n idx = self.available_idx[index]\n qn = self.questions[idx]\n qid = qn['id']\n house = qn['house']\n attr, room_attr = self.question_to_attribute(qn)\n\n # encode question and answer\n qe = self.encoded_questions[qn['h5_id']]\n ae = self.encoded_questions[qn['h5_id']]\n\n # choose path_ix\n path_ix = random.choice(range(qn['num_paths'])) if self.split == 'train' else 0 \n path_feats_h5 = h5py.File(osp.join(self.path_feats_dir, qn['path_name']+'.h5'), 'r')\n raw_ego_feats = path_feats_h5['ego_rgb%s' % path_ix][...].reshape(-1, 3200) # (L, 32, 10, 10)\n raw_path_len = raw_ego_feats.shape[0]\n raw_actions = qn['path_actions'][path_ix] # (L, )\n raw_pos_queue = qn['path_positions'][path_ix] # list of L positions\n if self.requires_imgs:\n path_images_h5 = h5py.File(osp.join(self.path_images_dir, qn['path_name']+'.h5'), 'r')\n raw_ego_imgs = path_images_h5['ego_rgb%s' % path_ix] # (L, 224, 224, 3)\n nav_ego_imgs = []\n\n # nav_phrases, nav_phrase_embs\n nav_pgs = [pg for pg in qn['program'] if 'nav' in pg['function']]\n nav_ids = [pg['id'][0] for pg in qn['program'] if 'nav' in pg['function']]\n nav_types = [pg['function'][4:] for pg in qn['program'] if 'nav' in pg['function']]\n nav_phrases = [pg['value_inputs'][0] for pg in qn['program'] if 'nav' in pg['function']]\n nav_phrase_embs = []\n for phrase in nav_phrases:\n nav_phrase_embs.append(np.array([self.wtov[wd] for wd in phrase.split()]).mean(0).astype(np.float32)) # (300, )\n nav_phrase_embs = np.array(nav_phrase_embs) # (#targets, 300)\n\n # For each segment path: feats + actions + pos_queue\n raw_key_ixs = qn['key_ixs_set'][path_ix]\n nav_ego_feats = []\n nav_action_inputs = []\n nav_action_outputs = []\n nav_pos_queues = []\n for i, key_ix in enumerate(raw_key_ixs):\n start_ix = 0 if i == 0 else raw_key_ixs[i-1] # we use last key_ix moment as start (spawn location)\n end_ix = raw_key_ixs[i]+1\n ego_feats = raw_ego_feats[start_ix:end_ix]\n action_inputs = np.array([4] + raw_actions[start_ix:end_ix][:-1], dtype=np.int64)\n action_outputs = np.array(raw_actions[start_ix:end_ix-1] + [3], dtype=np.int64)\n pos_queue = raw_pos_queue[start_ix:end_ix]\n assert ego_feats.shape[0] == len(pos_queue) == action_inputs.shape[0]\n # add to list\n nav_ego_feats.append(ego_feats)\n nav_action_inputs.append(action_inputs)\n nav_action_outputs.append(action_outputs)\n nav_pos_queues.append(pos_queue)\n if self.requires_imgs:\n nav_ego_imgs.append(raw_ego_imgs[start_ix:end_ix])\n\n # cache\n if self.to_cache and index not in self.img_data_cache:\n self.img_data_cache[index] = True # TODO: replace with ego_feats \n\n # private variable\n self.episode_house = self.env_loaded[house]\n self.nav_pos_queues = nav_pos_queues\n self.path_len = raw_path_len\n\n # return\n data = {}\n data['idx'] = idx\n data['qid'] = qid\n data['house'] = qn['house']\n data['question'] = qn['question']\n data['answer'] = qn['answer']\n data['type'] = qn['type']\n data['attr'] = attr\n data['qe'] = qe\n data['ae'] = ae\n data['path_name'] = qn['path_name']\n data['path_ix'] = path_ix\n data['nav_ids'] = nav_ids\n data['nav_types'] = nav_types\n data['nav_phrases'] = nav_phrases\n data['nav_phrase_embs'] = nav_phrase_embs\n data['nav_ego_feats'] = nav_ego_feats\n data['nav_action_inputs'] = nav_action_inputs\n data['nav_action_outputs'] = nav_action_outputs\n if self.requires_imgs:\n data['nav_ego_imgs'] = nav_ego_imgs\n return data","def tokenize_replace_pos(doc_list, language_code, replace_pos,\n core_num=multiprocessing.cpu_count()):\n param = [[d, language_code, replace_pos] for d in doc_list]\n pool = multiprocessing.Pool(core_num)\n return pool.map(_tokenize_replace_pos4map, param)","def q_attention(decoder_state, coverage=None):\n with variable_scope.variable_scope(\"Question_Attention\"):\n # Pass the decoder state through a linear layer (this is W_s s_t + b_attn in the paper)\n decoder_features = linear(decoder_state, attention_vec_size, True) # shape (batch_size, attention_vec_size)\n decoder_features = tf.expand_dims(tf.expand_dims(decoder_features, 1), 1) # reshape to (batch_size, 1, 1, attention_vec_size)\n\n if use_coverage and coverage is not None: # non-first step of coverage\n # Multiply coverage vector by w_c to get coverage_features.\n coverage_features = nn_ops.conv2d(coverage, w_q_c, [1, 1, 1, 1], \"SAME\") # c has shape (batch_size, attn_length, 1, attention_vec_size)\n\n # Calculate v^T tanh(W_h h_i + W_s s_t + w_c c_i^t + b_attn)\n e = math_ops.reduce_sum(v_q * math_ops.tanh(question_features + decoder_features + coverage_features), [2, 3]) # shape (batch_size,attn_length)\n\n # Calculate attention distribution\n attn_dist = masked_attention_q(e, q_padding_mask)\n\n # Update coverage vector\n coverage += array_ops.reshape(attn_dist, [batch_size, -1, 1, 1])\n else:\n # Calculate v^T tanh(W_h h_i + W_s s_t + b_attn)\n e = math_ops.reduce_sum(v_q * math_ops.tanh(question_features + decoder_features), [2, 3]) # calculate e\n\n # Calculate attention distribution\n attn_dist = masked_attention_q(e, q_padding_mask)\n\n if use_coverage: # first step of training\n coverage = tf.expand_dims(tf.expand_dims(attn_dist,2),2) # initialize coverage\n\n # Calculate the context vector from attn_dist and encoder_states\n context_vector = math_ops.reduce_sum(array_ops.reshape(attn_dist, [batch_size, -1, 1, 1]) * question_states, [1, 2]) # shape (batch_size, attn_size).\n context_vector = array_ops.reshape(context_vector, [-1, attn_size])\n\n return context_vector, attn_dist, coverage","def prepare_for_supervised(embeddings):\n \n X, y = [], []\n for problem in embeddings:\n pairs = [np.concatenate((problem['question'], problem[i])) \n for i in ('choice_0', 'choice_1', 'choice_2', 'choice_3')]\n correct_answer = problem['correct_answer']\n \n labels = [0, 0, 0, 0]\n labels[correct_answer] = 1\n X.extend(pairs)\n y.extend(labels)\n return X, y","def replace_tokens(self, tokens):\n details = []\n idx = 0\n if len(tokens) >= min_token_num:\n for i in range(len(tokens)):\n old_token = tokens[i]\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\n tokens[i] = self.get_delete_token()\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\n idx += len(tokens[i])\n return tokens, details","def pose_qa(self, specificity_sector=0, n_qas=4, n_diff_sectors=3,\n n_incorrect = 3, plan_file=None, save_posed=True):\n def test_ans_length(ans, indexes):\n la = len(ans)\n if la > indexes.max():\n return np.array(ans)[indexes]\n else:\n return np.array(ans)\n\n assert specificity_sector < n_diff_sectors, ('The specificity sector'\n ' goes from 0 to {}'.format(n_diff_sectors - 1))\n diff_sector_means = list(map(np.mean, \n np.array_split(\n np.array(\n list(range(10))) / 10.0,\n n_diff_sectors)))\n bn_parameter = diff_sector_means[specificity_sector]\n q_size = self.n_topics * self.n_top_sentences\n a_size = self.n_top_words\n ques_idx = np.random.binomial(n=q_size, p=bn_parameter, size=n_qas)\n anss_idx = np.random.binomial(n=a_size, p=bn_parameter, size=n_qas)\n\n if not plan_file is None:\n self.qa_plan = pd.read_csv(plan_file)\n self.qa_plan['answers'] = self.qa_plan['answers'] \\\n .apply(ast.literal_eval)\n\n ques = self.qa_plan['QA'][ques_idx]\n anss = [test_ans_length(a, anss_idx)\n for a in self.qa_plan['answers'][ques_idx]]\n posed_qas = []\n for que, ans in zip(ques, anss):\n if len(ans) >= n_incorrect:\n for a in ans:\n correct = tuple(a)\n q = que.replace(a[0], '_' * len(a[0]))\n tans = list(map(tuple, ans))\n tans.pop(tans.index(correct))\n posed_qas.append(\n (q, correct, tans)\n )\n if save_posed:\n pd.DataFrame(posed_qas,\n columns=['question', 'answer', 'bait']) \\\n .to_csv('qa_' + plan_file.split('.')[0] + '.csv',\n index=False)\n else:\n return pd.DataFrame(posed_qas,\n columns=['question', 'answer', 'bait'])\n else:\n plan_qas = {}\n for i in list(self.qa_plan.keys()):\n ques = self.qa_plan[i]['QA'][ques_idx]\n anss = [test_ans_length(a, anss_idx)\n for a in self.qa_plan[i]['answers'][ques_idx]]\n #q_tokenized = ' '.join(self.qa_plan[i]['QA'].values.tolist())\n int_bow = dict(self.interest_bower[i] \\\n .doc2bow(sum(self.int_sentences[i], [])))\n posed_qas = []\n for que, ans in zip(ques, anss):\n if len(ans) >= n_incorrect:\n for a in ans:\n correct = tuple(a)\n q = que.replace(a[0], '_' * len(a[0]))\n tans = list(map(tuple, ans))\n tans.pop(tans.index(correct))\n correct_id = self.interest_bower[i] \\\n .token2id[correct[0]]\n correct = correct + (int_bow[correct_id], )\n posed_qas.append((q, correct, tans))\n\n if save_posed:\n pd.DataFrame(posed_qas,\n columns=['question', 'answer', 'bait']) \\\n .to_csv('qa_for_' + i.replace(' ', '_') + '.csv',\n index=False)\n else:\n plan_qas[i] = pd.DataFrame(posed_qas,\n columns=['question', 'answer', 'bait'])\n return plan_qas","def insert_values():\n merged_df = pd.read_csv(\"merged_fuzzy_df.csv\")\n df = pd.read_csv(\"df.csv\")\n story_entity_df = pd.read_csv(\"story_entity_df.csv\")\n\n merged_df['entity_id'] = merged_df['entity_id'].apply(str)\n\n # find and input new types\n TYPES = get_types_ids(list(story_entity_df[\"label\"].unique()))\n\n new_parents = {}\n new_alias = {}\n\n merged_df[\"wiki\"].fillna(\"\", inplace=True)\n\n # if score = -2, it needs new alias as well as new parents\n for index, row in merged_df[merged_df[\"score\"] == -2].iterrows():\n\n # create a new parent\n if row[\"text\"] not in new_parents:\n new_parents[row[\"text\"]] = [\n str(uuid.uuid4()),\n row[\"text\"],\n TYPES[row[\"label\"]],\n row[\"wiki\"],\n True,\n str(datetime.utcnow())\n ]\n\n merged_df.at[index,\n \"entity_id\"] = new_parents[row[\"text\"]][0]\n\n # add alias with corresponding parent ID\n if row[\"text\"] not in new_alias:\n new_alias[row[\"text\"]] = [\n str(uuid.uuid4()),\n row[\"text\"],\n row[\"wiki\"],\n row[\"score\"],\n str(datetime.utcnow()),\n new_parents[row[\"text\"]][0],\n TYPES[row[\"label\"]]\n ]\n\n for index, row in merged_df[merged_df[\"score\"] >= -1].iterrows():\n # if score >= -1, it needs new alias\n if row[\"text\"] not in new_alias:\n new_alias[row[\"text\"]] = [\n str(uuid.uuid4()),\n row[\"text\"],\n row[\"wiki\"],\n row[\"score\"],\n str(datetime.utcnow()),\n row[\"entity_ref_id\"],\n TYPES[row[\"label\"]]\n ]\n\n merged_df.at[index,\n \"entity_id\"] = row[\"entity_ref_id\"]\n\n # if already matched, write story_entity_id into entity_id for mapping\n for index, row in merged_df[merged_df[\"score\"].isnull()].iterrows():\n merged_df.at[index,\n \"entity_id\"] = row[\"entity_ref_id\"]\n\n for _, value in new_parents.items():\n STORY_REF_INPUTS.append(value)\n\n for _, value in new_alias.items():\n ENTITY_ALIAS_INPUTS.append(value)\n\n logging.info(\"parents: {}\".format(len(STORY_REF_INPUTS)))\n logging.info(\"alias: {}\".format(len(ENTITY_ALIAS_INPUTS)))\n\n columns_to_drop = [\"legal_name\", \"wiki\", \"label\",\n \"entity_ref_id\", \"entity_name\",\n \"text\", \"score\"]\n merged_df.drop(columns_to_drop, axis=1, inplace=True)\n\n # generate uuids for story_map\n uuids = []\n for _ in range(len(merged_df)):\n uuids.append(str(uuid.uuid4()))\n\n logging.info(\"check na {}\".format(merged_df.isnull().values.any()))\n\n # input new_entites to table\n # using entity UUID and story UUID to apis_story_enity_map table\n\n merged_df[\"uuid\"] = uuids\n merged_df[\"created_at\"] = str(datetime.utcnow())\n\n merged_df = merged_df[[\"uuid\", \"entity_id\",\n \"story_uuid\", \"mentions\",\n \"salience\", \"created_at\"]]\n\n STORY_MAP_INPUTS = [tuple(row)\n for row in merged_df.itertuples(index=False)]\n\n # see if there are apis_entity elements in the stories\n match_manual_entity_to_story(df)\n\n insert_story_entity_ref(STORY_REF_INPUTS)\n insert_entity_alias(ENTITY_ALIAS_INPUTS)\n insert_story_entity_map(STORY_MAP_INPUTS)\n\n logging.info(\"finished\")\n\n logging.info(\"delete articles without entities\")\n articles_without_entities(df, story_entity_df)","def forward(self, passage, question):\n # Mask: FloatTensor with 0 in positions that are\n # padding (word index 0) and 1 in positions with actual words.\n # Make a mask for the passage. Shape: ?\n # TODO: Your code here.\n\n passage_mask = (passage != 0).type(\n torch.cuda.FloatTensor if passage.is_cuda else\n torch.FloatTensor)\n\n # Make a mask for the question. Shape: ?\n # TODO: Your code here.\n\n question_mask = (question != 0).type(\n torch.cuda.FloatTensor if question.is_cuda else\n torch.FloatTensor)\n\n\n # Make a LongTensor with the length (number non-padding words\n # in) each passage.\n # Shape: ?\n # TODO: Your code here.\n\n # Sum along dim 1 to get length of non-padding words for passage\n passageLengths = passage_mask.sum(dim=1)\n\n # Make a LongTensor with the length (number non-padding words\n # in) each question.\n # Shape: ?\n # TODO: Your code here.\n \n # Sum along dim 1 to get length of non-padding words for questions\n questionLengths = question_mask.sum(dim=1)\n\n # Part 1: Embed the passages and the questions.\n # 1.1 Embed the passage.\n # TODO: Your code here.\n # Shape: ?\n\n # Get passage embedding\n embedded_passage = self.embedding(passage)\n\n # 1.2. Embed the question.\n # TODO: Your code here.\n # Shape: ?\n\n # Get question embedding\n embedded_question = self.embedding(question)\n\n # Part 2. Encode the embedded passages with the RNN.\n # 2.1. Sort embedded passages by decreasing order of passage_lengths.\n # Hint: allennlp.nn.util.sort_batch_by_length might be helpful.\n # TODO: Your code here.\n\n # Sort training batch with allennlp function with passage and lengths as parameters\n sorted_passage, sorted_passage_lengths, passage_restoration, _ = sort_batch_by_length(embedded_passage, passageLengths)\n\n # 2.2. Pack the passages with torch.nn.utils.rnn.pack_padded_sequence.\n # Hint: Make sure you have the proper value for batch_first.\n # TODO: Your code here.\n\n # pack sequence based on non-padding words\n packed_passage = pack_padded_sequence(sorted_passage, sorted_passage_lengths, batch_first = True)\n\n # 2.3. Encode the packed passages with the RNN.\n # TODO: Your code here.\n\n # get passage representation from GRU\n passageEncoding, passageHidden = self.gruPassage(packed_passage)\n\n # 2.4. Unpack (pad) the passages with\n # torch.nn.utils.rnn.pad_packed_sequence.\n # Hint: Make sure you have the proper value for batch_first.\n # Shape: ?\n # TODO: Your code here.\n\n # Unpack sequence based on padding words\n passage_unpacked, lens_unpacked = pad_packed_sequence(passageEncoding, batch_first=True)\n\n # 2.5. Unsort the unpacked, encoded passage to restore the\n # initial ordering.\n # Hint: Look into torch.index_select or NumPy/PyTorch fancy indexing.\n # Shape: ?\n # TODO: Your code here.\n\n # get unsorted passage using restoration indices\n unsorted_passage = passage_unpacked.index_select(0, passage_restoration)\n\n # Part 3. Encode the embedded questions with the RNN.\n # 3.1. Sort the embedded questions by decreasing order\n # of question_lengths.\n # Hint: allennlp.nn.util.sort_batch_by_length might be helpful.\n # TODO: Your code here.\n\n # Sort question batches\n sorted_question, sorted_question_lengths, question_restoration, _ = sort_batch_by_length(embedded_question, questionLengths)\n\n # 3.2. Pack the questions with pack_padded_sequence.\n # Hint: Make sure you have the proper value for batch_first.\n # TODO: Your code here.\n\n # pack questions based on padding words\n packed_question = pack_padded_sequence(sorted_question, sorted_question_lengths, batch_first = True)\n\n # 3.3. Encode the questions with the RNN.\n # TODO: Your code here.\n\n # Get question representation from GRU\n questionEncoding, questionHidden = self.gruQuestion(packed_question)\n\n # 3.4. Unpack (pad) the questions with pad_packed_sequence.\n # Hint: Make sure you have the proper value for batch_first.\n # Shape: ?\n # TODO: Your code here.\n\n # Unpack question representation based on padding words\n question_unpacked, lens_unpacked = pad_packed_sequence(questionEncoding, batch_first = True)\n\n # 3.5. Unsort the unpacked, encoded question to restore the\n # initial ordering.\n # Hint: Look into torch.index_select or NumPy/PyTorch fancy indexing.\n # Shape: ?\n # TODO: Your code here.\n\n # restore original question ordering using restoration indices\n unsorted_question = question_unpacked.index_select(0, question_restoration)\n\n\n # Part 4. Calculate attention weights and attend to question.\n\n # use softmax to convert weights to probabilities, use those probabilites by multiplying questions to get weighted average\n # another affine transformation to get the weights from the passages, trainable parameter\n # define another matrix for attention and multiply that by tensor to get logits, then do softmax from logits to get probability\n # then computed weighted average from that probability\n\n # 4.1. Expand the encoded question to shape suitable for attention.\n # Hint: Think carefully about what the shape of the attention\n # input vector should be. torch.unsqueeze and torch.expand\n # might be useful.\n # Shape: (batch_size, passage_len, question_len, hidden_dim) (64, 15, 124, 512)\n # need to get question and passage shape the same\n # TODO: Your code here.\n\n # Goal: (batch_size, passage_len, question_len, hidden_dim) (64, 15, 124, 512)\n\n # unsorted question shape is (batch_size, question_len, hidden_dim) (64, , 15 x 512)\n # passage_mask.size(1) gets max passage size for the mask\n maxPassageSize = passage_mask.size(1)\n\n # Use -1 index within expand to keep original dimensions same and only add passage dimension\n expanded_question = unsorted_question.unsqueeze(dim=1).expand(-1, maxPassageSize, -1, -1)\n\n # 4.2. Expand the encoded passage to shape suitable for attention.\n # Hint: Think carefully about what the shape of the attention\n # input vector should be. torch.unsqueeze and torch.expand\n # might be useful.\n # Shape: ?\n # TODO: Your code here.\n\n # Get max question size\n maxQuestionSize = question_mask.size(1)\n\n # unsorted pasage shape is (batch_size, passage_len, hidden_dim) (64, 124, 512)\n # Add question dimension using expand and max question size\n\n # Keep all other dimensions the same with -1 index\n # Unsqueeze adds singleton dimension at place to insert new values\n expanded_passage = unsorted_passage.unsqueeze(dim=2).expand(-1, -1, maxQuestionSize,-1)\n\n\n # 4.3. Build attention_input. This is the tensor passed through\n # the affine transform.\n # Hint: Think carefully what the shape of this tensor should be.\n # torch.cat might be useful.\n # Shape: ?\n\n # attention_input is the concatenating of 4.1 and 4.2\n # pass in attention input to affine transformation\n # use affine_transform function and pass in the concatenated matrix\n # TODO: Your code here.\n\n # concatenate along the last dimension -1 with expanded passages and questions\n attention_input = torch.cat([expanded_passage, expanded_question,\n expanded_passage * expanded_question], dim=-1)\n\n # 4.4. Apply affine transform to attention input to get\n # attention logits. You will need to slightly reshape it\n # into a tensor of the shape you expect.\n # Shape: \n # TODO: Your code here.\n\n # apply attention transform layer, reshape the last dimension to so logits works with mask\n attention_logits = self.attention_transform(attention_input).squeeze(-1)\n\n # 4.5. Masked-softmax the attention logits over the last dimension\n # to normalize and make the attention logits a proper\n # probability distribution.\n # Hint: allennlp.nn.util.last_dim_softmax might be helpful.\n # Shape: ?\n # TODO: Your code here.\n\n # Get probabilty distribution from logits using softmax, default dim = -1 for last dimension\n prob_dist = masked_softmax(attention_logits, question_mask)\n\n # 4.6. Use the attention weights to get a weighted average\n # of the RNN output from encoding the question for each\n # passage word.\n # Hint: torch.bmm might be helpful.\n # Shape: ?\n # use torch.bmm with question to add weights\n # TODO: Your code here.\n\n # compute weighted average using matrix product with bmm\n # Weighted average = P(event) * event \n attentionWeights = torch.bmm(prob_dist, unsorted_question)\n\n # Part 5: Combine the passage and question representations by\n # concatenating the passage and question representations with\n # their product.\n # 5.1. Concatenate to make the combined representation.\n # Hint: Use torch.cat\n # Shape: ?\n # TODO: Your code here.\n\n # Get combined representation using formula to add passage representation, weighted average, and element-wise product\n # Concatenate over last dimension\n combinedRepresent = torch.cat([unsorted_passage, attentionWeights,\n unsorted_passage * attentionWeights], dim=-1)\n\n # Part 6: Compute logits for answer start index.\n\n # 6.1. Apply the affine transformation, and edit the shape.\n # Shape after affine transformation: ?\n # Shape after editing shape: ?\n # TODO: Your code here.\n\n # Get start projection using combined representation\n start_logits = self.start_output_projection(combinedRepresent).squeeze(-1)\n\n # 6.2. Replace the masked values so they have a very low score (-1e7).\n # This tensor is your start_logits.\n # Hint: allennlp.nn.util.replace_masked_values might be helpful.\n # Shape: ?\n # TODO: Your code here.\n\n start_logits = replace_masked_values(start_logits, passage_mask, -1e7)\n\n\n # 6.3. Apply a padding-aware log-softmax to normalize.\n # This tensor is your softmax_start_logits.\n # Hint: allennlp.nn.util.masked_log_softmax might be helpful.\n # Shape: ?\n # TODO: Your code here.\n \n softmax_start_logits = masked_log_softmax(start_logits, passage_mask)\n\n # Part 7: Compute logits for answer end index.\n\n # 7.1. Apply the affine transformation, and edit the shape.\n # Shape after affine transformation: ?\n # Shape after editing shape: ?\n # TODO: Your code here.\n\n end_logits = self.end_output_projection(combinedRepresent).squeeze(-1)\n\n # 7.2. Replace the masked values so they have a very low score (-1e7).\n # This tensor is your end_logits.\n # Hint: allennlp.nn.util.replace_masked_values might be helpful.\n # Shape: ?\n # TODO: Your code here.\n\n end_logits = replace_masked_values(end_logits, passage_mask, -1e7)\n\n # 7.3. Apply a padding-aware log-softmax to normalize.\n # This tensor is your softmax_end_logits.\n # Hint: allennlp.nn.util.masked_log_softmax might be helpful.\n # Shape: ?\n # TODO: Your code here.\n\n softmax_end_logits = masked_log_softmax(end_logits, passage_mask)\n\n # Part 8: Output a dictionary with the start_logits, end_logits,\n # softmax_start_logits, softmax_end_logits.\n # TODO: Your code here. Remove the NotImplementedError below.\n \n return {\n \"start_logits\": start_logits,\n \"end_logits\": end_logits,\n \"softmax_start_logits\": softmax_start_logits,\n \"softmax_end_logits\": softmax_end_logits\n }","def preprocess_nn(json_df, articles_df, vectorizer, max_seq_len, spellcheck=None, use_ngrams=True, credibility_model=None):\n\n # Raw Data\n uids = list(json_df[const.PKL_CLAIM_ID])\n claims = json_df[const.PKL_CLAIM]\n claimants = json_df[const.PKL_CLAIMANT]\n labels = json_df[const.PKL_LABEL]\n related_articles = json_df[const.PKL_RELATED_ARTICLES]\n\n # Processed Data\n processed_claims = []\n supporting_info = []\n credibilities = []\n final_labels = []\n\n start_time = time.time() # Used for tracking only\n\n '''\n Loop through all the claims and their article ID's\n '''\n for j, (str_claim, str_claimant, article_ids, label) in enumerate(zip(claims, claimants, related_articles, labels)):\n\n # Tracking use only\n if j % 1000 == 0 and j != 0:\n now = time.time()\n log(f\"Processing claim {j} | Last 1000 claims took {now - start_time} seconds\")\n start_time = now\n\n '''\n Process Claim: \n Final Claim = Claimant + Claim\n - Convert numbers to string representation\n - Take out all non-alphanumeric\n - Keep case - may be important\n '''\n claim = str_claimant + ' ' + str_claim\n claim = clean_txt(claim, spellcheck)\n\n '''\n Process articles\n - Get all articles from the dataframe by ID\n - Get relevant info from the article, truncated to max_seq_len # of words\n '''\n # Get list of article bodies from the dataframe\n article_ids = [str(article_id) for article_id in article_ids] # Need to lookup by string\n # Get the articles with the given article ID's and only extract the text column\n articles = articles_df.loc[articles_df[const.PKL_ARTICLE_ID].isin(article_ids), const.PKL_ARTICLE_TXT]\n\n # If using credibility, we separate the articles\n if credibility_model is not None:\n for article in articles:\n credibility = get_credibility(article, credibility_model)\n support_txt = get_relevant_info(claim, [article], vectorizer, max_seq_len, spellcheck, use_ngrams)\n # Add to list\n credibilities.append(credibility)\n processed_claims.append(claim)\n supporting_info.append(support_txt)\n final_labels.append(label)\n\n else:\n # If we are not using credibility model, construct support text from all articles\n support_txt = get_relevant_info(claim, articles, vectorizer, max_seq_len, spellcheck, use_ngrams)\n # Add to list\n processed_claims.append(claim)\n supporting_info.append(support_txt)\n final_labels.append(label)\n\n # Return what's appropriate\n if credibility_model is not None:\n return uids, processed_claims, supporting_info, final_labels, credibilities\n else:\n return uids, processed_claims, supporting_info, final_labels","def batch_inference(question,context): \n inputs = tokenizer(question, context, \n return_tensors='pt', \n truncation=True, \n padding=True)\n \n # Move data to GPU\n inputs = inputs.to(device)\n \n # Feed data through the model\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Q&A model outputs the two logit scores for each word.\n # One for its chance of being the start of the answer\n # and one for its chance of being the end\n start_logits = outputs.start_logits\n end_logits = outputs.end_logits\n \n # Find the words with the highest score\n # argmax(dim=1) means argmax with each sample\n start = start_logits.argmax(dim=1)\n end = end_logits.argmax(dim=1)\n \n # Return the answers\n # This is the point where we move the prediction back to main memory with .cpu()\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\"input_ids\"].cpu().numpy()]\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]","def __getitem__(self, idx):\n pos_pid = self.valid_passage_ids[idx]\n psg = self.passage_sent_dict[pos_pid]\n assert(len(psg) > 1)\n\n # randomly select a sentence as the question\n qid = random.choice(range(len(psg)))\n query = psg[qid]\n query_tokens = self.tokenizer.encode(query)\n\n # remove the selected sentence with 1 - sent_keep probability, this psg is the positive psg.\n sent_remove_flag = random.random() > self.sent_keep\n pos_psg = \" \".join(psg[:qid] + psg[qid+sent_remove_flag:])\n postive_psg_tokens = self.tokenizer.encode(pos_psg)\n\n # randomly sample from the rest to get negative samples.\n\n # extract a percentage of hard examples\n hard_k = int(self.sampled_softmax_n * self.hard_negative_rate)\n passage_set = self.passageids_set - set([pos_pid])\n hard_negatives = set([item for item in passage_set if item.split('.')[0] == pos_pid.split('.')[0]])\n\n # handle edge case for \n if len(hard_negatives) >= hard_k:\n npids_hard = random.sample(hard_negatives, k=hard_k)\n else:\n npids_hard = []\n hard_k = 0\n\n # extract a percentage of easy examples\n rest_k = self.sampled_softmax_n - hard_k\n npids_rest = random.sample(self.passageids_set - set([pos_pid]) - set(npids_hard), k=rest_k)\n\n # putting it all together\n npids = npids_hard + npids_rest\n negative_psg_tokens_list = [self.passage_dict[pid] for pid in npids]\n\n return query_tokens, postive_psg_tokens, negative_psg_tokens_list, pos_pid, npids","def vectorize_data(data, word_idx, sentence_size, memory_size,answer_size):\n S = []\n Q = []\n AS = []\n L = []\n label_nums = set([len(dt[2]) for dt in data])\n assert(len(label_nums) == 1)\n label_num = list(label_nums)[0]\n for story, query, answer, label in data:\n lq = max(0, sentence_size - len(query))\n q = [word_idx[w] for w in query] + [0] * lq\n\n ss = []\n for i, sentence in enumerate(story, 1):\n ls = max(0, sentence_size - len(sentence))\n ss.append([word_idx[w] for w in sentence] + [0] * ls)\n\n if len(ss) > memory_size:\n # Use Jaccard similarity to determine the most relevant sentences\n q_words = set(q)\n least_like_q = sorted(ss, cmp = lambda x, y: jaccard(set(x), q_words) < jaccard(set(y), q_words))[:len(ss)-memory_size]\n for sent in least_like_q:\n # Remove the first occurrence of sent. A list comprehension as in [sent for sent in ss if sent not in least_like_q]\n # should not be used, as it would remove multiple occurrences of the same sentence, some of which might actually make the cutoff.\n ss.remove(sent)\n else:\n # pad to memory_size\n lm = max(0, memory_size - len(ss))\n for _ in range(lm):\n ss.append([0] * sentence_size)\n\n y = np.zeros(len(word_idx) + 1) # 0 is reserved for nil word\n\n sa = []\n for i, sentence in enumerate(answer, 1):\n ls = max(0, answer_size - len(sentence))\n sa.append([word_idx[w] for w in sentence] + [0] * ls)\n\n lb = np.zeros(label_num)\n lb[int(label)] = 1\n\n S.append(ss)\n Q.append(q)\n AS.append(sa)\n L.append(lb)\n Q = pad_sequences(Q, sentence_size)\n\n return np.array(S), np.array(Q), np.array(AS), np.array(L)"],"string":"[\n \"def embed(raw_seq, index_dict):\\n return np.asarray([index_dict[word.lower()]\\n if word.lower() in index_dict\\n else index_dict[OOV_TOKEN] for word in raw_seq])\",\n \"def convert_questions_to_features(examples, tokenizer, max_query_length=None):\\n\\n unique_id = 1000000000\\n question_features = []\\n\\n for (example_index, example) in enumerate(tqdm(examples, desc='Converting questions')):\\n\\n query_tokens = tokenizer.tokenize(example.question_text)\\n if max_query_length is None:\\n max_query_length = len(query_tokens)\\n if len(query_tokens) > max_query_length:\\n query_tokens = query_tokens[0:max_query_length]\\n\\n for _ in enumerate(range(1)):\\n tokens_ = []\\n tokens_.append(\\\"[CLS]\\\")\\n for token in query_tokens:\\n tokens_.append(token)\\n tokens_.append(\\\"[SEP]\\\")\\n\\n input_ids_ = tokenizer.convert_tokens_to_ids(tokens_)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask_ = [1] * len(input_ids_)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids_) < max_query_length + 2:\\n input_ids_.append(0)\\n input_mask_.append(0)\\n\\n assert len(input_ids_) == max_query_length + 2\\n assert len(input_mask_) == max_query_length + 2\\n\\n if example_index < 1:\\n # logger.info(\\\"*** Example ***\\\")\\n # logger.info(\\\"unique_id: %s\\\" % (unique_id))\\n # logger.info(\\\"example_index: %s\\\" % (example_index))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in query_tokens]))\\n # logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids_]))\\n # logger.info(\\n # \\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask_]))\\n\\n question_features.append(\\n QuestionFeatures(\\n unique_id=unique_id,\\n example_index=example_index,\\n tokens_=tokens_,\\n input_ids=input_ids_,\\n input_mask=input_mask_))\\n unique_id += 1\\n\\n return question_features\",\n \"def qa_ctx_attention(self, qa_embed, ctx_embed, qa_mask, ctx_mask, noun_mask, non_visual_vectors):\\n num_img, num_region = ctx_mask.shape[2:]\\n u_a, raw_s, s_mask, s_normalized = self.str_attn(qa_embed, ctx_embed, qa_mask, ctx_mask, noun_mask=noun_mask, void_vector=non_visual_vectors)\\n qa_embed = qa_embed.repeat(1, 1, num_img, 1, 1)\\n mixed = torch.cat([qa_embed, u_a, qa_embed * u_a], dim=-1)\\n mixed = self.c2q_down_projection(mixed)\\n mixed_mask = (s_mask.sum(-1) != 0).float()\\n return mixed, mixed_mask, raw_s, s_normalized\",\n \"def _lost_answers_indexes(self, df, tokenized_contexts):\\n whole_answers_start = df[\\\"answer_start\\\"].tolist()\\n whole_answers_end = df[\\\"answer_end\\\"].tolist()\\n lost_dirty, lost_truncated = [], []\\n for i, (c, s, e) in enumerate(\\n zip(tokenized_contexts, whole_answers_start, whole_answers_end)\\n ):\\n mask = (\\n torch.tensor(c.attention_mask, device=self.device).bool()\\n & ~torch.tensor(c.special_tokens_mask, device=self.device).bool()\\n )\\n offsets = torch.tensor(c.offsets, device=self.device)[mask]\\n start_index = torch.nonzero(offsets[:, 0] == s)\\n end_index = torch.nonzero(offsets[:, 1] == e)\\n if len(start_index) == 0 or len(end_index) == 0:\\n if s > offsets[-1, 0] or e > offsets[-1, 1]:\\n lost_truncated.append(i)\\n else:\\n lost_dirty.append(i)\\n\\n return lost_truncated, lost_dirty\",\n \"def enseemble_results_extra(self, questions, topn):\\n ok_vocab = self.get_vocabulary()\\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\\n new_vocab = {w.upper(): v for w, v in new_vocab}\\n new_vocab = dict(new_vocab)\\n\\n results = []\\n for line_no, line in enumerate(utils.smart_open(questions)):\\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\\n line = utils.to_unicode(line)\\n if line.startswith(': '):\\n continue\\n else:\\n\\n try:\\n a, b, c, expected = [word.upper() for word in line.split()]\\n except ValueError:\\n logger.info(\\\"skipping invalid line #%i in %s\\\", line_no, questions)\\n continue\\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\\n \\\"\\\"\\\"if a not in new_vocab:\\n print(\\\"Dont know: \\\" + a)\\n if b not in new_vocab:\\n print(\\\"Dont know: \\\" + b)\\n if c not in new_vocab:\\n print(\\\"Dont know: \\\" + c)\\n if expected not in new_vocab:\\n print(\\\"Dont know: \\\" + expected)\\n \\\"\\\"\\\"\\n logger.debug(\\\"skipping line #%i with OOV words: %s\\\", line_no, line.strip())\\n results.append(None)\\n continue\\n\\n original_vocab = self.get_vocabulary()\\n self.set_vocabulary(new_vocab)\\n ignore = {a, b, c} # input words to be ignored\\n #print('topn')\\n #print(topn)\\n # find the most likely prediction, ignoring OOV words and input words\\n sims = self.most_similar(positive_words=[b, c], negative_words=[a], topn = topn)\\n # print(\\\"sims\\\")\\n #print(sims)\\n self.set_vocabulary(original_vocab)\\n inner_results = []\\n for predict in sims:\\n predicted = predict[0]\\n predicted = predicted.upper()\\n predicted_tuple = (predicted, predict[1])\\n #print(predicted_tuple)\\n inner_results.append(predicted_tuple)\\n #print(predicted)\\n results.append(inner_results)\\n #print(results)\\n\\n return results\",\n \"def parse_question(question):\\n\\tcontext = question['support']\\n\\tanswer = question['correct_answer']\\n\\ttarget = question['question']\\n\\n\\tcontext_words = context.split(\\\" \\\")[0: 510]\\n\\ttarget_words = target.split(\\\" \\\")\\n\\n\\tpunc_filter = str.maketrans('', '', string.punctuation)\\n\\n\\tcontext_words = [word.translate(punc_filter) for word in context_words]\\n\\ttarget_words = [word.translate(punc_filter) for word in target_words]\\n\\tanswer_words = [word.translate(punc_filter) for word in answer.split(\\\" \\\")]\\n\\n\\tbio_embeddings = [EMBEDER['O']]\\n\\tinside_answer = False\\n\\tanswer_index = 0\\n\\tcan_be_inside_answer = True\\n\\n\\t# The following loop and above code does:\\n\\t# -Find where the answer is and place a B tag\\n\\t# -While still in the answer (the answer is more than one word) put an I tag\\n\\t# -Outside of the answer place a O tag\\n\\t# -Start and end with an O tag for BERT's automatic\\n\\t# -start token and end token representing the start and end of a sentence.\\n\\tfor word in context_words:\\n\\t\\tif word.lower() == answer_words[0].lower() and can_be_inside_answer:\\n\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"B\\\"])\\n\\t\\t\\tanswer_index += 1\\n\\t\\t\\tinside_answer = True\\n\\t\\t\\tcan_be_inside_answer = False\\n\\t\\telif inside_answer:\\n\\t\\t\\tif len(answer_words) > 1:\\n\\t\\t\\t\\tif word.lower() != answer_words[answer_index]:\\n\\t\\t\\t\\t\\tinside_answer = False\\n\\t\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"I\\\"])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tinside_answer = False\\n\\t\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\t\\telse:\\n\\t\\t\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\tbio_embeddings.append(EMBEDER[\\\"O\\\"])\\n\\n\\tground_truth = torch.tensor([BERT_TOKENIZER.encode(target_words)])\\n\\tcontext_words = torch.tensor([BERT_TOKENIZER.encode(context_words)])\\n\\n\\tassert len(bio_embeddings) == len(context_words[0]), f'The BIO tags are not equal in length to the embeddings! ' \\\\\\n\\t f'{None} & {len(bio_embeddings)} & {len(context_words[0])}'\\n\\treturn context_words, bio_embeddings, ground_truth\",\n \"def replace_q_indices(circuit, q_nums, qr):\\n\\n new_circuit = qiskit.QuantumCircuit(qr)\\n for op in circuit.data:\\n original_qubits = op.qargs\\n new_op = copy.deepcopy(op)\\n new_op.qargs = [(qr, q_nums[x]) for x in [arg[1] for arg in original_qubits]]\\n new_circuit.data.append(new_op)\\n\\n return new_circuit\",\n \"def replace_canonical_referents(self, **kwargs):\\n replaced_count = 0\\n for doc in self.annotation_documents:\\n for sen in doc.sentences:\\n for part in sen.participants:\\n replaced_count += part.replace_by_canonical_referent(**kwargs) #this will replace in-place in project, but returns a count too.\\n\\n return replaced_count\",\n \"def process_question_for_prediction(question):\\n question = __set_has_hexadecimal(question)\\n question = __set_has_numeric(question)\\n homework_list = constants.HOMEWORK_SYNONMS_LIST\\n homework_list.sort(key=len, reverse=True)\\n replacement_text = constants.QUESTION_HAS_HOMEWORK_KEY\\n question = __set_has_homework_or_assignment(question, replacement_text, homework_list)\\n question = stem_training_data(question)\\n return question\",\n \"def sentences_2_idxs(self):\\n fo_pos = open(self.config.parsed_train_file_pos, 'w')\\n fo_neg = open(self.config.parsed_train_file_neg, 'w')\\n self.load_dicts()\\n labels = pd.read_csv(self.config.train_file, usecols=[\\\"target\\\"])\\n\\n labels = list(labels.values[:, 0])\\n questions = pd.read_csv(self.config.train_file,\\n usecols=[\\\"question_text\\\"], index_col=False)\\n unk_idx = self.word2idx.get(self.config.unknown_token)\\n\\n for label, quest in zip(labels, questions.question_text):\\n tokens = preprocess_text(quest)\\n\\n if self.config.include_unknown:\\n idxs = [self.word2idx.get(token, unk_idx) for token in\\n tokens]\\n else:\\n idxs = [self.word2idx.get(token) for token in tokens]\\n idxs = [idx for idx in idxs if idx]\\n out_line = (str(\\\" \\\".join(str(num) for num in idxs)) + \\\"\\\\n\\\")\\n if label == 1:\\n fo_pos.write(out_line)\\n else:\\n fo_neg.write(out_line)\",\n \"def preprocess_dataset(dataset, tokenizer):\\n eos = torch.tensor([tokenizer.eos_token_id], dtype=torch.long)\\n q_start = torch.tensor(tokenizer.encode('question:'), dtype=torch.long)\\n q_end = torch.tensor(tokenizer.encode(':question'), dtype=torch.long)\\n\\n tensors = [[] for i in range(3)]\\n for i in trange(len(dataset)):\\n example = dataset[i]\\n\\n context_start_idx = (example[2] == 1).nonzero()[0].item()\\n if example[1][-1] == 1:\\n context_end_idx = len(example[1]) - 1\\n else:\\n context_end_idx = (example[1] == 0).nonzero()[0].item()\\n ans_start = example[3] - context_start_idx\\n ans_end = example[4] - context_start_idx\\n\\n context = example[0][context_start_idx: context_end_idx]\\n question = example[0][: context_start_idx]\\n answer = example[0][example[3]: example[4] + 1]\\n\\n input_ids = torch.cat([\\n context,\\n eos,\\n answer,\\n eos,\\n q_start,\\n question,\\n q_end,\\n eos\\n ])\\n\\n attention_mask = torch.ones_like(input_ids, dtype=torch.long)\\n token_type_ids = torch.cat([\\n torch.zeros(len(context) + 1, dtype=torch.long),\\n torch.ones(len(answer) + 1, dtype=torch.long),\\n 2 * torch.ones(len(question) + 3, dtype=torch.long)\\n ])\\n token_type_ids[ans_start: ans_end + 1] = 1\\n\\n tensors[0].append(input_ids)\\n tensors[1].append(attention_mask)\\n tensors[2].append(token_type_ids)\\n\\n tensors_padded = []\\n for i, sequences in enumerate(tqdm(tensors)):\\n padded = pad_sequence(sequences, batch_first=True)\\n tensors_padded.append(padded)\\n\\n new_dataset = TensorDataset(*tensors_padded)\\n return new_dataset\",\n \"def substitute_num(self, numbers, qa3_answer):\\n question = self\\n for match in re.finditer('[0-9]+', question):\\n num = match.group(0)\\n i = qa3_answer.index_by_chunk(num)\\n if i is None or qa3_answer.result[i].get_type() != 'refYear':\\n if num not in numbers:\\n numbers.append(num)\\n question = re.sub(num, '<NUM' + string.ascii_uppercase[numbers.index(num)] + '>', question, 1)\\n return Qa3Question(question)\",\n \"def rearrange_indices(self):\\n num_fixed_words = 2\\n other_words = [w for w in self.word2index if w not in self.equivariant_words]\\n for idx, word in enumerate(self.equivariant_words):\\n w_idx = idx + num_fixed_words\\n self.word2index[word] = w_idx\\n self.index2word[w_idx] = word\\n for idx, word in enumerate(sorted(other_words)):\\n w_idx = idx + num_fixed_words + self.num_equivariant_words\\n self.word2index[word] = w_idx\\n self.index2word[w_idx] = word\",\n \"def replace_by_canonical_referent(self, cross_sentence=True):\\n replaced_count = 0\\n\\n # replace the participant in their containers\\n def replace_in_containers(myobj, replacing):\\n containers = {\\n \\\"event\\\": \\\"participants\\\",\\n \\\"sentiment_expression\\\": \\\"targets\\\",\\n \\\"sentence\\\": \\\"participants\\\",\\n }\\n for c_name, attrib_n in containers.items():\\n c_name = f\\\"in_{c_name}\\\"\\n if hasattr(myobj, c_name):\\n for c in getattr(myobj, c_name):\\n to_replace_in = getattr(c, attrib_n)\\n to_replace_in.append(replacing)\\n if myobj in to_replace_in:\\n to_replace_in.remove(myobj)\\n to_replace_in.sort(key=lambda x: x.begin)\\n\\n if self.canonical_referents and self.canonical_referents != \\\"from_canonref\\\":\\n # sometimes there are multiple canonrefs tagged\\n # this can be a) annotation mistake or\\n # b) multiple reference to a group, e.g. \\\"all\\\" refers to three companies.\\n for canonref in self.canonical_referents:\\n # check whether canonical referent is in same sentence\\n same_sentence = [s.element_id for s in self.in_sentence] == [\\n s.element_id for s in canonref.in_sentence\\n ]\\n # always replace when cross_sentence is true\\n # if cross_sentence is False (disallowed) only replace when canonref is in same sentence\\n if cross_sentence or same_sentence:\\n # replace element\\n replacing_participant = Participant(\\n canonref.text,\\n canonref.begin,\\n canonref.end,\\n canonref.element_id,\\n canonref.annotator_id,\\n canonref.document_title,\\n canonref.in_document,\\n self.role,\\n \\\"from_canonref\\\",\\n self.link_id,\\n canonref.tokens,\\n )\\n replacing_participant.in_sentence = self.in_sentence\\n replacing_participant.in_document = self.in_document\\n if hasattr(self, \\\"in_sentiment_expression\\\"):\\n replacing_participant.in_sentiment_expression = (\\n self.in_sentiment_expression\\n )\\n replacing_participant.from_original_participant = copy(self)\\n print(\\n f\\\"Replaced {self} with {canonref}. (in same sentence:{same_sentence})\\\"\\n )\\n\\n replace_in_containers(self, replacing_participant)\\n\\n # replace on document\\n self.in_document.participants.append(replacing_participant)\\n if self in self.in_document.participants:\\n self.in_document.participants.remove(self)\\n\\n replaced_count += 1\\n return replaced_count\",\n \"def enseemble_results(self, questions, topn):\\n ok_vocab = self.get_vocabulary()\\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\\n new_vocab = {w.upper(): v for w, v in new_vocab}\\n new_vocab = dict(new_vocab)\\n\\n results = []\\n for line_no, line in enumerate(utils.smart_open(questions)):\\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\\n line = utils.to_unicode(line)\\n if line.startswith(': '):\\n continue\\n else:\\n\\n try:\\n a, b, c, expected = [word.upper() for word in line.split()]\\n except ValueError:\\n logger.info(\\\"skipping invalid line #%i in %s\\\", line_no, questions)\\n continue\\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\\n \\\"\\\"\\\"if a not in new_vocab:\\n print(\\\"Dont know: \\\" + a)\\n if b not in new_vocab:\\n print(\\\"Dont know: \\\" + b)\\n if c not in new_vocab:\\n print(\\\"Dont know: \\\" + c)\\n if expected not in new_vocab:\\n print(\\\"Dont know: \\\" + expected)\\n \\\"\\\"\\\"\\n logger.debug(\\\"skipping line #%i with OOV words: %s\\\", line_no, line.strip())\\n results.append(None)\\n continue\\n\\n original_vocab = self.get_vocabulary()\\n self.set_vocabulary(new_vocab)\\n ignore = {a, b, c} # input words to be ignored\\n #print('topn')\\n #print(topn)\\n # find the most likely prediction, ignoring OOV words and input words\\n sims = self.most_similar(positive_words=[b, c], negative_words=[a], topn = topn)\\n # print(\\\"sims\\\")\\n #print(sims)\\n self.set_vocabulary(original_vocab)\\n inner_results = []\\n for predict in sims:\\n predicted = predict[0]\\n predicted = predicted.upper()\\n\\n inner_results.append(predicted)\\n #print(predicted)\\n results.append(inner_results)\\n #print(results)\\n\\n return results\",\n \"def preprocess(self, sequence, word2idx):\\n story = [word2idx[word] if word in word2idx else UNK_token for word in sequence.split()]\\n story = torch.Tensor(story)\\n return story\",\n \"def preprocess(self, sequence, word2idx):\\n context = [word2idx[word]\\n if word in word2idx else UNK_token for word in sequence.split()]\\n context = torch.Tensor(context)\\n return context\",\n \"def __getitem__(self, idx):\\n\\n ############ 1.9 TODO\\n # figure out the idx-th item of dataset from the VQA API\\n image_id_from_idx = self._vqa.questions['questions'][idx]['image_id']\\n question_id_from_idx = self._vqa.questions['questions'][idx]['question_id']\\n question_sentence = self._vqa.questions['questions'][idx]['question']\\n answer_sentences = [ans['answer'] for ans in self._vqa.qa[question_id_from_idx]['answers']]\\n\\n # import pdb; pdb.set_trace()\\n\\n ############\\n\\n # if self._cache_location is not None and self._pre_encoder is not None:\\n # ############ 3.2 TODO\\n # # implement your caching and loading logic here\\n\\n # ############\\n # raise NotImplementedError()\\n # else:\\n ############ 1.9 TODO\\n # load the image from disk, apply self._transform (if not None)\\n # import ipdb; ipdb.set_trace()\\n image_id_from_idx_string = self.fixed_str + str(image_id_from_idx)\\n truncated_image_id_from_idx = image_id_from_idx_string[-12:]\\n img_file_path = self._image_dir + '/' + self._image_filename_pattern.format(truncated_image_id_from_idx)\\n image = Image.open(img_file_path)\\n image = image.convert(\\\"RGB\\\")\\n image = self._transform(image)\\n ############\\n # raise NotImplementedError()\\n\\n ############ 1.9 TODO\\n # load and encode the question and answers, convert to torch tensors\\n question_encoding = torch.zeros(self._max_question_length, self.question_word_list_length)\\n answer_encoding = torch.zeros(10,self.answer_list_length)\\n\\n question_word_list = self._create_word_list(question_sentence)\\n # print(idx,question_word_list)\\n # print(len(self.question_word_to_id_map.keys()))\\n # quit()\\n for i, word in enumerate(question_word_list):\\n # import ipdb; ipdb.set_trace()\\n # print(i,word)\\n # quit()\\n if i >= self._max_question_length:\\n break\\n if word not in self.question_word_to_id_map.keys():\\n map_idx = self.unknown_question_word_index\\n else:\\n map_idx = self.question_word_to_id_map[word]\\n question_encoding[i][map_idx] = 1\\n\\n # answer_sentence_list = self._create_word_list(answer_sentences)\\n for i, answer in enumerate(answer_sentences):\\n if answer not in self.answer_to_id_map.keys():\\n map_idx = self.unknown_answer_index\\n else:\\n map_idx = self.answer_to_id_map[answer]\\n answer_encoding[i][map_idx] = 1\\n \\n data = {'image':image, 'question':question_encoding, 'answer':answer_encoding}\\n return data\\n\\n ############\\n # raise NotImplementedError()\",\n \"def _filter_unanswerable_samples(self):\\n a = []\\n q = []\\n annotations = []\\n for i in range(len(self.answers)):\\n if len(self.answers[i].nonzero()) > 0:\\n a.append(self.answers[i])\\n q.append(self.questions[i])\\n\\n annotations.append(self.annotations[i])\\n self.answers = a\\n self.questions = q\\n self.annotations = annotations\",\n \"def dynamic(question_quantized_dfs):\\n all_transitions = {}\\n\\n for i, qdf in enumerate(question_quantized_dfs):\\n q = qdf.iloc[:, utils.SKIP_COLUMNS:] # don't work on audio_rms column\\n\\n all_transitions[i] = OrderedDict()\\n\\n for au in q:\\n all_transitions[i][au] = np.zeros((4, 4))\\n\\n for (x, y), c in Counter(zip(q[au], q[au][1:])).items():\\n all_transitions[i][au][x - 1, y - 1] += c # TODO some warning about non-integer index\\n\\n # Concatenate all AU triples right, then all question down\\n temp1 = []\\n for k, q_transitions in all_transitions.items():\\n temp2 = []\\n\\n for au, trans in q_transitions.items():\\n trans_features = list(transition_features(trans))\\n trans_index = [au + '_change_ratio', au + '_slow_change_ratio', au + '_fast_change_ratio']\\n\\n temp2.append(pd.DataFrame(trans_features, index=trans_index).T)\\n temp1.append(pd.concat(temp2, axis=1))\\n\\n question_dynamic_features = pd.concat(temp1, axis=0)\\n\\n # Fix index\\n question_dynamic_features.index = range(len(question_quantized_dfs))\\n\\n return question_dynamic_features\",\n \"def process_question(qu):\\n\\n ## global ranking\\n rank_info = {}\\n rank_info_k = [\\\"viewcount\\\",\\\"score\\\",\\\"favoritecount\\\"]\\n for k in rank_info_k:\\n rank_info[k] = int(qu[k])\\n qu.pop(k,None)\\n\\n rank_info[\\\"creationdate\\\"] = qu[\\\"creationdate\\\"]\\n\\n if qu[\\\"acceptedanswer\\\"]:\\n qu[\\\"acceptedanswer\\\"] = list(qu[\\\"acceptedanswer\\\"])\\n else:\\n qu[\\\"acceptedanswer\\\"] = []\\n\\n qu.pop('comments',None) # discard comments, maybe add back later\\n qu[\\\"rank_info\\\"] = rank_info\\n\\n return qu\",\n \"def replace_special_token(self, tokenizer_fields: Dict[str, torch.Tensor], positions: List[int], replace_id: int):\\n token_ids, offsets = tokenizer_fields[\\\"token_ids\\\"], tokenizer_fields[\\\"offsets\\\"]\\n for pos in positions:\\n offset = offsets[pos].numpy().tolist()\\n if offset[0] != offset[1]:\\n warnings.warn(f\\\"replace normally expect token in `positions` has not been split to pieces.\\\"\\n f\\\"This warning should NOT happen unless during batch prediction at evaluation\\\")\\n token_ids[offset[0]] = replace_id\",\n \"def _encode_question(self, question):\\n \\n inputs = self.tokenizer.encode_plus(\\n question,\\n None,\\n add_special_tokens=True,\\n max_length=self.max_len,\\n )\\n\\n ids = inputs[\\\"input_ids\\\"]\\n mask = inputs[\\\"attention_mask\\\"]\\n token_type_ids = inputs[\\\"token_type_ids\\\"]\\n\\n padding_length = self.max_len - len(ids)\\n ids += ([0]*padding_length)\\n mask += ([0]*padding_length)\\n token_type_ids += ([0]*padding_length)\\n \\n return {\\n 'ids': torch.tensor(ids, dtype=torch.long),\\n 'mask': torch.tensor(mask, dtype=torch.long),\\n 'token_type_ids': torch.tensor(token_type_ids, dtype=torch.long),\\n \\n }\",\n \"def preprocess_seq(self, sequence, word2idx):\\n story = []\\n for value in sequence:\\n #v = [word2idx[word] if word in word2idx else UNK_token for word in value.split()] + [EOS_token]\\n story.append(word2idx[value] if value in word2idx else UNK_token)\\n story = torch.Tensor(story)\\n return story\",\n \"def convert_single_example(example, tokenizer, is_training, args):\\n tok_to_orig_index = []\\n orig_to_tok_index = []\\n all_doc_tokens = [] # all subtokens of original doc after tokenizing\\n features = []\\n for (i, token) in enumerate(example['paragraph_tokens']):\\n orig_to_tok_index.append(len(all_doc_tokens))\\n sub_tokens = albert_tokenize(tokenizer, token)\\n tok_to_orig_index.extend([i] * len(sub_tokens))\\n all_doc_tokens.extend(sub_tokens)\\n\\n # 特别注意！由于在paragraph_tokens中我们的token已经映射过一次了\\n # 这里wordpiece等于又映射了一遍，所以这里的操作是二次映射\\n if example['position_map']:\\n tok_to_orig_index = [example['position_map'][index] for index in tok_to_orig_index]\\n\\n # QUERY\\n query_tokens = []\\n query_tokens.append(\\\"[Q]\\\")\\n query_tokens.extend(albert_tokenize(tokenizer, example['question_text']))\\n if len(query_tokens) > args.max_query_length:\\n query_tokens = query_tokens[-args.max_query_length:]\\n\\n # ANSWER 预处理的时候先长短分开\\n tok_start_position = -1\\n tok_end_position = -1\\n # 这里终点是必然在para_tokens内的\\n if is_training:\\n # 现阶段，有短答案预测短答案，否则预测长答案\\n if example['answer_type'] != AnswerType['UNKNOWN']:\\n tok_long_start_position = orig_to_tok_index[example['long_start']]\\n if example['long_end'] == len(orig_to_tok_index):\\n tok_long_end_position = orig_to_tok_index[-1]\\n else:\\n tok_long_end_position = orig_to_tok_index[example['long_end']] - 1\\n tok_start_position = tok_long_start_position\\n tok_end_position = tok_long_end_position\\n if example['answer_type'] == AnswerType['SHORT']:\\n tok_short_start_position = orig_to_tok_index[example['short_start']]\\n if example['short_end'] == len(orig_to_tok_index):\\n tok_short_end_position = orig_to_tok_index[-1]\\n else:\\n tok_short_end_position = orig_to_tok_index[example['short_end']] - 1\\n tok_start_position = tok_short_start_position\\n tok_end_position = tok_short_end_position\\n\\n # Get max tokens number for original doc,\\n # should minus query tokens number and 3 special tokens\\n # The -3 accounts for [CLS], [SEP] and [SEP]\\n max_tokens_for_doc = args.max_seq_length - len(query_tokens) - 3\\n\\n # We can have documents that are longer than the maximum sequence length.\\n # To deal with this we do a sliding window approach, where we take chunks\\n # of up to our max length with a stride of `doc_stride`.\\n _DocSpan = collections.namedtuple(\\\"DocSpan\\\", [\\\"start\\\", \\\"length\\\"])\\n doc_spans = []\\n start_offset = 0\\n while start_offset < len(all_doc_tokens):\\n length = len(all_doc_tokens) - start_offset # compute number of tokens remaining unsliding\\n length = min(length, max_tokens_for_doc) # determine current sliding window size\\n doc_spans.append(_DocSpan(start=start_offset, length=length))\\n\\n # Consider case for reaching end of original doc\\n if start_offset + length == len(all_doc_tokens):\\n break\\n start_offset += min(length, args.doc_stride)\\n\\n # Convert window + query + special tokens to feature\\n for (doc_span_index, doc_span) in enumerate(doc_spans):\\n tokens = []\\n token_to_orig_map = {}\\n token_is_max_context = {}\\n segment_ids = []\\n tokens.append(\\\"[CLS]\\\")\\n segment_ids.append(0)\\n tokens.extend(query_tokens)\\n segment_ids.extend([0] * len(query_tokens))\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(0)\\n\\n for i in range(doc_span.length):\\n split_token_index = doc_span.start + i\\n token_to_orig_map[len(tokens)] = tok_to_orig_index[split_token_index]\\n\\n is_max_context = check_is_max_context(doc_spans, doc_span_index, split_token_index)\\n token_is_max_context[len(tokens)] = is_max_context\\n tokens.append(all_doc_tokens[split_token_index])\\n segment_ids.append(1)\\n tokens.append(\\\"[SEP]\\\")\\n segment_ids.append(1)\\n assert len(tokens) == len(segment_ids)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n\\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\\n # tokens are attended to.\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (args.max_seq_length - len(input_ids))\\n input_ids.extend(padding)\\n input_mask.extend(padding)\\n segment_ids.extend(padding)\\n\\n assert len(input_ids) == args.max_seq_length\\n assert len(input_mask) == args.max_seq_length\\n assert len(segment_ids) == args.max_seq_length\\n\\n start_position = None\\n end_position = None\\n answer_type = None\\n answer_text = \\\"\\\"\\n if is_training:\\n doc_start = doc_span.start\\n doc_end = doc_span.start + doc_span.length - 1\\n # For training, if our document chunk does not contain an annotation\\n # we throw it out, since there is nothing to predict.\\n contains_an_annotation = (tok_start_position >= doc_start and tok_end_position <= doc_end)\\n # 负样本需要经过采样，且目标为[CLS]\\n if (not contains_an_annotation) or example['answer_type'] == AnswerType['UNKNOWN']:\\n if args.include_unknowns < 0 or random.random() > args.include_unknowns:\\n continue\\n start_position = 0\\n end_position = 0\\n answer_type = AnswerType['UNKNOWN']\\n else:\\n doc_offset = len(query_tokens) + 2\\n start_position = tok_start_position - doc_start + doc_offset\\n end_position = tok_end_position - doc_start + doc_offset\\n answer_type = example['answer_type']\\n\\n # 如果是短答案，对一下答案是否正确\\n if example['answer_type'] == AnswerType['SHORT']:\\n answer_text = \\\" \\\".join(tokens[start_position:(end_position + 1)])\\n answer_text = answer_text.replace(' ', '').replace(u\\\"▁\\\", ' ').strip()\\n gt_answer = example['short_answer_text'].lower()\\n answer_text_chars = [c for c in answer_text if c not in \\\" \\\\t\\\\r\\\\n\\\" and ord(c) != 0x202F]\\n gt_answer_chars = [c for c in gt_answer if c not in \\\" \\\\t\\\\r\\\\n\\\" and ord(c) != 0x202F]\\n if \\\"\\\".join(answer_text_chars) != \\\"\\\".join(gt_answer_chars):\\n print(answer_text, 'V.S.', gt_answer)\\n\\n feature = InputFeatures(\\n unique_id=None,\\n example_index=None,\\n doc_span_index=doc_span_index,\\n tokens=tokens,\\n token_to_orig_map=token_to_orig_map,\\n token_is_max_context=token_is_max_context,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n segment_ids=segment_ids,\\n start_position=start_position,\\n end_position=end_position,\\n answer_text=answer_text,\\n answer_type=answer_type)\\n\\n features.append(feature)\\n\\n return features\",\n \"def convert_examples_to_features(examples, tokenizer, max_seq_length):\\n \\n features = []\\n num_tokens_article = []\\n count = 0\\n masking_token_id = tokenizer.convert_tokens_to_ids(['[MASK]'])[0]\\n # padding_token_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)\\n for example_index, example in enumerate(examples):\\n article_tokens = tokenizer.tokenize(example['article'])\\n ques_tokens = tokenizer.tokenize(example['question'].replace(\\\"@placeholder\\\", \\\"_\\\"))\\n masked_index = ques_tokens.index('_')\\n ques_tokens[masked_index] = '[MASK]'\\n \\n# options = example['options']\\n options = tokenizer.convert_tokens_to_ids(example['options'])\\n# print(options, '\\\\n')\\n\\n choices_features = []\\n _truncate_seq_pair(article_tokens, ques_tokens, max_seq_length - 3)\\n\\n# tokens = [\\\"[CLS]\\\"] + ques_tokens + [\\\"[SEP]\\\"] + article_tokens + [\\\"[SEP]\\\"]\\n tokens = ques_tokens + [\\\"[SEP]\\\"] + article_tokens + [\\\"[SEP]\\\"]\\n\\n# segment_ids = [0] * (len(ques_tokens) + 2) + [1] * (len(article_tokens) + 1)\\n segment_ids = [0] * (len(ques_tokens) + 1) + [1] * (len(article_tokens) + 1)\\n\\n input_ids = tokenizer.convert_tokens_to_ids(tokens)\\n input_mask = [1] * len(input_ids)\\n\\n # Zero-pad up to the sequence length.\\n padding = [0] * (max_seq_length - len(input_ids))\\n input_ids += padding\\n input_mask += padding\\n segment_ids += padding\\n\\t\\n candidates = example['options']\\n candidates_ids = tokenizer.convert_tokens_to_ids(candidates)\\n# print(tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0])\\n\\n lm_labels = [-1 if t_id != masking_token_id else tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0] for t_id in input_ids]\\n# lm_labels = [t_id if t_id != 0 else -1 for t_id in input_ids]\\n# for i, t_id in enumerate(lm_labels) :\\n# if(t_id == masking_token_id):\\n# lm_labels[i] = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\\n\\n# print(lm_labels, '\\\\n')\\n # tokenizer.convert_tokens_to_ids(tokenizer.tokenize(example['options'][example['label']]))[0]\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n assert len(segment_ids) == max_seq_length\\n assert len(lm_labels) == max_seq_length\\n\\n choices_features.append((tokens, input_ids, input_mask, segment_ids))\\n\\n features.append(\\n InputFeatures(\\n choices_features = choices_features,\\n lm_labels = lm_labels,\\n options = options,\\n label = example['label']\\n )\\n )\\n \\n return features\",\n \"def words_to_tensor(words, words_lookup_index, include_eos=True, numbers_replace=True, unknown_replace=True):\\n if type(words) != list: raise Exception(\\\"Expected a list (not a string etc)\\\")\\n tensor_length = len(words) + 1 if include_eos else len(words)\\n # tensor = np.zeros((1, tensor_length, len(words_lookup_index)), dtype=np.float32)\\n tensor = torch.zeros(1, tensor_length, len(words_lookup_index))\\n\\n for i, w in enumerate(words):\\n if w in words_lookup_index:\\n tensor[0, i, words_lookup_index[w]] = 1\\n elif numbers_replace and re_includes_numbers.search(w):\\n tensor[0, i, words_lookup_index[NUMBER_WORD_TOKEN]] = 1\\n elif unknown_replace:\\n tensor[0, i, words_lookup_index[UNKNOWN_WORD_TOKEN]] = 1\\n else:\\n raise Exception(\\\"Did not find item in index\\\")\\n\\n if include_eos:\\n tensor[0, -1, words_lookup_index[EOS_TOKEN]] = 1\\n return tensor\",\n \"def answerer(embeddings, tuples: tf.Variable, scoring=multilinear):\\n n_data, n_slots, rank = [d.value for d in embeddings.get_shape()]\\n n_data, n_tuples, order = [d.value for d in tuples.get_shape()]\\n\\n shift_indices = tf.constant(np.reshape(\\n np.outer(range(n_data), np.ones(n_tuples * n_slots)) * n_slots, (n_data, n_tuples, n_slots)), dtype='int64')\\n questions_shifted = tuples + shift_indices\\n\\n preds = scoring(\\n tf.reshape(embeddings, (n_data * n_slots, rank)),\\n tf.reshape(questions_shifted, (n_data * n_tuples, order)))\\n\\n return tf.reshape(preds, (n_data, n_tuples))\",\n \"def substitute_from_qa3(self, result, index, dataset):\\n question = self\\n if re.search(result.chunk, question):\\n if result.is_dataset(dataset):\\n question = re.sub(result.chunk, '<DATASET>', question)\\n elif result.is_type('refYear'):\\n question = re.sub(result.chunk, '<YEAR' + str(index) + '>', question)\\n elif result.is_identifier():\\n question = re.sub(result.chunk, '<PROP' + str(index) + '>', question)\\n else:\\n question = re.sub(result.chunk, '<VALUE' + str(index) + '>', question)\\n return Qa3Question(question)\",\n \"def additional_text_preprocessing_with_pos(pos_dict):\\n\\n tags_to_lemmatize = ['a', 'n', 'v', 'r']\\n\\n pos_dict = TextPreprocessor.find_named_entities(pos_dict)\\n if pos_dict is None:\\n return None, None\\n prepro = list()\\n contains_spelling_mistake = False\\n for t in pos_dict:\\n token = t['token']\\n tag = t['tag'].lower()\\n if token not in TextPreprocessor.PUNCTUATION and tag != \\\",\\\":\\n\\n token = TextPreprocessor.replace_user_mentions(token)\\n token = TextPreprocessor.replace_urls(token)\\n replaced = [token]\\n for i in replaced:\\n\\n i = TextPreprocessor.replace_all_punctuation(i)\\n if i.lower() not in TextPreprocessor.STOPWORDS and i != 'URL' and i!= 'USERMENTION':\\n if i != \\\"\\\" and not re.match('\\\\B#\\\\w*[a-zA-Z]+\\\\w*', i):\\n before = i\\n i = TextPreprocessor.SPELL_CHECKER.correct(i, tag)\\n if i != before:\\n contains_spelling_mistake = True\\n if tag in tags_to_lemmatize:\\n i = TextPreprocessor.lemmatize(i, tag)\\n i = TextPreprocessor.stem(i, tag)\\n # check again, since stemming, lemmatization or spelling correction can produce stopwords\\n # if i.lower() not in TextPreprocessor.STOPWORDS:\\n if i != 'URL' and i!= 'USERMENTION' and i!='':\\n i = i.lower()\\n if re.match(\\\".*[a-zA-Z]'\\\", i):\\n i = i[:-1]\\n prepro.append(i)\\n return prepro, contains_spelling_mistake\",\n \"def filter_ordered_questions_by_concepts(questions, item_params, target_concept, concept_map): \\n \\n def get_parents(target, concept_map):\\n \\\"\\\"\\\"\\n Given a target concept, return a list of concept IDs for parent concepts\\n \\\"\\\"\\\"\\n parents = []\\n target_index = concept_map[CONCEPTS_STR].index(target)\\n for row in range(len(concept_map[ADJ_MAT_STR])): \\n # get value in adjMat for each row at target concept's col\\n val = concept_map[ADJ_MAT_STR][row][target_index] \\n if val > 0 and target_index != row: # don't care concepts are their own parents\\n # print('parent found at {}, {}'.format(row, target_index)) # TODO remove\\n parents.append(concept_map[CONCEPTS_STR][row])\\n return parents\\n\\n def get_children(target, concept_map):\\n \\\"\\\"\\\"\\n Given a target concept, return a list of concept IDs for all child concepts\\n \\\"\\\"\\\"\\n child_inds = []\\n target_index = concept_map[CONCEPTS_STR].index(target)\\n target_row = concept_map[ADJ_MAT_STR][target_index]\\n for ind in range(len(target_row)): # for each ind in row of adj mat\\n val = target_row[ind]\\n if(val>0 and ind != target_index): # don't care concept is child of itself\\n child_inds.append(ind)\\n return list(map(lambda ind: concept_map[CONCEPTS_STR][ind], child_inds))\\n\\n def get_concept(eid, item_params):\\n \\\"\\\"\\\"\\n Given a question/exercise eid (String) and item_params (pd.DataFrame),\\n return the concept that exercise corresponds to.\\n\\n Assumes eid is unique (maps to exactly 1 row)\\n \\\"\\\"\\\"\\n\\n concept = item_params[item_params[EID]==eid][CONCEPT]\\n\\n if len(concept) < 1: # TODO: make this filter \\\"!= 1\\\" to be more strict\\n raise Exception(\\\"Exercise ID does not map to any exercises. eid: {}\\\".format(eid))\\n else:\\n return concept.iloc[0] # to get actual value\\n \\n df_item_params = pd.DataFrame.from_dict(item_params)\\n\\n rec_eids = []\\n\\n # get all recommendations from target, its children, parents\\n rec_eids += list(filter(lambda q: get_concept(q, df_item_params) in \\n [target_concept] + \\n get_children(target_concept, concept_map) +\\n get_parents(target_concept, concept_map), questions))\\n \\n # # GET TOP FOR EACH RELATIONSHIP\\n # # add max_num_target questions of same concept to rec_eids\\n # rec_target = list(filter(lambda q: get_concept(q, df_item_params) == target_concept, \\n # questions))[:max_num_target]\\n # # print(\\\"For target, added {}\\\".format(rec_target))\\n # rec_eids += rec_target\\n \\n\\n # # add max_num_child questions of child concepts to rec_eids\\n # rec_child = list(filter(lambda q: get_concept(q, df_item_params) in get_children(target_concept, concept_map), \\n # questions))[:max_num_child]\\n # # print(\\\"For children, added {}\\\".format(rec_child ))\\n # rec_eids += rec_child\\n\\n # # add max_num_parent questions of parent concepts to rec_eids\\n # rec_parent = list(filter(lambda q: get_concept(q, df_item_params) in get_parents(target_concept, concept_map), \\n # questions))[:max_num_parent] \\n # # print(\\\"For parents, added {}\\\".format(rec_parent))\\n # rec_eids += rec_parent \\n\\n # want order of recommendations to stay same & only grab from top half of recommendations\\n # return list(filter(lambda eid: eid in rec_eids, questions[:int(len(questions)/2)+1])) \\n\\n # want order of recommendations to stay same\\n return list(filter(lambda eid: eid in rec_eids, questions))\",\n \"def vectorize(ex, model, single_answer=False):\\r\\n word_dict = model.word_dict\\r\\n tgt_dict = model.tgt_dict\\r\\n\\r\\n if model.args.use_elmo:\\r\\n # Index words\\r\\n document = torch.from_numpy(np.asarray(elmo_sent_mapper(ex['document']), dtype=np.int))\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n question = torch.from_numpy(np.asarray(elmo_sent_mapper(ex['question']), dtype=np.int))\\r\\n\\r\\n # When using elmo, char representations are not required\\r\\n document_chars, question_chars = -1, -1\\r\\n else:\\r\\n # Index words\\r\\n document = torch.LongTensor([word_dict[w] for w in ex['document']])\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n question = torch.LongTensor([word_dict[w] for w in ex['question']])\\r\\n\\r\\n # Index chars\\r\\n if model.args.reader_type == 'mlstm' or \\\\\\r\\n model.args.reader_type == 'areader':\\r\\n document_chars, question_chars = -2, -2\\r\\n else:\\r\\n document_chars = torch.LongTensor([word_dict.word_to_char_ids(w).tolist() for w in ex['document']])\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n question_chars = torch.LongTensor([word_dict.word_to_char_ids(w).tolist() for w in ex['question']])\\r\\n\\r\\n # ...or with target(s) (might still be empty if answers is empty)\\r\\n # handle if questions are unanswerable [SQuAD v2.0]\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n \\r\\n if single_answer:\\r\\n assert (len(ex['answers']) > 0)\\r\\n answer = torch.LongTensor([tgt_dict[w] for w in ex['answers'][0]])\\r\\n else:\\r\\n # FIXME: multiple answers are possible, fix batchify also.\\r\\n # answer = [torch.LongTensor([word_dict[w] for w in ans]) for ans in ex['answers']]\\r\\n answer = torch.LongTensor([tgt_dict[w] for w in ex['answers'][0]])\\r\\n else:\\r\\n summary = torch.LongTensor([tgt_dict[w] for w in ex['summary']])\\r\\n\\r\\n\\r\\n if(model.args.reader_type!='summarizer'):\\r\\n return document, document_chars, question, question_chars, answer, \\\\\\r\\n ex['id'], ex['document'], ex['question'], ex['answers'], \\\\\\r\\n ex['src_vocab']\\r\\n else:\\r\\n return document, document_chars, summary, ex['id'], ex['document'], ex['summary'], ex['src_vocab']\",\n \"def own_accuracy(self, questions):\\n ok_vocab = self.get_vocabulary()\\n print(\\\"ok vocab\\\")\\n #print(ok_vocab)\\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\\n print(\\\"not dict\\\")\\n #new_vocab = [w.upper() for w in ok_vocab]\\n #print(new_vocab)\\n new_vocab = {w.upper(): v for w, v in new_vocab}\\n new_vocab = dict(new_vocab)\\n #print(new_vocab)\\n\\n\\n\\n\\n sections, section = [], None\\n wrong_predictions = []\\n for line_no, line in enumerate(utils.smart_open(questions)):\\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\\n line = utils.to_unicode(line)\\n if line.startswith(': '):\\n # a new section starts => store the old section\\n if section:\\n sections.append(section)\\n self.log_accuracy(section)\\n section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}\\n else:\\n if not section:\\n raise ValueError(\\\"missing section header before line #%i in %s\\\" % (line_no, questions))\\n try:\\n a, b, c, expected = [word.upper() for word in line.split()]\\n except ValueError:\\n logger.info(\\\"skipping invalid line #%i in %s\\\", line_no, questions)\\n continue\\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or expected not in new_vocab:\\n if a not in new_vocab:\\n print(\\\"Dont know: \\\" + a)\\n if b not in new_vocab:\\n print(\\\"Dont know: \\\" + b)\\n if c not in new_vocab:\\n print(\\\"Dont know: \\\" + c)\\n if expected not in new_vocab:\\n print(\\\"Dont know: \\\" + expected)\\n logger.debug(\\\"skipping line #%i with OOV words: %s\\\", line_no, line.strip())\\n continue\\n\\n original_vocab = self.get_vocabulary()\\n self.set_vocabulary(new_vocab)\\n ignore = {a, b, c} # input words to be ignored\\n\\n # find the most likely prediction, ignoring OOV words and input words\\n sims = self.most_similar(positive_words=[b, c], negative_words=[a])\\n #print(\\\"sims\\\")\\n #print(sims)\\n self.set_vocabulary(original_vocab)\\n\\n predicted = sims[0][0]\\n predicted = predicted.upper()\\n #print(predicted)\\n if predicted == expected:\\n section['correct'].append((a, b, c, expected))\\n else:\\n wrong_message = a + \\\" \\\" + b + \\\" \\\" + c + \\\", predicted: \\\" + predicted + \\\", should have been: \\\" + expected\\n section['incorrect'].append((a, b, c, expected))\\n wrong_predictions.append(wrong_message)\\n if section:\\n # store the last section, too\\n sections.append(section)\\n self.log_accuracy(section)\\n\\n total = {\\n 'section': 'total',\\n 'correct': sum((s['correct'] for s in sections), []),\\n 'incorrect': sum((s['incorrect'] for s in sections), []),\\n }\\n self.log_accuracy(total)\\n sections.append(total)\\n print(wrong_predictions)\\n return sections\",\n \"def fix_keyword_detection_issues(\\n dset: List, organ2ind: Dict\\n): \\n \\n \\\"\\\"\\\"SOLVE CARDIA\\\"\\\"\\\" \\n\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if (\\n \\\"cardiac\\\" in keywords\\n and \\\"stomach\\\" in occ_organ_names\\n and any(\\n [\\n item in organ_names\\n for item in [\\\"atrium\\\", \\\"ventricle\\\", \\\"myocardium\\\", \\\"pericardium\\\"]\\n ]\\n )\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"stomach\\\"])\\n occ_organ_names.remove(\\\"stomach\\\")\\n if (\\n \\\"cardia\\\" in keywords\\n and \\\"myocardium\\\" in occ_organ_names\\n and any([item in organ_names for item in [\\\"stomach\\\"]])\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"myocardium\\\"])\\n occ_organ_names.remove(\\\"myocardium\\\")\\n abstract[\\\"occ_organ_indices\\\"] = occ_organ_indices\\n abstract[\\\"occ_organ_names\\\"] = occ_organ_names\\n\\n inds = []\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if \\\"cardiac\\\" in keywords and \\\"stomach\\\" in occ_organ_names:\\n inds.append(ind)\\n\\n \\\"\\\"\\\"SOLVE THE LIVER - DELIVER PROBLEM\\\"\\\"\\\"\\n\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if (\\n any(\\n [\\n keyword in keywords\\n for keyword in [\\\"delivery\\\", \\\"delivered\\\", \\\"deliver\\\", \\\"delivering\\\"]\\n ]\\n )\\n and \\\"liver\\\" not in organ_names\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"liver\\\"])\\n occ_organ_names.remove(\\\"liver\\\")\\n keywords = [\\n keyword\\n for keyword in keywords\\n if keyword not in [\\\"delivery\\\", \\\"delivered\\\", \\\"deliver\\\", \\\"delivering\\\"]\\n ]\\n abstract[\\\"occ_organ_indices\\\"] = occ_organ_indices\\n abstract[\\\"occ_organ_names\\\"] = occ_organ_names\\n abstract[\\\"keywords\\\"] = keywords\\n\\n \\\"\\\"\\\"SOLVE THE COLON - COLONISE PROBLEM\\\"\\\"\\\"\\n\\n inds = []\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if (\\n any(\\n [\\n keyword in keywords\\n for keyword in [\\n \\\"colonize\\\",\\n \\\"colonise\\\",\\n \\\"colonized\\\",\\n \\\"colonised\\\",\\n \\\"colonies\\\",\\n ]\\n ]\\n )\\n and \\\"colon\\\" not in organ_names\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"colon\\\"])\\n occ_organ_names.remove(\\\"colon\\\")\\n keywords = [\\n keyword\\n for keyword in keywords\\n if keyword\\n not in [\\\"colonize\\\", \\\"colonise\\\", \\\"colonized\\\", \\\"colonised\\\", \\\"colonies\\\"]\\n ]\\n abstract[\\\"occ_organ_indices\\\"] = occ_organ_indices\\n abstract[\\\"occ_organ_names\\\"] = occ_organ_names\\n abstract[\\\"keywords\\\"] = keywords\\n\\n \\\"\\\"\\\"SOLVE THE BLADDER - GALLBLADDER PROBLEM\\\"\\\"\\\"\\n\\n \\\"\\\"\\\"Gallbladder doesn't cause the bladder keyword\\\"\\\"\\\"\\n \\\"\\\"\\\"Bladder does cause problems\\\"\\\"\\\"\\n\\n for ind, abstract in tqdm(enumerate(dset)):\\n keywords = abstract[\\\"keywords\\\"]\\n occ_organ_indices = abstract[\\\"occ_organ_indices\\\"]\\n occ_organ_names = abstract[\\\"occ_organ_names\\\"]\\n organ_names = abstract[\\\"organ_names\\\"]\\n if (\\n any([keyword in keywords for keyword in [\\\"bladder\\\", \\\"bladders\\\"]])\\n and any(\\n [\\n keyword in keywords\\n for keyword in [\\n \\\"gall\\\",\\n \\\"gallbladder\\\",\\n \\\"gall-bladder\\\",\\n \\\"gallbladders\\\",\\n \\\"gall-bladders\\\",\\n ]\\n ]\\n )\\n and \\\"gallbladder\\\" in organ_names\\n ):\\n occ_organ_indices.remove(organ2ind[\\\"urinary bladder\\\"])\\n occ_organ_names.remove(\\\"urinary bladder\\\")\\n keywords = [\\n keyword\\n for keyword in keywords\\n if keyword not in [\\\"bladder\\\", \\\"bladders\\\"]\\n ]\\n abstract[\\\"occ_organ_indices\\\"] = occ_organ_indices\\n abstract[\\\"occ_organ_names\\\"] = occ_organ_names\\n abstract[\\\"keywords\\\"] = keywords\\n\\n return dset\",\n \"def _process_row(self, question):\\n\\n # this returns a list, e.g. [('today', 'DATE'), ('Patrick', 'PERSON')]\\n ent_lst = self.text_preprocessor.compute_ner(question.context)\\n\\n ent_dct = {}\\n for ent_str, ner_category in ent_lst:\\n # perform uncasing\\n ent_dct[ent_str.lower()] = ner_category\\n\\n new_answers = []\\n for ans_struct in question.answers:\\n ans_text = ans_struct['text'].lower() # perform uncasing\\n if ans_text not in ent_dct:\\n continue\\n\\n ans_struct['ner_category'] = ent_dct[ans_text]\\n new_answers.append(ans_struct)\\n\\n question.answers = new_answers\\n return question\",\n \"def replace_oov_words_by_unk(tokenized_sentences, vocabulary, unknown_token=\\\"<unk>\\\"):\\r\\n \\r\\n # Place vocabulary into a set for faster search\\r\\n vocabulary = set(vocabulary)\\r\\n \\r\\n # Initialize a list that will hold the sentences\\r\\n # after less frequent words are replaced by the unknown token\\r\\n replaced_tokenized_sentences = []\\r\\n \\r\\n for sentence in tokenized_sentences:\\r\\n \\r\\n\\r\\n replaced_sentence = []\\r\\n\\r\\n for token in sentence: \\r\\n \\r\\n if token in vocabulary:\\r\\n replaced_sentence.append(token)\\r\\n else:\\r\\n replaced_sentence.append(unknown_token)\\r\\n \\r\\n # Append the list of tokens to the list of lists\\r\\n replaced_tokenized_sentences.append(replaced_sentence)\\r\\n \\r\\n return replaced_tokenized_sentences\",\n \"def _compute_question_ids(self):\\n if self._origin.question_ids:\\n # lines to keep: those with already sent emails or registrations\\n questions_tokeep_ids = self.env['event.registration.answer'].search(\\n [('question_id', 'in', self._origin.question_ids.ids)]\\n ).question_id.ids\\n else:\\n questions_tokeep_ids = []\\n for event in self:\\n if not event.event_type_id and not event.question_ids:\\n event.question_ids = False\\n continue\\n\\n if questions_tokeep_ids:\\n questions_toremove = event._origin.question_ids.filtered(lambda question: question.id not in questions_tokeep_ids)\\n command = [(3, question.id) for question in questions_toremove]\\n else:\\n command = [(5, 0)]\\n if event.event_type_id.use_mail_schedule:\\n command += [\\n (0, 0, {\\n 'title': question.title,\\n 'question_type': question.question_type,\\n 'sequence': question.sequence,\\n 'once_per_order': question.once_per_order,\\n 'answer_ids': [(0, 0, {\\n 'name': answer.name,\\n 'sequence': answer.sequence\\n }) for answer in question.answer_ids],\\n }) for question in event.event_type_id.question_ids\\n ]\\n event.question_ids = command\",\n \"def question_new_translate():\",\n \"def encode_answers(df, schema):\\n encoders = get_encoders(schema)\\n\\n for question in schema.questions:\\n df[question.prediction_encoded] = encoders[question.name].transform(df[question.prediction])\\n\\n return df\",\n \"def special_danish_accuracy(self, questions):\\n ok_vocab = self.get_vocabulary()\\n print(\\\"ok vocab\\\")\\n #print(ok_vocab)\\n new_vocab = [(w, self.model.wv.vocab[w]) for w in ok_vocab]\\n print(\\\"not dict\\\")\\n #new_vocab = [w.upper() for w in ok_vocab]\\n #print(new_vocab)\\n new_vocab = {w.upper(): v for w, v in new_vocab}\\n new_vocab = dict(new_vocab)\\n #print(new_vocab)\\n\\n\\n\\n\\n sections, section = [], None\\n wrong_predictions = []\\n for line_no, line in enumerate(utils.smart_open(questions)):\\n # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed\\n line = utils.to_unicode(line)\\n if line.startswith(': '):\\n # a new section starts => store the old section\\n if section:\\n sections.append(section)\\n self.log_accuracy(section)\\n section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}\\n else:\\n if not section:\\n raise ValueError(\\\"missing section header before line #%i in %s\\\" % (line_no, questions))\\n try:\\n a, b, c, d, e, expected = [word.upper() for word in line.split()]\\n except ValueError:\\n logger.info(\\\"skipping invalid line #%i in %s\\\", line_no, questions)\\n continue\\n if a not in new_vocab or b not in new_vocab or c not in new_vocab or d not in new_vocab or e not in new_vocab or expected not in new_vocab:\\n #print('not in vocab')\\n logger.debug(\\\"skipping line #%i with OOV words: %s\\\", line_no, line.strip())\\n continue\\n\\n original_vocab = self.get_vocabulary()\\n self.set_vocabulary(new_vocab)\\n ignore = {a, b, c, d, e} # input words to be ignored\\n\\n # find the most likely prediction, ignoring OOV words and input words\\n sims = self.most_similar(positive_words=[c, d, e], negative_words=[a, b])\\n #print(\\\"sims\\\")\\n #print(sims)\\n self.set_vocabulary(original_vocab)\\n\\n predicted = sims[0][0]\\n predicted = predicted.upper()\\n #print(predicted)\\n if predicted == expected:\\n section['correct'].append((a, b, c, d, e, expected))\\n else:\\n wrong_message = a + \\\" \\\" + b + \\\" \\\" + c + \\\" \\\" + d + \\\" \\\" + e + \\\", predicted: \\\" + predicted + \\\", should have been: \\\" + expected\\n section['incorrect'].append((a, b, c, d, e, expected))\\n wrong_predictions.append(wrong_message)\\n if section:\\n # store the last section, too\\n sections.append(section)\\n self.log_accuracy(section)\\n\\n total = {\\n 'section': 'total',\\n 'correct': sum((s['correct'] for s in sections), []),\\n 'incorrect': sum((s['incorrect'] for s in sections), []),\\n }\\n self.log_accuracy(total)\\n sections.append(total)\\n print(wrong_predictions)\\n return sections\",\n \"def _tokenize_replace_pos(text, language_code, replace_pos):\\n seq = annotool.raw2basicseq(text, language_code, pos=True)\\n word_seq = seq['word']\\n pos_seq = seq['pos']\\n for i, pos in enumerate(pos_seq):\\n if pos in replace_pos:\\n word_seq[i] = '[{}]'.format(pos)\\n return word_seq\",\n \"def encode_decode_TD(self, n_step, idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ ):\\r\\n\\r\\n actor_embedding = embed_seq(input_seq=self.input_, from_=self.dimension, to_= self.input_embed, is_training=self.is_training, BN=True, initializer=self.initializer)\\r\\n actor_encoding = encode_seq(input_seq=actor_embedding, input_dim=self.input_embed, num_stacks=self.num_stacks, num_heads=self.num_heads, num_neurons=self.num_neurons, is_training=self.is_training)\\r\\n \\r\\n if self.is_training == False:\\r\\n actor_encoding = tf.tile(actor_encoding,[self.batch_size,1,1])\\r\\n \\r\\n idx_list = copy(idx_list_previous)\\r\\n log_probs = copy(log_probs_previous)\\r\\n entropies = copy(entropies_previous)\\r\\n \\r\\n\\r\\n mask = copy(mask_previous)\\r\\n \\r\\n n_hidden = actor_encoding.get_shape().as_list()[2] # input_embed\\r\\n W_ref = tf.get_variable(\\\"W_ref\\\",[1, n_hidden, self.num_units],initializer=self.initializer)\\r\\n W_q = tf.get_variable(\\\"W_q\\\",[self.query_dim, self.num_units],initializer=self.initializer)\\r\\n v = tf.get_variable(\\\"v\\\",[self.num_units],initializer=self.initializer)\\r\\n \\r\\n encoded_ref = tf.nn.conv1d(actor_encoding, W_ref, 1, \\\"VALID\\\") # actor_encoding is the ref for actions [Batch size, seq_length, n_hidden]\\r\\n \\r\\n query1 = copy( query1_previous)\\r\\n query2 = copy( query2_previous)\\r\\n query3 = copy( query3_previous)\\r\\n idx_copy = copy(idx_)\\r\\n \\r\\n W_1 =tf.get_variable(\\\"W_1\\\",[n_hidden, self.query_dim],initializer=self.initializer) # update trajectory (state)\\r\\n W_2 =tf.get_variable(\\\"W_2\\\",[n_hidden, self.query_dim],initializer=self.initializer)\\r\\n W_3 =tf.get_variable(\\\"W_3\\\",[n_hidden, self.query_dim],initializer=self.initializer)\\r\\n \\r\\n \\r\\n \\\"\\\"\\\"\\r\\n # sample from POINTER from the perspective of the Actor\\r\\n \\\"\\\"\\\"\\r\\n for step in range(n_step + 1 ): \\r\\n query = tf.nn.relu(tf.matmul(query1, W_1) + tf.matmul(query2, W_2) + tf.matmul(query3, W_3))\\r\\n logits = pointer(encoded_ref=encoded_ref, query=query, mask=mask, W_ref=W_ref, W_q=W_q, v=v, C=config.C, temperature=config.temperature)\\r\\n prob = distr.Categorical(logits) # logits = masked_scores\\r\\n idx = prob.sample()\\r\\n\\r\\n idx_list.append(idx) # tour index\\r\\n idx_list_previous.append(idx)\\r\\n \\r\\n log_probs.append(prob.log_prob(idx)) # log prob\\r\\n log_probs_previous.append(prob.log_prob(idx))\\r\\n \\r\\n entropies.append(prob.entropy()) # entropies\\r\\n entropies_previous.append(prob.entropy())\\r\\n \\r\\n mask = mask + tf.one_hot(idx, self.max_length) # mask\\r\\n mask_previous = mask_previous + tf.one_hot(idx, self.max_length)\\r\\n\\r\\n idx_copy = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \\r\\n idx_ = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \\r\\n query3 = query2\\r\\n query2 = query1\\r\\n query1 = tf.gather_nd(actor_encoding, idx_) # update trajectory (state)\\r\\n \\r\\n query3_previous = query2_previous\\r\\n query2_previous = query1_previous\\r\\n query1_previous = tf.gather_nd(actor_encoding, idx_) # update trajectory (state) \\r\\n\\r\\n if (len(idx_list) >= self.max_length): break #leave the loop if reach the end of the episode\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n # sample from POINTER from the perspective of the Critic\\r\\n make q_t vector = 0\\r\\n \\\"\\\"\\\"\\r\\n while(len(idx_list) < self.max_length): \\r\\n \\r\\n logits = pointer_critic(encoded_ref=encoded_ref, mask=mask, W_ref=W_ref, v=v, C=config.C, temperature=config.temperature)\\r\\n prob = distr.Categorical(logits) # logits = masked_scores\\r\\n idx = prob.sample()\\r\\n\\r\\n idx_list.append(idx) # tour index\\r\\n log_probs.append(prob.log_prob(idx)) # log prob\\r\\n entropies.append(prob.entropy()) # entropies\\r\\n mask = mask + tf.one_hot(idx, self.max_length) # mask\\r\\n\\r\\n idx_copy = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \\r\\n #idx_ = tf.stack([tf.range(self.batch_size,dtype=tf.int32), idx],1) # idx with batch \\r\\n query3 = query2\\r\\n query2 = query1\\r\\n query1 = tf.gather_nd(actor_encoding, idx_copy) # update trajectory (state)\\r\\n \\r\\n idx_list.append(idx_list[0]) # return to start\\r\\n self.tour =tf.stack(idx_list, axis=1) # permutations\\r\\n self.log_prob = tf.add_n(log_probs) # corresponding log-probability for backprop\\r\\n self.entropies = tf.add_n(entropies)\\r\\n tf.summary.scalar('log_prob_mean', tf.reduce_mean(self.log_prob))\\r\\n tf.summary.scalar('entropies_mean', tf.reduce_mean(self.entropies))\\r\\n \\r\\n return idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ #returns variables necessary for the next loop\\r\",\n \"def map_question_linked_abstracts(include_no_abstracts):\\r\\n\\tif load_common_map():\\r\\n\\t\\treturn\\r\\n\\t\\t\\r\\n\\tglobal question_map, abstract_map, common_map\\r\\n\\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict\\r\\n\\r\\n\\tprint('\\\\nmapping question to answers')\\r\\n\\t\\r\\n\\tcommon_map = collections.defaultdict(list)\\r\\n\\t\\r\\n\\tno_abstract_count = 0\\r\\n\\t\\t\\r\\n\\tfor i,v in question_map.items():\\r\\n\\t\\tprint(i)\\r\\n\\t\\tabstracts = linked_abstracts_dict[i]\\r\\n\\t\\tfor a in abstracts:\\r\\n\\t\\t\\tif (a != 'NO_ABSTRACT') and (a in abstract_map.keys()):\\r\\n\\t\\t\\t\\tcommon_map[i].append([v,abstract_map[a]])\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tif include_no_abstracts:\\r\\n\\t\\t\\t\\t\\tcommon_map[i].append([v,()])\\r\\n\\t\\t\\t\\tno_abstract_count += 1\\r\\n\\t\\r\\n\\tprint('\\\\nabstractless : ' + str(no_abstract_count))\\r\\n\\t\\r\\n\\tprint(len(question_map))\\r\\n\\tprint(len(abstract_map))\\r\\n\\tprint(len(common_map))\\r\\n\\t\\r\\n\\tpickle.dump(common_map,open(paths.path_data_map_common_pickle,\\\"wb\\\"))\",\n \"def set_encodings(questions, candidates,\\n question_encoder, response_encoder):\\n for i, chunk in enumerate(chunks(questions, 100)):\\n question_strs = [q.question for q in chunk]\\n question_encodings = np.array(question_encoder(question_strs))\\n\\n for j in range(question_encodings.shape[0]):\\n questions[i * 100 + j].encoding = question_encodings[j]\\n if i % 50 == 0:\\n print(\\\"Questions: encoded %s of %s...\\\" % (i * 100, len(questions)))\\n\\n for i, chunk in enumerate(chunks(candidates, 50)):\\n candidate_strs = [(c.sentence, c.context) for c in chunk]\\n candidate_encodings = np.array(response_encoder(candidate_strs))\\n for j in range(candidate_encodings.shape[0]):\\n candidates[i * 50 + j].encoding = candidate_encodings[j]\\n if i % 100 == 0:\\n print(\\\"Candidates: encoded %s of %s...\\\" % (i * 50, len(candidates)))\",\n \"def match(self, passage_encodes, question_encodes, p_length, q_length):\\n with tf.variable_scope('bidaf'):\\n if self.use_complex_s:\\n p_length=tf.shape(passage_encodes)[1]\\n q_length=tf.shape(question_encodes)[1]\\n hp=tf.tile(tf.expand_dims(passage_encodes,2),[1,1,q_length,1])\\n hq=tf.tile(tf.expand_dims(question_encodes,1),[1,p_length,1,1])\\n fusion=tf.concat([hp,hq,hp*hq],-1)\\n sim_matrix=tf.squeeze(tf.contrib.layers.fully_connected(fusion,num_outputs=1,activation_fn=None),-1)\\n else:\\n sim_matrix = tf.matmul(passage_encodes, question_encodes, transpose_b=True)\\n context2question_attn = tf.matmul(tf.nn.softmax(sim_matrix, -1), question_encodes)\\n b = tf.nn.softmax(tf.expand_dims(tf.reduce_max(sim_matrix, 2), 1), -1)\\n question2context_attn = tf.tile(tf.matmul(b, passage_encodes),\\n [1, tf.shape(passage_encodes)[1], 1])\\n concat_outputs = tf.concat([passage_encodes, context2question_attn,\\n passage_encodes * context2question_attn,\\n passage_encodes * question2context_attn], -1)\\n return concat_outputs, None\",\n \"def combine_corpus(include_whole_abstracts=False):\\r\\n\\tif load_combined_corpus_maps():\\r\\n\\t\\treturn\\r\\n\\t\\r\\n\\tglobal gensim_dictionary\\r\\n\\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict, abstracts_dict\\r\\n\\tglobal common_corpus_list, question_map, abstract_map, abstract_whole_map\\r\\n\\tglobal corpus_layout\\r\\n\\t\\r\\n\\tprint('\\\\nbuilding common corpus')\\r\\n\\t\\r\\n\\tcommon_corpus_list = list()\\r\\n\\tquestion_map = dict()\\r\\n\\tabstract_map = dict()\\r\\n\\tabstract_whole_map = dict()\\r\\n\\t\\r\\n\\tsentence_count = 0\\r\\n\\t\\r\\n\\tcorpus_layout = []\\r\\n\\t\\r\\n\\tfor qi,qv in search_criteria_dict.items():\\r\\n\\t\\tquestions = qv\\r\\n\\t\\t\\r\\n\\t\\tsentence_incr = len(questions)\\r\\n\\t\\tquestion_map[qi] = (sentence_count,sentence_count + sentence_incr)\\r\\n\\t\\tsentence_count += sentence_incr\\r\\n\\t\\t\\r\\n\\t\\tfor st in questions:\\r\\n\\t\\t\\tcommon_corpus_list.append(st)\\r\\n\\t\\r\\n\\tcorpus_layout.append(('Q',sentence_count))\\r\\n\\t\\r\\n\\tfor ai,av in abstracts_dict.items():\\r\\n\\t\\tabstract = av\\r\\n\\t\\t\\r\\n\\t\\tsentence_incr = len(abstract)\\r\\n\\t\\tabstract_map[ai] = (sentence_count,sentence_count + sentence_incr)\\r\\n\\t\\tsentence_count += sentence_incr\\r\\n\\r\\n\\t\\tfor st in abstract:\\r\\n\\t\\t\\tcommon_corpus_list.append(st)\\r\\n\\t\\r\\n\\tcorpus_layout.append(('A',sentence_count))\\r\\n\\r\\n\\tif include_whole_abstracts:\\r\\n\\t\\tfor ai,av in abstracts_dict.items():\\r\\n\\t\\t\\tabstract = av\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tabstract_whole_map[ai] = (sentence_count,sentence_count + 1)\\r\\n\\t\\t\\tsentence_count += 1\\r\\n\\r\\n\\t\\t\\tst = tuple('\\\\n'.join(s) for s in zip(*abstract))\\r\\n\\t\\t\\tif len(st) < 2:\\r\\n\\t\\t\\t\\tst = ('','')\\r\\n\\r\\n\\t\\t\\tcommon_corpus_list.append(st)\\r\\n\\t\\t\\r\\n\\t\\tcorpus_layout.append(('W',sentence_count))\\r\\n\\t\\r\\n\\tpickle.dump(question_map,open(paths.path_data_map_questions_pickle,\\\"wb\\\"))\\r\\n\\tpickle.dump(abstract_map,open(paths.path_data_map_abstracts_pickle,\\\"wb\\\"))\\r\\n\\tpickle.dump(abstract_whole_map,open(paths.path_data_map_abstracts_whole_pickle,\\\"wb\\\"))\\t\\r\\n\\tpickle.dump(common_corpus_list,open(paths.path_data_corpus_pickle,\\\"wb\\\"))\\r\\n\\tpickle.dump(corpus_layout,open(paths.path_data_corpus_layout_pickle,\\\"wb\\\"))\",\n \"def preprocess(self, df, maxlen = 169):\\n \\n vocabs = self.tk.word_index.keys()\\n \\n df1 = self.treat_na(df)\\n df2 = self.remove_punc_sw(df1)\\n df3 = self.remove_numbers(df2)\\n df4 = self.lemma_pos(df3)\\n df5 = self.bigram(df4)\\n df6 = self.combine_bigrams(df5)\\n \\n new_docs = []\\n \\n for word_list in df6:\\n \\n if len(word_list) == 2 and word_list[0].lower() == 'noinfo' and word_list[1].lower() == 'noinfo':\\n new_docs.append(list(np.zeros(maxlen)))\\n \\n else:\\n new_word_list = []\\n for word in word_list:\\n if word not in vocabs:\\n word = 'UNKNOWN_TOKEN'\\n new_word_list.append(word)\\n \\n sequence = \\\" \\\".join(new_word_list)\\n vectors = self.tk.texts_to_sequences([sequence])\\n padded_vectors = pad_sequences(vectors, maxlen=maxlen, padding='post', truncating='post')\\n \\n new_docs.append(list(padded_vectors[0]))\\n \\n return new_docs\",\n \"def disambiguate_all_not_disambiguated(\\n celery_batch_size, total_records, indexing_queue_limit, disambiguation_queue_limit\\n):\\n with current_celery_app.connection_or_acquire() as conn:\\n indexer_queue = conn.default_channel.queue_declare(\\n queue=\\\"indexer_task\\\", passive=True\\n )\\n disambiguation_queue = conn.default_channel.queue_declare(\\n queue=\\\"disambiguation\\\", passive=True\\n )\\n if (\\n disambiguation_queue.message_count > disambiguation_queue_limit\\n or indexer_queue.message_count > indexing_queue_limit\\n ):\\n click.echo(\\\"MQ queues are full, can't run disambiguation\\\")\\n return\\n not_disambiguated_records_search = _get_all_not_disambiguated_records_search()\\n documents = not_disambiguated_records_search.scan()\\n if total_records:\\n documents = islice(documents, total_records)\\n uuids = (document.meta.id for document in documents)\\n _send_celery_group_disambiguation_task(uuids, celery_batch_size)\",\n \"def rewritten_queries(question):\\n # rewrites = []\\n # tq = tokenize(question)\\n # verb = tq[1] # 目前只处理 谁是XXX类 问题\\n # rewrites.append(\\n # RewrittenQuery(\\\"\\\\\\\"%s %s\\\\\\\"\\\" % (verb, \\\" \\\".join(tq[2:])),\\n # QUOTED_QUERY_SCORE))\\n # for j in range(2, len(tq)):\\n # rewrites.append(\\n # RewrittenQuery(\\n # \\\"\\\\\\\"%s %s %s\\\\\\\"\\\" % (\\n # \\\" \\\".join(tq[2:j + 1]), verb, \\\" \\\".join(tq[j + 1:])),\\n # QUOTED_QUERY_SCORE))\\n # rewrites.append(RewrittenQuery(\\\" \\\".join(tq[2:]), UNQUOTED_QUERY_SCORE))\\n return [RewrittenQuery(question, 1)]\",\n \"def w_question(analysis):\\n if analysis.sv:\\n #Opinion is a what question so we have to make some changes\\n if analysis.sv[0].vrb_main[0].endswith('like'):\\n verb = analysis.sv[0].vrb_main[0]\\n analysis.sv[0].vrb_main[0] = verb[:len(verb) - 4] + 'think+of'\\n\\n #processing as yes or no question\\n phrase = y_o_question(analysis)\\n\\n #Specific processing for invitation\\n if analysis.aim == 'invitation':\\n return ['how', 'about'] + phrase[1:]\\n\\n #Specific processing for classification\\n if analysis.aim.startswith('classification'):\\n aim_question = other_functions.list_rebuilding(analysis.aim)\\n return ['what', 'kind', 'of'] + aim_question[1:] + phrase\\n\\n #It is an how question\\n if other_functions.is_an_adj(analysis.aim) == 1:\\n return ['how'] + [analysis.aim] + phrase\\n elif analysis.aim == 'manner':\\n return ['how'] + phrase\\n\\n if analysis.aim == 'thing' or analysis.aim == 'situation' or analysis.aim == 'explication' or analysis.aim == 'opinion':\\n return ['what'] + phrase\\n return ['what'] + [analysis.aim] + phrase\",\n \"def auto_corr(sent, target_pos):\\n for pos in target_pos:\\n target_v = None\\n t0 = time.time()\\n if len(sent) > 1:\\n context_v = model.context2vec(sent, pos) \\n context_v = context_v / xp.sqrt((context_v * context_v).sum())\\n else:\\n context_v = None\\n\\n if target_v is not None and context_v is not None:\\n similarity = mult_sim(w, target_v, context_v)\\n else:\\n if target_v is not None:\\n v = target_v\\n elif context_v is not None:\\n v = context_v \\n else:\\n raise Exception(\\\"Can't find a target nor context.\\\") \\n similarity = (w.dot(v)+1.0)/2 # Cosine similarity can be negative, mapping similarity to [0,1]\\n\\n old_word = sent[pos]\\n if STATE == 'manual':\\n print \\\"\\\\n>> For the correction of word: \\\", old_word\\n print \\\">>>> Calculating the candidates ... ...\\\"\\n candidats = candidates(old_word)\\n\\n l = []\\n count = 0\\n\\n if len(candidats)!=0:\\n for i in (-similarity).argsort():\\n if index2word[i] not in candidats:\\n continue\\n else:\\n count += 1\\n if STATE == 'manual':\\n print \\\"candidate %d:\\\\t\\\"%count, index2word[i], \\\", similarity:\\\\t\\\", similarity[i]\\n l.append(i)\\n if count == N_RESULT:\\n break \\n else:\\n for i in (-similarity).argsort():\\n if np.isnan(similarity[i]):\\n continue\\n #print sent[pos], index2word[i]\\n dist = levenshtein(index2word[i], sent[pos])\\n if dist <= LEVEN_DIST:\\n count += 1\\n if STATE == 'manual':\\n print \\\"candidate %d:\\\\t\\\"%count, index2word[i],\\\", similarity:\\\\t\\\", similarity[i], \\\", levenshtein distance:\\\\t\\\", dist\\n l.append(i)\\n if count == N_RESULT:\\n break \\n if len(l) == 0:\\n continue\\n \\n if STATE == 'manual':\\n print \\\"Time: %.2fs\\\"%(time.time()-t0)\\n print \\\"Please choose the replacement, enter the number of the candidate: (Enter 0 for no replacement)\\\"\\n choice = six.moves.input('>> ')\\n c = int(choice)\\n if c == 0:\\n continue # no change made\\n elif c > 0:\\n idx = l[c - 1]\\n else:\\n raise Exception(\\\"Invalid input!\\\") \\n elif STATE == 'auto':\\n idx = l[0]\\n corr_word = index2word[idx]\\n\\n \\n print \\\">>>> \\\\t\\\", old_word, \\\"\\\\t--->\\\\t\\\", corr_word\\n sent[pos] = corr_word\\n return sent\",\n \"def generate_question_inter(path):\\n\\n\\t# Function to compute vocabulary intersection\\n\\tdef q1_q2_intersect(row):\\n\\t return(len(set(q_dict[row['question1']]).intersection(set(q_dict[row['question2']]))))\\n\\n\\t# Load training and test set\\n\\ttrain_orig =pd.read_csv(os.path.join(path,'train.csv'), sep=',',names = [\\\"id\\\", \\\"qid1\\\", \\\"qid2\\\", \\\"question1\\\",\\\"question2\\\",\\\"is_duplicate\\\"])\\n\\ttest_orig = pd.read_csv(os.path.join(path,'test.csv'), sep=',',names = [\\\"id\\\", \\\"qid1\\\", \\\"qid2\\\", \\\"question1\\\",\\\"question2\\\"])\\n\\n\\t# Concatenation\\n\\tques = pd.concat([train_orig[['question1', 'question2']], test_orig[['question1', 'question2']]], axis=0).reset_index(drop='index')\\n\\n\\n\\tq_dict = defaultdict(set)\\n\\tfor i in range(ques.shape[0]):\\n\\t q_dict[ques.question1[i]].add(ques.question2[i])\\n\\t q_dict[ques.question2[i]].add(ques.question1[i])\\n\\n\\t# Compute vocabulary intersection\\n\\ttrain_orig['q1_q2_intersect'] = train_orig.apply(q1_q2_intersect, axis=1, raw=True)\\n\\ttest_orig['q1_q2_intersect'] = test_orig.apply(q1_q2_intersect, axis=1, raw=True)\\n\\n\\ttrain_feat = train_orig[['q1_q2_intersect']]\\n\\ttest_feat = test_orig[['q1_q2_intersect']]\\n\\n\\tprint('Writing train features...')\\n\\ttrain_feat.to_csv(os.path.join(path,'train_question_inter.csv'))\\n\\n\\tprint('Writing test features...') \\n\\ttest_feat.to_csv(os.path.join(path,'test_question_inter.csv'))\\n\\n\\tprint('CSV written ! see: ', path, \\\" | suffix: \\\", \\\"_question_inter.csv\\\")\",\n \"def find_explanation_regression_based(user_question_list, global_patterns, global_patterns_dict,\\n cat_sim, num_dis_norm, agg_col, conn, cur, pat_table_name, res_table_name):\\n answer = [[] for i in range(len(user_question_list))]\\n local_pattern_loading_time = 0\\n question_validating_time = 0\\n score_computing_time = 0\\n score_computing_time_list = []\\n local_patterns_list = []\\n\\n for j, uq in enumerate(user_question_list):\\n dir = uq['dir']\\n topK_heap = TopkHeap(ExplConfig.TOP_K)\\n marked = {}\\n\\n t = dict(uq['target_tuple'])\\n\\n uq['global_patterns'] = find_patterns_relevant(\\n global_patterns_dict, uq['target_tuple'], conn, cur, res_table_name, pat_table_name, cat_sim)\\n\\n top_k_lists = [[] for i in range(len(uq['global_patterns']))]\\n local_patterns = []\\n\\n ExplConfig.VISITED_DICT = dict()\\n score_computing_start = time.time()\\n\\n for i in range(0, len(uq['global_patterns'])):\\n top_k_lists[i] = [4, uq['global_patterns'][i], t, []]\\n local_patterns.append(None)\\n F_key = str(sorted(uq['global_patterns'][i][0]))\\n V_key = str(sorted(uq['global_patterns'][i][1]))\\n pat_key = F_key + '|,|' + V_key + '|,|' + uq['global_patterns'][i][2] + '|,|' + uq['global_patterns'][i][3]\\n if pat_key in ExplConfig.VISITED_DICT:\\n continue\\n ExplConfig.VISITED_DICT[pat_key] = True\\n\\n tF = get_F_value(uq['global_patterns'][i][0], t)\\n local_pattern_query_fixed = '''SELECT * FROM {} \\n WHERE array_to_string(fixed, ', ')='{}' AND \\n REPLACE(array_to_string(fixed_value, ', '), '.0', '')='{}' AND\\n array_to_string(variable, ', ')='{}' AND \\n agg='{}' AND model='{}'\\n ORDER BY theta;\\n '''.format(\\n pat_table_name + '_local',\\n str(uq['global_patterns'][i][0]).replace(\\\"\\\\'\\\", '').replace('[', '').replace(']', ''),\\n str(tF)[1:-1].replace(\\\"\\\\'\\\", ''),\\n str(uq['global_patterns'][i][1]).replace(\\\"\\\\'\\\", '').replace('[', '').replace(']', ''),\\n uq['global_patterns'][i][2], uq['global_patterns'][i][3]\\n )\\n cur.execute(local_pattern_query_fixed)\\n res_fixed = cur.fetchall()\\n\\n if len(res_fixed) == 0:\\n continue\\n\\n local_patterns[i] = res_fixed[0]\\n T_set = set(t.keys()).difference(set(['lambda', uq['global_patterns'][i][2]]))\\n agg_col = local_patterns[i][3]\\n start = time.time()\\n t_t_list, agg_range, t_t_dict = get_tuples_by_F_V(local_patterns[i], local_patterns[i],\\n get_F_value(local_patterns[i][0], t),\\n # [get_V_value(local_patterns[i][2], t), [[-3, 3]]],\\n None,\\n conn, cur, res_table_name, cat_sim)\\n\\n dist_lb = 1e10\\n dev_ub = 0\\n for t_t in t_t_list:\\n if compare_tuple(t_t, t) == 0:\\n s = score_of_explanation(t_t, t, cat_sim, num_dis_norm, dir, t_t[agg_col], local_patterns[i],\\n local_patterns[i])\\n if str(t_t) not in marked:\\n marked[str(t_t)] = True\\n topK_heap.Push(Explanation(0, s[0], s[1], s[2], s[3], uq['dir'],\\n # list(map(lambda y: y[1], sorted(t_t.items(), key=lambda x: x[0]))),\\n dict(t_t),\\n ExplConfig.TOP_K, local_patterns[i], None))\\n\\n top_k_lists[i][-1].append(Explanation(0, s[0], s[1], s[2], s[3], uq['dir'],\\n dict(t_t),\\n ExplConfig.TOP_K, local_patterns[i], None))\\n if s[-1] < dist_lb:\\n dist_lb = s[-1]\\n # use raw distance (without penalty on missing attributes) as the lower bound\\n if abs(s[2]) > dev_ub:\\n dev_ub = abs(s[2])\\n if dist_lb < 1e-10:\\n dist_lb = 0.01\\n\\n end = time.time()\\n question_validating_time += end - start\\n\\n F_set = set(local_patterns[i][0])\\n V_set = set(local_patterns[i][2])\\n\\n # F union V \\\\subsetneq G\\n t_coarser_copy = list(t_t_list)\\n norm_lb = min(list(map(lambda x: x[agg_col], t_coarser_copy)))\\n\\n k_score = topK_heap.MinValue()\\n # prune\\n if topK_heap.HeapSize() == ExplConfig.TOP_K and 100 * float(dev_ub) / (dist_lb * float(norm_lb)) <= k_score:\\n continue\\n top_k_lists[i][-1] += DrillDown(global_patterns_dict, local_patterns[i],\\n F_set, T_set.difference(F_set.union(V_set)), V_set, t_coarser_copy,\\n t_coarser_copy, t, t,\\n conn, cur, pat_table_name, res_table_name, cat_sim, num_dis_norm,\\n dir, uq['query_result'],\\n norm_lb, dist_lb, topK_heap)\\n for tk in top_k_lists[i][-1]:\\n if str(tk.tuple_value) not in marked:\\n marked[str(tk.tuple_value)] = True\\n topK_heap.Push(tk)\\n\\n score_computing_end = time.time()\\n score_computing_time_cur_uq = score_computing_end - score_computing_start\\n\\n answer[j] = topK_heap.TopK()\\n score_computing_time_list.append([t, score_computing_time_cur_uq])\\n\\n print('Local pattern loading time: ' + str(local_pattern_loading_time) + 'seconds')\\n print('Score computing time: ' + str(score_computing_time) + 'seconds')\\n return answer, local_patterns_list, score_computing_time_list\",\n \"def convert_examples_to_features(examples, tokenizer, max_seq_length,\\n doc_stride, max_query_length, return_answers, skip_no_answer,\\n verbose=False, save_with_prob=False, msg=\\\"Converting examples\\\"):\\n\\n unique_id = 1000000000\\n features = []\\n question_features = []\\n\\n for (example_index, example) in enumerate(tqdm(examples, desc=msg)):\\n\\n # Tokenize query into (sub)tokens\\n query_tokens = tokenizer.tokenize(example.question_text)\\n if len(query_tokens) > max_query_length:\\n query_tokens = query_tokens[0:max_query_length]\\n\\n # Creating a map between word <=> (sub)token\\n tok_to_word_index = []\\n word_to_tok_index = [] # word to (start of) subtokens\\n all_doc_tokens = []\\n for (i, word) in enumerate(example.doc_words):\\n word_to_tok_index.append(len(all_doc_tokens))\\n sub_tokens = tokenizer.tokenize(word)\\n for sub_token in sub_tokens:\\n tok_to_word_index.append(i)\\n all_doc_tokens.append(sub_token)\\n\\n # The -2 accounts for [CLS], [SEP]\\n max_tokens_for_doc = max_seq_length - 2\\n\\n # Split sequence by max_seq_len with doc_stride, _DocSpan is based on tokens without [CLS], [SEP]\\n _DocSpan = collections.namedtuple( # pylint: disable=invalid-name\\n \\\"DocSpan\\\", [\\\"start\\\", \\\"length\\\"])\\n doc_spans = []\\n start_tok_offset = 0 # From all_doc_tokens\\n\\n # Get doc_spans with stride and offset\\n while start_tok_offset < len(all_doc_tokens):\\n length = len(all_doc_tokens) - start_tok_offset\\n if length > max_tokens_for_doc:\\n length = max_tokens_for_doc\\n doc_spans.append(_DocSpan(start=start_tok_offset, length=length))\\n if start_tok_offset + length == len(all_doc_tokens):\\n break\\n start_tok_offset += min(length, doc_stride) # seems to prefer doc_stride always\\n assert doc_stride < length, \\\"length is no larger than doc_stride for {}\\\".format(doc_spans)\\n\\n # Iterate each doc_span and make out_tokens\\n for (doc_span_index, doc_span) in enumerate(doc_spans):\\n\\n # Find answer position based on new out_tokens\\n start_position = None\\n end_position = None\\n\\n # For no_answer, same (-1, -1) applies\\n if example.start_position is not None and example.start_position < 0:\\n assert example.start_position == -1 and example.end_position == -1\\n start_position, end_position = NO_ANS, NO_ANS\\n\\n # For existing answers, find answers if exist\\n elif return_answers:\\n\\n # Get token-level start/end position\\n tok_start_position = word_to_tok_index[example.start_position]\\n if example.end_position < len(example.doc_words) - 1:\\n tok_end_position = word_to_tok_index[example.end_position + 1] - 1 # By backwarding from next word\\n else:\\n assert example.end_position == len(example.doc_words) - 1\\n tok_end_position = len(all_doc_tokens) - 1\\n\\n # Improve answer span by subword-level\\n (tok_start_position, tok_end_position) = _improve_answer_span(\\n all_doc_tokens, tok_start_position, tok_end_position, tokenizer,\\n example.orig_answer_text)\\n\\n # Throw away training samples without answers (due to doc_span split)\\n doc_start = doc_span.start\\n doc_end = doc_span.start + doc_span.length - 1\\n if (tok_start_position < doc_start or tok_end_position < doc_start or\\n tok_start_position > doc_end or tok_end_position > doc_end):\\n if skip_no_answer:\\n continue\\n else:\\n # For NQ, only add this in 2% (50 times downsample)\\n if save_with_prob:\\n if np.random.randint(100) < 2:\\n start_position, end_position = NO_ANS, NO_ANS\\n else:\\n continue\\n else:\\n start_position, end_position = NO_ANS, NO_ANS\\n\\n # Training samples with answers\\n else:\\n doc_offset = 1 # For [CLS]\\n start_position = tok_start_position - doc_start + doc_offset\\n end_position = tok_end_position - doc_start + doc_offset\\n assert start_position >= 0 and end_position >= 0, (start_position, end_position)\\n\\n out_tokens = [] # doc\\n out_tokens_ = [] # quesry\\n out_tokens.append(\\\"[CLS]\\\")\\n out_tokens_.append(\\\"[CLS]\\\")\\n token_to_word_map = {} # The difference with tok_to_word_index is it includes special tokens\\n token_is_max_context = {}\\n\\n # For query tokens, just copy and add [SEP]\\n for token in query_tokens:\\n out_tokens_.append(token)\\n out_tokens_.append(\\\"[SEP]\\\")\\n\\n # For each doc token, create token_to_word_map and is_max_context, and add to out_tokens\\n for i in range(doc_span.length):\\n split_token_index = doc_span.start + i\\n token_to_word_map[len(out_tokens)] = tok_to_word_index[split_token_index]\\n is_max_context = _check_is_max_context(doc_spans, doc_span_index, split_token_index)\\n token_is_max_context[len(out_tokens)] = is_max_context\\n out_tokens.append(all_doc_tokens[split_token_index])\\n out_tokens.append(\\\"[SEP]\\\")\\n\\n # Convert to ids and masks\\n input_ids = tokenizer.convert_tokens_to_ids(out_tokens)\\n input_ids_ = tokenizer.convert_tokens_to_ids(out_tokens_)\\n input_mask = [1] * len(input_ids)\\n input_mask_ = [1] * len(input_ids_)\\n\\n # Zero-pad up to the sequence length.\\n while len(input_ids) < max_seq_length:\\n input_ids.append(0)\\n input_mask.append(0)\\n assert len(input_ids) == max_seq_length\\n assert len(input_mask) == max_seq_length\\n while len(input_ids_) < max_query_length + 2: # +2 for [CLS], [SEP]\\n input_ids_.append(0)\\n input_mask_.append(0)\\n assert len(input_ids_) == max_query_length + 2\\n assert len(input_mask_) == max_query_length + 2\\n\\n # Printing for debug\\n if example_index < 1 and verbose:\\n logger.info(\\\"*** Example ***\\\")\\n logger.info(\\\"unique_id: %s\\\" % (unique_id))\\n logger.info(\\\"example_index: %s\\\" % (example_index))\\n logger.info(\\\"doc_span_index: %s\\\" % (doc_span_index))\\n logger.info(\\\"tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in out_tokens]))\\n logger.info(\\\"q tokens: %s\\\" % \\\" \\\".join(\\n [tokenization.printable_text(x) for x in out_tokens_]))\\n logger.info(\\\"token_to_word_map: %s\\\" % \\\" \\\".join(\\n [\\\"%d:%d\\\" % (x, y) for (x, y) in six.iteritems(token_to_word_map)]))\\n logger.info(\\\"token_is_max_context: %s\\\" % \\\" \\\".join([\\n \\\"%d:%s\\\" % (x, y) for (x, y) in six.iteritems(token_is_max_context)\\n ]))\\n logger.info(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in input_ids]))\\n logger.info(\\n \\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in input_mask]))\\n if return_answers:\\n answer_text = \\\" \\\".join(out_tokens[start_position:(end_position + 1)])\\n logger.info(\\\"start_position: %d\\\" % (start_position))\\n logger.info(\\\"end_position: %d\\\" % (end_position))\\n logger.info(\\n \\\"answer: %s\\\" % (tokenization.printable_text(answer_text)))\\n\\n # Append feature\\n features.append(\\n ContextFeatures(\\n unique_id=unique_id,\\n example_index=example_index,\\n doc_span_index=doc_span_index,\\n tokens=out_tokens,\\n token_to_word_map=token_to_word_map,\\n token_is_max_context=token_is_max_context,\\n input_ids=input_ids,\\n input_mask=input_mask,\\n start_position=start_position,\\n end_position=end_position))\\n question_features.append(\\n QuestionFeatures(\\n unique_id=unique_id,\\n example_index=example_index,\\n tokens_=out_tokens_,\\n input_ids=input_ids_,\\n input_mask=input_mask_))\\n\\n # Check validity of answer\\n if return_answers:\\n if start_position <= NO_ANS:\\n assert start_position == NO_ANS and end_position == NO_ANS, (start_position, end_position)\\n else:\\n assert out_tokens[start_position:end_position+1] == \\\\\\n all_doc_tokens[tok_start_position:tok_end_position+1]\\n orig_text, start_pos, end_pos = get_final_text_(\\n example, features[-1], start_position, end_position, True, False)\\n phrase = orig_text[start_pos:end_pos]\\n try:\\n assert phrase == example.orig_answer_text\\n except Exception as e:\\n # print('diff ans [%s]/[%s]'%(phrase, example.orig_answer_text))\\n pass\\n unique_id += 1\\n\\n return features, question_features\",\n \"def test_replace_question_mark_with_nan(raw_data: pd.DataFrame):\\n\\n raw_data_nan = replace_question_mark_with_nan(raw_data)\\n\\n # Check the existence of NaN values\\n assert check_null_values(raw_data_nan)\\n\\n # Check that there are no more question marks\\n assert not check_question_mark_as_null(raw_data_nan)\",\n \"def reindex(self):\\n self._index = {w: i for i, w in enumerate(self._words)}\\n self.n, self.d = self._vecs.shape\\n assert self.n == len(self._words) == len(self._index)\\n self._neighbors = None\",\n \"def ques_lstm(self, word_embeddings):\\n nlayer = self.config.nrnn_layer\\n lstm_cell = tf.contrib.rnn.BasicLSTMCell(\\n num_units=self.config.rnn_size, state_is_tuple=True)\\n lstm_cell = tf.contrib.rnn.MultiRNNCell(\\n [lstm_cell] * nlayer, state_is_tuple=True)\\n\\n with tf.variable_scope(\\n 'ques_lstm', initializer=self.initializer) as scope:\\n # Run the batch of sequence embeddings through the LSTM.\\n assert (self.feed_per_seq_length != None)\\n _, lstm_state = tf.nn.dynamic_rnn(\\n cell=lstm_cell,\\n inputs=word_embeddings,\\n sequence_length=self.feed_per_seq_length,\\n dtype=tf.float32)\\n\\n # extract c and h, then concat them all\\n ques_encoding_lis = []\\n for i in range(nlayer):\\n ques_encoding_lis = ques_encoding_lis + [\\n lstm_state[i].c, lstm_state[i].h\\n ]\\n ques_encoding = tf.concat(ques_encoding_lis, axis=1)\\n\\n assert (ques_encoding.shape[1] == self.config.rnnout_dim)\\n\\n return ques_encoding\",\n \"def transform_answers(self, stim_dict: dict):\\n new_ind = [resp.name for resp in RESPONSES]\\n for stim in stim_dict:\\n df = stim_dict[stim][\\\"responses\\\"]\\n df = df.fillna(\\\"empty\\\")\\n new_df = pd.DataFrame(columns=df.columns, index=new_ind)\\n for col in new_df.columns:\\n for row in new_df.index:\\n new_df[col][row] = 0\\n for subj in df.index:\\n if row in df[col][subj]:\\n new_df[col][row] += 1\\n new_df.columns = [\\\"Feelings\\\", \\\"Familiarity\\\"]\\n stim_dict[stim][\\\"transformed_responses\\\"] = new_df\\n self.stim_dict = stim_dict\",\n \"def simplify_ques(question, debug=False):\\n if not isinstance(question, str):\\n raise TypeError('Please provide a string for a question.')\\n\\n if debug is True:\\n load_json()\\n\\n neg = False\\n qwords = question.lower().split()\\n for i in qwords:\\n if i in NEGATIVE_WORDS:\\n neg = True\\n\\n cleanwords = [word for word in qwords if word.lower() not in REMOVE_WORDS]\\n temp = ' '.join(cleanwords)\\n\\n clean_question = \\\"\\\"\\n for letter in temp:\\n if letter != \\\"?\\\" or letter != \\\"\\\\\\\"\\\" or letter != \\\"\\\\'\\\":\\n clean_question = clean_question + letter\\n\\n return clean_question.lower(), neg\",\n \"def _postprocess_embeddings(self, prediction_dict, y_indices, x_indices):\\n embedding_predictions = prediction_dict[TRACK_REID][-1]\\n embeddings = predicted_embeddings_at_object_centers(\\n embedding_predictions, y_indices, x_indices)\\n embeddings, _ = tf.linalg.normalize(embeddings, axis=-1)\\n\\n return embeddings\",\n \"def reindex_metadata_tags(self):\\r\\n previous_position_values = None\\r\\n\\r\\n for position_index, position in enumerate(self.required_fields_index):\\r\\n if position_index > 0:\\r\\n position.reindex(previous_position_values)\\r\\n\\r\\n previous_position_values = position.current_values()\",\n \"def load_as_raw(self):\\n\\n # Q & A\\n questions, answers = self.get_questions_answers()\\n\\n # Get vocabs\\n\\n # Step 4: cleaning the questions\\n pprint('---- Step 4 cleaning questions ----')\\n\\n clean_questions = []\\n for question in questions:\\n clean_questions.append(clean_text(question))\\n\\n pprint(clean_questions, stream=Head(5))\\n print('\\\\n\\\\n')\\n \\\"\\\"\\\"\\n Step 5: Clean the answers\\n \\\"\\\"\\\"\\n\\n pprint('---- Step 5 cleaning answers ----')\\n clean_answers = []\\n for answer in answers:\\n clean_answers.append(clean_text(answer))\\n\\n pprint(clean_answers, stream=Head(5))\\n print('\\\\n\\\\n')\\n \\\"\\\"\\\"\\n Step 6: Creating a dictionary that maps each word to its number of occurences\\n \\\"\\\"\\\"\\n\\n word2count = {}\\n pprint('------ Step 6: counting words in questions ----')\\n\\n word2count = convert_word_to_count(word2count, clean_questions)\\n\\n pprint(word2count, stream=Head(5))\\n print('\\\\n\\\\n')\\n \\\"\\\"\\\"\\n Step 7:\\n For example, for a question: can we make this quick roxanne korrine and andrew barrett are having an incredibly horrendous public break up on the quad again\\n It counts each word occurence such as \\\"can\\\" and accumulates the count into word2count dict\\n \\\"\\\"\\\"\\n pprint('------ Step 6: counting words in answers ----')\\n\\n word2count = convert_word_to_count(word2count, clean_answers)\\n\\n pprint(word2count, stream=Head(5))\\n print('\\\\n\\\\n')\\n\\n keys = ['<unk>', '<s>', '</s>']\\n\\n \\\"\\\"\\\"\\n Step 8: Creating word 2 int(count) by filtering words that are greater than the threshold\\n \\\"\\\"\\\"\\n\\n pprint(\\n '------ Step 8: questions_vocabs filtered by threshold (>) ----')\\n threshold_questions = 20\\n questions_vocabs = [] + keys\\n for word, count in word2count.items():\\n if count >= threshold_questions:\\n if not word in questions_vocabs:\\n questions_vocabs.append(word)\\n\\n pprint(questions_vocabs, stream=Head(5))\\n print('\\\\n\\\\n')\\n \\\"\\\"\\\"\\n Step 9: Same as step 8 but for answers\\n \\\"\\\"\\\"\\n pprint(\\n '------ Step 9: answers_vocabs filtered by threshold (>) ----')\\n threshold_answers = 20\\n answers_vocabs = [] + keys\\n for word, count in word2count.items():\\n if count >= threshold_answers:\\n if not word in answers_vocabs:\\n answers_vocabs.append(word)\\n\\n pprint(answers_vocabs, stream=Head(5))\\n\\n return questions, answers, questions_vocabs, answers_vocabs\",\n \"def replace_waveforms(self, waveform_dict):\\n for waveform, value in waveform_dict.items():\\n\\n if waveform not in self.unresolved_placeholders:\\n self.hd.log.error(f\\\"Placeholder {waveform} not found in sequence.\\\")\\n\\n waveform_wrapped = f\\\"{self.marker_string}{waveform}{self.marker_string}\\\"\\n waveform_vector = 'vect(' + ','.join([str(x) for x in value]) + ')'\\n self.sequence = self.sequence.replace(f\\\"{waveform_wrapped}\\\", str(waveform_vector))\\n self.unresolved_placeholders.discard(waveform)\",\n \"def word_analogy(self):\\n data = open(\\\"data/word_analogy_subset.en.ar.txt\\\").read().split('\\\\n')\\n data = [x for x in data if len(x.split()) == 4]\\n cnt = 0\\n keys = list(self.embeddings_index.keys())\\n vectors = np.array(list(self.embeddings_index.values()))\\n norms = np.linalg.norm(vectors, axis=1)\\n for i in data:\\n i = self.preprocessor(i).split()\\n try:\\n v = self.embeddings_index[i[0]] - self.embeddings_index[i[1]] + self.embeddings_index[i[2]]\\n except:\\n continue\\n unit = v / np.linalg.norm(v)\\n dists = np.dot(vectors, unit) / norms\\n best = np.argpartition(-dists, 10)[:10 + 1]\\n best = best.take(np.argsort((-dists).take(best)))\\n result = [(keys[sim], float(dists[sim]))\\n for sim in best]\\n sbv = result[:10]\\n for j in sbv:\\n if j[0] == i[3]:\\n cnt += 1\\n return cnt/ len(data)\",\n \"def replace_errors(suggestion_num, sequence_switched, end_matches, offset_list):\\n if len(end_matches) != 0:\\n # Initialize Variables\\n new_list = initialize_suggestion_list(suggestion_num)\\n tokenizer, model = edf.initialize_tokenizer_variables()\\n\\n # Swapping masks with corrections section\\n if len(end_matches) > 1:\\n k = 0\\n j = 0\\n current = 0\\n keep_going = True\\n\\n while keep_going:\\n # Determine what section to locate mask token in\\n mask_str = section_decision(j, sequence_switched, offset_list, end_matches)\\n\\n new_list = replace_tokens(mask_str, sequence_switched, new_list, j, tokenizer, model, suggestion_num)\\n\\n # If end of sentence, return j to 0, else continue iterations\\n if j == (len(end_matches) - 1):\\n # Update variables\\n j = 0\\n current += 1\\n keep_going = False\\n\\n else:\\n j += 1\\n\\n k += 1\\n\\n else:\\n new_list = replace_tokens(sequence_switched, sequence_switched, new_list, 0, tokenizer, model,\\n suggestion_num)\\n\\n return new_list\\n\\n else:\\n return []\",\n \"def forward(self, aligned_feat):\\n n, t, c, h, w = aligned_feat.size()\\n # temporal attention\\n embedding_ref = self.temporal_attn1(\\n aligned_feat[:, self.center_frame_idx, :, :, :].clone())\\n emb = self.temporal_attn2(aligned_feat.view(-1, c, h, w))\\n emb = emb.view(n, t, -1, h, w) # (n, t, c, h, w)\\n\\n corr_l = [] # correlation list\\n for i in range(t):\\n emb_neighbor = emb[:, i, :, :, :]\\n corr = torch.sum(emb_neighbor * embedding_ref, 1) # (n, h, w)\\n corr_l.append(corr.unsqueeze(1)) # (n, 1, h, w)\\n corr_prob = torch.sigmoid(torch.cat(corr_l, dim=1)) # (n, t, h, w)\\n corr_prob = corr_prob.unsqueeze(2).expand(n, t, c, h, w)\\n corr_prob = corr_prob.contiguous().view(n, -1, h, w) # (n, t*c, h, w)\\n aligned_feat = aligned_feat.view(n, -1, h, w) * corr_prob\\n\\n # fusion\\n feat = self.feat_fusion(aligned_feat)\\n\\n # spatial attention\\n attn = self.spatial_attn1(aligned_feat)\\n attn_max = self.max_pool(attn)\\n attn_avg = self.avg_pool(attn)\\n attn = self.spatial_attn2(torch.cat([attn_max, attn_avg], dim=1))\\n # pyramid levels\\n attn_level = self.spatial_attn_l1(attn)\\n attn_max = self.max_pool(attn_level)\\n attn_avg = self.avg_pool(attn_level)\\n attn_level = self.spatial_attn_l2(\\n torch.cat([attn_max, attn_avg], dim=1))\\n attn_level = self.spatial_attn_l3(attn_level)\\n attn_level = self.upsample(attn_level)\\n\\n attn = self.spatial_attn3(attn) + attn_level\\n attn = self.spatial_attn4(attn)\\n attn = self.upsample(attn)\\n attn = self.spatial_attn5(attn)\\n attn_add = self.spatial_attn_add2(self.spatial_attn_add1(attn))\\n attn = torch.sigmoid(attn)\\n\\n # after initialization, * 2 makes (attn * 2) to be close to 1.\\n feat = feat * attn * 2 + attn_add\\n return feat\",\n \"def batchify_QA(batch):\\r\\n\\r\\n if type(batch[0][1]) != torch.LongTensor:\\r\\n no_elmo, use_char = (True, False) if batch[0][1] == -2 else (False, False)\\r\\n else:\\r\\n no_elmo, use_char = True, True\\r\\n\\r\\n docs = [ex[0] for ex in batch]\\r\\n docs_char = [ex[1] for ex in batch]\\r\\n ques = [ex[2] for ex in batch]\\r\\n questions_char = [ex[3] for ex in batch]\\r\\n answers = [ex[4] for ex in batch]\\r\\n\\r\\n # Batch documents\\r\\n max_doc_length = max([d.size(0) for d in docs])\\r\\n x1_len = torch.LongTensor(len(docs)).zero_()\\r\\n x1 = torch.LongTensor(len(docs),\\r\\n max_doc_length).zero_() if no_elmo else torch.LongTensor(len(docs),\\r\\n max_doc_length,\\r\\n 50).zero_()\\r\\n x1_char = torch.LongTensor(len(docs),\\r\\n max_doc_length,\\r\\n docs_char[0].size(1)).zero_() if (no_elmo and use_char) else None\\r\\n for i, d in enumerate(docs):\\r\\n x1_len[i] = d.size(0)\\r\\n x1[i, :d.size(0)].copy_(d)\\r\\n if not no_elmo:\\r\\n x1_char[i, :d.size(0), :].copy_(docs_char[i])\\r\\n\\r\\n # Batch questions\\r\\n max_ques_length = max([q.size(0) for q in ques])\\r\\n x2_len = torch.LongTensor(len(ques)).zero_()\\r\\n x2 = torch.LongTensor(len(ques), max_ques_length).zero_() if no_elmo else torch.LongTensor(len(ques),\\r\\n max_ques_length,\\r\\n 50).zero_()\\r\\n x2_char = torch.LongTensor(len(ques),\\r\\n max_ques_length,\\r\\n questions_char[0].size(1)).zero_() if (no_elmo and use_char) else None\\r\\n for i, q in enumerate(ques):\\r\\n x2_len[i] = q.size(0)\\r\\n x2[i, :q.size(0)].copy_(q)\\r\\n if not no_elmo:\\r\\n x2_char[i, :q.size(0), :].copy_(questions_char[i])\\r\\n\\r\\n # Batch answers\\r\\n max_ans_length = max([a.size(0) for a in answers])\\r\\n ans_len = torch.LongTensor(len(answers)).zero_()\\r\\n ans = torch.LongTensor(len(answers), max_ans_length).zero_()\\r\\n for i, a in enumerate(answers):\\r\\n ans_len[i] = a.size(0)\\r\\n ans[i, :a.size(0)].copy_(a)\\r\\n\\r\\n ids = [ex[5] for ex in batch]\\r\\n contexts = [ex[6] for ex in batch]\\r\\n # FIXME: multiple answers are possible, fix vectorize also.\\r\\n targets = [ex[8][0] for ex in batch]\\r\\n src_vocabs = [ex[9] for ex in batch]\\r\\n source_maps = []\\r\\n alignments = []\\r\\n\\r\\n # Prepare source vocabs, alignment [required for Copy Attention]\\r\\n for eid, context, target, (token2idx, idx2token) in \\\\\\r\\n zip(ids, contexts, targets, src_vocabs):\\r\\n # Mapping source tokens to indices in the dynamic dict.\\r\\n src_map = torch.LongTensor([token2idx[w] for w in context])\\r\\n source_maps.append(src_map)\\r\\n\\r\\n # TODO: does skipping the first and last token in answer valid?\\r\\n mask = torch.LongTensor([token2idx[w] if w in token2idx\\r\\n else UNK for w in target])\\r\\n alignments.append(mask)\\r\\n\\r\\n return {'doc_rep': x1,\\r\\n 'doc_char_rep': x1_char,\\r\\n 'doc_len': x1_len,\\r\\n 'que_rep': x2,\\r\\n 'que_char_rep': x2_char,\\r\\n 'que_len': x2_len,\\r\\n 'ans_rep': ans,\\r\\n 'ans_len': ans_len,\\r\\n 'ids': ids,\\r\\n 'documents': contexts,\\r\\n 'questions': [ex[7] for ex in batch],\\r\\n 'answers': targets,\\r\\n 'source_vocabs': src_vocabs,\\r\\n 'src_map': source_maps,\\r\\n 'alignment': alignments}\",\n \"def intent_of_text_LnDOR(ChapterTextS, TargetQuestionsD, TestS, StopWords):\\n \\n # Chapter Text - stokenize\\n StokensCT = stokenize(ChapterTextS, StopWords) \\n\\n # Test question - stokenize\\n StokensTest = stokenize(TestS, StopWords)\\n\\n # Knowledge Base Dict - stokenize\\n KBD_structure = stokenizeKBD(TargetQuestionsD, StopWords)\\n\\n # List (because list is mutable, set is not) of all stokens in document\\n StokensDoc = StokensCT[:] # from chapter text\\n StokensDoc.extend(StokensTest[:]) # += Test string\\n\\n # extend list of stokens in Doc\\n for i in TargetQuestionsD:\\n StokensDoc.extend(TargetQuestionsD[i][\\\"mq stokens\\\"][:]) # += KB target [matched Q]s\\n StokensDoc.extend(TargetQuestionsD[i][\\\"ans stokens\\\"][:]) # += KB answers\\n \\n StokensTestV = set(StokensTest)\\n StokensDocV = set(StokensDoc)\\n StokensAntiTgtV = StokensDocV\\n \\n # Complement of all targets\\n for i in TargetQuestionsD:\\n StokensAntiTgtV = StokensAntiTgtV.difference(set(TargetQuestionsD[i][\\\"mq stokens\\\"]))\\n \\n # calculate confusion matrix and DOR etc.\\n LnDORD = {}\\n # Anti Target\\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensAntiTgtV, StokensTestV) \\n LnDOR = lndor(TP, FP, FN, TN) \\n someAngle = angleDOR(TP, FP, FN, TN) \\n \\n LnDORD[\\\"AntiTgt\\\"] = {'lndor': LnDOR, 'theta': someAngle}\\n\\n # total occurences\\n total_occ = 0\\n for i in TargetQuestionsD:\\n total_occ += TargetQuestionsD[i]['count']\\n\\n for i in TargetQuestionsD:\\n StokensTgtV = set(TargetQuestionsD[i][\\\"mq stokens\\\"][:])\\n\\n TP, FP, FN, TN = confusion_matrix(StokensDocV, StokensTgtV, StokensTestV) \\n priorOR = TargetQuestionsD[i]['count'] / total_occ\\n\\n LnDOR = lndor(TP, FP, FN, TN) \\n someAngle = angleDOR(TP, FP, FN, TN, priorOR) \\n \\n LnDORD[i] = {'lndor': LnDOR, 'theta': someAngle}\\n # LnDORD = {i: {'lndor': , 'theta': }}, KB indices + \\\"AntiTgt\\\"\\n\\n return LnDORD\",\n \"def qualify_words():\\n config = get_config()\\n\\n all_feature_matrices = []\\n all_opinion_matrices = []\\n\\n # first 5 parts are labeled, thus are useful\\n all_feature_label_vectors = []\\n all_opinion_label_vectors = []\\n\\n for fname in config.file_names:\\n feature_X, feature_dims = load_feature_matrices(fname)\\n opinion_X, opinion_dims = load_opinion_matrices(fname)\\n feature_y = load_feature_labels(fname)\\n opinion_y = load_opinion_labels(fname)\\n\\n # append to all collector\\n all_feature_matrices.append(feature_X)\\n all_feature_label_vectors.append(feature_y)\\n all_opinion_matrices.append(opinion_X)\\n all_opinion_label_vectors.append(opinion_y)\\n # use first 5 for training\\n # stack first 5\\n feature_training_X = []\\n feature_training_y = []\\n opinion_training_X = []\\n opinion_training_y = []\\n for i in range(5):\\n feature_training_X.append(all_feature_matrices[i])\\n feature_training_y.append(all_feature_label_vectors[i])\\n opinion_training_X.append(all_opinion_matrices[i])\\n opinion_training_y.append(all_opinion_label_vectors[i])\\n\\n feature_training_X = np.hstack(feature_training_X)\\n feature_training_y = np.hstack(feature_training_y)\\n opinion_training_X = np.hstack(opinion_training_X)\\n opinion_training_y = np.hstack(opinion_training_y)\\n\\n # using combination of rule and ranking score as features\\n feature_model = MultinomialNB()\\n opinion_model = MultinomialNB()\\n\\n # training\\n feature_model.fit(np.transpose(feature_training_X), feature_training_y.ravel())\\n opinion_model.fit(np.transpose(opinion_training_X), opinion_training_y.ravel())\\n\\n # predicting on candidate aspects and opinions, extracted from amazon reviews\\n for i in range(5, len(config.file_names)):\\n fname = config.file_names[i]\\n feature_pred = feature_model.predict_proba(\\n np.transpose(all_feature_matrices[i]))[:,1]\\n opinion_pred = opinion_model.predict_proba(\\n np.transpose(all_opinion_matrices[i]))[:,1]\\n # pickle the prediction results\\n with open('../results/' + fname + '_feature_pred_score.pickle', 'wb') as f:\\n pickle.dump(feature_pred, f)\\n with open('../results/' + fname + '_opinion_pred_score.pickle', 'wb') as f:\\n pickle.dump(opinion_pred, f)\",\n \"def compute_query_repr(annots_df, qaid, invindex, aggregate=False, alpha=3, thresh=0):\\n if utool.VERBOSE:\\n print('[smk_index] Query Repr qaid=%r' % (qaid,))\\n wx2_idf = invindex.wx2_idf\\n words = invindex.words\\n wordflann = invindex.wordflann\\n if WITH_PANDAS:\\n qfx2_vec = annots_df['vecs'][qaid]\\n else:\\n qfx2_vec = pdh.ensure_values(annots_df['vecs'][qaid])\\n # Assign query to words\\n wx2_qfxs1, wx2_weights, qfx2_wxs = assign_to_words_(\\n wordflann, words, qfx2_vec, idx_name='fx', dense=False) # 71.9 %\\n # Hack to make implementing asmk easier, very redundant\\n #qfx2_aid = pdh.IntSeries([qaid] * len(qfx2_wx), index=qfx2_wx.index, name='qfx2_aid')\\n #qfx2_aid = pdh.IntSeries([qaid] * len(qfx2_wx), name='qfx2_aid')\\n qfx2_aid = np.array([qaid] * len(qfx2_wxs), dtype=INTEGER_TYPE)\\n if WITH_PANDAS:\\n qfx2_qfx = qfx2_vec.index\\n else:\\n qfx2_qfx = np.arange(len(qfx2_vec))\\n # Compute query residuals\\n wx2_qrvecs, wx2_qaids, wx2_qfxs = compute_residuals_(\\n words, wx2_qfxs1, qfx2_vec, qfx2_aid, qfx2_qfx, aggregate) # 24.8\\n # Compute query gamma\\n if utool.VERBOSE:\\n print('[smk_index] Query Gamma alpha=%r, thresh=%r' % (alpha, thresh))\\n wx_sublist = pdh.ensure_index(wx2_qrvecs).astype(np.int32)\\n idf_list = pdh.ensure_values_subset(wx2_idf, wx_sublist)\\n rvecs_list = pdh.ensure_values_subset(wx2_qrvecs, wx_sublist)\\n query_gamma = smk_core.gamma_summation2(rvecs_list, idf_list, alpha, thresh)\\n assert query_gamma > 0, 'query gamma is not positive!'\\n return wx2_qrvecs, wx2_qaids, wx2_qfxs, query_gamma\",\n \"def encode_samples(tokenized_samples, word_to_idx):\\n features = []\\n for sample in tokenized_samples:\\n feature = []\\n for token in sample:\\n if token in word_to_idx:\\n feature.append(word_to_idx[token])\\n else:\\n feature.append(0)\\n features.append(feature)\\n return features\",\n \"def match(self, passage_encodes, question_encodes, p_length, q_length):\\n with tf.variable_scope('bidaf'):\\n sim_matrix = tf.matmul(\\n passage_encodes, question_encodes, transpose_b=True)\\n context2question_attn = tf.matmul(\\n tf.nn.softmax(sim_matrix, -1), question_encodes)\\n b = tf.nn.softmax(tf.expand_dims(\\n tf.reduce_max(sim_matrix, 2), 1), -1)\\n question2context_attn = tf.tile(tf.matmul(b, passage_encodes),\\n [1, tf.shape(passage_encodes)[1], 1])\\n concat_outputs = tf.concat([passage_encodes, context2question_attn,\\n passage_encodes * context2question_attn,\\n passage_encodes * question2context_attn], -1)\\n return concat_outputs, None\",\n \"def replace_token_with_index(self, tokenized_tweet, max_length_dictionary):\\n\\n # should be replacing each token in a list of tokens by their corresponding index\\n # Source: https://github.com/stanfordnlp/GloVe\\n # Source: https://towardsdatascience.com/word-embeddings-for-sentiment-analysis-65f42ea5d26e\\n\\n if self.mode == \\\"zip\\\":\\n for idx, word in enumerate(tokenized_tweet):\\n if word not in self.corpus:\\n tokenized_tweet[idx] = \\\"<unknown>\\\"\\n else:\\n for idx, word in enumerate(tokenized_tweet):\\n if word not in self.corpus:\\n tokenized_tweet[idx] = \\\"<unk>\\\"\\n return [self.corpus.index(x) for x in tokenized_tweet]\",\n \"def fix_annotmatch_pzmaster1():\\n import wbia\\n\\n ibs = wbia.opendb('PZ_Master1')\\n infr = wbia.AnnotInference(ibs=ibs, aids=ibs.get_valid_aids(), verbose=5)\\n infr.initialize_graph()\\n annots = ibs.annots()\\n aid_to_nid = ut.dzip(annots.aids, annots.nids)\\n\\n if False:\\n infr.reset_feedback()\\n infr.ensure_mst()\\n infr.apply_feedback_edges()\\n infr.relabel_using_reviews()\\n infr.start_qt_interface()\\n\\n # Get annotmatch rowids that agree with current labeling\\n if False:\\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\\n import pandas as pd\\n\\n flags1 = pd.isnull(annotmatch['annotmatch_evidence_decision'])\\n flags2 = annotmatch['annotmatch_tag_text'] == ''\\n bad_part = annotmatch[flags1 & flags2]\\n rowids = bad_part.index.tolist()\\n ibs.delete_annotmatch(rowids)\\n\\n if False:\\n # Delete bidirectional annotmatches\\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\\n df = annotmatch.set_index(['annot_rowid1', 'annot_rowid2'])\\n\\n # Find entires that have both directions\\n pairs1 = annotmatch[['annot_rowid1', 'annot_rowid2']].values\\n f_edges = {tuple(p) for p in pairs1}\\n b_edges = {tuple(p[::-1]) for p in pairs1}\\n isect_edges = {tuple(sorted(p)) for p in b_edges.intersection(f_edges)}\\n isect_edges1 = list(isect_edges)\\n isect_edges2 = [p[::-1] for p in isect_edges]\\n\\n # cols = ['annotmatch_evidence_decision', 'annotmatch_tag_text']\\n import pandas as pd\\n\\n custom_ = {\\n (559, 4909): (False, ['photobomb']),\\n (7918, 8041): (False, ['photobomb']),\\n (6634, 6754): (False, ['photobomb']),\\n (3707, 3727): (False, ['photobomb']),\\n (86, 103): (False, ['photobomb']),\\n }\\n extra_ = {}\\n\\n fixme_edges = []\\n\\n d1 = df.loc[isect_edges1].reset_index(drop=False)\\n d2 = df.loc[isect_edges2].reset_index(drop=False)\\n flags = d1['annotmatch_evidence_decision'] != d2['annotmatch_evidence_decision']\\n from wbia.tag_funcs import _parse_tags\\n\\n for f, r1, r2 in zip(flags, d1.iterrows(), d2.iterrows()):\\n v1, v2 = r1[1], r2[1]\\n aid1 = v1['annot_rowid1']\\n aid2 = v1['annot_rowid2']\\n truth_real = (\\n ibs.const.EVIDENCE_DECISION.POSITIVE\\n if aid_to_nid[aid1] == aid_to_nid[aid2]\\n else ibs.const.EVIDENCE_DECISION.NEGATIVE\\n )\\n truth1 = v1['annotmatch_evidence_decision']\\n truth2 = v2['annotmatch_evidence_decision']\\n t1 = _parse_tags(v1['annotmatch_tag_text'])\\n t2 = _parse_tags(v2['annotmatch_tag_text'])\\n newtag = ut.union_ordered(t1, t2)\\n if (aid1, aid2) in custom_:\\n continue\\n fixme_flag = False\\n if not pd.isnull(truth1):\\n if truth_real != truth1:\\n fixme_flag = True\\n if not pd.isnull(truth2):\\n if truth_real != truth2:\\n fixme_flag = True\\n if fixme_flag:\\n logger.info('newtag = {!r}'.format(newtag))\\n logger.info('truth_real = {!r}'.format(truth_real))\\n logger.info('truth1 = {!r}'.format(truth1))\\n logger.info('truth2 = {!r}'.format(truth2))\\n logger.info('aid1 = {!r}'.format(aid1))\\n logger.info('aid2 = {!r}'.format(aid2))\\n fixme_edges.append((aid1, aid2))\\n else:\\n extra_[(aid1, aid2)] = (truth_real, newtag)\\n\\n extra_.update(custom_)\\n new_pairs = extra_.keys()\\n new_truths = ut.take_column(ut.dict_take(extra_, new_pairs), 0)\\n new_tags = ut.take_column(ut.dict_take(extra_, new_pairs), 1)\\n new_tag_texts = [';'.join(t) for t in new_tags]\\n aids1, aids2 = ut.listT(new_pairs)\\n\\n # Delete the old\\n ibs.delete_annotmatch(\\n d1['annotmatch_rowid'].values.tolist()\\n + d2['annotmatch_rowid'].values.tolist()\\n )\\n\\n # Add the new\\n ams = ibs.add_annotmatch_undirected(aids1, aids2)\\n ibs.set_annotmatch_evidence_decision(ams, new_truths)\\n ibs.set_annotmatch_tag_text(ams, new_tag_texts)\\n\\n if False:\\n import wbia.guitool as gt\\n\\n gt.ensure_qapp()\\n ut.qtensure()\\n from wbia.gui import inspect_gui\\n\\n inspect_gui.show_vsone_tuner(ibs, aid1, aid2)\\n\\n # pairs2 = pairs1.T[::-1].T\\n # idx1, idx2 = ut.isect_indices(list(map(tuple, pairs1)),\\n # list(map(tuple, pairs2)))\\n # r_edges = list(set(map(tuple, map(sorted, pairs1[idx1]))))\\n # unique_pairs = list(set(map(tuple, map(sorted, pairs1[idx1]))))\\n # df = annotmatch.set_index(['annot_rowid1', 'annot_rowid2'])\\n\\n x = ut.ddict(list)\\n annotmatch = ibs.db.get_table_as_pandas('annotmatch')\\n import ubelt as ub\\n\\n _iter = annotmatch.iterrows()\\n prog = ub.ProgIter(_iter, length=len(annotmatch))\\n for k, m in prog:\\n aid1 = m['annot_rowid1']\\n aid2 = m['annot_rowid2']\\n if m['annotmatch_evidence_decision'] == ibs.const.EVIDENCE_DECISION.POSITIVE:\\n if aid_to_nid[aid1] == aid_to_nid[aid2]:\\n x['agree1'].append(k)\\n else:\\n x['disagree1'].append(k)\\n elif m['annotmatch_evidence_decision'] == ibs.const.EVIDENCE_DECISION.NEGATIVE:\\n if aid_to_nid[aid1] == aid_to_nid[aid2]:\\n x['disagree2'].append(k)\\n else:\\n x['agree2'].append(k)\\n\\n ub.map_vals(len, x)\\n ut.dict_hist(annotmatch.loc[x['disagree1']]['annotmatch_tag_text'])\\n\\n disagree1 = annotmatch.loc[x['disagree1']]\\n pb_disagree1 = disagree1[disagree1['annotmatch_tag_text'] == 'photobomb']\\n aids1 = pb_disagree1['annot_rowid1'].values.tolist()\\n aids2 = pb_disagree1['annot_rowid2'].values.tolist()\\n aid_pairs = list(zip(aids1, aids2))\\n infr = wbia.AnnotInference.from_pairs(aid_pairs, ibs=ibs, verbose=5)\\n if False:\\n feedback = infr.read_wbia_annotmatch_feedback(edges=infr.edges())\\n infr.external_feedback = feedback\\n infr.apply_feedback_edges()\\n infr.start_qt_interface(loop=False)\\n\\n # Delete these values\\n if False:\\n nonpb_disagree1 = disagree1[disagree1['annotmatch_tag_text'] != 'photobomb']\\n disagree2 = annotmatch.loc[x['disagree2']]\\n ibs.delete_annotmatch(nonpb_disagree1['annotmatch_rowid'])\\n ibs.delete_annotmatch(disagree2['annotmatch_rowid'])\\n\\n # ut.dict_hist(disagree1['annotmatch_tag_text'])\\n import networkx as nx\\n\\n graph = nx.Graph()\\n graph.add_edges_from(zip(pb_disagree1['annot_rowid1'], pb_disagree1['annot_rowid2']))\\n list(nx.connected_components(graph))\\n\\n set(annotmatch.loc[x['disagree2']]['annotmatch_tag_text'])\\n\\n # aid1, aid2 = 2585, 1875\\n # # pd.unique(annotmatch['annotmatch_evidence_decision'])\\n # from wbia.gui import inspect_gui\\n # inspect_gui.show_vsone_tuner(ibs, aid1, aid2)\\n # from vtool import inspect_matches\\n\\n # aid1, aid2 = 2108, 2040\\n\\n # pd.unique(annotmatch['annotmatch_tag_text'])\\n\\n # infr.reset_feedback()\\n # infr.relabel_using_reviews()\",\n \"def compute(db, detected_chords_by_song):\\n detected = {}\\n ground = {}\\n detected_chords = []\\n ground_chords = []\\n\\n for s in detected_chords_by_song:\\n detected[s['title']] = s['detected_chords']\\n\\n for s in db:\\n ground[s['title']] = s['chord_vector']\\n\\n for k, v in ground.items():\\n if k in detected:\\n if len(v) == len(detected[k]):\\n detected_chords.extend(detected[k])\\n ground_chords.extend(v)\\n\\n # ignore chors represented with dash given that are not suppoted by the algorithm\\n ground = []\\n detected = []\\n i = 0\\n while i < len(ground_chords): \\n if '-' != ground_chords[i]:\\n ground.append(ground_chords[i])\\n detected.append(detected_chords[i])\\n i += 1\\n\\n fig, ax = plt.subplots()\\n tick_marks = np.arange(len(EXISTING_NOTES))\\n plt.xticks(tick_marks, EXISTING_NOTES, rotation=45)\\n plt.yticks(tick_marks, EXISTING_NOTES)\\n\\n matrix = confusion_matrix(ground, detected, labels=EXISTING_NOTES)\\n thresh = 500\\n\\n for i, j in itertools.product(range(matrix.shape[0]), range(matrix.shape[1])):\\n plt.text(j, i, matrix[i, j],\\n horizontalalignment=\\\"center\\\",\\n size=5,\\n color=\\\"black\\\" if matrix[i, j] > thresh else \\\"white\\\")\\n plt.ylabel('True chords')\\n plt.xlabel('Predicted chords')\\n plt.tight_layout()\\n\\n fname = (\\n os.path.join(\\n settings.IMG_DIR,\\n 'initial_diagnose', 'total_accuracy_confusion_matrix.png'))\\n\\n plt.imshow(matrix, interpolation='nearest')\\n plt.colorbar()\\n plt.savefig(fname)\",\n \"def build_dataset(token_seq, token_seq_index, term_to_index, char_to_index, max_token_length=15, leading_context_size=10, trailing_context_size=10, leading_separator='{', trailing_separator='}', n_examples_per_context=10, n_errors_per_token=[1], n_errors_per_context=[0], dictionary=enchant.Dict('en_US'), seed=17):\\n if isinstance(seed, RandomState):\\n rng = seed\\n else:\\n rng = RandomState(seed=seed)\\n\\n n_contexts = sum([len(token_seq_index[t]) for t in token_seq_index.keys() if len(t) <= max_token_length])\\n n_examples = n_examples_per_context * n_contexts\\n max_inserts_per_token = max(n_errors_per_token)\\n max_inserts_per_context = 2*max(n_errors_per_context)\\n max_chars_in_window = leading_context_size + max_token_length + trailing_context_size + len(leading_separator) + len(trailing_separator) + max_inserts_per_token + max_inserts_per_context\\n\\n error_examples = np.zeros((n_examples, max_chars_in_window), dtype=np.int32)\\n error_examples.fill(char_to_index[' '])\\n\\n leading_contexts = np.zeros((n_examples, leading_context_size + max_inserts_per_context))\\n leading_contexts.fill(char_to_index[' '])\\n spelling_errors = np.zeros((n_examples, max_token_length + max_inserts_per_token))\\n spelling_errors.fill(char_to_index[' '])\\n trailing_contexts = np.zeros((n_examples, trailing_context_size + max_inserts_per_context))\\n trailing_contexts.fill(char_to_index[' '])\\n\\n correct_tokens = []\\n corrupt_tokens = []\\n corrections = np.zeros(n_examples, dtype=np.int32)\\n error_types = []\\n context_ids = []\\n example_ids = []\\n term_lens = []\\n edit_distance_to_nearest_term = []\\n nearest_term = []\\n\\n print('starting to construct {n_examples} examples'.format(\\n n_examples=n_examples))\\n\\n pbar = progressbar.ProgressBar(term_width=40,\\n widgets=[' ', progressbar.Percentage(),\\n ' ', progressbar.ETA()],\\n maxval=n_examples).start()\\n n = 0\\n\\n index_to_char = dict((i,c) for c,i in char_to_index.iteritems())\\n if 63 not in index_to_char.keys():\\n # A workaround for now. Delete ASAP.\\n index_to_char[63] = '^'\\n\\n def add_chars_to_array(n, array, chars, default_char=' '):\\n for k, ch in enumerate(chars):\\n try:\\n array[n, k] = char_to_index[ch]\\n except KeyError, e:\\n array[n, k] = char_to_index[default_char]\\n\\n for token in token_seq_index.keys():\\n if len(token) > max_token_length:\\n continue\\n\\n term_len = len(token)\\n distances = min_dictionary_edit_distance([token], dictionary)\\n distance = distances[token]['distance']\\n term = distances[token]['accepted']\\n\\n for i in token_seq_index[token]:\\n for j in six.moves.range(n_examples_per_context):\\n pbar.update(n+1)\\n corruptor = rng.choice([insert_characters, delete_characters,\\n replace_characters, transpose_characters])\\n n_token_errors = rng.choice(n_errors_per_token)\\n corrupt_token = corruptor(token, index_to_char, n=n_token_errors, seed=rng)\\n\\n n_context_errors = rng.choice(n_errors_per_context)\\n leading = leading_context(token_seq, i, leading_context_size)\\n leading = corruptor(leading, index_to_char, n=n_context_errors, seed=rng)\\n trailing = trailing_context(token_seq, i, trailing_context_size)\\n trailing = corruptor(trailing, index_to_char, n=n_context_errors, seed=rng)\\n\\n window = ''.join([leading, leading_separator,\\n corrupt_token, trailing_separator, trailing])\\n\\n add_chars_to_array(n, error_examples, window)\\n add_chars_to_array(n, leading_contexts, leading)\\n add_chars_to_array(n, spelling_errors, corrupt_token)\\n add_chars_to_array(n, trailing_contexts, trailing)\\n\\n correct_tokens.append(token)\\n corrections[n] = term_to_index[token]\\n corrupt_tokens.append(corrupt_token)\\n error_types.append(corruptor.__name__)\\n context_ids.append(i)\\n example_ids.append(n)\\n edit_distance_to_nearest_term.append(distance)\\n nearest_term.append(term)\\n term_lens.append(term_len)\\n\\n n += 1\\n\\n pbar.finish()\\n\\n df = pd.DataFrame({\\n 'correction': corrections,\\n 'error_type': error_types,\\n 'context_id': context_ids,\\n 'example_id': example_ids,\\n 'edit_distance_to_nearest_term': edit_distance_to_nearest_term,\\n 'nearest': nearest_term,\\n 'term_length': term_lens,\\n 'correct_token': correct_tokens,\\n 'corrupt_token': corrupt_tokens\\n })\\n\\n def add_columns(df, array, colname_prefix):\\n colwidth = int(np.log10(array.shape[1]))+1\\n colfmt = colname_prefix + '{col:0' + str(colwidth) + 'd}'\\n for col in np.arange(array.shape[1]):\\n colname = colfmt.format(col=col)\\n df[colname] = array[:, col]\\n\\n add_columns(df, error_examples, 'full_error')\\n add_columns(df, leading_contexts, 'leading_context')\\n add_columns(df, spelling_errors, 'spelling_error')\\n add_columns(df, trailing_contexts, 'trailing_context')\\n\\n return df\",\n \"async def respond(self, ctx, index, *, response):\\n try:\\n config = self.bot.db['questions'][str(ctx.guild.id)][str(ctx.channel.id)]\\n except KeyError:\\n return\\n if not response:\\n await hf.safe_send(ctx, \\\"You need to type something for your response.\\\")\\n return\\n if len(response.split()) == 1:\\n try:\\n msg = await ctx.channel.fetch_message(int(response))\\n await ctx.message.add_reaction('⤴')\\n ctx.message = msg\\n ctx.author = msg.author\\n response = msg.content\\n except (discord.NotFound, ValueError):\\n pass\\n if index not in config['questions']:\\n await hf.safe_send(ctx, \\\"Invalid question index. Make sure you're typing this command in the channel \\\"\\n \\\"the question was originally made in.\\\")\\n return\\n\\n try:\\n log_channel = ctx.guild.get_channel(config['log_channel'])\\n except discord.NotFound:\\n await hf.safe_send(ctx, \\\"The original log channel can't be found (type `;q setup`)\\\")\\n return\\n try:\\n log_message = await log_channel.fetch_message(config['questions'][index]['log_message'])\\n except discord.NotFound:\\n await hf.safe_send(ctx, \\\"The original question log message could not be found. Type `;q a <index>` to \\\"\\n \\\"close the question and clear it.\\\")\\n return\\n\\n emb: discord.Embed = log_message.embeds[0]\\n value_text = f\\\"\\\\n[Jump URL]({ctx.message.jump_url})\\\"\\n emb.add_field(name=f\\\"Response by {ctx.author.name}#{ctx.author.discriminator}\\\",\\n value=value_text.replace('', response[:1024-len(value_text)]))\\n await log_message.edit(embed=emb)\\n config['questions'][index].setdefault('responses', []).append(ctx.message.jump_url)\\n await self._delete_log(ctx)\\n await self._post_log(ctx)\\n await ctx.message.add_reaction('✅')\",\n \"def get_embeddings_from_raw_image(recognizer, frame):\\n # detect faces, original frame and face boxes\\n a, boxes = detector.find_face(frame, recognizer.ort_session, recognizer.input_name)\\n\\n\\n # align facesq\\n aligned_faces = []\\n boxes[boxes < 0] = 0\\n for i in range(boxes.shape[0]):\\n box = boxes[i, :]\\n f = np.copy(frame)\\n y = align_face(recognizer, f, box)\\n aligned_faces.append(y)\\n\\n embs = []\\n for i in range(boxes.shape[0]):\\n aligned_face = aligned_faces[i]\\n embs.append(face_embedding(recognizer, aligned_face))\\n\\n return embs\",\n \"def forward(self, input_features, review_qid):\\n\\n # items that are not padded\\n src_mask = (input_features[\\\"qid\\\"] != 0).unsqueeze(-2)\\n\\n encoder_output = self.encoder(\\n self.src_embed(input_features),\\n src_mask,\\n )\\n review_embedding = self.embedding_by_feature[\\\"qid\\\"](review_qid)\\n\\n output = self.review_generator(encoder_output, src_mask, review_embedding)\\n\\n return output\",\n \"def replace_tokens(self, tokens):\\n details = []\\n idx = 0\\n if len(tokens) >= min_token_num:\\n for i in range(len(tokens)):\\n old_token = tokens[i]\\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\\n tokens[i] = self.get_insert_token(tokens[i])\\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\\n idx += len(tokens[i])\\n return tokens, details\",\n \"def fix_answer_values(answers):\\n answers_fixed = answers.copy()\\n answers_fixed = np.where(answers_fixed==1, 3, answers_fixed) # move \\\"no\\\" away temporarily\\n answers_fixed = np.where(answers_fixed==2, 1, answers_fixed) # set \\\"no opinion\\\" value to 1\\n answers_fixed = np.where(answers_fixed==3, 2, answers_fixed) # set temporary value 3 (meaning \\\"no\\\") to 2\\n return answers_fixed\",\n \"def find_corresponding_question(chat, tagged_user, prev_mod_index, index, q, unique_users):\\n\\n # searches from the previous message sent by the moderator\\n for i in range(index, prev_mod_index[1], -1):\\n message = chat[i]\\n if message['user'] == tagged_user:\\n question = is_question(message, unique_users, q)\\n if question != None:\\n return question\\n \\n # expanding the search space ft. some additional checks\\n for i in range(prev_mod_index[1], prev_mod_index[0], -1):\\n message = chat[i]\\n \\n if message['user'] == tagged_user:\\n question = find_question_expanded(message, unique_users, q)\\n \\n if question != None:\\n return question\\n\\n return None\",\n \"def tag_conjunction_entities(annotated_pages):\\n for page_id in annotated_pages:\\n page = Page.objects(id=page_id).first()\\n #page = db_conn.pages.find_one({\\\"_id\\\":page_id}) # TODO: refactor\\n annotation_ids = [p.id for p in page[\\\"annotations_ids\\\"]]\\n all_annotations = list(Annotation.objects(id__in=annotation_ids))\\n # retrieve meta-annotations from that page\\n meta_annotations = list(Annotation.objects(id__in=annotation_ids, entity_type=\\\"meta-annotation\\\"))\\n #all_annotations = list(db_conn.annotations.find({\\\"_id\\\":{\\\"$in\\\":annotation_ids}})) # TODO: refactor\\n #meta_annotations = list(db_conn.annotations.find({\\\"_id\\\":{\\\"$in\\\":annotation_ids} # TODO: refactor\\n # ,\\\"entity_type\\\":\\\"meta-annotation\\\"}))\\n if(len(meta_annotations)>0):\\n logger.debug(\\\"Meta-annotations: %s\\\"%meta_annotations)\\n for meta_annotation in meta_annotations:\\n logger.info(\\\"Processing meta-annotation %s\\\"%meta_annotation[\\\"id\\\"])\\n line_span = sorted(list(set([(position[\\\"page_id\\\"], position[\\\"line_n\\\"]) \\n for position in meta_annotation[\\\"positions\\\"]])))\\n top_entities_ids = [ann.id for ann in meta_annotation[\\\"top_entities\\\"]]\\n top_entities = list(Annotation.objects(id__in=top_entities_ids))\\n #top_entities = [db_conn.annotations.find_one({\\\"_id\\\":top_annotation_id}) \\n # for top_annotation_id in meta_annotation[\\\"top_entities\\\"]]\\n tokens = []\\n for page_obj, line_n in line_span:\\n page = Page.objects(id=page_obj.id).first()\\n #page = db_conn.pages.find_one({\\\"_id\\\":page_id})\\n for line in page[\\\"lines\\\"]:\\n if line[\\\"line_number\\\"]==line_n:\\n tokens.append((page_obj,line_n,line[\\\"tokens\\\"]))\\n try:\\n for entity in top_entities:\\n assert entity is not None\\n true_conjunctions = []\\n meta_annotation_start = (top_entities[0][\\\"positions\\\"][0][\\\"page_id\\\"]\\n ,top_entities[0][\\\"positions\\\"][0][\\\"line_n\\\"]\\n ,top_entities[0][\\\"positions\\\"][0][\\\"start\\\"])\\n meta_annotation_end = (top_entities[-1][\\\"positions\\\"][-1][\\\"page_id\\\"]\\n ,top_entities[-1][\\\"positions\\\"][-1][\\\"line_n\\\"]\\n ,top_entities[-1][\\\"positions\\\"][-1][\\\"end\\\"])\\n conjunctions = [(token,page,line) for page,line,toks in tokens for token in toks\\n if(token[\\\"offset_start\\\"] >= meta_annotation_start[2] and token[\\\"offset_end\\\"] <= meta_annotation_end[2])]\\n true_conjunctions += [(page,line,token) for token,page,line in conjunctions \\n if not is_annotated(page,line,token,all_annotations)]\\n if(len(true_conjunctions)>0):\\n logger.debug(\\\"Conjunctions found: %s\\\"%true_conjunctions)\\n conjunction_annotations = []\\n all_ann_ids = [annotation[\\\"ann_id\\\"] for annotation in all_annotations \\n if '+' not in annotation[\\\"ann_id\\\"] ]\\n identifier_counter = int(sorted(all_ann_ids, key=lambda x: int(x.replace('T','')))[-1].replace(\\\"T\\\",\\\"\\\"))\\n logger.debug(sorted(all_ann_ids, key=lambda x: int(x.replace('T','')))[-1])\\n for page_obj, line_n, token in true_conjunctions:\\n identifier_counter += 1\\n conjunction_annotation = Annotation(entity_type=\\\"conjunction\\\"\\n , ingestion_timestamp=datetime.utcnow()\\n , annotation_ingester_version=__version__\\n , pageid=meta_annotation.pageid\\n , filename=meta_annotation.filename\\n , bid=meta_annotation.bid)\\n conjunction_annotation.surface = token[\\\"surface\\\"]\\n conjunction_annotation.ann_id = \\\"T%i\\\"%identifier_counter\\n conjunction_annotation.positions.append(PagePosition(page_id = page_obj\\n , start = token[\\\"offset_start\\\"]\\n , end = token[\\\"offset_end\\\"]\\n , line_n = line_n))\\n conjunction_annotation.save()\\n conjunction_annotations.append(conjunction_annotation)\\n logger.info(\\\"(Page: %s) %i conjunction annotations were created and stored in MongoDB\\\"%(page_obj.id\\n , len(conjunction_annotations)))\\n logger.debug(\\\"N %i of top entities before adding conjunction entities\\\"%len(meta_annotation[\\\"top_entities\\\"]))\\n meta_annotation[\\\"top_entities\\\"] += conjunction_annotations\\n logger.debug(\\\"N %i of top entities after adding conjunction entities\\\"%len(meta_annotation[\\\"top_entities\\\"]))\\n Annotation.objects(id=meta_annotation.id).update_one(set__top_entities = meta_annotation[\\\"top_entities\\\"])\\n for conj_annotation in conjunction_annotations:\\n for position in conj_annotation[\\\"positions\\\"]:\\n page = Page.objects(id=position.page_id.id).first()\\n page[\\\"annotations_ids\\\"].append(conj_annotation)\\n page.save()\\n except AssertionError as e:\\n #raise e\\n logger.warning(\\\"The meta-annotation %s has no top-level entities and generated the following error: %s\\\"%(meta_annotation[\\\"_id\\\"],e))\\n except Exception as e:\\n raise e\",\n \"def make_correction_matrix(isotracer, formuladict, na_dict, indist_elems, autodetect, corr_limit):\\n lookup_dict = {'O':['O16','O17','O18'], 'S':['S32','S33','S34'], 'Si':['Si28','Si29','Si30']}\\n trac_atom = get_isotope_element(isotracer)\\n if (isotracer == 'O18' or isotracer == 'S34' or isotracer == 'Si30'):\\n \\tM = make_expected_na_matrix_heavy(formuladict.get(trac_atom, 0), na_dict[trac_atom])\\n else:\\n \\tM = make_expected_na_matrix(formuladict.get(trac_atom, 0), na_dict[trac_atom])\\n M_indist = []\\n\\n indist_elems_copy = copy(indist_elems)\\n na_dict_copy = copy(na_dict)\\n for e in indist_elems:\\n if e in indist_elems_copy:\\n e2 = get_isotope_element(e)\\n if e2 in formuladict:\\n try:\\n if(lookup_dict[e2][1] in indist_elems_copy) and (lookup_dict[e2][2] in indist_elems_copy):\\n corr_limit_1 = int(corr_limit[lookup_dict[e2][1]])\\n corr_limit_2 = int(corr_limit[lookup_dict[e2][2]])\\n M_indist.append(add_indistinguishable_element_for_autodetect_heavy(M, formuladict[e2], na_dict_copy[e2], corr_limit_1, corr_limit_2))\\n indist_elems_copy.remove(lookup_dict[e2][1])\\n indist_elems_copy.remove(lookup_dict[e2][2])\\n\\n elif ((lookup_dict[e2][1] in indist_elems_copy) and (lookup_dict[e2][2] not in indist_elems_copy)) or \\\\\\n ((lookup_dict[e2][1] not in indist_elems_copy) and (lookup_dict[e2][2] in indist_elems_copy)):\\n pos = lookup_dict[e2].index(str(e))\\n list_values = [0]*3\\n list_values[0]= na_dict_copy[e2][0]\\n list_values[pos]= na_dict_copy[e2][pos]\\n na_dict_copy[str(e)]=list_values \\n corr_limit_1 = int(corr_limit[e])\\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\\n\\n else:\\n corr_limit_1 = int(corr_limit[e])\\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\\n\\n except Exception, exception_str:\\n corr_limit_1 = int(corr_limit[e])\\n M_indist.append(add_indistinguishable_element_for_autodetect(M, formuladict[e2], na_dict_copy[e], corr_limit_1))\\n\\n if M_indist:\\n i = np.eye(M.shape[1])\\n for m in M_indist:\\n m = np.matmul(m, i)\\n i=m\\n M = np.matmul(i, M)\\n return pinv(M)\",\n \"def process_replies(self, process_scores_only=False) -> None:\\n if self._data.empty:\\n logger.warning(msg=\\\"No survey replies found.\\\")\\n return\\n\\n self._data[cons.SURVEY_REPLY].replace('', np.nan, inplace=True)\\n self._data[cons.SURVEY_REPLY].replace('--deleted-content--', np.nan, inplace=True)\\n survey_replies_with_content = self._data.dropna(subset=[cons.SURVEY_REPLY]).reset_index(\\n drop=True)\\n\\n for row in survey_replies_with_content.itertuples(index=False):\\n comment = self._clean_comments(comment=row.comment)\\n period = \\\"%s_%s\\\" % (row.iteration_week, row.iteration_year)\\n\\n if self._process_prefix and comment is not None:\\n\\n if row.company_id not in self._result:\\n self._result[row.company_id] = {}\\n if period not in self._result[row.company_id]:\\n self._result[row.company_id][period] = {}\\n\\n text = self.__attach_question_to_comment(comment, row, cons.lang_english)\\n score, sentiment = self._process_sentiment(company_id=row.company_id, text=text)\\n\\n reply_data = {}\\n\\n if process_scores_only:\\n reply_data.update(score=score)\\n else:\\n entities_text, entities_type = self._process_entities(comment)\\n\\n reply_data.update(dimension=row.dimension_description)\\n reply_data.update(text=row.comment)\\n reply_data.update(sentiment=sentiment)\\n reply_data.update(entities_text=entities_text,\\n entities_type=list(set(entities_type)))\\n\\n self._result[row.company_id][period][row.survey_reply_id] = {}\\n self._result[row.company_id][period][row.survey_reply_id] = reply_data\\n\\n time.sleep(0.5)\",\n \"def remove_extra_index_from_context_actions(context_action_dict):\\n keys_to_keep = {'initial_value', 'replacement_value'}\\n for question in context_action_dict:\\n for obj_dct in context_action_dict[question]:\\n total_keys = set(obj_dct.keys())\\n keys_to_remove = total_keys - keys_to_keep\\n for key in keys_to_remove:\\n obj_dct.pop(key)\\n return context_action_dict\",\n \"def batchify(batch):\\n\\n\\tquestion_len = list()\\n\\tlabel_list = list()\\n\\tfor ex in batch:\\n\\t\\tquestion_len.append(len(ex[0]))\\n\\t\\tlabel_list.append(ex[1])\\n\\n\\t'''\\n\\tPadding the labels - unequal length sequences for sequenial data like we have. \\n\\tSince actual labels are 0/1 - we pad with -1, and will use this when 'masking' labels during loss and\\n\\taccuracy evaluation.\\n\\t'''\\n\\ttarget_labels = torch.nn.utils.rnn.pad_sequence([torch.tensor(y) for y in label_list], padding_value=-1).t()\\n\\n\\t# dimension is dimension of every feature vector = n_guesses in this homework setting\\n\\tdim = batch[0][0].shape[1]\\n\\n\\t# similar padding happens for the feature vectors, with vector of all zeros appended.\\n\\tx1 = torch.FloatTensor(len(question_len), max(question_len), dim).zero_()\\n\\tfor i in range(len(question_len)):\\n\\t\\tquestion_feature_vec = batch[i][0]\\n\\t\\tvec = torch.FloatTensor(question_feature_vec)\\n\\t\\tx1[i, :len(question_feature_vec)].copy_(vec)\\n\\tq_batch = {'feature_vec': x1, 'len': torch.FloatTensor(question_len), 'labels': target_labels}\\n\\treturn q_batch\",\n \"def replace_char(line_copy, index_candidates): \\n for idx in index_candidates:\\n line_copy[idx] = idx_vocab[random.choice(range(100, 10000))]\\n\\n return line_copy\",\n \"def __getitem__(self, index):\\n idx = self.available_idx[index]\\n qn = self.questions[idx]\\n qid = qn['id']\\n house = qn['house']\\n attr, room_attr = self.question_to_attribute(qn)\\n\\n # encode question and answer\\n qe = self.encoded_questions[qn['h5_id']]\\n ae = self.encoded_questions[qn['h5_id']]\\n\\n # choose path_ix\\n path_ix = random.choice(range(qn['num_paths'])) if self.split == 'train' else 0 \\n path_feats_h5 = h5py.File(osp.join(self.path_feats_dir, qn['path_name']+'.h5'), 'r')\\n raw_ego_feats = path_feats_h5['ego_rgb%s' % path_ix][...].reshape(-1, 3200) # (L, 32, 10, 10)\\n raw_path_len = raw_ego_feats.shape[0]\\n raw_actions = qn['path_actions'][path_ix] # (L, )\\n raw_pos_queue = qn['path_positions'][path_ix] # list of L positions\\n if self.requires_imgs:\\n path_images_h5 = h5py.File(osp.join(self.path_images_dir, qn['path_name']+'.h5'), 'r')\\n raw_ego_imgs = path_images_h5['ego_rgb%s' % path_ix] # (L, 224, 224, 3)\\n nav_ego_imgs = []\\n\\n # nav_phrases, nav_phrase_embs\\n nav_pgs = [pg for pg in qn['program'] if 'nav' in pg['function']]\\n nav_ids = [pg['id'][0] for pg in qn['program'] if 'nav' in pg['function']]\\n nav_types = [pg['function'][4:] for pg in qn['program'] if 'nav' in pg['function']]\\n nav_phrases = [pg['value_inputs'][0] for pg in qn['program'] if 'nav' in pg['function']]\\n nav_phrase_embs = []\\n for phrase in nav_phrases:\\n nav_phrase_embs.append(np.array([self.wtov[wd] for wd in phrase.split()]).mean(0).astype(np.float32)) # (300, )\\n nav_phrase_embs = np.array(nav_phrase_embs) # (#targets, 300)\\n\\n # For each segment path: feats + actions + pos_queue\\n raw_key_ixs = qn['key_ixs_set'][path_ix]\\n nav_ego_feats = []\\n nav_action_inputs = []\\n nav_action_outputs = []\\n nav_pos_queues = []\\n for i, key_ix in enumerate(raw_key_ixs):\\n start_ix = 0 if i == 0 else raw_key_ixs[i-1] # we use last key_ix moment as start (spawn location)\\n end_ix = raw_key_ixs[i]+1\\n ego_feats = raw_ego_feats[start_ix:end_ix]\\n action_inputs = np.array([4] + raw_actions[start_ix:end_ix][:-1], dtype=np.int64)\\n action_outputs = np.array(raw_actions[start_ix:end_ix-1] + [3], dtype=np.int64)\\n pos_queue = raw_pos_queue[start_ix:end_ix]\\n assert ego_feats.shape[0] == len(pos_queue) == action_inputs.shape[0]\\n # add to list\\n nav_ego_feats.append(ego_feats)\\n nav_action_inputs.append(action_inputs)\\n nav_action_outputs.append(action_outputs)\\n nav_pos_queues.append(pos_queue)\\n if self.requires_imgs:\\n nav_ego_imgs.append(raw_ego_imgs[start_ix:end_ix])\\n\\n # cache\\n if self.to_cache and index not in self.img_data_cache:\\n self.img_data_cache[index] = True # TODO: replace with ego_feats \\n\\n # private variable\\n self.episode_house = self.env_loaded[house]\\n self.nav_pos_queues = nav_pos_queues\\n self.path_len = raw_path_len\\n\\n # return\\n data = {}\\n data['idx'] = idx\\n data['qid'] = qid\\n data['house'] = qn['house']\\n data['question'] = qn['question']\\n data['answer'] = qn['answer']\\n data['type'] = qn['type']\\n data['attr'] = attr\\n data['qe'] = qe\\n data['ae'] = ae\\n data['path_name'] = qn['path_name']\\n data['path_ix'] = path_ix\\n data['nav_ids'] = nav_ids\\n data['nav_types'] = nav_types\\n data['nav_phrases'] = nav_phrases\\n data['nav_phrase_embs'] = nav_phrase_embs\\n data['nav_ego_feats'] = nav_ego_feats\\n data['nav_action_inputs'] = nav_action_inputs\\n data['nav_action_outputs'] = nav_action_outputs\\n if self.requires_imgs:\\n data['nav_ego_imgs'] = nav_ego_imgs\\n return data\",\n \"def tokenize_replace_pos(doc_list, language_code, replace_pos,\\n core_num=multiprocessing.cpu_count()):\\n param = [[d, language_code, replace_pos] for d in doc_list]\\n pool = multiprocessing.Pool(core_num)\\n return pool.map(_tokenize_replace_pos4map, param)\",\n \"def q_attention(decoder_state, coverage=None):\\n with variable_scope.variable_scope(\\\"Question_Attention\\\"):\\n # Pass the decoder state through a linear layer (this is W_s s_t + b_attn in the paper)\\n decoder_features = linear(decoder_state, attention_vec_size, True) # shape (batch_size, attention_vec_size)\\n decoder_features = tf.expand_dims(tf.expand_dims(decoder_features, 1), 1) # reshape to (batch_size, 1, 1, attention_vec_size)\\n\\n if use_coverage and coverage is not None: # non-first step of coverage\\n # Multiply coverage vector by w_c to get coverage_features.\\n coverage_features = nn_ops.conv2d(coverage, w_q_c, [1, 1, 1, 1], \\\"SAME\\\") # c has shape (batch_size, attn_length, 1, attention_vec_size)\\n\\n # Calculate v^T tanh(W_h h_i + W_s s_t + w_c c_i^t + b_attn)\\n e = math_ops.reduce_sum(v_q * math_ops.tanh(question_features + decoder_features + coverage_features), [2, 3]) # shape (batch_size,attn_length)\\n\\n # Calculate attention distribution\\n attn_dist = masked_attention_q(e, q_padding_mask)\\n\\n # Update coverage vector\\n coverage += array_ops.reshape(attn_dist, [batch_size, -1, 1, 1])\\n else:\\n # Calculate v^T tanh(W_h h_i + W_s s_t + b_attn)\\n e = math_ops.reduce_sum(v_q * math_ops.tanh(question_features + decoder_features), [2, 3]) # calculate e\\n\\n # Calculate attention distribution\\n attn_dist = masked_attention_q(e, q_padding_mask)\\n\\n if use_coverage: # first step of training\\n coverage = tf.expand_dims(tf.expand_dims(attn_dist,2),2) # initialize coverage\\n\\n # Calculate the context vector from attn_dist and encoder_states\\n context_vector = math_ops.reduce_sum(array_ops.reshape(attn_dist, [batch_size, -1, 1, 1]) * question_states, [1, 2]) # shape (batch_size, attn_size).\\n context_vector = array_ops.reshape(context_vector, [-1, attn_size])\\n\\n return context_vector, attn_dist, coverage\",\n \"def prepare_for_supervised(embeddings):\\n \\n X, y = [], []\\n for problem in embeddings:\\n pairs = [np.concatenate((problem['question'], problem[i])) \\n for i in ('choice_0', 'choice_1', 'choice_2', 'choice_3')]\\n correct_answer = problem['correct_answer']\\n \\n labels = [0, 0, 0, 0]\\n labels[correct_answer] = 1\\n X.extend(pairs)\\n y.extend(labels)\\n return X, y\",\n \"def replace_tokens(self, tokens):\\n details = []\\n idx = 0\\n if len(tokens) >= min_token_num:\\n for i in range(len(tokens)):\\n old_token = tokens[i]\\n if old_token in self.vocab and self.get_random_prob() < self.token_prob:\\n tokens[i] = self.get_delete_token()\\n details.append((old_token, tokens[i], idx, idx + len(tokens[i])))\\n idx += len(tokens[i])\\n return tokens, details\",\n \"def pose_qa(self, specificity_sector=0, n_qas=4, n_diff_sectors=3,\\n n_incorrect = 3, plan_file=None, save_posed=True):\\n def test_ans_length(ans, indexes):\\n la = len(ans)\\n if la > indexes.max():\\n return np.array(ans)[indexes]\\n else:\\n return np.array(ans)\\n\\n assert specificity_sector < n_diff_sectors, ('The specificity sector'\\n ' goes from 0 to {}'.format(n_diff_sectors - 1))\\n diff_sector_means = list(map(np.mean, \\n np.array_split(\\n np.array(\\n list(range(10))) / 10.0,\\n n_diff_sectors)))\\n bn_parameter = diff_sector_means[specificity_sector]\\n q_size = self.n_topics * self.n_top_sentences\\n a_size = self.n_top_words\\n ques_idx = np.random.binomial(n=q_size, p=bn_parameter, size=n_qas)\\n anss_idx = np.random.binomial(n=a_size, p=bn_parameter, size=n_qas)\\n\\n if not plan_file is None:\\n self.qa_plan = pd.read_csv(plan_file)\\n self.qa_plan['answers'] = self.qa_plan['answers'] \\\\\\n .apply(ast.literal_eval)\\n\\n ques = self.qa_plan['QA'][ques_idx]\\n anss = [test_ans_length(a, anss_idx)\\n for a in self.qa_plan['answers'][ques_idx]]\\n posed_qas = []\\n for que, ans in zip(ques, anss):\\n if len(ans) >= n_incorrect:\\n for a in ans:\\n correct = tuple(a)\\n q = que.replace(a[0], '_' * len(a[0]))\\n tans = list(map(tuple, ans))\\n tans.pop(tans.index(correct))\\n posed_qas.append(\\n (q, correct, tans)\\n )\\n if save_posed:\\n pd.DataFrame(posed_qas,\\n columns=['question', 'answer', 'bait']) \\\\\\n .to_csv('qa_' + plan_file.split('.')[0] + '.csv',\\n index=False)\\n else:\\n return pd.DataFrame(posed_qas,\\n columns=['question', 'answer', 'bait'])\\n else:\\n plan_qas = {}\\n for i in list(self.qa_plan.keys()):\\n ques = self.qa_plan[i]['QA'][ques_idx]\\n anss = [test_ans_length(a, anss_idx)\\n for a in self.qa_plan[i]['answers'][ques_idx]]\\n #q_tokenized = ' '.join(self.qa_plan[i]['QA'].values.tolist())\\n int_bow = dict(self.interest_bower[i] \\\\\\n .doc2bow(sum(self.int_sentences[i], [])))\\n posed_qas = []\\n for que, ans in zip(ques, anss):\\n if len(ans) >= n_incorrect:\\n for a in ans:\\n correct = tuple(a)\\n q = que.replace(a[0], '_' * len(a[0]))\\n tans = list(map(tuple, ans))\\n tans.pop(tans.index(correct))\\n correct_id = self.interest_bower[i] \\\\\\n .token2id[correct[0]]\\n correct = correct + (int_bow[correct_id], )\\n posed_qas.append((q, correct, tans))\\n\\n if save_posed:\\n pd.DataFrame(posed_qas,\\n columns=['question', 'answer', 'bait']) \\\\\\n .to_csv('qa_for_' + i.replace(' ', '_') + '.csv',\\n index=False)\\n else:\\n plan_qas[i] = pd.DataFrame(posed_qas,\\n columns=['question', 'answer', 'bait'])\\n return plan_qas\",\n \"def insert_values():\\n merged_df = pd.read_csv(\\\"merged_fuzzy_df.csv\\\")\\n df = pd.read_csv(\\\"df.csv\\\")\\n story_entity_df = pd.read_csv(\\\"story_entity_df.csv\\\")\\n\\n merged_df['entity_id'] = merged_df['entity_id'].apply(str)\\n\\n # find and input new types\\n TYPES = get_types_ids(list(story_entity_df[\\\"label\\\"].unique()))\\n\\n new_parents = {}\\n new_alias = {}\\n\\n merged_df[\\\"wiki\\\"].fillna(\\\"\\\", inplace=True)\\n\\n # if score = -2, it needs new alias as well as new parents\\n for index, row in merged_df[merged_df[\\\"score\\\"] == -2].iterrows():\\n\\n # create a new parent\\n if row[\\\"text\\\"] not in new_parents:\\n new_parents[row[\\\"text\\\"]] = [\\n str(uuid.uuid4()),\\n row[\\\"text\\\"],\\n TYPES[row[\\\"label\\\"]],\\n row[\\\"wiki\\\"],\\n True,\\n str(datetime.utcnow())\\n ]\\n\\n merged_df.at[index,\\n \\\"entity_id\\\"] = new_parents[row[\\\"text\\\"]][0]\\n\\n # add alias with corresponding parent ID\\n if row[\\\"text\\\"] not in new_alias:\\n new_alias[row[\\\"text\\\"]] = [\\n str(uuid.uuid4()),\\n row[\\\"text\\\"],\\n row[\\\"wiki\\\"],\\n row[\\\"score\\\"],\\n str(datetime.utcnow()),\\n new_parents[row[\\\"text\\\"]][0],\\n TYPES[row[\\\"label\\\"]]\\n ]\\n\\n for index, row in merged_df[merged_df[\\\"score\\\"] >= -1].iterrows():\\n # if score >= -1, it needs new alias\\n if row[\\\"text\\\"] not in new_alias:\\n new_alias[row[\\\"text\\\"]] = [\\n str(uuid.uuid4()),\\n row[\\\"text\\\"],\\n row[\\\"wiki\\\"],\\n row[\\\"score\\\"],\\n str(datetime.utcnow()),\\n row[\\\"entity_ref_id\\\"],\\n TYPES[row[\\\"label\\\"]]\\n ]\\n\\n merged_df.at[index,\\n \\\"entity_id\\\"] = row[\\\"entity_ref_id\\\"]\\n\\n # if already matched, write story_entity_id into entity_id for mapping\\n for index, row in merged_df[merged_df[\\\"score\\\"].isnull()].iterrows():\\n merged_df.at[index,\\n \\\"entity_id\\\"] = row[\\\"entity_ref_id\\\"]\\n\\n for _, value in new_parents.items():\\n STORY_REF_INPUTS.append(value)\\n\\n for _, value in new_alias.items():\\n ENTITY_ALIAS_INPUTS.append(value)\\n\\n logging.info(\\\"parents: {}\\\".format(len(STORY_REF_INPUTS)))\\n logging.info(\\\"alias: {}\\\".format(len(ENTITY_ALIAS_INPUTS)))\\n\\n columns_to_drop = [\\\"legal_name\\\", \\\"wiki\\\", \\\"label\\\",\\n \\\"entity_ref_id\\\", \\\"entity_name\\\",\\n \\\"text\\\", \\\"score\\\"]\\n merged_df.drop(columns_to_drop, axis=1, inplace=True)\\n\\n # generate uuids for story_map\\n uuids = []\\n for _ in range(len(merged_df)):\\n uuids.append(str(uuid.uuid4()))\\n\\n logging.info(\\\"check na {}\\\".format(merged_df.isnull().values.any()))\\n\\n # input new_entites to table\\n # using entity UUID and story UUID to apis_story_enity_map table\\n\\n merged_df[\\\"uuid\\\"] = uuids\\n merged_df[\\\"created_at\\\"] = str(datetime.utcnow())\\n\\n merged_df = merged_df[[\\\"uuid\\\", \\\"entity_id\\\",\\n \\\"story_uuid\\\", \\\"mentions\\\",\\n \\\"salience\\\", \\\"created_at\\\"]]\\n\\n STORY_MAP_INPUTS = [tuple(row)\\n for row in merged_df.itertuples(index=False)]\\n\\n # see if there are apis_entity elements in the stories\\n match_manual_entity_to_story(df)\\n\\n insert_story_entity_ref(STORY_REF_INPUTS)\\n insert_entity_alias(ENTITY_ALIAS_INPUTS)\\n insert_story_entity_map(STORY_MAP_INPUTS)\\n\\n logging.info(\\\"finished\\\")\\n\\n logging.info(\\\"delete articles without entities\\\")\\n articles_without_entities(df, story_entity_df)\",\n \"def forward(self, passage, question):\\n # Mask: FloatTensor with 0 in positions that are\\n # padding (word index 0) and 1 in positions with actual words.\\n # Make a mask for the passage. Shape: ?\\n # TODO: Your code here.\\n\\n passage_mask = (passage != 0).type(\\n torch.cuda.FloatTensor if passage.is_cuda else\\n torch.FloatTensor)\\n\\n # Make a mask for the question. Shape: ?\\n # TODO: Your code here.\\n\\n question_mask = (question != 0).type(\\n torch.cuda.FloatTensor if question.is_cuda else\\n torch.FloatTensor)\\n\\n\\n # Make a LongTensor with the length (number non-padding words\\n # in) each passage.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Sum along dim 1 to get length of non-padding words for passage\\n passageLengths = passage_mask.sum(dim=1)\\n\\n # Make a LongTensor with the length (number non-padding words\\n # in) each question.\\n # Shape: ?\\n # TODO: Your code here.\\n \\n # Sum along dim 1 to get length of non-padding words for questions\\n questionLengths = question_mask.sum(dim=1)\\n\\n # Part 1: Embed the passages and the questions.\\n # 1.1 Embed the passage.\\n # TODO: Your code here.\\n # Shape: ?\\n\\n # Get passage embedding\\n embedded_passage = self.embedding(passage)\\n\\n # 1.2. Embed the question.\\n # TODO: Your code here.\\n # Shape: ?\\n\\n # Get question embedding\\n embedded_question = self.embedding(question)\\n\\n # Part 2. Encode the embedded passages with the RNN.\\n # 2.1. Sort embedded passages by decreasing order of passage_lengths.\\n # Hint: allennlp.nn.util.sort_batch_by_length might be helpful.\\n # TODO: Your code here.\\n\\n # Sort training batch with allennlp function with passage and lengths as parameters\\n sorted_passage, sorted_passage_lengths, passage_restoration, _ = sort_batch_by_length(embedded_passage, passageLengths)\\n\\n # 2.2. Pack the passages with torch.nn.utils.rnn.pack_padded_sequence.\\n # Hint: Make sure you have the proper value for batch_first.\\n # TODO: Your code here.\\n\\n # pack sequence based on non-padding words\\n packed_passage = pack_padded_sequence(sorted_passage, sorted_passage_lengths, batch_first = True)\\n\\n # 2.3. Encode the packed passages with the RNN.\\n # TODO: Your code here.\\n\\n # get passage representation from GRU\\n passageEncoding, passageHidden = self.gruPassage(packed_passage)\\n\\n # 2.4. Unpack (pad) the passages with\\n # torch.nn.utils.rnn.pad_packed_sequence.\\n # Hint: Make sure you have the proper value for batch_first.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Unpack sequence based on padding words\\n passage_unpacked, lens_unpacked = pad_packed_sequence(passageEncoding, batch_first=True)\\n\\n # 2.5. Unsort the unpacked, encoded passage to restore the\\n # initial ordering.\\n # Hint: Look into torch.index_select or NumPy/PyTorch fancy indexing.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # get unsorted passage using restoration indices\\n unsorted_passage = passage_unpacked.index_select(0, passage_restoration)\\n\\n # Part 3. Encode the embedded questions with the RNN.\\n # 3.1. Sort the embedded questions by decreasing order\\n # of question_lengths.\\n # Hint: allennlp.nn.util.sort_batch_by_length might be helpful.\\n # TODO: Your code here.\\n\\n # Sort question batches\\n sorted_question, sorted_question_lengths, question_restoration, _ = sort_batch_by_length(embedded_question, questionLengths)\\n\\n # 3.2. Pack the questions with pack_padded_sequence.\\n # Hint: Make sure you have the proper value for batch_first.\\n # TODO: Your code here.\\n\\n # pack questions based on padding words\\n packed_question = pack_padded_sequence(sorted_question, sorted_question_lengths, batch_first = True)\\n\\n # 3.3. Encode the questions with the RNN.\\n # TODO: Your code here.\\n\\n # Get question representation from GRU\\n questionEncoding, questionHidden = self.gruQuestion(packed_question)\\n\\n # 3.4. Unpack (pad) the questions with pad_packed_sequence.\\n # Hint: Make sure you have the proper value for batch_first.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Unpack question representation based on padding words\\n question_unpacked, lens_unpacked = pad_packed_sequence(questionEncoding, batch_first = True)\\n\\n # 3.5. Unsort the unpacked, encoded question to restore the\\n # initial ordering.\\n # Hint: Look into torch.index_select or NumPy/PyTorch fancy indexing.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # restore original question ordering using restoration indices\\n unsorted_question = question_unpacked.index_select(0, question_restoration)\\n\\n\\n # Part 4. Calculate attention weights and attend to question.\\n\\n # use softmax to convert weights to probabilities, use those probabilites by multiplying questions to get weighted average\\n # another affine transformation to get the weights from the passages, trainable parameter\\n # define another matrix for attention and multiply that by tensor to get logits, then do softmax from logits to get probability\\n # then computed weighted average from that probability\\n\\n # 4.1. Expand the encoded question to shape suitable for attention.\\n # Hint: Think carefully about what the shape of the attention\\n # input vector should be. torch.unsqueeze and torch.expand\\n # might be useful.\\n # Shape: (batch_size, passage_len, question_len, hidden_dim) (64, 15, 124, 512)\\n # need to get question and passage shape the same\\n # TODO: Your code here.\\n\\n # Goal: (batch_size, passage_len, question_len, hidden_dim) (64, 15, 124, 512)\\n\\n # unsorted question shape is (batch_size, question_len, hidden_dim) (64, , 15 x 512)\\n # passage_mask.size(1) gets max passage size for the mask\\n maxPassageSize = passage_mask.size(1)\\n\\n # Use -1 index within expand to keep original dimensions same and only add passage dimension\\n expanded_question = unsorted_question.unsqueeze(dim=1).expand(-1, maxPassageSize, -1, -1)\\n\\n # 4.2. Expand the encoded passage to shape suitable for attention.\\n # Hint: Think carefully about what the shape of the attention\\n # input vector should be. torch.unsqueeze and torch.expand\\n # might be useful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Get max question size\\n maxQuestionSize = question_mask.size(1)\\n\\n # unsorted pasage shape is (batch_size, passage_len, hidden_dim) (64, 124, 512)\\n # Add question dimension using expand and max question size\\n\\n # Keep all other dimensions the same with -1 index\\n # Unsqueeze adds singleton dimension at place to insert new values\\n expanded_passage = unsorted_passage.unsqueeze(dim=2).expand(-1, -1, maxQuestionSize,-1)\\n\\n\\n # 4.3. Build attention_input. This is the tensor passed through\\n # the affine transform.\\n # Hint: Think carefully what the shape of this tensor should be.\\n # torch.cat might be useful.\\n # Shape: ?\\n\\n # attention_input is the concatenating of 4.1 and 4.2\\n # pass in attention input to affine transformation\\n # use affine_transform function and pass in the concatenated matrix\\n # TODO: Your code here.\\n\\n # concatenate along the last dimension -1 with expanded passages and questions\\n attention_input = torch.cat([expanded_passage, expanded_question,\\n expanded_passage * expanded_question], dim=-1)\\n\\n # 4.4. Apply affine transform to attention input to get\\n # attention logits. You will need to slightly reshape it\\n # into a tensor of the shape you expect.\\n # Shape: \\n # TODO: Your code here.\\n\\n # apply attention transform layer, reshape the last dimension to so logits works with mask\\n attention_logits = self.attention_transform(attention_input).squeeze(-1)\\n\\n # 4.5. Masked-softmax the attention logits over the last dimension\\n # to normalize and make the attention logits a proper\\n # probability distribution.\\n # Hint: allennlp.nn.util.last_dim_softmax might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Get probabilty distribution from logits using softmax, default dim = -1 for last dimension\\n prob_dist = masked_softmax(attention_logits, question_mask)\\n\\n # 4.6. Use the attention weights to get a weighted average\\n # of the RNN output from encoding the question for each\\n # passage word.\\n # Hint: torch.bmm might be helpful.\\n # Shape: ?\\n # use torch.bmm with question to add weights\\n # TODO: Your code here.\\n\\n # compute weighted average using matrix product with bmm\\n # Weighted average = P(event) * event \\n attentionWeights = torch.bmm(prob_dist, unsorted_question)\\n\\n # Part 5: Combine the passage and question representations by\\n # concatenating the passage and question representations with\\n # their product.\\n # 5.1. Concatenate to make the combined representation.\\n # Hint: Use torch.cat\\n # Shape: ?\\n # TODO: Your code here.\\n\\n # Get combined representation using formula to add passage representation, weighted average, and element-wise product\\n # Concatenate over last dimension\\n combinedRepresent = torch.cat([unsorted_passage, attentionWeights,\\n unsorted_passage * attentionWeights], dim=-1)\\n\\n # Part 6: Compute logits for answer start index.\\n\\n # 6.1. Apply the affine transformation, and edit the shape.\\n # Shape after affine transformation: ?\\n # Shape after editing shape: ?\\n # TODO: Your code here.\\n\\n # Get start projection using combined representation\\n start_logits = self.start_output_projection(combinedRepresent).squeeze(-1)\\n\\n # 6.2. Replace the masked values so they have a very low score (-1e7).\\n # This tensor is your start_logits.\\n # Hint: allennlp.nn.util.replace_masked_values might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n start_logits = replace_masked_values(start_logits, passage_mask, -1e7)\\n\\n\\n # 6.3. Apply a padding-aware log-softmax to normalize.\\n # This tensor is your softmax_start_logits.\\n # Hint: allennlp.nn.util.masked_log_softmax might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n \\n softmax_start_logits = masked_log_softmax(start_logits, passage_mask)\\n\\n # Part 7: Compute logits for answer end index.\\n\\n # 7.1. Apply the affine transformation, and edit the shape.\\n # Shape after affine transformation: ?\\n # Shape after editing shape: ?\\n # TODO: Your code here.\\n\\n end_logits = self.end_output_projection(combinedRepresent).squeeze(-1)\\n\\n # 7.2. Replace the masked values so they have a very low score (-1e7).\\n # This tensor is your end_logits.\\n # Hint: allennlp.nn.util.replace_masked_values might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n end_logits = replace_masked_values(end_logits, passage_mask, -1e7)\\n\\n # 7.3. Apply a padding-aware log-softmax to normalize.\\n # This tensor is your softmax_end_logits.\\n # Hint: allennlp.nn.util.masked_log_softmax might be helpful.\\n # Shape: ?\\n # TODO: Your code here.\\n\\n softmax_end_logits = masked_log_softmax(end_logits, passage_mask)\\n\\n # Part 8: Output a dictionary with the start_logits, end_logits,\\n # softmax_start_logits, softmax_end_logits.\\n # TODO: Your code here. Remove the NotImplementedError below.\\n \\n return {\\n \\\"start_logits\\\": start_logits,\\n \\\"end_logits\\\": end_logits,\\n \\\"softmax_start_logits\\\": softmax_start_logits,\\n \\\"softmax_end_logits\\\": softmax_end_logits\\n }\",\n \"def preprocess_nn(json_df, articles_df, vectorizer, max_seq_len, spellcheck=None, use_ngrams=True, credibility_model=None):\\n\\n # Raw Data\\n uids = list(json_df[const.PKL_CLAIM_ID])\\n claims = json_df[const.PKL_CLAIM]\\n claimants = json_df[const.PKL_CLAIMANT]\\n labels = json_df[const.PKL_LABEL]\\n related_articles = json_df[const.PKL_RELATED_ARTICLES]\\n\\n # Processed Data\\n processed_claims = []\\n supporting_info = []\\n credibilities = []\\n final_labels = []\\n\\n start_time = time.time() # Used for tracking only\\n\\n '''\\n Loop through all the claims and their article ID's\\n '''\\n for j, (str_claim, str_claimant, article_ids, label) in enumerate(zip(claims, claimants, related_articles, labels)):\\n\\n # Tracking use only\\n if j % 1000 == 0 and j != 0:\\n now = time.time()\\n log(f\\\"Processing claim {j} | Last 1000 claims took {now - start_time} seconds\\\")\\n start_time = now\\n\\n '''\\n Process Claim: \\n Final Claim = Claimant + Claim\\n - Convert numbers to string representation\\n - Take out all non-alphanumeric\\n - Keep case - may be important\\n '''\\n claim = str_claimant + ' ' + str_claim\\n claim = clean_txt(claim, spellcheck)\\n\\n '''\\n Process articles\\n - Get all articles from the dataframe by ID\\n - Get relevant info from the article, truncated to max_seq_len # of words\\n '''\\n # Get list of article bodies from the dataframe\\n article_ids = [str(article_id) for article_id in article_ids] # Need to lookup by string\\n # Get the articles with the given article ID's and only extract the text column\\n articles = articles_df.loc[articles_df[const.PKL_ARTICLE_ID].isin(article_ids), const.PKL_ARTICLE_TXT]\\n\\n # If using credibility, we separate the articles\\n if credibility_model is not None:\\n for article in articles:\\n credibility = get_credibility(article, credibility_model)\\n support_txt = get_relevant_info(claim, [article], vectorizer, max_seq_len, spellcheck, use_ngrams)\\n # Add to list\\n credibilities.append(credibility)\\n processed_claims.append(claim)\\n supporting_info.append(support_txt)\\n final_labels.append(label)\\n\\n else:\\n # If we are not using credibility model, construct support text from all articles\\n support_txt = get_relevant_info(claim, articles, vectorizer, max_seq_len, spellcheck, use_ngrams)\\n # Add to list\\n processed_claims.append(claim)\\n supporting_info.append(support_txt)\\n final_labels.append(label)\\n\\n # Return what's appropriate\\n if credibility_model is not None:\\n return uids, processed_claims, supporting_info, final_labels, credibilities\\n else:\\n return uids, processed_claims, supporting_info, final_labels\",\n \"def batch_inference(question,context): \\n inputs = tokenizer(question, context, \\n return_tensors='pt', \\n truncation=True, \\n padding=True)\\n \\n # Move data to GPU\\n inputs = inputs.to(device)\\n \\n # Feed data through the model\\n with torch.no_grad():\\n outputs = model(**inputs)\\n\\n # Q&A model outputs the two logit scores for each word.\\n # One for its chance of being the start of the answer\\n # and one for its chance of being the end\\n start_logits = outputs.start_logits\\n end_logits = outputs.end_logits\\n \\n # Find the words with the highest score\\n # argmax(dim=1) means argmax with each sample\\n start = start_logits.argmax(dim=1)\\n end = end_logits.argmax(dim=1)\\n \\n # Return the answers\\n # This is the point where we move the prediction back to main memory with .cpu()\\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\\\"input_ids\\\"].cpu().numpy()]\\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]\",\n \"def __getitem__(self, idx):\\n pos_pid = self.valid_passage_ids[idx]\\n psg = self.passage_sent_dict[pos_pid]\\n assert(len(psg) > 1)\\n\\n # randomly select a sentence as the question\\n qid = random.choice(range(len(psg)))\\n query = psg[qid]\\n query_tokens = self.tokenizer.encode(query)\\n\\n # remove the selected sentence with 1 - sent_keep probability, this psg is the positive psg.\\n sent_remove_flag = random.random() > self.sent_keep\\n pos_psg = \\\" \\\".join(psg[:qid] + psg[qid+sent_remove_flag:])\\n postive_psg_tokens = self.tokenizer.encode(pos_psg)\\n\\n # randomly sample from the rest to get negative samples.\\n\\n # extract a percentage of hard examples\\n hard_k = int(self.sampled_softmax_n * self.hard_negative_rate)\\n passage_set = self.passageids_set - set([pos_pid])\\n hard_negatives = set([item for item in passage_set if item.split('.')[0] == pos_pid.split('.')[0]])\\n\\n # handle edge case for \\n if len(hard_negatives) >= hard_k:\\n npids_hard = random.sample(hard_negatives, k=hard_k)\\n else:\\n npids_hard = []\\n hard_k = 0\\n\\n # extract a percentage of easy examples\\n rest_k = self.sampled_softmax_n - hard_k\\n npids_rest = random.sample(self.passageids_set - set([pos_pid]) - set(npids_hard), k=rest_k)\\n\\n # putting it all together\\n npids = npids_hard + npids_rest\\n negative_psg_tokens_list = [self.passage_dict[pid] for pid in npids]\\n\\n return query_tokens, postive_psg_tokens, negative_psg_tokens_list, pos_pid, npids\",\n \"def vectorize_data(data, word_idx, sentence_size, memory_size,answer_size):\\n S = []\\n Q = []\\n AS = []\\n L = []\\n label_nums = set([len(dt[2]) for dt in data])\\n assert(len(label_nums) == 1)\\n label_num = list(label_nums)[0]\\n for story, query, answer, label in data:\\n lq = max(0, sentence_size - len(query))\\n q = [word_idx[w] for w in query] + [0] * lq\\n\\n ss = []\\n for i, sentence in enumerate(story, 1):\\n ls = max(0, sentence_size - len(sentence))\\n ss.append([word_idx[w] for w in sentence] + [0] * ls)\\n\\n if len(ss) > memory_size:\\n # Use Jaccard similarity to determine the most relevant sentences\\n q_words = set(q)\\n least_like_q = sorted(ss, cmp = lambda x, y: jaccard(set(x), q_words) < jaccard(set(y), q_words))[:len(ss)-memory_size]\\n for sent in least_like_q:\\n # Remove the first occurrence of sent. A list comprehension as in [sent for sent in ss if sent not in least_like_q]\\n # should not be used, as it would remove multiple occurrences of the same sentence, some of which might actually make the cutoff.\\n ss.remove(sent)\\n else:\\n # pad to memory_size\\n lm = max(0, memory_size - len(ss))\\n for _ in range(lm):\\n ss.append([0] * sentence_size)\\n\\n y = np.zeros(len(word_idx) + 1) # 0 is reserved for nil word\\n\\n sa = []\\n for i, sentence in enumerate(answer, 1):\\n ls = max(0, answer_size - len(sentence))\\n sa.append([word_idx[w] for w in sentence] + [0] * ls)\\n\\n lb = np.zeros(label_num)\\n lb[int(label)] = 1\\n\\n S.append(ss)\\n Q.append(q)\\n AS.append(sa)\\n L.append(lb)\\n Q = pad_sequences(Q, sentence_size)\\n\\n return np.array(S), np.array(Q), np.array(AS), np.array(L)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5195214","0.50893027","0.5070433","0.50482714","0.49829122","0.4942411","0.49302742","0.49184462","0.49094704","0.4815408","0.47388384","0.47334188","0.47175914","0.4665474","0.46608728","0.4643911","0.46391892","0.46259004","0.4593503","0.45771012","0.4553119","0.45482367","0.45480984","0.4533959","0.45282972","0.45237404","0.45052335","0.4486216","0.44823095","0.447423","0.44645303","0.44563994","0.44557577","0.44304413","0.44177645","0.4409339","0.44091696","0.4407723","0.4407588","0.44063717","0.4406199","0.44010967","0.43876475","0.43829462","0.43813556","0.43743935","0.43727142","0.436283","0.4360348","0.43586463","0.43510962","0.4343073","0.43331036","0.43156755","0.43112168","0.43033317","0.43007636","0.4297648","0.4288893","0.42830348","0.4282469","0.42737898","0.42680424","0.42675692","0.42633733","0.42347232","0.4232677","0.42261627","0.4222951","0.42146182","0.42143357","0.4201347","0.42011535","0.4200742","0.4197676","0.41910595","0.41909713","0.4185414","0.41834384","0.41813415","0.417902","0.41778964","0.41723084","0.41678935","0.4163057","0.41617933","0.41580755","0.41562304","0.4154177","0.4146936","0.41433296","0.41405612","0.41380414","0.41372803","0.41251963","0.4124657","0.41131404","0.4110819","0.41083866","0.41074637"],"string":"[\n \"0.5195214\",\n \"0.50893027\",\n \"0.5070433\",\n \"0.50482714\",\n \"0.49829122\",\n \"0.4942411\",\n \"0.49302742\",\n \"0.49184462\",\n \"0.49094704\",\n \"0.4815408\",\n \"0.47388384\",\n \"0.47334188\",\n \"0.47175914\",\n \"0.4665474\",\n \"0.46608728\",\n \"0.4643911\",\n \"0.46391892\",\n \"0.46259004\",\n \"0.4593503\",\n \"0.45771012\",\n \"0.4553119\",\n \"0.45482367\",\n \"0.45480984\",\n \"0.4533959\",\n \"0.45282972\",\n \"0.45237404\",\n \"0.45052335\",\n \"0.4486216\",\n \"0.44823095\",\n \"0.447423\",\n \"0.44645303\",\n \"0.44563994\",\n \"0.44557577\",\n \"0.44304413\",\n \"0.44177645\",\n \"0.4409339\",\n \"0.44091696\",\n \"0.4407723\",\n \"0.4407588\",\n \"0.44063717\",\n \"0.4406199\",\n \"0.44010967\",\n \"0.43876475\",\n \"0.43829462\",\n \"0.43813556\",\n \"0.43743935\",\n \"0.43727142\",\n \"0.436283\",\n \"0.4360348\",\n \"0.43586463\",\n \"0.43510962\",\n \"0.4343073\",\n \"0.43331036\",\n \"0.43156755\",\n \"0.43112168\",\n \"0.43033317\",\n \"0.43007636\",\n \"0.4297648\",\n \"0.4288893\",\n \"0.42830348\",\n \"0.4282469\",\n \"0.42737898\",\n \"0.42680424\",\n \"0.42675692\",\n \"0.42633733\",\n \"0.42347232\",\n \"0.4232677\",\n \"0.42261627\",\n \"0.4222951\",\n \"0.42146182\",\n \"0.42143357\",\n \"0.4201347\",\n \"0.42011535\",\n \"0.4200742\",\n \"0.4197676\",\n \"0.41910595\",\n \"0.41909713\",\n \"0.4185414\",\n \"0.41834384\",\n \"0.41813415\",\n \"0.417902\",\n \"0.41778964\",\n \"0.41723084\",\n \"0.41678935\",\n \"0.4163057\",\n \"0.41617933\",\n \"0.41580755\",\n \"0.41562304\",\n \"0.4154177\",\n \"0.4146936\",\n \"0.41433296\",\n \"0.41405612\",\n \"0.41380414\",\n \"0.41372803\",\n \"0.41251963\",\n \"0.4124657\",\n \"0.41131404\",\n \"0.4110819\",\n \"0.41083866\",\n \"0.41074637\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.502763"},"document_rank":{"kind":"string","value":"4"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":848,"numItemsPerPage":100,"numTotalItems":95772,"offset":84800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjAxMjE3NCwianRpIjoiYzdkZTkwODgtMTI1OS00OTg0LWIzYmQtZTBkNjI4NGRlM2E4Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwMTU3NzQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.pBcrmpB5El-WN83pHFbhSl1-9MAJjEOrA1mif_9jGQHDxAFB5x8MdAfSenIhcAgoOkY5aEDA-UJh41_ugrQnBQ","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 |
|---|---|---|---|---|---|---|
sending all relevant scene information to all clients, for status update | def send_scene_informations(self):
self.send_player_position()
self.send_player_direction()
self.send_grafik_objects() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def update(self):\n \n logging.info('updating state...')\n info = await self.send_command(\"$dat\", \"upd01-\")\n if not info:\n msg = \"Unable to get data about windows and scenes from Gateway\"\n return msg\n\n logging.debug('hub response is :')\n lo... | [
"0.60041046",
"0.59992117",
"0.5972423",
"0.5819911",
"0.5718183",
"0.5576376",
"0.5558921",
"0.55262274",
"0.5505325",
"0.5475588",
"0.54616416",
"0.5444071",
"0.5439299",
"0.5424768",
"0.54154384",
"0.5349631",
"0.5341202",
"0.5330424",
"0.5319409",
"0.5318403",
"0.530497",... | 0.77263695 | 0 |
send positions of all player to all clients | def send_player_position(self):
pl_coor_dict = {}
for pl in self.player_list:
#coor_list = [[p.x(),p.y()] for p in pl._line_list]
pl_coor_dict[pl.id] = pl.get_line_list_float()
self.on_data_to_all_clients({"game":{"player_coor":pl_coor_dict}}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_msg_to_players(players, msg=\"\"):\n for player in players:\n player.player_socket.send(msg + \"\\n\")",
"def send_player_direction(self):\n pl_dir_dict = {}\n for pl in self.player_list:\n pl_dir_dict[pl.id] = pl.direction\n self.on_data_to_all_clients({\"game\... | [
"0.71883184",
"0.6897638",
"0.67860633",
"0.6763005",
"0.6666125",
"0.6314095",
"0.6149467",
"0.6116273",
"0.6100776",
"0.60904455",
"0.60173345",
"0.6011354",
"0.5980113",
"0.5946969",
"0.5932228",
"0.59281164",
"0.5904502",
"0.5900891",
"0.58715874",
"0.5848904",
"0.5835822... | 0.7897912 | 0 |
send direction of all player to the server | def send_player_direction(self):
pl_dir_dict = {}
for pl in self.player_list:
pl_dir_dict[pl.id] = pl.direction
self.on_data_to_all_clients({"game":{"player_dir":pl_dir_dict}}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_player_direction(self,direction):\n pass",
"async def send_dms(self):\n # Player 1 info\n info = \"\"\n for k, v in self.p1_moves.items():\n info += f\"Type **{k}** for **{v}**\\n\"\n\n embed = discord.Embed(\n title=f\"RPS in #{self.channel.nam... | [
"0.6904939",
"0.63594335",
"0.6280396",
"0.60382164",
"0.6019095",
"0.5836359",
"0.5783612",
"0.5775737",
"0.5773039",
"0.5698471",
"0.568822",
"0.56532097",
"0.56252",
"0.5607198",
"0.5595909",
"0.5570109",
"0.55576384",
"0.5543813",
"0.55298716",
"0.5492103",
"0.54724264",
... | 0.8593915 | 0 |
process a batch of k7 data to aod data | def run(self, year, month, day):
try:
self.__download(year, month, day)
except:
err_msg = "[download]->{0}".format(sys.exc_info()[1])
print err_msg
logging.error(err_msg)
return
try:
self.__unrar(year, month, day)
e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self, data_batch: Any, data_samples: Sequence[dict]) -> None:",
"def __data_generation(self, batch_data):\n X = np.zeros((self.batch_size, self.num_features), dtype=float)\n y = np.zeros((self.batch_size, self.num_outputs), dtype=float)\n\n for i, sample in batch_data.iterrows():... | [
"0.6077993",
"0.59293693",
"0.58010113",
"0.57387745",
"0.57387745",
"0.5557606",
"0.55523646",
"0.5549795",
"0.55199504",
"0.54765236",
"0.5470754",
"0.5459762",
"0.5458714",
"0.54408133",
"0.5438925",
"0.5334758",
"0.5333314",
"0.5331136",
"0.53106886",
"0.52860236",
"0.528... | 0.0 | -1 |
run step by step for dev testing | def run_dev(self, year, month, day, step):
if step == 1:
try:
self.__download(year, month, day)
except:
err_msg = "[download]->{0}".format(sys.exc_info()[1])
print err_msg
logging.error(err_msg)
return
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def TestOneStep(self):\n pass",
"def main():\n run_test_all()",
"def runTests(self):\n \n pass",
"def runFunc(runType):\n logger.info('Running test locally with development environment')\n runProcess('local', ['invoke', '-v', '--config-file', 'run_config.yaml'])",
"def runtest(sel... | [
"0.6946755",
"0.689978",
"0.67207056",
"0.66583073",
"0.663308",
"0.660766",
"0.6507847",
"0.6494383",
"0.6468679",
"0.64583427",
"0.64412826",
"0.6440748",
"0.6406907",
"0.63950074",
"0.6394978",
"0.6392331",
"0.6387707",
"0.6383412",
"0.6378931",
"0.63360447",
"0.63303214",... | 0.6413963 | 12 |
download k7 data through ftp. | def __download(self, year, month, day):
print 'Download...'
logging.info('[download]->Download...')
t = datetime.datetime(year, month, day)
spdata.download(stime=t, stations=self.aodSetting.stations, ftp_dir=self.aodSetting.ftp_root, data_dir=self.aodSetting.dd_dir, ftp_ip=self.aodSettin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_data(self, filename=None):\n if (filename is None): filename = ['Public','Gathering.dat']\n elif (type(filename) is str): filename = [filename]\n elif (type(filename) is list): pass\n else: raise TypeError('Require the file path (\\'Public/Gathering.dat\\')')\n\n sel... | [
"0.64380985",
"0.6341836",
"0.6291272",
"0.61992234",
"0.61770105",
"0.6147908",
"0.6088427",
"0.60708237",
"0.6060267",
"0.6028903",
"0.60202116",
"0.5973396",
"0.59491414",
"0.59483415",
"0.59292954",
"0.5885672",
"0.58776695",
"0.58719426",
"0.5834144",
"0.5829435",
"0.579... | 0.62414247 | 3 |
unzip the downloaded k7 files. | def __unrar(self, year, month, day):
print 'Un-rar...'
logging.info('[unrar]->Un-rar...')
k7dir = self.aodSetting.k7_dir
t = datetime.datetime(year, month, day)
stids = self.aodSetting.stations.getstIds()
# Loop - unrar files for each station
for stid in stids:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _unzip_files(self) -> None:\n for file in self.input_path.iterdir():\n if is_zipfile(file):\n with ZipFile(file, mode=\"r\") as archive:\n archive.extractall(path=self.temp_path)",
"def unzip() -> None:\n logger = logging.getLogger(__name__)\n logger.... | [
"0.67345315",
"0.66036296",
"0.6459418",
"0.63836205",
"0.6344491",
"0.6254143",
"0.62338066",
"0.6205159",
"0.6141289",
"0.61412406",
"0.61354464",
"0.61244124",
"0.6117852",
"0.6092154",
"0.6087271",
"0.6069659",
"0.60132784",
"0.59876263",
"0.5933005",
"0.5920788",
"0.5919... | 0.0 | -1 |
decoding the k7 files and merge all of k7 files in specific date range into a single k7 file | def __merge(self, year, month, day):
print 'Merge...'
logging.info('[merge]->Merge...')
k7dir = self.aodSetting.k7_dir # path.join(baseDir, 'k7')
mdir = self.aodSetting.merge_dir # path.join(baseDir, 'merge')
t = datetime.datetime(year, month, day)
stids = self.aodSet... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\r\n\r\n directory = 'D:\\\\Profession\\\\Intern\\\\Assignments\\\\Codes\\\\Assignement Codes\\\\Part 2\\\\data_dumps'\r\n path = os.path.join(directory, 'dump_3')\r\n if not (os.path.exists(path)):\r\n os.mkdir(path)\r\n\r\n for date in range(1, 31):\r\n # date-month-year\r\n ... | [
"0.5749903",
"0.55136085",
"0.5509204",
"0.5468086",
"0.538251",
"0.5376807",
"0.536799",
"0.5353574",
"0.53223854",
"0.53129154",
"0.52146643",
"0.5213128",
"0.52057177",
"0.51921964",
"0.5189649",
"0.5172596",
"0.51672804",
"0.51579833",
"0.5130428",
"0.5128183",
"0.5115077... | 0.6418639 | 0 |
calculate the aod file | def __cal_aod(self, year, month, day):
print 'Calculate...'
logging.info('[calculate]->Calculate...')
t = datetime.datetime(year, month, day)
ddir = self.aodSetting.data_dir
wdir = self.aodSetting.p_aot_dir
ascdir = self.aodSetting.ascii_dir
aotdir = self.aodSet... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_opal(self, file_name):\n \n return 0",
"def aovsPath(self):\n\t\treturn fl.File( self._path + '/aovs.data' )",
"def arff_file(data,attributes,relation,description,output_dir=\"./\",filename=\"tmp\"):\n x = []\n for k in attributes:\n x.append(k[0])\n data_write = {}\n ... | [
"0.5947568",
"0.58376205",
"0.5767446",
"0.5706364",
"0.56674826",
"0.5640036",
"0.56169784",
"0.5545555",
"0.5503337",
"0.5500597",
"0.546921",
"0.54391",
"0.54287213",
"0.5404696",
"0.5369557",
"0.5313572",
"0.53117436",
"0.5296597",
"0.5285791",
"0.52849066",
"0.5265977",
... | 0.71632695 | 0 |
Test the behavior of spec | def test_spec(self):
u_spec = leabra.UnitSpec()
u_spec.act_thr = 0.25
u = leabra.Unit(spec=u_spec) # by default, copyspec=False
u2 = leabra.Unit(spec=u_spec)
self.assertEqual(u.spec.act_thr, 0.25)
self.assertEqual(u2.spec.act_thr, 0.25)
u.spec.act_thr = 0.30
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spec_tests():\n pass",
"def test_basic_execution(self):",
"def test_T01():",
"def test_let(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def test_bed(self):\n #TODO write bed tests",
"def spec(self) -> bool:\n\t\tretu... | [
"0.7441077",
"0.7135826",
"0.7132918",
"0.69778395",
"0.6925052",
"0.6925052",
"0.6925052",
"0.6925052",
"0.6925052",
"0.6907251",
"0.68216866",
"0.67737484",
"0.67737484",
"0.6766573",
"0.6734277",
"0.67254025",
"0.67254025",
"0.67170155",
"0.6712714",
"0.6712714",
"0.670945... | 0.68294686 | 10 |
Test that forcing activity behaves as expected | def test_forced_act(self):
u = leabra.Unit()
u.force_activity(0.5)
u.calculate_net_in()
u.cycle('minus')
self.assertEqual(u.act, 0.5)
# is it maintained?
for _ in range(10):
u.calculate_net_in()
u.cycle('minus')
self.assertEqua... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_activity(self):\n pass",
"def test_create_activity(self):\n pass",
"def test_get_activity(self):\n pass",
"def test_get_activity(self):\n pass",
"def manipulate_activity():\n pass",
"def test_act_on_settings(self):\n pass # TODO(tlarsen)",
"def tes... | [
"0.7063998",
"0.6907587",
"0.6682218",
"0.6682218",
"0.6436824",
"0.6383743",
"0.6383743",
"0.62944734",
"0.6199359",
"0.6198656",
"0.61355084",
"0.6128582",
"0.608371",
"0.60338753",
"0.6028483",
"0.5990039",
"0.59850067",
"0.5970036",
"0.59694934",
"0.59281826",
"0.59158045... | 0.68137604 | 2 |
Test that the longterm average are correctly updated. | def test_avg_l(self):
u_spec = leabra.UnitSpec(g_bar_e=0.3, g_bar_l=0.3, g_bar_i=1.0)
u = leabra.Unit(spec=u_spec)
for _ in range(20):
u.add_excitatory(1.0)
u.calculate_net_in()
u.cycle('minus')
self.assertEqual(u.avg_l, 0.40)
u.spec.update_a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_mean(self):\n pass",
"def test_mean(self):\n pass",
"def test_compute_metrics(self):\n with self.test_session() as sess:\n tf.set_random_seed(1234)\n dut = _setup_trainer(self.tmpdir)\n\n sess.run(tf.global_variables_initializer())\n ses... | [
"0.6695123",
"0.6695123",
"0.6322456",
"0.62833387",
"0.62269557",
"0.6221759",
"0.6209817",
"0.6205302",
"0.62012064",
"0.61570823",
"0.6138694",
"0.6086192",
"0.6057636",
"0.6040159",
"0.6011267",
"0.60064286",
"0.5958843",
"0.5958843",
"0.5958843",
"0.59416413",
"0.5934692... | 0.69294035 | 0 |
Test that the unit activity is behaving well under excitation. | def test_act(self):
spec = leabra.UnitSpec(g_bar_e=0.40, g_bar_l=2.80, g_bar_i=1.00, g_l=1.0,
e_rev_e=1.00, e_rev_l=0.15, e_rev_i=0.15,
act_thr=0.25, act_gain=600.00, act_sd=0.01)
u = leabra.Unit(spec=spec)
for _ in range(15):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_work_without_activity(human):\n with pytest.raises(AttributeError):\n human.work()",
"def test_launch_failures_hw(self):\n self.test_launch_failures()",
"def test_run_ended(self):",
"def testFailure():\n run(\"chariot-me\") #Start management-engine without initial deplflag\n egres... | [
"0.7335777",
"0.7193599",
"0.71814764",
"0.7141535",
"0.6771068",
"0.67386454",
"0.6735247",
"0.670248",
"0.6625328",
"0.659727",
"0.6576637",
"0.65378594",
"0.6536924",
"0.6535871",
"0.65232897",
"0.65107983",
"0.64797604",
"0.6475129",
"0.6453638",
"0.6439196",
"0.6437578",... | 0.6264284 | 37 |
Test the threshold for xx1 functions | def test_xx1_thr(self):
u_spec = leabra.UnitSpec()
u_spec.act_thr = 0.25
u = leabra.Unit(spec=u_spec)
self.assertEqual(u_spec.xx1(-0.1), 0.0)
self.assertTrue(0.0 < u_spec.xx1(0.1))
self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)
self.assertTrue(0.1 < u_spec.noisy_xx... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_thresholding(x):\n return x > threshold_otsu(x)",
"def _check_threshold(threshold, value):\r\n return threshold[0](value, threshold[1])",
"def global_threshold(img, threshold_method):\n pass",
"def evaluate(self, threshold=0.5):\n pass",
"def threshold(self,thresholdValue):\n ... | [
"0.7725878",
"0.6990938",
"0.6906055",
"0.6781788",
"0.66641164",
"0.66137177",
"0.6556111",
"0.6470207",
"0.6446204",
"0.6439647",
"0.6415058",
"0.63528293",
"0.63288236",
"0.62733644",
"0.6249242",
"0.62310404",
"0.62025386",
"0.62004095",
"0.61916935",
"0.6184021",
"0.6153... | 0.67071444 | 4 |
Test if units with forced activity update their averages | def test_avgs_forced(self):
u = leabra.Unit()
for t in range(10):
u.force_activity(1.0)
u.calculate_net_in()
u.cycle('minus')
for name in ['avg_ss', 'avg_s', 'avg_m', 'avg_s_eff']:
self.assertTrue(getattr(u, name) != 0.15) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_is_average(self):\n avg_orders = Decimal(self._uncertain_demand.average_orders)\n self.assertEqual(avg_orders, 50)",
"def should_average(self):\n return self._should_average",
"def trigger_measurement_with_mass_flow_t_comp_and_averaging(self):\n return self.execute(SdpI2cCm... | [
"0.6194015",
"0.60837054",
"0.58219624",
"0.57840586",
"0.57701164",
"0.5766448",
"0.5765421",
"0.5758668",
"0.56976837",
"0.56943905",
"0.56729764",
"0.56564695",
"0.56349504",
"0.5634266",
"0.56338817",
"0.5632846",
"0.5626187",
"0.561752",
"0.5612526",
"0.56117576",
"0.559... | 0.722404 | 0 |
Test quantitative equivalence with emergent on the xx1 function. | def test_emergent_xx1(self):
xx1_data = data.parse_xy('convolve_nxx1.txt')
spec = leabra.UnitSpec(adapt_on=False, noisy_act=True,
act_gain=40, act_sd=0.01)
receiver = leabra.Unit(spec=spec)
receiver.cycle('minus') # create the noisy_xx1 convolution
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_xx1_thr(self):\n u_spec = leabra.UnitSpec()\n u_spec.act_thr = 0.25\n u = leabra.Unit(spec=u_spec)\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\n self.assertTrue(0.0 < u_spec.xx1(0.1))\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\n self.assertTrue(0.1 < u_s... | [
"0.64280814",
"0.6261571",
"0.6162461",
"0.61146444",
"0.60372925",
"0.5985458",
"0.59624684",
"0.59294164",
"0.59135175",
"0.58800495",
"0.5852574",
"0.5826231",
"0.58108443",
"0.5767499",
"0.575935",
"0.5757728",
"0.5744132",
"0.5743049",
"0.5740862",
"0.57356805",
"0.57282... | 0.72790396 | 0 |
Test quantitative equivalence with emergent on the neuron tutorial. | def test_emergent_neuron(self):
check = True
for adapt_on in [False, True]:
neuron_data = data.parse_unit('neuron_adapt.dat' if adapt_on else 'neuron.dat')
spec = leabra.UnitSpec(adapt_on=adapt_on, noisy_act=True,
g_bar_e=0.3, g_bar_l=0.3, g_b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_neuron(self):\r\n # crear una lista 1-D (Horizontal, Entradas).\r\n Z = [1, 2, 3]\r\n # crear una lista 1-D (Vertical, Pesos de la red).\r\n W = [10, 20, 30]\r\n # Inicializamos la neurona, y obtenemos el valor que toma dado W * Z\r\n # X(k) = W * Z\r\n res... | [
"0.6686928",
"0.6533093",
"0.6525016",
"0.64122593",
"0.6292761",
"0.62885284",
"0.622003",
"0.62067026",
"0.61581796",
"0.6143428",
"0.61156917",
"0.61012167",
"0.6086759",
"0.6082188",
"0.6054977",
"0.6037327",
"0.60279274",
"0.6006935",
"0.60018116",
"0.59948033",
"0.59834... | 0.6972024 | 0 |
Returns a handle to an open connection to the mongo db | def get_db(db=None):
if db is None:
db = ideagenstest
return get_mongodb(db['url'],
db['port'],
db['dbName'],
db['user'],
db['pswd']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_db_connection():\n client = MongoClient() #'104.131.185.191', 27017\n db = client[\"225VOH\"]\n return client, db",
"def get_connection():\n return MongoClient(\"mongodb://username:password@localhost:27017\")",
"def get_connection(self):\n\t\tfrom pymongo import MongoClient\n\n\t\tif s... | [
"0.80200183",
"0.7941817",
"0.7930454",
"0.7876856",
"0.7773081",
"0.772081",
"0.76380205",
"0.75901055",
"0.75638014",
"0.7555717",
"0.7388763",
"0.73846686",
"0.7339755",
"0.7277495",
"0.7248042",
"0.7173492",
"0.7163325",
"0.7161241",
"0.7124021",
"0.7117875",
"0.70666003"... | 0.0 | -1 |
Add a list of excluded participants based on a set of usernames. Can't base on user_id because there are duplicate user_id's with the same user name | def add_excl_parts(db, usernames):
desc = "Replicating the effect " + \
"of priming with common vs rare ideas in individual " + \
"brainstorming with revised interface"
exp_id= 'tN33ATDiCukWfj5G7'
# exps = db.experiments.find()
exp = db.experiments.find_one({'_id': exp_id})
db.experiments... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_usernames(self, usernames):\n\t\tself.usernames += self._coerce_list(usernames)",
"def get_ingred_exclusions(user_id):\n\n exclusions = ExcludedIngredient.query.filter_by(user_id=user_id).all()\n if exclusions:\n exclusion_list = []\n for exclusion in exclusions:\n exclu... | [
"0.60056657",
"0.58411485",
"0.5776767",
"0.57505184",
"0.57505184",
"0.57290083",
"0.5695878",
"0.5579431",
"0.5529767",
"0.5501804",
"0.549265",
"0.5400099",
"0.53770614",
"0.5350103",
"0.5335042",
"0.53326446",
"0.52876663",
"0.52876663",
"0.52825737",
"0.52825737",
"0.528... | 0.69511336 | 0 |
takes db parameters and returns a connected db object usign those | def get_mongodb(dbUrl, dbPort, dbName, dbUser=None, dbPswd=None):
if ((dbUser == None) and (dbPswd == None)):
dbURI = "mongodb://" + dbUrl + ":" + \
str(dbPort) + "/" + dbName
elif ((dbUser == "") and (dbPswd == "")):
dbURI = "mongodb://" + dbUrl + ":" + \
str(dbPort) + "/" + dbName
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_db():\n\n def dict_factory(cursor, row):\n \"\"\"\n Creates dict from row.\n\n Args:\n cursor: DB cursor.\n row: Row.\n\n Returns:\n dict: Dict of results.\n \"\"\"\n d = {}\n for idx, col in enumerate(cursor.description):... | [
"0.75570565",
"0.7331119",
"0.73260736",
"0.7320136",
"0.72991186",
"0.72591406",
"0.72268337",
"0.72137827",
"0.71695155",
"0.71635467",
"0.7161651",
"0.7161571",
"0.7161415",
"0.7160452",
"0.71597546",
"0.71348345",
"0.7116581",
"0.7108206",
"0.7085266",
"0.70741093",
"0.70... | 0.0 | -1 |
Constructor that sets the data root directory of the utility and the parameters of the database to operate on | def __init__(self, data_path='data', db_params=ideagens):
my_path = path.abspath(data_path)
self.path = my_path
self.db_params = db_params
self.db = get_db(self.db_params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.filepath = os.path.dirname(__file__)\n self.filepath = os.path.join(self.filepath, \"Datenbank\")\n self.filepath_render_database = os.path.join(self.filepath, self.render_database)\n self.filepath_object_database = os.path.join(self.filepath, self.object_data... | [
"0.7692113",
"0.7485547",
"0.7096281",
"0.70213985",
"0.6860665",
"0.68553454",
"0.6828117",
"0.6802415",
"0.67979676",
"0.6768281",
"0.6652036",
"0.6593271",
"0.65823466",
"0.65577674",
"0.65354234",
"0.6481026",
"0.6476851",
"0.64603406",
"0.6454555",
"0.6447259",
"0.644643... | 0.78404117 | 0 |
Get a list of documents from the db collection for specified fields only. fields is list of field names for each document. | def get_data(self, collection, fields=None, filters=None):
data = self.db[collection].find(filters)
if fields is None:
return data
else:
filtered_data = []
for doc in data:
rowDict = {}
for field in fields:
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def only(self, *fields):\n for field in fields:\n path = \".\".join(self.document._meta.resolve_subfield_hierarchy(field.split(\".\")))\n self._only_fields.add(path)\n if self.query._Cursor__fields is None:\n # Identifier and version fields must always be included\n self.query._Curs... | [
"0.6406087",
"0.6140172",
"0.6130618",
"0.6042337",
"0.60035366",
"0.5963449",
"0.5830266",
"0.57392967",
"0.57133764",
"0.5711136",
"0.56971174",
"0.56897503",
"0.56877464",
"0.56624216",
"0.5639431",
"0.5594121",
"0.5571269",
"0.55386645",
"0.55327886",
"0.552651",
"0.55089... | 0.6569988 | 0 |
Perform a similar operation to a sql join for 2 sets of data. base_data list of fields to extend with joined data join_data dictionary of data, indexed by base_field value base_field value to use as key in lookup in join_data dictionary join_fields list of field data to replace the base_field id The modified base_data ... | def join_data(self, base_data, join_data, base_field, join_fields):
for data in base_data:
extra = join_data[data[base_field]]
for field in join_fields:
data[field] = extra[field]
return base_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_join(data: JoinedQueryData, verbose: bool) -> str:\n # The collection (sometimes referred to as \"type\" in the docs) to join\n string = 'type:' if verbose else ''\n string += str(data.collection)\n # The fields used to link the two collections\n if (parent := data.field_on) is not None:... | [
"0.63011765",
"0.6102088",
"0.6041325",
"0.58504885",
"0.58337146",
"0.5824748",
"0.5823174",
"0.5774815",
"0.5771162",
"0.5677486",
"0.5626348",
"0.5621308",
"0.5617843",
"0.55927736",
"0.55664855",
"0.54893863",
"0.5447424",
"0.5423097",
"0.5384637",
"0.5383763",
"0.5378737... | 0.8677487 | 0 |
Get a list of all the ideas | def get_ideas(self):
fields = ['content', 'clusterIDs', 'isGamechanger',
'userID', 'promptID']
return self.get_data("ideas", fields) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_meals():",
"def get_queryset(self):\n return Objective.objects.filter(perspective__description='Learning and Capacity').order_by('code')",
"def get_assay_solutions(self):\n vocabs = []\n assay = self.get_assay()\n if not assay:\n return vocabs\n for sol... | [
"0.6047027",
"0.596079",
"0.5894852",
"0.5878744",
"0.5878744",
"0.58675534",
"0.5793577",
"0.57694536",
"0.57275474",
"0.57194996",
"0.5701384",
"0.5672025",
"0.56617755",
"0.56588876",
"0.56406057",
"0.56047946",
"0.5599134",
"0.5578972",
"0.5569903",
"0.5548997",
"0.554799... | 0.6485765 | 0 |
Get a list of all the ideas | def get_clusters(self):
fields = ['name', ]
return self.get_data("clusters", fields) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ideas(self):\n fields = ['content', 'clusterIDs', 'isGamechanger',\n 'userID', 'promptID']\n return self.get_data(\"ideas\", fields)",
"def get_all_meals():",
"def get_queryset(self):\n return Objective.objects.filter(perspective__description='Learning and Capacity... | [
"0.6485765",
"0.6047027",
"0.596079",
"0.5894852",
"0.5878744",
"0.5878744",
"0.58675534",
"0.5793577",
"0.57694536",
"0.57275474",
"0.57194996",
"0.5701384",
"0.5672025",
"0.56617755",
"0.56588876",
"0.56406057",
"0.56047946",
"0.5599134",
"0.5578972",
"0.5569903",
"0.554899... | 0.0 | -1 |
Get a list of all the ideas | def get_users(self):
fields = ['name', ]
return self.get_data("myUsers", fields) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ideas(self):\n fields = ['content', 'clusterIDs', 'isGamechanger',\n 'userID', 'promptID']\n return self.get_data(\"ideas\", fields)",
"def get_all_meals():",
"def get_queryset(self):\n return Objective.objects.filter(perspective__description='Learning and Capacity... | [
"0.6485765",
"0.6047027",
"0.596079",
"0.5894852",
"0.5878744",
"0.5878744",
"0.58675534",
"0.5793577",
"0.57694536",
"0.57275474",
"0.57194996",
"0.5701384",
"0.5672025",
"0.56617755",
"0.56588876",
"0.56406057",
"0.56047946",
"0.5599134",
"0.5578972",
"0.5569903",
"0.554899... | 0.0 | -1 |
This function creates a GUI obj and draw the simulation board | def initGameState(self):
print("Setting game state: ")
self.playGUI = GUI()
self.playGUI.drawBoard(self.player) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_GUI(self):\n # root object, highest point in GUI, window\n GUI = tk.Tk()\n GUI.title('Sudoku')\n\n # background to fill in the window\n canvas = tk.Canvas(GUI,\n height=self.window_height,\n width=self.window_width,\n... | [
"0.7151314",
"0.7061625",
"0.6972889",
"0.69183123",
"0.68531877",
"0.6804946",
"0.67883235",
"0.6772686",
"0.6707081",
"0.6605524",
"0.6539703",
"0.6533666",
"0.65030825",
"0.64919126",
"0.645551",
"0.6448594",
"0.6443375",
"0.6423321",
"0.6410087",
"0.6408588",
"0.6392138",... | 0.0 | -1 |
This function creates 2 csv files (m_GreenPiece.csv and m_RedPiece.csv) based on the chess piece list data | def genDataFiles(self, pieceList):
b_list, r_list = list(), list()
for i in range(len(pieceList)):
eval("{}.append((pieceList[i]['Name'], pieceList[i]['Pos']))".format('b_list' if pieceList[i]['Team'] == -1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def file(self):\n result = []\n completePath = CompletePath(self.path, self.filename) \n with open(completePath.path(), 'w', newline='') as csvfile:\n fieldnames = ['Activity', 'Points']\n writer = csv.DictWriter(csvfile, fieldnames = fieldnames)\n writer.writ... | [
"0.577005",
"0.56117916",
"0.54306716",
"0.5400523",
"0.53685206",
"0.5366225",
"0.5328159",
"0.53274345",
"0.53264546",
"0.5310038",
"0.52820057",
"0.52732444",
"0.52692014",
"0.52437043",
"0.52368194",
"0.522381",
"0.5191414",
"0.5183072",
"0.5179588",
"0.5169188",
"0.51512... | 0.78872997 | 0 |
This function calls the inputMove() function | def playGame(self):
print("\nPlay Game")
if (self.EndGame()):
print("EndGame stt: ", self.EndGame())
print("The End")
return True
else:
# Get pieceList from thong
input_result = self.inputMove()
# input move return 2 forms... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __process_input(self, input_):\n if self.state.game_over:\n if input_.key_pressed:\n self.state.exit = True\n else:\n if input_.action == 'PLAYER_UP':\n self.state.player.direction = 'U'\n elif input_.action == 'PLAYER_DOWN':\n ... | [
"0.7072983",
"0.69347125",
"0.6717801",
"0.6645006",
"0.6645006",
"0.6645006",
"0.6634736",
"0.66273606",
"0.6622313",
"0.6620156",
"0.66164476",
"0.66120136",
"0.6598716",
"0.65917563",
"0.6580514",
"0.6560492",
"0.6544803",
"0.6444798",
"0.644479",
"0.644001",
"0.64037025",... | 0.0 | -1 |
This function checks whether the BoardData_update.csv is still open to avoid problem when writing to that file | def checkOpenStatus(self):
xl = win32.gencache.EnsureDispatch('Excel.Application')
update_file = "BoardData_update.csv"
update_file_pth = os.path.join(self.current_dir, 'src', update_file)
if xl.Workbooks.Count > 0:
print("opened: ", xl.Workbooks.Count)
# if non... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __check_write_success(self, update_data, path, method):\n #Initiate line-counter\n current_line = 1\n #Calculate what line will have the row we are looking for.\n looking_for_line = self.__row_id_in_file(list(update_data)[0])\n row_id = list(update_data)[0]\n #open fil... | [
"0.5843392",
"0.58275557",
"0.5788735",
"0.57246226",
"0.5717325",
"0.56745094",
"0.56287354",
"0.5576904",
"0.55670744",
"0.55064464",
"0.54561514",
"0.54476815",
"0.5400796",
"0.5398325",
"0.53946525",
"0.53489804",
"0.5316601",
"0.53152823",
"0.53104585",
"0.52899975",
"0.... | 0.675971 | 0 |
This function give the index of a key in the dictionary in a list that match the input value | def find(self, list, key, value):
for i, dic in enumerate(list):
if dic[key] == value:
return i
return -1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def findIndex(lst, key, value):\r\n\r\n for i, dic in enumerate(lst):\r\n if dic['properties'][key] == value:\r\n return i\r\n return -1",
"def find(lst, key, value):\n\n for i, dic in enumerate(lst):\n if dic[key] == value:\n return i\n return None",
"def linear... | [
"0.80608493",
"0.7877168",
"0.7741012",
"0.75335795",
"0.73866296",
"0.7343798",
"0.725151",
"0.69240844",
"0.6870099",
"0.68550146",
"0.6810738",
"0.68026084",
"0.6739354",
"0.6683892",
"0.666758",
"0.66640234",
"0.66579",
"0.6631289",
"0.6626184",
"0.66238743",
"0.66025114"... | 0.84405464 | 0 |
This function handles the inputs from the recognition system and call the AlphaBeta function | def inputMove(self):
# Check if BoardData_update is still opended
self.checkOpenStatus()
self.genDataFiles(self.player.getCurrentPieceList())
print("PieceRecog.exe", len(self.player.getCurrentPieceList()))
# Call the recognition function
os.system("PieceRecog.exe " + st... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_compute_alphas(self):\n\t\tdetails = self.watcher.analyze(layers=[self.second_layer], pool=False, randomize=False, plot=False, mp_fit=False, pl_package=WW_POWERLAW)\n\t\t#d = self.watcher.get_details(results=results)\n\t\ta = details.alpha.to_numpy()\n\t\tself.assertAlmostEqual(a[0],1.74859, places=3)\n\t... | [
"0.5983545",
"0.5803987",
"0.5793107",
"0.57146734",
"0.558493",
"0.5578768",
"0.5578768",
"0.55334127",
"0.5491118",
"0.5359632",
"0.53505504",
"0.5339986",
"0.5333948",
"0.53233486",
"0.5307697",
"0.5304445",
"0.5276514",
"0.5271035",
"0.52671754",
"0.52498364",
"0.52494586... | 0.0 | -1 |
Simulation chess engine which will replace the player role. The depth in this chess engine is fixed to 2 | def autochess(self):
print("Player {}: depth = 2".format(self.player.getCurrentPlayer()))
self.player.changeCurrentPlayer()
red_start = time.time()
result = self.alphabeta(2, True, -9999, 9999, 2)
red_end = time.time()
red_elapse = red_end - red_start
print("red ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play_game(self, k, maxiter=80):\n episode_end = False\n turncount = 0\n tree = Node(self.env.board, gamma=self.gamma) # Initialize the game tree\n\n # Play a game of chess\n while not episode_end:\n state = np.expand_dims(self.env.layer_board.copy(), axis=0)\n ... | [
"0.6021178",
"0.5980791",
"0.5744953",
"0.5693278",
"0.5628124",
"0.55482346",
"0.5477458",
"0.54460293",
"0.5431414",
"0.542534",
"0.54016364",
"0.5384369",
"0.53777295",
"0.5365708",
"0.5363621",
"0.53609574",
"0.5342275",
"0.53383505",
"0.53202564",
"0.53122914",
"0.529054... | 0.0 | -1 |
This function calls the Minimax algorithm with AlphaBeta pruning and update the Board data with its result and pass that result to the SCARA arm | def setNextMove_AB(self):
print("Player {} depth = 2".format(self.player.getCurrentPlayer()))
# Set timer start here:
black_start = time.time()
# Call Alpha Beta algorithm. Result is a dict: (score, piece, pos)
result = self.alphabeta(2, False, -9999, 9999, 2)
# Set time... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_ai():\n print(\"Minimax AI\") # First line is the name of this AI \n color = int(input()) # Then we read the color: 1 for dark (goes first), \n # 2 for light. \n\n while True: # This is the main loop \n # Read in the current game status, for example:\n # \"SC... | [
"0.6739058",
"0.66835195",
"0.66799206",
"0.6660185",
"0.6656803",
"0.6656803",
"0.6570939",
"0.6370557",
"0.6370331",
"0.6335045",
"0.6319892",
"0.62688786",
"0.6221413",
"0.622117",
"0.6218329",
"0.61801255",
"0.6123658",
"0.61101794",
"0.6104088",
"0.61020035",
"0.6071752"... | 0.6949715 | 0 |
This function update the current position of the chess piece in the chess piece list | def movePiece(self, pieceList, piece, pos):
# check captured:
check = self.player.checkCaptured(self.pieceList, pos)
for i in range(len(pieceList)):
# print("I{} = ".format(i),self.pieceList['Symbol'][i])
if piece == pieceList[i]['Symbol']:
# print('Old: ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self): # called to update this piece's position\r\n \r\n if self.name == \"white\" and self.y == 25: self.crowned()\r\n elif self.name == \"black\" and self.y >= 350: self.crowned()\r\n self.draw()",
"def update_state(self):\n self.reset_state()\n for piece in... | [
"0.70116913",
"0.6867341",
"0.6747652",
"0.6747652",
"0.67394334",
"0.6716448",
"0.6712994",
"0.66439164",
"0.6630502",
"0.6586831",
"0.65586555",
"0.6537414",
"0.65296495",
"0.65072405",
"0.65052354",
"0.6481683",
"0.64677644",
"0.64517635",
"0.6444109",
"0.6429925",
"0.6427... | 0.6776017 | 2 |
This function calls the isGeneralExist() function to check if the game has ended | def EndGame(self):
check_endgame = not self.player.getPlayer().isGeneralExist()
return check_endgame | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_game_end(self):\r\n\r\n if np.all(self.remaining == -1): # end of game\r\n self.show_results() # show the final results\r\n sys.exit() # exit the program\r",
"def check_game_over(self):\n for piece in self.pieces:\n if not piece.destroyed:\n ... | [
"0.655188",
"0.6521891",
"0.6394489",
"0.6333242",
"0.6310302",
"0.6310302",
"0.62986654",
"0.62562",
"0.62385774",
"0.6233926",
"0.6220784",
"0.6182156",
"0.61446255",
"0.6126335",
"0.6113239",
"0.60957617",
"0.60863745",
"0.60460824",
"0.59908366",
"0.5977668",
"0.59536237"... | 0.7835693 | 0 |
This function clone the current State to not affect the current chess piece list | def nextState(self, piece, pos):
# Copy current pieceList to new state obj
nextState = copy.deepcopy(self)
nextState.movePiece(nextState.player.getCurrentPieceList(), piece, pos)
return nextState | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def myclone(self):\n new_state = GameState(self.size)\n for rc in self.gameState:\n new_state.gameState[rc] = self.gameState[rc] \n new_state.numRebels = self.numRebels\n new_state.numSith = self.numSith\n new_state.numJedi = self.numJedi\n new_state.numT... | [
"0.7235795",
"0.7170529",
"0.70201683",
"0.69685066",
"0.6800548",
"0.6752228",
"0.6737828",
"0.6681385",
"0.66702825",
"0.6632915",
"0.662159",
"0.6373292",
"0.6328631",
"0.63259995",
"0.63209665",
"0.63136923",
"0.628523",
"0.6269973",
"0.62681705",
"0.6263873",
"0.62616587... | 0.6757453 | 5 |
Minimax algorithm with AlphaBeta pruning. This algorithm is upgraded to fix the pruning problem at the highest depth | def alphabeta(self, depth, isMax, alpha, beta, depth_flag):
# Check for endgame condition:
if self.EndGame() == True:
# print(self.player.getCurrentPieceList())
result = {
"Score": '',
"Piece": '',
"Pos": ''
}
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def minimax(board: bytearray,\n depth: int, # depth of current plies (0 = deepest)\n alpha: int, \n beta: int, \n max_player: bool, # is this maximzing player?\n at_top: bool=False, # are we the top call to this?\n ):\n \n # base cases:\n ... | [
"0.75425935",
"0.74693",
"0.73752105",
"0.7092995",
"0.7008297",
"0.6930921",
"0.6910464",
"0.6905876",
"0.6891868",
"0.6854438",
"0.68499684",
"0.68315196",
"0.6827699",
"0.6825186",
"0.67290574",
"0.67262363",
"0.6707463",
"0.6678839",
"0.66525674",
"0.66510415",
"0.6541357... | 0.6647835 | 20 |
Convert price string to int. | def convert_prices(price):
return int(price.replace("$", "").replace(",", "")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_integer_price(decimal_price):\n return int(float(decimal_price) * 100)",
"def format_price(self, price_text):\n return int(re.sub(r\"\\D\", \"\", price_text))",
"def dec2int(r: str) -> int:",
"def _str_to_int(in_str):\n if in_str == '':\n return 0\n return int(in_str, 1... | [
"0.7487968",
"0.70949787",
"0.7048899",
"0.7001138",
"0.6740254",
"0.6589532",
"0.65539086",
"0.65201676",
"0.6513394",
"0.6505703",
"0.64942455",
"0.64933985",
"0.64712745",
"0.64681584",
"0.6453859",
"0.64247787",
"0.6400984",
"0.6392125",
"0.637679",
"0.63657695",
"0.63581... | 0.7599279 | 0 |
Convert date string to datetime. | def convert_date(date_str):
return datetime.strptime(date_str, "%d/%m/%Y") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def str_to_datetime(datestr):\n\n from dateutil import parser\n from datetime import datetime\n\n date = parser.parse(datestr)\n return date",
"def parse_datetime(date_str: str) -> datetime:\n return dateutil.parser.parse(date_str)",
"def to_datetime(date_string):\n return dt.strptime(date_st... | [
"0.8128393",
"0.8001215",
"0.7989846",
"0.798428",
"0.79651654",
"0.7881875",
"0.7866022",
"0.78598154",
"0.78395015",
"0.77747935",
"0.7715534",
"0.76870006",
"0.75268126",
"0.7498706",
"0.74965304",
"0.7485769",
"0.74842775",
"0.746032",
"0.7424017",
"0.74084324",
"0.739559... | 0.75608206 | 12 |
Extract key information from supplied dicts. | def process_property(prop):
output = {}
output['Property'] = prop['PropertyAddress']
output['Sale date'] = convert_date(prop['DateSold'])
output['Sale price'] = convert_prices(prop['SalePrice'])
output['Rates value'] = convert_prices(prop['CapitalValue'])
return output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_keys(dic, *keys):\n for k in keys:\n if k not in dic:\n raise KeyError(\"key %r is not in original mapping\" % k)\n r1 = {}\n r2 = {}\n for k, v in dic.items():\n if k in keys:\n r1[k] = v\n else:\n r2[k] = v\n return r1, r2",
"def ... | [
"0.69396967",
"0.65762895",
"0.60969096",
"0.6032293",
"0.58696604",
"0.5815913",
"0.5800308",
"0.5795667",
"0.5753932",
"0.5684017",
"0.56767654",
"0.5654763",
"0.5616689",
"0.5562791",
"0.5560253",
"0.5541182",
"0.5537519",
"0.54865456",
"0.54665345",
"0.5452122",
"0.543408... | 0.0 | -1 |
Scrape the most recent sales from the specified QV URL (region). | def get_sale_prices():
r = requests.post(settings.qv_url, data=REQUEST_DATA)
response = r.json()
data_processed = [process_property(prop) for prop in response['LocalAreaSales']]
return data_processed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_search(self):\n # Call the website\n self.driver.get(self.BASE_URL)\n\n # Request the proper historical data\n self.select_proper_version()\n self.save_image()\n\n # If the entity exists in this historical version, extract the data\n if self.select_proper_reg... | [
"0.55092543",
"0.55061114",
"0.54281896",
"0.52271366",
"0.5180293",
"0.5082719",
"0.50809556",
"0.50806385",
"0.5078647",
"0.5068418",
"0.50643146",
"0.5047871",
"0.49885723",
"0.49187106",
"0.4887966",
"0.48736772",
"0.48600337",
"0.48512283",
"0.48398307",
"0.4830591",
"0.... | 0.51767665 | 5 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7274154",
"0.7247606",
"0.7247606",
"0.7247606",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72756827",
"0.7249146",
"0.7249146",
"0.7249146",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72740597",
"0.72474295",
"0.72474295",
"0.72474295",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7275837",
"0.72492236",
"0.72492236",
"0.72492236",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.74556196",
"0.74288356",
"0.74288356",
"0.74288356",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",
"0.7237776",... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72756827",
"0.7249146",
"0.7249146",
"0.7249146",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72740597",
"0.72474295",
"0.72474295",
"0.72474295",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7275837",
"0.72492236",
"0.72492236",
"0.72492236",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7274154",
"0.7247606",
"0.7247606",
"0.7247606",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72756827",
"0.7249146",
"0.7249146",
"0.7249146",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72740597",
"0.72474295",
"0.72474295",
"0.72474295",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7275837",
"0.72492236",
"0.72492236",
"0.72492236",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7274154",
"0.7247606",
"0.7247606",
"0.7247606",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72756827",
"0.7249146",
"0.7249146",
"0.7249146",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72740597",
"0.72474295",
"0.72474295",
"0.72474295",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7275837",
"0.72492236",
"0.72492236",
"0.72492236",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7274154",
"0.7247606",
"0.7247606",
"0.7247606",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72756827",
"0.7249146",
"0.7249146",
"0.7249146",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72740597",
"0.72474295",
"0.72474295",
"0.72474295",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7275837",
"0.72492236",
"0.72492236",
"0.72492236",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7274154",
"0.7247606",
"0.7247606",
"0.7247606",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72756827",
"0.7249146",
"0.7249146",
"0.7249146",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72740597",
"0.72474295",
"0.72474295",
"0.72474295",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",
"0.7114331",... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7275837",
"0.72492236",
"0.72492236",
"0.72492236",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
"0.7115413",
... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.7274154",
"0.7247606",
"0.7247606",
"0.7247606",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"0.7113835",
"... | 0.0 | -1 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self, *args): #cannot find CLR method
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72756827",
"0.7249146",
"0.7249146",
"0.7249146",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
"0.7115314",
... | 0.0 | -1 |
Applies the transforms to the input image. | def __call__(self, image: Union[Tensor, Image]) -> Tensor:
return self.transform(image) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _apply_transform(self, img: np.ndarray): \n img = self.transform(image=img)[\"image\"]\n return img",
"def _apply_transform(self, img: np.ndarray): \n img = self.transform(image=img)[\"image\"]\n return img",
"def _apply_transform(self, x, transform_parameters):\n # x is ... | [
"0.78274447",
"0.78274447",
"0.73057055",
"0.7134887",
"0.69119126",
"0.69119126",
"0.69119126",
"0.6858849",
"0.68499225",
"0.68282694",
"0.6821925",
"0.6816408",
"0.6813896",
"0.67515564",
"0.6749164",
"0.6738225",
"0.67337704",
"0.6722991",
"0.671074",
"0.6646072",
"0.6643... | 0.615406 | 40 |
Applies the transforms to the input image. | def __call__(self, image: Union[Tensor, Image]) -> Tensor:
return self.transform(image) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _apply_transform(self, img: np.ndarray): \n img = self.transform(image=img)[\"image\"]\n return img",
"def _apply_transform(self, img: np.ndarray): \n img = self.transform(image=img)[\"image\"]\n return img",
"def _apply_transform(self, x, transform_parameters):\n # x is ... | [
"0.78274447",
"0.78274447",
"0.73057055",
"0.7134887",
"0.69119126",
"0.69119126",
"0.69119126",
"0.6858849",
"0.68499225",
"0.68282694",
"0.6821925",
"0.6816408",
"0.6813896",
"0.67515564",
"0.6749164",
"0.6738225",
"0.67337704",
"0.6722991",
"0.671074",
"0.6646072",
"0.6643... | 0.615406 | 41 |
Return a context manager which manages the lifetime of a guarded scope. | def guarded(phi: List[CircuitStatement], guard_idf: HybridArgumentIdf, is_true: bool) -> ContextManager:
phi.append(CircGuardModification(guard_idf, is_true))
yield
phi.append(CircGuardModification(None)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def context_local(context=None):\n class manager(object):\n def __init__(self, ctx):\n \"\"\"\n :type ctx: Context\n \"\"\"\n self.context = ctx.copy()\n\n def __enter__(self):\n self.orig_context = context_get()\n context_set(self.... | [
"0.72501886",
"0.6513197",
"0.60733324",
"0.6048442",
"0.60429126",
"0.6010695",
"0.5881372",
"0.5877266",
"0.57822174",
"0.5732369",
"0.5726881",
"0.5629307",
"0.5621824",
"0.5597244",
"0.55930954",
"0.5543057",
"0.55411077",
"0.5521868",
"0.55116427",
"0.550153",
"0.5498804... | 0.0 | -1 |
Function to load rates from Norges Bank. | def run_load_fx():
from integrations.norges_bank.utils.fx import load_fx
load_fx()
logger.info('Loaded FX-rates from Norges Bank') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_currency_rates(url=\"http://www.nbrb.by/API/ExRates/Rates?Periodicity=0\") -> dict:\n data = {}\n response = requests.get(url)\n if response.status_code == 200:\n data = get_json(response)\n return data",
"def getData(self):\n\n url = 'https://www.ecb.europa.eu/stats/eurofxref... | [
"0.6234643",
"0.5868967",
"0.58248913",
"0.58198726",
"0.57753855",
"0.5621314",
"0.55591446",
"0.55049",
"0.5376426",
"0.5365806",
"0.5357714",
"0.53376746",
"0.53337437",
"0.5299859",
"0.52955884",
"0.5285284",
"0.5275836",
"0.5268934",
"0.5255301",
"0.52466327",
"0.5239159... | 0.63152975 | 0 |
Computes policy with a weight of a matrix | def policy(matrix, weight):
# for each column of weights, sum (matrix[i] * weight[i]) using dot product
dot_product = matrix.dot(weight)
# find the exponent of the calculated dot product
exp = np.exp(dot_product)
# policy is exp / sum(exp)
policy = exp / np.sum(exp)
return policy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calcMaxEntPolicy(trans_mat, horizon, r_weights, state_features):\n\tn_states = np.shape(trans_mat)[0]\n\tn_actions = np.shape(trans_mat)[1]\n\n\tpartition = np.zeros((n_states, 1))\n\tpolicy = np.zeros((n_states, n_actions))\n\n\tpartition[n_states-1] = 1\n\treward = np.exp(np.dot(r_weights, state_features.T))... | [
"0.645586",
"0.63133764",
"0.63012934",
"0.60636747",
"0.60606676",
"0.605857",
"0.60234654",
"0.5999505",
"0.59799826",
"0.5944463",
"0.5941373",
"0.59219086",
"0.592158",
"0.58848405",
"0.5873565",
"0.58386296",
"0.58148813",
"0.58018655",
"0.5767474",
"0.5761609",
"0.57509... | 0.86566025 | 0 |
Computes the Monte Carlo policy gradient based on the policy calculated from the above policy() function | def policy_gradient(state, weight):
# first calculate policy using the policy function above
Policy = policy(state, weight)
# get action from policy
action = np.random.choice(len(Policy[0]), p=Policy[0])
# reshape single feature from policy
s = Policy.reshape(-1, 1)
# apply softmax function ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def policy_gradient(self, loader):\n\n net = nn.DataParallel(self.agent, device_ids=self.gpus)\n total_steps = len(loader)\n \n for step_idx, src in enumerate(tqdm(loader, desc='Calculating policy gradient...', leave=False)):\n\n # Decode fragments and smiles, and get loss\n ... | [
"0.7161173",
"0.7032053",
"0.68745005",
"0.68698114",
"0.6776028",
"0.6714242",
"0.65616333",
"0.6516723",
"0.64023477",
"0.6382716",
"0.6294712",
"0.62807685",
"0.6279373",
"0.62744296",
"0.62561136",
"0.6107736",
"0.61047393",
"0.606276",
"0.6048897",
"0.60471356",
"0.60091... | 0.7108714 | 1 |
This step takes in raw data and outputs features suitable for an ML model. | def compute_features(input: str, output: str):
co.nb.matplotlib_inline()
df = pd.read_csv(input)
# Show proportion of customers exited vs retained
labels = 'Exited', 'Retained'
sizes = [df.Exited[df['Exited'] == 1].count(), df.Exited[df['Exited'] == 0].count()]
explode = (0, 0.1)
fig1, ax1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generateFeatures(self, data):\n pass",
"def extract_features(self, inputs):\n pass",
"def createMLData(self):\n\n if self._verbose:\n print('\\nCreate ML Data')\n\n # Minimum required number of input data for ML training under the\n # current implemented setup.... | [
"0.7104645",
"0.67514604",
"0.6521787",
"0.6518997",
"0.6508287",
"0.64788514",
"0.63838124",
"0.632782",
"0.62780243",
"0.62633497",
"0.6249205",
"0.6240376",
"0.62220335",
"0.6219605",
"0.62063205",
"0.6204144",
"0.6161946",
"0.6157869",
"0.6146887",
"0.6146828",
"0.6140769... | 0.0 | -1 |
Fit a machine learning model. | def fit(model, input: str, output: str):
print(f"Fitting model of type: {model}")
# Define the model. Use a randomized search to efficiently explore the
# hyperparameter space in a limited time.
if model == "logistic":
# Primal logistic regression
param_dist = {
'C': logunif... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_model(self):\n logger.info('Fitting model')\n if self.traj_dict is None:\n self.traj_dict = self.get_traj_dict()\n self.model.fit(self.traj_dict.values())",
"def fit_training_data(self):\n self.model.fit(self.X_train)",
"def fit(self, X, y):\n self.model = ... | [
"0.77583563",
"0.76801455",
"0.74248505",
"0.7397779",
"0.7377171",
"0.7368339",
"0.7294504",
"0.7290782",
"0.7290782",
"0.7290782",
"0.7290782",
"0.7290782",
"0.7290782",
"0.7290782",
"0.7290782",
"0.7290782",
"0.7290782",
"0.72613734",
"0.722498",
"0.7219712",
"0.71763957",... | 0.68260574 | 56 |
Backtest the model against the given features. Output a DataFrame that | def backtest(features: str, model: str, output: str):
# Load model from data store
with open(model, "rb") as f:
mdl = joblib.load(f)
# Load feature data. In a true pipeline there would be a split between
# training and testing data, but this was omitted for clarity.
#
# ** Never run a r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_forest_test_Data(strat_test_set):\n logging.info(\"Random forest.....\")\n X_test = strat_test_set.drop(\"median_house_value\", axis=1)\n y_test = strat_test_set[\"median_house_value\"].copy()\n X_test_num = X_test.drop(\"ocean_proximity\", axis=1)\n imputer = SimpleImputer(strategy=\"med... | [
"0.6345319",
"0.63277817",
"0.6277333",
"0.6158429",
"0.61521703",
"0.61427313",
"0.6100492",
"0.6037001",
"0.6009598",
"0.60037315",
"0.59914774",
"0.5963398",
"0.59282446",
"0.5915352",
"0.5909637",
"0.5890372",
"0.588733",
"0.5859227",
"0.5789517",
"0.57549775",
"0.5742304... | 0.7583552 | 0 |
Plot the true positive rate vs false positive rate for each model. | def analyze(results: str):
# Initialize plot
co.nb.matplotlib_inline()
plt.figure(figsize=(5, 4), linewidth=1)
for model in os.listdir(results):
# For each model, read in the results DataFrame
df = pd.read_csv(os.path.join(results, model))
# Compute statistics
auc = roc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_tp_rate(tp_rate):\r\n # Calculate the means for plotting\r\n means = pd.DataFrame(tp_rate.groupby(\"Temperature [°C]\").mean()[\"True Positive Rate [%]\"]).reset_index()\r\n ax = sns.swarmplot(y='True Positive Rate [%]',x=\"Temperature [°C]\", data=means, palette=\"magma_r\", edgecolor=\"black\",... | [
"0.63636893",
"0.61657566",
"0.6158322",
"0.61474645",
"0.6131326",
"0.61257786",
"0.60458773",
"0.59943515",
"0.59793687",
"0.59292173",
"0.5920243",
"0.58957326",
"0.5851733",
"0.5817033",
"0.5779324",
"0.57768863",
"0.57759243",
"0.57722485",
"0.5761979",
"0.57581687",
"0.... | 0.0 | -1 |
The translation table from PIF field to MDF field The dictionary contains multiple levels. The first level is the "block" in the corresponding MDF output. The second level is the name of the field in a flattened PIF and the value of that key is the name of the field in the MDF block and a function that translates the P... | def get_translations(self) -> Dict[str, Dict[str, Tuple[str, Type]]]:
return {
'material': {'elemental_proportion': ('elemental_proportions', dict)},
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def field_mapping(self):\n fields = self.fields\n if self.target_field is not None:\n del fields[self.target_field.get('name')]\n field_labels = list(self.fields.keys())\n\n field_mapping = {\n name: (\n field_labels.index(name),\n lambda value, e=e: self.parse_type(value, e)\n ... | [
"0.5871717",
"0.5462577",
"0.543782",
"0.536871",
"0.5336033",
"0.53021574",
"0.5231751",
"0.51640385",
"0.50003684",
"0.49734783",
"0.492218",
"0.4920944",
"0.48893556",
"0.4860132",
"0.4791568",
"0.47843945",
"0.4777327",
"0.47663555",
"0.47152624",
"0.47021145",
"0.4693048... | 0.5236178 | 6 |
Push an item onto the stack. No return value. | def push(self, item):
self.stack.append(item) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push(self, item):\r\n self.stack.insert(0, item)",
"def push(self, item):\n\n self._stack.append(item)",
"def push(self, item):\n self._items.append(item)\n # This operation increments the number of items\n # in the stack, we need to update the count variable\n sel... | [
"0.90451604",
"0.8828648",
"0.84492636",
"0.8447282",
"0.8417025",
"0.8344185",
"0.818139",
"0.81461024",
"0.8125367",
"0.8123161",
"0.8120266",
"0.8086752",
"0.80313486",
"0.8019047",
"0.7989268",
"0.7989268",
"0.79771405",
"0.79666865",
"0.79666865",
"0.79666865",
"0.796668... | 0.90169555 | 2 |
Pop the topmost item off the stack. Returns the item. | def pop(self):
item = self.stack[-1]
self.stack = self.stack[:-1]
return item | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pop(self):\n try:\n if self.size() > 0:\n top = self.top()\n self.items.pop()\n return top\n else:\n raise IndexError('Cannot pop item, stack is empty.')\n except IndexError as err:\n print(err)\n ... | [
"0.9038657",
"0.89699066",
"0.8646669",
"0.8436965",
"0.8425731",
"0.8394855",
"0.8379378",
"0.83787584",
"0.8376376",
"0.836779",
"0.8341289",
"0.83400613",
"0.83147097",
"0.8313943",
"0.8297329",
"0.8291556",
"0.8232232",
"0.82071257",
"0.82069063",
"0.81836283",
"0.8150139... | 0.9046111 | 0 |
Peek at the topmost item of the stack without popping. Returns the item, or None on underflow. | def peek(self):
try:
return self.stack[-1]
except IndexError:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def peek(self):\n if self.isEmpty():\n raise Exception(\"Stack underflow\") # Nothing to peek at\n return self.first.Item # most recently added item",
"def peek(self):\n if not self.is_empty():\n return self._stack_items[-1]\n else:\n raise StackException('Peek oper... | [
"0.7854999",
"0.7848019",
"0.77432376",
"0.7725692",
"0.7712781",
"0.7672322",
"0.76620185",
"0.7641305",
"0.7610284",
"0.76081336",
"0.7587791",
"0.7587791",
"0.75744694",
"0.7550017",
"0.75288725",
"0.7514343",
"0.75083995",
"0.7495166",
"0.74850506",
"0.7464874",
"0.745950... | 0.80332464 | 0 |
Returns whether or not the stack is empty. | def is_empty(self):
return len(self.stack) == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_empty(self):\n return len(self.the_stack) == 0",
"def empty(self) -> bool:\n return len(self.stack) == 0",
"def empty(self):\n return len(self.stack) == 0",
"def empty(self):\n return len(self.stack) == 0",
"def empty(self):\r\n return len(self.stack) == 0",
"def... | [
"0.92969453",
"0.90845764",
"0.9067046",
"0.9067046",
"0.9049475",
"0.9040509",
"0.90028155",
"0.8970693",
"0.8958459",
"0.894402",
"0.8918213",
"0.89048815",
"0.88327855",
"0.8823499",
"0.8811676",
"0.87955076",
"0.87955076",
"0.8791064",
"0.87125903",
"0.8611502",
"0.859849... | 0.92230463 | 1 |
Return number of items on the stack. | def __len__(self):
return len(self.stack) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def size(self): #returns the size or number of items in the stack\n if self.is_empty():\n return 0\n else:\n return self.num_items",
"def size(self):\n return self.N # Number of items in the stack",
"def size(self):\n return len(self._stack_items... | [
"0.87046397",
"0.8648053",
"0.8380214",
"0.80204916",
"0.80051744",
"0.79051936",
"0.79051936",
"0.7672555",
"0.7672555",
"0.7635527",
"0.76000184",
"0.75771415",
"0.7474788",
"0.73247254",
"0.7290252",
"0.725836",
"0.7244049",
"0.722061",
"0.72152984",
"0.7203107",
"0.710687... | 0.7670148 | 9 |
String representation of the stack. | def __repr__(self):
return str(self.stack) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getStackString(self):\n return \"\".join(self.stack[:0:-1])",
"def __repr__(self):\n return str(self._stack_items)",
"def __str__(self):\n return \"The stack contains: \" + str(self.the_stack)",
"def __str__(self):\n data_str = [str(i) for i in self._data]\n return \"ST... | [
"0.85406256",
"0.8412833",
"0.8216093",
"0.8198461",
"0.8198461",
"0.818666",
"0.8168011",
"0.81232345",
"0.7814737",
"0.7814737",
"0.76956904",
"0.76956904",
"0.76956904",
"0.76956904",
"0.7628415",
"0.7368872",
"0.715802",
"0.7069953",
"0.67405593",
"0.67273206",
"0.6695258... | 0.87551796 | 0 |
Validates that the string is a correct infix expression. Also, replaces unary minus operators with a 'u'. Returns a valid, tokenized string on success; raises ExpressionError if the input is erroneous. | def validate(string):
tokens = string.split()
# Remembers if the previous token was an operator
opflag = True
## Highly inefficient validity checking begins here ##
# List of operators as they would appear in the infix expression
operators = ['+', '-', '*', '/', '^', 'sqrt']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_infix(string):\n return postfix(infix_to_postfix(string))",
"def parse_infix(input: str) -> Node:\n parsed = ParsedString(input).tokenize()\n ans = parse_e(parsed)\n return ans",
"def infix_to_postfix(string):\n \n # Validate and tokenize the string\n tokens = validate(string)... | [
"0.67217284",
"0.66280156",
"0.66256684",
"0.6390146",
"0.63846296",
"0.6309319",
"0.63021815",
"0.6235218",
"0.61009157",
"0.60545176",
"0.60317606",
"0.60182995",
"0.5994529",
"0.5970374",
"0.59688133",
"0.5967874",
"0.59608865",
"0.59466004",
"0.5895652",
"0.5879398",
"0.5... | 0.75027424 | 0 |
Function to convert a single input infix string to postfix notation. It is assumed that tokens in the string are separated by whitespace. Returns the postfix expression on success; raises ExpressionError if the input expression is erroneous. | def infix_to_postfix(string):
# Validate and tokenize the string
tokens = validate(string)
# Initialize the stack
s = Stack()
# Ready the final postfix expression
postfix = ''
# List of operators that have to be handled
operators = ['+', '-', '*', '/', '^', 'sqrt', 'u-', ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def infix_to_postfix(string):\n tokenlist = string.split()\n output = []\n stack = create_stack()\n for token in tokenlist:\n if token == '(':\n stack.push(token)\n elif token == ')':\n toptoken = stack.pop()\n while toptoken != '(':\n outpu... | [
"0.82886326",
"0.8267429",
"0.8116412",
"0.80532104",
"0.79317456",
"0.7838054",
"0.78235006",
"0.7815421",
"0.77934223",
"0.7734474",
"0.7727248",
"0.7694409",
"0.7610501",
"0.7605938",
"0.75745595",
"0.75698835",
"0.74956685",
"0.7477651",
"0.7460197",
"0.7417434",
"0.73968... | 0.8161909 | 2 |
Take in as input a list The function multiply_list() will multiply all of the numbers in the list. If any item in the list is invalid return False. | def multiply_list(input):
result = 1
#if there is no numbers in list return False
if not input:
return False
#if the list contains strings or 0 return False
else:
for x in input:
if type(x) == str or x == 0:
return False
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_mul():\n l = [1, 2, 3, 4]\n assert s7.mul(*l) == 1 * 2 * 3 * 4\n assert s7.mul(10, 20) == 200\n assert s7.mul(1.0, 2.0, 100.0) == 200.0",
"def multiply_list(lst):\n if lst == []:\n return 1\n else:\n return lst[0] * multiply_list(lst[1:])",
"def listMul(l):\n \n #... | [
"0.6760711",
"0.6697329",
"0.64938724",
"0.64613146",
"0.63816386",
"0.6319394",
"0.63060385",
"0.6242373",
"0.62085116",
"0.6153073",
"0.6107456",
"0.6038584",
"0.602507",
"0.600547",
"0.5875371",
"0.5868004",
"0.5868004",
"0.58225316",
"0.5819411",
"0.5819411",
"0.579956",
... | 0.80064815 | 0 |
Parse query param and take validated names | def parse_query_param(self, sideload_parameter):
self.relations_to_sideload = set(sideload_parameter.split(",")) & set(
self._sideloadable_fields.keys()
)
return self.relations_to_sideload | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_params(self, params):\r\n if params[0] == \":\":\r\n params = [params[1:]]\r\n else:\r\n params = params.split(\" :\", 1)\r\n if len(params) == 1:\r\n last_arg = None\r\n else:\r\n last_arg = params[1]\r\n ... | [
"0.6670326",
"0.6389083",
"0.6330131",
"0.62615776",
"0.6193709",
"0.61634845",
"0.60988027",
"0.60571504",
"0.6051584",
"0.6048205",
"0.60453707",
"0.5957845",
"0.5956611",
"0.59373385",
"0.58949566",
"0.589364",
"0.58637",
"0.58585805",
"0.5825855",
"0.58050853",
"0.5799345... | 0.0 | -1 |
Returns config for tf.session | def get_config():
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth=True
return config | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _config_session(self):\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n config.gpu_options.visible_device_list = str(self.device_num)\n return tf.Session(config=config)",
"def get_config():\n config = tf.ConfigProto(allow_soft_placement=True)\n config.g... | [
"0.7999958",
"0.7535755",
"0.72901034",
"0.7119736",
"0.6969369",
"0.6781894",
"0.65969217",
"0.64716965",
"0.6348045",
"0.6322737",
"0.631881",
"0.62444156",
"0.6241746",
"0.6201172",
"0.61908853",
"0.61729336",
"0.6153548",
"0.6133191",
"0.6101502",
"0.6080999",
"0.6076644"... | 0.75894344 | 1 |
Load checkpoint from the ckpt_dir (if unspecified, this is train dir) and restore it to saver and sess, waiting 10 secs in the case of failure. Also returns checkpoint name. | def load_ckpt(saver, sess, ckpt_dir="train"):
while True:
try:
latest_filename = "checkpoint_best" if ckpt_dir=="eval" else None
ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)
ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest_filename)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_ckpt(saver, sess, ckpt_dir=\"train\"):\n while True:\n try:\n latest_filename = \"checkpoint_best\" if ckpt_dir == \"eval\" else None\n ckpt_dir = os.path.join(FLAGS.log_root, ckpt_dir)\n ckpt_state = tf.train.get_checkpoint_state(ckpt_dir, latest_filename=latest... | [
"0.8223236",
"0.78587455",
"0.77297467",
"0.7691358",
"0.7526772",
"0.7455489",
"0.7162959",
"0.7072553",
"0.7010319",
"0.69536954",
"0.6937316",
"0.6916923",
"0.68400085",
"0.6833414",
"0.6830013",
"0.68147194",
"0.6802229",
"0.67763555",
"0.67456764",
"0.6729885",
"0.669250... | 0.8222074 | 1 |
Compute the log of the sum of exponentials of input elements. | def logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False):
if b is not None:
a, b = np.broadcast_arrays(a, b)
if np.any(b == 0):
a = a + 0. # promote to at least float
a[b == 0] = -np.inf
a_max = np.amax(a, axis=axis, keepdims=True)
if a_max.ndim > 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_sum_exp(x):\n log_reduce_sum = P.ReduceSum()\n log = P.Log()\n exp = P.Exp()\n x_max = max(x.data)\n return log(log_reduce_sum(exp(x - x_max), 1)) + x_max",
"def log_sum_exp(self, x):\n b = numpy.max(x[(x<sys.maxsize)]) # ignore inf values\n\n s = b + numpy.log(numpy.sum(nu... | [
"0.8021816",
"0.7973607",
"0.79658216",
"0.7952592",
"0.79182106",
"0.79182106",
"0.7760167",
"0.7711429",
"0.76088345",
"0.7591885",
"0.7590158",
"0.75868016",
"0.7528201",
"0.73942685",
"0.7390474",
"0.73903686",
"0.7328685",
"0.72765005",
"0.72420055",
"0.72006994",
"0.720... | 0.6233052 | 64 |
Defines an initializer for the Xavier distribution. Specifically, the output should be sampled uniformly from [epsilon, epsilon] where epsilon = sqrt(6) / e.g., if shape = (2, 3), epsilon = sqrt(6 / (2 + 3)) This function will be used as a variable initializer. | def xavier_weight_init(shape):
lim = np.sqrt(6. / sum(shape))
out = np.random.uniform(-lim, lim, shape)
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def XavierInit(self):\n\n raw_std = (2 / (self.num_input + self.num_output))**0.5\n if 'relu' == self.act_function:\n init_std = raw_std * (2**0.5)\n elif 'sigmoid' == self.act_function:\n init_std = raw_std\n else:\n init_std = raw_std # * 4\n\n ... | [
"0.713179",
"0.694579",
"0.6937731",
"0.6779628",
"0.6648162",
"0.6642838",
"0.6642838",
"0.65998244",
"0.6546982",
"0.6546982",
"0.6505124",
"0.64154625",
"0.64006364",
"0.6392973",
"0.6384507",
"0.63683206",
"0.62566024",
"0.622814",
"0.6173743",
"0.6173743",
"0.61022276",
... | 0.6419569 | 11 |
Constructs word2idx dict from Glove pretrained embeddings and writes it to word2idx.txt file in data directory of the project. | def construct_dict(self):
i = 0
self.word2idx = dict()
fi = open(self.config.word_vec_fi_glove, 'r')
for line in fi:
self.word2idx[line.split(" ")[0]] = i
i += 1
self.vocab_size = i
self.write_dict()
fi.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_idx2word():\n idx2word = {}\n d = train_data.shared['word2idx']\n for word, idx in d.items():\n print(word)\n idx2word[idx] = word\n if config.use_glove_for_unk:\n d2 = train_data.shared['new_word2idx']\n for word, idx in d2.items():\... | [
"0.7383777",
"0.71597224",
"0.6914332",
"0.6700071",
"0.66937166",
"0.6675268",
"0.6658766",
"0.6642013",
"0.65650064",
"0.6545669",
"0.6526046",
"0.6516871",
"0.65157616",
"0.6507262",
"0.6481229",
"0.6472119",
"0.6454776",
"0.6420657",
"0.6418853",
"0.64167535",
"0.64134",
... | 0.7407205 | 0 |
Creates embedding matrix from input file and writes to binary file Considering numpy rowmajor order stores word vector rowwise. | def construct_embedding(self):
i = 0
self.load_dicts()
embedding_shape = (max(self.word2idx.values()) + 1,
self.embedding_size)
self.embedding = np.zeros(embedding_shape)
with open(self.config.word_vec_fi_glove, 'r') as fi:
for line in fi:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_embedding_matrix(filepath, word_index, embedding_dim):\n vocab_size = len(word_index) + 1 # Adding again 1 because of reserved 0 index\n embedding_matrix = np.zeros((vocab_size, embedding_dim))\n\n with open(filepath) as f:\n for line in f:\n word, *vector = line.split()\n ... | [
"0.71148777",
"0.6811717",
"0.66535574",
"0.6645278",
"0.6578764",
"0.65542287",
"0.65381473",
"0.6517769",
"0.65073204",
"0.6506877",
"0.6471639",
"0.64159757",
"0.6356227",
"0.6192997",
"0.6183885",
"0.61746114",
"0.6166684",
"0.61592853",
"0.6129667",
"0.6122645",
"0.60884... | 0.69728744 | 1 |
Helper function to add new token to self.word2idx and embedding to self.embeddings | def add_embedding(self, token, embedding):
self.word2idx[token] = self.vocab_size
self.vocab_size += 1
self.embedding = np.vstack((self.embedding, embedding)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_to_dict(self, tokens):\n# TODO: ?add normalization of a token?\n for token in tokens:\n if self.embedding_words and (token not in self.embedding_words):\n continue\n self.freq[token] += 1\n if token not in self.tok2ind:\n index = len(sel... | [
"0.6996325",
"0.6894177",
"0.6658061",
"0.65426093",
"0.6435544",
"0.6401983",
"0.6349686",
"0.63282156",
"0.6324981",
"0.6320355",
"0.6309303",
"0.6281128",
"0.6220901",
"0.62193155",
"0.61735755",
"0.61483675",
"0.6124767",
"0.61123055",
"0.61009485",
"0.6099443",
"0.605398... | 0.77013934 | 0 |
Averages word vectors that occur in both glove and paragram and creates union of two embeddings | def add_paragram(self):
num_new_words = 720000
new_embeddings = np.empty((num_new_words, self.embedding_size))
concat_emb = np.zeros((2, self.embedding_size))
new_word2idx = dict()
new_words_count = 0
self.load_all()
fi = open(self.config.word_vec_fi_paragram, "r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def word_averaging(wv, words):\n all_words, mean = set(), []\n \n for word in words:\n if isinstance(word, np.ndarray):\n mean.append(word)\n elif word in wv.vocab:\n mean.append(wv.vectors_norm[wv.vocab[word].index])\n all_words.add(wv.vocab[word].index)\n\n... | [
"0.70063585",
"0.65691555",
"0.655092",
"0.65492266",
"0.64220226",
"0.63821906",
"0.6352523",
"0.63278",
"0.6304237",
"0.63029516",
"0.6285422",
"0.6161037",
"0.61082405",
"0.60827434",
"0.6066551",
"0.605643",
"0.60406655",
"0.6036333",
"0.6034815",
"0.60307336",
"0.6029545... | 0.68158096 | 1 |
Adds unknown token to word2idx dictionary and computes vector as an average of random sample as suggested by Pennington | def add_unknown_token(self):
self.load_all()
sample_idxs = np.random.randint(0, self.embedding.shape[0],
self.config.embedding_sample_size)
unknown_vector = np.mean(self.embedding[sample_idxs, :], axis=0)
self.add_embedding(self.config.unknown_tok... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_average_vec(tokens_list, vector, generate_missing=False, k=300):\r\n if len(tokens_list)<1:\r\n return np.zeros(k)\r\n \r\n if generate_missing:\r\n vectorized = [vector[word] if word in vector else np.random.rand(k) for word in tokens_list]\r\n else:\r\n vectorized = [vect... | [
"0.6838759",
"0.65651834",
"0.6410613",
"0.6106581",
"0.6086365",
"0.6085573",
"0.6080259",
"0.6050455",
"0.6035664",
"0.5996665",
"0.59961116",
"0.5990178",
"0.5940137",
"0.5930811",
"0.59277254",
"0.5890196",
"0.588386",
"0.58830386",
"0.58822876",
"0.58559144",
"0.5849721"... | 0.69098496 | 0 |
Replaces each Quora question with indexes corressponding to respective position of tokens in embedding matrix. If include_unknown is true, then replaces with corressponding index, ignores otherwise. | def sentences_2_idxs(self):
fo_pos = open(self.config.parsed_train_file_pos, 'w')
fo_neg = open(self.config.parsed_train_file_neg, 'w')
self.load_dicts()
labels = pd.read_csv(self.config.train_file, usecols=["target"])
labels = list(labels.values[:, 0])
questions = pd.re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def embed(raw_seq, index_dict):\n return np.asarray([index_dict[word.lower()]\n if word.lower() in index_dict\n else index_dict[OOV_TOKEN] for word in raw_seq])",
"def convert_questions_to_features(examples, tokenizer, max_query_length=None):\n\n unique_id = 1000... | [
"0.5196209",
"0.508824",
"0.50696385",
"0.50494385",
"0.50279325",
"0.49846712",
"0.4941945",
"0.493053",
"0.49194095",
"0.49090177",
"0.4737878",
"0.47329834",
"0.47198913",
"0.46659964",
"0.46623522",
"0.46447614",
"0.46400312",
"0.46255264",
"0.4593311",
"0.4577011",
"0.45... | 0.48166406 | 10 |
Replaces each Quora question with indexes corressponding to respective position of tokens in embedding matrix. If include_unknown is true, then replaces with corressponding index, ignores otherwise. | def predict_sentences_2_idxs(self):
fo = open(self.config.parsed_predict_file, 'w')
self.load_dicts()
questions = pd.read_csv(self.config.predict_file,
usecols=["question_text"], index_col=False)
unk_idx = self.word2idx[self.config.unknown_token]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def embed(raw_seq, index_dict):\n return np.asarray([index_dict[word.lower()]\n if word.lower() in index_dict\n else index_dict[OOV_TOKEN] for word in raw_seq])",
"def convert_questions_to_features(examples, tokenizer, max_query_length=None):\n\n unique_id = 1000... | [
"0.5195214",
"0.50893027",
"0.5070433",
"0.50482714",
"0.49829122",
"0.4942411",
"0.49302742",
"0.49184462",
"0.49094704",
"0.4815408",
"0.47388384",
"0.47334188",
"0.47175914",
"0.4665474",
"0.46608728",
"0.4643911",
"0.46391892",
"0.46259004",
"0.4593503",
"0.45771012",
"0.... | 0.502763 | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.