= self.Code_segment.__len__()):\\r\\n self.State = \\\"RTE\\\"\\r\\n return False\\r\\n else:\\r\\n return False\\r\\n else:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def BlockReadBit(self, request_iterator, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def testHasReturns(self):\\n concise = build_code([], [], [], concise=True)\\n full = build_code([], [], [], concise=False)\\n self.assertNotIn('return', concise)\\n self.assertIn('return', full)\",\n \"def SymbolizerFilter(input_file, build_ids_files):\\n\\n symbolizer_proc = RunSymbolizer(input_file, subprocess.PIPE, build_ids_files)\\n\\n while True:\\n # TODO(chonggu): Switch to encoding='utf-8' once we drop Python 2\\n # support.\\n line = symbolizer_proc.stdout.readline().decode('utf-8')\\n if not line:\\n break\\n\\n # Skip spam emitted by the symbolizer that obscures the symbolized output.\\n # TODO(https://crbug.com/1069446): Fix the symbolizer and remove this.\\n if '[[[ELF ' in line:\\n continue\\n\\n yield line\\n\\n symbolizer_proc.wait()\",\n \"def unknown_visit(self, node: Node) -> None:\\n\\n logger.warning(\\\"Handouts hit unexpected node: %s\\\", node)\\n raise SkipNode\",\n \"def bf16_guard():\\n with framework.name_scope(prefix=_bf16_guard_pattern):\\n yield\",\n \"def gen_epilogue(self, frame): # pragma: no cover\\n raise NotImplementedError(\\\"Implement this!\\\")\",\n \"def test_py3_return():\\n\\n @do\\n def py3_generator_with_return():\\n yield Effect(Constant(1))\\n return 2 # noqa\\n\\n eff = py3_generator_with_return()\\n assert perf(eff) == 2\",\n \"def get_statements_without_agents(db, prefix, *other_stmt_clauses, **kwargs):\\n num_per_yield = kwargs.pop('num_per_yield', 100)\\n verbose = kwargs.pop('verbose', False)\\n\\n # Get the objects for either raw or pa statements.\\n stmt_tbl_obj = db.tables[prefix + '_statements']\\n agent_tbl_obj = db.tables[prefix + '_agents']\\n\\n # Build a dict mapping stmt UUIDs to statement IDs\\n logger.info(\\\"Getting %s that lack %s in the database.\\\"\\n % (stmt_tbl_obj.__tablename__, agent_tbl_obj.__tablename__))\\n if prefix == 'pa':\\n stmts_w_agents_q = db.filter_query(\\n stmt_tbl_obj,\\n stmt_tbl_obj.mk_hash == agent_tbl_obj.stmt_mk_hash\\n )\\n elif prefix == 'raw':\\n stmts_w_agents_q = db.filter_query(\\n stmt_tbl_obj,\\n stmt_tbl_obj.id == agent_tbl_obj.stmt_id\\n )\\n else:\\n raise IndraDatabaseError(\\\"Unrecognized prefix: %s.\\\" % prefix)\\n stmts_wo_agents_q = (db.filter_query(stmt_tbl_obj, *other_stmt_clauses)\\n .except_(stmts_w_agents_q))\\n\\n # Start printing some data\\n if verbose:\\n num_stmts = stmts_wo_agents_q.count()\\n print(\\\"Adding agents for %d statements.\\\" % num_stmts)\\n else:\\n num_stmts = None\\n\\n # Get the iterator\\n return stmts_wo_agents_q.yield_per(num_per_yield), num_stmts\",\n \"def analyze(self):\\n for filepath, code in self.code_dict.items():\\n for result in self.analyze_file(filepath, code):\\n yield result\\n self.clear_file_lines_cache()\",\n \"def collect_free_continues(self, *args):\\n return _ida_hexrays.cinsn_t_collect_free_continues(self, *args)\",\n \"def test_76_continue(self):\\n\\t\\tinput = \\\"\\\"\\\"procedure main(); var x:integer;\\n\\t\\tbegin while(true)do begin\\n\\t\\twith x:integer; do with x:real; do begin\\n\\t\\t\\tif (x>0) then continue;\\n\\t\\t\\twith x:integer; do continue;\\n\\t\\tend{with} end{with} foo(); end\\\"\\\"\\\"\\n\\t\\texpect = \\\"Undeclared Procedure: foo\\\"\\n\\t\\tself.assertTrue(TestChecker.test(input,expect,476))\",\n \"def next(self):\\n symbol = None\\n while symbol is None:\\n if self.index == len(self.brainfuck_code):\\n return Symbol.PROGRAM_END\\n symbol = self.symbol_dict.get(self.brainfuck_code[self.index])\\n self.index += 1\\n\\n return symbol\",\n \"def First():\\n return CheckForError(lib.Generators_Get_First())\",\n \"def _skip(app, what, name, obj, skip, options):\\n if name.startswith(\\\"_\\\") and name not in \\\\\\n [\\\"__qualname__\\\",\\n \\\"__module__\\\",\\n \\\"__dict__\\\",\\n \\\"__doc__\\\",\\n \\\"__weakref__\\\",\\n ]:\\n return False\\n return skip\",\n \"def test_77_continue(self):\\n\\t\\tinput = \\\"\\\"\\\"procedure main(); var x:integer;\\n\\t\\tbegin while(true)do begin\\n\\t\\twith x:integer; do with x:real; do begin\\n\\t\\t\\tif (x>0) then continue;\\n\\t\\t\\twith x:integer; do if (x=0) then continue; else return;\\n\\t\\tend{with} end{while} foo(); end\\\"\\\"\\\"\\n\\t\\texpect = \\\"Undeclared Procedure: foo\\\"\\n\\t\\tself.assertTrue(TestChecker.test(input,expect,477))\",\n \"def run(self):\\n while True:\\n instruction = self.bytecode.code[self.ip]\\n\\n if instruction == OpCode.PRINT:\\n self._run_print()\\n\\n elif instruction == OpCode.APPLY:\\n self._run_apply()\\n\\n else:\\n raise RuntimeError(\\\"Unknown instruction found at offset <\\\" + str(self.ip) + \\\"> on line <\\\" + str(self.bytecode.lines[self.ip]) + \\\">.\\\")\\n\\n # If the instruction pointer points beyond the bytecode boundaries, we terminate execution\\n if self.ip == self.bytecode.length():\\n break\",\n \"def __next__(self):\\n\\t\\treturn next()\",\n \"def test_68_function_not_return(self):\\n\\t\\tinput = \\\"\\\"\\\"procedure main(); var x:integer;\\n\\t\\tbegin x:=fu(); end\\n\\t\\tfunction fu():integer;\\n\\t\\tbegin with a:boolean; do\\n\\t\\twith a:integer; do for a:=-5 to 5 do return 1;end\\\"\\\"\\\"\\n\\t\\texpect = \\\"Function fu Not Return\\\"\\n\\t\\tself.assertTrue(TestChecker.test(input,expect,468))\",\n \"def test_post_codegen_error_query(self):\\n with tempfile.TemporaryDirectory() as tmpdirname:\\n translator = AstUprootTranslator()\\n with pytest.raises(GenerateCodeException):\\n translator.generate_code(\\\"\\\", cache_path=tmpdirname)\",\n \"def gen_continue(self, stmt: statements.Continue) -> None:\\n # block = self.get_label_block(stmt.label)\\n if self.continue_block_stack:\\n block = self.continue_block_stack[-1]\\n self.builder.emit_jump(block)\\n else:\\n self.error(\\\"Cannot continue here!\\\", stmt)\\n new_block = self.builder.new_block()\\n self.builder.set_block(new_block)\",\n \"def dummy_elif(dummy_code_block):\\n return make_dummy_elif()\",\n \"def dispatch_exception(self, frame, arg):\\n if self.stop_here(frame):\\n # When stepping with next/until/return in a generator frame, skip\\n # the internal StopIteration exception (with no traceback)\\n # triggered by a subiterator run with the 'yield from' statement.\\n if not (frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS\\n and arg[0] is StopIteration and arg[2] is None):\\n self.user_exception(frame, arg)\\n if self.quitting: raise BdbQuit\\n # Stop at the StopIteration or GeneratorExit exception when the user\\n # has set stopframe in a generator by issuing a return command, or a\\n # next/until command at the last statement in the generator before the\\n # exception.\\n elif (self.stopframe and frame is not self.stopframe\\n and self.stopframe.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS\\n and arg[0] in (StopIteration, GeneratorExit)):\\n self.user_exception(frame, arg)\\n if self.quitting: raise BdbQuit\\n\\n return self.trace_dispatch\",\n \"def consCheck(self):\\n if self._firstInstr is None or self._lastInstr is None:\\n assert self._firstInstr is None\\n assert self._lastInstr is None\\n return\\n assert self._firstInstr.prev is None\\n assert self._lastInstr.next is None\\n fast = self._firstInstr\\n slow = self._firstInstr\\n odd = False\\n while True:\\n assert isinstance(fast, ICode)\\n assert fast.owner is self\\n if fast.next is None:\\n assert fast is self._lastInstr\\n break\\n assert fast.next.prev is fast\\n fast = fast.next\\n if odd:\\n slow = slow.next\\n odd = not odd\\n assert slow is not fast\",\n \"def do_code_lookup(self, arg):\\n cmd_call = 'code_lookup'\\n _v1, _v2 = self.validate_args(arg, cmd_call)\\n setup = {'file': _v1, 'args': _v2}\\n return self.run_cmd(setup, cmd_call, True)\",\n \"def skip(self):\\r\\n length = self.next_byte()\\r\\n while length != b\\\"\\\\x00\\\" and length:\\r\\n self.next_bytes(parse_int(length, 'big'))\\r\\n length = self.next_byte()\",\n \"def __next__(self):\\n raise NotImplementedError()\",\n \"def is_code_ended(self) -> bool:\",\n \"def get_code(self, parent, modname, fqname):\\n\\n if self.verbose:\\n print >> sys.stderr, '-'*78\\n print >> sys.stderr, \\\"Importing %s from the network ...\\\" % fqname\\n print >> sys.stderr, '-'*78\\n\\n\\n out = None\\n for baseurl in self.path:\\n\\n proto_url = '/'.join([baseurl] + fqname.split('.'))\\n\\n\\n # Is this a package?\\n # ==================\\n # If so, we want to look for __init__.py.\\n\\n is_package = self.download(proto_url + '/')\\n if is_package:\\n proto_url += '/__init__'\\n\\n\\n # Try to find some code.\\n # ======================\\n\\n for suffix in imp.get_suffixes():\\n url = proto_url + suffix[0]\\n fp = self.download(url)\\n if fp is not None:\\n\\n # Prepare elements for imputil.Importer.\\n # ======================================\\n\\n mod = imp.load_module(modname, fp, fp.name, suffix)\\n out = (is_package, mod, {})\\n break\\n\\n if out is not None:\\n break\\n\\n return out\",\n \"def stop(x=None):\\n raise StopIteration(x)\",\n \"def __next__(self):\\n\\n\\t\\ttry:\\n\\t\\t\\treturn next(self._packages_iterator)\\n\\t\\texcept StopIteration:\\n\\t\\t\\tself._pacakges_iterator = None\\n\\t\\t\\traise\",\n \"def _scan_bytecode(\\n self, module, module_code_object, is_scanning_imports):\\n level = None\\n fromlist = None\\n\\n # 'deque' is a list-like container with fast appends, pops on\\n # either end, and automatically discarding elements too much.\\n prev_insts = deque(maxlen=2)\\n for inst in util.iterate_instructions(module_code_object):\\n if not inst:\\n continue\\n # If this is an import statement originating from this module,\\n # parse this import.\\n #\\n # Note that the related \\\"IMPORT_FROM\\\" opcode need *NOT* be parsed.\\n # \\\"IMPORT_NAME\\\" suffices. For further details, see\\n # http://probablyprogramming.com/2008/04/14/python-import_name\\n if inst.opname == 'IMPORT_NAME':\\n # If this method is ignoring import statements, skip to the\\n # next opcode.\\n if not is_scanning_imports:\\n continue\\n\\n assert prev_insts[-2].opname == 'LOAD_CONST'\\n assert prev_insts[-1].opname == 'LOAD_CONST'\\n\\n # Python >=2.5: LOAD_CONST flags, LOAD_CONST names, IMPORT_NAME name\\n level = prev_insts[-2].argval\\n fromlist = prev_insts[-1].argval\\n\\n assert fromlist is None or type(fromlist) is tuple\\n target_module_partname = inst.argval\\n\\n #FIXME: The exact same logic appears in _collect_import(),\\n #which isn't particularly helpful. Instead, defer this logic\\n #until later by:\\n #\\n #* Refactor the \\\"_deferred_imports\\\" list to contain 2-tuples\\n # \\\"(_safe_import_hook_args, _safe_import_hook_kwargs)\\\" rather\\n # than 3-tuples \\\"(have_star, _safe_import_hook_args,\\n # _safe_import_hook_kwargs)\\\".\\n #* Stop prepending these tuples by a \\\"have_star\\\" boolean both\\n # here, in _collect_import(), and in _process_imports().\\n #* Shift the logic below to _process_imports().\\n #* Remove the same logic from _collect_import().\\n have_star = False\\n if fromlist is not None:\\n fromlist = uniq(fromlist)\\n if '*' in fromlist:\\n fromlist.remove('*')\\n have_star = True\\n\\n # Record this import as originating from this module for\\n # subsequent handling by the _process_imports() method.\\n module._deferred_imports.append((\\n have_star,\\n (target_module_partname, module, fromlist, level),\\n {}\\n ))\\n\\n elif inst.opname in ('STORE_NAME', 'STORE_GLOBAL'):\\n # If this is the declaration of a global attribute (e.g.,\\n # class, variable) in this module, store this declaration for\\n # subsequent lookup. See method docstring for further details.\\n #\\n # Global attributes are usually irrelevant to import parsing, but\\n # remain the only means of distinguishing erroneous non-ignorable\\n # attempts to import non-existent submodules of a package from\\n # successful ignorable attempts to import existing global\\n # attributes of a package's \\\"__init__\\\" submodule (e.g., the \\\"bar\\\"\\n # in \\\"from foo import bar\\\", which is either a non-ignorable\\n # submodule of \\\"foo\\\" or an ignorable global attribute of\\n # \\\"foo.__init__\\\").\\n name = inst.argval\\n module.add_global_attr(name)\\n\\n elif inst.opname in ('DELETE_NAME', 'DELETE_GLOBAL'):\\n # If this is the undeclaration of a previously declared global\\n # attribute (e.g., class, variable) in this module, remove that\\n # declaration to prevent subsequent lookup. See method docstring\\n # for further details.\\n name = inst.argval\\n module.remove_global_attr_if_found(name)\\n\\n prev_insts.append(inst)\",\n \"def search_next(self):\\n self._raise_not_supported()\",\n \"def check_throw():\\n while True:\\n try:\\n yield\\n except ValueError:\\n pass\",\n \"def test_yield_in_const_conditional_true():\\n if True:\\n print((yield 1))\",\n \"def nocoverage(func):\\n if hasattr(func, 'uncovered'):\\n return func\\n func.uncovered = True\\n\\n def not_covered(*args, **kwargs):\\n with pause_trace():\\n return func(*args, **kwargs)\\n not_covered.uncovered = True\\n return not_covered\",\n \"def generate(self, **kwargs):\\n yield NotImplementedError\",\n \"def execute(code):\\r\\n\\r\\n ip = 0\\r\\n acc = 0\\r\\n visited = defaultdict(int)\\r\\n\\r\\n while visited[ip] == 0:\\r\\n visited[ip] = visited[ip] + 1\\r\\n\\r\\n if code[ip][0] == \\\"acc\\\":\\r\\n acc = acc + code[ip][1]\\r\\n ip = ip + 1\\r\\n elif code[ip][0] == \\\"nop\\\":\\r\\n ip = ip + 1\\r\\n elif code[ip][0] == \\\"jmp\\\":\\r\\n ip = ip + code[ip][1]\\r\\n\\r\\n if ip >= len(code):\\r\\n return (True, acc, visited)\\r\\n break\\r\\n\\r\\n return (False, acc, visited)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5561266","0.5535464","0.5518014","0.49592614","0.4936246","0.4916298","0.48616886","0.470336","0.46492574","0.4646029","0.46459916","0.46368012","0.4590937","0.45884967","0.4579382","0.4562117","0.45618558","0.45422032","0.4526873","0.4470122","0.446246","0.44544232","0.44365343","0.44359633","0.4432314","0.44144693","0.441354","0.44125953","0.44118905","0.4409639","0.44034794","0.4397042","0.43877733","0.43728387","0.43675733","0.4361456","0.4331592","0.43187082","0.43072665","0.43056267","0.42770898","0.4250836","0.4233241","0.42205968","0.4213151","0.4211568","0.4207098","0.42055786","0.42050785","0.42049623","0.42035875","0.419305","0.41899037","0.41768995","0.41768995","0.41678864","0.41639525","0.41510332","0.41417432","0.4141127","0.4130802","0.41244215","0.41203603","0.41155252","0.41072845","0.4101347","0.41007572","0.40928698","0.40913337","0.40912682","0.40882277","0.40840834","0.4081214","0.40749848","0.40722477","0.40721098","0.4069801","0.40673476","0.40665656","0.40551424","0.40451634","0.40444937","0.4033793","0.40255633","0.40251902","0.40226793","0.40225688","0.4013664","0.40062335","0.39980537","0.39947352","0.39890984","0.39882526","0.3984617","0.39803085","0.3975561","0.39753094","0.39668897","0.39649093","0.39581448"],"string":"[\n \"0.5561266\",\n \"0.5535464\",\n \"0.5518014\",\n \"0.49592614\",\n \"0.4936246\",\n \"0.4916298\",\n \"0.48616886\",\n \"0.470336\",\n \"0.46492574\",\n \"0.4646029\",\n \"0.46459916\",\n \"0.46368012\",\n \"0.4590937\",\n \"0.45884967\",\n \"0.4579382\",\n \"0.4562117\",\n \"0.45618558\",\n \"0.45422032\",\n \"0.4526873\",\n \"0.4470122\",\n \"0.446246\",\n \"0.44544232\",\n \"0.44365343\",\n \"0.44359633\",\n \"0.4432314\",\n \"0.44144693\",\n \"0.441354\",\n \"0.44125953\",\n \"0.44118905\",\n \"0.4409639\",\n \"0.44034794\",\n \"0.4397042\",\n \"0.43877733\",\n \"0.43728387\",\n \"0.43675733\",\n \"0.4361456\",\n \"0.4331592\",\n \"0.43187082\",\n \"0.43072665\",\n \"0.43056267\",\n \"0.42770898\",\n \"0.4250836\",\n \"0.4233241\",\n \"0.42205968\",\n \"0.4213151\",\n \"0.4211568\",\n \"0.4207098\",\n \"0.42055786\",\n \"0.42050785\",\n \"0.42049623\",\n \"0.42035875\",\n \"0.419305\",\n \"0.41899037\",\n \"0.41768995\",\n \"0.41768995\",\n \"0.41678864\",\n \"0.41639525\",\n \"0.41510332\",\n \"0.41417432\",\n \"0.4141127\",\n \"0.4130802\",\n \"0.41244215\",\n \"0.41203603\",\n \"0.41155252\",\n \"0.41072845\",\n \"0.4101347\",\n \"0.41007572\",\n \"0.40928698\",\n \"0.40913337\",\n \"0.40912682\",\n \"0.40882277\",\n \"0.40840834\",\n \"0.4081214\",\n \"0.40749848\",\n \"0.40722477\",\n \"0.40721098\",\n \"0.4069801\",\n \"0.40673476\",\n \"0.40665656\",\n \"0.40551424\",\n \"0.40451634\",\n \"0.40444937\",\n \"0.4033793\",\n \"0.40255633\",\n \"0.40251902\",\n \"0.40226793\",\n \"0.40225688\",\n \"0.4013664\",\n \"0.40062335\",\n \"0.39980537\",\n \"0.39947352\",\n \"0.39890984\",\n \"0.39882526\",\n \"0.3984617\",\n \"0.39803085\",\n \"0.3975561\",\n \"0.39753094\",\n \"0.39668897\",\n \"0.39649093\",\n \"0.39581448\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.713805"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19488,"cells":{"query":{"kind":"string","value":"Estimate the completed fraction of the trie that is contiguous with the current index (which rotates every 32 blocks) It will be probably be quite noticeable that it will get \"stuck\" when downloading a lot of storage, because we'll have to blow it up to more than a percentage to see any significant change within 32 blocks. (when the index will change again anyway)"},"document":{"kind":"string","value":"def _contiguous_accounts_complete_fraction(self) -> float:\n starting_index = bytes_to_nibbles(self._next_trie_root_hash)\n unknown_prefixes = self._account_tracker._trie_fog._unexplored_prefixes\n if len(unknown_prefixes) == 0:\n return 1\n\n # find the nearest unknown prefix (typically, on the right)\n nearest_index = unknown_prefixes.bisect(starting_index)\n\n # Get the nearest unknown prefix to the left\n if nearest_index == 0:\n left_prefix = (0, ) * 64\n else:\n left_prefix = unknown_prefixes[nearest_index - 1]\n if key_starts_with(starting_index, left_prefix):\n # The prefix of the starting index is unknown, so the index\n # itself is unknown.\n return 0\n\n # Get the nearest unknown prefix to the right\n if len(unknown_prefixes) == nearest_index:\n right_prefix = (0xf, ) * 64\n else:\n right_prefix = unknown_prefixes[nearest_index]\n\n # Use the space between the unknown prefixes to estimate the completed contiguous fraction\n\n # At the base, every gap in the first nibble is a full 1/16th of the state complete\n known_first_nibbles = right_prefix[0] - left_prefix[0] - 1\n completed_fraction_base = (1 / 16) * known_first_nibbles\n\n # Underneath, you can count completed subtrees on the right, each child 1/16 of the parent\n right_side_completed = sum(\n nibble * (1 / 16) ** nibble_depth\n for nibble_depth, nibble\n in enumerate(right_prefix[1:], 2)\n )\n # Do the same on the left\n left_side_completed = sum(\n (0xf - nibble) * (1 / 16) ** nibble_depth\n for nibble_depth, nibble\n in enumerate(left_prefix[1:], 2)\n )\n\n # Add up all completed areas\n return left_side_completed + completed_fraction_base + right_side_completed"},"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 fraction_completed(self):\n return sum(self._chunk_done.values()) / len(self.chunks)","def get_utilization(self):\n child_prefixes = Prefix.objects.filter(prefix__net_contained_or_equal=str(self.prefix))\n # Remove overlapping prefixes from list of children\n networks = cidr_merge([c.prefix for c in child_prefixes])\n children_size = float(0)\n for p in networks:\n children_size += p.size\n return int(children_size / self.prefix.size * 100)","def test_zPartialCurrents(self):\n # node 15 (ring=2, position=3), axial=3, group=3, j=1 (z-plus)\n iNode, iz, ig, j = 14, 2, 2, 0\n self.assertAlmostEqual(\n self.nhf.partialCurrentsZ[iNode, iz, j, ig] / 1.6928521e06, 1.0\n )","def fractionPassing(self):\n return self.cut.entries / self.entries","def _perc_up(self, cur_idx):\n while (cur_idx - 1) // 2 >= 0:\n parent_idx = (cur_idx - 1) // 2\n if self._heap[cur_idx] < self._heap[parent_idx]:\n self._heap[cur_idx], self._heap[parent_idx] = (\n self._heap[parent_idx],\n self._heap[cur_idx],\n )\n cur_idx = parent_idx","def fifteen():\r\n\r\n currentcell = 1.0\r\n cellpaths = 2.0\r\n \r\n while currentcell < 20.0:\r\n currentcell += 1.0\r\n cellpaths = cellpaths * (4.0 - 2.0/currentcell)\r\n \r\n return cellpaths","def modularity():\n\n q = 0.0\n for idx in range(0, node_count):\n if _tot[idx] > 0.0:\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\n return q","def measure_gcd_success():\n for size in range(2,16):\n print(\"--------- samplesize = %d\" % size)\n d = dict()\n for _ in range(1000):\n q = findpoly(size)\n d.setdefault(q,0)\n d[q] += 1\n for k,v in sorted(d.items(), key=lambda x: x[1]):\n print(\"%5d: %8s\" % (v, k))","def gc(self) -> float:\n g = self.count(\"G\")\n c = self.count(\"C\")\n return (g + c) / len(self) * 100","def calc_GC(filepath):\n liste=['small.exon.piRNA_2.fa', 'small.exon.piRNA_1.fa', 'small.exon.piRNA_3.fa']\n \n length=list(range(0,34))\n d={}\n for i in length:\n d[i]={'A':0, 'G':0, 'T':0, 'C':0}\n for i in liste:\n with open(filepath+'/'+i, 'r') as f:\n for line in f:\n #fasta header starts with >\n if line.startswith('>'):\n pass\n else:\n line_l=list(line)\n for el in range(len(line_l)):\n if line_l[el]=='A':\n d[el]['A']+=1\n elif line_l[el]=='T':\n d[el]['T']+=1\n elif line_l[el]== 'G':\n d[el]['G']+=1\n elif line_l[el]== 'C':\n d[el]['C']+=1\n\n df=pd.DataFrame.from_dict(d)\n df=df.transpose()\n df.index = np.arange(1, len(df) + 1)\n \n\n df['A [%]']=df['A']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['G [%]']=df['G']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['T [%]']=df['T']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['C [%]']=df['C']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100","def gc(self):\n g = self.seq.count('G')\n g += self.seq.count('g')\n c = self.seq.count('C')\n c += self.seq.count('c')\n return (g + c) / len(self.seq)","def reduce(self) -> float:\n # Note: Reduction over segments not supported/needed for now.\n return self._tree[1]","def total_chunks(self) -> global___Expression:","def get_value(self):\r\n if len(self.walk) == 0:\r\n return 0\r\n value = 0\r\n start = 0\r\n end = len(self.walk) - 1\r\n while start < end:\r\n i_segment = self.get_segment(start+1)\r\n if i_segment.value == 'RUNG':\r\n break\r\n start += 2\r\n while end >= 2:\r\n i_segment = self.get_segment(end-1)\r\n if i_segment.value == 'RUNG':\r\n break\r\n end -= 2\r\n j = start\r\n while j < end:\r\n j_node = self.get_node(j)\r\n j += 1\r\n j_segment = self.get_segment(j)\r\n j += 1\r\n if j_segment.value != 'RUNG':\r\n # if the node connector is not critical, try to find and skip a loop\r\n k = j\r\n while k < end:\r\n k_node = self.get_node(k)\r\n k += 1\r\n k_segment = self.get_segment(k)\r\n k += 1\r\n if k_segment.value == 'RUNG':\r\n break\r\n if k_node == j_node:\r\n # Only skippable nodes existed before returned to original node, so skip that loop.\r\n value += (k - j) * 10\r\n j = k\r\n j_node = k_node\r\n j_segment = k_segment\r\n break\r\n if j_segment.value == 'SCAFFOLD':\r\n value -= j_segment.a.distance_sq(j_segment.b)\r\n elif j_segment.value == 'RUNG':\r\n value -= j_segment.a.distance_sq(j_segment.b)\r\n return value","def load_factor(self):\n return round(self._n / self._size, 2)","def gc_rate(dna: str, percent=False):\n c = Counter(dna)\n result = (c[\"G\"] + c[\"C\"]) / len(dna)\n return result * 100 if percent else result","def overall_reduction(self):\n return 84","def gc_content(seq):\n result = float(str(seq).count('G') + str(seq).count('C'))/len(seq) *100\n return result","def percentage(self):\n return sum(self.chunk_percentage) / self.total_steps","def _load_factor(self):\n return self.size / len(self.buckets)","def get_next(current):\n return 0.5 * (current + n / current)","def get_expected_compression_ratio_pct(self) -> int:\n return 100","def _continued_fraction_kv(v, z, output_log_space=False):\n dtype = dtype_util.common_dtype([v, z], tf.float32)\n tol = tf.cast(np.finfo(dtype_util.as_numpy_dtype(\n dtype)).eps, dtype=dtype)\n max_iterations = 1000\n\n # Use Steed's algorithm to evaluate the confluent hypergeometric\n # function continued fraction in a numerically stable manner.\n def steeds_algorithm(\n should_stop,\n index,\n partial_numerator,\n partial_denominator,\n denominator_ratio,\n convergent_difference,\n hypergeometric_ratio,\n # Terms for recurrence in 6.7.36 in [3].\n k_0,\n k_1,\n # Intermediate coefficient in 6.7.30 in [3].\n c,\n # Intermediate sum in 6.7.35 in [3].\n q,\n hypergeometric_sum):\n # The numerator is v**2 - (index - 0.5) ** 2\n partial_numerator = partial_numerator - 2. * (index - 1.)\n c = tf.where(should_stop, c, -c * partial_numerator / index)\n next_k = (k_0 - partial_denominator * k_1) / partial_numerator\n k_0 = tf.where(should_stop, k_0, k_1)\n k_1 = tf.where(should_stop, k_1, next_k)\n q = tf.where(should_stop, q, q + c * next_k)\n partial_denominator = partial_denominator + 2.\n denominator_ratio = 1. / (\n partial_denominator + partial_numerator * denominator_ratio)\n convergent_difference = tf.where(\n should_stop, convergent_difference,\n convergent_difference * (\n partial_denominator * denominator_ratio - 1.))\n hypergeometric_ratio = tf.where(\n should_stop,\n hypergeometric_ratio,\n hypergeometric_ratio + convergent_difference)\n hypergeometric_sum = tf.where(\n should_stop,\n hypergeometric_sum,\n hypergeometric_sum + q * convergent_difference)\n index = index + 1\n should_stop = (tf.math.abs(q * convergent_difference) <\n tf.math.abs(hypergeometric_sum) * tol) | (\n index > max_iterations)\n return (should_stop,\n index,\n partial_numerator,\n partial_denominator,\n denominator_ratio,\n convergent_difference,\n hypergeometric_ratio,\n k_0, k_1, c, q, hypergeometric_sum)\n\n initial_numerator = tf.math.square(v) - 0.25\n initial_denominator = 2 * (z + 1.)\n initial_ratio = 1. / initial_denominator + tf.zeros_like(v)\n initial_seq = -initial_numerator + tf.zeros_like(z)\n\n (_, _, _, _, _, _, hypergeometric_ratio,\n _, _, _, _, hypergeometric_sum) = tf.while_loop(\n cond=lambda stop, *_: tf.reduce_any(~stop),\n body=steeds_algorithm,\n loop_vars=(\n tf.zeros_like(v + z, dtype=tf.bool),\n tf.cast(2., dtype=dtype),\n initial_numerator,\n initial_denominator,\n initial_ratio,\n initial_ratio,\n initial_ratio,\n tf.zeros_like(v + z),\n tf.ones_like(v + z),\n initial_seq,\n initial_seq,\n 1 - initial_numerator * initial_ratio))\n\n log_kve = 0.5 * tf.math.log(np.pi / (2 * z)) - tf.math.log(hypergeometric_sum)\n log_kvp1e = (\n log_kve + tf.math.log1p(\n 2 * (v + z + initial_numerator * hypergeometric_ratio))\n - tf.math.log(z) - dtype_util.as_numpy_dtype(dtype)(np.log(2.)))\n if output_log_space:\n return log_kve, log_kvp1e\n return tf.math.exp(log_kve), tf.math.exp(log_kvp1e)","def load_factor(self) -> float:\n return self.filled_count / self.table_size","def leaf_nodes_to_search_percent(self) -> Optional[int]:\n return pulumi.get(self, \"leaf_nodes_to_search_percent\")","def correct_fraction():\n with open(os.path.join(ocr.settings.BASE_DIR,\n 'training_set.json')) as file:\n training_set = json.load(file)\n correct = 0\n for letter in training_set['list']:\n print(letter['letter'])\n for _ in range(REPETITIONS):\n if ocr.basic_nn.tools.recognize_symbol(letter['inputs']) \\\n == letter['letter']:\n correct += 1 / REPETITIONS\n fraction = correct / len(training_set['list'])\n print(fraction)\n return fraction","def backUp(self, value):\n return value / len(self.children)","def _reduce(self) -> None:\n divisor = self._gcd(self._numerator, self._denominator)\n self._numerator = self._numerator // divisor\n self._denominator = self._denominator // divisor","def problem_086(limit,verbose):\n\n # Three routes:\n # *------F Sides labeled A, B, C, routes clockwise from S\n # | /| R1^2 = (A + C)^2 + B^2\n # | / n R2^2 = (B + C)^2 + A^2\n # +-----+------+-----F R3^2 = (A + B)^2 + C^2\n # | | / | . `|\n # | A / .|` / |\n # | |/. ` a-n / |\n # +-C---S-b-B--+-----+\n # | ` . |\n # | `|\n # *------+\n # | |\n # | |\n # | |\n # +------F\n \n # Genreate all triples up to perimeter 3M + sqrt((M + M)^2 + M^2)\n # Which is is 3M + sqrt(5M^2)\n\n total_found = 0\n cuboids = defaultdict(set)\n triples = set()\n under_length = []\n \n for batch in count():\n size = (batch + 1) * 500\n max_triple_perimeter = int(3 * size + sqrt(5 * size**2)) + 1\n all_triples = set(generate_triples(max_triple_perimeter))\n this_loop = all_triples - triples\n triples = all_triples\n \n with click.progressbar(this_loop, label=\"{}\".format(total_found)) as bar:\n new_cuboids = (c for t in bar for c in generate_cuboids(t))\n new_cuboids = (c for c in new_cuboids if c.a > 0)\n new_cuboids = (c for c in new_cuboids if is_shortest_route_integral(c))\n for cuboid in new_cuboids:\n cuboids[cuboid.c].add(cuboid)\n \n for i in range(batch * 500, batch * 500 + 500):\n \n total_found += len(cuboids[i])\n if total_found >= limit:\n click.echo(total_found)\n click.echo(i)\n return","def _perc_down(self, cur_idx):\n while 2 * cur_idx + 1 < len(self._heap):\n min_child_idx = self._get_min_child(cur_idx)\n if self._heap[cur_idx] > self._heap[min_child_idx]:\n self._heap[cur_idx], self._heap[min_child_idx] = (\n self._heap[min_child_idx],\n self._heap[cur_idx],\n )\n else:\n return\n cur_idx = min_child_idx","def d50(clones, num_Reads): \n\n\n d50_amount = num_Reads/2\n read_count=0\n for i in clones:\n read_count+=clones[i].num_reads\n if read_count>=d50_amount:\n return i/float(len(clones))","def gc_content(sequence):\n gc = sequence.count('G') + sequence.count('C')\n atgc = sequence.count('A') + sequence.count('T') + sequence.count('G') + sequence.count('C')\n \n return (gc/atgc) * 100","def getFractionalItems(self, startingPoint, returnFmt = 0, refinements = 1):\n\n def closest_node(node, nodes):\n\n \"\"\" returns closest node using dot vectorization, slightly faster see https://codereview.stackexchange.com/questions/28207/finding-the-closest-point-to-a-list-of-points \"\"\"\n\n if node in nodes:\n nodes.remove(node)\n\n nodes = np.asarray(nodes)\n deltas = nodes - node\n dist_2 = np.einsum('ij,ij->i', deltas, deltas)\n temp = nodes[np.argmin(dist_2)]\n return (temp[0], temp[1])\n\n def averagePoints(nodeList):\n #Consider switching to numpy mean arrays if performance is an issue\n #inits\n tempX, tempY = 0, 0\n for node in nodeList:\n tempX += node[0]\n tempY += node[1]\n \n avX, avY = tempX/len(nodeList), tempY/len(nodeList)\n avPoint = [avX, avY]\n\n return avPoint\n\n def fractionalPoints(totalNodeList, recNodeList, fracPoints):\n\n \"\"\" Starts out with one point should be in a place of high density #NOTE this is not automated yet. Keep adding points (it will add the closest)\n point to the set over and over until 50% of the points are encircled. Then it will return a list of those points \"\"\"\n\n avPoint = averagePoints(recNodeList)\n\n for i in range(0, fracPoints):\n closestPoint = closest_node(avPoint, totalNodeList) #Finds closest point\n totalNodeList.remove(closestPoint)\n recNodeList.append(closestPoint)\n\n printProgressBar(i, fracPoints) \n\n return recNodeList \n\n #Gets fractional points \n numPointsFrac = math.floor(self.numPoints * self.detectionFraction)\n fracPoints = fractionalPoints(self.points, [startingPoint], numPointsFrac)\n \n #Hull creation and getting of verticies\n hull = ConvexHull(fracPoints)\n polyVertices = [fracPoints[vertex] for vertex in hull.vertices] \n cutVertices = chaikins_corner_cutting(polyVertices, refinements)\n\n #Path creation \n polyCodes = [mppath.Path.LINETO] * len(polyVertices)\n polyCodes[0] = mppath.Path.MOVETO\n polyCodes[-1] = mppath.Path.CLOSEPOLY\n\n cutCodes = [mppath.Path.LINETO] * len(cutVertices)\n cutCodes[0] = mppath.Path.MOVETO\n cutCodes[-1] = mppath.Path.CLOSEPOLY\n\n polyPath = mppath.Path(polyVertices, polyCodes)\n cutPath = mppath.Path(cutVertices, cutCodes)\n\n #How you want the information returned \n if returnFmt == -2:\n return [[cutVertices, cutPath], fracPoints]\n if returnFmt == -1:\n return fracPoints\n if returnFmt == 0:\n return [cutVertices, cutPath]\n if returnFmt == 1:\n return [polyVertices, polyPath]\n if returnFmt == 2:\n return [[cutVertices, cutPath], [polyVertices, polyPath]]","def GetGC(flanks):\n gc = 0\n total = 0\n for i in flanks:\n if i != \"N\":\n total += 1\n if i == \"C\" or i == \"G\": gc += 1\n return gc*1.0/total","def trie_recurse(wordinds, charinds, prefix, probs, cumul, trie, model, new_inp):\n num = 0\n for let in charinds.keys():\n new_inp[0][-1] = eye[charinds[let]]\n keys = trie.keys(prefix+let)\n num = len(trie.keys(prefix+let))\n if num == 1:\n final_probs[0][wordinds[keys[0]]] = np.multiply(cumul, probs[0][charinds[let]])\n elif num > 1:\n probs = model.predict(new_inp)\n new_inp = np.roll(new_inp, -1, 1)\n \n cumul = np.multiply(cumul, probs[0][charinds[let]])\n trie_recurse(wordinds, charinds, prefix+let, probs, cumul, trie, model, new_inp)","def leafScore(self) :\n return 0","def balance_section(self,phi, max_iter=100):\r\n\t\tub = self.depth\r\n\t\tlb = 0.0\r\n\t\tna_z = 0.5*self.depth\r\n\t\tsection_converged = False\r\n\t\tfor i in range(max_iter):\r\n\t\t\tstrain = self.strain_distribution(na_z,phi)\r\n\t\t\tFc = self.concrete_total_force(strain)\r\n\t\t\tFs = self.steel_total_force(strain)\r\n\t\t\tif abs(Fc + Fs) <= FORCE_TOL:\r\n\t\t\t\tsection_converged = True\r\n\t\t\t\tbreak\r\n\t\t\telse:\r\n\t\t\t\tif phi >= 0.0:\r\n\t\t\t\t\tif (Fc + Fs) > 0.0:\r\n\t\t\t\t\t\tlb = na_z # Non mutable variable fingures crossed.. Found a bug.. Bitch is here\r\n\t\t\t\t\t\tna_z = 0.5*(na_z + ub)\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tub = na_z\r\n\t\t\t\t\t\tna_z = 0.5*(na_z + lb)\r\n\t\t\t\telse:\r\n\t\t\t\t\tif (Fc + Fs) > 0.0:\r\n\t\t\t\t\t\tub = na_z\r\n\t\t\t\t\t\tna_z = 0.5*(na_z + lb) \r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tlb = na_z\r\n\t\t\t\t\t\tna_z = 0.5*(na_z + ub)\r\n\t\tif section_converged:\r\n\t\t\treturn na_z\r\n\t\telse:\r\n\t\t\treturn None","def ratio(original, compressed):\n olen = len(original)\n clen = len(compressed)\n return (olen - clen) / olen","def speedChange(self):\n original = ALIENS_IN_ROW *ALIEN_ROWS\n i = 0 # accumulator\n for x in range(ALIEN_ROWS):\n for y in range(ALIENS_IN_ROW):\n if self._aliens[x][y] != None:\n i+=1\n return i / original","def testTreeF(node, test):\n total = len(test)\n success = 0\n for d in test:\n i = searchTreeF(node, d)\n if i == d[-1]:\n success += 1\n return success / total","def progress(self) -> int:\n return int(round(100 * self.somme() / self.finances))","def lowComplexityFraction(self):\n length = len(self)\n if length:\n lowerCount = len(list(filter(str.islower, self.sequence)))\n return float(lowerCount) / length\n else:\n return 0.0","def percent_processed(self):\n try:\n return (self.pos / self.data_encap.size) * 100.0\n except ZeroDivisionError:\n return 100.0","def get_current_term_finished_fraction():\n term_id = Term.get_current_term_id()\n next_term_id = Term.get_next_term_id_from_term_id(term_id)\n\n current_term_date = Term.get_date_from_term_id(term_id)\n next_term_date = Term.get_date_from_term_id(next_term_id)\n now = datetime.datetime.now()\n\n term_length = next_term_date - current_term_date\n elapsed_length = now - current_term_date\n\n return 1.0 * elapsed_length.days / term_length.days","def _get_m(self, ks: List[int]) -> int:\n\n base = 1\n for c in ks:\n base = base * c // gcd(base, c)\n return base","def calc_progress(self):\n if self.is_prepared():\n self._sync_info_from_disk()\n self._num_sown_batches = len(\n glob.glob(\n os.path.join(self.location, \"batches\", BTCH_NM.format(\"*\"))\n )\n )\n self._num_results = len(\n glob.glob(\n os.path.join(self.location, \"results\", RSLT_NM.format(\"*\"))\n )\n )\n else:\n self._num_sown_batches = -1\n self._num_results = -1","def nocache_create_equal_size_subtrees():\n N = len(self)\n subTrees = [set(range(i, N, numSubTrees)) for i in range(numSubTrees)]\n totalCost = N\n return subTrees, totalCost","def _compute_tqdm_miniters(byte_size: int) -> float:\n return min(byte_size / 100.0, 1.0)","def get_load_factor(self):\n # Your code here\n return self.count/len(self.data)","def testPartitionIsCorrectGolden(self):\n # Here we enumerate a set of positive rational numbers n/d alongside\n # numerically approximated values of Z(n / d) up to 10 digits of precision,\n # stored as (n, d, Z(n/d)). This was generated with an external mathematica\n # script.\n golden = (\n (1, 7, 4.080330073), (1, 6, 4.038544331), (1, 5, 3.984791180),\n (1, 4, 3.912448576), (1, 3, 3.808203509), (2, 5, 3.735479786),\n (3, 7, 3.706553276), (1, 2, 3.638993131), (3, 5, 3.553489270),\n (2, 3, 3.501024540), (3, 4, 3.439385624), (4, 5, 3.404121259),\n (1, 1, 3.272306973), (6, 5, 3.149249092), (5, 4, 3.119044506),\n (4, 3, 3.068687433), (7, 5, 3.028084866), (3, 2, 2.965924889),\n (8, 5, 2.901059987), (5, 3, 2.855391798), (7, 4, 2.794052016),\n (7, 3, 2.260434598), (5, 2, 2.218882601), (8, 3, 2.190349858),\n (3, 1, 2.153202857), (4, 1, 2.101960916), (7, 2, 2.121140098),\n (5, 1, 2.080000512), (9, 2, 2.089161164), (6, 1, 2.067751267),\n (7, 1, 2.059929623), (8, 1, 2.054500222), (10, 3, 2.129863884),\n (11, 3, 2.113763384), (13, 3, 2.092928254), (14, 3, 2.085788350),\n (16, 3, 2.075212740), (11, 2, 2.073116001), (17, 3, 2.071185791),\n (13, 2, 2.063452243), (15, 2, 2.056990258)) # pyformat: disable\n alpha, z_true = tuple(jnp.array([(n / d, z) for (n, d, z) in golden]).T)\n log_z_true = jnp.log(z_true)\n log_z = self.variant(self._distribution.log_base_partition_function)(alpha)\n chex.assert_tree_all_close(log_z, log_z_true, atol=1e-7, rtol=1e-7)","def _estimateDepth(self, size, neighbourRadius):\n neighbourRadius *= 1.5\n for i in xrange(100):\n j = 2**i\n spacings = [c/j for c in size]\n maxSpace = max(spacings)\n if maxSpace < neighbourRadius:\n return i+1","def test03(self):\n N, blen = self.N, 100\n a = bcolz.fromiter(xrange(N), dtype=np.float64, count=N,\n rootdir=self.rootdir)\n l, s = 0, 0\n for block in bcolz.iterblocks(a, blen, blen-1, 3*blen+2):\n l += len(block)\n s += block.sum()\n mlen = min(N - (blen - 1), 2*blen + 3)\n self.assertEqual(l, mlen)\n slen = min(N, 3*blen + 2)\n self.assertEqual(s, np.arange(blen-1, slen).sum())","def balance_section_capacity(self,postive=True,max_iter=1000):\r\n\t\tub = self.depth\r\n\t\tlb = 0.0\r\n\t\tna_z = 0.5*self.depth\r\n\t\tsection_converged = False\r\n\t\tfor i in range(max_iter):\r\n\t\t\tif postive:\r\n\t\t\t\tstrain = self.strain_distribution_capacity(na_z,postive)\r\n\t\t\telse:\r\n\t\t\t\tstrain = self.strain_distribution_capacity(self.depth-na_z,postive)\r\n\t\t\tFc = self.concrete_total_force(strain)\r\n\t\t\tFs = self.steel_total_force(strain)\r\n\t\t\tif abs(Fc + Fs) <= FORCE_TOL:\r\n\t\t\t\tsection_converged = True\r\n\t\t\t\tbreak\r\n\t\t\telse:\r\n\t\t\t\tif postive:\r\n\t\t\t\t\tif (Fc + Fs) > 0.0:\r\n\t\t\t\t\t\tlb = na_z\r\n\t\t\t\t\t\tna_z = 0.5*(na_z + ub)\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tub = na_z\r\n\t\t\t\t\t\tna_z = 0.5*(na_z + lb)\r\n\t\t\t\telse:\r\n\t\t\t\t\tif (Fc + Fs) > 0.0:\r\n\t\t\t\t\t\tub = na_z\r\n\t\t\t\t\t\tna_z = 0.5*(na_z + lb) \r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tlb = na_z\r\n\t\t\t\t\t\tna_z = 0.5*(na_z + ub)\r\n\t\tif section_converged:\r\n\t\t\treturn na_z\r\n\t\telse:\r\n\t\t\treturn None","def get_at_gc_ratio(at, gc):\n return at / gc","def get_at_gc_ratio(at, gc):\n return at / gc","def fib(index):\n return round((GR**index)/R5)","def numerator(self,data,gold):\n gold_size = 0.0\n for lead in gold.keys():\n gold_size += len(gold[lead])\n print gold_size\n epsilon = 0.0000000001\n match = 0.0\n not_match = 0.0\n exp_size = 0.0\n for lead in data.keys():\n for hit in data[lead]:\n exp_size += 1\n edge = (lead,hit[0])\n if self.CompareEdges(edge,gold):\n print edge\n match += 1\n else:\n not_match += 1\n\n if match == 0.0:\n match = epsilon\n elif not_match == 0.0:\n not_match = epsilon\n print match\n print not_match\n num1 = match \n num2 = not_match\n return num1/num2","def coverage(self):\n try:\n return self.found * 100 / self.needed\n except ZeroDivisionError:\n return 100.0","def _good_turing_new_c(self, count: int) -> float:\n next_count_index = count + 1\n next_count: Optional[float] = None\n if next_count_index not in self.count_map:\n # this happens when N_{c+1} is 0\n # this can make the total probability not equal to 1\n next_count = 0.\n else:\n next_count = float(self.count_map[next_count_index])\n\n new_count: Optional[float] = None\n new_count = (count + 1) * next_count / self.count_map[count]\n return new_count","def data_balancing(path):\r\n \r\n distribution_list = data_distribution(path)\r\n \r\n balancing_factor = []\r\n for i in range(len(distribution_list)):\r\n #print(i,distribution_list[i])\r\n #multiplier = max(distribution_list) / distribution_list[i] - 1\r\n multiplier = (np.round(5000 / distribution_list[i],0))\r\n multiplier = int(np.round(multiplier/4,0))\r\n balancing_factor.append(multiplier)\r\n #print(\"sddada\",max(distribution_list) / distribution_list[i])\r\n return balancing_factor","def get_allowable_fraction_without(mem_to_reserve, cuda_device_index):\n current_free = get_free_gpu_memory(cuda_device_index)\n allowable = current_free - mem_to_reserve # 1GB\n allowable_fraction = allowable / current_free\n if allowable_fraction <= 0.0:\n raise ValueError(f\"Can't leave 1GB over for the inference kernel, because\"\n f\" there is only {allowable} total free GPU memory.\")\n return allowable_fraction","def get_load_factor(self):\n # Your code here\n return self.total_items / self.capacity","def get_deletion_threshold(percent_match,\n seq_total):\n \n\n return int(float(1-percent_match)*seq_total)","def solution(A):\n \"\"\"method 2 n**2\n east=[] #0\n west=[] #1\n for i in range(len(A)):\n if A[i] == 0:\n east.append(i)\n else:\n west.append(i)\n\n result = 0\n for e in east:\n count = 0\n for j in range(len(west)):\n if e > west[j]:\n continue\n if e < west[j]:\n count = len(west) - j\n result += count\n #print(e, count)\n break\n return result\n \"\"\"\n east=[] #0\n west=[] #1\n l = len(A)\n for i in range(len(A)):\n if A[i] == 0:\n east.append(i)\n else:\n west.append(i)\n\n result = {}\n for i in range(len(east)):\n e = east[i]\n if i == 0:\n result[e] = l - e - len(east)\n if i != 0:\n result[e] = result[east[i-1]] - (e - east[i-1]-1)\n\n #print(result)\n s = sum(result.values())\n if s > 1000000000:\n return -1\n return s","def dd_vtr_duration_ratio_map_nb(record):\n return dd_vtr_duration_map_nb(record) / dd_duration_map_nb(record)","def heuristic_3_partition(game, player) -> float:\n\n partition_possible_factor = get_partition_possible_factor(game, player)\n\n return float(partition_possible_factor)","def test01(self):\n N, blen = self.N, 100\n a = bcolz.fromiter(xrange(N), dtype=np.float64, count=N,\n rootdir=self.rootdir)\n l, s = 0, 0\n for block in bcolz.iterblocks(a, blen):\n if l == 0:\n self.assertEqual(len(block), blen)\n l += len(block)\n s += block.sum()\n self.assertEqual(l, N)","def get_tree_size(thread, root, top, path, docs, sizes, inodes, depth=0, maxdepth=999):\n global filecount\n global skipfilecount\n global inodecount\n global dircount\n global skipdircount\n global total_doc_count\n global warnings\n\n size = 0\n size_du = 0\n dirs = 0\n files = 0\n f_count = 0\n d_count = 0\n f_skip_count = 0\n d_skip_count = 0\n tot_doc_count = 0\n parent_path = None\n size_norecurs = 0\n size_du_norecurs = 0\n files_norecurs = 0\n dirs_norecurs = 0\n \n # use alt scanner\n # try to get stat info for dir path\n if options.altscanner:\n try:\n d_stat = alt_scanner.stat(path)\n except RuntimeError as e:\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\n logger.error(logmsg)\n if logtofile: logger_warn.error(logmsg)\n with crawl_thread_lock:\n warnings += 1\n return 0, 0, 0, 0\n except Exception as e:\n logmsg = '[{0}] ALT SCANNER EXCEPTION: {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n return 0, 0, 0, 0\n else:\n # try to get os stat info for dir path\n try:\n d_stat = os.stat(path)\n except OSError as e:\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n return 0, 0, 0, 0\n \n # restore times (atime/mtime)\n if restore_times:\n res, err = set_times(path, d_stat.st_atime, d_stat.st_mtime)\n if not res:\n logmsg = 'OS ERROR setting file times for {0} (error {1})'.format(path, err)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n\n # scan directory\n try:\n logger.debug('[{0}] Scanning path {1}...'.format(thread, path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] Scanning path {1}...'.format(thread, path))\n for entry in os.scandir(path):\n logger.debug('[{0}] Scanning dir entry {1}...'.format(thread, entry.path))\n if options.vverbose:\n logger.info('[{0}] Scanning dir entry {1}...'.format(thread, entry.path)) \n \n if entry.is_symlink():\n logger.debug('[{0}] skipping symlink {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping symlink {1}'.format(thread, entry.path))\n pass\n elif entry.is_dir():\n d_count += 1\n if not dir_excluded(entry.path):\n dirs += 1\n dirs_norecurs += 1\n if maxdepth > 0:\n if depth < maxdepth:\n # recurse into subdir\n if not quit:\n s, sdu, fc, dc = get_tree_size(thread, root, top, entry.path, docs, sizes, inodes, depth+1, maxdepth)\n size += s\n size_du += sdu\n files += fc\n dirs += dc\n else:\n logger.debug('[{0}] not descending {1}, maxdepth {2} reached'.format(\n thread, entry.path, maxdepth))\n if options.verbose or options.vverbose:\n logger.info('[{0}] not descending {1}, maxdepth {2} reached'.format(\n thread, entry.path, maxdepth))\n else:\n logger.debug('[{0}] skipping dir {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping dir {1}'.format(thread, entry.path))\n d_skip_count += 1\n else:\n f_count += 1\n if not file_excluded(entry.name):\n f_stat = entry.stat()\n # restore times (atime/mtime)\n if restore_times and not options.altscanner:\n ret = set_times(entry.path, f_stat.st_atime, f_stat.st_mtime)\n if not ret:\n with crawl_thread_lock:\n warnings += 1\n\n fsize = f_stat.st_size\n # calculate allocated file size (du size)\n if IS_WIN:\n fsize_du = fsize\n elif options.altscanner:\n fsize_du = f_stat.st_sizedu\n else:\n fsize_du = f_stat.st_blocks * blocksize\n # set fsize_du to 0 if inode in inodes list (hardlink)\n if f_stat.st_ino in inodes:\n fsize_du = 0\n # add inode to inodes list if hardlink count > 1\n elif f_stat.st_nlink > 1:\n with crawl_thread_lock:\n inodes.append(f_stat.st_ino)\n fmtime_sec = time.time() - f_stat.st_mtime\n fctime_sec = time.time() - f_stat.st_ctime\n fatime_sec = time.time() - f_stat.st_atime\n\n if not exc_empty_files or (exc_empty_files and fsize > 0):\n if fsize >= minfilesize and \\\n fmtime_sec > minmtime and \\\n fmtime_sec < maxmtime and \\\n fctime_sec > minctime and \\\n fctime_sec < maxctime and \\\n fatime_sec > minatime and \\\n fatime_sec < maxatime:\n size += fsize\n size_norecurs += fsize\n size_du += fsize_du\n size_du_norecurs += fsize_du\n files += 1\n files_norecurs += 1\n # get owner and group names\n if IS_WIN:\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\n owner = f_stat.st_uid\n group = f_stat.st_gid\n else:\n owner, group = get_owner_group_names(f_stat.st_uid, f_stat.st_gid)\n \n # check for bad Unicode utf-8 characters\n try:\n if parent_path is None:\n parent_path = get_parent_path(entry.path)\n file_name = get_file_name(entry.name)\n except UnicodeError:\n if parent_path is None:\n parent_path = get_parent_path(entry.path, ignore_errors=True)\n file_name = get_file_name(entry.name, ignore_errors=True)\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n \n # index doc dict\n data = {\n 'name': file_name,\n 'extension': os.path.splitext(entry.name)[1][1:].lower(),\n 'parent_path': parent_path,\n 'size': fsize,\n 'size_du': fsize_du,\n 'owner': owner,\n 'group': group,\n 'mtime': datetime.utcfromtimestamp(int(f_stat.st_mtime)).isoformat(),\n 'atime': datetime.utcfromtimestamp(int(f_stat.st_atime)).isoformat(),\n 'ctime': datetime.utcfromtimestamp(int(f_stat.st_ctime)).isoformat(),\n 'nlink': f_stat.st_nlink,\n 'ino': str(f_stat.st_ino),\n 'type': 'file'\n }\n\n # check if using altscanner and if any additional meta data to add to data dict\n if options.altscanner:\n try:\n extrameta_dict = alt_scanner.add_meta(entry.path, f_stat)\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except Exception as e:\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n # check plugins for adding extra meta data to data dict\n if plugins_enabled and plugins_files:\n for plugin in plugins:\n try:\n # check if plugin is for file doc\n if plugin.for_type('file'):\n extrameta_dict = plugin.add_meta(entry.path, f_stat)\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except (RuntimeWarning, RuntimeError) as e:\n err_message = e.args[0]\n if e.__class__ == RuntimeWarning:\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n else:\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\n logger.error(logmsg)\n if logtofile: logger_warn.error(logmsg)\n with crawl_thread_lock:\n warnings += 1\n extrameta_dict = e.args[1]\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except Exception as e:\n logmsg = '[{0}] PLUGIN EXCEPTION {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n # add file doc to docs list and upload to ES once it reaches certain size\n docs.append(data.copy())\n doc_count = len(docs)\n if doc_count >= es_chunksize:\n start_bulk_upload(thread, root, docs)\n tot_doc_count += doc_count\n docs.clear()\n\n else:\n f_skip_count += 1\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\n else:\n f_skip_count += 1\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\n else:\n f_skip_count += 1\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\n \n # if not excluding empty dirs is set or exclude empty dirs is set but there are files or \n # dirs in the current directory, index the dir\n if not exc_empty_dirs or (exc_empty_dirs and (files > 0 or dirs > 0)):\n # get owner and group names\n if IS_WIN:\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\n owner = d_stat.st_uid\n group = d_stat.st_gid\n else:\n owner, group = get_owner_group_names(d_stat.st_uid, d_stat.st_gid)\n \n # check for bad Unicode utf-8 characters\n try:\n file_name = get_dir_name(path)\n parent_path = get_parent_path(path)\n except UnicodeError:\n file_name = get_dir_name(path, ignore_errors=True)\n parent_path = get_parent_path(path, ignore_errors=True)\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n \n # index doc dict\n data = {\n 'name': file_name,\n 'parent_path': parent_path,\n 'size': size,\n 'size_norecurs': size_norecurs,\n 'size_du': size_du,\n 'size_du_norecurs': size_du_norecurs,\n 'file_count': files,\n 'file_count_norecurs': files_norecurs, \n 'dir_count': dirs + 1,\n 'dir_count_norecurs': dirs_norecurs + 1,\n 'dir_depth': depth,\n 'mtime': datetime.utcfromtimestamp(int(d_stat.st_mtime)).isoformat(),\n 'atime': datetime.utcfromtimestamp(int(d_stat.st_atime)).isoformat(),\n 'ctime': datetime.utcfromtimestamp(int(d_stat.st_ctime)).isoformat(),\n 'nlink': d_stat.st_nlink,\n 'ino': str(d_stat.st_ino),\n 'owner': owner,\n 'group': group,\n 'type': 'directory'\n }\n\n # check if using altscanner and if any additional meta data to add to data dict\n if options.altscanner:\n try:\n extrameta_dict = alt_scanner.add_meta(path, d_stat)\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except Exception as e:\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n # check plugins for adding extra meta data to data dict\n if plugins_enabled and plugins_dirs:\n for plugin in plugins:\n # check if plugin is for directory doc\n try:\n if plugin.for_type('directory'):\n extrameta_dict = plugin.add_meta(path, d_stat)\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except (RuntimeWarning, RuntimeError) as e:\n err_message = e.args[0]\n if e.__class__ == RuntimeWarning:\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n else:\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\n logger.error(logmsg)\n if logtofile: logger_warn.error(logmsg)\n with crawl_thread_lock:\n warnings += 1\n extrameta_dict = e.args[1]\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except Exception as e:\n logmsg = '[{0}] PLUGIN EXCEPTION: {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n \n if depth > 0:\n # add file doc to docs list and upload to ES once it reaches certain size\n docs.append(data.copy())\n doc_count = len(docs)\n if doc_count >= es_chunksize:\n start_bulk_upload(thread, root, docs)\n tot_doc_count += doc_count\n docs.clear()\n \n else:\n with crawl_thread_lock:\n sizes[root] = data.copy()\n else:\n d_skip_count += 1\n logger.debug('[{0}] skipping empty dir {1}'.format(thread, path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping empty dir {1}'.format(thread, path))\n if dirs > 0: dirs -= 1\n\n with crawl_thread_lock:\n dircount[root] += d_count - d_skip_count\n filecount[root] += f_count - f_skip_count\n skipfilecount[root] += f_skip_count\n skipdircount[root] += d_skip_count\n total_doc_count[root] += tot_doc_count\n inodecount[root] += d_count + f_count \n\n except OSError as e:\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n except RuntimeError as e:\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\n logger.error(logmsg)\n if logtofile: logger_warn.error(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n \n return size, size_du, files, dirs","def calculate_path(self):\n #Se repite el ciclo para el número especificado de veces\n for i in range(self.iterations):\n for ant in self.ants:\n ant.setup_ant()\n while not ant.final_node_reached:\n #Seleccion aleatoria del nodo a visitar\n node_to_vist = self.select_next_node(self.map.nodes_array[int(ant.actual_node[0])][int(ant.actual_node[1])])\n #Mover la hormiga al siguiente nodo seleccionado al azar\n ant.move_ant(node_to_visit)\n #Compruebe si se ha alcanzado la solución\n ant.is_final_node_reached()\n #Agregar la ruta resultante a la lista de rutas\n self.add_to_path_results(self.delete_loops(ant.get_visited_nodes()))\n # Habilitar a la hormiga para otra busqueda\n ant.enable_start_new_path()\n \n # Actualizar el nivel global de feromonas\n self.pheromone_update()\n self.best_result = self.paths[0]\n\n #Vaciar la lista de rutas\n self.empty_paths()\n print('Iteration: ', i, 'lenght of the path: ', len(self.best_result))\n return self.best_result","def calculate_gpa(self):\n cur_node = self.head\n gpa = 0\n total_credits = 0\n while cur_node is not None:\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\n total_credits += cur_node.data.credit_hr()\n cur_node = cur_node.next\n if total_credits == 0:\n return 0\n return gpa / total_credits","def get_clust_num_perc(model, vis_perc=0.9):\n\tnc = len(np.where(model.allocmodel.Nk > 0)[0])\n\tidx = np.argsort(-model.allocmodel.Nk)[0:nc]\n\n\ttot = model.allocmodel.Nk[idx].sum()\n\tcursum = 0\n\ti = 0\n\twhile cursum < tot*vis_perc:\n\t cursum += model.allocmodel.Nk[idx][i]\n\t i+=1\n\n\treturn i","def get_depth_milli_metres(self):\n self.depth = (self.get_depth_metres() * 1000).astype(np.float32)\n self.full_depth = copy.copy(self.depth)\n return self.depth","def get_fraction_of_reps_with_gene(self, gene_index, value):\n return value + (1 - 2 * value) * self.fraction_of_reps_that_has_1[gene_index]","def get_block_size(n, k):\r\n l, r = get_position(k)\r\n c, p, q = get_level_profile(n, l)\r\n return c + 1 if r < q else c","def solution(self):\n return [(\"the\", 1579644)] * 100","def brute_force_search_solution():\n return len(coin_search(TOTAL, COINS))","def get_current_challenge_part(self):\n dist = max(self.get_global_total_distance_on_foot(), self.get_global_total_distance_on_bike())\n checkpoints = self._get_challenge_parts()\n\n result = 0\n for d in checkpoints.keys():\n if d <= dist:\n result = result + 1\n\n return '%02d' % result","def quick_ratio(self):\n return (\n self.current_assets - self.inventory_net) / self.current_liabilities","def denominator(self,gold,length):\n size = length * (length - 1) \n\n gold_size = 0.0\n for lead in gold.keys():\n gold_size += len(gold[lead])\n \n #print 'Whazzup'\n #print gold_size\n #print size\n den1 = gold_size\n den2 = size - gold_size \n #print den1\n #print den2\n return den1/den2","def calculate(self):\n\n result = \"FINITE\"\n pos = 0\n vis = set([])\n while 0 <= pos < self.n:\n vis.add(pos)\n if self.numa[pos]:\n pos += self.numb[pos]\n else:\n pos -= self.numb[pos]\n if pos in vis:\n result = \"IN\" + result\n break\n\n return str(result)","def overhead(readings):\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))","def bulk_modulus():\n\n return 10000.0","def annihilation_branching_fractions(self, Q):\n CSs = self.cross_sections(Q)\n\n if CSs[\"total\"] == 0.0:\n return {\"mu mu\": 0.0, \"e e\": 0.0, \"pi0 pi pi\": 0.0, \"a a\": 0.0}\n else:\n return {\n \"mu mu\": CSs[\"mu mu\"] / CSs[\"total\"],\n \"e e\": CSs[\"e e\"] / CSs[\"total\"],\n \"pi0 pi pi\": CSs[\"pi0 pi pi\"] / CSs[\"total\"],\n \"a a\": CSs[\"a a\"] / CSs[\"total\"],\n }","def perturbanceFactor(lenWhole, lenPart, perturbance):\n k = 1 - perturbance\n return lenPart ** k / lenWhole ** k","def revContFraction(a):\n N = 1\n D = a[len(a)-1]\n\n for i in range(len(a)-2, -1, -1):\n N += D * a[i]\n tmp = N\n N = D\n D = tmp\n return (N,D)","def get_load_factor(self):\r\n return self.num_items / self.table_size","def test02(self):\n N, blen = self.N, 100\n a = bcolz.fromiter(xrange(N), dtype=np.float64, count=N,\n rootdir=self.rootdir)\n l, s = 0, 0\n for block in bcolz.iterblocks(a, blen, blen-1):\n l += len(block)\n s += block.sum()\n self.assertEqual(l, (N - (blen - 1)))\n self.assertEqual(s, np.arange(blen-1, N).sum())","def progress(self):\n try:\n return 100.0 * (self.fields['sizeWhenDone'] - self.fields['leftUntilDone']) / float(self.fields['sizeWhenDone'])\n except ZeroDivisionError:\n return 0.0","def far(self):\n return self.table[0, 1] / (self.table[0, 0] + self.table[0, 1])","def update(self, leaf_value):\n # Count visit.\n self._n_visits += 1\n # Update Q, a running average of values for all visits. wtf ??? this line is rigth but kind of wired !\n self._Q += 1.0 * (leaf_value - self._Q) / self._n_visits","def delta(self):\r\n return 1 - xl.Refractive_Index_Re(self.compound, self.energy, self.density)","def get_sdram_size_of_region_for(self, vertex):","def calculate_gc_content(sequence):\n sequence = sequence.upper()\n sc = Counter(sequence)\n return round((sc['C'] + sc['G']) / (sc['A'] + sc['C'] + sc['G'] + sc['T']) * 100, 2)","def calculate(index):\n postingl1 = [len(x[0]) for x in index[0].values()]\n print(\"Number of terms in index i1 : \" + str(len(postingl1)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl1)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl1)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl1) / float(len(postingl1))) + \"\\t\")\n print(\"Size of the file that stores the index i1 : \" + \\\n str(os.stat('invertedindex1.txt').st_size) + \" bytes\\n\")\n\n postingl2 = [len(x[0]) for x in index[1].values()]\n print(\"Number of terms in index i2 : \" + str(len(postingl2)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl2)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl2)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl2) / float(len(postingl2))) + \"\\t\")\n print(\"Size of the file that stores the index i2 : \" + \\\n str(os.stat('invertedindex2.txt').st_size) + \" bytes\\n\")\n\n postingl3 = [len(x[0]) for x in index[2].values()]\n print(\"Number of terms in index i3 : \" + str(len(postingl3)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl3)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl3)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl3) / float(len(postingl3))) + \"\\t\")\n print(\"Size of the file that stores the index i3 : \" + \\\n str(os.stat('invertedindex3.txt').st_size) + \" bytes\\n\")\n\n postingl4 = [len(x[0]) for x in index[3].values()]\n print(\"Number of terms in index i4 : \" + str(len(postingl4)) + \"\\t\")\n print(\"Maximum Length of Postings List : \" + str(max(postingl4)) + \"\\t\")\n print(\"Minimum Length of Postings List : \" + str(min(postingl4)) + \"\\t\")\n print(\"Average Length of Postings List : \" + str(sum(postingl4) / float(len(postingl4))) + \"\\t\")\n print(\"Size of the file that stores the index i4 : \" + \\\n str(os.stat('invertedindex4.txt').st_size) + \" bytes\\n\")","def completion_proximity_score(prefix, completion):\n if prefix == completion:\n return float(\"inf\")\n else:\n return 1.0 / float(len(completion))","def middle_drop(progress):\n eps = 0.75\n if 1 - progress < eps:\n return eps * 0.1\n return 1 - progress","def get_approximate_size(self):\n return FutureInt64(\n self.capi.fdb_transaction_get_approximate_size(self.tpointer)\n )","def waste_frac(bucket):\n if not isinstance(bucket, tuple) or len(bucket) not in {0, 2}:\n raise ValueError('Wrong bucket format')\n\n if not len(bucket):\n return 0.0\n\n boundary, len2freq = bucket\n zero_cnt = sum([(boundary - 1 - lng) * f for lng, f in len2freq.items()])\n total_freq = sum([f for _, f in len2freq.items()])\n\n return zero_cnt / (total_freq * (boundary - 1))","def dist_from_root(self, index):\n if index == 0:\n return 0\n return self.dist_from_root(self.parent(index)) + 1","def count_contigs(fastafile):\n\n # import file into a dictionary using biopython module\n from Bio import SeqIO\n seq_dict = {rec.id : rec.seq for rec in SeqIO.parse(fastafile, \"fasta\")}\n\n # count contigs\n count_dict = {}\n for id in seq_dict:\n count_dict[id] = len(seq_dict[id])\n\n # cluster amount of contigs according to their lengths\n smaller_than_500 = 0\n up_to_1000bp = 0\n up_to_5000bp = 0\n ten_thousand = 0\n twenty_thousand = 0\n fifty_thousand = 0\n hundred_thousand_and_larger = 0\n larger_than_100000 = 0\n\n for id in count_dict:\n if count_dict[id] <= 500:\n smaller_than_500 += 1\n elif 500 < count_dict[id] <= 1000:\n up_to_1000bp += 1\n elif 1000 < count_dict[id] <= 5000:\n up_to_5000bp += 1\n elif 5000 < count_dict[id] <= 10000:\n ten_thousand += 1\n elif 10000 < count_dict[id] <= 20000:\n twenty_thousand += 1\n elif 20000 < count_dict[id] <= 50000:\n fifty_thousand += 1\n elif 50000 < count_dict[id] <= 100000:\n hundred_thousand_and_larger += 1\n elif 100000 < count_dict[id]:\n larger_than_100000 += 1\n\n print (\"up to 500 bp:\",smaller_than_500)\n print (\"500 to 1000 bp:\", up_to_1000bp)\n print (\"1000 - 5000 bp:\", up_to_5000bp)\n print (\"5000 - 10 000 bp:\", ten_thousand)\n print (\"10 000 - 20 000 bp:\", twenty_thousand)\n print (\"20 000 - 50 000 bp:\", fifty_thousand)\n print (\"50 000 - 100 000 bp:\", hundred_thousand_and_larger)\n print (\"larger than 100 000 bp:\", larger_than_100000)"],"string":"[\n \"def fraction_completed(self):\\n return sum(self._chunk_done.values()) / len(self.chunks)\",\n \"def get_utilization(self):\\n child_prefixes = Prefix.objects.filter(prefix__net_contained_or_equal=str(self.prefix))\\n # Remove overlapping prefixes from list of children\\n networks = cidr_merge([c.prefix for c in child_prefixes])\\n children_size = float(0)\\n for p in networks:\\n children_size += p.size\\n return int(children_size / self.prefix.size * 100)\",\n \"def test_zPartialCurrents(self):\\n # node 15 (ring=2, position=3), axial=3, group=3, j=1 (z-plus)\\n iNode, iz, ig, j = 14, 2, 2, 0\\n self.assertAlmostEqual(\\n self.nhf.partialCurrentsZ[iNode, iz, j, ig] / 1.6928521e06, 1.0\\n )\",\n \"def fractionPassing(self):\\n return self.cut.entries / self.entries\",\n \"def _perc_up(self, cur_idx):\\n while (cur_idx - 1) // 2 >= 0:\\n parent_idx = (cur_idx - 1) // 2\\n if self._heap[cur_idx] < self._heap[parent_idx]:\\n self._heap[cur_idx], self._heap[parent_idx] = (\\n self._heap[parent_idx],\\n self._heap[cur_idx],\\n )\\n cur_idx = parent_idx\",\n \"def fifteen():\\r\\n\\r\\n currentcell = 1.0\\r\\n cellpaths = 2.0\\r\\n \\r\\n while currentcell < 20.0:\\r\\n currentcell += 1.0\\r\\n cellpaths = cellpaths * (4.0 - 2.0/currentcell)\\r\\n \\r\\n return cellpaths\",\n \"def modularity():\\n\\n q = 0.0\\n for idx in range(0, node_count):\\n if _tot[idx] > 0.0:\\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\\n return q\",\n \"def measure_gcd_success():\\n for size in range(2,16):\\n print(\\\"--------- samplesize = %d\\\" % size)\\n d = dict()\\n for _ in range(1000):\\n q = findpoly(size)\\n d.setdefault(q,0)\\n d[q] += 1\\n for k,v in sorted(d.items(), key=lambda x: x[1]):\\n print(\\\"%5d: %8s\\\" % (v, k))\",\n \"def gc(self) -> float:\\n g = self.count(\\\"G\\\")\\n c = self.count(\\\"C\\\")\\n return (g + c) / len(self) * 100\",\n \"def calc_GC(filepath):\\n liste=['small.exon.piRNA_2.fa', 'small.exon.piRNA_1.fa', 'small.exon.piRNA_3.fa']\\n \\n length=list(range(0,34))\\n d={}\\n for i in length:\\n d[i]={'A':0, 'G':0, 'T':0, 'C':0}\\n for i in liste:\\n with open(filepath+'/'+i, 'r') as f:\\n for line in f:\\n #fasta header starts with >\\n if line.startswith('>'):\\n pass\\n else:\\n line_l=list(line)\\n for el in range(len(line_l)):\\n if line_l[el]=='A':\\n d[el]['A']+=1\\n elif line_l[el]=='T':\\n d[el]['T']+=1\\n elif line_l[el]== 'G':\\n d[el]['G']+=1\\n elif line_l[el]== 'C':\\n d[el]['C']+=1\\n\\n df=pd.DataFrame.from_dict(d)\\n df=df.transpose()\\n df.index = np.arange(1, len(df) + 1)\\n \\n\\n df['A [%]']=df['A']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['G [%]']=df['G']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['T [%]']=df['T']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['C [%]']=df['C']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\",\n \"def gc(self):\\n g = self.seq.count('G')\\n g += self.seq.count('g')\\n c = self.seq.count('C')\\n c += self.seq.count('c')\\n return (g + c) / len(self.seq)\",\n \"def reduce(self) -> float:\\n # Note: Reduction over segments not supported/needed for now.\\n return self._tree[1]\",\n \"def total_chunks(self) -> global___Expression:\",\n \"def get_value(self):\\r\\n if len(self.walk) == 0:\\r\\n return 0\\r\\n value = 0\\r\\n start = 0\\r\\n end = len(self.walk) - 1\\r\\n while start < end:\\r\\n i_segment = self.get_segment(start+1)\\r\\n if i_segment.value == 'RUNG':\\r\\n break\\r\\n start += 2\\r\\n while end >= 2:\\r\\n i_segment = self.get_segment(end-1)\\r\\n if i_segment.value == 'RUNG':\\r\\n break\\r\\n end -= 2\\r\\n j = start\\r\\n while j < end:\\r\\n j_node = self.get_node(j)\\r\\n j += 1\\r\\n j_segment = self.get_segment(j)\\r\\n j += 1\\r\\n if j_segment.value != 'RUNG':\\r\\n # if the node connector is not critical, try to find and skip a loop\\r\\n k = j\\r\\n while k < end:\\r\\n k_node = self.get_node(k)\\r\\n k += 1\\r\\n k_segment = self.get_segment(k)\\r\\n k += 1\\r\\n if k_segment.value == 'RUNG':\\r\\n break\\r\\n if k_node == j_node:\\r\\n # Only skippable nodes existed before returned to original node, so skip that loop.\\r\\n value += (k - j) * 10\\r\\n j = k\\r\\n j_node = k_node\\r\\n j_segment = k_segment\\r\\n break\\r\\n if j_segment.value == 'SCAFFOLD':\\r\\n value -= j_segment.a.distance_sq(j_segment.b)\\r\\n elif j_segment.value == 'RUNG':\\r\\n value -= j_segment.a.distance_sq(j_segment.b)\\r\\n return value\",\n \"def load_factor(self):\\n return round(self._n / self._size, 2)\",\n \"def gc_rate(dna: str, percent=False):\\n c = Counter(dna)\\n result = (c[\\\"G\\\"] + c[\\\"C\\\"]) / len(dna)\\n return result * 100 if percent else result\",\n \"def overall_reduction(self):\\n return 84\",\n \"def gc_content(seq):\\n result = float(str(seq).count('G') + str(seq).count('C'))/len(seq) *100\\n return result\",\n \"def percentage(self):\\n return sum(self.chunk_percentage) / self.total_steps\",\n \"def _load_factor(self):\\n return self.size / len(self.buckets)\",\n \"def get_next(current):\\n return 0.5 * (current + n / current)\",\n \"def get_expected_compression_ratio_pct(self) -> int:\\n return 100\",\n \"def _continued_fraction_kv(v, z, output_log_space=False):\\n dtype = dtype_util.common_dtype([v, z], tf.float32)\\n tol = tf.cast(np.finfo(dtype_util.as_numpy_dtype(\\n dtype)).eps, dtype=dtype)\\n max_iterations = 1000\\n\\n # Use Steed's algorithm to evaluate the confluent hypergeometric\\n # function continued fraction in a numerically stable manner.\\n def steeds_algorithm(\\n should_stop,\\n index,\\n partial_numerator,\\n partial_denominator,\\n denominator_ratio,\\n convergent_difference,\\n hypergeometric_ratio,\\n # Terms for recurrence in 6.7.36 in [3].\\n k_0,\\n k_1,\\n # Intermediate coefficient in 6.7.30 in [3].\\n c,\\n # Intermediate sum in 6.7.35 in [3].\\n q,\\n hypergeometric_sum):\\n # The numerator is v**2 - (index - 0.5) ** 2\\n partial_numerator = partial_numerator - 2. * (index - 1.)\\n c = tf.where(should_stop, c, -c * partial_numerator / index)\\n next_k = (k_0 - partial_denominator * k_1) / partial_numerator\\n k_0 = tf.where(should_stop, k_0, k_1)\\n k_1 = tf.where(should_stop, k_1, next_k)\\n q = tf.where(should_stop, q, q + c * next_k)\\n partial_denominator = partial_denominator + 2.\\n denominator_ratio = 1. / (\\n partial_denominator + partial_numerator * denominator_ratio)\\n convergent_difference = tf.where(\\n should_stop, convergent_difference,\\n convergent_difference * (\\n partial_denominator * denominator_ratio - 1.))\\n hypergeometric_ratio = tf.where(\\n should_stop,\\n hypergeometric_ratio,\\n hypergeometric_ratio + convergent_difference)\\n hypergeometric_sum = tf.where(\\n should_stop,\\n hypergeometric_sum,\\n hypergeometric_sum + q * convergent_difference)\\n index = index + 1\\n should_stop = (tf.math.abs(q * convergent_difference) <\\n tf.math.abs(hypergeometric_sum) * tol) | (\\n index > max_iterations)\\n return (should_stop,\\n index,\\n partial_numerator,\\n partial_denominator,\\n denominator_ratio,\\n convergent_difference,\\n hypergeometric_ratio,\\n k_0, k_1, c, q, hypergeometric_sum)\\n\\n initial_numerator = tf.math.square(v) - 0.25\\n initial_denominator = 2 * (z + 1.)\\n initial_ratio = 1. / initial_denominator + tf.zeros_like(v)\\n initial_seq = -initial_numerator + tf.zeros_like(z)\\n\\n (_, _, _, _, _, _, hypergeometric_ratio,\\n _, _, _, _, hypergeometric_sum) = tf.while_loop(\\n cond=lambda stop, *_: tf.reduce_any(~stop),\\n body=steeds_algorithm,\\n loop_vars=(\\n tf.zeros_like(v + z, dtype=tf.bool),\\n tf.cast(2., dtype=dtype),\\n initial_numerator,\\n initial_denominator,\\n initial_ratio,\\n initial_ratio,\\n initial_ratio,\\n tf.zeros_like(v + z),\\n tf.ones_like(v + z),\\n initial_seq,\\n initial_seq,\\n 1 - initial_numerator * initial_ratio))\\n\\n log_kve = 0.5 * tf.math.log(np.pi / (2 * z)) - tf.math.log(hypergeometric_sum)\\n log_kvp1e = (\\n log_kve + tf.math.log1p(\\n 2 * (v + z + initial_numerator * hypergeometric_ratio))\\n - tf.math.log(z) - dtype_util.as_numpy_dtype(dtype)(np.log(2.)))\\n if output_log_space:\\n return log_kve, log_kvp1e\\n return tf.math.exp(log_kve), tf.math.exp(log_kvp1e)\",\n \"def load_factor(self) -> float:\\n return self.filled_count / self.table_size\",\n \"def leaf_nodes_to_search_percent(self) -> Optional[int]:\\n return pulumi.get(self, \\\"leaf_nodes_to_search_percent\\\")\",\n \"def correct_fraction():\\n with open(os.path.join(ocr.settings.BASE_DIR,\\n 'training_set.json')) as file:\\n training_set = json.load(file)\\n correct = 0\\n for letter in training_set['list']:\\n print(letter['letter'])\\n for _ in range(REPETITIONS):\\n if ocr.basic_nn.tools.recognize_symbol(letter['inputs']) \\\\\\n == letter['letter']:\\n correct += 1 / REPETITIONS\\n fraction = correct / len(training_set['list'])\\n print(fraction)\\n return fraction\",\n \"def backUp(self, value):\\n return value / len(self.children)\",\n \"def _reduce(self) -> None:\\n divisor = self._gcd(self._numerator, self._denominator)\\n self._numerator = self._numerator // divisor\\n self._denominator = self._denominator // divisor\",\n \"def problem_086(limit,verbose):\\n\\n # Three routes:\\n # *------F Sides labeled A, B, C, routes clockwise from S\\n # | /| R1^2 = (A + C)^2 + B^2\\n # | / n R2^2 = (B + C)^2 + A^2\\n # +-----+------+-----F R3^2 = (A + B)^2 + C^2\\n # | | / | . `|\\n # | A / .|` / |\\n # | |/. ` a-n / |\\n # +-C---S-b-B--+-----+\\n # | ` . |\\n # | `|\\n # *------+\\n # | |\\n # | |\\n # | |\\n # +------F\\n \\n # Genreate all triples up to perimeter 3M + sqrt((M + M)^2 + M^2)\\n # Which is is 3M + sqrt(5M^2)\\n\\n total_found = 0\\n cuboids = defaultdict(set)\\n triples = set()\\n under_length = []\\n \\n for batch in count():\\n size = (batch + 1) * 500\\n max_triple_perimeter = int(3 * size + sqrt(5 * size**2)) + 1\\n all_triples = set(generate_triples(max_triple_perimeter))\\n this_loop = all_triples - triples\\n triples = all_triples\\n \\n with click.progressbar(this_loop, label=\\\"{}\\\".format(total_found)) as bar:\\n new_cuboids = (c for t in bar for c in generate_cuboids(t))\\n new_cuboids = (c for c in new_cuboids if c.a > 0)\\n new_cuboids = (c for c in new_cuboids if is_shortest_route_integral(c))\\n for cuboid in new_cuboids:\\n cuboids[cuboid.c].add(cuboid)\\n \\n for i in range(batch * 500, batch * 500 + 500):\\n \\n total_found += len(cuboids[i])\\n if total_found >= limit:\\n click.echo(total_found)\\n click.echo(i)\\n return\",\n \"def _perc_down(self, cur_idx):\\n while 2 * cur_idx + 1 < len(self._heap):\\n min_child_idx = self._get_min_child(cur_idx)\\n if self._heap[cur_idx] > self._heap[min_child_idx]:\\n self._heap[cur_idx], self._heap[min_child_idx] = (\\n self._heap[min_child_idx],\\n self._heap[cur_idx],\\n )\\n else:\\n return\\n cur_idx = min_child_idx\",\n \"def d50(clones, num_Reads): \\n\\n\\n d50_amount = num_Reads/2\\n read_count=0\\n for i in clones:\\n read_count+=clones[i].num_reads\\n if read_count>=d50_amount:\\n return i/float(len(clones))\",\n \"def gc_content(sequence):\\n gc = sequence.count('G') + sequence.count('C')\\n atgc = sequence.count('A') + sequence.count('T') + sequence.count('G') + sequence.count('C')\\n \\n return (gc/atgc) * 100\",\n \"def getFractionalItems(self, startingPoint, returnFmt = 0, refinements = 1):\\n\\n def closest_node(node, nodes):\\n\\n \\\"\\\"\\\" returns closest node using dot vectorization, slightly faster see https://codereview.stackexchange.com/questions/28207/finding-the-closest-point-to-a-list-of-points \\\"\\\"\\\"\\n\\n if node in nodes:\\n nodes.remove(node)\\n\\n nodes = np.asarray(nodes)\\n deltas = nodes - node\\n dist_2 = np.einsum('ij,ij->i', deltas, deltas)\\n temp = nodes[np.argmin(dist_2)]\\n return (temp[0], temp[1])\\n\\n def averagePoints(nodeList):\\n #Consider switching to numpy mean arrays if performance is an issue\\n #inits\\n tempX, tempY = 0, 0\\n for node in nodeList:\\n tempX += node[0]\\n tempY += node[1]\\n \\n avX, avY = tempX/len(nodeList), tempY/len(nodeList)\\n avPoint = [avX, avY]\\n\\n return avPoint\\n\\n def fractionalPoints(totalNodeList, recNodeList, fracPoints):\\n\\n \\\"\\\"\\\" Starts out with one point should be in a place of high density #NOTE this is not automated yet. Keep adding points (it will add the closest)\\n point to the set over and over until 50% of the points are encircled. Then it will return a list of those points \\\"\\\"\\\"\\n\\n avPoint = averagePoints(recNodeList)\\n\\n for i in range(0, fracPoints):\\n closestPoint = closest_node(avPoint, totalNodeList) #Finds closest point\\n totalNodeList.remove(closestPoint)\\n recNodeList.append(closestPoint)\\n\\n printProgressBar(i, fracPoints) \\n\\n return recNodeList \\n\\n #Gets fractional points \\n numPointsFrac = math.floor(self.numPoints * self.detectionFraction)\\n fracPoints = fractionalPoints(self.points, [startingPoint], numPointsFrac)\\n \\n #Hull creation and getting of verticies\\n hull = ConvexHull(fracPoints)\\n polyVertices = [fracPoints[vertex] for vertex in hull.vertices] \\n cutVertices = chaikins_corner_cutting(polyVertices, refinements)\\n\\n #Path creation \\n polyCodes = [mppath.Path.LINETO] * len(polyVertices)\\n polyCodes[0] = mppath.Path.MOVETO\\n polyCodes[-1] = mppath.Path.CLOSEPOLY\\n\\n cutCodes = [mppath.Path.LINETO] * len(cutVertices)\\n cutCodes[0] = mppath.Path.MOVETO\\n cutCodes[-1] = mppath.Path.CLOSEPOLY\\n\\n polyPath = mppath.Path(polyVertices, polyCodes)\\n cutPath = mppath.Path(cutVertices, cutCodes)\\n\\n #How you want the information returned \\n if returnFmt == -2:\\n return [[cutVertices, cutPath], fracPoints]\\n if returnFmt == -1:\\n return fracPoints\\n if returnFmt == 0:\\n return [cutVertices, cutPath]\\n if returnFmt == 1:\\n return [polyVertices, polyPath]\\n if returnFmt == 2:\\n return [[cutVertices, cutPath], [polyVertices, polyPath]]\",\n \"def GetGC(flanks):\\n gc = 0\\n total = 0\\n for i in flanks:\\n if i != \\\"N\\\":\\n total += 1\\n if i == \\\"C\\\" or i == \\\"G\\\": gc += 1\\n return gc*1.0/total\",\n \"def trie_recurse(wordinds, charinds, prefix, probs, cumul, trie, model, new_inp):\\n num = 0\\n for let in charinds.keys():\\n new_inp[0][-1] = eye[charinds[let]]\\n keys = trie.keys(prefix+let)\\n num = len(trie.keys(prefix+let))\\n if num == 1:\\n final_probs[0][wordinds[keys[0]]] = np.multiply(cumul, probs[0][charinds[let]])\\n elif num > 1:\\n probs = model.predict(new_inp)\\n new_inp = np.roll(new_inp, -1, 1)\\n \\n cumul = np.multiply(cumul, probs[0][charinds[let]])\\n trie_recurse(wordinds, charinds, prefix+let, probs, cumul, trie, model, new_inp)\",\n \"def leafScore(self) :\\n return 0\",\n \"def balance_section(self,phi, max_iter=100):\\r\\n\\t\\tub = self.depth\\r\\n\\t\\tlb = 0.0\\r\\n\\t\\tna_z = 0.5*self.depth\\r\\n\\t\\tsection_converged = False\\r\\n\\t\\tfor i in range(max_iter):\\r\\n\\t\\t\\tstrain = self.strain_distribution(na_z,phi)\\r\\n\\t\\t\\tFc = self.concrete_total_force(strain)\\r\\n\\t\\t\\tFs = self.steel_total_force(strain)\\r\\n\\t\\t\\tif abs(Fc + Fs) <= FORCE_TOL:\\r\\n\\t\\t\\t\\tsection_converged = True\\r\\n\\t\\t\\t\\tbreak\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tif phi >= 0.0:\\r\\n\\t\\t\\t\\t\\tif (Fc + Fs) > 0.0:\\r\\n\\t\\t\\t\\t\\t\\tlb = na_z # Non mutable variable fingures crossed.. Found a bug.. Bitch is here\\r\\n\\t\\t\\t\\t\\t\\tna_z = 0.5*(na_z + ub)\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\tub = na_z\\r\\n\\t\\t\\t\\t\\t\\tna_z = 0.5*(na_z + lb)\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tif (Fc + Fs) > 0.0:\\r\\n\\t\\t\\t\\t\\t\\tub = na_z\\r\\n\\t\\t\\t\\t\\t\\tna_z = 0.5*(na_z + lb) \\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\tlb = na_z\\r\\n\\t\\t\\t\\t\\t\\tna_z = 0.5*(na_z + ub)\\r\\n\\t\\tif section_converged:\\r\\n\\t\\t\\treturn na_z\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn None\",\n \"def ratio(original, compressed):\\n olen = len(original)\\n clen = len(compressed)\\n return (olen - clen) / olen\",\n \"def speedChange(self):\\n original = ALIENS_IN_ROW *ALIEN_ROWS\\n i = 0 # accumulator\\n for x in range(ALIEN_ROWS):\\n for y in range(ALIENS_IN_ROW):\\n if self._aliens[x][y] != None:\\n i+=1\\n return i / original\",\n \"def testTreeF(node, test):\\n total = len(test)\\n success = 0\\n for d in test:\\n i = searchTreeF(node, d)\\n if i == d[-1]:\\n success += 1\\n return success / total\",\n \"def progress(self) -> int:\\n return int(round(100 * self.somme() / self.finances))\",\n \"def lowComplexityFraction(self):\\n length = len(self)\\n if length:\\n lowerCount = len(list(filter(str.islower, self.sequence)))\\n return float(lowerCount) / length\\n else:\\n return 0.0\",\n \"def percent_processed(self):\\n try:\\n return (self.pos / self.data_encap.size) * 100.0\\n except ZeroDivisionError:\\n return 100.0\",\n \"def get_current_term_finished_fraction():\\n term_id = Term.get_current_term_id()\\n next_term_id = Term.get_next_term_id_from_term_id(term_id)\\n\\n current_term_date = Term.get_date_from_term_id(term_id)\\n next_term_date = Term.get_date_from_term_id(next_term_id)\\n now = datetime.datetime.now()\\n\\n term_length = next_term_date - current_term_date\\n elapsed_length = now - current_term_date\\n\\n return 1.0 * elapsed_length.days / term_length.days\",\n \"def _get_m(self, ks: List[int]) -> int:\\n\\n base = 1\\n for c in ks:\\n base = base * c // gcd(base, c)\\n return base\",\n \"def calc_progress(self):\\n if self.is_prepared():\\n self._sync_info_from_disk()\\n self._num_sown_batches = len(\\n glob.glob(\\n os.path.join(self.location, \\\"batches\\\", BTCH_NM.format(\\\"*\\\"))\\n )\\n )\\n self._num_results = len(\\n glob.glob(\\n os.path.join(self.location, \\\"results\\\", RSLT_NM.format(\\\"*\\\"))\\n )\\n )\\n else:\\n self._num_sown_batches = -1\\n self._num_results = -1\",\n \"def nocache_create_equal_size_subtrees():\\n N = len(self)\\n subTrees = [set(range(i, N, numSubTrees)) for i in range(numSubTrees)]\\n totalCost = N\\n return subTrees, totalCost\",\n \"def _compute_tqdm_miniters(byte_size: int) -> float:\\n return min(byte_size / 100.0, 1.0)\",\n \"def get_load_factor(self):\\n # Your code here\\n return self.count/len(self.data)\",\n \"def testPartitionIsCorrectGolden(self):\\n # Here we enumerate a set of positive rational numbers n/d alongside\\n # numerically approximated values of Z(n / d) up to 10 digits of precision,\\n # stored as (n, d, Z(n/d)). This was generated with an external mathematica\\n # script.\\n golden = (\\n (1, 7, 4.080330073), (1, 6, 4.038544331), (1, 5, 3.984791180),\\n (1, 4, 3.912448576), (1, 3, 3.808203509), (2, 5, 3.735479786),\\n (3, 7, 3.706553276), (1, 2, 3.638993131), (3, 5, 3.553489270),\\n (2, 3, 3.501024540), (3, 4, 3.439385624), (4, 5, 3.404121259),\\n (1, 1, 3.272306973), (6, 5, 3.149249092), (5, 4, 3.119044506),\\n (4, 3, 3.068687433), (7, 5, 3.028084866), (3, 2, 2.965924889),\\n (8, 5, 2.901059987), (5, 3, 2.855391798), (7, 4, 2.794052016),\\n (7, 3, 2.260434598), (5, 2, 2.218882601), (8, 3, 2.190349858),\\n (3, 1, 2.153202857), (4, 1, 2.101960916), (7, 2, 2.121140098),\\n (5, 1, 2.080000512), (9, 2, 2.089161164), (6, 1, 2.067751267),\\n (7, 1, 2.059929623), (8, 1, 2.054500222), (10, 3, 2.129863884),\\n (11, 3, 2.113763384), (13, 3, 2.092928254), (14, 3, 2.085788350),\\n (16, 3, 2.075212740), (11, 2, 2.073116001), (17, 3, 2.071185791),\\n (13, 2, 2.063452243), (15, 2, 2.056990258)) # pyformat: disable\\n alpha, z_true = tuple(jnp.array([(n / d, z) for (n, d, z) in golden]).T)\\n log_z_true = jnp.log(z_true)\\n log_z = self.variant(self._distribution.log_base_partition_function)(alpha)\\n chex.assert_tree_all_close(log_z, log_z_true, atol=1e-7, rtol=1e-7)\",\n \"def _estimateDepth(self, size, neighbourRadius):\\n neighbourRadius *= 1.5\\n for i in xrange(100):\\n j = 2**i\\n spacings = [c/j for c in size]\\n maxSpace = max(spacings)\\n if maxSpace < neighbourRadius:\\n return i+1\",\n \"def test03(self):\\n N, blen = self.N, 100\\n a = bcolz.fromiter(xrange(N), dtype=np.float64, count=N,\\n rootdir=self.rootdir)\\n l, s = 0, 0\\n for block in bcolz.iterblocks(a, blen, blen-1, 3*blen+2):\\n l += len(block)\\n s += block.sum()\\n mlen = min(N - (blen - 1), 2*blen + 3)\\n self.assertEqual(l, mlen)\\n slen = min(N, 3*blen + 2)\\n self.assertEqual(s, np.arange(blen-1, slen).sum())\",\n \"def balance_section_capacity(self,postive=True,max_iter=1000):\\r\\n\\t\\tub = self.depth\\r\\n\\t\\tlb = 0.0\\r\\n\\t\\tna_z = 0.5*self.depth\\r\\n\\t\\tsection_converged = False\\r\\n\\t\\tfor i in range(max_iter):\\r\\n\\t\\t\\tif postive:\\r\\n\\t\\t\\t\\tstrain = self.strain_distribution_capacity(na_z,postive)\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tstrain = self.strain_distribution_capacity(self.depth-na_z,postive)\\r\\n\\t\\t\\tFc = self.concrete_total_force(strain)\\r\\n\\t\\t\\tFs = self.steel_total_force(strain)\\r\\n\\t\\t\\tif abs(Fc + Fs) <= FORCE_TOL:\\r\\n\\t\\t\\t\\tsection_converged = True\\r\\n\\t\\t\\t\\tbreak\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tif postive:\\r\\n\\t\\t\\t\\t\\tif (Fc + Fs) > 0.0:\\r\\n\\t\\t\\t\\t\\t\\tlb = na_z\\r\\n\\t\\t\\t\\t\\t\\tna_z = 0.5*(na_z + ub)\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\tub = na_z\\r\\n\\t\\t\\t\\t\\t\\tna_z = 0.5*(na_z + lb)\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tif (Fc + Fs) > 0.0:\\r\\n\\t\\t\\t\\t\\t\\tub = na_z\\r\\n\\t\\t\\t\\t\\t\\tna_z = 0.5*(na_z + lb) \\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\tlb = na_z\\r\\n\\t\\t\\t\\t\\t\\tna_z = 0.5*(na_z + ub)\\r\\n\\t\\tif section_converged:\\r\\n\\t\\t\\treturn na_z\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn None\",\n \"def get_at_gc_ratio(at, gc):\\n return at / gc\",\n \"def get_at_gc_ratio(at, gc):\\n return at / gc\",\n \"def fib(index):\\n return round((GR**index)/R5)\",\n \"def numerator(self,data,gold):\\n gold_size = 0.0\\n for lead in gold.keys():\\n gold_size += len(gold[lead])\\n print gold_size\\n epsilon = 0.0000000001\\n match = 0.0\\n not_match = 0.0\\n exp_size = 0.0\\n for lead in data.keys():\\n for hit in data[lead]:\\n exp_size += 1\\n edge = (lead,hit[0])\\n if self.CompareEdges(edge,gold):\\n print edge\\n match += 1\\n else:\\n not_match += 1\\n\\n if match == 0.0:\\n match = epsilon\\n elif not_match == 0.0:\\n not_match = epsilon\\n print match\\n print not_match\\n num1 = match \\n num2 = not_match\\n return num1/num2\",\n \"def coverage(self):\\n try:\\n return self.found * 100 / self.needed\\n except ZeroDivisionError:\\n return 100.0\",\n \"def _good_turing_new_c(self, count: int) -> float:\\n next_count_index = count + 1\\n next_count: Optional[float] = None\\n if next_count_index not in self.count_map:\\n # this happens when N_{c+1} is 0\\n # this can make the total probability not equal to 1\\n next_count = 0.\\n else:\\n next_count = float(self.count_map[next_count_index])\\n\\n new_count: Optional[float] = None\\n new_count = (count + 1) * next_count / self.count_map[count]\\n return new_count\",\n \"def data_balancing(path):\\r\\n \\r\\n distribution_list = data_distribution(path)\\r\\n \\r\\n balancing_factor = []\\r\\n for i in range(len(distribution_list)):\\r\\n #print(i,distribution_list[i])\\r\\n #multiplier = max(distribution_list) / distribution_list[i] - 1\\r\\n multiplier = (np.round(5000 / distribution_list[i],0))\\r\\n multiplier = int(np.round(multiplier/4,0))\\r\\n balancing_factor.append(multiplier)\\r\\n #print(\\\"sddada\\\",max(distribution_list) / distribution_list[i])\\r\\n return balancing_factor\",\n \"def get_allowable_fraction_without(mem_to_reserve, cuda_device_index):\\n current_free = get_free_gpu_memory(cuda_device_index)\\n allowable = current_free - mem_to_reserve # 1GB\\n allowable_fraction = allowable / current_free\\n if allowable_fraction <= 0.0:\\n raise ValueError(f\\\"Can't leave 1GB over for the inference kernel, because\\\"\\n f\\\" there is only {allowable} total free GPU memory.\\\")\\n return allowable_fraction\",\n \"def get_load_factor(self):\\n # Your code here\\n return self.total_items / self.capacity\",\n \"def get_deletion_threshold(percent_match,\\n seq_total):\\n \\n\\n return int(float(1-percent_match)*seq_total)\",\n \"def solution(A):\\n \\\"\\\"\\\"method 2 n**2\\n east=[] #0\\n west=[] #1\\n for i in range(len(A)):\\n if A[i] == 0:\\n east.append(i)\\n else:\\n west.append(i)\\n\\n result = 0\\n for e in east:\\n count = 0\\n for j in range(len(west)):\\n if e > west[j]:\\n continue\\n if e < west[j]:\\n count = len(west) - j\\n result += count\\n #print(e, count)\\n break\\n return result\\n \\\"\\\"\\\"\\n east=[] #0\\n west=[] #1\\n l = len(A)\\n for i in range(len(A)):\\n if A[i] == 0:\\n east.append(i)\\n else:\\n west.append(i)\\n\\n result = {}\\n for i in range(len(east)):\\n e = east[i]\\n if i == 0:\\n result[e] = l - e - len(east)\\n if i != 0:\\n result[e] = result[east[i-1]] - (e - east[i-1]-1)\\n\\n #print(result)\\n s = sum(result.values())\\n if s > 1000000000:\\n return -1\\n return s\",\n \"def dd_vtr_duration_ratio_map_nb(record):\\n return dd_vtr_duration_map_nb(record) / dd_duration_map_nb(record)\",\n \"def heuristic_3_partition(game, player) -> float:\\n\\n partition_possible_factor = get_partition_possible_factor(game, player)\\n\\n return float(partition_possible_factor)\",\n \"def test01(self):\\n N, blen = self.N, 100\\n a = bcolz.fromiter(xrange(N), dtype=np.float64, count=N,\\n rootdir=self.rootdir)\\n l, s = 0, 0\\n for block in bcolz.iterblocks(a, blen):\\n if l == 0:\\n self.assertEqual(len(block), blen)\\n l += len(block)\\n s += block.sum()\\n self.assertEqual(l, N)\",\n \"def get_tree_size(thread, root, top, path, docs, sizes, inodes, depth=0, maxdepth=999):\\n global filecount\\n global skipfilecount\\n global inodecount\\n global dircount\\n global skipdircount\\n global total_doc_count\\n global warnings\\n\\n size = 0\\n size_du = 0\\n dirs = 0\\n files = 0\\n f_count = 0\\n d_count = 0\\n f_skip_count = 0\\n d_skip_count = 0\\n tot_doc_count = 0\\n parent_path = None\\n size_norecurs = 0\\n size_du_norecurs = 0\\n files_norecurs = 0\\n dirs_norecurs = 0\\n \\n # use alt scanner\\n # try to get stat info for dir path\\n if options.altscanner:\\n try:\\n d_stat = alt_scanner.stat(path)\\n except RuntimeError as e:\\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION: {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n else:\\n # try to get os stat info for dir path\\n try:\\n d_stat = os.stat(path)\\n except OSError as e:\\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n \\n # restore times (atime/mtime)\\n if restore_times:\\n res, err = set_times(path, d_stat.st_atime, d_stat.st_mtime)\\n if not res:\\n logmsg = 'OS ERROR setting file times for {0} (error {1})'.format(path, err)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n\\n # scan directory\\n try:\\n logger.debug('[{0}] Scanning path {1}...'.format(thread, path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] Scanning path {1}...'.format(thread, path))\\n for entry in os.scandir(path):\\n logger.debug('[{0}] Scanning dir entry {1}...'.format(thread, entry.path))\\n if options.vverbose:\\n logger.info('[{0}] Scanning dir entry {1}...'.format(thread, entry.path)) \\n \\n if entry.is_symlink():\\n logger.debug('[{0}] skipping symlink {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping symlink {1}'.format(thread, entry.path))\\n pass\\n elif entry.is_dir():\\n d_count += 1\\n if not dir_excluded(entry.path):\\n dirs += 1\\n dirs_norecurs += 1\\n if maxdepth > 0:\\n if depth < maxdepth:\\n # recurse into subdir\\n if not quit:\\n s, sdu, fc, dc = get_tree_size(thread, root, top, entry.path, docs, sizes, inodes, depth+1, maxdepth)\\n size += s\\n size_du += sdu\\n files += fc\\n dirs += dc\\n else:\\n logger.debug('[{0}] not descending {1}, maxdepth {2} reached'.format(\\n thread, entry.path, maxdepth))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] not descending {1}, maxdepth {2} reached'.format(\\n thread, entry.path, maxdepth))\\n else:\\n logger.debug('[{0}] skipping dir {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping dir {1}'.format(thread, entry.path))\\n d_skip_count += 1\\n else:\\n f_count += 1\\n if not file_excluded(entry.name):\\n f_stat = entry.stat()\\n # restore times (atime/mtime)\\n if restore_times and not options.altscanner:\\n ret = set_times(entry.path, f_stat.st_atime, f_stat.st_mtime)\\n if not ret:\\n with crawl_thread_lock:\\n warnings += 1\\n\\n fsize = f_stat.st_size\\n # calculate allocated file size (du size)\\n if IS_WIN:\\n fsize_du = fsize\\n elif options.altscanner:\\n fsize_du = f_stat.st_sizedu\\n else:\\n fsize_du = f_stat.st_blocks * blocksize\\n # set fsize_du to 0 if inode in inodes list (hardlink)\\n if f_stat.st_ino in inodes:\\n fsize_du = 0\\n # add inode to inodes list if hardlink count > 1\\n elif f_stat.st_nlink > 1:\\n with crawl_thread_lock:\\n inodes.append(f_stat.st_ino)\\n fmtime_sec = time.time() - f_stat.st_mtime\\n fctime_sec = time.time() - f_stat.st_ctime\\n fatime_sec = time.time() - f_stat.st_atime\\n\\n if not exc_empty_files or (exc_empty_files and fsize > 0):\\n if fsize >= minfilesize and \\\\\\n fmtime_sec > minmtime and \\\\\\n fmtime_sec < maxmtime and \\\\\\n fctime_sec > minctime and \\\\\\n fctime_sec < maxctime and \\\\\\n fatime_sec > minatime and \\\\\\n fatime_sec < maxatime:\\n size += fsize\\n size_norecurs += fsize\\n size_du += fsize_du\\n size_du_norecurs += fsize_du\\n files += 1\\n files_norecurs += 1\\n # get owner and group names\\n if IS_WIN:\\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\\n owner = f_stat.st_uid\\n group = f_stat.st_gid\\n else:\\n owner, group = get_owner_group_names(f_stat.st_uid, f_stat.st_gid)\\n \\n # check for bad Unicode utf-8 characters\\n try:\\n if parent_path is None:\\n parent_path = get_parent_path(entry.path)\\n file_name = get_file_name(entry.name)\\n except UnicodeError:\\n if parent_path is None:\\n parent_path = get_parent_path(entry.path, ignore_errors=True)\\n file_name = get_file_name(entry.name, ignore_errors=True)\\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n # index doc dict\\n data = {\\n 'name': file_name,\\n 'extension': os.path.splitext(entry.name)[1][1:].lower(),\\n 'parent_path': parent_path,\\n 'size': fsize,\\n 'size_du': fsize_du,\\n 'owner': owner,\\n 'group': group,\\n 'mtime': datetime.utcfromtimestamp(int(f_stat.st_mtime)).isoformat(),\\n 'atime': datetime.utcfromtimestamp(int(f_stat.st_atime)).isoformat(),\\n 'ctime': datetime.utcfromtimestamp(int(f_stat.st_ctime)).isoformat(),\\n 'nlink': f_stat.st_nlink,\\n 'ino': str(f_stat.st_ino),\\n 'type': 'file'\\n }\\n\\n # check if using altscanner and if any additional meta data to add to data dict\\n if options.altscanner:\\n try:\\n extrameta_dict = alt_scanner.add_meta(entry.path, f_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # check plugins for adding extra meta data to data dict\\n if plugins_enabled and plugins_files:\\n for plugin in plugins:\\n try:\\n # check if plugin is for file doc\\n if plugin.for_type('file'):\\n extrameta_dict = plugin.add_meta(entry.path, f_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except (RuntimeWarning, RuntimeError) as e:\\n err_message = e.args[0]\\n if e.__class__ == RuntimeWarning:\\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n else:\\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n extrameta_dict = e.args[1]\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] PLUGIN EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # add file doc to docs list and upload to ES once it reaches certain size\\n docs.append(data.copy())\\n doc_count = len(docs)\\n if doc_count >= es_chunksize:\\n start_bulk_upload(thread, root, docs)\\n tot_doc_count += doc_count\\n docs.clear()\\n\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n \\n # if not excluding empty dirs is set or exclude empty dirs is set but there are files or \\n # dirs in the current directory, index the dir\\n if not exc_empty_dirs or (exc_empty_dirs and (files > 0 or dirs > 0)):\\n # get owner and group names\\n if IS_WIN:\\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\\n owner = d_stat.st_uid\\n group = d_stat.st_gid\\n else:\\n owner, group = get_owner_group_names(d_stat.st_uid, d_stat.st_gid)\\n \\n # check for bad Unicode utf-8 characters\\n try:\\n file_name = get_dir_name(path)\\n parent_path = get_parent_path(path)\\n except UnicodeError:\\n file_name = get_dir_name(path, ignore_errors=True)\\n parent_path = get_parent_path(path, ignore_errors=True)\\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n # index doc dict\\n data = {\\n 'name': file_name,\\n 'parent_path': parent_path,\\n 'size': size,\\n 'size_norecurs': size_norecurs,\\n 'size_du': size_du,\\n 'size_du_norecurs': size_du_norecurs,\\n 'file_count': files,\\n 'file_count_norecurs': files_norecurs, \\n 'dir_count': dirs + 1,\\n 'dir_count_norecurs': dirs_norecurs + 1,\\n 'dir_depth': depth,\\n 'mtime': datetime.utcfromtimestamp(int(d_stat.st_mtime)).isoformat(),\\n 'atime': datetime.utcfromtimestamp(int(d_stat.st_atime)).isoformat(),\\n 'ctime': datetime.utcfromtimestamp(int(d_stat.st_ctime)).isoformat(),\\n 'nlink': d_stat.st_nlink,\\n 'ino': str(d_stat.st_ino),\\n 'owner': owner,\\n 'group': group,\\n 'type': 'directory'\\n }\\n\\n # check if using altscanner and if any additional meta data to add to data dict\\n if options.altscanner:\\n try:\\n extrameta_dict = alt_scanner.add_meta(path, d_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # check plugins for adding extra meta data to data dict\\n if plugins_enabled and plugins_dirs:\\n for plugin in plugins:\\n # check if plugin is for directory doc\\n try:\\n if plugin.for_type('directory'):\\n extrameta_dict = plugin.add_meta(path, d_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except (RuntimeWarning, RuntimeError) as e:\\n err_message = e.args[0]\\n if e.__class__ == RuntimeWarning:\\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n else:\\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n extrameta_dict = e.args[1]\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] PLUGIN EXCEPTION: {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n if depth > 0:\\n # add file doc to docs list and upload to ES once it reaches certain size\\n docs.append(data.copy())\\n doc_count = len(docs)\\n if doc_count >= es_chunksize:\\n start_bulk_upload(thread, root, docs)\\n tot_doc_count += doc_count\\n docs.clear()\\n \\n else:\\n with crawl_thread_lock:\\n sizes[root] = data.copy()\\n else:\\n d_skip_count += 1\\n logger.debug('[{0}] skipping empty dir {1}'.format(thread, path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping empty dir {1}'.format(thread, path))\\n if dirs > 0: dirs -= 1\\n\\n with crawl_thread_lock:\\n dircount[root] += d_count - d_skip_count\\n filecount[root] += f_count - f_skip_count\\n skipfilecount[root] += f_skip_count\\n skipdircount[root] += d_skip_count\\n total_doc_count[root] += tot_doc_count\\n inodecount[root] += d_count + f_count \\n\\n except OSError as e:\\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n except RuntimeError as e:\\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n return size, size_du, files, dirs\",\n \"def calculate_path(self):\\n #Se repite el ciclo para el número especificado de veces\\n for i in range(self.iterations):\\n for ant in self.ants:\\n ant.setup_ant()\\n while not ant.final_node_reached:\\n #Seleccion aleatoria del nodo a visitar\\n node_to_vist = self.select_next_node(self.map.nodes_array[int(ant.actual_node[0])][int(ant.actual_node[1])])\\n #Mover la hormiga al siguiente nodo seleccionado al azar\\n ant.move_ant(node_to_visit)\\n #Compruebe si se ha alcanzado la solución\\n ant.is_final_node_reached()\\n #Agregar la ruta resultante a la lista de rutas\\n self.add_to_path_results(self.delete_loops(ant.get_visited_nodes()))\\n # Habilitar a la hormiga para otra busqueda\\n ant.enable_start_new_path()\\n \\n # Actualizar el nivel global de feromonas\\n self.pheromone_update()\\n self.best_result = self.paths[0]\\n\\n #Vaciar la lista de rutas\\n self.empty_paths()\\n print('Iteration: ', i, 'lenght of the path: ', len(self.best_result))\\n return self.best_result\",\n \"def calculate_gpa(self):\\n cur_node = self.head\\n gpa = 0\\n total_credits = 0\\n while cur_node is not None:\\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\\n total_credits += cur_node.data.credit_hr()\\n cur_node = cur_node.next\\n if total_credits == 0:\\n return 0\\n return gpa / total_credits\",\n \"def get_clust_num_perc(model, vis_perc=0.9):\\n\\tnc = len(np.where(model.allocmodel.Nk > 0)[0])\\n\\tidx = np.argsort(-model.allocmodel.Nk)[0:nc]\\n\\n\\ttot = model.allocmodel.Nk[idx].sum()\\n\\tcursum = 0\\n\\ti = 0\\n\\twhile cursum < tot*vis_perc:\\n\\t cursum += model.allocmodel.Nk[idx][i]\\n\\t i+=1\\n\\n\\treturn i\",\n \"def get_depth_milli_metres(self):\\n self.depth = (self.get_depth_metres() * 1000).astype(np.float32)\\n self.full_depth = copy.copy(self.depth)\\n return self.depth\",\n \"def get_fraction_of_reps_with_gene(self, gene_index, value):\\n return value + (1 - 2 * value) * self.fraction_of_reps_that_has_1[gene_index]\",\n \"def get_block_size(n, k):\\r\\n l, r = get_position(k)\\r\\n c, p, q = get_level_profile(n, l)\\r\\n return c + 1 if r < q else c\",\n \"def solution(self):\\n return [(\\\"the\\\", 1579644)] * 100\",\n \"def brute_force_search_solution():\\n return len(coin_search(TOTAL, COINS))\",\n \"def get_current_challenge_part(self):\\n dist = max(self.get_global_total_distance_on_foot(), self.get_global_total_distance_on_bike())\\n checkpoints = self._get_challenge_parts()\\n\\n result = 0\\n for d in checkpoints.keys():\\n if d <= dist:\\n result = result + 1\\n\\n return '%02d' % result\",\n \"def quick_ratio(self):\\n return (\\n self.current_assets - self.inventory_net) / self.current_liabilities\",\n \"def denominator(self,gold,length):\\n size = length * (length - 1) \\n\\n gold_size = 0.0\\n for lead in gold.keys():\\n gold_size += len(gold[lead])\\n \\n #print 'Whazzup'\\n #print gold_size\\n #print size\\n den1 = gold_size\\n den2 = size - gold_size \\n #print den1\\n #print den2\\n return den1/den2\",\n \"def calculate(self):\\n\\n result = \\\"FINITE\\\"\\n pos = 0\\n vis = set([])\\n while 0 <= pos < self.n:\\n vis.add(pos)\\n if self.numa[pos]:\\n pos += self.numb[pos]\\n else:\\n pos -= self.numb[pos]\\n if pos in vis:\\n result = \\\"IN\\\" + result\\n break\\n\\n return str(result)\",\n \"def overhead(readings):\\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))\",\n \"def bulk_modulus():\\n\\n return 10000.0\",\n \"def annihilation_branching_fractions(self, Q):\\n CSs = self.cross_sections(Q)\\n\\n if CSs[\\\"total\\\"] == 0.0:\\n return {\\\"mu mu\\\": 0.0, \\\"e e\\\": 0.0, \\\"pi0 pi pi\\\": 0.0, \\\"a a\\\": 0.0}\\n else:\\n return {\\n \\\"mu mu\\\": CSs[\\\"mu mu\\\"] / CSs[\\\"total\\\"],\\n \\\"e e\\\": CSs[\\\"e e\\\"] / CSs[\\\"total\\\"],\\n \\\"pi0 pi pi\\\": CSs[\\\"pi0 pi pi\\\"] / CSs[\\\"total\\\"],\\n \\\"a a\\\": CSs[\\\"a a\\\"] / CSs[\\\"total\\\"],\\n }\",\n \"def perturbanceFactor(lenWhole, lenPart, perturbance):\\n k = 1 - perturbance\\n return lenPart ** k / lenWhole ** k\",\n \"def revContFraction(a):\\n N = 1\\n D = a[len(a)-1]\\n\\n for i in range(len(a)-2, -1, -1):\\n N += D * a[i]\\n tmp = N\\n N = D\\n D = tmp\\n return (N,D)\",\n \"def get_load_factor(self):\\r\\n return self.num_items / self.table_size\",\n \"def test02(self):\\n N, blen = self.N, 100\\n a = bcolz.fromiter(xrange(N), dtype=np.float64, count=N,\\n rootdir=self.rootdir)\\n l, s = 0, 0\\n for block in bcolz.iterblocks(a, blen, blen-1):\\n l += len(block)\\n s += block.sum()\\n self.assertEqual(l, (N - (blen - 1)))\\n self.assertEqual(s, np.arange(blen-1, N).sum())\",\n \"def progress(self):\\n try:\\n return 100.0 * (self.fields['sizeWhenDone'] - self.fields['leftUntilDone']) / float(self.fields['sizeWhenDone'])\\n except ZeroDivisionError:\\n return 0.0\",\n \"def far(self):\\n return self.table[0, 1] / (self.table[0, 0] + self.table[0, 1])\",\n \"def update(self, leaf_value):\\n # Count visit.\\n self._n_visits += 1\\n # Update Q, a running average of values for all visits. wtf ??? this line is rigth but kind of wired !\\n self._Q += 1.0 * (leaf_value - self._Q) / self._n_visits\",\n \"def delta(self):\\r\\n return 1 - xl.Refractive_Index_Re(self.compound, self.energy, self.density)\",\n \"def get_sdram_size_of_region_for(self, vertex):\",\n \"def calculate_gc_content(sequence):\\n sequence = sequence.upper()\\n sc = Counter(sequence)\\n return round((sc['C'] + sc['G']) / (sc['A'] + sc['C'] + sc['G'] + sc['T']) * 100, 2)\",\n \"def calculate(index):\\n postingl1 = [len(x[0]) for x in index[0].values()]\\n print(\\\"Number of terms in index i1 : \\\" + str(len(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl1)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl1) / float(len(postingl1))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i1 : \\\" + \\\\\\n str(os.stat('invertedindex1.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl2 = [len(x[0]) for x in index[1].values()]\\n print(\\\"Number of terms in index i2 : \\\" + str(len(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl2)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl2) / float(len(postingl2))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i2 : \\\" + \\\\\\n str(os.stat('invertedindex2.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl3 = [len(x[0]) for x in index[2].values()]\\n print(\\\"Number of terms in index i3 : \\\" + str(len(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl3)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl3) / float(len(postingl3))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i3 : \\\" + \\\\\\n str(os.stat('invertedindex3.txt').st_size) + \\\" bytes\\\\n\\\")\\n\\n postingl4 = [len(x[0]) for x in index[3].values()]\\n print(\\\"Number of terms in index i4 : \\\" + str(len(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Maximum Length of Postings List : \\\" + str(max(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Minimum Length of Postings List : \\\" + str(min(postingl4)) + \\\"\\\\t\\\")\\n print(\\\"Average Length of Postings List : \\\" + str(sum(postingl4) / float(len(postingl4))) + \\\"\\\\t\\\")\\n print(\\\"Size of the file that stores the index i4 : \\\" + \\\\\\n str(os.stat('invertedindex4.txt').st_size) + \\\" bytes\\\\n\\\")\",\n \"def completion_proximity_score(prefix, completion):\\n if prefix == completion:\\n return float(\\\"inf\\\")\\n else:\\n return 1.0 / float(len(completion))\",\n \"def middle_drop(progress):\\n eps = 0.75\\n if 1 - progress < eps:\\n return eps * 0.1\\n return 1 - progress\",\n \"def get_approximate_size(self):\\n return FutureInt64(\\n self.capi.fdb_transaction_get_approximate_size(self.tpointer)\\n )\",\n \"def waste_frac(bucket):\\n if not isinstance(bucket, tuple) or len(bucket) not in {0, 2}:\\n raise ValueError('Wrong bucket format')\\n\\n if not len(bucket):\\n return 0.0\\n\\n boundary, len2freq = bucket\\n zero_cnt = sum([(boundary - 1 - lng) * f for lng, f in len2freq.items()])\\n total_freq = sum([f for _, f in len2freq.items()])\\n\\n return zero_cnt / (total_freq * (boundary - 1))\",\n \"def dist_from_root(self, index):\\n if index == 0:\\n return 0\\n return self.dist_from_root(self.parent(index)) + 1\",\n \"def count_contigs(fastafile):\\n\\n # import file into a dictionary using biopython module\\n from Bio import SeqIO\\n seq_dict = {rec.id : rec.seq for rec in SeqIO.parse(fastafile, \\\"fasta\\\")}\\n\\n # count contigs\\n count_dict = {}\\n for id in seq_dict:\\n count_dict[id] = len(seq_dict[id])\\n\\n # cluster amount of contigs according to their lengths\\n smaller_than_500 = 0\\n up_to_1000bp = 0\\n up_to_5000bp = 0\\n ten_thousand = 0\\n twenty_thousand = 0\\n fifty_thousand = 0\\n hundred_thousand_and_larger = 0\\n larger_than_100000 = 0\\n\\n for id in count_dict:\\n if count_dict[id] <= 500:\\n smaller_than_500 += 1\\n elif 500 < count_dict[id] <= 1000:\\n up_to_1000bp += 1\\n elif 1000 < count_dict[id] <= 5000:\\n up_to_5000bp += 1\\n elif 5000 < count_dict[id] <= 10000:\\n ten_thousand += 1\\n elif 10000 < count_dict[id] <= 20000:\\n twenty_thousand += 1\\n elif 20000 < count_dict[id] <= 50000:\\n fifty_thousand += 1\\n elif 50000 < count_dict[id] <= 100000:\\n hundred_thousand_and_larger += 1\\n elif 100000 < count_dict[id]:\\n larger_than_100000 += 1\\n\\n print (\\\"up to 500 bp:\\\",smaller_than_500)\\n print (\\\"500 to 1000 bp:\\\", up_to_1000bp)\\n print (\\\"1000 - 5000 bp:\\\", up_to_5000bp)\\n print (\\\"5000 - 10 000 bp:\\\", ten_thousand)\\n print (\\\"10 000 - 20 000 bp:\\\", twenty_thousand)\\n print (\\\"20 000 - 50 000 bp:\\\", fifty_thousand)\\n print (\\\"50 000 - 100 000 bp:\\\", hundred_thousand_and_larger)\\n print (\\\"larger than 100 000 bp:\\\", larger_than_100000)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57871044","0.57394934","0.5700969","0.557595","0.55153626","0.5491407","0.54715765","0.54007584","0.53748786","0.5336496","0.5328934","0.5310399","0.5259188","0.52554494","0.5247512","0.5241603","0.5217785","0.51893973","0.51840824","0.5177834","0.5167148","0.51589537","0.51565206","0.5141999","0.5114801","0.51116115","0.5084546","0.5079915","0.50679106","0.5065548","0.50616425","0.50496244","0.5046199","0.5034047","0.5016063","0.5004761","0.500463","0.49972373","0.49965996","0.49898407","0.49817955","0.49748114","0.49733874","0.49715754","0.49662307","0.49626195","0.49537823","0.49511033","0.49480212","0.49435902","0.49434015","0.49368027","0.49242514","0.49239075","0.49239075","0.4911537","0.49073395","0.49036872","0.4898208","0.4897851","0.48945692","0.48896265","0.48874822","0.48778385","0.4876526","0.48746005","0.4872342","0.48704115","0.48702845","0.48634526","0.4859101","0.48550928","0.48523694","0.4846681","0.48416805","0.484","0.48381025","0.4836213","0.48291463","0.48275828","0.4826375","0.48258638","0.482282","0.4821371","0.4820887","0.4820457","0.48179814","0.4811251","0.48076263","0.4806921","0.48041132","0.48036793","0.4803155","0.47971675","0.47930053","0.47839504","0.47836253","0.47825125","0.47821587","0.47808027"],"string":"[\n \"0.57871044\",\n \"0.57394934\",\n \"0.5700969\",\n \"0.557595\",\n \"0.55153626\",\n \"0.5491407\",\n \"0.54715765\",\n \"0.54007584\",\n \"0.53748786\",\n \"0.5336496\",\n \"0.5328934\",\n \"0.5310399\",\n \"0.5259188\",\n \"0.52554494\",\n \"0.5247512\",\n \"0.5241603\",\n \"0.5217785\",\n \"0.51893973\",\n \"0.51840824\",\n \"0.5177834\",\n \"0.5167148\",\n \"0.51589537\",\n \"0.51565206\",\n \"0.5141999\",\n \"0.5114801\",\n \"0.51116115\",\n \"0.5084546\",\n \"0.5079915\",\n \"0.50679106\",\n \"0.5065548\",\n \"0.50616425\",\n \"0.50496244\",\n \"0.5046199\",\n \"0.5034047\",\n \"0.5016063\",\n \"0.5004761\",\n \"0.500463\",\n \"0.49972373\",\n \"0.49965996\",\n \"0.49898407\",\n \"0.49817955\",\n \"0.49748114\",\n \"0.49733874\",\n \"0.49715754\",\n \"0.49662307\",\n \"0.49626195\",\n \"0.49537823\",\n \"0.49511033\",\n \"0.49480212\",\n \"0.49435902\",\n \"0.49434015\",\n \"0.49368027\",\n \"0.49242514\",\n \"0.49239075\",\n \"0.49239075\",\n \"0.4911537\",\n \"0.49073395\",\n \"0.49036872\",\n \"0.4898208\",\n \"0.4897851\",\n \"0.48945692\",\n \"0.48896265\",\n \"0.48874822\",\n \"0.48778385\",\n \"0.4876526\",\n \"0.48746005\",\n \"0.4872342\",\n \"0.48704115\",\n \"0.48702845\",\n \"0.48634526\",\n \"0.4859101\",\n \"0.48550928\",\n \"0.48523694\",\n \"0.4846681\",\n \"0.48416805\",\n \"0.484\",\n \"0.48381025\",\n \"0.4836213\",\n \"0.48291463\",\n \"0.48275828\",\n \"0.4826375\",\n \"0.48258638\",\n \"0.482282\",\n \"0.4821371\",\n \"0.4820887\",\n \"0.4820457\",\n \"0.48179814\",\n \"0.4811251\",\n \"0.48076263\",\n \"0.4806921\",\n \"0.48041132\",\n \"0.48036793\",\n \"0.4803155\",\n \"0.47971675\",\n \"0.47930053\",\n \"0.47839504\",\n \"0.47836253\",\n \"0.47825125\",\n \"0.47821587\",\n \"0.47808027\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.764008"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19489,"cells":{"query":{"kind":"string","value":"Stop iterating this node, until mark_for_review() is called"},"document":{"kind":"string","value":"def pause_review(self, prefix: Nibbles) -> None:\n self._active_prefixes.add(prefix)"},"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 _review_printer(self):\n cont = input(\"Read a review? (y/n) \")\n if cont == 'y':\n review_count = len(self.user_reviews)\n for i in range(review_count):\n # Cycles through all reviews one at a time (amount is chosen by user)\n print('\\n' + self.user_reviews[i])\n if i == (review_count - 1):\n print('\\nEnd of reviews.')\n break\n cont = input(\"\\nRead another review? (y/n) \")\n # Continues on if user says y, ceases if n\n if cont == 'n':\n break","def _do_iteration(self):\n return True","def bookkeep(self) :\n\t\tself.loopiter += 1","def fetch(self):\n self.genre = \"Review\"\n try:\n if not self.__setSoup():\n log.info(self.log_msg(\"Soup not set,returning false\"))\n return False\n #if not self._getParentPage():\n # log.info(self.log_msg(\"Parent page not found\"))\n while True:\n parent_page_soup = copy.copy(self.soup)\n # log.info(self.log_msg('current uri%s'%parent_page_soup))\n if not self.__addReviews():\n log.info(self.log_msg('fetched all reviews for the url %s'\\\n %self.task.instance_data['uri']))\n \n log.info(self.log_msg('Next page%s'%self.currenturi))\n try:\n \n # self.currenturi = self.task.instance_data['uri'].rsplit\\\n # ('/', 1)[0] + '/' + self.soup.find('a', \\\n # title='Go to the next page')['href']\n self.currenturi = 'http://www.phonedog.com' + parent_page_soup.find('a',title='Go to the next page')['href']\n \n if not self.__setSoup():\n log.info(self.log_msg('soup not set for the uri %s'%\\\n self.currenturi))\n break\n except:\n log.info(self.log_msg('Next page not found for the uri %s'%\\\n self.currenturi))\n break\n return True\n except:\n log.exception(self.log_msg(\"Exception in fetch\"))\n return False","def reset_reviews(self):\n # FIXME: this state does not make sense\n self.review_date_set = False\n self.review_comment_set = False","def end_iter(self):\n raise NotImplementedError","def flagNodes(self, kmer_iter):\n for k in kmer_iter:\n k = k.rstrip()\n assert k in self.kmers\n self.G.edge[k + \"_L\"][k + \"_R\"]['bad'] = True","def leave_review(self, product_url, review, review_title):\n raise NotImplementedError","def skip(self):\n self.skip_votes.clear()\n if self.is_playing():\n self.player.stop()","def review(self, review):\n self._review = review","def review(self):\n for player in self.team.players:\n player.career.potentially_retire()","def stop(self):\n return not self.iteration < self.options['max_iters']","def add_review(self, review):\n review_issue = IParentGetter(review).get_parent_object_of_type(\"Issue\")\n if review_issue is None:\n review_issue = IParentGetter(review).get_parent_object_of_type(\"Volume\")\n if self.current_issue != review_issue:\n if self.current_issue:\n self.finish_issue()\n self.current_issue = review_issue\n self.reviews_xml.append(review.restrictedTraverse(self.xml_view_name)())","def process(self):\n self._counter += 1\n if self._counter >= self._iterations:\n self.running = False\n return super().process()","def stop():\n raise StopIteration","def loop_through_units(self):\n\n if self.screenshot_only:\n self.UI.remove_UI()\n\n self.num_units_to_review = len(self.incomplete_list)\n for counter, unit_id in enumerate(self.incomplete_list):\n\n self.current_unit_id = unit_id\n self.identify_unit(unit_id, counter)\n self.add_alerts()\n\n skip_subject = self.load_unit(unit_id)\n\n if skip_subject:\n print('Skipping current subject ..')\n continue\n\n self.display_unit()\n\n # checking if batch generation of screenshots is requested\n if not self.screenshot_only:\n\n print('\\nReviewing {}'.format(unit_id))\n timer_start = timer()\n\n # this is where all the reviewing/rating/notes happen\n self.show_fig_and_wait()\n\n # capturing time elapsed by ID, in seconds\n self.timer[unit_id] = timedelta(seconds=timer() - timer_start).seconds\n\n # TODO save each rating to disk to avoid loss of work due to crach etc\n self.print_rating(unit_id)\n\n if self.quit_now:\n print('\\nUser chosen to quit..')\n break\n else:\n self.export_screenshot()\n # annot text is unit specific\n self.UI.annot_text.remove()","def run(self, __eatery_id):\n self.start = time.time()\n\t \n print __eatery_id\n instance = ClassifyReviews([eatery_id])\n instance.run()\n #return group(callback.clone([arg, __eatery_id]) for arg in __review_list)()","def breakiter(self):\n self._broken = True","def nextIter(self):\n\t\tpass","def test_request_review(self):\n other_pk = self.nodes[1].overlay.my_peer.public_key.key_to_bin()\n self.nodes[0].overlay.request_review(1, other_pk)\n yield self.deliver_messages()\n\n pending_review_requests = self.nodes[1].overlay.trustchain.persistence.get_pending_review_requests(other_pk)\n self.assertTrue(pending_review_requests)\n\n self.nodes[1].overlay.respond_to_review_request(pending_review_requests[0].hash, True)\n yield self.deliver_messages()\n\n pending_review_requests = self.nodes[1].overlay.trustchain.persistence.get_pending_review_requests(other_pk)\n self.assertFalse(pending_review_requests)\n self.assertEqual(self.nodes[0].overlay.trustchain.persistence.get_number_of_known_blocks(), 2)","def next( self ):\n next(self)","def tearDown(self):\n del self.review","def stop(self):\n stopping = False\n if self.currentGeneration > maxIter:\n stopping = True\n logging.info(\"Maximum Iterations Reached!\")\n return stopping","def process_nbk_html(self, limit):\n model = Model(self.graph)\n c = 0\n books_not_found = set()\n for nbk in self.book_ids:\n c += 1\n nbk_id = 'GeneReviews:'+nbk\n book_item = self.all_books.get(nbk)\n url = '/'.join((self.rawdir, book_item['file']))\n\n # figure out if the book is there; if so, process, otherwise skip\n book_dir = '/'.join((self.rawdir, 'books'))\n book_files = os.listdir(book_dir)\n if ''.join((nbk, '.html')) not in book_files:\n # logger.warning(\"No book found locally for %s; skipping\", nbk)\n books_not_found.add(nbk)\n continue\n logger.info(\"Processing %s\", nbk)\n\n page = open(url)\n soup = BeautifulSoup(page.read())\n\n # sec0 == clinical description\n clin_summary = \\\n soup.find(\n 'div', id=re.compile(\".*Summary.sec0\"))\n if clin_summary is not None:\n p = clin_summary.find('p')\n ptext = p.text\n ptext = re.sub(r'\\s+', ' ', ptext)\n\n ul = clin_summary.find('ul')\n if ul is not None:\n item_text = list()\n for li in ul.find_all('li'):\n item_text.append(re.sub(r'\\s+', ' ', li.text))\n ptext += ' '.join(item_text)\n\n # add in the copyright and citation info to description\n ptext = \\\n ' '.join(\n (ptext,\n '[GeneReviews:NBK1116, GeneReviews:NBK138602, ' +\n nbk_id+']'))\n\n model.addDefinition(nbk_id, ptext.strip())\n\n # get the pubs\n pmid_set = set()\n pub_div = soup.find('div', id=re.compile(r\".*Literature_Cited\"))\n if pub_div is not None:\n ref_list = pub_div.find_all('div', attrs={'class': \"bk_ref\"})\n for r in ref_list:\n for a in r.find_all(\n 'a', attrs={'href': re.compile(r\"pubmed\")}):\n if re.match(r'PubMed:', a.text):\n pmnum = re.sub(r'PubMed:\\s*', '', a.text)\n else:\n pmnum = \\\n re.search(\n r'\\/pubmed\\/(\\d+)$', a['href']).group(1)\n if pmnum is not None:\n pmid = 'PMID:'+str(pmnum)\n self.graph.addTriple(\n pmid,\n model.object_properties['is_about'],\n nbk_id)\n pmid_set.add(pmnum)\n reference = Reference(\n self.graph,\n pmid, Reference.ref_types['journal_article'])\n reference.addRefToGraph()\n\n # TODO add author history, copyright, license to dataset\n\n # TODO get PMID-NBKID equivalence (near foot of page),\n # and make it \"is about\" link\n # self.gu.addTriple(\n # self.graph, pmid,\n # self.gu.object_properties['is_about'], nbk_id)\n # for example: NBK1191 PMID:20301370\n\n # add the book to the dataset\n self.dataset.setFileAccessUrl(book_item['url'])\n\n if limit is not None and c > limit:\n break\n\n # finish looping through books\n\n l = len(books_not_found)\n if len(books_not_found) > 0:\n if l > 100:\n logger.warning(\"There were %d books not found.\", l)\n else:\n logger.warning(\n \"The following %d books were not found locally: %s\",\n l, str(books_not_found))\n logger.info(\n \"Finished processing %d books for clinical descriptions\", c-l)\n\n return","def next(self):\n pass","def next(self):\n pass","def next(self):\n pass","def next(self):\n pass","def __iter__(self):\n self.iter_node_ = 1\n return self","def next(self):\r\n pass","def review(self, review: object):\n\n self._review = review","def find_reviews():\n print(\"***** Find Reviews of a Business *****\")\n while (True):\n print()\n business_object = query_business_name()\n if business_object == \"back\":\n return\n elif business_object is None:\n continue\n id = business_object['business_id']\n review_object = review_col.find({\"business_id\": id})\n print(f'{business_object[\"name\"]} has'\n f' {business_object[\"review_count\"]} '\n f'reviews:')\n for review in review_object:\n userid = review['user_id']\n print(f'- ({review[\"stars\"]}):'\n f' {review[\"text\"]}.'\n f' {review[\"date\"]}')","def _inner_priority_gen(infr, use_refresh=False, only_auto=False):\n if infr.refresh:\n infr.refresh.enabled = use_refresh\n infr.print('Start inner loop with {} items in the queue'.format(len(infr.queue)))\n for count in it.count(0):\n if infr.is_recovering():\n infr.print(\n 'Still recovering after %d iterations' % (count,),\n 3,\n color='brightcyan',\n )\n else:\n # Do not check for refresh if we are recovering\n if use_refresh and infr.refresh.check():\n infr.print(\n 'Triggered refresh criteria after %d iterations' % (count,),\n 1,\n color='yellow',\n )\n break\n\n # If the queue is empty break\n if len(infr.queue) == 0:\n infr.print(\n 'No more edges after %d iterations, need refresh' % (count,),\n 1,\n color='yellow',\n )\n break\n\n # Try to automatically do the next review.\n try:\n edge, priority = infr.peek()\n except TypeError:\n infr.print(\n 'Nothing to peek',\n 1,\n color='yellow',\n )\n break\n\n infr.print('next_review. edge={}'.format(edge), 100)\n inconsistent = infr.is_recovering(edge)\n\n feedback = None\n if infr.params['autoreview.enabled'] and not inconsistent:\n # Try to autoreview if we aren't in an inconsistent state\n feedback = infr.try_auto_review(edge)\n\n if feedback is not None:\n # Add feedback from the automated method\n infr.add_feedback(edge, priority=priority, **feedback)\n else:\n # We can't automatically review, ask for help\n if only_auto and not inconsistent:\n # We are in auto only mode, skip manual review\n # unless there is an inconsistency\n infr.skip(edge)\n else:\n if infr.simulation_mode:\n # Use oracle feedback\n feedback = infr.request_oracle_review(edge)\n infr.add_feedback(edge, priority=priority, **feedback)\n else:\n # Yield to the user if we need to pause\n yield infr.emit_manual_review(edge, priority)\n\n if infr.metrics_list:\n infr._print_previous_loop_statistics(count)","def feed(self):\n # or intelligence discard\n pass","def accept_review_step_skip(driver):\n labels = driver.find_elements_by_tag_name(\"label\")\n label = labels[7]\n label.click()\n button = driver.find_element_by_class_name(ALERT_CLASS_NAME)\n button.send_keys(\"\\n\")\n time.sleep(1.5)","def iter_nodes(self):","def end_training(self):\n self.training = False","def end(self, tag):\n if tag == \"node\" and self._current_node:\n self.__save_node()\n self._current_node = None","def _getReview(self,parent_uri):\n try:\n page={}\n review_data = self.current_review.find('div',attrs={'class':'P10'}).findAll('div',attrs={'class':'Std'})\n try:\n page['data']=stripHtml(review_data[1].renderContents())\n except:\n page['data'] = ''\n log.info(self.log_msg(\"Error occured while fetching review data\"))\n \n try:\n review_identity_hash = md5.md5(''.join(sorted(map(lambda x: str(x) if isinstance(x,(int,float)) else x , \\\n page.values()))).encode('utf-8','ignore')).hexdigest()\n except:\n log.info(self.log_msg(\"Error occured while creating the review_identity_hash\"))\n return False\n\n if not checkSessionInfo(self.genre,\n self.session_info_out, \n review_identity_hash,\n self.task.instance_data.get('update'),\n parent_list=[parent_uri]):\n page['title']=''\n try:\n page['et_author_name'] = stripHtml(re.findall(\"^by\\s(\\w+)\",stripHtml(review_data[0].renderContents()))[0])\n except:\n log.info(self.log_msg(\"Error occured while fetching author name\"))\n\n try:\n page['et_author_location']= re.match(\"(.*?--)(.*?--)(.*)$\",stripHtml(review_data[0].renderContents())).group(3).strip()\n\n except:\n log.info(self.log_msg(\"Error occured while fetching author location\")) \n try:\n page['ef_rating_overall'] = float(stripHtml(self.current_review.find('td',attrs={'class':'StdClr2','width':'10%'}).renderContents()))\n except:\n log.info(self.log_msg(\"Error occured while fetching overall rating\"))\n try:\n secondary_ratings = [each for each in self.current_review.find('td',attrs={'class':'rateGFX'}).parent.parent.findAll('tr')\n if each.find('td',attrs={'class':'Std'})]\n\n for each_rating in secondary_ratings:\n try:\n rating_list = each_rating.findAll('td',attrs={'class':'Std'})\n feature_name = stripHtml(rating_list[0].renderContents()).lower().replace(' ','_')\n page['ef_rating_%s'%feature_name] = float(stripHtml(rating_list[1].renderContents()))\n except:\n log.info(\"Secondary rating element not found, continuing to the next element\")\n continue\n except:\n log.info(self.log_msg(\"secondary ratings not found for this review\"))\n\n try:\n review_hash = md5.md5(''.join(sorted(map(lambda x: str(x) if isinstance(x,(int,float)) else x , \\\n page.values()))).encode('utf-8','ignore')).hexdigest()\n except:\n log.info(self.log_msg(\"Error occured while creating the review_hash\"))\n return False\n result=updateSessionInfo(self.genre, self.session_info_out, review_identity_hash, review_hash, \n 'Review', self.task.instance_data.get('update'), parent_list=[parent_uri])\n if result['updated']:\n try:\n review_meta_info = stripHtml(self.current_review.find('div',attrs={'class':'P10'}).findAll('div',attrs={'class':'Std'})[0]\\\n .renderContents())\n posted_date_str = re.findall(\"--([\\w\\s]+)--\",review_meta_info)[0]\n page['posted_date']=datetime.strftime(datetime.strptime(re.sub(\"(\\d+)(st|nd|rd|th)\",r\"\\1\",posted_date_str).strip(),\"%B %d %Y\"),\\\n \"%Y-%m-%dT%H:%M:%SZ\")\n except:\n page['posted_date']=datetime.strftime(datetime.utcnow(),\"%Y-%m-%dT%H:%M:%SZ\") \n log.info(self.log_msg(\"Error occured while fetching posted date\"))\n\n page['uri']=normalize(self.currenturi)\n page['parent_path'] = [parent_uri]\n page['path'] = [parent_uri,review_identity_hash]\n page['task_log_id']=self.task.id\n page['versioned']=self.task.instance_data.get('versioned',False)\n page['category']=self.task.instance_data.get('category','generic')\n page['last_updated_time']= datetime.strftime(datetime.utcnow(),\"%Y-%m-%dT%H:%M:%SZ\") #Now\n page['client_name']=self.task.client_name\n page['entity']='review'\n page['uri_domain'] = urlparse(page['uri'])[1]\n page['priority']=self.task.priority\n page['level']=self.task.level\n page['pickup_date'] = datetime.strftime(datetime.utcnow(),\"%Y-%m-%dT%H:%M:%SZ\")\n page['connector_instance_log_id'] = self.task.connector_instance_log_id\n page['connector_instance_id'] = self.task.connector_instance_id\n page['workspace_id'] = self.task.workspace_id\n page['client_id'] = self.task.client_id # TODO: Get the client from the project\n log.debug(self.log_msg(\"Adding review for the url %s\" %self.currenturi))\n self.pages.append(page)\n return True\n else:\n log.debug(self.log_msg(\"Not adding review to pages\"))\n return False\n else:\n log.debug(self.log_msg(\"Not adding review to pages\"))\n return False\n except Exception,e:\n log.exception(self.log_msg(\"Exception occured in _getReview()\"))\n raise e","def loop(self):\n yield self\n e = self.next\n while e is not self:\n yield e\n e = e.next","def iterate(self):\n raise NotImplementedError()","def run(self, iter: int = -1):\n try:\n while iter != 0:\n self.iteration_count += 1\n iso = self._iso_observe()\n self._propagate(iso)\n iter -= 1\n except _FinishedObserving:\n return True\n except _Contradiction:\n return False","def reset(self):\n debug('resetting')\n self.marked = False","def _process_reviews(self):\n params = {'add_special_tokens': True, 'max_length': self._max_len,\n 'return_token_type_ids': False, 'pad_to_max_length': True,\n 'return_attention_mask': True, 'return_tensors': 'pt'}\n\n self._tokens = self._review.apply(self._tokenizer.encode_plus, **params)","def next(self):\n raise NotImplementedError","def cmd_k(self):\n node = self.start\n while node is not None:\n if node == self.cursor:\n if node.prev is not None:\n self.cursor = node.prev\n break\n node = node.next\n self.get_text()","def reset(self):\n for c in self.children:\n c.reset()\n self.marked = False","def remove(self):\n self.iterator.remove()","def __iteratePosts(self):\n try:\n posts = self.soup.findAll('div', 'lia-message-view')\n if not posts:\n log.info(self.log_msg('No posts found'))\n return False\n log.debug(self.log_msg('Total No of Posts found is %d'%len(posts)))\n posts.reverse()\n for post in posts:\n if not self.__addPost(post):\n log.info(self.log_msg('Post not added to self.pages for url\\\n %s'%self.currenturi))\n return False\n return True\n except:\n log.exception(self.log_msg('Reviews are not found for url %s'%self.currenturi))\n return False","def post_review(self, form):\n comments_file = form.cleaned_data.get('comments', None)\n return_code = form.cleaned_data.get('return_code', None)\n\n # Update the review\n self.object.post_review(comments_file, return_code=return_code)\n if return_code:\n self.revision.return_code = return_code\n\n verb = None\n # If every reviewer has posted comments, close the reviewers step\n if self.object.role == 'reviewer':\n qs = Review.objects \\\n .filter(document=self.document) \\\n .filter(revision=self.revision.revision) \\\n .filter(role='reviewer') \\\n .exclude(closed_on=None)\n if qs.count() == self.revision.reviewers.count():\n self.revision.end_reviewers_step(save=False)\n verb = Activity.VERB_CLOSED_REVIEWER_STEP\n\n # If leader, end leader step\n elif self.object.role == 'leader':\n self.revision.end_leader_step(save=False)\n verb = Activity.VERB_CLOSED_LEADER_STEP\n\n # If approver, end approver step\n elif self.object.role == 'approver':\n self.revision.end_review(save=False)\n verb = Activity.VERB_CLOSED_APPROVER_STEP\n\n self.revision.save(update_document=True)\n\n if verb:\n activity_log.send(verb=verb,\n target=self.revision,\n sender=do_batch_import,\n actor=self.request.user)","def auto_review(self, auto_review):\n \n self._auto_review = auto_review","def set_reviewing(self, revert=None):\n self.connection.set_reviewing(self.mturk_id, revert=revert)\n self.update()","def auto_review(self):\n return self._auto_review","def traverse_ancestors(self):\n self.event.wait()\n for a in super(FalseObject, self).traverse_ancestors():\n yield a","def review(self):\n return self._review","def next(self):\n while not self.is_stable():\n self.step()","def next_iter(self):\n self.is_first_iter = False\n self.handles_to_post_forward_order_index.clear()\n self.handles_post_forward_order.clear()\n if self._checking_order:\n self.current_order_index = 0\n if self.warn_status == _ExecOrderWarnStatus.WARNING:\n self.warn_status = _ExecOrderWarnStatus.WARNED","def filter_reviews():\n print(\"***** Filter Specific Rating Reviews of a Business *****\")\n while (True):\n print()\n business_object = query_business_name()\n if business_object == \"back\":\n return\n elif business_object is None:\n continue\n id = business_object['business_id']\n rating = float(input(\n f'Please enter the number 1-5 to see reviews of {business_object[\"name\"]}: '))\n review_object = review_col.find({\"business_id\": id,\n \"stars\": rating}).limit(10)\n print()\n for review in review_object:\n userid = review['user_id']\n username = user_col.find_one({\"user_id\": userid})\n print(f'- {username[\"name\"]} ({review[\"stars\"]}):'\n f' {review[\"text\"]}.'\n f' {review[\"date\"]}')","def do_fold(self) -> None:\r\n self.active = False","def continue_next(self):\n\n self.scope_assign = {}\n self.scope_var_id = 0\n self.cont = True","def iterate(self):","def set_test_loop(self , _iter):\n\t\tself.__test=_iter","def dispatch_next(self):\n if not self.dispatch_one_batch(self._original_iterator):\n self._iterating = False\n self._original_iterator = None","def __iter__(self):\n if self.is_empty():\n self._current_node = None\n else:\n self._current_node = self._tail._next\n return self","def review(self) -> object:\n return self._review","def iterate_tsne(self):\n send_stop_event = False\n if self.analysis is None:\n return\n if not self._stop_iter:\n self.timer_count = self.timer_count + 1\n for j in range(self.iters_per_frame):\n self.analysis.do_iteration()\n self._iter_count = self.timer_count * self.iters_per_frame + j\n self.status.showMessage(f\"Iteration: {self._iter_count}\")\n\n if self.timer_count == self.num_frames - 1:\n self._stop_iter = True\n send_stop_event = True\n self.timer_count = 0\n self.status.showMessage(\"Iteration: Completed\")\n\n # Update point positions\n self.embedding_viewer.update_plot(self.analysis.embedding)\n else:\n if self.timer_count % 10 == 0:\n self.embedding_viewer.force_refresh()\n\n if send_stop_event:\n self.embedding_viewer.force_refresh()\n time.sleep(0.1)\n self.analysis_stopped(self.analysis,\n self.embedding_viewer.get_figure_as_buffer())","def greedy(self) -> Action:\n return NotImplemented","def fetch(self):\n try:\n self.genre = 'Review'\n log.debug(self.log_msg(\"Fetching the prouct page url %s\"%self.currenturi))\n res=self._getHTML(self.currenturi) # Assuming self.currenturi is at the product page\n self.rawpage=res['result']\n self._setCurrentPage()\n try:\n self.parent_page_title = stripHtml(self.soup.find('h1',{'id':'pgTitleDetail'}).renderContents())\n except:\n self.parent_page_title =''\n try:\n self.__product_price = self.soup.find('tbody',{'class':'prices'}).td.renderContents().replace('$','')\n except:\n log.exception(\"Error in fetching product_price\")\n self.__product_price = None\n\n parent_page_url = self.task.instance_data['uri']\n review_first_page_url = self.soup.find('a',text=\"Show All Customer Reviews » \").parent['href']\n review_url_order = \"&sortReviewsBy=DateDescending\"\n self.currenturi = self.base_url + review_first_page_url + review_url_order\n log.info(self.log_msg('current_uri :: %s'%(self.currenturi)))\n self._getParentPage()\n self.next_url_links=[]\n self.fetch_next_link = True\n while self.fetch_next_link:\n self._iterateReviewPages(parent_page_url)\n return True\n except Exception,e:\n log.exception(self.log_msg(\"Exception occured in fetch()\"))\n return False","def get_item_reviews(self, soup: BeautifulSoup) -> None:\n try:\n reviews = soup.find(\"span\", class_=\"_a7a5sx\").get_text()\n reviews = re.findall(\"[0-9]+\", reviews)[0]\n except AttributeError:\n reviews = None\n self.__collected_dic[\"reviews\"].append(reviews)","def advance(self) -> None:\n pass","def go_again(self):\n return True","def go_again(self):\n return False","def __iter__(self):\n self._current_node = self._head\n return self","def keep_first_iteration(self):\n self.keep_first_iteration_flag = True","def _stop_iter(self, query_i, n_pool):\n\n stop_iter = False\n n_train = self.X.shape[0] - n_pool\n\n # if the pool is empty, always stop\n if n_pool == 0:\n stop_iter = True\n\n # If we are exceeding the number of papers, stop.\n if self.n_papers is not None and n_train >= self.n_papers:\n stop_iter = True\n\n # don't stop if there is no stopping criteria\n if self.n_queries is not None and query_i >= self.n_queries:\n stop_iter = True\n\n return stop_iter","def _reject_rendering(self):\n\n curItem = self.tree.focus()\n parent = self.tree.parent(curItem)\n\n categories = ['approved', 'conflicts', 'suggestions', 'unknown', \\\n 'cldr',]\n if parent is '':\n #skip it\n pass\n else:\n if parent not in categories:\n curTerm = parent\n category = self.tree.parent(parent)\n else:\n curTerm = curItem\n category = parent\n if category == 'approved':\n #move from approved to unknown, with rendering deleted\n self.tree.item(curTerm, \\\n values=[self.tree.item(curTerm)['values'][0], ''])\n self.tree.move(curTerm, 'unknown', 'end')\n pass\n elif category == 'sugestions':\n if curTerm != curItem:\n self.tree.delete(curItem)\n if len(self.tree.get_children(curTerm)) < 1:\n self.tree.move(curTerm, 'unknown', 'end')\n # move curTrem from suggestions to unknown\n else: #if curTerm == curItem:\n self.tree.delete(*self.tree.get_children(curTerm))\n self.tree.move(curTerm, 'unknown', 'end')\n pass\n elif category == 'conflicts':\n if curTerm != curItem:\n self.tree.delete(curItem)\n if len(self.tree.get_children(curTerm)) == 1:\n curItem = self.tree.get_children(curTerm)[0]\n va = self.tree.item(curTerm)['values']\n vb = self.tree.item(curItem)['values']\n self.tree.item(curTerm, values=[va[0], vb[1]])\n self.tree.item(curTerm, tags='approved')\n self.tree.move(curTerm, 'approved', 'end')\n pass\n elif category == 'unknown':\n #ignore\n pass\n elif category == 'cldr':\n #ignore\n pass\n else:\n messagebox.showerror('_reject_rendering', \\\n 'Unknown category {}.'.format(category))\n\n self._make_suggestions()\n \n self.tree.tag_configure('approved', background='palegreen')\n self.tree.tag_configure('conflict', background='bisque')\n self.tree.tag_configure('suggestions', background='lightblue')\n self.tree.tag_configure('unknown', background='whitesmoke')\n self.tree.tag_configure('cldr', background='violet')\n self.update()","def ignore_visit_interslide(self, node):\n raise SkipNode","def fetch(self):\n \n self.genre=\"Review\"\n \n try:\n self.parent_uri = self.currenturi\n \n self.total_threads_count = 0\n self.last_timestamp = datetime( 1980,1,1 )\n if tg.config.get(path='Connector',key='collegenet_max_threads_to_process'):\n self.max_threads_count = int(tg.config.get(path='Connector',key='collegenet_max_threads_to_process'))\n else:\n self.max_threads_count = None\n \n self.collegenetTimelag_max = tg.config.get(path='Connector', key='collegenet_search_timeLag_max')\n self.collegenetTimelag_min = tg.config.get(path='Connector', key='collegenet_search_timeLag_min')\n log.info(self.log_msg('Time Logs :::::::'))\n log.info(self.collegenetTimelag_max)\n log.info(self.collegenetTimelag_min)\n \n## if self.collegenetTimelag_min and self.collegenetTimelag_max:\n## randomTimeLag = random.randint(self.collegenetTimelag_min,self.collegenetTimelag_max) / 1000.0000\n## log.info('sleeping for %s seconds between requests'%randomTimeLag)\n## time.sleep(randomTimeLag)\n \n if not self.__setSoup():\n log.exception(self.log_msg('Soup not set ..... '))\n return False\n \n #post_no = 0 #Remove\n while True:\n #if post_no==3: #Remove\n # break #Remove\n #post_no = post_no + 1 #Remove\n \n currenturi = self.currenturi\n if not self.__addPosts():\n break \n #Get \"post\" information\n #break #Remove\n self.currenturi = currenturi\n if self.collegenetTimelag_min and self.collegenetTimelag_max:\n randomTimeLag = random.randint(self.collegenetTimelag_min,self.collegenetTimelag_max) / 1000.0000\n log.info('sleeping for %s seconds between requests'%randomTimeLag)\n time.sleep(randomTimeLag)\n #We need to set soup again as addPosts() method is changing self.currenturi and self.soup\n if not self.__setSoup():\n log.info(self.log_msg('Soup not set.... break while loop.'))\n break\n \n try:\n next_uri = baseuri + self.soup.find('div',id='search_results_controls').find('a',text=re.compile('>')) \\\n .parent['href']\n self.currenturi = next_uri\n log.info(self.log_msg('Next URI :::::::;'))\n log.info(next_uri)\n except:\n log.exception(self.log_msg('Next Post link not found'))\n break\n \n## if self.collegenetTimelag_min and self.collegenetTimelag_max:\n## randomTimeLag = random.randint(self.collegenetTimelag_min,self.collegenetTimelag_max) / 1000.0000\n## log.info('sleeping for %s seconds between requests'%randomTimeLag)\n## time.sleep(randomTimeLag)\n \n if not self.__setSoup():\n log.info(self.log_msg('Soup not set.... break while loop.'))\n break\n \n return True\n \n except:\n log.exception(self.log_msg('Exception in fetch'))\n return False","def ROOMSELECTION_LOOP():\n pass","def main_loop(infr, max_loops=None, use_refresh=True):\n raise RuntimeError()\n infr.start_id_review(max_loops=max_loops, use_refresh=use_refresh)\n # To automatically run through the loop just exhaust the generator\n try:\n result = next(infr._gen)\n except StopIteration:\n pass\n assert result is None, 'need user interaction. cannot auto loop'\n infr._gen = None","def __call__(\n self, document: tp.Optional[dict]\n ) -> tp.Optional[tp.Generator[dict, None, None]]:\n if document is None:\n return\n\n if isstopiteration(document):\n self._count_stop_iteration += 1\n if self._count_stop_iteration == self._nb_input_nodes:\n yield STOP_ITERATION\n else:\n if self._drop:\n new_doc = deepcopy(document)\n for key in self._keys:\n try:\n new_doc.pop(key)\n except KeyError:\n continue\n else:\n new_doc = dict()\n for key in self._keys:\n try:\n new_doc[key] = document[key]\n except KeyError:\n continue\n yield new_doc","def evaluate(self):\n self.training = False","def get_user_reviews(self):\n raw_review_data = imdb.get_title_user_reviews(self.ID) # Returns dictionary of dicts\n reviews_dict = raw_review_data['reviews'] # Stores the dictionary of reviews\n for dictionary in reviews_dict:\n self.user_reviews.append(dictionary['reviewText'])\n # Appends review text to list\n self._review_printer() # Calls printer to output reviews","def start_iter(self):\n raise NotImplementedError","def hasNext(self) -> bool:\n ...","def prune(self, x_val, y_val):\n\n # make sure that the classifier has been trained before predicting\n if not self.is_trained:\n raise Exception(\"DecisionTreeClassifier has not yet been trained.\")\n\n # get the maximum depth\n deepest_depth = get_max_depth(self.root)\n\n # explore the depth starting from (max_depth - 1) to half of the max_depth\n half_of_max_depth = deepest_depth // 2\n for depth in range(deepest_depth - 1, half_of_max_depth, -1):\n explore_nodes_to_prune(self, self.root, x_val, y_val, depth)\n\n print(\"Pruning completed\")","def delete_business_rating():\n print(\"***** Deleting Rating *****\")\n while True:\n print()\n business_object = query_business_name()\n if business_object == \"back\":\n return\n elif business_object is None:\n continue\n\n print(\"Please wait...\")\n\n # find review using business id and user id\n business_id = business_object['business_id']\n review_obj = review_col.find_one({\"user_id\": app.USER_ID})\n\n if review_obj:\n print('This is your review for ' + business_object['name'] + ': ')\n print('Stars: ' + str(review_obj['stars']))\n print('Review: ' + review_obj['text'])\n\n choice = input(\n '\\nDo you want to delete this review? Type \"yes\" to delete, type \"back\" to go back: ')\n if choice == 'back':\n return\n elif choice == 'yes':\n review_col.remove(review_obj)\n print(\"\\nYour review has been deleted!\")\n else:\n print(\"Invalid choice\")\n return\n else:\n print(\"You have no review for \" + business_object['name'] + \"\\n\")\n return\n print()","def train_loop_post(self, current_step):\r\n pass","def _stop(self):\n if self._classifier:\n self._classifier.__exit__()\n self._classifier = None","def hasNext(self):\n if self.tree:\n return True\n else:\n return False","def analyse(self):\n self.__gather_tagged_reviews(self._restaurants)","def __iter__(self):\n for node in self.grammar.walk():\n yield node","def hasNext(self) -> bool:\n return self.pointer < len(self.ordered_nodes)","def __iter__(self):\n while (self.pointsleft > 0):\n current = min(self.pointsleft, self.settings.LOCALSKIPNUM)\n for i in range(current):\n self.add(self.fabric.getcoordinate())\n self.pointsleft -= self.settings.LOCALSKIPNUM\n self.pointscontroller.set(self.graph)\n yield self.graph","def iteration(self) -> global___Statement.Iteration:","def iteration(self) -> global___Statement.Iteration:","def __iter__(self):\n self.current = self.start\n self.returned = 0\n return self","def __iter__(self):\n return iter(self.node)","def visit(self):\n self.tree = self.recursive_visit(self.tree)\n # assert self.current_line == self.tree.absolute_bounding_box.bottom_right.line","def endDocument(self):\n self.return_q.put(self.obj_depth[-1])","def iter_followings(self) -> Iterator[ChildNodeType]:\n if self.item is None or self.item is self.root:\n return\n elif isinstance(self.item, ElementNode):\n status = self.item, self.axis\n self.axis = 'following'\n item = self.item\n\n descendants = set(item.iter_descendants())\n for self.item in self.root.iter_descendants(with_self=False):\n if item.position < self.item.position and self.item not in descendants:\n yield cast(ChildNodeType, self.item)\n\n self.item, self.axis = status"],"string":"[\n \"def _review_printer(self):\\n cont = input(\\\"Read a review? (y/n) \\\")\\n if cont == 'y':\\n review_count = len(self.user_reviews)\\n for i in range(review_count):\\n # Cycles through all reviews one at a time (amount is chosen by user)\\n print('\\\\n' + self.user_reviews[i])\\n if i == (review_count - 1):\\n print('\\\\nEnd of reviews.')\\n break\\n cont = input(\\\"\\\\nRead another review? (y/n) \\\")\\n # Continues on if user says y, ceases if n\\n if cont == 'n':\\n break\",\n \"def _do_iteration(self):\\n return True\",\n \"def bookkeep(self) :\\n\\t\\tself.loopiter += 1\",\n \"def fetch(self):\\n self.genre = \\\"Review\\\"\\n try:\\n if not self.__setSoup():\\n log.info(self.log_msg(\\\"Soup not set,returning false\\\"))\\n return False\\n #if not self._getParentPage():\\n # log.info(self.log_msg(\\\"Parent page not found\\\"))\\n while True:\\n parent_page_soup = copy.copy(self.soup)\\n # log.info(self.log_msg('current uri%s'%parent_page_soup))\\n if not self.__addReviews():\\n log.info(self.log_msg('fetched all reviews for the url %s'\\\\\\n %self.task.instance_data['uri']))\\n \\n log.info(self.log_msg('Next page%s'%self.currenturi))\\n try:\\n \\n # self.currenturi = self.task.instance_data['uri'].rsplit\\\\\\n # ('/', 1)[0] + '/' + self.soup.find('a', \\\\\\n # title='Go to the next page')['href']\\n self.currenturi = 'http://www.phonedog.com' + parent_page_soup.find('a',title='Go to the next page')['href']\\n \\n if not self.__setSoup():\\n log.info(self.log_msg('soup not set for the uri %s'%\\\\\\n self.currenturi))\\n break\\n except:\\n log.info(self.log_msg('Next page not found for the uri %s'%\\\\\\n self.currenturi))\\n break\\n return True\\n except:\\n log.exception(self.log_msg(\\\"Exception in fetch\\\"))\\n return False\",\n \"def reset_reviews(self):\\n # FIXME: this state does not make sense\\n self.review_date_set = False\\n self.review_comment_set = False\",\n \"def end_iter(self):\\n raise NotImplementedError\",\n \"def flagNodes(self, kmer_iter):\\n for k in kmer_iter:\\n k = k.rstrip()\\n assert k in self.kmers\\n self.G.edge[k + \\\"_L\\\"][k + \\\"_R\\\"]['bad'] = True\",\n \"def leave_review(self, product_url, review, review_title):\\n raise NotImplementedError\",\n \"def skip(self):\\n self.skip_votes.clear()\\n if self.is_playing():\\n self.player.stop()\",\n \"def review(self, review):\\n self._review = review\",\n \"def review(self):\\n for player in self.team.players:\\n player.career.potentially_retire()\",\n \"def stop(self):\\n return not self.iteration < self.options['max_iters']\",\n \"def add_review(self, review):\\n review_issue = IParentGetter(review).get_parent_object_of_type(\\\"Issue\\\")\\n if review_issue is None:\\n review_issue = IParentGetter(review).get_parent_object_of_type(\\\"Volume\\\")\\n if self.current_issue != review_issue:\\n if self.current_issue:\\n self.finish_issue()\\n self.current_issue = review_issue\\n self.reviews_xml.append(review.restrictedTraverse(self.xml_view_name)())\",\n \"def process(self):\\n self._counter += 1\\n if self._counter >= self._iterations:\\n self.running = False\\n return super().process()\",\n \"def stop():\\n raise StopIteration\",\n \"def loop_through_units(self):\\n\\n if self.screenshot_only:\\n self.UI.remove_UI()\\n\\n self.num_units_to_review = len(self.incomplete_list)\\n for counter, unit_id in enumerate(self.incomplete_list):\\n\\n self.current_unit_id = unit_id\\n self.identify_unit(unit_id, counter)\\n self.add_alerts()\\n\\n skip_subject = self.load_unit(unit_id)\\n\\n if skip_subject:\\n print('Skipping current subject ..')\\n continue\\n\\n self.display_unit()\\n\\n # checking if batch generation of screenshots is requested\\n if not self.screenshot_only:\\n\\n print('\\\\nReviewing {}'.format(unit_id))\\n timer_start = timer()\\n\\n # this is where all the reviewing/rating/notes happen\\n self.show_fig_and_wait()\\n\\n # capturing time elapsed by ID, in seconds\\n self.timer[unit_id] = timedelta(seconds=timer() - timer_start).seconds\\n\\n # TODO save each rating to disk to avoid loss of work due to crach etc\\n self.print_rating(unit_id)\\n\\n if self.quit_now:\\n print('\\\\nUser chosen to quit..')\\n break\\n else:\\n self.export_screenshot()\\n # annot text is unit specific\\n self.UI.annot_text.remove()\",\n \"def run(self, __eatery_id):\\n self.start = time.time()\\n\\t \\n print __eatery_id\\n instance = ClassifyReviews([eatery_id])\\n instance.run()\\n #return group(callback.clone([arg, __eatery_id]) for arg in __review_list)()\",\n \"def breakiter(self):\\n self._broken = True\",\n \"def nextIter(self):\\n\\t\\tpass\",\n \"def test_request_review(self):\\n other_pk = self.nodes[1].overlay.my_peer.public_key.key_to_bin()\\n self.nodes[0].overlay.request_review(1, other_pk)\\n yield self.deliver_messages()\\n\\n pending_review_requests = self.nodes[1].overlay.trustchain.persistence.get_pending_review_requests(other_pk)\\n self.assertTrue(pending_review_requests)\\n\\n self.nodes[1].overlay.respond_to_review_request(pending_review_requests[0].hash, True)\\n yield self.deliver_messages()\\n\\n pending_review_requests = self.nodes[1].overlay.trustchain.persistence.get_pending_review_requests(other_pk)\\n self.assertFalse(pending_review_requests)\\n self.assertEqual(self.nodes[0].overlay.trustchain.persistence.get_number_of_known_blocks(), 2)\",\n \"def next( self ):\\n next(self)\",\n \"def tearDown(self):\\n del self.review\",\n \"def stop(self):\\n stopping = False\\n if self.currentGeneration > maxIter:\\n stopping = True\\n logging.info(\\\"Maximum Iterations Reached!\\\")\\n return stopping\",\n \"def process_nbk_html(self, limit):\\n model = Model(self.graph)\\n c = 0\\n books_not_found = set()\\n for nbk in self.book_ids:\\n c += 1\\n nbk_id = 'GeneReviews:'+nbk\\n book_item = self.all_books.get(nbk)\\n url = '/'.join((self.rawdir, book_item['file']))\\n\\n # figure out if the book is there; if so, process, otherwise skip\\n book_dir = '/'.join((self.rawdir, 'books'))\\n book_files = os.listdir(book_dir)\\n if ''.join((nbk, '.html')) not in book_files:\\n # logger.warning(\\\"No book found locally for %s; skipping\\\", nbk)\\n books_not_found.add(nbk)\\n continue\\n logger.info(\\\"Processing %s\\\", nbk)\\n\\n page = open(url)\\n soup = BeautifulSoup(page.read())\\n\\n # sec0 == clinical description\\n clin_summary = \\\\\\n soup.find(\\n 'div', id=re.compile(\\\".*Summary.sec0\\\"))\\n if clin_summary is not None:\\n p = clin_summary.find('p')\\n ptext = p.text\\n ptext = re.sub(r'\\\\s+', ' ', ptext)\\n\\n ul = clin_summary.find('ul')\\n if ul is not None:\\n item_text = list()\\n for li in ul.find_all('li'):\\n item_text.append(re.sub(r'\\\\s+', ' ', li.text))\\n ptext += ' '.join(item_text)\\n\\n # add in the copyright and citation info to description\\n ptext = \\\\\\n ' '.join(\\n (ptext,\\n '[GeneReviews:NBK1116, GeneReviews:NBK138602, ' +\\n nbk_id+']'))\\n\\n model.addDefinition(nbk_id, ptext.strip())\\n\\n # get the pubs\\n pmid_set = set()\\n pub_div = soup.find('div', id=re.compile(r\\\".*Literature_Cited\\\"))\\n if pub_div is not None:\\n ref_list = pub_div.find_all('div', attrs={'class': \\\"bk_ref\\\"})\\n for r in ref_list:\\n for a in r.find_all(\\n 'a', attrs={'href': re.compile(r\\\"pubmed\\\")}):\\n if re.match(r'PubMed:', a.text):\\n pmnum = re.sub(r'PubMed:\\\\s*', '', a.text)\\n else:\\n pmnum = \\\\\\n re.search(\\n r'\\\\/pubmed\\\\/(\\\\d+)$', a['href']).group(1)\\n if pmnum is not None:\\n pmid = 'PMID:'+str(pmnum)\\n self.graph.addTriple(\\n pmid,\\n model.object_properties['is_about'],\\n nbk_id)\\n pmid_set.add(pmnum)\\n reference = Reference(\\n self.graph,\\n pmid, Reference.ref_types['journal_article'])\\n reference.addRefToGraph()\\n\\n # TODO add author history, copyright, license to dataset\\n\\n # TODO get PMID-NBKID equivalence (near foot of page),\\n # and make it \\\"is about\\\" link\\n # self.gu.addTriple(\\n # self.graph, pmid,\\n # self.gu.object_properties['is_about'], nbk_id)\\n # for example: NBK1191 PMID:20301370\\n\\n # add the book to the dataset\\n self.dataset.setFileAccessUrl(book_item['url'])\\n\\n if limit is not None and c > limit:\\n break\\n\\n # finish looping through books\\n\\n l = len(books_not_found)\\n if len(books_not_found) > 0:\\n if l > 100:\\n logger.warning(\\\"There were %d books not found.\\\", l)\\n else:\\n logger.warning(\\n \\\"The following %d books were not found locally: %s\\\",\\n l, str(books_not_found))\\n logger.info(\\n \\\"Finished processing %d books for clinical descriptions\\\", c-l)\\n\\n return\",\n \"def next(self):\\n pass\",\n \"def next(self):\\n pass\",\n \"def next(self):\\n pass\",\n \"def next(self):\\n pass\",\n \"def __iter__(self):\\n self.iter_node_ = 1\\n return self\",\n \"def next(self):\\r\\n pass\",\n \"def review(self, review: object):\\n\\n self._review = review\",\n \"def find_reviews():\\n print(\\\"***** Find Reviews of a Business *****\\\")\\n while (True):\\n print()\\n business_object = query_business_name()\\n if business_object == \\\"back\\\":\\n return\\n elif business_object is None:\\n continue\\n id = business_object['business_id']\\n review_object = review_col.find({\\\"business_id\\\": id})\\n print(f'{business_object[\\\"name\\\"]} has'\\n f' {business_object[\\\"review_count\\\"]} '\\n f'reviews:')\\n for review in review_object:\\n userid = review['user_id']\\n print(f'- ({review[\\\"stars\\\"]}):'\\n f' {review[\\\"text\\\"]}.'\\n f' {review[\\\"date\\\"]}')\",\n \"def _inner_priority_gen(infr, use_refresh=False, only_auto=False):\\n if infr.refresh:\\n infr.refresh.enabled = use_refresh\\n infr.print('Start inner loop with {} items in the queue'.format(len(infr.queue)))\\n for count in it.count(0):\\n if infr.is_recovering():\\n infr.print(\\n 'Still recovering after %d iterations' % (count,),\\n 3,\\n color='brightcyan',\\n )\\n else:\\n # Do not check for refresh if we are recovering\\n if use_refresh and infr.refresh.check():\\n infr.print(\\n 'Triggered refresh criteria after %d iterations' % (count,),\\n 1,\\n color='yellow',\\n )\\n break\\n\\n # If the queue is empty break\\n if len(infr.queue) == 0:\\n infr.print(\\n 'No more edges after %d iterations, need refresh' % (count,),\\n 1,\\n color='yellow',\\n )\\n break\\n\\n # Try to automatically do the next review.\\n try:\\n edge, priority = infr.peek()\\n except TypeError:\\n infr.print(\\n 'Nothing to peek',\\n 1,\\n color='yellow',\\n )\\n break\\n\\n infr.print('next_review. edge={}'.format(edge), 100)\\n inconsistent = infr.is_recovering(edge)\\n\\n feedback = None\\n if infr.params['autoreview.enabled'] and not inconsistent:\\n # Try to autoreview if we aren't in an inconsistent state\\n feedback = infr.try_auto_review(edge)\\n\\n if feedback is not None:\\n # Add feedback from the automated method\\n infr.add_feedback(edge, priority=priority, **feedback)\\n else:\\n # We can't automatically review, ask for help\\n if only_auto and not inconsistent:\\n # We are in auto only mode, skip manual review\\n # unless there is an inconsistency\\n infr.skip(edge)\\n else:\\n if infr.simulation_mode:\\n # Use oracle feedback\\n feedback = infr.request_oracle_review(edge)\\n infr.add_feedback(edge, priority=priority, **feedback)\\n else:\\n # Yield to the user if we need to pause\\n yield infr.emit_manual_review(edge, priority)\\n\\n if infr.metrics_list:\\n infr._print_previous_loop_statistics(count)\",\n \"def feed(self):\\n # or intelligence discard\\n pass\",\n \"def accept_review_step_skip(driver):\\n labels = driver.find_elements_by_tag_name(\\\"label\\\")\\n label = labels[7]\\n label.click()\\n button = driver.find_element_by_class_name(ALERT_CLASS_NAME)\\n button.send_keys(\\\"\\\\n\\\")\\n time.sleep(1.5)\",\n \"def iter_nodes(self):\",\n \"def end_training(self):\\n self.training = False\",\n \"def end(self, tag):\\n if tag == \\\"node\\\" and self._current_node:\\n self.__save_node()\\n self._current_node = None\",\n \"def _getReview(self,parent_uri):\\n try:\\n page={}\\n review_data = self.current_review.find('div',attrs={'class':'P10'}).findAll('div',attrs={'class':'Std'})\\n try:\\n page['data']=stripHtml(review_data[1].renderContents())\\n except:\\n page['data'] = ''\\n log.info(self.log_msg(\\\"Error occured while fetching review data\\\"))\\n \\n try:\\n review_identity_hash = md5.md5(''.join(sorted(map(lambda x: str(x) if isinstance(x,(int,float)) else x , \\\\\\n page.values()))).encode('utf-8','ignore')).hexdigest()\\n except:\\n log.info(self.log_msg(\\\"Error occured while creating the review_identity_hash\\\"))\\n return False\\n\\n if not checkSessionInfo(self.genre,\\n self.session_info_out, \\n review_identity_hash,\\n self.task.instance_data.get('update'),\\n parent_list=[parent_uri]):\\n page['title']=''\\n try:\\n page['et_author_name'] = stripHtml(re.findall(\\\"^by\\\\s(\\\\w+)\\\",stripHtml(review_data[0].renderContents()))[0])\\n except:\\n log.info(self.log_msg(\\\"Error occured while fetching author name\\\"))\\n\\n try:\\n page['et_author_location']= re.match(\\\"(.*?--)(.*?--)(.*)$\\\",stripHtml(review_data[0].renderContents())).group(3).strip()\\n\\n except:\\n log.info(self.log_msg(\\\"Error occured while fetching author location\\\")) \\n try:\\n page['ef_rating_overall'] = float(stripHtml(self.current_review.find('td',attrs={'class':'StdClr2','width':'10%'}).renderContents()))\\n except:\\n log.info(self.log_msg(\\\"Error occured while fetching overall rating\\\"))\\n try:\\n secondary_ratings = [each for each in self.current_review.find('td',attrs={'class':'rateGFX'}).parent.parent.findAll('tr')\\n if each.find('td',attrs={'class':'Std'})]\\n\\n for each_rating in secondary_ratings:\\n try:\\n rating_list = each_rating.findAll('td',attrs={'class':'Std'})\\n feature_name = stripHtml(rating_list[0].renderContents()).lower().replace(' ','_')\\n page['ef_rating_%s'%feature_name] = float(stripHtml(rating_list[1].renderContents()))\\n except:\\n log.info(\\\"Secondary rating element not found, continuing to the next element\\\")\\n continue\\n except:\\n log.info(self.log_msg(\\\"secondary ratings not found for this review\\\"))\\n\\n try:\\n review_hash = md5.md5(''.join(sorted(map(lambda x: str(x) if isinstance(x,(int,float)) else x , \\\\\\n page.values()))).encode('utf-8','ignore')).hexdigest()\\n except:\\n log.info(self.log_msg(\\\"Error occured while creating the review_hash\\\"))\\n return False\\n result=updateSessionInfo(self.genre, self.session_info_out, review_identity_hash, review_hash, \\n 'Review', self.task.instance_data.get('update'), parent_list=[parent_uri])\\n if result['updated']:\\n try:\\n review_meta_info = stripHtml(self.current_review.find('div',attrs={'class':'P10'}).findAll('div',attrs={'class':'Std'})[0]\\\\\\n .renderContents())\\n posted_date_str = re.findall(\\\"--([\\\\w\\\\s]+)--\\\",review_meta_info)[0]\\n page['posted_date']=datetime.strftime(datetime.strptime(re.sub(\\\"(\\\\d+)(st|nd|rd|th)\\\",r\\\"\\\\1\\\",posted_date_str).strip(),\\\"%B %d %Y\\\"),\\\\\\n \\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n except:\\n page['posted_date']=datetime.strftime(datetime.utcnow(),\\\"%Y-%m-%dT%H:%M:%SZ\\\") \\n log.info(self.log_msg(\\\"Error occured while fetching posted date\\\"))\\n\\n page['uri']=normalize(self.currenturi)\\n page['parent_path'] = [parent_uri]\\n page['path'] = [parent_uri,review_identity_hash]\\n page['task_log_id']=self.task.id\\n page['versioned']=self.task.instance_data.get('versioned',False)\\n page['category']=self.task.instance_data.get('category','generic')\\n page['last_updated_time']= datetime.strftime(datetime.utcnow(),\\\"%Y-%m-%dT%H:%M:%SZ\\\") #Now\\n page['client_name']=self.task.client_name\\n page['entity']='review'\\n page['uri_domain'] = urlparse(page['uri'])[1]\\n page['priority']=self.task.priority\\n page['level']=self.task.level\\n page['pickup_date'] = datetime.strftime(datetime.utcnow(),\\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n page['connector_instance_log_id'] = self.task.connector_instance_log_id\\n page['connector_instance_id'] = self.task.connector_instance_id\\n page['workspace_id'] = self.task.workspace_id\\n page['client_id'] = self.task.client_id # TODO: Get the client from the project\\n log.debug(self.log_msg(\\\"Adding review for the url %s\\\" %self.currenturi))\\n self.pages.append(page)\\n return True\\n else:\\n log.debug(self.log_msg(\\\"Not adding review to pages\\\"))\\n return False\\n else:\\n log.debug(self.log_msg(\\\"Not adding review to pages\\\"))\\n return False\\n except Exception,e:\\n log.exception(self.log_msg(\\\"Exception occured in _getReview()\\\"))\\n raise e\",\n \"def loop(self):\\n yield self\\n e = self.next\\n while e is not self:\\n yield e\\n e = e.next\",\n \"def iterate(self):\\n raise NotImplementedError()\",\n \"def run(self, iter: int = -1):\\n try:\\n while iter != 0:\\n self.iteration_count += 1\\n iso = self._iso_observe()\\n self._propagate(iso)\\n iter -= 1\\n except _FinishedObserving:\\n return True\\n except _Contradiction:\\n return False\",\n \"def reset(self):\\n debug('resetting')\\n self.marked = False\",\n \"def _process_reviews(self):\\n params = {'add_special_tokens': True, 'max_length': self._max_len,\\n 'return_token_type_ids': False, 'pad_to_max_length': True,\\n 'return_attention_mask': True, 'return_tensors': 'pt'}\\n\\n self._tokens = self._review.apply(self._tokenizer.encode_plus, **params)\",\n \"def next(self):\\n raise NotImplementedError\",\n \"def cmd_k(self):\\n node = self.start\\n while node is not None:\\n if node == self.cursor:\\n if node.prev is not None:\\n self.cursor = node.prev\\n break\\n node = node.next\\n self.get_text()\",\n \"def reset(self):\\n for c in self.children:\\n c.reset()\\n self.marked = False\",\n \"def remove(self):\\n self.iterator.remove()\",\n \"def __iteratePosts(self):\\n try:\\n posts = self.soup.findAll('div', 'lia-message-view')\\n if not posts:\\n log.info(self.log_msg('No posts found'))\\n return False\\n log.debug(self.log_msg('Total No of Posts found is %d'%len(posts)))\\n posts.reverse()\\n for post in posts:\\n if not self.__addPost(post):\\n log.info(self.log_msg('Post not added to self.pages for url\\\\\\n %s'%self.currenturi))\\n return False\\n return True\\n except:\\n log.exception(self.log_msg('Reviews are not found for url %s'%self.currenturi))\\n return False\",\n \"def post_review(self, form):\\n comments_file = form.cleaned_data.get('comments', None)\\n return_code = form.cleaned_data.get('return_code', None)\\n\\n # Update the review\\n self.object.post_review(comments_file, return_code=return_code)\\n if return_code:\\n self.revision.return_code = return_code\\n\\n verb = None\\n # If every reviewer has posted comments, close the reviewers step\\n if self.object.role == 'reviewer':\\n qs = Review.objects \\\\\\n .filter(document=self.document) \\\\\\n .filter(revision=self.revision.revision) \\\\\\n .filter(role='reviewer') \\\\\\n .exclude(closed_on=None)\\n if qs.count() == self.revision.reviewers.count():\\n self.revision.end_reviewers_step(save=False)\\n verb = Activity.VERB_CLOSED_REVIEWER_STEP\\n\\n # If leader, end leader step\\n elif self.object.role == 'leader':\\n self.revision.end_leader_step(save=False)\\n verb = Activity.VERB_CLOSED_LEADER_STEP\\n\\n # If approver, end approver step\\n elif self.object.role == 'approver':\\n self.revision.end_review(save=False)\\n verb = Activity.VERB_CLOSED_APPROVER_STEP\\n\\n self.revision.save(update_document=True)\\n\\n if verb:\\n activity_log.send(verb=verb,\\n target=self.revision,\\n sender=do_batch_import,\\n actor=self.request.user)\",\n \"def auto_review(self, auto_review):\\n \\n self._auto_review = auto_review\",\n \"def set_reviewing(self, revert=None):\\n self.connection.set_reviewing(self.mturk_id, revert=revert)\\n self.update()\",\n \"def auto_review(self):\\n return self._auto_review\",\n \"def traverse_ancestors(self):\\n self.event.wait()\\n for a in super(FalseObject, self).traverse_ancestors():\\n yield a\",\n \"def review(self):\\n return self._review\",\n \"def next(self):\\n while not self.is_stable():\\n self.step()\",\n \"def next_iter(self):\\n self.is_first_iter = False\\n self.handles_to_post_forward_order_index.clear()\\n self.handles_post_forward_order.clear()\\n if self._checking_order:\\n self.current_order_index = 0\\n if self.warn_status == _ExecOrderWarnStatus.WARNING:\\n self.warn_status = _ExecOrderWarnStatus.WARNED\",\n \"def filter_reviews():\\n print(\\\"***** Filter Specific Rating Reviews of a Business *****\\\")\\n while (True):\\n print()\\n business_object = query_business_name()\\n if business_object == \\\"back\\\":\\n return\\n elif business_object is None:\\n continue\\n id = business_object['business_id']\\n rating = float(input(\\n f'Please enter the number 1-5 to see reviews of {business_object[\\\"name\\\"]}: '))\\n review_object = review_col.find({\\\"business_id\\\": id,\\n \\\"stars\\\": rating}).limit(10)\\n print()\\n for review in review_object:\\n userid = review['user_id']\\n username = user_col.find_one({\\\"user_id\\\": userid})\\n print(f'- {username[\\\"name\\\"]} ({review[\\\"stars\\\"]}):'\\n f' {review[\\\"text\\\"]}.'\\n f' {review[\\\"date\\\"]}')\",\n \"def do_fold(self) -> None:\\r\\n self.active = False\",\n \"def continue_next(self):\\n\\n self.scope_assign = {}\\n self.scope_var_id = 0\\n self.cont = True\",\n \"def iterate(self):\",\n \"def set_test_loop(self , _iter):\\n\\t\\tself.__test=_iter\",\n \"def dispatch_next(self):\\n if not self.dispatch_one_batch(self._original_iterator):\\n self._iterating = False\\n self._original_iterator = None\",\n \"def __iter__(self):\\n if self.is_empty():\\n self._current_node = None\\n else:\\n self._current_node = self._tail._next\\n return self\",\n \"def review(self) -> object:\\n return self._review\",\n \"def iterate_tsne(self):\\n send_stop_event = False\\n if self.analysis is None:\\n return\\n if not self._stop_iter:\\n self.timer_count = self.timer_count + 1\\n for j in range(self.iters_per_frame):\\n self.analysis.do_iteration()\\n self._iter_count = self.timer_count * self.iters_per_frame + j\\n self.status.showMessage(f\\\"Iteration: {self._iter_count}\\\")\\n\\n if self.timer_count == self.num_frames - 1:\\n self._stop_iter = True\\n send_stop_event = True\\n self.timer_count = 0\\n self.status.showMessage(\\\"Iteration: Completed\\\")\\n\\n # Update point positions\\n self.embedding_viewer.update_plot(self.analysis.embedding)\\n else:\\n if self.timer_count % 10 == 0:\\n self.embedding_viewer.force_refresh()\\n\\n if send_stop_event:\\n self.embedding_viewer.force_refresh()\\n time.sleep(0.1)\\n self.analysis_stopped(self.analysis,\\n self.embedding_viewer.get_figure_as_buffer())\",\n \"def greedy(self) -> Action:\\n return NotImplemented\",\n \"def fetch(self):\\n try:\\n self.genre = 'Review'\\n log.debug(self.log_msg(\\\"Fetching the prouct page url %s\\\"%self.currenturi))\\n res=self._getHTML(self.currenturi) # Assuming self.currenturi is at the product page\\n self.rawpage=res['result']\\n self._setCurrentPage()\\n try:\\n self.parent_page_title = stripHtml(self.soup.find('h1',{'id':'pgTitleDetail'}).renderContents())\\n except:\\n self.parent_page_title =''\\n try:\\n self.__product_price = self.soup.find('tbody',{'class':'prices'}).td.renderContents().replace('$','')\\n except:\\n log.exception(\\\"Error in fetching product_price\\\")\\n self.__product_price = None\\n\\n parent_page_url = self.task.instance_data['uri']\\n review_first_page_url = self.soup.find('a',text=\\\"Show All Customer Reviews » \\\").parent['href']\\n review_url_order = \\\"&sortReviewsBy=DateDescending\\\"\\n self.currenturi = self.base_url + review_first_page_url + review_url_order\\n log.info(self.log_msg('current_uri :: %s'%(self.currenturi)))\\n self._getParentPage()\\n self.next_url_links=[]\\n self.fetch_next_link = True\\n while self.fetch_next_link:\\n self._iterateReviewPages(parent_page_url)\\n return True\\n except Exception,e:\\n log.exception(self.log_msg(\\\"Exception occured in fetch()\\\"))\\n return False\",\n \"def get_item_reviews(self, soup: BeautifulSoup) -> None:\\n try:\\n reviews = soup.find(\\\"span\\\", class_=\\\"_a7a5sx\\\").get_text()\\n reviews = re.findall(\\\"[0-9]+\\\", reviews)[0]\\n except AttributeError:\\n reviews = None\\n self.__collected_dic[\\\"reviews\\\"].append(reviews)\",\n \"def advance(self) -> None:\\n pass\",\n \"def go_again(self):\\n return True\",\n \"def go_again(self):\\n return False\",\n \"def __iter__(self):\\n self._current_node = self._head\\n return self\",\n \"def keep_first_iteration(self):\\n self.keep_first_iteration_flag = True\",\n \"def _stop_iter(self, query_i, n_pool):\\n\\n stop_iter = False\\n n_train = self.X.shape[0] - n_pool\\n\\n # if the pool is empty, always stop\\n if n_pool == 0:\\n stop_iter = True\\n\\n # If we are exceeding the number of papers, stop.\\n if self.n_papers is not None and n_train >= self.n_papers:\\n stop_iter = True\\n\\n # don't stop if there is no stopping criteria\\n if self.n_queries is not None and query_i >= self.n_queries:\\n stop_iter = True\\n\\n return stop_iter\",\n \"def _reject_rendering(self):\\n\\n curItem = self.tree.focus()\\n parent = self.tree.parent(curItem)\\n\\n categories = ['approved', 'conflicts', 'suggestions', 'unknown', \\\\\\n 'cldr',]\\n if parent is '':\\n #skip it\\n pass\\n else:\\n if parent not in categories:\\n curTerm = parent\\n category = self.tree.parent(parent)\\n else:\\n curTerm = curItem\\n category = parent\\n if category == 'approved':\\n #move from approved to unknown, with rendering deleted\\n self.tree.item(curTerm, \\\\\\n values=[self.tree.item(curTerm)['values'][0], ''])\\n self.tree.move(curTerm, 'unknown', 'end')\\n pass\\n elif category == 'sugestions':\\n if curTerm != curItem:\\n self.tree.delete(curItem)\\n if len(self.tree.get_children(curTerm)) < 1:\\n self.tree.move(curTerm, 'unknown', 'end')\\n # move curTrem from suggestions to unknown\\n else: #if curTerm == curItem:\\n self.tree.delete(*self.tree.get_children(curTerm))\\n self.tree.move(curTerm, 'unknown', 'end')\\n pass\\n elif category == 'conflicts':\\n if curTerm != curItem:\\n self.tree.delete(curItem)\\n if len(self.tree.get_children(curTerm)) == 1:\\n curItem = self.tree.get_children(curTerm)[0]\\n va = self.tree.item(curTerm)['values']\\n vb = self.tree.item(curItem)['values']\\n self.tree.item(curTerm, values=[va[0], vb[1]])\\n self.tree.item(curTerm, tags='approved')\\n self.tree.move(curTerm, 'approved', 'end')\\n pass\\n elif category == 'unknown':\\n #ignore\\n pass\\n elif category == 'cldr':\\n #ignore\\n pass\\n else:\\n messagebox.showerror('_reject_rendering', \\\\\\n 'Unknown category {}.'.format(category))\\n\\n self._make_suggestions()\\n \\n self.tree.tag_configure('approved', background='palegreen')\\n self.tree.tag_configure('conflict', background='bisque')\\n self.tree.tag_configure('suggestions', background='lightblue')\\n self.tree.tag_configure('unknown', background='whitesmoke')\\n self.tree.tag_configure('cldr', background='violet')\\n self.update()\",\n \"def ignore_visit_interslide(self, node):\\n raise SkipNode\",\n \"def fetch(self):\\n \\n self.genre=\\\"Review\\\"\\n \\n try:\\n self.parent_uri = self.currenturi\\n \\n self.total_threads_count = 0\\n self.last_timestamp = datetime( 1980,1,1 )\\n if tg.config.get(path='Connector',key='collegenet_max_threads_to_process'):\\n self.max_threads_count = int(tg.config.get(path='Connector',key='collegenet_max_threads_to_process'))\\n else:\\n self.max_threads_count = None\\n \\n self.collegenetTimelag_max = tg.config.get(path='Connector', key='collegenet_search_timeLag_max')\\n self.collegenetTimelag_min = tg.config.get(path='Connector', key='collegenet_search_timeLag_min')\\n log.info(self.log_msg('Time Logs :::::::'))\\n log.info(self.collegenetTimelag_max)\\n log.info(self.collegenetTimelag_min)\\n \\n## if self.collegenetTimelag_min and self.collegenetTimelag_max:\\n## randomTimeLag = random.randint(self.collegenetTimelag_min,self.collegenetTimelag_max) / 1000.0000\\n## log.info('sleeping for %s seconds between requests'%randomTimeLag)\\n## time.sleep(randomTimeLag)\\n \\n if not self.__setSoup():\\n log.exception(self.log_msg('Soup not set ..... '))\\n return False\\n \\n #post_no = 0 #Remove\\n while True:\\n #if post_no==3: #Remove\\n # break #Remove\\n #post_no = post_no + 1 #Remove\\n \\n currenturi = self.currenturi\\n if not self.__addPosts():\\n break \\n #Get \\\"post\\\" information\\n #break #Remove\\n self.currenturi = currenturi\\n if self.collegenetTimelag_min and self.collegenetTimelag_max:\\n randomTimeLag = random.randint(self.collegenetTimelag_min,self.collegenetTimelag_max) / 1000.0000\\n log.info('sleeping for %s seconds between requests'%randomTimeLag)\\n time.sleep(randomTimeLag)\\n #We need to set soup again as addPosts() method is changing self.currenturi and self.soup\\n if not self.__setSoup():\\n log.info(self.log_msg('Soup not set.... break while loop.'))\\n break\\n \\n try:\\n next_uri = baseuri + self.soup.find('div',id='search_results_controls').find('a',text=re.compile('>')) \\\\\\n .parent['href']\\n self.currenturi = next_uri\\n log.info(self.log_msg('Next URI :::::::;'))\\n log.info(next_uri)\\n except:\\n log.exception(self.log_msg('Next Post link not found'))\\n break\\n \\n## if self.collegenetTimelag_min and self.collegenetTimelag_max:\\n## randomTimeLag = random.randint(self.collegenetTimelag_min,self.collegenetTimelag_max) / 1000.0000\\n## log.info('sleeping for %s seconds between requests'%randomTimeLag)\\n## time.sleep(randomTimeLag)\\n \\n if not self.__setSoup():\\n log.info(self.log_msg('Soup not set.... break while loop.'))\\n break\\n \\n return True\\n \\n except:\\n log.exception(self.log_msg('Exception in fetch'))\\n return False\",\n \"def ROOMSELECTION_LOOP():\\n pass\",\n \"def main_loop(infr, max_loops=None, use_refresh=True):\\n raise RuntimeError()\\n infr.start_id_review(max_loops=max_loops, use_refresh=use_refresh)\\n # To automatically run through the loop just exhaust the generator\\n try:\\n result = next(infr._gen)\\n except StopIteration:\\n pass\\n assert result is None, 'need user interaction. cannot auto loop'\\n infr._gen = None\",\n \"def __call__(\\n self, document: tp.Optional[dict]\\n ) -> tp.Optional[tp.Generator[dict, None, None]]:\\n if document is None:\\n return\\n\\n if isstopiteration(document):\\n self._count_stop_iteration += 1\\n if self._count_stop_iteration == self._nb_input_nodes:\\n yield STOP_ITERATION\\n else:\\n if self._drop:\\n new_doc = deepcopy(document)\\n for key in self._keys:\\n try:\\n new_doc.pop(key)\\n except KeyError:\\n continue\\n else:\\n new_doc = dict()\\n for key in self._keys:\\n try:\\n new_doc[key] = document[key]\\n except KeyError:\\n continue\\n yield new_doc\",\n \"def evaluate(self):\\n self.training = False\",\n \"def get_user_reviews(self):\\n raw_review_data = imdb.get_title_user_reviews(self.ID) # Returns dictionary of dicts\\n reviews_dict = raw_review_data['reviews'] # Stores the dictionary of reviews\\n for dictionary in reviews_dict:\\n self.user_reviews.append(dictionary['reviewText'])\\n # Appends review text to list\\n self._review_printer() # Calls printer to output reviews\",\n \"def start_iter(self):\\n raise NotImplementedError\",\n \"def hasNext(self) -> bool:\\n ...\",\n \"def prune(self, x_val, y_val):\\n\\n # make sure that the classifier has been trained before predicting\\n if not self.is_trained:\\n raise Exception(\\\"DecisionTreeClassifier has not yet been trained.\\\")\\n\\n # get the maximum depth\\n deepest_depth = get_max_depth(self.root)\\n\\n # explore the depth starting from (max_depth - 1) to half of the max_depth\\n half_of_max_depth = deepest_depth // 2\\n for depth in range(deepest_depth - 1, half_of_max_depth, -1):\\n explore_nodes_to_prune(self, self.root, x_val, y_val, depth)\\n\\n print(\\\"Pruning completed\\\")\",\n \"def delete_business_rating():\\n print(\\\"***** Deleting Rating *****\\\")\\n while True:\\n print()\\n business_object = query_business_name()\\n if business_object == \\\"back\\\":\\n return\\n elif business_object is None:\\n continue\\n\\n print(\\\"Please wait...\\\")\\n\\n # find review using business id and user id\\n business_id = business_object['business_id']\\n review_obj = review_col.find_one({\\\"user_id\\\": app.USER_ID})\\n\\n if review_obj:\\n print('This is your review for ' + business_object['name'] + ': ')\\n print('Stars: ' + str(review_obj['stars']))\\n print('Review: ' + review_obj['text'])\\n\\n choice = input(\\n '\\\\nDo you want to delete this review? Type \\\"yes\\\" to delete, type \\\"back\\\" to go back: ')\\n if choice == 'back':\\n return\\n elif choice == 'yes':\\n review_col.remove(review_obj)\\n print(\\\"\\\\nYour review has been deleted!\\\")\\n else:\\n print(\\\"Invalid choice\\\")\\n return\\n else:\\n print(\\\"You have no review for \\\" + business_object['name'] + \\\"\\\\n\\\")\\n return\\n print()\",\n \"def train_loop_post(self, current_step):\\r\\n pass\",\n \"def _stop(self):\\n if self._classifier:\\n self._classifier.__exit__()\\n self._classifier = None\",\n \"def hasNext(self):\\n if self.tree:\\n return True\\n else:\\n return False\",\n \"def analyse(self):\\n self.__gather_tagged_reviews(self._restaurants)\",\n \"def __iter__(self):\\n for node in self.grammar.walk():\\n yield node\",\n \"def hasNext(self) -> bool:\\n return self.pointer < len(self.ordered_nodes)\",\n \"def __iter__(self):\\n while (self.pointsleft > 0):\\n current = min(self.pointsleft, self.settings.LOCALSKIPNUM)\\n for i in range(current):\\n self.add(self.fabric.getcoordinate())\\n self.pointsleft -= self.settings.LOCALSKIPNUM\\n self.pointscontroller.set(self.graph)\\n yield self.graph\",\n \"def iteration(self) -> global___Statement.Iteration:\",\n \"def iteration(self) -> global___Statement.Iteration:\",\n \"def __iter__(self):\\n self.current = self.start\\n self.returned = 0\\n return self\",\n \"def __iter__(self):\\n return iter(self.node)\",\n \"def visit(self):\\n self.tree = self.recursive_visit(self.tree)\\n # assert self.current_line == self.tree.absolute_bounding_box.bottom_right.line\",\n \"def endDocument(self):\\n self.return_q.put(self.obj_depth[-1])\",\n \"def iter_followings(self) -> Iterator[ChildNodeType]:\\n if self.item is None or self.item is self.root:\\n return\\n elif isinstance(self.item, ElementNode):\\n status = self.item, self.axis\\n self.axis = 'following'\\n item = self.item\\n\\n descendants = set(item.iter_descendants())\\n for self.item in self.root.iter_descendants(with_self=False):\\n if item.position < self.item.position and self.item not in descendants:\\n yield cast(ChildNodeType, self.item)\\n\\n self.item, self.axis = status\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.55926895","0.5364128","0.5353215","0.5327375","0.5236763","0.5153191","0.5037302","0.5021179","0.5010047","0.49338165","0.49248472","0.49155876","0.49141592","0.48874277","0.4864139","0.4858734","0.48342335","0.4833316","0.48259443","0.48172835","0.47990173","0.47806618","0.47671548","0.47668448","0.47636935","0.47636935","0.47636935","0.47636935","0.47612667","0.4759272","0.47576895","0.4752792","0.4737546","0.47149476","0.4712279","0.469754","0.46850187","0.46813437","0.46714437","0.46640205","0.46398747","0.46371156","0.46355915","0.46193615","0.46107695","0.45996755","0.45930773","0.45887074","0.4588033","0.4583232","0.45804244","0.45756012","0.45611683","0.4560552","0.45598364","0.45447224","0.45397982","0.45351738","0.45299622","0.45297655","0.45215085","0.45166638","0.45124018","0.450491","0.44964674","0.44922003","0.44868425","0.4484148","0.44834378","0.44757318","0.4472595","0.44676772","0.44577372","0.44566795","0.44526646","0.44496223","0.4448131","0.44379568","0.44353065","0.44322985","0.4428244","0.44238815","0.4423661","0.44226584","0.4416127","0.44139743","0.44095212","0.43961716","0.439324","0.43913555","0.43896914","0.43823838","0.43822703","0.43822572","0.43806246","0.43806246","0.4378369","0.4370433","0.4368305","0.4365337","0.43567234"],"string":"[\n \"0.55926895\",\n \"0.5364128\",\n \"0.5353215\",\n \"0.5327375\",\n \"0.5236763\",\n \"0.5153191\",\n \"0.5037302\",\n \"0.5021179\",\n \"0.5010047\",\n \"0.49338165\",\n \"0.49248472\",\n \"0.49155876\",\n \"0.49141592\",\n \"0.48874277\",\n \"0.4864139\",\n \"0.4858734\",\n \"0.48342335\",\n \"0.4833316\",\n \"0.48259443\",\n \"0.48172835\",\n \"0.47990173\",\n \"0.47806618\",\n \"0.47671548\",\n \"0.47668448\",\n \"0.47636935\",\n \"0.47636935\",\n \"0.47636935\",\n \"0.47636935\",\n \"0.47612667\",\n \"0.4759272\",\n \"0.47576895\",\n \"0.4752792\",\n \"0.4737546\",\n \"0.47149476\",\n \"0.4712279\",\n \"0.469754\",\n \"0.46850187\",\n \"0.46813437\",\n \"0.46714437\",\n \"0.46640205\",\n \"0.46398747\",\n \"0.46371156\",\n \"0.46355915\",\n \"0.46193615\",\n \"0.46107695\",\n \"0.45996755\",\n \"0.45930773\",\n \"0.45887074\",\n \"0.4588033\",\n \"0.4583232\",\n \"0.45804244\",\n \"0.45756012\",\n \"0.45611683\",\n \"0.4560552\",\n \"0.45598364\",\n \"0.45447224\",\n \"0.45397982\",\n \"0.45351738\",\n \"0.45299622\",\n \"0.45297655\",\n \"0.45215085\",\n \"0.45166638\",\n \"0.45124018\",\n \"0.450491\",\n \"0.44964674\",\n \"0.44922003\",\n \"0.44868425\",\n \"0.4484148\",\n \"0.44834378\",\n \"0.44757318\",\n \"0.4472595\",\n \"0.44676772\",\n \"0.44577372\",\n \"0.44566795\",\n \"0.44526646\",\n \"0.44496223\",\n \"0.4448131\",\n \"0.44379568\",\n \"0.44353065\",\n \"0.44322985\",\n \"0.4428244\",\n \"0.44238815\",\n \"0.4423661\",\n \"0.44226584\",\n \"0.4416127\",\n \"0.44139743\",\n \"0.44095212\",\n \"0.43961716\",\n \"0.439324\",\n \"0.43913555\",\n \"0.43896914\",\n \"0.43823838\",\n \"0.43822703\",\n \"0.43822572\",\n \"0.43806246\",\n \"0.43806246\",\n \"0.4378369\",\n \"0.4370433\",\n \"0.4368305\",\n \"0.4365337\",\n \"0.43567234\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":19490,"cells":{"query":{"kind":"string","value":"Return the Trie Fog that can be searched, ignoring any nodes that are currently being requested."},"document":{"kind":"string","value":"def _get_eligible_fog(self) -> fog.HexaryTrieFog:\n return self._trie_fog.mark_all_complete(self._active_prefixes)"},"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 empty_trie():\n trie = Trie()\n return trie","def empty_trie():\n from trie import Trie\n trie = Trie()\n return trie","def traversal_test_trie():\n from trie import Trie\n trie = Trie()\n trie.insert('alpha')\n trie.insert('alpaca')\n trie.insert('boy')\n return trie","def tricky_trie():\n from trie import Trie\n trie = Trie()\n trie.insert('bbbbbbb')\n trie.insert('bbb')\n trie.insert('lololololol')\n trie.insert('blololololol')\n return trie","def cc_trie (cls) :\n return Trie (cls.cc_map)","def full_trie():\n trie = Trie()\n trie.insert(\"hey\")\n return trie","def find_fiq_and_vq(self):\n start = self._query.get_start()\n finish = self._query.get_finish()\n feature_vector = self._query.get_preference()\n filtering_vector = self._query.get_teta()\n\n fiq = {}\n vq = set()\n for node in self.list_of_node_features:\n for feature_index in range(len(self.list_of_node_features[node])):\n # Check the following conditions:\n # 1. Feature value of node at position h equals zero\n # 2. Feature value of node at position h is less than feature value in filtering vector\n # at position h\n # 3. node is node a start or finish node\n # If 3rd condition and either 1 or 2 do not add node to FIQ\n if (self.list_of_node_features.get(node)[feature_index] == 0 or\n self.list_of_node_features.get(node)[feature_index] < filtering_vector[feature_index])\\\n and (node != start and node != finish):\n continue\n\n # Add node to FIQ and VQ\n if fiq.get(feature_index):\n element = (node, self.list_of_node_features.get(node)[feature_index])\n fiq.get(feature_index).append(element)\n else:\n fiq[feature_index] = [(node, self.list_of_node_features.get(node)[feature_index])]\n vq.add(node)\n\n # remove features with zero values in feature vector\n for feature_index in range(len(feature_vector)):\n if feature_vector[feature_index] == 0:\n del(fiq[feature_index])\n\n return fiq, vq","def checkFog(ontology_fog):\n if len(ontology_fog.has_bounding_box) != 0:\n bounding_box = checkBoundingBox(ontology_fog.has_bounding_box[0]) #checks the ontology BoundingBox individual and assigns a correct PYOSCX BoundingBox object.\n if len(ontology_fog.has_visual_range) !=0:\n visual_range = ontology_fog.has_visual_range[0]\n return xosc.Fog(visual_range,bounding_box)","def get_root():\n root = VGOCache('https://www.vegguide.org/region/0')\n return check_has_regions(root.results['regions']['primary'])","def get_node():\n return TrieNode()","def test_traversal_with_no_input_string_returns_trie(full_trie):\n assert list(full_trie.traversal()) == ['h', 'e', 'y']\n assert list(full_trie.traversal('')) == ['h', 'e', 'y']","def get_allowed_geometry(self):\n\n objects = self.get_geometry()\n\n allowed_objects = []\n\n for obj in objects:\n\n if rs.ObjectType(obj) == gs.allowed_object_types[self.path[1]]:\n\n allowed_objects.append(obj)\n\n return allowed_objects","def multi_trie():\n trie = Trie()\n trie.insert(\"hey\")\n trie.insert(\"hell\")\n trie.insert(\"hello\")\n trie.insert(\"howdy\")\n trie.insert(\"head\")\n trie.insert(\"hi you\")\n return trie","def alphacheck(self):\n if self.root_system.is_finite() and self.root_system.is_irreducible():\n return Family(self.index_set(), self.simple_coroot, \\\n hidden_keys = [0], hidden_function = lambda i: - self.cohighest_root())\n else:\n return self.simple_coroots()","def test_traverse_on_empty_trie(empty_trie):\n assert list(empty_trie.traversal()) == []","def test_create_empty_trie(empty_trie):\n assert empty_trie.root.children == {}\n assert empty_trie._size == 0","def test_traversal_with_string_not_in_trie(full_trie):\n assert list(full_trie.traversal(\"goodbye\")) == []","def eligible_nodes(self):\n return [v for v in self.G if self.eligible_node(v)]","def __init__(self):\r\n self.trie = Trie()","def usable(self):\n return self.exclude(Q(location=None) | Q(ipv4=None) | Q(ipv6=None))","def get_fog_ids(self):\n fog_ids = []\n \n for node_id in self.nodes:\n if (isinstance(self.nodes[node_id], FogNode)):\n fog_ids.append(node_id)\n\n return fog_ids","def __init__(self):\n self.trie = Trie()","async def _missing_trie_hashes(self) -> AsyncIterator[TrackedRequest]:\n # For each account, when we have asked for all known storage and bytecode\n # hashes, but some are still not present, we \"pause\" the account so we can look\n # for neighboring nodes.\n # This is a list of paused accounts, using the path to the leaf node,\n # because that's how the account tracker is indexed.\n exhausted_account_leaves: Tuple[Nibbles, ...] = ()\n\n starting_root_hash = self._next_trie_root_hash\n\n try:\n while self.manager.is_running:\n # Get the next account\n\n # We have to rebuild the account iterator every time because...\n # something about an exception during a manual __anext__()?\n account_iterator = self._request_tracking_trie_items(\n self._account_tracker,\n starting_root_hash,\n )\n try:\n next_account_info = await account_iterator.__anext__()\n except trie_exceptions.MissingTraversalNode as exc:\n # Found a missing trie node while looking for the next account\n yield self._account_tracker.generate_request(\n exc.missing_node_hash,\n exc.nibbles_traversed,\n )\n continue\n except StopAsyncIteration:\n # Finished iterating over all available accounts\n break\n\n # Decode account\n path_to_leaf, address_hash_nibbles, encoded_account = next_account_info\n account = rlp.decode(encoded_account, sedes=Account)\n\n # Iterate over all missing hashes of subcomponents (storage & bytecode)\n subcomponent_hashes_iterator = self._missing_subcomponent_hashes(\n address_hash_nibbles,\n account,\n starting_root_hash,\n )\n async for node_request in subcomponent_hashes_iterator:\n yield node_request\n\n # Check if account is fully downloaded\n account_components_complete = self._are_account_components_complete(\n address_hash_nibbles,\n account,\n )\n if account_components_complete:\n # Mark fully downloaded accounts as complete, and do some cleanup\n self._mark_account_complete(path_to_leaf, address_hash_nibbles)\n else:\n # Pause accounts that are not fully downloaded, and track the account\n # to resume when the generator exits.\n self._account_tracker.pause_review(path_to_leaf)\n exhausted_account_leaves += (path_to_leaf, )\n\n except GeneratorExit:\n # As the generator is exiting, we want to resume any paused accounts. This\n # allows us to find missing storage/bytecode on the next iteration.\n for path_to_leaf in exhausted_account_leaves:\n self._account_tracker.mark_for_review(path_to_leaf)\n raise\n else:\n # If we pause a few accounts and then run out of nodes to ask for, then we\n # still need to resume the paused accounts to prepare for the next iteration.\n for path_to_leaf in exhausted_account_leaves:\n self._account_tracker.mark_for_review(path_to_leaf)\n\n # Possible scenarios:\n # 1. We have completed backfill\n # 2. We have iterated the available nodes, and all known hashes are being requested.\n # For example: if 0 nodes are available, and we walk to the root and request\n # the root from a peer, we do not have any available information to ask for\n # more nodes, and exit cleanly.\n #\n # In response to these situations, we might like to:\n # 1. Log and celebrate that the full state has been downloaded\n # 2. Exit this search and sleep a bit, waiting for new trie nodes to arrive\n #\n # 1 and 2 are a little more cleanly handled outside this iterator, so we just\n # exit and let the caller deal with it, using a _check_complete() check.\n return","def get_all(root: TrieNode, prefix: str):\n \"\"\" Retorna uma lista IDs de cursos com o prefixo \"\"\"\n node = root\n found = []\n prefix = prefix.upper()\n\n # Se a raíz não tem filhos, a árvore é vazia\n if not root.children:\n return found\n\n # se não, busca cada caractere do prefixo \n for char in prefix:\n char_not_found = True\n\n # se o usuário colocar um asterisco, sinaliza qualquer palavra com o prefixo\n if char == '*': \n break\n else:\n # busca nas childs do nodo atual\n for child in node.children:\n if child.char == char:\n # se encontrar, atualiza a flag\n char_not_found = False\n # e recomeça do nodo que encontrou\n node = child\n break\n\n # se não encontrou algum caractere\n if char_not_found:\n return found\n\n # se encontrou todas as letras ou um *, pega todas as palavras\n return find_words(node)","def test_on_tricky_trie(tricky_trie):\n assert tricky_trie.size == 4","def __init__(self):\n self.root = TrieNode('*')","def __init__(self):\n self.root = TrieNode('*')\n self.size = 0","def infras (self):\n return (node for id, node in self.network.nodes_iter(data=True) if\n node.type == Node.INFRA)","def __init__(self):\n self.trie = TrieNode()","def __init__(self):\n self.trie = TrieNode()","def refinesearch(self) :\n\t\ttry :\n\t\t\treturn self._refinesearch\n\t\texcept Exception as e:\n\t\t\traise e","def __init__(self):\r\n self.trie = {}","def permitted_geometries(self) -> Optional[List[str]]:\n\n return self._permitted_geometries","def findFeatures(self):\n\t\tpass","def get_new_node(self):\n return TrieNode()","def __init__(self):\n\t\tself.root = TrieNode('*')","def breadthFirst( self, node, cutoff ):\n return nx.single_source_shortest_path(self._G, node, cutoff).keys()","def test_size_doesnt_change_when_you_run_contains(full_trie):\n full_trie.contains(\"hey\")\n assert full_trie.size() == 1","def retrieve_trie(self):\n trie = pickle.load(open(self.persist, \"rb\"))\n return trie","def _get_traversable_nodes(self):\n nodes = self.local_environment.get_node_neighborhood(self.location)\n potential_nodes = [node for node in nodes if self.local_environment.get_node_deadline(node) >= 0]\n edges_to_potential_nodes = self.local_environment.graph.edges(self.location)\n\n for single_edge in edges_to_potential_nodes:\n\n # if edge is blocked\n if self.local_environment.graph[single_edge[0]][single_edge[1]][\"blocked\"]:\n potential_nodes.remove(single_edge[1])\n return potential_nodes","def __init__(self):\n self.trie = {}","def __init__(self):\n self.trie = {}","def __init__(self):\n self.trie = {}","def __init__(self):\n self.trie = {}","def nodes_flags(self):\n return self._nodes_flags","def __init__(self):\n self.root = Solution2.TrieNode()","def get_orfs(genome, min_num_aa):\n allowed = \"ATGC\"\n if not isinstance(genome, str) or len(genome) == 0 or not all(c in allowed for c in genome):\n raise TypeError\n start_codon = \"ATG\"\n stop_codon = ['TAA', 'TAG', 'TGA']\n ref_dict = {\"T\" : \"A\", \"A\" : \"T\", \"G\" : \"C\", \"C\" : \"G\"}\n amino_dict = {\n 'L' : ['CTC', 'CTT', 'CTA', 'CTG', 'TTA', 'TTG'],\n 'S' : ['TCA', 'TCT', 'TCC', 'TCG', 'AGC', 'AGT'],\n 'R' : ['CGA', 'CGC', 'CGT', 'CGG', 'AGA', 'AGG'],\n 'V' : ['GTA', 'GTG', 'GTC', 'GTT'],\n 'P' : ['CCC', 'CCA', 'CCG', 'CCT'],\n 'T' : ['ACC', 'ACG', 'ACT', 'ACA'],\n 'A' : ['GCA', 'GCC', 'GCG', 'GCT'],\n 'G' : ['GGA', 'GGC', 'GGT', 'GGG'],\n 'I' : ['ATA', 'ATC', 'ATT'],\n 'F' : ['TTT', 'TTC'],\n 'Y' : ['TAT', 'TAC'],\n 'H' : ['CAC', 'CAT'],\n 'Q' : ['CAG', 'CAA'],\n 'N' : ['AAC', 'AAT'],\n 'K' : ['AAA', 'AAG'],\n 'D' : ['GAC', 'GAT'],\n 'E' : ['GAA', 'GAG'],\n 'C' : ['TGC', 'TGT'],\n 'M' : ['ATG'],\n 'W' : ['TGG']\n\n }\n comp_genome = \"\"\n for stra in genome:\n comp_genome += ref_dict[stra]\n main_orfs = find_orfs(genome, start_codon, stop_codon, min_num_aa, amino_dict, False)\n comp_orfs = find_orfs(comp_genome[::-1], start_codon, stop_codon, min_num_aa, amino_dict, True)\n circular_orfs = find_cir_orfs(genome, main_orfs, start_codon, stop_codon, min_num_aa, amino_dict, False)\n \n circular_orfs_comp = find_cir_orfs(comp_genome[::-1], comp_orfs, start_codon, stop_codon, min_num_aa, amino_dict, True)\n \n for main_orf in main_orfs:\n for cir_orf in circular_orfs:\n if main_orf[0] <= cir_orf[1] and main_orf[1] <= cir_orf[1] or len(main_orf) == 5:\n main_orfs.remove(main_orf)\n for comp_orf in comp_orfs:\n for cir_orf in circular_orfs_comp:\n if comp_orf[1] == cir_orf[1] or len(comp_orf) == 5:\n comp_orfs.remove(comp_orf)\n\n final_orf = main_orfs + comp_orfs + circular_orfs + circular_orfs_comp\n #print(len(comp_orfs))\n \n \n \n return final_orf","def __init__(self):\n self.root = TrieNode()\n self.kmap = {}","def conditional_fptree(candidate, fptree, head_pointers, min_support, partial, items, initial_counts):","def __init__(self):\n self.root = Trie()","def create_trie(self, genome):\r\n i = 0\r\n while i <= len(genome): # O(N)\r\n current = self.root\r\n self.create_trie_aux(current, genome, i) # O(N)\r\n i += 1","def __init__(self):\n self.root = TrieNode(\".\")","def get_children(uri):\n children = VGOCache(uri).results['children']\n return check_has_regions(children)","def _storage_review(\n self,\n storage_key: Hash32,\n storage_root_hash: Hash32) -> Set[Hash32]:\n with self._trie_db.at_root(storage_root_hash) as snapshot:\n try:\n # request the data just to see which part is missing\n snapshot[storage_key]\n except MissingTrieNode as exc:\n return {exc.missing_node_hash}\n else:\n return set()","def search(self, prefix: str) -> TrieNode:\n leaf = self.root\n for level in range(len(prefix)):\n letter = prefix[level]\n\n if letter not in leaf.children:\n return self.get_node()\n leaf = leaf.children[letter]\n\n if leaf is not None:\n return leaf\n return self.get_node()","def test_traversal_with_partial_word_returns_rest_of_word(full_trie):\n assert list(full_trie.traversal('h')) == ['e', 'y']","def test_traversal_on_word_with_no_following_letters(full_trie):\n assert list(full_trie.traversal(\"hey\")) == []","def __init__(self):\n self.root = TrieNode(None)","def __init__(self):\n self.root = TrieNode(None)","def compare_with_trie(self, delta=0.8):\n\n def format_diff(el, f, diff):\n s = (\n \"VALUE={0}\\nSYST=[{1}]\\nTRIE=[{2}]\\nMORE SYSTEM:\"\n \"\\n{3}\\n######\\nMORE TRIE:\\n{4}\"\n ).format(\n el.value,\n el.str_mks(),\n f.stat.str_mks(),\n el.str_all_completions(),\n f.str_all_completions(),\n )\n if diff:\n return f\"-------\\n{s}\\n-------\"\n return s\n\n trie = CompletionTrieNode.build(self.tuples())\n self.compute_metrics(delta=delta, details=True)\n trie.precompute_stat()\n trie.update_stat_dynamic(delta=delta)\n diffs = []\n for el in self:\n f = trie.find(el.value)\n d0 = el.mks0 - f.stat.mks0\n d1 = el.mks1 - f.stat.mks1\n d2 = el.mks2 - f.stat.mks2\n d4 = el.mks0_ - f.stat.mks0_\n if d0 != 0 or d1 != 0 or d2 != 0 or d4 != 0:\n diffs.append((d0, d1, d2, d4, el, f, format_diff(el, f, True)))\n if diffs:\n diffs.sort(key=str)\n return diffs\n else:\n return None","def __init__(self):\n self.trie = Node()","def test_empty_tree_size(empty_trie):\n assert empty_trie.size == 0","def alpha(self):\n if self.root_system.is_finite() and self.root_system.is_irreducible():\n return Family(self.index_set(), self.simple_root, \\\n hidden_keys = [0], hidden_function = lambda i: - self.highest_root())\n else:\n return self.simple_roots()","def support_tree(self):\n v = self.vertices\n h_edges = list(self.hyper_edges)\n\n h_edges.sort(key=lambda x: len(x))\n support_tree = Graph()\n\n for x in v:\n support_tree.add(x)\n\n for h_edge in h_edges:\n kruskal = list(connected_parts(support_tree, vertex_subset=h_edge))\n if len(kruskal) == 1:\n continue\n else:\n for i in range(len(kruskal) - 1):\n support_tree.update([(next(iter(kruskal[i])), next(iter(kruskal[i + 1])))],\n node_creation=False)\n\n return support_tree","def _find_all_top_level_non_gene_features(chrom: str, db: FeatureDB, feature_types: List[str]) -> Iterable[Feature]:\n for feature in db.region(seqid=chrom, featuretype=feature_types):\n try:\n _ = next(db.parents(feature.id))\n except StopIteration:\n yield feature","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n Trie = lambda: defaultdict(Trie)\n self.trie = Trie()","def concrete_search(self, limit):\n frontier = Frontier_SortedList.Frontier_SortedList()\n closed = {}\n initial_node = TreeNode.TreeNode(\n id=0,\n state=self.problem.initial_state,\n cost=0,\n node_depth=0,\n f=None,\n parent=None,\n last_action=None,\n )\n initial_node.f = self.__f_strategy(initial_node)\n id = 1\n frontier.insert(initial_node)\n solution = False\n while not solution and not frontier.is_empty():\n actual_node = frontier.remove()\n pruned = False\n if self.problem.is_goal(actual_node.state):\n solution = True\n else:\n if self.pruning == 1:\n pruned = self.check_node_pruning_1st_prune(actual_node, closed)\n if not pruned:\n closed[actual_node.state.create_md5()] = abs(actual_node.f)\n\n if self.pruning in [0, 1]:\n if not pruned:\n if actual_node.node_depth < limit:\n frontier, id = self.expand_node(id, actual_node, frontier)\n\n if self.pruning == 2:\n if actual_node.node_depth < limit:\n list_nodes, id = self.expand_node_2nd_prune(id, actual_node)\n for node in list_nodes:\n md5 = node.state.create_md5()\n if md5 not in closed or closed[md5] > abs(node.f):\n closed[md5] = abs(node.f)\n frontier.insert(node)\n if solution:\n return self.solution(actual_node)\n else:\n return None","def get_family_with_filtered_pedigree_with_samples(self):\n return {self.name: self.get_filtered_pedigree_with_samples()}","def delete_tree():\n from trie import Trie\n t = Trie()\n t.insert(\"ted\")\n t.insert(\"tea\")\n t.insert(\"teabag\")\n t.insert(\"teabags\")\n t.insert(\"teabagger\")\n t.insert(\"teabaggers\")\n t.insert(\"teabagged\")\n return t","def __init__(self):\n self.trie = dict()","def __init__(self):\n self.trie = dict()","def __init__(self):\n self.root = TrieNode()\n self.char_map = {}","def fs_used_including_snapshot_reserve(self):\n return self._fs_used_including_snapshot_reserve","def __init__(self):\n self.root = TrieNode(\"st\")","def prune_trie(trie, threshold):\n\tnode = trie.root\n\tpq = []\n\tfor i in node.children.keys():\n\t\tpq.append((node.children[i],node.children[i].char))\n\twhile len(pq) > 0:\n\t\tcur_node, char = pq.pop()\n\t\tif cur_node.isEnd == False:\n\t\t\tfor i in cur_node.children.keys():\n\t\t\t\tpq.append((cur_node.children[i],char + cur_node.children[i].char))\n\t\telse:\n\t\t\tif cur_node.weight < threshold:\n\t\t\t\tdelete(trie, char)\n\t\t\telse:\n\t\t\t\tcontinue\n\treturn trie","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def __init__(self):\n self.root = TrieNode()","def find_features_geojson(self, geojson_tagset):\n kreis_region_bund_list = []\n only_regs_set = set()\n for feature in geojson_tagset:\n bundesl = feature.properties.get('NAME_1')\n region = feature.properties.get('NAME_2')\n kreis = feature.properties.get('NAME_3')\n\n kreis_region_bund_list.append((kreis, region, bundesl))\n #Check: does \"Göttingen\" appear in this list as a region? Why does Goettingen need to be a region?)\n return kreis_region_bund_list","def build_feature_filter(self):\n if self.features == [\"*\"]:\n random_iso = list(self.data.keys())[0]\n self.features = set()\n for lang_features in self.data.values():\n self.features |= set(lang_features.keys())\n self.features = list(self.features)\n if self.exclusions:\n self.features = [f for f in self.features if f not in self.exclusions]\n self.feature_filter = set(self.features)","def __init__(self):\n self.root = self.TrieNode(None)","def get_candidates(self,query_index):\r\n # you will need to use self.hashed_A for this method\r\n bucket1 = self.hashed_A\r\n bucket = bucket1.filter(lambda z: (z[2] != query_index[2]) and (any(set(z[2]) & set(query_index[2]))))\r\n #print(bucket)\r\n return bucket\r\n raise NotImplementedError","def facial_tetrahedron(x, y, z, xb, yb, zb):\n success_mask = triangle_inequality(x, y, zb) # x, y, zb\n triangle_inequality(x, y, zb, out = success_mask) # x, yb, z\n triangle_inequality(xb, y, z, out = success_mask) # xb, y, z\n triangle_inequality(xb, yb, zb, out = success_mask) # xb, yb, zb\n return success_mask","def filesystem_layers(self):\n return None","def surface_mask(self):\n return np.vectorize(lambda name: name in self.nvertices.keys())(self.name)","def __init__(self):\r\n self.root=Trie_Node()","def __init__(self):\n self.root=TrieNode()","def __init__(self):\n self.root=TrieNode()"],"string":"[\n \"def empty_trie():\\n trie = Trie()\\n return trie\",\n \"def empty_trie():\\n from trie import Trie\\n trie = Trie()\\n return trie\",\n \"def traversal_test_trie():\\n from trie import Trie\\n trie = Trie()\\n trie.insert('alpha')\\n trie.insert('alpaca')\\n trie.insert('boy')\\n return trie\",\n \"def tricky_trie():\\n from trie import Trie\\n trie = Trie()\\n trie.insert('bbbbbbb')\\n trie.insert('bbb')\\n trie.insert('lololololol')\\n trie.insert('blololololol')\\n return trie\",\n \"def cc_trie (cls) :\\n return Trie (cls.cc_map)\",\n \"def full_trie():\\n trie = Trie()\\n trie.insert(\\\"hey\\\")\\n return trie\",\n \"def find_fiq_and_vq(self):\\n start = self._query.get_start()\\n finish = self._query.get_finish()\\n feature_vector = self._query.get_preference()\\n filtering_vector = self._query.get_teta()\\n\\n fiq = {}\\n vq = set()\\n for node in self.list_of_node_features:\\n for feature_index in range(len(self.list_of_node_features[node])):\\n # Check the following conditions:\\n # 1. Feature value of node at position h equals zero\\n # 2. Feature value of node at position h is less than feature value in filtering vector\\n # at position h\\n # 3. node is node a start or finish node\\n # If 3rd condition and either 1 or 2 do not add node to FIQ\\n if (self.list_of_node_features.get(node)[feature_index] == 0 or\\n self.list_of_node_features.get(node)[feature_index] < filtering_vector[feature_index])\\\\\\n and (node != start and node != finish):\\n continue\\n\\n # Add node to FIQ and VQ\\n if fiq.get(feature_index):\\n element = (node, self.list_of_node_features.get(node)[feature_index])\\n fiq.get(feature_index).append(element)\\n else:\\n fiq[feature_index] = [(node, self.list_of_node_features.get(node)[feature_index])]\\n vq.add(node)\\n\\n # remove features with zero values in feature vector\\n for feature_index in range(len(feature_vector)):\\n if feature_vector[feature_index] == 0:\\n del(fiq[feature_index])\\n\\n return fiq, vq\",\n \"def checkFog(ontology_fog):\\n if len(ontology_fog.has_bounding_box) != 0:\\n bounding_box = checkBoundingBox(ontology_fog.has_bounding_box[0]) #checks the ontology BoundingBox individual and assigns a correct PYOSCX BoundingBox object.\\n if len(ontology_fog.has_visual_range) !=0:\\n visual_range = ontology_fog.has_visual_range[0]\\n return xosc.Fog(visual_range,bounding_box)\",\n \"def get_root():\\n root = VGOCache('https://www.vegguide.org/region/0')\\n return check_has_regions(root.results['regions']['primary'])\",\n \"def get_node():\\n return TrieNode()\",\n \"def test_traversal_with_no_input_string_returns_trie(full_trie):\\n assert list(full_trie.traversal()) == ['h', 'e', 'y']\\n assert list(full_trie.traversal('')) == ['h', 'e', 'y']\",\n \"def get_allowed_geometry(self):\\n\\n objects = self.get_geometry()\\n\\n allowed_objects = []\\n\\n for obj in objects:\\n\\n if rs.ObjectType(obj) == gs.allowed_object_types[self.path[1]]:\\n\\n allowed_objects.append(obj)\\n\\n return allowed_objects\",\n \"def multi_trie():\\n trie = Trie()\\n trie.insert(\\\"hey\\\")\\n trie.insert(\\\"hell\\\")\\n trie.insert(\\\"hello\\\")\\n trie.insert(\\\"howdy\\\")\\n trie.insert(\\\"head\\\")\\n trie.insert(\\\"hi you\\\")\\n return trie\",\n \"def alphacheck(self):\\n if self.root_system.is_finite() and self.root_system.is_irreducible():\\n return Family(self.index_set(), self.simple_coroot, \\\\\\n hidden_keys = [0], hidden_function = lambda i: - self.cohighest_root())\\n else:\\n return self.simple_coroots()\",\n \"def test_traverse_on_empty_trie(empty_trie):\\n assert list(empty_trie.traversal()) == []\",\n \"def test_create_empty_trie(empty_trie):\\n assert empty_trie.root.children == {}\\n assert empty_trie._size == 0\",\n \"def test_traversal_with_string_not_in_trie(full_trie):\\n assert list(full_trie.traversal(\\\"goodbye\\\")) == []\",\n \"def eligible_nodes(self):\\n return [v for v in self.G if self.eligible_node(v)]\",\n \"def __init__(self):\\r\\n self.trie = Trie()\",\n \"def usable(self):\\n return self.exclude(Q(location=None) | Q(ipv4=None) | Q(ipv6=None))\",\n \"def get_fog_ids(self):\\n fog_ids = []\\n \\n for node_id in self.nodes:\\n if (isinstance(self.nodes[node_id], FogNode)):\\n fog_ids.append(node_id)\\n\\n return fog_ids\",\n \"def __init__(self):\\n self.trie = Trie()\",\n \"async def _missing_trie_hashes(self) -> AsyncIterator[TrackedRequest]:\\n # For each account, when we have asked for all known storage and bytecode\\n # hashes, but some are still not present, we \\\"pause\\\" the account so we can look\\n # for neighboring nodes.\\n # This is a list of paused accounts, using the path to the leaf node,\\n # because that's how the account tracker is indexed.\\n exhausted_account_leaves: Tuple[Nibbles, ...] = ()\\n\\n starting_root_hash = self._next_trie_root_hash\\n\\n try:\\n while self.manager.is_running:\\n # Get the next account\\n\\n # We have to rebuild the account iterator every time because...\\n # something about an exception during a manual __anext__()?\\n account_iterator = self._request_tracking_trie_items(\\n self._account_tracker,\\n starting_root_hash,\\n )\\n try:\\n next_account_info = await account_iterator.__anext__()\\n except trie_exceptions.MissingTraversalNode as exc:\\n # Found a missing trie node while looking for the next account\\n yield self._account_tracker.generate_request(\\n exc.missing_node_hash,\\n exc.nibbles_traversed,\\n )\\n continue\\n except StopAsyncIteration:\\n # Finished iterating over all available accounts\\n break\\n\\n # Decode account\\n path_to_leaf, address_hash_nibbles, encoded_account = next_account_info\\n account = rlp.decode(encoded_account, sedes=Account)\\n\\n # Iterate over all missing hashes of subcomponents (storage & bytecode)\\n subcomponent_hashes_iterator = self._missing_subcomponent_hashes(\\n address_hash_nibbles,\\n account,\\n starting_root_hash,\\n )\\n async for node_request in subcomponent_hashes_iterator:\\n yield node_request\\n\\n # Check if account is fully downloaded\\n account_components_complete = self._are_account_components_complete(\\n address_hash_nibbles,\\n account,\\n )\\n if account_components_complete:\\n # Mark fully downloaded accounts as complete, and do some cleanup\\n self._mark_account_complete(path_to_leaf, address_hash_nibbles)\\n else:\\n # Pause accounts that are not fully downloaded, and track the account\\n # to resume when the generator exits.\\n self._account_tracker.pause_review(path_to_leaf)\\n exhausted_account_leaves += (path_to_leaf, )\\n\\n except GeneratorExit:\\n # As the generator is exiting, we want to resume any paused accounts. This\\n # allows us to find missing storage/bytecode on the next iteration.\\n for path_to_leaf in exhausted_account_leaves:\\n self._account_tracker.mark_for_review(path_to_leaf)\\n raise\\n else:\\n # If we pause a few accounts and then run out of nodes to ask for, then we\\n # still need to resume the paused accounts to prepare for the next iteration.\\n for path_to_leaf in exhausted_account_leaves:\\n self._account_tracker.mark_for_review(path_to_leaf)\\n\\n # Possible scenarios:\\n # 1. We have completed backfill\\n # 2. We have iterated the available nodes, and all known hashes are being requested.\\n # For example: if 0 nodes are available, and we walk to the root and request\\n # the root from a peer, we do not have any available information to ask for\\n # more nodes, and exit cleanly.\\n #\\n # In response to these situations, we might like to:\\n # 1. Log and celebrate that the full state has been downloaded\\n # 2. Exit this search and sleep a bit, waiting for new trie nodes to arrive\\n #\\n # 1 and 2 are a little more cleanly handled outside this iterator, so we just\\n # exit and let the caller deal with it, using a _check_complete() check.\\n return\",\n \"def get_all(root: TrieNode, prefix: str):\\n \\\"\\\"\\\" Retorna uma lista IDs de cursos com o prefixo \\\"\\\"\\\"\\n node = root\\n found = []\\n prefix = prefix.upper()\\n\\n # Se a raíz não tem filhos, a árvore é vazia\\n if not root.children:\\n return found\\n\\n # se não, busca cada caractere do prefixo \\n for char in prefix:\\n char_not_found = True\\n\\n # se o usuário colocar um asterisco, sinaliza qualquer palavra com o prefixo\\n if char == '*': \\n break\\n else:\\n # busca nas childs do nodo atual\\n for child in node.children:\\n if child.char == char:\\n # se encontrar, atualiza a flag\\n char_not_found = False\\n # e recomeça do nodo que encontrou\\n node = child\\n break\\n\\n # se não encontrou algum caractere\\n if char_not_found:\\n return found\\n\\n # se encontrou todas as letras ou um *, pega todas as palavras\\n return find_words(node)\",\n \"def test_on_tricky_trie(tricky_trie):\\n assert tricky_trie.size == 4\",\n \"def __init__(self):\\n self.root = TrieNode('*')\",\n \"def __init__(self):\\n self.root = TrieNode('*')\\n self.size = 0\",\n \"def infras (self):\\n return (node for id, node in self.network.nodes_iter(data=True) if\\n node.type == Node.INFRA)\",\n \"def __init__(self):\\n self.trie = TrieNode()\",\n \"def __init__(self):\\n self.trie = TrieNode()\",\n \"def refinesearch(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._refinesearch\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def __init__(self):\\r\\n self.trie = {}\",\n \"def permitted_geometries(self) -> Optional[List[str]]:\\n\\n return self._permitted_geometries\",\n \"def findFeatures(self):\\n\\t\\tpass\",\n \"def get_new_node(self):\\n return TrieNode()\",\n \"def __init__(self):\\n\\t\\tself.root = TrieNode('*')\",\n \"def breadthFirst( self, node, cutoff ):\\n return nx.single_source_shortest_path(self._G, node, cutoff).keys()\",\n \"def test_size_doesnt_change_when_you_run_contains(full_trie):\\n full_trie.contains(\\\"hey\\\")\\n assert full_trie.size() == 1\",\n \"def retrieve_trie(self):\\n trie = pickle.load(open(self.persist, \\\"rb\\\"))\\n return trie\",\n \"def _get_traversable_nodes(self):\\n nodes = self.local_environment.get_node_neighborhood(self.location)\\n potential_nodes = [node for node in nodes if self.local_environment.get_node_deadline(node) >= 0]\\n edges_to_potential_nodes = self.local_environment.graph.edges(self.location)\\n\\n for single_edge in edges_to_potential_nodes:\\n\\n # if edge is blocked\\n if self.local_environment.graph[single_edge[0]][single_edge[1]][\\\"blocked\\\"]:\\n potential_nodes.remove(single_edge[1])\\n return potential_nodes\",\n \"def __init__(self):\\n self.trie = {}\",\n \"def __init__(self):\\n self.trie = {}\",\n \"def __init__(self):\\n self.trie = {}\",\n \"def __init__(self):\\n self.trie = {}\",\n \"def nodes_flags(self):\\n return self._nodes_flags\",\n \"def __init__(self):\\n self.root = Solution2.TrieNode()\",\n \"def get_orfs(genome, min_num_aa):\\n allowed = \\\"ATGC\\\"\\n if not isinstance(genome, str) or len(genome) == 0 or not all(c in allowed for c in genome):\\n raise TypeError\\n start_codon = \\\"ATG\\\"\\n stop_codon = ['TAA', 'TAG', 'TGA']\\n ref_dict = {\\\"T\\\" : \\\"A\\\", \\\"A\\\" : \\\"T\\\", \\\"G\\\" : \\\"C\\\", \\\"C\\\" : \\\"G\\\"}\\n amino_dict = {\\n 'L' : ['CTC', 'CTT', 'CTA', 'CTG', 'TTA', 'TTG'],\\n 'S' : ['TCA', 'TCT', 'TCC', 'TCG', 'AGC', 'AGT'],\\n 'R' : ['CGA', 'CGC', 'CGT', 'CGG', 'AGA', 'AGG'],\\n 'V' : ['GTA', 'GTG', 'GTC', 'GTT'],\\n 'P' : ['CCC', 'CCA', 'CCG', 'CCT'],\\n 'T' : ['ACC', 'ACG', 'ACT', 'ACA'],\\n 'A' : ['GCA', 'GCC', 'GCG', 'GCT'],\\n 'G' : ['GGA', 'GGC', 'GGT', 'GGG'],\\n 'I' : ['ATA', 'ATC', 'ATT'],\\n 'F' : ['TTT', 'TTC'],\\n 'Y' : ['TAT', 'TAC'],\\n 'H' : ['CAC', 'CAT'],\\n 'Q' : ['CAG', 'CAA'],\\n 'N' : ['AAC', 'AAT'],\\n 'K' : ['AAA', 'AAG'],\\n 'D' : ['GAC', 'GAT'],\\n 'E' : ['GAA', 'GAG'],\\n 'C' : ['TGC', 'TGT'],\\n 'M' : ['ATG'],\\n 'W' : ['TGG']\\n\\n }\\n comp_genome = \\\"\\\"\\n for stra in genome:\\n comp_genome += ref_dict[stra]\\n main_orfs = find_orfs(genome, start_codon, stop_codon, min_num_aa, amino_dict, False)\\n comp_orfs = find_orfs(comp_genome[::-1], start_codon, stop_codon, min_num_aa, amino_dict, True)\\n circular_orfs = find_cir_orfs(genome, main_orfs, start_codon, stop_codon, min_num_aa, amino_dict, False)\\n \\n circular_orfs_comp = find_cir_orfs(comp_genome[::-1], comp_orfs, start_codon, stop_codon, min_num_aa, amino_dict, True)\\n \\n for main_orf in main_orfs:\\n for cir_orf in circular_orfs:\\n if main_orf[0] <= cir_orf[1] and main_orf[1] <= cir_orf[1] or len(main_orf) == 5:\\n main_orfs.remove(main_orf)\\n for comp_orf in comp_orfs:\\n for cir_orf in circular_orfs_comp:\\n if comp_orf[1] == cir_orf[1] or len(comp_orf) == 5:\\n comp_orfs.remove(comp_orf)\\n\\n final_orf = main_orfs + comp_orfs + circular_orfs + circular_orfs_comp\\n #print(len(comp_orfs))\\n \\n \\n \\n return final_orf\",\n \"def __init__(self):\\n self.root = TrieNode()\\n self.kmap = {}\",\n \"def conditional_fptree(candidate, fptree, head_pointers, min_support, partial, items, initial_counts):\",\n \"def __init__(self):\\n self.root = Trie()\",\n \"def create_trie(self, genome):\\r\\n i = 0\\r\\n while i <= len(genome): # O(N)\\r\\n current = self.root\\r\\n self.create_trie_aux(current, genome, i) # O(N)\\r\\n i += 1\",\n \"def __init__(self):\\n self.root = TrieNode(\\\".\\\")\",\n \"def get_children(uri):\\n children = VGOCache(uri).results['children']\\n return check_has_regions(children)\",\n \"def _storage_review(\\n self,\\n storage_key: Hash32,\\n storage_root_hash: Hash32) -> Set[Hash32]:\\n with self._trie_db.at_root(storage_root_hash) as snapshot:\\n try:\\n # request the data just to see which part is missing\\n snapshot[storage_key]\\n except MissingTrieNode as exc:\\n return {exc.missing_node_hash}\\n else:\\n return set()\",\n \"def search(self, prefix: str) -> TrieNode:\\n leaf = self.root\\n for level in range(len(prefix)):\\n letter = prefix[level]\\n\\n if letter not in leaf.children:\\n return self.get_node()\\n leaf = leaf.children[letter]\\n\\n if leaf is not None:\\n return leaf\\n return self.get_node()\",\n \"def test_traversal_with_partial_word_returns_rest_of_word(full_trie):\\n assert list(full_trie.traversal('h')) == ['e', 'y']\",\n \"def test_traversal_on_word_with_no_following_letters(full_trie):\\n assert list(full_trie.traversal(\\\"hey\\\")) == []\",\n \"def __init__(self):\\n self.root = TrieNode(None)\",\n \"def __init__(self):\\n self.root = TrieNode(None)\",\n \"def compare_with_trie(self, delta=0.8):\\n\\n def format_diff(el, f, diff):\\n s = (\\n \\\"VALUE={0}\\\\nSYST=[{1}]\\\\nTRIE=[{2}]\\\\nMORE SYSTEM:\\\"\\n \\\"\\\\n{3}\\\\n######\\\\nMORE TRIE:\\\\n{4}\\\"\\n ).format(\\n el.value,\\n el.str_mks(),\\n f.stat.str_mks(),\\n el.str_all_completions(),\\n f.str_all_completions(),\\n )\\n if diff:\\n return f\\\"-------\\\\n{s}\\\\n-------\\\"\\n return s\\n\\n trie = CompletionTrieNode.build(self.tuples())\\n self.compute_metrics(delta=delta, details=True)\\n trie.precompute_stat()\\n trie.update_stat_dynamic(delta=delta)\\n diffs = []\\n for el in self:\\n f = trie.find(el.value)\\n d0 = el.mks0 - f.stat.mks0\\n d1 = el.mks1 - f.stat.mks1\\n d2 = el.mks2 - f.stat.mks2\\n d4 = el.mks0_ - f.stat.mks0_\\n if d0 != 0 or d1 != 0 or d2 != 0 or d4 != 0:\\n diffs.append((d0, d1, d2, d4, el, f, format_diff(el, f, True)))\\n if diffs:\\n diffs.sort(key=str)\\n return diffs\\n else:\\n return None\",\n \"def __init__(self):\\n self.trie = Node()\",\n \"def test_empty_tree_size(empty_trie):\\n assert empty_trie.size == 0\",\n \"def alpha(self):\\n if self.root_system.is_finite() and self.root_system.is_irreducible():\\n return Family(self.index_set(), self.simple_root, \\\\\\n hidden_keys = [0], hidden_function = lambda i: - self.highest_root())\\n else:\\n return self.simple_roots()\",\n \"def support_tree(self):\\n v = self.vertices\\n h_edges = list(self.hyper_edges)\\n\\n h_edges.sort(key=lambda x: len(x))\\n support_tree = Graph()\\n\\n for x in v:\\n support_tree.add(x)\\n\\n for h_edge in h_edges:\\n kruskal = list(connected_parts(support_tree, vertex_subset=h_edge))\\n if len(kruskal) == 1:\\n continue\\n else:\\n for i in range(len(kruskal) - 1):\\n support_tree.update([(next(iter(kruskal[i])), next(iter(kruskal[i + 1])))],\\n node_creation=False)\\n\\n return support_tree\",\n \"def _find_all_top_level_non_gene_features(chrom: str, db: FeatureDB, feature_types: List[str]) -> Iterable[Feature]:\\n for feature in db.region(seqid=chrom, featuretype=feature_types):\\n try:\\n _ = next(db.parents(feature.id))\\n except StopIteration:\\n yield feature\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n Trie = lambda: defaultdict(Trie)\\n self.trie = Trie()\",\n \"def concrete_search(self, limit):\\n frontier = Frontier_SortedList.Frontier_SortedList()\\n closed = {}\\n initial_node = TreeNode.TreeNode(\\n id=0,\\n state=self.problem.initial_state,\\n cost=0,\\n node_depth=0,\\n f=None,\\n parent=None,\\n last_action=None,\\n )\\n initial_node.f = self.__f_strategy(initial_node)\\n id = 1\\n frontier.insert(initial_node)\\n solution = False\\n while not solution and not frontier.is_empty():\\n actual_node = frontier.remove()\\n pruned = False\\n if self.problem.is_goal(actual_node.state):\\n solution = True\\n else:\\n if self.pruning == 1:\\n pruned = self.check_node_pruning_1st_prune(actual_node, closed)\\n if not pruned:\\n closed[actual_node.state.create_md5()] = abs(actual_node.f)\\n\\n if self.pruning in [0, 1]:\\n if not pruned:\\n if actual_node.node_depth < limit:\\n frontier, id = self.expand_node(id, actual_node, frontier)\\n\\n if self.pruning == 2:\\n if actual_node.node_depth < limit:\\n list_nodes, id = self.expand_node_2nd_prune(id, actual_node)\\n for node in list_nodes:\\n md5 = node.state.create_md5()\\n if md5 not in closed or closed[md5] > abs(node.f):\\n closed[md5] = abs(node.f)\\n frontier.insert(node)\\n if solution:\\n return self.solution(actual_node)\\n else:\\n return None\",\n \"def get_family_with_filtered_pedigree_with_samples(self):\\n return {self.name: self.get_filtered_pedigree_with_samples()}\",\n \"def delete_tree():\\n from trie import Trie\\n t = Trie()\\n t.insert(\\\"ted\\\")\\n t.insert(\\\"tea\\\")\\n t.insert(\\\"teabag\\\")\\n t.insert(\\\"teabags\\\")\\n t.insert(\\\"teabagger\\\")\\n t.insert(\\\"teabaggers\\\")\\n t.insert(\\\"teabagged\\\")\\n return t\",\n \"def __init__(self):\\n self.trie = dict()\",\n \"def __init__(self):\\n self.trie = dict()\",\n \"def __init__(self):\\n self.root = TrieNode()\\n self.char_map = {}\",\n \"def fs_used_including_snapshot_reserve(self):\\n return self._fs_used_including_snapshot_reserve\",\n \"def __init__(self):\\n self.root = TrieNode(\\\"st\\\")\",\n \"def prune_trie(trie, threshold):\\n\\tnode = trie.root\\n\\tpq = []\\n\\tfor i in node.children.keys():\\n\\t\\tpq.append((node.children[i],node.children[i].char))\\n\\twhile len(pq) > 0:\\n\\t\\tcur_node, char = pq.pop()\\n\\t\\tif cur_node.isEnd == False:\\n\\t\\t\\tfor i in cur_node.children.keys():\\n\\t\\t\\t\\tpq.append((cur_node.children[i],char + cur_node.children[i].char))\\n\\t\\telse:\\n\\t\\t\\tif cur_node.weight < threshold:\\n\\t\\t\\t\\tdelete(trie, char)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcontinue\\n\\treturn trie\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def __init__(self):\\n self.root = TrieNode()\",\n \"def find_features_geojson(self, geojson_tagset):\\n kreis_region_bund_list = []\\n only_regs_set = set()\\n for feature in geojson_tagset:\\n bundesl = feature.properties.get('NAME_1')\\n region = feature.properties.get('NAME_2')\\n kreis = feature.properties.get('NAME_3')\\n\\n kreis_region_bund_list.append((kreis, region, bundesl))\\n #Check: does \\\"Göttingen\\\" appear in this list as a region? Why does Goettingen need to be a region?)\\n return kreis_region_bund_list\",\n \"def build_feature_filter(self):\\n if self.features == [\\\"*\\\"]:\\n random_iso = list(self.data.keys())[0]\\n self.features = set()\\n for lang_features in self.data.values():\\n self.features |= set(lang_features.keys())\\n self.features = list(self.features)\\n if self.exclusions:\\n self.features = [f for f in self.features if f not in self.exclusions]\\n self.feature_filter = set(self.features)\",\n \"def __init__(self):\\n self.root = self.TrieNode(None)\",\n \"def get_candidates(self,query_index):\\r\\n # you will need to use self.hashed_A for this method\\r\\n bucket1 = self.hashed_A\\r\\n bucket = bucket1.filter(lambda z: (z[2] != query_index[2]) and (any(set(z[2]) & set(query_index[2]))))\\r\\n #print(bucket)\\r\\n return bucket\\r\\n raise NotImplementedError\",\n \"def facial_tetrahedron(x, y, z, xb, yb, zb):\\n success_mask = triangle_inequality(x, y, zb) # x, y, zb\\n triangle_inequality(x, y, zb, out = success_mask) # x, yb, z\\n triangle_inequality(xb, y, z, out = success_mask) # xb, y, z\\n triangle_inequality(xb, yb, zb, out = success_mask) # xb, yb, zb\\n return success_mask\",\n \"def filesystem_layers(self):\\n return None\",\n \"def surface_mask(self):\\n return np.vectorize(lambda name: name in self.nvertices.keys())(self.name)\",\n \"def __init__(self):\\r\\n self.root=Trie_Node()\",\n \"def __init__(self):\\n self.root=TrieNode()\",\n \"def __init__(self):\\n self.root=TrieNode()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5776142","0.57360816","0.5326462","0.5315044","0.5267867","0.5225813","0.51331353","0.5095872","0.50827706","0.49944326","0.49880475","0.496863","0.48768044","0.4836348","0.48069534","0.4800665","0.47692093","0.47494227","0.47216982","0.47108996","0.46952766","0.46802568","0.46288362","0.4597854","0.4574584","0.45703384","0.45663476","0.4565464","0.4564405","0.4564405","0.45574844","0.45485255","0.45451596","0.45401546","0.45385167","0.45328686","0.45239022","0.4520946","0.4520197","0.4520112","0.45198953","0.45198953","0.45198953","0.45198953","0.45145264","0.45127985","0.44835976","0.4474151","0.4472264","0.44716892","0.44614446","0.44568646","0.4437008","0.4435111","0.44331038","0.44319916","0.4426432","0.44238934","0.44238934","0.4417342","0.4404813","0.4404538","0.44030648","0.44023728","0.43960297","0.43917504","0.43801296","0.43749654","0.43700442","0.43585113","0.4344165","0.4344165","0.43413666","0.43398416","0.43356985","0.43331984","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43274632","0.43235445","0.4319148","0.43135387","0.43123403","0.4311675","0.42995092","0.4299432","0.42975456","0.42913768","0.42913768"],"string":"[\n \"0.5776142\",\n \"0.57360816\",\n \"0.5326462\",\n \"0.5315044\",\n \"0.5267867\",\n \"0.5225813\",\n \"0.51331353\",\n \"0.5095872\",\n \"0.50827706\",\n \"0.49944326\",\n \"0.49880475\",\n \"0.496863\",\n \"0.48768044\",\n \"0.4836348\",\n \"0.48069534\",\n \"0.4800665\",\n \"0.47692093\",\n \"0.47494227\",\n \"0.47216982\",\n \"0.47108996\",\n \"0.46952766\",\n \"0.46802568\",\n \"0.46288362\",\n \"0.4597854\",\n \"0.4574584\",\n \"0.45703384\",\n \"0.45663476\",\n \"0.4565464\",\n \"0.4564405\",\n \"0.4564405\",\n \"0.45574844\",\n \"0.45485255\",\n \"0.45451596\",\n \"0.45401546\",\n \"0.45385167\",\n \"0.45328686\",\n \"0.45239022\",\n \"0.4520946\",\n \"0.4520197\",\n \"0.4520112\",\n \"0.45198953\",\n \"0.45198953\",\n \"0.45198953\",\n \"0.45198953\",\n \"0.45145264\",\n \"0.45127985\",\n \"0.44835976\",\n \"0.4474151\",\n \"0.4472264\",\n \"0.44716892\",\n \"0.44614446\",\n \"0.44568646\",\n \"0.4437008\",\n \"0.4435111\",\n \"0.44331038\",\n \"0.44319916\",\n \"0.4426432\",\n \"0.44238934\",\n \"0.44238934\",\n \"0.4417342\",\n \"0.4404813\",\n \"0.4404538\",\n \"0.44030648\",\n \"0.44023728\",\n \"0.43960297\",\n \"0.43917504\",\n \"0.43801296\",\n \"0.43749654\",\n \"0.43700442\",\n \"0.43585113\",\n \"0.4344165\",\n \"0.4344165\",\n \"0.43413666\",\n \"0.43398416\",\n \"0.43356985\",\n \"0.43331984\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43274632\",\n \"0.43235445\",\n \"0.4319148\",\n \"0.43135387\",\n \"0.43123403\",\n \"0.4311675\",\n \"0.42995092\",\n \"0.4299432\",\n \"0.42975456\",\n \"0.42913768\",\n \"0.42913768\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7354035"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19491,"cells":{"query":{"kind":"string","value":"Return title + episode (if series)"},"document":{"kind":"string","value":"def inclusive_title(self):\n return self.title + (\" %s\" % (self.episode_to_string(self.latest_season, self.latest_episode),) if self.is_series() else \"\")"},"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 episode_title_for_tvdb(self):\n \n # strip out the year from the episode title:\n return \"Episode %d\"%self.episode_number[1]","def episode_title_for_tvdb(self):\n return self.episode_title","def episode_title_for_tvdb(self):\n \n # strip out the year from the episode title:\n return re.sub('(Part )(?P<part>\\d+)','(\\g<part>)',self.episode_title)","def _get_full_title(self):\n return \"%s - %s %d\" % (self.title, _('Season'), self.season)","def parse_episode_title(filename):\n print_info('Attempting to parse episode title from {0}'.format(filename))\n for regex in EPISODE_TITLE_REGEX:\n m = re.search(regex, filename)\n\n if m is None:\n continue\n\n extracted_title = m.group('EpisodeTitle')\n return clean_episode_title(extracted_title)\n return ''","def media_series_title(self):\n media_status = self._media_status()[0]\n return media_status.series_title if media_status else None","def seasonEpisode(self):\n return f's{str(self.seasonNumber).zfill(2)}e{str(self.episodeNumber).zfill(2)}'","def book_series_title(self):\n return get_value(self.record, \"book_series[0].title\")","def season_episode_str_from_show(show):\n return 'S{:02d}E{:02d}'.format(show._next.season, show._next.episode)","def convert_title_season_episode_to_long_form(self, se_input, title_input):\n se_input = se_input[1:]\n se_input.replace(' ', '')\n\n e_ndx = se_input.index('E')\n\n #sometimes it looks like \"S14 E10\" and sometimes it's \"S14 Ep10\"\n if \"Ep\" in se_input:\n ep_offset = 2\n else:\n ep_offset = 1\n\n s = se_input[:e_ndx]\n e = se_input[e_ndx+ep_offset:]\n\n return \"%s Season %s Episode %s\" % (title_input, s, e)","def extract_season_episode(string):\n series, episode = (None, None)\n\n # The series page url contains \"<name>_sX_eY\"\n m = re.match('.*[sS](\\d+)_?[eE](\\d+).*', string)\n if m:\n series, episode = m.groups()\n series = int(series)\n episode = int(episode)\n\n else:\n # Matches \"XxY\" OR unicode x (\\xd7 / ×)\n m = re.search(\"(\\d+)[x|\\xd7](\\d+)\", string)\n if m:\n series, episode = m.groups()\n series = int(series)\n episode = int(episode)\n else:\n m = re.search(\"S(\\d+)E(\\d+)\", string)\n if m:\n series, episode = m.groups()\n series = int(series)\n episode = int(episode)\n\n else:\n # Broke Girls – Season 4 Episode 22 – And the In and Out\n f = re.findall('(.+?)season\\s(\\d+)\\sepisode\\s(\\d+)', string + \" \", re.I)\n if f:\n _, series, episode = f[0]\n series = int(series)\n episode = int(episode)\n\n else:\n # Broke Girls – saison 5 épisode 16\n f = re.findall(\n '(.+?)\\ssaison\\s(\\d+)\\s\\xe9pisode\\s(\\d+)\\s',\n string + \" \", re.I)\n if f:\n _, series, episode = f[0]\n series = int(series)\n episode = int(episode)\n else:\n # 'Dragon Ball Super: Temporada 1 - Episodio 11 (2015)' TODO can be optimized\n f = re.findall('(.+?)\\stemporada\\s(\\d+)(.*)\\sepisodio\\s(\\d+)\\s', string + \" \", re.I)\n if f:\n _, series, __, episode = f[0]\n series = int(series)\n episode = int(episode)\n else:\n # Broke Girls – saison 5 episode 16\n f = re.findall(\n '(.+?)\\ssaison\\s(\\d+)\\s\\episode\\s(\\d+)\\s',\n string + \" \", re.I)\n if f:\n _, series, episode = f[0]\n series = int(series)\n episode = int(episode)\n\n return series, episode","def get_title():","def media_series_title(self):\n if lgtv[\"pairingKey\"] == 0:\n return \"Pin not set\"\n if self._currentSourceNumber == \"0\":\n return (\"{0} - CH{1:d} - {2}\").format(self._currentSourceName, self._currentChannelNumber, self._currentChannelName)\n else:\n return \"\"","def parse_anime_episode_title(filename):\n print_info('Attempting to parse episode title from {0}'.format(filename))\n for regex in ANIME_EPISODE_TITLE_REGEXS:\n m = re.search(regex, filename)\n\n if m is None:\n continue\n\n extracted_title = m.group('EpisodeTitle')\n return clean_episode_title(extracted_title)\n return ''","def get_episode_details(token, url, season):\n u = url + str(season)\n headers = {'Accept': 'application/json', 'Authorization': token}\n r = requests.get(u, headers=headers)\n json_data = json.loads(r.text).get('data')\n season_details = {}\n season_details['current_season'] = season\n if len(json_data) > 1:\n for episode in json_data:\n d = episode.get('firstAired')\n date = datetime.datetime.strptime(d, \"%Y-%m-%d\")\n today = datetime.datetime.today()\n if date.date() >= today.date():\n season_details['next_ep_no'] = episode.get('airedEpisodeNumber')\n season_details['next_air_date'] = episode.get('firstAired')\n season_details['ep_title'] = episode.get('episodeName')\n season_details['ep_overview'] = episode.get('overview')\n break\n else:\n season_details['next_ep_no'] = (json_data[len(json_data) - 1].get('airedEpisodeNumber'))\n season_details['next_air_date'] = (json_data[len(json_data) - 1].get('firstAired'))\n season_details['ep_title'] = (json_data[len(json_data) - 1].get('episodeName'))\n season_details['ep_overview'] = (json_data[len(json_data) - 1].get('overview'))\n else:\n season_details['next_ep_no'] = 1\n season_details['next_air_date'] = (json_data[0].get('firstAired'))\n season_details['ep_title'] = (json_data[0].get('episodeName'))\n season_details['ep_overview'] = (json_data[0].get('overview'))\n if season_details['next_air_date'] == \"\":\n season_details['next_air_date'] = 'TBD'\n if season_details['ep_title'] == \"\" or season_details['ep_title'] is None:\n season_details['ep_title'] = 'TBD'\n if season_details['ep_overview'] == \"\" or season_details['ep_overview'] is None:\n season_details['ep_overview'] = 'TBD'\n return season_details","def parse_episode(filename):\n print_info('Extracting episode from {0}'.format(filename))\n for regex in EPISODE_NUM_REGEXS:\n m = re.search(regex, filename)\n\n if m is None:\n continue\n\n extracted_ep = m.group('Episode').lower()\n print_info('Extracted episode: {0}'.format(extracted_ep))\n\n if '-' in extracted_ep:\n print_info('Multiple Episodes found')\n tokens = extracted_ep.split('-e')\n first_token = tokens[0]\n last_token = tokens[len(tokens)-1]\n return parse_episode(first_token) + '-' + parse_episode(last_token)\n else:\n ep_num = int(extracted_ep)\n if ep_num is not None and ep_num > 0:\n print_info('Episode might be: {0}'.format(ep_num))\n return 'E' + format_num(ep_num)\n\n return None","def getEpisodeArt(episode):\n\tseriesId = None\n\tfor sk in Dict['series'].keys():\n\t\tif Dict['series'][str(sk)]['title']==episode['seriesTitle']:\n\t\t\tseriesId = int(sk)\n\tif seriesId is not None:\n\t\tartUrl = \"\"\n\t\tif Dict['series'][str(seriesId)]['tvdbId'] is not None:\n\t\t\tartUrl = fanartScrapper.getSeasonThumb(Dict['series'][str(seriesId)]['tvdbId'], episode['season'], rand=False)\n\t\t\t#Log.Debug(\"arturl: %s\"%artUrl)\n\t\t\tif artUrl is not None:\n\t\t\t\tart = Function(getArt,url=artUrl)\n\t\tif artUrl == \"\" or artUrl is None:\n\t\t\tartUrl = Dict['series'][str(seriesId)]['art']\n\t\tif artUrl == \"\" or artUrl is None:\n\t\t\tartUrl = R(CRUNCHYROLL_ART)\n\telse:\n\t\tartUrl = R(CRUNCHYROLL_ART)\n\tLog.Debug(\"artUrl: %s\"%artUrl)\n\treturn artUrl","def testGetEpisodeName(self):\n\t\tfor case in self.testCases:\n\t\t\tassert case['title'] == getEpisodeName( case['show'], case['season'], case['episode'])","def episode_string(self, episode):\n cp, _ = zip(*episode.states)\n\n car_positions = dict()\n for i, p in enumerate(cp):\n car_positions[p] = i\n\n x, y = zip(*self.track_positions)\n output = \"\"\n y_rng = range(max(y) + 1)\n for i in range(max(x) + 1):\n row = \"\"\n for j in y_rng:\n pos = i, j\n if pos in car_positions:\n row += str(car_positions[pos])\n elif pos in self.start_positions:\n row += self.format_dict['start']\n elif pos in self.finish_positions:\n row += self.format_dict['finish']\n elif pos in self.track_positions:\n row += self.format_dict['track']\n else:\n row += self.format_dict['border']\n row += self.format_dict['sep']\n output = row + \"\\n\" + output\n return output","def test_get_episode_overview(self):\n self.assertEquals(\n self.t['Battlestar Galactica (2003)'][1][6]['overview'].startswith(\n 'When a new copy of Doral, a Cylon who had been previously'),\n True\n )","def get_title_artist(title_element): \n \n \n title_token = title_element.text.split(\" \")\n\n word = title_token.pop(0)\n artist = ''\n title = ''\n first = True\n while(title_token != [] and word != '-' and word[-1] != '-'):\n if first:\n first = False\n artist += (word)\n else:\n artist += ' '\n artist += word\n\n word = title_token.pop(0)\n \n if word[-1] == '-':\n word = word[:-1]\n artist += word\n \n if title_token == []:\n print(\"ERROR HERE: \", title_element.text)\n return None, None\n \n word = title_token.pop(0)\n first = True\n\n while(True):\n if first:\n first = False\n title += word\n else:\n title += ' '\n title += word\n if title_token != []:\n word = title_token.pop(0)\n if word == \"ALBUM\" or (word == \"EP\" and title_token[0] == \"REVIEW\"):\n break\n else:\n break\n return title, artist","def retrieve_episode(url):\n domain = parse_domain(url)\n html = retrieve_episode_html(url)\n return domain, html","def list_episodes(title, uri):\r\n\r\n # Set plugin category. It is displayed in some skins as the name\r\n # of the current section.\r\n xbmcplugin.setPluginCategory(_handle, title)\r\n\r\n # Get the list of videos in the category.\r\n result = _get_data(uri)\r\n # Iterate through videos.\r\n #logger.info(\"######: {}, log: {}########\".format('rk1', result['items']))\r\n for video in result['items']:\r\n # {\r\n # \"title\": \"Sakthi returns to India\",\r\n # \"contentId\": 1000036012,\r\n # \"uri\": \"https://api.hotstar.com/o/v1/episode/detail?id=80096&contentId=\r\n # 1000036012&offset=0&size=20&tao=0&tas=5\",\r\n # \"description\": \"Saravanana and Meenakshi's oldest son, Sakthi, returns to\r\n # India 25 years after his parents had left it. He wants to search for a bride,\",\r\n # \"duration\": 1332,\r\n # \"contentType\": \"EPISODE\",\r\n # \"contentProvider\": \"Global Villagers\",\r\n # \"cpDisplayName\": \"Global Villagers\",\r\n # \"assetType\": \"EPISODE\",\r\n # \"genre\": [\r\n # \"Family\"\r\n # ],\r\n # \"lang\": [\r\n # \"Tamil\"\r\n # ],\r\n # \"channelName\": \"Star Vijay\",\r\n # \"seasonNo\": 1,\r\n # \"episodeNo\": 520,\r\n # \"premium\": false,\r\n # \"live\": false,\r\n # \"hboContent\": false,\r\n # \"encrypted\": false,\r\n # \"startDate\": 1416649260,\r\n # \"endDate\": 4127812200,\r\n # \"broadCastDate\": 1382367600,\r\n # \"showName\": \"Saravanan Meenatchi\",\r\n # \"showId\": 99,\r\n # \"showShortTitle\": \"Saravanan Meenatchi\",\r\n # \"seasonName\": \"Chapter 1\",\r\n # \"playbackUri\": \"https://api.hotstar.com/h/v1/play?contentId=1000036012\",\r\n # \"contentDownloadable\": false\r\n # },\r\n _add_video_item(video)\r\n #logger.info(\"######: {}, log: {}########\".format('rk2', video))\r\n\r\n _add_next_page_and_search_item(result['nextPage'], 'episodes', title)\r\n\r\n # Add a sort method for the virtual folder items (alphabetically, ignore articles)\r\n xbmcplugin.addSortMethod(_handle, xbmcplugin.SORT_METHOD_NONE)\r\n\r\n # Finish creating a virtual folder.\r\n xbmcplugin.endOfDirectory(_handle)","def episode(self, title=None, episode=None):\n key = f'{self.key}/children'\n if title is not None and not isinstance(title, int):\n return self.fetchItem(key, Episode, title__iexact=title)\n elif episode is not None or isinstance(title, int):\n if isinstance(title, int):\n index = title\n else:\n index = episode\n return self.fetchItem(key, Episode, parentIndex=self.index, index=index)\n raise BadRequest('Missing argument: title or episode is required')","def episodes(self):\n for episode in self._root.iter('Episode'):\n entry = {}\n entry['season'] = int(episode.find('SeasonNumber').text)\n entry['episode'] = int(episode.find('EpisodeNumber').text)\n entry['title'] = unicode(episode.find('EpisodeName').text)\n if entry['title'] == '':\n continue\n entry['description'] = unicode(episode.find('Overview').text)\n entry['firstAired'] = episode.find('FirstAired').text\n yield entry","def add_episode(self, ep):\n #make da season\n ses = self._add_season(ep)\n dvdses = self._add_season(ep, dvd=True) \n self._add_episode(ep, ses)\n self._add_episode(ep, dvdses, dvd=True)","def title(self):\n if self.file_name is None:\n return None\n else:\n fname = os.path.split(self.file_name)[-1]\n fname, *ext = fname.rsplit('.', 1)\n procgen = ext and ext[0] in ('json', 'yaml')\n if procgen and self._seed and self._seed.spawn_key:\n # Append the spawn key as the episode number\n fname += '-e' + str(self._seed.spawn_key[-1])\n return fname","def create_episode(e, debug=False):\n #{\"title\": , \"summary\": , \"image\": , \"link\": , \"season\": , \"number\": , \"rating\"}\n\n if debug:\n print(\"beginning create_episode()\")\n\n episode = {}\n\n # get BeautifulSoup data for extracting details\n episode_url = \"https://www.imdb.com/\" + e[\"link\"]\n episode_soup = bs4.BeautifulSoup(requests.get(episode_url).text, features=\"html.parser\")\n\n #get title\n title_wrapper = episode_soup.select(\".title_wrapper\")[0]\n episode[\"title\"] = title_wrapper.select(\"h1\")[0].contents[0].replace(u'\\xa0', ' ')\n\n #get summary\n episode[\"summary\"] = episode_soup.select(\".summary_text\")[0].contents[0].replace(u'\\n', ' ')\n\n #get image\n episode[\"image\"] = get_image(e[\"link\"], debug)\n\n #link\n episode[\"link\"] = e[\"link\"]\n\n #season\n episode[\"season\"] = e[\"season\"]\n\n #number\n episode[\"number\"] = e[\"episode_number\"]\n\n #rating\n episode[\"rating\"] = e[\"rating\"]\n\n return episode","def SongTitle( path ):\n p = subprocess.Popen( ['ffprobe',path], stderr=subprocess.PIPE )\n\n output = p.communicate()[1].decode()\n if 'Invalid data found' in output:\n return None\n\n # find the first occurance of \"title : stuff\" with any number of spaces.\n res = re.search( r'title\\s+:\\s+([a-zA-Z0-9,\\(\\) ]+)', output )\n\n if res is None:\n return \"\"\n\n ret = res.group(1)\n\n return ret","def get_video_title(self, response):\n return response.css(\".watch-title::text\").extract_first(default='')","def convert_season_episode_to_long_form(self, se_input):\n se_input = se_input[1:]\n se_input.replace(' ', '')\n\n e_ndx = se_input.index('E')\n\n #sometimes it looks like \"S14 E10\" and sometimes it's \"S14 Ep10\"\n if \"Ep\" in se_input:\n ep_offset = 2\n else:\n ep_offset = 1\n\n s = se_input[:e_ndx]\n e = se_input[e_ndx+ep_offset:]\n\n return \"S%s Ep%s Season %s Episode %s\" % (s, e, s, e)","def getTitle(movieInfo):\n if \"title\" in movieInfo:\n #We remove the punctuation\n title = \"\".join(c for c in movieInfo[\"title\"] if c not in punctuation)\n #We return the title as a list of words in the right format\n return [ _format(w) for w in title.split() ]\n else:\n raise AttributeError(\"%s instance has no attribute title\" % movieInfo)","def episodes(self):\n episodes = []\n for series in self.series:\n episodes.extend(series.episodes)\n return episodes","def get_title(self):\n\n title = ''\n doc = self.article.doc\n\n title_element = self.parser.getElementsByTag(doc, tag='title')\n # no title found\n if title_element is None or len(title_element) == 0:\n return title\n\n # title elem found\n title_text = self.parser.getText(title_element[0])\n used_delimeter = False\n\n # split title with |\n if '|' in title_text:\n title_text = self.split_title(title_text, PIPE_SPLITTER)\n used_delimeter = True\n\n # split title with -\n if not used_delimeter and '-' in title_text:\n title_text = self.split_title(title_text, DASH_SPLITTER)\n used_delimeter = True\n\n # split title with »\n if not used_delimeter and u'»' in title_text:\n title_text = self.split_title(title_text, ARROWS_SPLITTER)\n used_delimeter = True\n\n # split title with :\n if not used_delimeter and ':' in title_text:\n title_text = self.split_title(title_text, COLON_SPLITTER)\n used_delimeter = True\n\n title = MOTLEY_REPLACEMENT.replaceAll(title_text)\n return title","def get_title_repr(self) -> str:\n try:\n return Title[self.title].value\n except (KeyError, ValueError):\n pass","def get_episode_metadata(\n episode: Sequence[Any]) -> Dict[str, Any]:\n\n first_step = episode[0]\n if not first_step.timestep.first():\n raise ValueError('The first step in this episode is not first')\n custom_data = first_step.custom_data\n return custom_data.get('episode_metadata', {}) if custom_data else {}","def EpisodeStatement(df):\n\n ls = []\n for index, row in df.iterrows():\n if len(row['Episode Title']) > 45:\n et = row['Episode Title'][:42] + \"...\"\n else:\n et = row['Episode Title']\n ls.append(\"Rated {}; S{}E{} {}\".format(row['Rating'], str(row['SX']).zfill(2), str(row['EX']).zfill(2), et))\n return ls","def get_title(self):\n return self.metadata['title']","def alternative_visit_title(self, node):\n std_domain = self.builder.env.domains['std']\n\n # get the figtype from the parent of this node since titles are not\n # enumerable\n figtype = std_domain.get_enumerable_node_type(node.parent)\n\n if figtype is None:\n raise RuntimeError('The figtype was not found despite the '\n 'exercise_title node being used within an exercise '\n 'node.')\n\n assert figtype in ('exercise', 'solution')\n\n # get the map of figure numbers for exercises for this document\n # if figtype is solution, we need to get a number of the corresponding\n # exercise\n fig_map = self.builder.fignumbers.get(figtype, {})\n\n # get id the exercise node\n fig_id = node.parent['ids'][0]\n # get figure number of the exercise node\n assert fig_id in fig_map\n\n if figtype == 'solution':\n _, _, fig_number = source_exercise_target(self, node)\n else:\n fig_number = fig_map[fig_id]\n\n # stringify the exercise id\n fig_number_str = '.'.join(map(str, fig_number))\n\n # format the exercise id\n prefix = self.builder.config.numfig_format.get(figtype)\n assert prefix is not None, 'exercise fignum format is not defined.'\n exercise_title = prefix % fig_number_str\n\n # build the HTML structure\n self.body.append('<span class=\"caption-number\">')\n self.body.append(exercise_title + ' ')\n self.body.append('</span>')","def convert_season_episode(self, se_input):\n if type(se_input) == str:\n se_input = se_input[1:]\n se_input.replace(' ', '')\n\n e_ndx = se_input.index('E')\n\n #sometimes it looks like \"S14 E10\" and sometimes it's \"S14 Ep10\"\n if \"Ep\" in se_input:\n ep_offset = 2\n else:\n ep_offset = 1\n\n # return two ints\n return int(se_input[:e_ndx]), int(se_input[e_ndx+ep_offset:])\n\n else:\n # return it as \"S14 Ep10\"\n return \"S%s Ep%s\" % (se_input[0], se_input[1])","def title(self):\n # Use the first line of the articles text as title, if not title\n # exists.\n title = self._text[:min(32, self._text.find(\"\\n\"))]\n return title","def get_release_name(self) -> str:\n if self.season is not None and self.episode is None:\n return os.path.basename(os.path.dirname(self.file))\n return os.path.splitext(os.path.basename(self.file))[0]","def media_title(self):\n return self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.Title","def list_show(self, alias):\n re_m = re.match(r'^(.*\\D)(\\d{1,2}){0,1}$', alias)\n if not re_m:\n print('Bad format for list - \"{0}\"'.format(alias))\n\n season = -1\n if re_m.lastindex == 2:\n season = int(re_m.group(2))\n show_id = self.id_by_title(\n self.title_by_alias(re_m.group(1), no_exit=True)\n )\n epis = self.load_episodes(show_id)\n episodes = epis['episodes']\n list_map = {}\n for epi_id in episodes:\n next_episode = episodes[epi_id]\n if season in [-1, next_episode['seasonNumber']]:\n list_map[\n next_episode['seasonNumber'] * 1000 +\n next_episode['episodeNumber']\n ] = next_episode\n\n watched = self.load_watched(show_id)\n current_season = -1\n for epi_num in sorted(list_map.keys()):\n next_episode = list_map[epi_num]\n next_season = next_episode['seasonNumber']\n if current_season != next_season:\n current_season = next_season\n print('{0} Season {1}:'.format(\n tr_out(epis['title']), current_season\n ))\n comment = ''\n epi_id = str(next_episode['id'])\n if epi_id in watched:\n comment = 'watched ' + watched[epi_id]['watchDate']\n print(' \"{0}\" (s{1:02d}e{2:02d}) {3}'.format(\n tr_out(next_episode['title']),\n next_episode['seasonNumber'],\n next_episode['episodeNumber'],\n comment\n ))","def get_podcast_episodes(url):\n\n def parse_pubdate(date_string):\n \"\"\"\n Change pubdate string to datetime object. Tries a bunch of\n possible formats, but if none of them is a match, it will\n return a epoch = 0 datetime object\n\n :param date_string: A string representing a date\n :return: datetime object\n \"\"\"\n date_formats = (\n '%a, %d %b %Y %H:%M:%S +0000',\n '%a, %d %b %Y',\n '%a, %d %b %Y%H:%M:%S +0000',\n '%a, %d %b %Y %H:%M',\n '%a, %d %b %Y %H.%M'\n )\n df_generator = (format for format in date_formats)\n\n date = None\n while date is None:\n try:\n date = datetime.strptime(date_string, next(df_generator))\n except ValueError:\n pass\n except StopIteration:\n date = datetime.fromtimestamp(0)\n\n return date\n\n doc = get_document(url)\n\n return (\n {\n 'url': item.select('guid')[0].text,\n 'Premiered': parse_pubdate(\n item.select('pubdate')[0].text\n ).strftime(\"%d.%m.%Y\"),\n # 'Duration': duration_to_seconds(item.find('itunes:duration').text),\n 'title': item.title.text,\n 'Plot': item.description.text\n }\n for item in doc.find_all(\"item\")\n )","def get_title(self, obj):\n title = obj.habit.title\n return title","def get_title(line):\n title = line.split(' (')[0]\n return title","def get_episode(self, object_id):\n return self.get_object(\"episode\", object_id)","def __calculate_title(video_data):\n title = 'Unknown'\n if 'fulltitle' in video_data.keys():\n title = video_data['fulltitle']\n elif 'title' in video_data.keys():\n title = video_data['title']\n elif '_filename' in video_data.keys():\n title = video_data['_filename']\n return title","def search_season_episode(self,strz):\t\n\t\tpattern = compile(\"(S(\\d\\d)E(\\d\\d))\") #S01E03\n\t\tsep = pattern.search(strz)\t\t\n\t\tif sep is not None:\n\t\t\tse= sep.group(1)\n\t\t\tseason = sep.group(2)\n\t\t\tepisode = sep.group(3)\n\t\t\treturn strz.replace(se,\"\")\n\t\t\t\n\t\tpattern = compile(\"((\\d\\d)x(\\d\\d))\") #01x03\n\t\tsep = pattern.search(strz)\t\t\n\t\tif sep is not None:\n\t\t\tse= sep.group(1)\n\t\t\tseason = sep.group(2)\n\t\t\tepisode = sep.group(3)\n\t\t\treturn strz.replace(se,\"\")\n\t\t\t\n\t\tpattern = compile(\"(Ep(\\d\\d))\") #Ep03\n\t\tsep = pattern.search(strz)\t\t\n\t\tif sep is not None:\n\t\t\tse= sep.group(1)\n\t\t\tepisode = sep.group(2)\n\t\t\treturn strz.replace(se,\"\")","def extract_season_episode_from_str(s):\n m = check_for_season_episode_code(s)\n\n if not m:\n return 1, 1\n\n return int(m.group(1)), int(m.group(2))","def video_title(self):\n # type: () -> string_types\n return self._video_title","def media_title(self):\n if self._track_id is not None and self._playlist:\n for track in self._playlist:\n if track.get(\"id\") == self._track_id:\n return track.get(\"title\")\n return None","def test_repr_episode(self):\n self.assertEquals(\n repr(self.t['CNNNN'][1][1]),\n \"<Episode 01x01 - September 19, 2002 (20:30 - 21:00)>\"\n )","def get_title(self) -> str:\n pass","def getlistofpossibletitles(fileitem,shows):\n title = []\n title.append(fileitem)\n lookfor = fileitem.replace(\".\",\" \")\n title.append(lookfor)\n lookfor = fileitem.replace('-',\" \")\n title.append(lookfor)\n return title","def media_episode(self):\n media_status = self._media_status()[0]\n return media_status.episode if media_status else None","def media_title(self):\n if 'artist' in self._status and 'title' in self._status:\n return '{artist} - {title}'.format(\n artist=self._status['artist'],\n title=self._status['title']\n )\n if 'current_title' in self._status:\n return self._status['current_title']","def extract_episode_details(season, episode_response):\n try:\n rating = float(episode_response['imdbRating'])\n except ValueError:\n # Rating may come through as 'N/A' if episode has not aired\n rating = None\n\n return {\n 'title': episode_response['Title'],\n 'episode': int(episode_response['Episode']),\n 'season': season,\n 'ratings': {'imdb': rating},\n }","def title(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"title\")","def test_get_title(self):\n title = \"The Title\"\n event = mixer.blend(\n 'calendarium.Event', start=now(), end=now(),\n creation_date=now(),\n title=title)\n self.assertEqual(title, str(event), msg=(\n 'Method ``__str__`` did not output event title.'))","def get_title(self):\n return [i['title'] for i in self]","def media_title(self) -> str:\n return self._device.movie.title","def title(self):\n return self.run_command('title')[0]","def title_string(self):\n return ' '.join(self.title).replace(' - ', '')","def get_title(portobjlist):\n #fetch_title(portobjlist)\n fetch_title(portobjlist)","def with_season(title, season):\n videos = list(mythVideo.searchVideos(title = title, season = season))\n\n for video in videos:\n video.label = video.title + \" - \" + video.subtitle\n video.url = \"/videos/\" + video.title + \"/\" + video.hash\n\n videos = sorted(videos, key = lambda video: video.episode)\n return render_template('list.html', items = videos, page_title = title + \" Season \" + str(season))","def short_title(self):\n if hasattr(self, \"title\"):\n return self.title\n else:\n return \"\"","def episode(self, title=None, season=None, episode=None):\n key = f'{self.key}/allLeaves'\n if title is not None:\n return self.fetchItem(key, Episode, title__iexact=title)\n elif season is not None and episode is not None:\n return self.fetchItem(key, Episode, parentIndex=season, index=episode)\n raise BadRequest('Missing argument: title or season and episode are required')","def get_title(mods):\n title = mods.find(\"{{{0}}}titleInfo/{{{0}}}title\".format(common.MODS_NS))\n return title.text","def episodes(self):\n episodes = []\n for season in self.seasons:\n episodes.extend(season.episodes)\n return episodes","def get_title(self):\n title_tag = self.soup.find('title').text\n title_list = string.split(sep='-')\n self.title = title_list[0].strip()","def parse_manga_title(filename):\n print_info('Attempting to parse manga title from {0}'.format(filename))\n for regex in MANGA_TITLE_REGEX:\n m = re.search(regex, filename)\n\n if m is None:\n continue\n\n extracted_title = m.group('Series')\n return clean_episode_title(extracted_title)\n return ''","def get_title(self):\n return self.run_command('get_title')[0]","def title(self):\n return self['title']","def parse_episode (self, episode, genres=None):\n mpaa = ''\n if episode.get('maturity', None) is not None:\n if episode['maturity'].get('board', None) is not None and episode['maturity'].get('value', None) is not None:\n mpaa = str(episode['maturity'].get('board', '').encode('utf-8')) + '-' + str(episode['maturity'].get('value', '').encode('utf-8'))\n\n return {\n episode['summary']['id']: {\n 'id': episode['summary']['id'],\n 'episode': episode['summary']['episode'],\n 'season': episode['summary']['season'],\n 'plot': episode['info']['synopsis'],\n 'duration': episode['info']['runtime'],\n 'title': episode['info']['title'],\n 'year': episode['info']['releaseYear'],\n 'genres': self.parse_genres_for_video(video=episode, genres=genres),\n 'mpaa': mpaa,\n 'maturity': episode['maturity'],\n 'playcount': (0, 1)[episode['watched']],\n 'rating': episode['userRating'].get('average', 0) if episode['userRating'].get('average', None) != None else episode['userRating'].get('predicted', 0),\n 'thumb': episode['info']['interestingMoments']['url'],\n 'fanart': episode['interestingMoment']['_1280x720']['jpg']['url'],\n 'poster': episode['boxarts']['_1280x720']['jpg']['url'],\n 'banner': episode['boxarts']['_342x192']['jpg']['url'],\n 'mediatype': {'episode': 'episode', 'movie': 'movie'}[episode['summary']['type']],\n 'my_list': episode['queue']['inQueue'],\n 'bookmark': episode['bookmarkPosition']\n }\n }","def get_title(self):\n meta = self.get_meta_data()\n if \"og:title\" in meta:\n return meta[\"og:title\"]\n else:\n soup = BeautifulSoup(self.TARGET_DATA)\n title = soup.find('title')\n if title:\n return title.text\n else:\n return \"No Title\"","def get_title(self) -> Optional[str]:\n return self.title","def get_title(self):\n return self.title","def get_title(self):\n return self.title","def get_title(self):\n return self.title","def get_series(self, seriesname, imdb=False): \n if not self.get_first:\n shows = self._get_many_series(seriesname, imdb=imdb)\n log.debug(shows)\n return shows\n sid = self.get_series_id(seriesname, imdb=imdb)\n return self.get_series_by_id(sid)","def _get_episodes(self):\n return [series_episode for series_episode in SeriesEpisode.objects.filter(series=self)]","def episode_factory(episode_info):\n logging.debug(\"episode_factory(info=%s)\"%episode_info)\n try:\n senum=episode_info['senum']\n season_episode_match=re.compile('s(\\d+)e(\\d+)').match(senum)\n season_index,episode_index=season_episode_match.groups()\n except KeyError:\n # senum missing\n logging.warning(\"senum missing from episode info\")\n season_index,episode_index=0,0\n \n \n specials=[HorizonEpisode, DragonsRidersOfBerk, DragonsDen, BakeOffExtraSlice\n ]\n for episode_class in specials:\n if episode_class.match_info(episode_info):\n return episode_class(episode_info['name'],episode_info['title'],int(season_index),int(episode_index))\n return Episode(episode_info['name'],episode_info['title'],int(season_index),int(episode_index))","def _make_title(self, ind):\n start = self.df_event_time.loc[ind, 'time']\n date = np.datetime_as_string(start.astype('<M8[ns]'), unit='s')\n start_ns = start - (start // 10**9) * 10**9\n end = self.df_event_time.loc[ind, 'endtime']\n end_ns = end - start + start_ns\n return ''.join((f'##Event {ind} from run {self.run_id}\\n',\n f'##Recorded at ({date[:10]} {date[10:]}) UTC ',\n f'{start_ns} ns - {end_ns} ns'))","async def title(self):\n if not hasattr(self, \"_title\"):\n self._title = await Stack.fetch_stack_value(self, \"http://purl.org/dc/terms/title\", await self.uuid)\n return self._title","def download_episode(self, filmid):\n self.logger.debug('download_episode')\n if not self._test_download_path(self.settings.getDownloadPathEpisode()):\n return\n film = self.database.retrieve_film_info(filmid)\n if film is None:\n return\n\n (filmurl, extension,) = self._get_film_url_and_extension(film)\n\n # detect season and episode\n (season, episode, fninfo,) = self._season_and_episode_detect(film)\n\n # determine names\n showname = mvutils.cleanup_filename(film.show)[:64]\n namestem = mvutils.cleanup_filename(film.title)[:80]\n if not namestem:\n namestem = u'Episode-{}'.format(film.filmid)\n if not showname:\n showname = namestem\n\n # review name\n if self.settings.getReviewName():\n (namestem, confirmed) = self.notifier.get_entered_text(namestem, 30986)\n namestem = mvutils.cleanup_filename(namestem)\n if len(namestem) < 1 or confirmed is False:\n return\n\n # prepare download directory and determine sequence number\n pathname = self.settings.getDownloadPathEpisode() + showname + '/'\n sequence = 1\n if xbmcvfs.exists(pathname):\n (_, epfiles,) = xbmcvfs.listdir(pathname)\n for epfile in epfiles:\n match = re.search(r'^.* - \\(([0-9]*)\\)\\.[^/]*$', epfile)\n if match and match.groups():\n if sequence <= int(match.group(1)):\n sequence = int(match.group(1)) + 1\n else:\n xbmcvfs.mkdir(pathname)\n\n filename = showname + ' - ' + fninfo + \\\n namestem + (u' - (%04d)' % sequence)\n # download the stuff\n if self._download_files(film, filmurl, pathname, filename, extension):\n self._make_series_nfo_files(\n film, filmurl, pathname, filename, season, episode, sequence)","def _prettyfilename(self):\n return f'{self.grandparentTitle} - {self.seasonEpisode} - {self.title}'","def get_appendix_title(node):\n return tree_utils.get_node_text(appendix_headers(node)[0])","def parse_anime_episode(filename):\n print_info('Extracting episode from {0}'.format(filename))\n for regex in ANIME_EPISODE_NUM_REGEXS:\n m = re.search(regex, filename)\n\n if m is None:\n continue\n\n extracted_ep = m.group('Episode')\n print_info('Extracted episode: {0}'.format(extracted_ep))\n\n ep_num = int(extracted_ep)\n if ep_num is not None and ep_num > 0:\n print_info('Episode might be: {0}'.format(ep_num))\n return 'E' + format_num(ep_num)\n\n return None","def get_title(self, article):\r\n\r\n title = ''\r\n doc = article.doc\r\n\r\n title_element = self.parser.getElementsByTag(doc, tag='title')\r\n # no title found\r\n if title_element is None or len(title_element) == 0:\r\n return title\r\n\r\n # title elem found\r\n title_text = self.parser.getText(title_element[0])\r\n used_delimeter = False\r\n\r\n # split title with |\r\n if '|' in title_text:\r\n title_text = self.split_title(title_text, PIPE_SPLITTER)\r\n used_delimeter = True\r\n\r\n # split title with -\r\n if not used_delimeter and '-' in title_text:\r\n title_text = self.split_title(title_text, DASH_SPLITTER)\r\n used_delimeter = True\r\n\r\n # split title with »\r\n if not used_delimeter and u'»' in title_text:\r\n title_text = self.split_title(title_text, ARROWS_SPLITTER)\r\n used_delimeter = True\r\n\r\n # split title with :\r\n if not used_delimeter and ':' in title_text:\r\n title_text = self.split_title(title_text, COLON_SPLITTER)\r\n used_delimeter = True\r\n\r\n title = MOTLEY_REPLACEMENT.replaceAll(title_text)\r\n return title","def extract_url(episode: dict) -> str:\n url = episode['embed_info']\n is_playable = episode['playable']\n episode_num = episode['number']\n #episode might not be playable or url might be empty\n if not is_playable or not url:\n raise Exception(f\"L'episodio {episode_num} non e' scaricabile.\")\n\n url = real_url(episode['embed_info'])\n url = format_url(url, episode['video_type'])\n if 'youtube.com' in url:\n raise Exception(f\"L'episodio {episode_num} e' un video di YouTube che puoi guardare a questo url: \\n{url}\")\n\n return url","def _parse_title(self, item):\n title = item[\"Title\"]\n return title","def get_p_key(episode_info):\n\treturn f'{episode_info[\"show_stub\"]}S{episode_info[\"season\"]}E{episode_info[\"episode\"]}'","def _defaultSyncTitle(self):\n return f'{self.grandparentTitle} - {self.parentTitle} - ({self.seasonEpisode}) {self.title}'","def title(self) -> str:\n return pulumi.get(self, \"title\")","def title(self) -> str:\n return pulumi.get(self, \"title\")","def title(self) -> str:\n return pulumi.get(self, \"title\")","def fetch_title(self, movie_id):\n movie = tmdbsimple.Movies(movie_id)\n request = movie.info()\n\n return movie.title","def get_oneseries_desc(oneseries):\n return oneseries"],"string":"[\n \"def episode_title_for_tvdb(self):\\n \\n # strip out the year from the episode title:\\n return \\\"Episode %d\\\"%self.episode_number[1]\",\n \"def episode_title_for_tvdb(self):\\n return self.episode_title\",\n \"def episode_title_for_tvdb(self):\\n \\n # strip out the year from the episode title:\\n return re.sub('(Part )(?P<part>\\\\d+)','(\\\\g<part>)',self.episode_title)\",\n \"def _get_full_title(self):\\n return \\\"%s - %s %d\\\" % (self.title, _('Season'), self.season)\",\n \"def parse_episode_title(filename):\\n print_info('Attempting to parse episode title from {0}'.format(filename))\\n for regex in EPISODE_TITLE_REGEX:\\n m = re.search(regex, filename)\\n\\n if m is None:\\n continue\\n\\n extracted_title = m.group('EpisodeTitle')\\n return clean_episode_title(extracted_title)\\n return ''\",\n \"def media_series_title(self):\\n media_status = self._media_status()[0]\\n return media_status.series_title if media_status else None\",\n \"def seasonEpisode(self):\\n return f's{str(self.seasonNumber).zfill(2)}e{str(self.episodeNumber).zfill(2)}'\",\n \"def book_series_title(self):\\n return get_value(self.record, \\\"book_series[0].title\\\")\",\n \"def season_episode_str_from_show(show):\\n return 'S{:02d}E{:02d}'.format(show._next.season, show._next.episode)\",\n \"def convert_title_season_episode_to_long_form(self, se_input, title_input):\\n se_input = se_input[1:]\\n se_input.replace(' ', '')\\n\\n e_ndx = se_input.index('E')\\n\\n #sometimes it looks like \\\"S14 E10\\\" and sometimes it's \\\"S14 Ep10\\\"\\n if \\\"Ep\\\" in se_input:\\n ep_offset = 2\\n else:\\n ep_offset = 1\\n\\n s = se_input[:e_ndx]\\n e = se_input[e_ndx+ep_offset:]\\n\\n return \\\"%s Season %s Episode %s\\\" % (title_input, s, e)\",\n \"def extract_season_episode(string):\\n series, episode = (None, None)\\n\\n # The series page url contains \\\"<name>_sX_eY\\\"\\n m = re.match('.*[sS](\\\\d+)_?[eE](\\\\d+).*', string)\\n if m:\\n series, episode = m.groups()\\n series = int(series)\\n episode = int(episode)\\n\\n else:\\n # Matches \\\"XxY\\\" OR unicode x (\\\\xd7 / ×)\\n m = re.search(\\\"(\\\\d+)[x|\\\\xd7](\\\\d+)\\\", string)\\n if m:\\n series, episode = m.groups()\\n series = int(series)\\n episode = int(episode)\\n else:\\n m = re.search(\\\"S(\\\\d+)E(\\\\d+)\\\", string)\\n if m:\\n series, episode = m.groups()\\n series = int(series)\\n episode = int(episode)\\n\\n else:\\n # Broke Girls – Season 4 Episode 22 – And the In and Out\\n f = re.findall('(.+?)season\\\\s(\\\\d+)\\\\sepisode\\\\s(\\\\d+)', string + \\\" \\\", re.I)\\n if f:\\n _, series, episode = f[0]\\n series = int(series)\\n episode = int(episode)\\n\\n else:\\n # Broke Girls – saison 5 épisode 16\\n f = re.findall(\\n '(.+?)\\\\ssaison\\\\s(\\\\d+)\\\\s\\\\xe9pisode\\\\s(\\\\d+)\\\\s',\\n string + \\\" \\\", re.I)\\n if f:\\n _, series, episode = f[0]\\n series = int(series)\\n episode = int(episode)\\n else:\\n # 'Dragon Ball Super: Temporada 1 - Episodio 11 (2015)' TODO can be optimized\\n f = re.findall('(.+?)\\\\stemporada\\\\s(\\\\d+)(.*)\\\\sepisodio\\\\s(\\\\d+)\\\\s', string + \\\" \\\", re.I)\\n if f:\\n _, series, __, episode = f[0]\\n series = int(series)\\n episode = int(episode)\\n else:\\n # Broke Girls – saison 5 episode 16\\n f = re.findall(\\n '(.+?)\\\\ssaison\\\\s(\\\\d+)\\\\s\\\\episode\\\\s(\\\\d+)\\\\s',\\n string + \\\" \\\", re.I)\\n if f:\\n _, series, episode = f[0]\\n series = int(series)\\n episode = int(episode)\\n\\n return series, episode\",\n \"def get_title():\",\n \"def media_series_title(self):\\n if lgtv[\\\"pairingKey\\\"] == 0:\\n return \\\"Pin not set\\\"\\n if self._currentSourceNumber == \\\"0\\\":\\n return (\\\"{0} - CH{1:d} - {2}\\\").format(self._currentSourceName, self._currentChannelNumber, self._currentChannelName)\\n else:\\n return \\\"\\\"\",\n \"def parse_anime_episode_title(filename):\\n print_info('Attempting to parse episode title from {0}'.format(filename))\\n for regex in ANIME_EPISODE_TITLE_REGEXS:\\n m = re.search(regex, filename)\\n\\n if m is None:\\n continue\\n\\n extracted_title = m.group('EpisodeTitle')\\n return clean_episode_title(extracted_title)\\n return ''\",\n \"def get_episode_details(token, url, season):\\n u = url + str(season)\\n headers = {'Accept': 'application/json', 'Authorization': token}\\n r = requests.get(u, headers=headers)\\n json_data = json.loads(r.text).get('data')\\n season_details = {}\\n season_details['current_season'] = season\\n if len(json_data) > 1:\\n for episode in json_data:\\n d = episode.get('firstAired')\\n date = datetime.datetime.strptime(d, \\\"%Y-%m-%d\\\")\\n today = datetime.datetime.today()\\n if date.date() >= today.date():\\n season_details['next_ep_no'] = episode.get('airedEpisodeNumber')\\n season_details['next_air_date'] = episode.get('firstAired')\\n season_details['ep_title'] = episode.get('episodeName')\\n season_details['ep_overview'] = episode.get('overview')\\n break\\n else:\\n season_details['next_ep_no'] = (json_data[len(json_data) - 1].get('airedEpisodeNumber'))\\n season_details['next_air_date'] = (json_data[len(json_data) - 1].get('firstAired'))\\n season_details['ep_title'] = (json_data[len(json_data) - 1].get('episodeName'))\\n season_details['ep_overview'] = (json_data[len(json_data) - 1].get('overview'))\\n else:\\n season_details['next_ep_no'] = 1\\n season_details['next_air_date'] = (json_data[0].get('firstAired'))\\n season_details['ep_title'] = (json_data[0].get('episodeName'))\\n season_details['ep_overview'] = (json_data[0].get('overview'))\\n if season_details['next_air_date'] == \\\"\\\":\\n season_details['next_air_date'] = 'TBD'\\n if season_details['ep_title'] == \\\"\\\" or season_details['ep_title'] is None:\\n season_details['ep_title'] = 'TBD'\\n if season_details['ep_overview'] == \\\"\\\" or season_details['ep_overview'] is None:\\n season_details['ep_overview'] = 'TBD'\\n return season_details\",\n \"def parse_episode(filename):\\n print_info('Extracting episode from {0}'.format(filename))\\n for regex in EPISODE_NUM_REGEXS:\\n m = re.search(regex, filename)\\n\\n if m is None:\\n continue\\n\\n extracted_ep = m.group('Episode').lower()\\n print_info('Extracted episode: {0}'.format(extracted_ep))\\n\\n if '-' in extracted_ep:\\n print_info('Multiple Episodes found')\\n tokens = extracted_ep.split('-e')\\n first_token = tokens[0]\\n last_token = tokens[len(tokens)-1]\\n return parse_episode(first_token) + '-' + parse_episode(last_token)\\n else:\\n ep_num = int(extracted_ep)\\n if ep_num is not None and ep_num > 0:\\n print_info('Episode might be: {0}'.format(ep_num))\\n return 'E' + format_num(ep_num)\\n\\n return None\",\n \"def getEpisodeArt(episode):\\n\\tseriesId = None\\n\\tfor sk in Dict['series'].keys():\\n\\t\\tif Dict['series'][str(sk)]['title']==episode['seriesTitle']:\\n\\t\\t\\tseriesId = int(sk)\\n\\tif seriesId is not None:\\n\\t\\tartUrl = \\\"\\\"\\n\\t\\tif Dict['series'][str(seriesId)]['tvdbId'] is not None:\\n\\t\\t\\tartUrl = fanartScrapper.getSeasonThumb(Dict['series'][str(seriesId)]['tvdbId'], episode['season'], rand=False)\\n\\t\\t\\t#Log.Debug(\\\"arturl: %s\\\"%artUrl)\\n\\t\\t\\tif artUrl is not None:\\n\\t\\t\\t\\tart = Function(getArt,url=artUrl)\\n\\t\\tif artUrl == \\\"\\\" or artUrl is None:\\n\\t\\t\\tartUrl = Dict['series'][str(seriesId)]['art']\\n\\t\\tif artUrl == \\\"\\\" or artUrl is None:\\n\\t\\t\\tartUrl = R(CRUNCHYROLL_ART)\\n\\telse:\\n\\t\\tartUrl = R(CRUNCHYROLL_ART)\\n\\tLog.Debug(\\\"artUrl: %s\\\"%artUrl)\\n\\treturn artUrl\",\n \"def testGetEpisodeName(self):\\n\\t\\tfor case in self.testCases:\\n\\t\\t\\tassert case['title'] == getEpisodeName( case['show'], case['season'], case['episode'])\",\n \"def episode_string(self, episode):\\n cp, _ = zip(*episode.states)\\n\\n car_positions = dict()\\n for i, p in enumerate(cp):\\n car_positions[p] = i\\n\\n x, y = zip(*self.track_positions)\\n output = \\\"\\\"\\n y_rng = range(max(y) + 1)\\n for i in range(max(x) + 1):\\n row = \\\"\\\"\\n for j in y_rng:\\n pos = i, j\\n if pos in car_positions:\\n row += str(car_positions[pos])\\n elif pos in self.start_positions:\\n row += self.format_dict['start']\\n elif pos in self.finish_positions:\\n row += self.format_dict['finish']\\n elif pos in self.track_positions:\\n row += self.format_dict['track']\\n else:\\n row += self.format_dict['border']\\n row += self.format_dict['sep']\\n output = row + \\\"\\\\n\\\" + output\\n return output\",\n \"def test_get_episode_overview(self):\\n self.assertEquals(\\n self.t['Battlestar Galactica (2003)'][1][6]['overview'].startswith(\\n 'When a new copy of Doral, a Cylon who had been previously'),\\n True\\n )\",\n \"def get_title_artist(title_element): \\n \\n \\n title_token = title_element.text.split(\\\" \\\")\\n\\n word = title_token.pop(0)\\n artist = ''\\n title = ''\\n first = True\\n while(title_token != [] and word != '-' and word[-1] != '-'):\\n if first:\\n first = False\\n artist += (word)\\n else:\\n artist += ' '\\n artist += word\\n\\n word = title_token.pop(0)\\n \\n if word[-1] == '-':\\n word = word[:-1]\\n artist += word\\n \\n if title_token == []:\\n print(\\\"ERROR HERE: \\\", title_element.text)\\n return None, None\\n \\n word = title_token.pop(0)\\n first = True\\n\\n while(True):\\n if first:\\n first = False\\n title += word\\n else:\\n title += ' '\\n title += word\\n if title_token != []:\\n word = title_token.pop(0)\\n if word == \\\"ALBUM\\\" or (word == \\\"EP\\\" and title_token[0] == \\\"REVIEW\\\"):\\n break\\n else:\\n break\\n return title, artist\",\n \"def retrieve_episode(url):\\n domain = parse_domain(url)\\n html = retrieve_episode_html(url)\\n return domain, html\",\n \"def list_episodes(title, uri):\\r\\n\\r\\n # Set plugin category. It is displayed in some skins as the name\\r\\n # of the current section.\\r\\n xbmcplugin.setPluginCategory(_handle, title)\\r\\n\\r\\n # Get the list of videos in the category.\\r\\n result = _get_data(uri)\\r\\n # Iterate through videos.\\r\\n #logger.info(\\\"######: {}, log: {}########\\\".format('rk1', result['items']))\\r\\n for video in result['items']:\\r\\n # {\\r\\n # \\\"title\\\": \\\"Sakthi returns to India\\\",\\r\\n # \\\"contentId\\\": 1000036012,\\r\\n # \\\"uri\\\": \\\"https://api.hotstar.com/o/v1/episode/detail?id=80096&contentId=\\r\\n # 1000036012&offset=0&size=20&tao=0&tas=5\\\",\\r\\n # \\\"description\\\": \\\"Saravanana and Meenakshi's oldest son, Sakthi, returns to\\r\\n # India 25 years after his parents had left it. He wants to search for a bride,\\\",\\r\\n # \\\"duration\\\": 1332,\\r\\n # \\\"contentType\\\": \\\"EPISODE\\\",\\r\\n # \\\"contentProvider\\\": \\\"Global Villagers\\\",\\r\\n # \\\"cpDisplayName\\\": \\\"Global Villagers\\\",\\r\\n # \\\"assetType\\\": \\\"EPISODE\\\",\\r\\n # \\\"genre\\\": [\\r\\n # \\\"Family\\\"\\r\\n # ],\\r\\n # \\\"lang\\\": [\\r\\n # \\\"Tamil\\\"\\r\\n # ],\\r\\n # \\\"channelName\\\": \\\"Star Vijay\\\",\\r\\n # \\\"seasonNo\\\": 1,\\r\\n # \\\"episodeNo\\\": 520,\\r\\n # \\\"premium\\\": false,\\r\\n # \\\"live\\\": false,\\r\\n # \\\"hboContent\\\": false,\\r\\n # \\\"encrypted\\\": false,\\r\\n # \\\"startDate\\\": 1416649260,\\r\\n # \\\"endDate\\\": 4127812200,\\r\\n # \\\"broadCastDate\\\": 1382367600,\\r\\n # \\\"showName\\\": \\\"Saravanan Meenatchi\\\",\\r\\n # \\\"showId\\\": 99,\\r\\n # \\\"showShortTitle\\\": \\\"Saravanan Meenatchi\\\",\\r\\n # \\\"seasonName\\\": \\\"Chapter 1\\\",\\r\\n # \\\"playbackUri\\\": \\\"https://api.hotstar.com/h/v1/play?contentId=1000036012\\\",\\r\\n # \\\"contentDownloadable\\\": false\\r\\n # },\\r\\n _add_video_item(video)\\r\\n #logger.info(\\\"######: {}, log: {}########\\\".format('rk2', video))\\r\\n\\r\\n _add_next_page_and_search_item(result['nextPage'], 'episodes', title)\\r\\n\\r\\n # Add a sort method for the virtual folder items (alphabetically, ignore articles)\\r\\n xbmcplugin.addSortMethod(_handle, xbmcplugin.SORT_METHOD_NONE)\\r\\n\\r\\n # Finish creating a virtual folder.\\r\\n xbmcplugin.endOfDirectory(_handle)\",\n \"def episode(self, title=None, episode=None):\\n key = f'{self.key}/children'\\n if title is not None and not isinstance(title, int):\\n return self.fetchItem(key, Episode, title__iexact=title)\\n elif episode is not None or isinstance(title, int):\\n if isinstance(title, int):\\n index = title\\n else:\\n index = episode\\n return self.fetchItem(key, Episode, parentIndex=self.index, index=index)\\n raise BadRequest('Missing argument: title or episode is required')\",\n \"def episodes(self):\\n for episode in self._root.iter('Episode'):\\n entry = {}\\n entry['season'] = int(episode.find('SeasonNumber').text)\\n entry['episode'] = int(episode.find('EpisodeNumber').text)\\n entry['title'] = unicode(episode.find('EpisodeName').text)\\n if entry['title'] == '':\\n continue\\n entry['description'] = unicode(episode.find('Overview').text)\\n entry['firstAired'] = episode.find('FirstAired').text\\n yield entry\",\n \"def add_episode(self, ep):\\n #make da season\\n ses = self._add_season(ep)\\n dvdses = self._add_season(ep, dvd=True) \\n self._add_episode(ep, ses)\\n self._add_episode(ep, dvdses, dvd=True)\",\n \"def title(self):\\n if self.file_name is None:\\n return None\\n else:\\n fname = os.path.split(self.file_name)[-1]\\n fname, *ext = fname.rsplit('.', 1)\\n procgen = ext and ext[0] in ('json', 'yaml')\\n if procgen and self._seed and self._seed.spawn_key:\\n # Append the spawn key as the episode number\\n fname += '-e' + str(self._seed.spawn_key[-1])\\n return fname\",\n \"def create_episode(e, debug=False):\\n #{\\\"title\\\": , \\\"summary\\\": , \\\"image\\\": , \\\"link\\\": , \\\"season\\\": , \\\"number\\\": , \\\"rating\\\"}\\n\\n if debug:\\n print(\\\"beginning create_episode()\\\")\\n\\n episode = {}\\n\\n # get BeautifulSoup data for extracting details\\n episode_url = \\\"https://www.imdb.com/\\\" + e[\\\"link\\\"]\\n episode_soup = bs4.BeautifulSoup(requests.get(episode_url).text, features=\\\"html.parser\\\")\\n\\n #get title\\n title_wrapper = episode_soup.select(\\\".title_wrapper\\\")[0]\\n episode[\\\"title\\\"] = title_wrapper.select(\\\"h1\\\")[0].contents[0].replace(u'\\\\xa0', ' ')\\n\\n #get summary\\n episode[\\\"summary\\\"] = episode_soup.select(\\\".summary_text\\\")[0].contents[0].replace(u'\\\\n', ' ')\\n\\n #get image\\n episode[\\\"image\\\"] = get_image(e[\\\"link\\\"], debug)\\n\\n #link\\n episode[\\\"link\\\"] = e[\\\"link\\\"]\\n\\n #season\\n episode[\\\"season\\\"] = e[\\\"season\\\"]\\n\\n #number\\n episode[\\\"number\\\"] = e[\\\"episode_number\\\"]\\n\\n #rating\\n episode[\\\"rating\\\"] = e[\\\"rating\\\"]\\n\\n return episode\",\n \"def SongTitle( path ):\\n p = subprocess.Popen( ['ffprobe',path], stderr=subprocess.PIPE )\\n\\n output = p.communicate()[1].decode()\\n if 'Invalid data found' in output:\\n return None\\n\\n # find the first occurance of \\\"title : stuff\\\" with any number of spaces.\\n res = re.search( r'title\\\\s+:\\\\s+([a-zA-Z0-9,\\\\(\\\\) ]+)', output )\\n\\n if res is None:\\n return \\\"\\\"\\n\\n ret = res.group(1)\\n\\n return ret\",\n \"def get_video_title(self, response):\\n return response.css(\\\".watch-title::text\\\").extract_first(default='')\",\n \"def convert_season_episode_to_long_form(self, se_input):\\n se_input = se_input[1:]\\n se_input.replace(' ', '')\\n\\n e_ndx = se_input.index('E')\\n\\n #sometimes it looks like \\\"S14 E10\\\" and sometimes it's \\\"S14 Ep10\\\"\\n if \\\"Ep\\\" in se_input:\\n ep_offset = 2\\n else:\\n ep_offset = 1\\n\\n s = se_input[:e_ndx]\\n e = se_input[e_ndx+ep_offset:]\\n\\n return \\\"S%s Ep%s Season %s Episode %s\\\" % (s, e, s, e)\",\n \"def getTitle(movieInfo):\\n if \\\"title\\\" in movieInfo:\\n #We remove the punctuation\\n title = \\\"\\\".join(c for c in movieInfo[\\\"title\\\"] if c not in punctuation)\\n #We return the title as a list of words in the right format\\n return [ _format(w) for w in title.split() ]\\n else:\\n raise AttributeError(\\\"%s instance has no attribute title\\\" % movieInfo)\",\n \"def episodes(self):\\n episodes = []\\n for series in self.series:\\n episodes.extend(series.episodes)\\n return episodes\",\n \"def get_title(self):\\n\\n title = ''\\n doc = self.article.doc\\n\\n title_element = self.parser.getElementsByTag(doc, tag='title')\\n # no title found\\n if title_element is None or len(title_element) == 0:\\n return title\\n\\n # title elem found\\n title_text = self.parser.getText(title_element[0])\\n used_delimeter = False\\n\\n # split title with |\\n if '|' in title_text:\\n title_text = self.split_title(title_text, PIPE_SPLITTER)\\n used_delimeter = True\\n\\n # split title with -\\n if not used_delimeter and '-' in title_text:\\n title_text = self.split_title(title_text, DASH_SPLITTER)\\n used_delimeter = True\\n\\n # split title with »\\n if not used_delimeter and u'»' in title_text:\\n title_text = self.split_title(title_text, ARROWS_SPLITTER)\\n used_delimeter = True\\n\\n # split title with :\\n if not used_delimeter and ':' in title_text:\\n title_text = self.split_title(title_text, COLON_SPLITTER)\\n used_delimeter = True\\n\\n title = MOTLEY_REPLACEMENT.replaceAll(title_text)\\n return title\",\n \"def get_title_repr(self) -> str:\\n try:\\n return Title[self.title].value\\n except (KeyError, ValueError):\\n pass\",\n \"def get_episode_metadata(\\n episode: Sequence[Any]) -> Dict[str, Any]:\\n\\n first_step = episode[0]\\n if not first_step.timestep.first():\\n raise ValueError('The first step in this episode is not first')\\n custom_data = first_step.custom_data\\n return custom_data.get('episode_metadata', {}) if custom_data else {}\",\n \"def EpisodeStatement(df):\\n\\n ls = []\\n for index, row in df.iterrows():\\n if len(row['Episode Title']) > 45:\\n et = row['Episode Title'][:42] + \\\"...\\\"\\n else:\\n et = row['Episode Title']\\n ls.append(\\\"Rated {}; S{}E{} {}\\\".format(row['Rating'], str(row['SX']).zfill(2), str(row['EX']).zfill(2), et))\\n return ls\",\n \"def get_title(self):\\n return self.metadata['title']\",\n \"def alternative_visit_title(self, node):\\n std_domain = self.builder.env.domains['std']\\n\\n # get the figtype from the parent of this node since titles are not\\n # enumerable\\n figtype = std_domain.get_enumerable_node_type(node.parent)\\n\\n if figtype is None:\\n raise RuntimeError('The figtype was not found despite the '\\n 'exercise_title node being used within an exercise '\\n 'node.')\\n\\n assert figtype in ('exercise', 'solution')\\n\\n # get the map of figure numbers for exercises for this document\\n # if figtype is solution, we need to get a number of the corresponding\\n # exercise\\n fig_map = self.builder.fignumbers.get(figtype, {})\\n\\n # get id the exercise node\\n fig_id = node.parent['ids'][0]\\n # get figure number of the exercise node\\n assert fig_id in fig_map\\n\\n if figtype == 'solution':\\n _, _, fig_number = source_exercise_target(self, node)\\n else:\\n fig_number = fig_map[fig_id]\\n\\n # stringify the exercise id\\n fig_number_str = '.'.join(map(str, fig_number))\\n\\n # format the exercise id\\n prefix = self.builder.config.numfig_format.get(figtype)\\n assert prefix is not None, 'exercise fignum format is not defined.'\\n exercise_title = prefix % fig_number_str\\n\\n # build the HTML structure\\n self.body.append('<span class=\\\"caption-number\\\">')\\n self.body.append(exercise_title + ' ')\\n self.body.append('</span>')\",\n \"def convert_season_episode(self, se_input):\\n if type(se_input) == str:\\n se_input = se_input[1:]\\n se_input.replace(' ', '')\\n\\n e_ndx = se_input.index('E')\\n\\n #sometimes it looks like \\\"S14 E10\\\" and sometimes it's \\\"S14 Ep10\\\"\\n if \\\"Ep\\\" in se_input:\\n ep_offset = 2\\n else:\\n ep_offset = 1\\n\\n # return two ints\\n return int(se_input[:e_ndx]), int(se_input[e_ndx+ep_offset:])\\n\\n else:\\n # return it as \\\"S14 Ep10\\\"\\n return \\\"S%s Ep%s\\\" % (se_input[0], se_input[1])\",\n \"def title(self):\\n # Use the first line of the articles text as title, if not title\\n # exists.\\n title = self._text[:min(32, self._text.find(\\\"\\\\n\\\"))]\\n return title\",\n \"def get_release_name(self) -> str:\\n if self.season is not None and self.episode is None:\\n return os.path.basename(os.path.dirname(self.file))\\n return os.path.splitext(os.path.basename(self.file))[0]\",\n \"def media_title(self):\\n return self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.Title\",\n \"def list_show(self, alias):\\n re_m = re.match(r'^(.*\\\\D)(\\\\d{1,2}){0,1}$', alias)\\n if not re_m:\\n print('Bad format for list - \\\"{0}\\\"'.format(alias))\\n\\n season = -1\\n if re_m.lastindex == 2:\\n season = int(re_m.group(2))\\n show_id = self.id_by_title(\\n self.title_by_alias(re_m.group(1), no_exit=True)\\n )\\n epis = self.load_episodes(show_id)\\n episodes = epis['episodes']\\n list_map = {}\\n for epi_id in episodes:\\n next_episode = episodes[epi_id]\\n if season in [-1, next_episode['seasonNumber']]:\\n list_map[\\n next_episode['seasonNumber'] * 1000 +\\n next_episode['episodeNumber']\\n ] = next_episode\\n\\n watched = self.load_watched(show_id)\\n current_season = -1\\n for epi_num in sorted(list_map.keys()):\\n next_episode = list_map[epi_num]\\n next_season = next_episode['seasonNumber']\\n if current_season != next_season:\\n current_season = next_season\\n print('{0} Season {1}:'.format(\\n tr_out(epis['title']), current_season\\n ))\\n comment = ''\\n epi_id = str(next_episode['id'])\\n if epi_id in watched:\\n comment = 'watched ' + watched[epi_id]['watchDate']\\n print(' \\\"{0}\\\" (s{1:02d}e{2:02d}) {3}'.format(\\n tr_out(next_episode['title']),\\n next_episode['seasonNumber'],\\n next_episode['episodeNumber'],\\n comment\\n ))\",\n \"def get_podcast_episodes(url):\\n\\n def parse_pubdate(date_string):\\n \\\"\\\"\\\"\\n Change pubdate string to datetime object. Tries a bunch of\\n possible formats, but if none of them is a match, it will\\n return a epoch = 0 datetime object\\n\\n :param date_string: A string representing a date\\n :return: datetime object\\n \\\"\\\"\\\"\\n date_formats = (\\n '%a, %d %b %Y %H:%M:%S +0000',\\n '%a, %d %b %Y',\\n '%a, %d %b %Y%H:%M:%S +0000',\\n '%a, %d %b %Y %H:%M',\\n '%a, %d %b %Y %H.%M'\\n )\\n df_generator = (format for format in date_formats)\\n\\n date = None\\n while date is None:\\n try:\\n date = datetime.strptime(date_string, next(df_generator))\\n except ValueError:\\n pass\\n except StopIteration:\\n date = datetime.fromtimestamp(0)\\n\\n return date\\n\\n doc = get_document(url)\\n\\n return (\\n {\\n 'url': item.select('guid')[0].text,\\n 'Premiered': parse_pubdate(\\n item.select('pubdate')[0].text\\n ).strftime(\\\"%d.%m.%Y\\\"),\\n # 'Duration': duration_to_seconds(item.find('itunes:duration').text),\\n 'title': item.title.text,\\n 'Plot': item.description.text\\n }\\n for item in doc.find_all(\\\"item\\\")\\n )\",\n \"def get_title(self, obj):\\n title = obj.habit.title\\n return title\",\n \"def get_title(line):\\n title = line.split(' (')[0]\\n return title\",\n \"def get_episode(self, object_id):\\n return self.get_object(\\\"episode\\\", object_id)\",\n \"def __calculate_title(video_data):\\n title = 'Unknown'\\n if 'fulltitle' in video_data.keys():\\n title = video_data['fulltitle']\\n elif 'title' in video_data.keys():\\n title = video_data['title']\\n elif '_filename' in video_data.keys():\\n title = video_data['_filename']\\n return title\",\n \"def search_season_episode(self,strz):\\t\\n\\t\\tpattern = compile(\\\"(S(\\\\d\\\\d)E(\\\\d\\\\d))\\\") #S01E03\\n\\t\\tsep = pattern.search(strz)\\t\\t\\n\\t\\tif sep is not None:\\n\\t\\t\\tse= sep.group(1)\\n\\t\\t\\tseason = sep.group(2)\\n\\t\\t\\tepisode = sep.group(3)\\n\\t\\t\\treturn strz.replace(se,\\\"\\\")\\n\\t\\t\\t\\n\\t\\tpattern = compile(\\\"((\\\\d\\\\d)x(\\\\d\\\\d))\\\") #01x03\\n\\t\\tsep = pattern.search(strz)\\t\\t\\n\\t\\tif sep is not None:\\n\\t\\t\\tse= sep.group(1)\\n\\t\\t\\tseason = sep.group(2)\\n\\t\\t\\tepisode = sep.group(3)\\n\\t\\t\\treturn strz.replace(se,\\\"\\\")\\n\\t\\t\\t\\n\\t\\tpattern = compile(\\\"(Ep(\\\\d\\\\d))\\\") #Ep03\\n\\t\\tsep = pattern.search(strz)\\t\\t\\n\\t\\tif sep is not None:\\n\\t\\t\\tse= sep.group(1)\\n\\t\\t\\tepisode = sep.group(2)\\n\\t\\t\\treturn strz.replace(se,\\\"\\\")\",\n \"def extract_season_episode_from_str(s):\\n m = check_for_season_episode_code(s)\\n\\n if not m:\\n return 1, 1\\n\\n return int(m.group(1)), int(m.group(2))\",\n \"def video_title(self):\\n # type: () -> string_types\\n return self._video_title\",\n \"def media_title(self):\\n if self._track_id is not None and self._playlist:\\n for track in self._playlist:\\n if track.get(\\\"id\\\") == self._track_id:\\n return track.get(\\\"title\\\")\\n return None\",\n \"def test_repr_episode(self):\\n self.assertEquals(\\n repr(self.t['CNNNN'][1][1]),\\n \\\"<Episode 01x01 - September 19, 2002 (20:30 - 21:00)>\\\"\\n )\",\n \"def get_title(self) -> str:\\n pass\",\n \"def getlistofpossibletitles(fileitem,shows):\\n title = []\\n title.append(fileitem)\\n lookfor = fileitem.replace(\\\".\\\",\\\" \\\")\\n title.append(lookfor)\\n lookfor = fileitem.replace('-',\\\" \\\")\\n title.append(lookfor)\\n return title\",\n \"def media_episode(self):\\n media_status = self._media_status()[0]\\n return media_status.episode if media_status else None\",\n \"def media_title(self):\\n if 'artist' in self._status and 'title' in self._status:\\n return '{artist} - {title}'.format(\\n artist=self._status['artist'],\\n title=self._status['title']\\n )\\n if 'current_title' in self._status:\\n return self._status['current_title']\",\n \"def extract_episode_details(season, episode_response):\\n try:\\n rating = float(episode_response['imdbRating'])\\n except ValueError:\\n # Rating may come through as 'N/A' if episode has not aired\\n rating = None\\n\\n return {\\n 'title': episode_response['Title'],\\n 'episode': int(episode_response['Episode']),\\n 'season': season,\\n 'ratings': {'imdb': rating},\\n }\",\n \"def title(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"title\\\")\",\n \"def test_get_title(self):\\n title = \\\"The Title\\\"\\n event = mixer.blend(\\n 'calendarium.Event', start=now(), end=now(),\\n creation_date=now(),\\n title=title)\\n self.assertEqual(title, str(event), msg=(\\n 'Method ``__str__`` did not output event title.'))\",\n \"def get_title(self):\\n return [i['title'] for i in self]\",\n \"def media_title(self) -> str:\\n return self._device.movie.title\",\n \"def title(self):\\n return self.run_command('title')[0]\",\n \"def title_string(self):\\n return ' '.join(self.title).replace(' - ', '')\",\n \"def get_title(portobjlist):\\n #fetch_title(portobjlist)\\n fetch_title(portobjlist)\",\n \"def with_season(title, season):\\n videos = list(mythVideo.searchVideos(title = title, season = season))\\n\\n for video in videos:\\n video.label = video.title + \\\" - \\\" + video.subtitle\\n video.url = \\\"/videos/\\\" + video.title + \\\"/\\\" + video.hash\\n\\n videos = sorted(videos, key = lambda video: video.episode)\\n return render_template('list.html', items = videos, page_title = title + \\\" Season \\\" + str(season))\",\n \"def short_title(self):\\n if hasattr(self, \\\"title\\\"):\\n return self.title\\n else:\\n return \\\"\\\"\",\n \"def episode(self, title=None, season=None, episode=None):\\n key = f'{self.key}/allLeaves'\\n if title is not None:\\n return self.fetchItem(key, Episode, title__iexact=title)\\n elif season is not None and episode is not None:\\n return self.fetchItem(key, Episode, parentIndex=season, index=episode)\\n raise BadRequest('Missing argument: title or season and episode are required')\",\n \"def get_title(mods):\\n title = mods.find(\\\"{{{0}}}titleInfo/{{{0}}}title\\\".format(common.MODS_NS))\\n return title.text\",\n \"def episodes(self):\\n episodes = []\\n for season in self.seasons:\\n episodes.extend(season.episodes)\\n return episodes\",\n \"def get_title(self):\\n title_tag = self.soup.find('title').text\\n title_list = string.split(sep='-')\\n self.title = title_list[0].strip()\",\n \"def parse_manga_title(filename):\\n print_info('Attempting to parse manga title from {0}'.format(filename))\\n for regex in MANGA_TITLE_REGEX:\\n m = re.search(regex, filename)\\n\\n if m is None:\\n continue\\n\\n extracted_title = m.group('Series')\\n return clean_episode_title(extracted_title)\\n return ''\",\n \"def get_title(self):\\n return self.run_command('get_title')[0]\",\n \"def title(self):\\n return self['title']\",\n \"def parse_episode (self, episode, genres=None):\\n mpaa = ''\\n if episode.get('maturity', None) is not None:\\n if episode['maturity'].get('board', None) is not None and episode['maturity'].get('value', None) is not None:\\n mpaa = str(episode['maturity'].get('board', '').encode('utf-8')) + '-' + str(episode['maturity'].get('value', '').encode('utf-8'))\\n\\n return {\\n episode['summary']['id']: {\\n 'id': episode['summary']['id'],\\n 'episode': episode['summary']['episode'],\\n 'season': episode['summary']['season'],\\n 'plot': episode['info']['synopsis'],\\n 'duration': episode['info']['runtime'],\\n 'title': episode['info']['title'],\\n 'year': episode['info']['releaseYear'],\\n 'genres': self.parse_genres_for_video(video=episode, genres=genres),\\n 'mpaa': mpaa,\\n 'maturity': episode['maturity'],\\n 'playcount': (0, 1)[episode['watched']],\\n 'rating': episode['userRating'].get('average', 0) if episode['userRating'].get('average', None) != None else episode['userRating'].get('predicted', 0),\\n 'thumb': episode['info']['interestingMoments']['url'],\\n 'fanart': episode['interestingMoment']['_1280x720']['jpg']['url'],\\n 'poster': episode['boxarts']['_1280x720']['jpg']['url'],\\n 'banner': episode['boxarts']['_342x192']['jpg']['url'],\\n 'mediatype': {'episode': 'episode', 'movie': 'movie'}[episode['summary']['type']],\\n 'my_list': episode['queue']['inQueue'],\\n 'bookmark': episode['bookmarkPosition']\\n }\\n }\",\n \"def get_title(self):\\n meta = self.get_meta_data()\\n if \\\"og:title\\\" in meta:\\n return meta[\\\"og:title\\\"]\\n else:\\n soup = BeautifulSoup(self.TARGET_DATA)\\n title = soup.find('title')\\n if title:\\n return title.text\\n else:\\n return \\\"No Title\\\"\",\n \"def get_title(self) -> Optional[str]:\\n return self.title\",\n \"def get_title(self):\\n return self.title\",\n \"def get_title(self):\\n return self.title\",\n \"def get_title(self):\\n return self.title\",\n \"def get_series(self, seriesname, imdb=False): \\n if not self.get_first:\\n shows = self._get_many_series(seriesname, imdb=imdb)\\n log.debug(shows)\\n return shows\\n sid = self.get_series_id(seriesname, imdb=imdb)\\n return self.get_series_by_id(sid)\",\n \"def _get_episodes(self):\\n return [series_episode for series_episode in SeriesEpisode.objects.filter(series=self)]\",\n \"def episode_factory(episode_info):\\n logging.debug(\\\"episode_factory(info=%s)\\\"%episode_info)\\n try:\\n senum=episode_info['senum']\\n season_episode_match=re.compile('s(\\\\d+)e(\\\\d+)').match(senum)\\n season_index,episode_index=season_episode_match.groups()\\n except KeyError:\\n # senum missing\\n logging.warning(\\\"senum missing from episode info\\\")\\n season_index,episode_index=0,0\\n \\n \\n specials=[HorizonEpisode, DragonsRidersOfBerk, DragonsDen, BakeOffExtraSlice\\n ]\\n for episode_class in specials:\\n if episode_class.match_info(episode_info):\\n return episode_class(episode_info['name'],episode_info['title'],int(season_index),int(episode_index))\\n return Episode(episode_info['name'],episode_info['title'],int(season_index),int(episode_index))\",\n \"def _make_title(self, ind):\\n start = self.df_event_time.loc[ind, 'time']\\n date = np.datetime_as_string(start.astype('<M8[ns]'), unit='s')\\n start_ns = start - (start // 10**9) * 10**9\\n end = self.df_event_time.loc[ind, 'endtime']\\n end_ns = end - start + start_ns\\n return ''.join((f'##Event {ind} from run {self.run_id}\\\\n',\\n f'##Recorded at ({date[:10]} {date[10:]}) UTC ',\\n f'{start_ns} ns - {end_ns} ns'))\",\n \"async def title(self):\\n if not hasattr(self, \\\"_title\\\"):\\n self._title = await Stack.fetch_stack_value(self, \\\"http://purl.org/dc/terms/title\\\", await self.uuid)\\n return self._title\",\n \"def download_episode(self, filmid):\\n self.logger.debug('download_episode')\\n if not self._test_download_path(self.settings.getDownloadPathEpisode()):\\n return\\n film = self.database.retrieve_film_info(filmid)\\n if film is None:\\n return\\n\\n (filmurl, extension,) = self._get_film_url_and_extension(film)\\n\\n # detect season and episode\\n (season, episode, fninfo,) = self._season_and_episode_detect(film)\\n\\n # determine names\\n showname = mvutils.cleanup_filename(film.show)[:64]\\n namestem = mvutils.cleanup_filename(film.title)[:80]\\n if not namestem:\\n namestem = u'Episode-{}'.format(film.filmid)\\n if not showname:\\n showname = namestem\\n\\n # review name\\n if self.settings.getReviewName():\\n (namestem, confirmed) = self.notifier.get_entered_text(namestem, 30986)\\n namestem = mvutils.cleanup_filename(namestem)\\n if len(namestem) < 1 or confirmed is False:\\n return\\n\\n # prepare download directory and determine sequence number\\n pathname = self.settings.getDownloadPathEpisode() + showname + '/'\\n sequence = 1\\n if xbmcvfs.exists(pathname):\\n (_, epfiles,) = xbmcvfs.listdir(pathname)\\n for epfile in epfiles:\\n match = re.search(r'^.* - \\\\(([0-9]*)\\\\)\\\\.[^/]*$', epfile)\\n if match and match.groups():\\n if sequence <= int(match.group(1)):\\n sequence = int(match.group(1)) + 1\\n else:\\n xbmcvfs.mkdir(pathname)\\n\\n filename = showname + ' - ' + fninfo + \\\\\\n namestem + (u' - (%04d)' % sequence)\\n # download the stuff\\n if self._download_files(film, filmurl, pathname, filename, extension):\\n self._make_series_nfo_files(\\n film, filmurl, pathname, filename, season, episode, sequence)\",\n \"def _prettyfilename(self):\\n return f'{self.grandparentTitle} - {self.seasonEpisode} - {self.title}'\",\n \"def get_appendix_title(node):\\n return tree_utils.get_node_text(appendix_headers(node)[0])\",\n \"def parse_anime_episode(filename):\\n print_info('Extracting episode from {0}'.format(filename))\\n for regex in ANIME_EPISODE_NUM_REGEXS:\\n m = re.search(regex, filename)\\n\\n if m is None:\\n continue\\n\\n extracted_ep = m.group('Episode')\\n print_info('Extracted episode: {0}'.format(extracted_ep))\\n\\n ep_num = int(extracted_ep)\\n if ep_num is not None and ep_num > 0:\\n print_info('Episode might be: {0}'.format(ep_num))\\n return 'E' + format_num(ep_num)\\n\\n return None\",\n \"def get_title(self, article):\\r\\n\\r\\n title = ''\\r\\n doc = article.doc\\r\\n\\r\\n title_element = self.parser.getElementsByTag(doc, tag='title')\\r\\n # no title found\\r\\n if title_element is None or len(title_element) == 0:\\r\\n return title\\r\\n\\r\\n # title elem found\\r\\n title_text = self.parser.getText(title_element[0])\\r\\n used_delimeter = False\\r\\n\\r\\n # split title with |\\r\\n if '|' in title_text:\\r\\n title_text = self.split_title(title_text, PIPE_SPLITTER)\\r\\n used_delimeter = True\\r\\n\\r\\n # split title with -\\r\\n if not used_delimeter and '-' in title_text:\\r\\n title_text = self.split_title(title_text, DASH_SPLITTER)\\r\\n used_delimeter = True\\r\\n\\r\\n # split title with »\\r\\n if not used_delimeter and u'»' in title_text:\\r\\n title_text = self.split_title(title_text, ARROWS_SPLITTER)\\r\\n used_delimeter = True\\r\\n\\r\\n # split title with :\\r\\n if not used_delimeter and ':' in title_text:\\r\\n title_text = self.split_title(title_text, COLON_SPLITTER)\\r\\n used_delimeter = True\\r\\n\\r\\n title = MOTLEY_REPLACEMENT.replaceAll(title_text)\\r\\n return title\",\n \"def extract_url(episode: dict) -> str:\\n url = episode['embed_info']\\n is_playable = episode['playable']\\n episode_num = episode['number']\\n #episode might not be playable or url might be empty\\n if not is_playable or not url:\\n raise Exception(f\\\"L'episodio {episode_num} non e' scaricabile.\\\")\\n\\n url = real_url(episode['embed_info'])\\n url = format_url(url, episode['video_type'])\\n if 'youtube.com' in url:\\n raise Exception(f\\\"L'episodio {episode_num} e' un video di YouTube che puoi guardare a questo url: \\\\n{url}\\\")\\n\\n return url\",\n \"def _parse_title(self, item):\\n title = item[\\\"Title\\\"]\\n return title\",\n \"def get_p_key(episode_info):\\n\\treturn f'{episode_info[\\\"show_stub\\\"]}S{episode_info[\\\"season\\\"]}E{episode_info[\\\"episode\\\"]}'\",\n \"def _defaultSyncTitle(self):\\n return f'{self.grandparentTitle} - {self.parentTitle} - ({self.seasonEpisode}) {self.title}'\",\n \"def title(self) -> str:\\n return pulumi.get(self, \\\"title\\\")\",\n \"def title(self) -> str:\\n return pulumi.get(self, \\\"title\\\")\",\n \"def title(self) -> str:\\n return pulumi.get(self, \\\"title\\\")\",\n \"def fetch_title(self, movie_id):\\n movie = tmdbsimple.Movies(movie_id)\\n request = movie.info()\\n\\n return movie.title\",\n \"def get_oneseries_desc(oneseries):\\n return oneseries\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74555385","0.7378745","0.6963783","0.68400466","0.66249967","0.6508349","0.64518964","0.6446037","0.6445582","0.6437754","0.6297738","0.62690187","0.6210943","0.6200764","0.61216825","0.6120273","0.611263","0.59974575","0.5988067","0.5951355","0.59445405","0.59397787","0.59121096","0.58959424","0.5892946","0.58775663","0.58768576","0.5873981","0.5853357","0.5831947","0.5814893","0.58104134","0.57905984","0.5784382","0.576614","0.57565624","0.5745293","0.5723939","0.57188964","0.57129765","0.5701463","0.5699715","0.5698786","0.56960243","0.5679867","0.566907","0.5655219","0.56496173","0.5610548","0.55991733","0.55938417","0.55916935","0.55844116","0.55774546","0.5573033","0.5571704","0.55674225","0.5550426","0.5549308","0.5548581","0.55476224","0.5541125","0.55392635","0.55382097","0.553391","0.553289","0.5532803","0.5531126","0.552863","0.5518769","0.5518338","0.5517007","0.55158466","0.551115","0.55063856","0.5493543","0.54835564","0.5480603","0.54769707","0.54769707","0.54769707","0.54748726","0.5448211","0.54478467","0.5441337","0.5440893","0.54372036","0.54200846","0.5417544","0.54124033","0.54098076","0.5400378","0.5398292","0.53969866","0.5392208","0.53852767","0.53852767","0.53852767","0.53824425","0.53804094"],"string":"[\n \"0.74555385\",\n \"0.7378745\",\n \"0.6963783\",\n \"0.68400466\",\n \"0.66249967\",\n \"0.6508349\",\n \"0.64518964\",\n \"0.6446037\",\n \"0.6445582\",\n \"0.6437754\",\n \"0.6297738\",\n \"0.62690187\",\n \"0.6210943\",\n \"0.6200764\",\n \"0.61216825\",\n \"0.6120273\",\n \"0.611263\",\n \"0.59974575\",\n \"0.5988067\",\n \"0.5951355\",\n \"0.59445405\",\n \"0.59397787\",\n \"0.59121096\",\n \"0.58959424\",\n \"0.5892946\",\n \"0.58775663\",\n \"0.58768576\",\n \"0.5873981\",\n \"0.5853357\",\n \"0.5831947\",\n \"0.5814893\",\n \"0.58104134\",\n \"0.57905984\",\n \"0.5784382\",\n \"0.576614\",\n \"0.57565624\",\n \"0.5745293\",\n \"0.5723939\",\n \"0.57188964\",\n \"0.57129765\",\n \"0.5701463\",\n \"0.5699715\",\n \"0.5698786\",\n \"0.56960243\",\n \"0.5679867\",\n \"0.566907\",\n \"0.5655219\",\n \"0.56496173\",\n \"0.5610548\",\n \"0.55991733\",\n \"0.55938417\",\n \"0.55916935\",\n \"0.55844116\",\n \"0.55774546\",\n \"0.5573033\",\n \"0.5571704\",\n \"0.55674225\",\n \"0.5550426\",\n \"0.5549308\",\n \"0.5548581\",\n \"0.55476224\",\n \"0.5541125\",\n \"0.55392635\",\n \"0.55382097\",\n \"0.553391\",\n \"0.553289\",\n \"0.5532803\",\n \"0.5531126\",\n \"0.552863\",\n \"0.5518769\",\n \"0.5518338\",\n \"0.5517007\",\n \"0.55158466\",\n \"0.551115\",\n \"0.55063856\",\n \"0.5493543\",\n \"0.54835564\",\n \"0.5480603\",\n \"0.54769707\",\n \"0.54769707\",\n \"0.54769707\",\n \"0.54748726\",\n \"0.5448211\",\n \"0.54478467\",\n \"0.5441337\",\n \"0.5440893\",\n \"0.54372036\",\n \"0.54200846\",\n \"0.5417544\",\n \"0.54124033\",\n \"0.54098076\",\n \"0.5400378\",\n \"0.5398292\",\n \"0.53969866\",\n \"0.5392208\",\n \"0.53852767\",\n \"0.53852767\",\n \"0.53852767\",\n \"0.53824425\",\n \"0.53804094\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7791267"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19492,"cells":{"query":{"kind":"string","value":"Predicts cluster basing on a data row and the model."},"document":{"kind":"string","value":"def som_predict(x, som) -> int:\n result = som.winner(np.array(x))\n return 10 * result[0] + result[1]"},"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 predict_cluster(self, inputs):\n if not self.trained:\n if self.verbose:\n print(\"KMeans Model Class - Predict Cluster Function: No trained model\")\n return -1\n\n\n return self.model.predict(inputs)","def predict(toPredict=None):\n\tif not toPredict:\n\t\ttoPredict = gc.generate_test_cases(1)[0]\n\ttoPredict = np.asarray(toPredict)\n\ttoPredict = toPredict.reshape(1, -1)\t\n\tclusterer = joblib.load(\"training_data.pkl\")\n\tprint(clusterer.predict(toPredict))","def predict(self, data):\n\t\treturn closestCluster(data, self.centers)","def predictClusters(self, df, k):\n self.models.fitModels(df)\n return self.models.predict()","def predict(data, model_predict):\n # Execute any steps you need to do before scoring\n\n # This method makes predictions against the raw, deserialized model\n #predictions = model_predict(data)\n\n data.to_csv(\"/opt/code/chemprop_folder/for_scoring.csv\", index=False)\n\n args = PredictArgs().parse_args([\n '--test_path', '/opt/chemprop_folder/for_scoring.csv',\n '--checkpoint_path', '/opt/code/model.pth',\n '--preds_path', '/opt/chemprop_folder/preds.csv'\n ])\n\n make_predictions(args)\n\n preds_df = pds.read_csv(\"/opt/chemprop_folder/preds.csv\")\n sh = str(preds_df.shape)\n print(sh)\n\n preds_df = preds_df.rename(columns = {\"p_np\": \"positive_class_label\"})\n preds_df = preds_df.drop(columns=['smiles'])\n preds_df[\"negative_class_label\"] = 1 - preds_df[\"positive_class_label\"]\n\n print(preds_df.head())\n\n # Execute any steps you need to do after scoring\n # Note: To properly send predictions back to DataRobot, the returned DataFrame should contain a\n # column for each output label for classification or a single value column for regression\n return preds_df","def predict_class(self, inputs):\n if not self.trained:\n if self.verbose:\n print(\"KMeans Model Class - Predict Class Function: No trained model\")\n return -1\n\n\n return self.cluster_classes[self.model.predict(inputs)]","def predict_cluster(self, point):\n # assuming point belongs to clusters that were computed by fit functions\n return self.cluster[tuple(point)]","def predict_cluster(point):\n # assuming point belongs to clusters that were computed by fit functions\n return cluster[tuple(point)]","def predict(self):\n for column in self.data_to_predict.columns:\n if column not in list(self.selected_features_):\n self.data_to_predict.drop(column, axis=1, inplace=True)\n for column in list(self.selected_features_):\n if column not in self.data_to_predict.columns:\n self.data_to_predict.loc[:, column] = 0\n self.predictions = self.model.predict(\n self.data_to_predict[self.selected_features_])","def predict(self, data):\r\n return self.sess.run([self.predict_op, self.Mu], feed_dict={self.X: data})","def predict(self, test_data):\n if self.centroids_.shape[0]==0:\n raise ValueError(\"No centroids present. Run KMeans.fit first.\")\n\n print test_data.shape\n part_of_cluster=np.zeros(test_data.shape[0])\n for i in range(test_data.shape[0]):\n dists=[]\n for c in range(self.centroids_.shape[0]):\n # compute distance between current train_data instance and each cluster\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\n \n # assign point to cluster with minimal distance\n part_of_cluster[i]=dists.index(min(dists))\n\n return part_of_cluster","def fit_predict(self):\n self.classifier = self.model\n self.classifier.fit(self.X_sample, self.y_sample)\n self.y_pred = self.classifier.predict(self.X_test)","def _predict(self, data):\n # make sure we're talking about arrays\n data = N.asarray(data)\n\n # checks only in debug mode\n if __debug__:\n if not data.ndim == 2:\n raise ValueError, \"Data array must be two-dimensional.\"\n\n if not data.shape[1] == self.__data.nfeatures:\n raise ValueError, \"Length of data samples (features) does \" \\\n \"not match the classifier.\"\n\n # compute the distance matrix between training and test data with\n # distances stored row-wise, ie. distances between test sample [0]\n # and all training samples will end up in row 0\n dists = self.__dfx(self.__data.samples, data).T\n\n # determine the k nearest neighbors per test sample\n knns = dists.argsort(axis=1)[:, :self.__k]\n\n # predicted class labels will go here\n predicted = []\n\n if self.__voting == 'majority':\n vfx = self.getMajorityVote\n elif self.__voting == 'weighted':\n vfx = self.getWeightedVote\n else:\n raise ValueError, \"kNN told to perform unknown voting '%s'.\" \\\n % self.__voting\n\n # perform voting\n results = [vfx(knn) for knn in knns]\n\n # extract predictions\n predicted = [r[0] for r in results]\n\n # store the predictions in the state. Relies on State._setitem to do\n # nothing if the relevant state member is not enabled\n self.predictions = predicted\n self.values = [r[1] for r in results]\n\n return predicted","def predict(self, dataset):\n # TODO: self.model(training=False)\n # logging.info('Predicting')\n # if self.verbosity > 1:\n # print('Predicting')\n dataset = rdata.data2dataset(dataset) # Convert to dataset\n assert dataset.get_dim_input() == self.n_inputs, \\\n 'Number of covariates does not match the model %d -> %d' % (dataset.get_dim_input(), self.n_inputs)\n n_data = dataset.get_n_data()\n\n pred = self._predict(dataset=dataset) # Predict\n\n if self.isprobabilistic():\n assert pred[0].shape == (n_data, self.n_outputs)\n assert pred[1].shape == (n_data, self.n_outputs)\n else:\n assert pred.shape == (n_data, self.n_outputs)\n return pred","def predict(self, model, x_test):\n pass","def fit_predict(self, df, n_clusters):\n _ = self.fit(df)\n _ = self.predict(n_clusters)\n\n return self.labels","def predict(self, data):\n return self.result.predict(data)","def predict(self, X):\n # TODO: decide whether enable predict function for clustering\n raise NotImplemented(\"predict function is currently disabled for\"\n \"clustering due to inconsistent behaviours.\")","def predict(self, data, version='default'):\n if self.transform_service:\n data = self.transform_service.predict(data, version)\n return self.model_service.predict(data, version)","def predict(self, model, context, data):\n pass","def predict ( self, X: np.ndarray ):\n \n return self.knn.predict ( X )\n # End predict()","def predict(self, data):\r\n\r\n distances = [np.linalg.norm(data-self.centroids[centroid]) for centroid in self.centroids]\r\n classification = distances.index(min(distances))\r\n return classification","def predict(self, test_data):\n return self.leader.predict(test_data)","def predict(self,data):\n results = []\n predict_instances = np.shape(data)[0]\n stored_instances = np.shape(self.data)[0]\n for predict_index in range(predict_instances):\n neighbors = [] # dist, label\n for stored_index in range(stored_instances):\n neighbors.append((self._distance(self.data[stored_index], data[predict_index]), self.data_labels[stored_index][0], data[predict_index]))\n neighbors = sorted(neighbors, key=lambda x: x[0])[:self.k]\n results.append(self._analyze_neighbors(neighbors))","def predict(data, model: str = None, **kwargs):\n\n model_instance = get_model(model)\n log.debug(\"Predict with \" + str(model_instance))\n return model_instance.predict(data, **kwargs)","def predict(self, model, arg):\n prediction = model.predict(arg)\n\n return prediction\n\n #def getAccuracyScore(self, n_splits):\n \"\"\"\n Gives an cross-validated accuracy score for the new model.\n\n Inputs:\n n_splits: number of sets to split the data into\n\n Returns:\n score: the accuracy score of the model.\n \"\"\"","def predict(self, data):\n return self.model.predict(data, batch_size=data.shape[1])","def cluster(n: int, model: str) -> NDArray[int]:\n return MiniBatchKMeans(n).fit_predict(XS[model])","def predict_single_fold(self, model: TorchBasedLinearEstimator, dataset: TabularDataset) -> np.ndarray:\n pred = model.predict(dataset.data)\n\n return pred","def oldPredict(self, data):\n\n predictions = []\n\n if len(self.observations) < self.k_neighbors:\n print(f\"Data length ({len(data)}) was too small.\")\n\n for row in data:\n neighbors_info = {}\n\n for row_index in range(len(self.observations)):\n distance = self.calcualteEuclideanDistance(self.observations[row_index], row)\n if len(neighbors_info) > self.k_neighbors - 1:\n largest_distance = max(neighbors_info.keys())\n if distance < largest_distance:\n neighbors_info[distance] = self.labels[row_index]\n del neighbors_info[largest_distance]\n else:\n neighbors_info[distance] = self.labels[row_index]\n\n unique_values = set(neighbors_info.values())\n if len(unique_values) == 1:\n value = unique_values.pop()\n predictions.append(value)\n else:\n best_value = 0\n best_value_weight = 0\n for label in unique_values:\n weight = 0\n for distance in neighbors_info.keys():\n if label == neighbors_info[distance]:\n if 'inverse_distance' == self.weight_type:\n weight += self.calulateWeightedVote(distance)\n elif 'no_weight' == self.weight_type:\n weight += 1\n else:\n print(\"Not a valid_weight_type.\")\n\n if weight > best_value_weight:\n best_value_weight = weight\n best_value = label\n\n predictions.append(best_value)\n # print(f\"Neighbors Info: {neighbors_info}\")\n\n return predictions","def model_predict(self, X):\n return self.cmodel.predict(X=X)","def predict(self):\n batch = get_predict_batch(1, num_rec_out=self.num_test_rec)\n self.g_model.test_batch(\n batch, self.global_step, num_rec_out=self.num_test_rec)","def predict ( self, X ):\n \n return self.knn.predict ( X )\n # End predict()","def predict(self, data):\n\n prediction = None\n if self.model is not None:\n prediction = self.model.predict(data)\n return prediction","def predict(self, data):\n\t\traise NotImplementedError","def predict(self, data: np.array) -> np.array:\n return self.model.predict(squeeze_keep_batch(data))","def predict(self, X_test):\n\n # Predict Label 0\n i = 0\n X = X_test\n\n # Retrieve trained classifier for label 0\n clf = self.trained[i]\n\n # Make prediction\n y = clf.predict(X)\n result = np.zeros((X_test.shape[0], self.label_dim))\n\n result[:, i] = y\n\n # Concatenate result to X\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\"csr\")\n\n # iterator = tqdm.trange(1, self.label_dim)\n iterator = range(1, self.label_dim)\n for i in iterator:\n # Predict Label i\n\n # Retrieve trained classifier for label i\n clf = self.trained[i]\n\n # Make prediction\n y = clf.predict(X)\n\n result[:, i] = y\n\n # Concatenate result to X\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\"csr\")\n\n return result","def _eval_clustering(self, gen_reviews, clusters, embedding_model, clustering):\n result = []\n preds = self.predict_gen(gen_reviews, embedding_model, clustering)\n\n acc = accuracy_score(np.array(clusters), np.array(preds))\n conf = confusion_matrix(np.array(clusters), np.array(preds))\n\n return acc, conf","def predict(self, X: TimeSeriesInstances, y=None) -> np.ndarray:\n self.check_is_fitted()\n X = self._check_clusterer_input(X)\n return self._predict(X)","def predict(self, user: torch.tensor, k: int):\n pass","def predict(self): \n return self.model.predict(self.test_x)","def predict(data, model, final_columns, category_features, averages):\n new_data = extend_dummy_columns(data, final_columns, category_features)\n # np array to use for our model.\n test_data = np.ones(len(final_columns))\n for i, col in enumerate(final_columns):\n if new_data[col] is None:\n test_data[i] = averages[col]\n else:\n test_data[i] = new_data[col]\n return model.predict_proba(test_data)[0][1]","def predict(self, data, version='default'):\n if isinstance(data, list):\n inputs = [self._indarray(x) for x in data]\n else:\n inputs = [self._indarray(data)]\n\n classification_response = self.skil.api.multipredict(\n deployment_name=self.deployment.name,\n model_name=self.model_name,\n version_name=version,\n body=skil_client.MultiPredictRequest(\n id=str(uuid.uuid1()),\n needs_pre_processing=False,\n inputs=inputs\n )\n )\n outputs = classification_response.outputs\n outputs = [np.asarray(o.data).reshape(o.shape) for o in outputs]\n if len(outputs) == 1:\n return outputs[0]\n return outputs","async def predict(iris: IrisPredictionInput) :\n return clf.predict(iris.data)","def predict(self):\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\n model = tf.keras.models.load_model(path)\n\n _, _, x_test, y_test = self._load_data()\n x_test = tf.keras.utils.normalize(x_test, axis=1)\n\n preds = model.predict(x_test)\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)","def evaluate_cluster(cluster_model, labels):\n \n predictions = cluster_model.labels_ # Predict labels\n\n ARI = adjusted_rand_score(labels, predictions)\n NMI = normalized_mutual_info_score(labels, predictions)\n \n return ARI, NMI","def predict(self, X):\n\n stuff = self._vectorizer.transform(X)\n result = self._classifier.predict(stuff)\n return result\n pass","def predict_with_model(request):\n # [START predict_with_model]\n model = get_model(request)\n\n data_response = {}\n\n q = read_request(request)\n data_response[\"q\"] = escape(q)\n print(\"Predict with a model for: {}\".format(q))\n\n print(\"Setup TablesClient\")\n try:\n client = automl.TablesClient(\n project=project_id,\n region=region,\n client_options=client_options\n )\n except Exception as e:\n print(e.message)\n\n print(\"Prediction start\")\n try:\n response = client.predict(\n model=model,\n inputs=[q],\n feature_importance=True\n )\n except Exception as e:\n print(e.message)\n\n print(\"Prediction results\")\n for result in response.payload:\n data_response[escape(result.tables.value.string_value)] = round(result.tables.score, 3)\n print(\"Predicted class name: {}, score: {}\".format(\n result.tables.value.string_value,\n result.tables.score)\n )\n\n print(\"Prediction finished\")\n r = write_response(data_response)\n # [END predict_with_model]\n return r","def predict(self):\r\n\r\n # reshape test_array since it is a single row of data\r\n user_array = np.asanyarray(self.test_array).reshape(1, -1)\r\n # one hot encode user_array\r\n self.enc.fit(user_array)\r\n user_array = self.enc.transform(user_array)\r\n # create, train and predict the model with the dataset\r\n model = (\"Ridge\", linear_model.Ridge(alpha=0.01, random_state=4))\r\n model[1].fit(self.X_train, self.y_train)\r\n y_pred = model[1].predict(self.X_test)\r\n # predict with user provided chords\r\n y_usr = model[1].predict(user_array)\r\n if y_usr[0] < 0:\r\n y_usr[0] = 0\r\n acc = metrics.r2_score(self.y_test, y_pred)\r\n output = \"I am {}% sure that you like this progression.\".format('%.2f' % (100 * y_usr[0]))\r\n model_info = \"Predicted using a {} model with {} accuracy from {} data samples.\".format(model[0], '%.3f' % acc,\r\n self.data_count())\r\n return output, model_info","def predict(self,X):\n return self.classifier.predict(X)","def predict(self,X):\n return self.classifier.predict(X)","def predict(self,X):\n return self.classifier.predict(X)","def predict(self,X):\n return self.classifier.predict(X)","def predict(self):\n raise NotImplementedError","def predict (self, model, context, data):\n # 1. Feature engineering\n features_df = FeatureEngineering().do_for_predict(data, joblib.load(model.files['description-vectorizer']), joblib.load(model.files['user-encoder']), context)\n\n # 2. Load model & other required files\n trained_model = joblib.load(model.files['model'])\n categories = pd.read_csv(model.files['categories'], index_col=0)\n\n # 3. Predict\n pred = trained_model.predict(features_df)\n\n # 4. Return the prediction\n predicted_category = pd.DataFrame(pred, columns=categories['category']).idxmax(axis=1)[0]\n\n logger.compute(context.correlation_id, '[ {ctx} ] - [ PREDICTION ] - Model {model}.v{version} - Predicted category for description [{desc}]: {c}'.format(ctx=context.process, model=model.info['name'], version=model.info['version'], desc=data['description'], c=predicted_category), 'info')\n \n return ModelPrediction(prediction={\"category\": predicted_category})","def predict(self, X):\n ...","def predict(self, X):\n ...","def predict(self, X):\n ...","def predict(self):\n train_array = np.array(self.labels != 0, dtype=float)\n if not self.ising:\n labels_logit = self.ising_weights['vertices']\n else:\n neigh_num = self.adj.dot(train_array)\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\n neigh_weights = self.ising_weights['edges'] * self.labels\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\n + self.ising_weights['vertices'])\n self.prediction = np.where(labels_logit > 0, 1, -1)\n return self","def predict(self, data):\n data['predicted'] = self.sentiment_classifier.predict_estimator(data)\n return data","def predict(model):\n # load test dataset\n test = dict(json.load(open('util_files/test.json')))\n ids = test['ids']\n data = test['data']\n\n df = pd.read_csv('data/document_departments.csv')\n labels = dict(df.values.tolist())\n\n id2cls = dict(json.load(open('util_files/id2cls.json')))\n \n ytrue = []\n ypredicted = []\n \n for i in range(len(data)):\n \n prediction = np.argmax(model.predict_on_batch(np.expand_dims(data[i], axis=0)))\n \n ypredicted.append(id2cls[str(prediction)])\n \n cls = labels[int(ids[i])]\n ytrue.append(cls)\n \n print \"classification report\"\n print classification_report(y_true=ytrue,\n y_pred=ypredicted)\n \n print \"*********************\"\n print \"Accuracy on test set\"\n print accuracy_score(y_true=ytrue,\n y_pred=ypredicted)\n print \"*********************\"","def predict(self, X: _DaskMatrixLike, **kwargs: Any) -> dask_Array:\n return _predict(\n model=self.to_local(),\n data=X,\n dtype=self.classes_.dtype,\n **kwargs\n )","def predict(self, instances):\r\n raise NotImplementedError","def classify(self, data):\n \"*** YOUR CODE HERE ***\"\n return self.sklearn_classifier.predict(data)","def predict(data, samples, classifier='SVM',\r\n classification='combined', selectFeatures=('CUK', 10)):\r\n if (classification == \"trained\"):\r\n classifyTrained = True\r\n classifySurface = False\r\n elif (classification == 'surface'):\r\n classifyTrained = False\r\n classifySurface = True\r\n else:\r\n classifyTrained = True\r\n classifySurface = True\r\n if (classifier == \"SVM\"):\r\n clf = cl.classifyDataSVM(data, classifyTrained,\r\n classifySurface, selectFeatures,scaling=False)\r\n elif (classifier == \"DT\"):\r\n clf = cl.classifyDataDT(data, classifyTrained,\r\n classifySurface, selectFeatures,scaling=False)\r\n elif (classifier == \"KNN\"):\r\n clf = cl.classifyDataKNN(data, classifyTrained,\r\n classifySurface, selectFeatures,scaling=False)\r\n elif (classifier == \"LogReg\"):\r\n clf = cl.classifyDataLR(data, classifyTrained,\r\n classifySurface, selectFeatures,scaling=False)\r\n else:\r\n print (str(classifier) + \" is not a valid option\")\r\n \r\n [samples, _,_,_] = clf.extractData(samples,scaling=False)\r\n \r\n predictions = [clf.predict(s) for s in samples]\r\n return predictions","def predict(cls, input):\n clf = cls.get_model()\n print('input=')\n print(input)\n return clf.predict(input)","def predict(self, estimator, blocks=None, cluster_by_stability=False, custom_order=False):\n\n return nmf_predict(estimator, blocks=blocks, leverage=self.leverage, cluster_by_stability=cluster_by_stability,\n custom_order=custom_order, verbose=self.verbose)","def predict(self, estimator, blocks=None, cluster_by_stability=False, custom_order=False):\n\n return nmf_predict(estimator, blocks=blocks, leverage=self.leverage, cluster_by_stability=cluster_by_stability,\n custom_order=custom_order, verbose=self.verbose)","def _predict(self, X):\n # self._X should be the stored _X\n dist_mat = self._distance(X, self._X)\n\n y_pred = self.knn_estimator_.predict(dist_mat)\n\n return y_pred","def predict(self, X):\n X = X['user_id']\n return self.clf.predict(X)","def predict(prediction_request):\n\n feature_type = prediction_request['feature_type']\n\n if feature_type not in [MFCC, C_CENS, C_CQT, C_STFT, MEL]:\n raise Exception('Invalid Feature type for prediction: {}'.format(feature_type))\n\n model = model_from_feature[feature_type]\n\n prediction = np.argmax(model.predict([np.reshape(prediction_request['content'], (1, *prediction_request['content'].shape, 1))]), axis=1)[0]\n\n predicted_class = \"COPD\" if prediction == 0 else \"non-COPD\"\n\n print(\"Prediction for type {} = {}\".format(feature_type, predicted_class))\n\n socket.send_pyobj({\n 'model': feature_type,\n 'class': predicted_class\n })","def clf1_predict(self):\n self._pred_clf_1 = self._clf1.predict(self._vectorized_input)[0]","def make_predictions(df):\n t_labels = get_labels(\"labels_pca\")\n # clean data\n df = clean_data(df)\n # engineer data\n df = engineer_features(df)\n # predict\n with open(\"model.pkl\",\"r\") as mdl:\n model = pickle.load(mdl)\n mdl.close()\n predictions = model.predict(df[t_labels])\n return predictions","def predict(self, test_data):\r\n return self.gs.predict(test_data)","def _predict(self, classify: np.array, n_preds=1):\r\n tmp = classify.argsort()[:, :n_preds] # Return the index of the best label classification\r\n preds = copy(tmp) # allow to copy tmp\r\n for index, target in enumerate(self.targets):\r\n preds = np.where(tmp == index, target, preds) # Return the target label corresponding to the index\r\n self.preds = preds","def predict(self, data: List):\r\n return self._lda.predict(data)","def classify(self, data):\n \"*** YOUR CODE HERE ***\"\n return self.sklearn_svm.predict(data)","def predict(cls, input):\n clf = cls.get_model()\n return clf.predict(input)","def predict(dataset):\n import capsnet\n\n # Load (standardized) input data and associated file names\n test_x, _, names = _load_data(dataset)\n\n # Predict class probabilities for each model (epoch)\n at_preds, sed_preds = [], []\n\n for epoch in _determine_epochs(cfg.prediction_epochs):\n model = _load_model(epoch)\n at_pred, sed_pred = utils.timeit(\n lambda: capsnet.gccaps_predict(test_x, model),\n '[Epoch %d] Predicted class probabilities' % epoch)\n\n at_preds.append(at_pred)\n sed_preds.append(sed_pred)\n\n # Average predictions to give an overall output\n total_at_pred = np.mean(at_preds, axis=0)\n total_sed_pred = np.mean(sed_preds, axis=0)\n\n # Ensure output directory exists and set file path format\n os.makedirs(os.path.dirname(cfg.predictions_path), exist_ok=True)\n predictions_path = cfg.predictions_path.format('%s', dataset.name)\n\n # Save free parameters to disk\n utils.log_parameters({'prediction_epochs': cfg.prediction_epochs},\n os.path.join(os.path.dirname(cfg.predictions_path),\n 'parameters.json'))\n\n # Write predictions to disk\n utils.write_predictions(names, total_at_pred, predictions_path % 'at')\n utils.write_predictions(names, total_sed_pred, predictions_path % 'sed')","def supervised_predict(self, x):\n z_ik = self.get_posterior(x)\n em_label = np.argmax(z_ik, axis=1)\n y_hat = [self.cluster_label_map[idx] for idx in em_label]\n return np.array(y_hat)","def predict(self, data_in):\n pass","def predict(self, to_predict):\n\t\treturn self.model.predict(to_predict)","def predict(self, model, batch):\n device = list(model.parameters())[0].device\n batch = batch.to(device)\n inputs = batch.inputs\n # Extract features with the model\n h = model(*inputs)\n # predictions\n return self.predict_on_features(h)","def predict(self, X):\n return self.classifier.predict(X)","def predict(self, x):\n new_x = np.array(self.transform(x.reshape(1, -1)).flatten())\n return self.clf.predict(new_x.T)","def predict(self, load_script=False, variant=\"predict\"):\n \n # Interpret the request data based on the expected row and column structure\n row_template = ['strData', 'strData']\n col_headers = ['model_name', 'n_features']\n feature_col_num = 1\n \n # An additional key field column is expected if the call is made through the load script\n if load_script:\n row_template = ['strData', 'strData', 'strData']\n col_headers = ['model_name', 'key', 'n_features']\n feature_col_num = 2\n \n # Create a Pandas Data Frame for the request data\n self.request_df = utils.request_df(self.request, row_template, col_headers)\n \n # Initialize the persistent model\n self.model = PersistentModel()\n \n # Get the model name from the request dataframe\n self.model.name = self.request_df.loc[0, 'model_name']\n \n # Get the model from cache or disk\n self._get_model()\n \n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(3)\n \n if load_script:\n # Set the key column as the index\n self.request_df.set_index(\"key\", drop=False, inplace=True)\n \n try:\n # Split the features provided as a string into individual columns\n self.X = pd.DataFrame([x[feature_col_num].split(\"|\") for x in self.request_df.values.tolist()],\\\n columns=self.model.features_df.loc[:,\"name\"].tolist(),\\\n index=self.request_df.index)\n except AssertionError as ae:\n err = \"The number of input columns do not match feature definitions. Ensure you are using the | delimiter and that the target is not included in your input to the prediction function.\"\n raise AssertionError(err) from ae\n \n # Convert the data types based on feature definitions \n self.X = utils.convert_types(self.X, self.model.features_df, sort=False)\n\n if variant in ('predict_proba', 'predict_log_proba'):\n # If probabilities need to be returned\n if variant == 'predict_proba':\n # Get the predicted probability for each sample \n self.y = self.model.pipe.predict_proba(self.X)\n elif variant == 'predict_log_proba':\n # Get the log probability for each sample\n self.y = self.model.pipe.predict_log_proba(self.X)\n \n # Prepare a list of probability by class for each sample\n probabilities = []\n\n for a in self.y:\n s = \"\"\n i = 0\n for b in a:\n s = s + \", {0}: {1:.3f}\".format(self.model.pipe.named_steps['estimator'].classes_[i], b)\n i = i + 1\n probabilities.append(s[2:])\n \n self.y = probabilities\n \n else:\n # Predict y for X using the previously fit pipeline\n self.y = self.model.pipe.predict(self.X)\n\n # Inverse transformations on the targets if required\n if self.model.scale_target or self.model.make_stationary:\n # Apply the transformer to the test targets\n self.y = self.model.target_transformer.inverse_transform(self.y) \n\n # Prepare the response\n self.response = pd.DataFrame(self.y, columns=[\"result\"], index=self.X.index)\n \n if load_script:\n # Add the key field column to the response\n self.response = self.request_df.join(self.response).drop(['n_features'], axis=1)\n \n # If the function was called through the load script we return a Data Frame\n self._send_table_description(\"predict\")\n \n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(4)\n \n return self.response\n \n # If the function was called through a chart expression we return a Series\n else:\n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(4)\n \n return self.response.loc[:,'result']","def predict(\r\n model: sklearn_Pipeline, \r\n test_x: pd.DataFrame\r\n) -> pd.DataFrame:\r\n # Return predictions\r\n return model.predict(test_x)","def predictClass(training_data, test_row, k):\n\n neighbors = getNeighbors(training_data, test_row, k)\n output_vals = [row[-1] for row in neighbors]\n \n counts = dict()\n\n for i in output_vals:\n counts[i] = counts.get(i, 0) + 1\n\n v = [value for value in counts.values()]\n\n #Pick a class on random if ties occur\n prediction = choice([key for key in counts if counts[key] == max(v)])\n\n return prediction","def predict(self, X):\n pass","def predict(self, X):\n pass","def predict(self, X):\n pass","def predict_only(self):","def predict(self, X, k):\n # Sanity check\n if self.__trained == False:\n return 'Model not trained yet'\n \n # Reshape data to 2D array if possible\n if len(X.shape) == 1:\n X = X[None, :]\n \n # Compute the distances between all given points and all training points\n distances = np.sum((X[:, None, :] - self.__X[None, :, :]) ** 2, axis = -1)\n \n # Find the K nearest neighbors\n k_nearest_neighbors = np.argsort(distances, axis=-1)[:,:k]\n\n # Run over all columns and find the most common neighbor in each, then return his label\n n_observations = X.shape[0]\n idx = [np.argmax(np.bincount(k_nearest_neighbors[i])) for i in range(n_observations)]\n return self.__y[idx]","def pre_train(self, dataset):\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\n pe = principleextractor.PrincipleExtractor()\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\n # not in the .json; or with argument given TODO\n self.skm.add_syllogistic_data(data=pd_dataset)\n\n self.skm.generate_clusters(cutoff=self.cutoff)\n\n results = pe.extract_principles_from_k_clusters(self.skm.final_clusters_syll_list)\n\n participant_correspondence = principleextractor.compute_participant_correspondence(self.skm.subj_data_dict,\n self.skm.final_clusters_num)\n principleextractor.write_results(results[0], results[1], self.skm.final_clusters_syll_list,\n participant_correspondence)\n\n self.k_clusters = self.skm.final_clusters_syll_list\n\n gen_skm = syllogistickmeans.SyllogisticKMeans(1)\n gen_skm.add_syllogistic_data(data=pd_dataset)\n\n gen_skm.generate_clusters(cutoff=self.cutoff)\n\n self.current_k_cluster = gen_skm.final_clusters_syll_list[0]","def predict_data(data: pd.DataFrame, model: list):\n prediction = []\n for i, row in data.iterrows():\n prediction.append(predict_dataset(row, model))\n return prediction","def predict(self, X, k=1):\n dists = self.compute_distances(X)\n return self.predict_labels(dists, k=k)","def clf2_predict(self):\n self._pred_clf_2 = self._clf2.predict(self._vectorized_input)[0]","def predict(self, x: DNDarray) -> DNDarray:\n # input sanitation\n if not isinstance(x, DNDarray):\n raise ValueError(f\"input needs to be a ht.DNDarray, but was {type(x)}\")\n if x.split is not None and x.split != 0:\n raise NotImplementedError(\"Not implemented for other splitting-axes\")\n\n _, eigenvectors = self._spectral_embedding(x)\n\n components = eigenvectors[:, : self.n_clusters].copy()\n\n return self._cluster.predict(components)","def predict():\n\n\n json_payload = request.json\n #LOG.info(f\"JSON payload: %s\" %json_payload)\n inference_payload = pd.DataFrame(json_payload)\n #LOG.info(\"inference payload DataFrame: %s\" %inference_payload)\n scaled_payload = scale(inference_payload)\n prediction = list(clf.predict(scaled_payload))\n return jsonify({'prediction': prediction})","def predict(model, X_testing):\n predictions = model.predict(X_testing)\n\n return predictions","def predict(self, X):"],"string":"[\n \"def predict_cluster(self, inputs):\\n if not self.trained:\\n if self.verbose:\\n print(\\\"KMeans Model Class - Predict Cluster Function: No trained model\\\")\\n return -1\\n\\n\\n return self.model.predict(inputs)\",\n \"def predict(toPredict=None):\\n\\tif not toPredict:\\n\\t\\ttoPredict = gc.generate_test_cases(1)[0]\\n\\ttoPredict = np.asarray(toPredict)\\n\\ttoPredict = toPredict.reshape(1, -1)\\t\\n\\tclusterer = joblib.load(\\\"training_data.pkl\\\")\\n\\tprint(clusterer.predict(toPredict))\",\n \"def predict(self, data):\\n\\t\\treturn closestCluster(data, self.centers)\",\n \"def predictClusters(self, df, k):\\n self.models.fitModels(df)\\n return self.models.predict()\",\n \"def predict(data, model_predict):\\n # Execute any steps you need to do before scoring\\n\\n # This method makes predictions against the raw, deserialized model\\n #predictions = model_predict(data)\\n\\n data.to_csv(\\\"/opt/code/chemprop_folder/for_scoring.csv\\\", index=False)\\n\\n args = PredictArgs().parse_args([\\n '--test_path', '/opt/chemprop_folder/for_scoring.csv',\\n '--checkpoint_path', '/opt/code/model.pth',\\n '--preds_path', '/opt/chemprop_folder/preds.csv'\\n ])\\n\\n make_predictions(args)\\n\\n preds_df = pds.read_csv(\\\"/opt/chemprop_folder/preds.csv\\\")\\n sh = str(preds_df.shape)\\n print(sh)\\n\\n preds_df = preds_df.rename(columns = {\\\"p_np\\\": \\\"positive_class_label\\\"})\\n preds_df = preds_df.drop(columns=['smiles'])\\n preds_df[\\\"negative_class_label\\\"] = 1 - preds_df[\\\"positive_class_label\\\"]\\n\\n print(preds_df.head())\\n\\n # Execute any steps you need to do after scoring\\n # Note: To properly send predictions back to DataRobot, the returned DataFrame should contain a\\n # column for each output label for classification or a single value column for regression\\n return preds_df\",\n \"def predict_class(self, inputs):\\n if not self.trained:\\n if self.verbose:\\n print(\\\"KMeans Model Class - Predict Class Function: No trained model\\\")\\n return -1\\n\\n\\n return self.cluster_classes[self.model.predict(inputs)]\",\n \"def predict_cluster(self, point):\\n # assuming point belongs to clusters that were computed by fit functions\\n return self.cluster[tuple(point)]\",\n \"def predict_cluster(point):\\n # assuming point belongs to clusters that were computed by fit functions\\n return cluster[tuple(point)]\",\n \"def predict(self):\\n for column in self.data_to_predict.columns:\\n if column not in list(self.selected_features_):\\n self.data_to_predict.drop(column, axis=1, inplace=True)\\n for column in list(self.selected_features_):\\n if column not in self.data_to_predict.columns:\\n self.data_to_predict.loc[:, column] = 0\\n self.predictions = self.model.predict(\\n self.data_to_predict[self.selected_features_])\",\n \"def predict(self, data):\\r\\n return self.sess.run([self.predict_op, self.Mu], feed_dict={self.X: data})\",\n \"def predict(self, test_data):\\n if self.centroids_.shape[0]==0:\\n raise ValueError(\\\"No centroids present. Run KMeans.fit first.\\\")\\n\\n print test_data.shape\\n part_of_cluster=np.zeros(test_data.shape[0])\\n for i in range(test_data.shape[0]):\\n dists=[]\\n for c in range(self.centroids_.shape[0]):\\n # compute distance between current train_data instance and each cluster\\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\\n \\n # assign point to cluster with minimal distance\\n part_of_cluster[i]=dists.index(min(dists))\\n\\n return part_of_cluster\",\n \"def fit_predict(self):\\n self.classifier = self.model\\n self.classifier.fit(self.X_sample, self.y_sample)\\n self.y_pred = self.classifier.predict(self.X_test)\",\n \"def _predict(self, data):\\n # make sure we're talking about arrays\\n data = N.asarray(data)\\n\\n # checks only in debug mode\\n if __debug__:\\n if not data.ndim == 2:\\n raise ValueError, \\\"Data array must be two-dimensional.\\\"\\n\\n if not data.shape[1] == self.__data.nfeatures:\\n raise ValueError, \\\"Length of data samples (features) does \\\" \\\\\\n \\\"not match the classifier.\\\"\\n\\n # compute the distance matrix between training and test data with\\n # distances stored row-wise, ie. distances between test sample [0]\\n # and all training samples will end up in row 0\\n dists = self.__dfx(self.__data.samples, data).T\\n\\n # determine the k nearest neighbors per test sample\\n knns = dists.argsort(axis=1)[:, :self.__k]\\n\\n # predicted class labels will go here\\n predicted = []\\n\\n if self.__voting == 'majority':\\n vfx = self.getMajorityVote\\n elif self.__voting == 'weighted':\\n vfx = self.getWeightedVote\\n else:\\n raise ValueError, \\\"kNN told to perform unknown voting '%s'.\\\" \\\\\\n % self.__voting\\n\\n # perform voting\\n results = [vfx(knn) for knn in knns]\\n\\n # extract predictions\\n predicted = [r[0] for r in results]\\n\\n # store the predictions in the state. Relies on State._setitem to do\\n # nothing if the relevant state member is not enabled\\n self.predictions = predicted\\n self.values = [r[1] for r in results]\\n\\n return predicted\",\n \"def predict(self, dataset):\\n # TODO: self.model(training=False)\\n # logging.info('Predicting')\\n # if self.verbosity > 1:\\n # print('Predicting')\\n dataset = rdata.data2dataset(dataset) # Convert to dataset\\n assert dataset.get_dim_input() == self.n_inputs, \\\\\\n 'Number of covariates does not match the model %d -> %d' % (dataset.get_dim_input(), self.n_inputs)\\n n_data = dataset.get_n_data()\\n\\n pred = self._predict(dataset=dataset) # Predict\\n\\n if self.isprobabilistic():\\n assert pred[0].shape == (n_data, self.n_outputs)\\n assert pred[1].shape == (n_data, self.n_outputs)\\n else:\\n assert pred.shape == (n_data, self.n_outputs)\\n return pred\",\n \"def predict(self, model, x_test):\\n pass\",\n \"def fit_predict(self, df, n_clusters):\\n _ = self.fit(df)\\n _ = self.predict(n_clusters)\\n\\n return self.labels\",\n \"def predict(self, data):\\n return self.result.predict(data)\",\n \"def predict(self, X):\\n # TODO: decide whether enable predict function for clustering\\n raise NotImplemented(\\\"predict function is currently disabled for\\\"\\n \\\"clustering due to inconsistent behaviours.\\\")\",\n \"def predict(self, data, version='default'):\\n if self.transform_service:\\n data = self.transform_service.predict(data, version)\\n return self.model_service.predict(data, version)\",\n \"def predict(self, model, context, data):\\n pass\",\n \"def predict ( self, X: np.ndarray ):\\n \\n return self.knn.predict ( X )\\n # End predict()\",\n \"def predict(self, data):\\r\\n\\r\\n distances = [np.linalg.norm(data-self.centroids[centroid]) for centroid in self.centroids]\\r\\n classification = distances.index(min(distances))\\r\\n return classification\",\n \"def predict(self, test_data):\\n return self.leader.predict(test_data)\",\n \"def predict(self,data):\\n results = []\\n predict_instances = np.shape(data)[0]\\n stored_instances = np.shape(self.data)[0]\\n for predict_index in range(predict_instances):\\n neighbors = [] # dist, label\\n for stored_index in range(stored_instances):\\n neighbors.append((self._distance(self.data[stored_index], data[predict_index]), self.data_labels[stored_index][0], data[predict_index]))\\n neighbors = sorted(neighbors, key=lambda x: x[0])[:self.k]\\n results.append(self._analyze_neighbors(neighbors))\",\n \"def predict(data, model: str = None, **kwargs):\\n\\n model_instance = get_model(model)\\n log.debug(\\\"Predict with \\\" + str(model_instance))\\n return model_instance.predict(data, **kwargs)\",\n \"def predict(self, model, arg):\\n prediction = model.predict(arg)\\n\\n return prediction\\n\\n #def getAccuracyScore(self, n_splits):\\n \\\"\\\"\\\"\\n Gives an cross-validated accuracy score for the new model.\\n\\n Inputs:\\n n_splits: number of sets to split the data into\\n\\n Returns:\\n score: the accuracy score of the model.\\n \\\"\\\"\\\"\",\n \"def predict(self, data):\\n return self.model.predict(data, batch_size=data.shape[1])\",\n \"def cluster(n: int, model: str) -> NDArray[int]:\\n return MiniBatchKMeans(n).fit_predict(XS[model])\",\n \"def predict_single_fold(self, model: TorchBasedLinearEstimator, dataset: TabularDataset) -> np.ndarray:\\n pred = model.predict(dataset.data)\\n\\n return pred\",\n \"def oldPredict(self, data):\\n\\n predictions = []\\n\\n if len(self.observations) < self.k_neighbors:\\n print(f\\\"Data length ({len(data)}) was too small.\\\")\\n\\n for row in data:\\n neighbors_info = {}\\n\\n for row_index in range(len(self.observations)):\\n distance = self.calcualteEuclideanDistance(self.observations[row_index], row)\\n if len(neighbors_info) > self.k_neighbors - 1:\\n largest_distance = max(neighbors_info.keys())\\n if distance < largest_distance:\\n neighbors_info[distance] = self.labels[row_index]\\n del neighbors_info[largest_distance]\\n else:\\n neighbors_info[distance] = self.labels[row_index]\\n\\n unique_values = set(neighbors_info.values())\\n if len(unique_values) == 1:\\n value = unique_values.pop()\\n predictions.append(value)\\n else:\\n best_value = 0\\n best_value_weight = 0\\n for label in unique_values:\\n weight = 0\\n for distance in neighbors_info.keys():\\n if label == neighbors_info[distance]:\\n if 'inverse_distance' == self.weight_type:\\n weight += self.calulateWeightedVote(distance)\\n elif 'no_weight' == self.weight_type:\\n weight += 1\\n else:\\n print(\\\"Not a valid_weight_type.\\\")\\n\\n if weight > best_value_weight:\\n best_value_weight = weight\\n best_value = label\\n\\n predictions.append(best_value)\\n # print(f\\\"Neighbors Info: {neighbors_info}\\\")\\n\\n return predictions\",\n \"def model_predict(self, X):\\n return self.cmodel.predict(X=X)\",\n \"def predict(self):\\n batch = get_predict_batch(1, num_rec_out=self.num_test_rec)\\n self.g_model.test_batch(\\n batch, self.global_step, num_rec_out=self.num_test_rec)\",\n \"def predict ( self, X ):\\n \\n return self.knn.predict ( X )\\n # End predict()\",\n \"def predict(self, data):\\n\\n prediction = None\\n if self.model is not None:\\n prediction = self.model.predict(data)\\n return prediction\",\n \"def predict(self, data):\\n\\t\\traise NotImplementedError\",\n \"def predict(self, data: np.array) -> np.array:\\n return self.model.predict(squeeze_keep_batch(data))\",\n \"def predict(self, X_test):\\n\\n # Predict Label 0\\n i = 0\\n X = X_test\\n\\n # Retrieve trained classifier for label 0\\n clf = self.trained[i]\\n\\n # Make prediction\\n y = clf.predict(X)\\n result = np.zeros((X_test.shape[0], self.label_dim))\\n\\n result[:, i] = y\\n\\n # Concatenate result to X\\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\\\"csr\\\")\\n\\n # iterator = tqdm.trange(1, self.label_dim)\\n iterator = range(1, self.label_dim)\\n for i in iterator:\\n # Predict Label i\\n\\n # Retrieve trained classifier for label i\\n clf = self.trained[i]\\n\\n # Make prediction\\n y = clf.predict(X)\\n\\n result[:, i] = y\\n\\n # Concatenate result to X\\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\\\"csr\\\")\\n\\n return result\",\n \"def _eval_clustering(self, gen_reviews, clusters, embedding_model, clustering):\\n result = []\\n preds = self.predict_gen(gen_reviews, embedding_model, clustering)\\n\\n acc = accuracy_score(np.array(clusters), np.array(preds))\\n conf = confusion_matrix(np.array(clusters), np.array(preds))\\n\\n return acc, conf\",\n \"def predict(self, X: TimeSeriesInstances, y=None) -> np.ndarray:\\n self.check_is_fitted()\\n X = self._check_clusterer_input(X)\\n return self._predict(X)\",\n \"def predict(self, user: torch.tensor, k: int):\\n pass\",\n \"def predict(self): \\n return self.model.predict(self.test_x)\",\n \"def predict(data, model, final_columns, category_features, averages):\\n new_data = extend_dummy_columns(data, final_columns, category_features)\\n # np array to use for our model.\\n test_data = np.ones(len(final_columns))\\n for i, col in enumerate(final_columns):\\n if new_data[col] is None:\\n test_data[i] = averages[col]\\n else:\\n test_data[i] = new_data[col]\\n return model.predict_proba(test_data)[0][1]\",\n \"def predict(self, data, version='default'):\\n if isinstance(data, list):\\n inputs = [self._indarray(x) for x in data]\\n else:\\n inputs = [self._indarray(data)]\\n\\n classification_response = self.skil.api.multipredict(\\n deployment_name=self.deployment.name,\\n model_name=self.model_name,\\n version_name=version,\\n body=skil_client.MultiPredictRequest(\\n id=str(uuid.uuid1()),\\n needs_pre_processing=False,\\n inputs=inputs\\n )\\n )\\n outputs = classification_response.outputs\\n outputs = [np.asarray(o.data).reshape(o.shape) for o in outputs]\\n if len(outputs) == 1:\\n return outputs[0]\\n return outputs\",\n \"async def predict(iris: IrisPredictionInput) :\\n return clf.predict(iris.data)\",\n \"def predict(self):\\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\\n model = tf.keras.models.load_model(path)\\n\\n _, _, x_test, y_test = self._load_data()\\n x_test = tf.keras.utils.normalize(x_test, axis=1)\\n\\n preds = model.predict(x_test)\\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)\",\n \"def evaluate_cluster(cluster_model, labels):\\n \\n predictions = cluster_model.labels_ # Predict labels\\n\\n ARI = adjusted_rand_score(labels, predictions)\\n NMI = normalized_mutual_info_score(labels, predictions)\\n \\n return ARI, NMI\",\n \"def predict(self, X):\\n\\n stuff = self._vectorizer.transform(X)\\n result = self._classifier.predict(stuff)\\n return result\\n pass\",\n \"def predict_with_model(request):\\n # [START predict_with_model]\\n model = get_model(request)\\n\\n data_response = {}\\n\\n q = read_request(request)\\n data_response[\\\"q\\\"] = escape(q)\\n print(\\\"Predict with a model for: {}\\\".format(q))\\n\\n print(\\\"Setup TablesClient\\\")\\n try:\\n client = automl.TablesClient(\\n project=project_id,\\n region=region,\\n client_options=client_options\\n )\\n except Exception as e:\\n print(e.message)\\n\\n print(\\\"Prediction start\\\")\\n try:\\n response = client.predict(\\n model=model,\\n inputs=[q],\\n feature_importance=True\\n )\\n except Exception as e:\\n print(e.message)\\n\\n print(\\\"Prediction results\\\")\\n for result in response.payload:\\n data_response[escape(result.tables.value.string_value)] = round(result.tables.score, 3)\\n print(\\\"Predicted class name: {}, score: {}\\\".format(\\n result.tables.value.string_value,\\n result.tables.score)\\n )\\n\\n print(\\\"Prediction finished\\\")\\n r = write_response(data_response)\\n # [END predict_with_model]\\n return r\",\n \"def predict(self):\\r\\n\\r\\n # reshape test_array since it is a single row of data\\r\\n user_array = np.asanyarray(self.test_array).reshape(1, -1)\\r\\n # one hot encode user_array\\r\\n self.enc.fit(user_array)\\r\\n user_array = self.enc.transform(user_array)\\r\\n # create, train and predict the model with the dataset\\r\\n model = (\\\"Ridge\\\", linear_model.Ridge(alpha=0.01, random_state=4))\\r\\n model[1].fit(self.X_train, self.y_train)\\r\\n y_pred = model[1].predict(self.X_test)\\r\\n # predict with user provided chords\\r\\n y_usr = model[1].predict(user_array)\\r\\n if y_usr[0] < 0:\\r\\n y_usr[0] = 0\\r\\n acc = metrics.r2_score(self.y_test, y_pred)\\r\\n output = \\\"I am {}% sure that you like this progression.\\\".format('%.2f' % (100 * y_usr[0]))\\r\\n model_info = \\\"Predicted using a {} model with {} accuracy from {} data samples.\\\".format(model[0], '%.3f' % acc,\\r\\n self.data_count())\\r\\n return output, model_info\",\n \"def predict(self,X):\\n return self.classifier.predict(X)\",\n \"def predict(self,X):\\n return self.classifier.predict(X)\",\n \"def predict(self,X):\\n return self.classifier.predict(X)\",\n \"def predict(self,X):\\n return self.classifier.predict(X)\",\n \"def predict(self):\\n raise NotImplementedError\",\n \"def predict (self, model, context, data):\\n # 1. Feature engineering\\n features_df = FeatureEngineering().do_for_predict(data, joblib.load(model.files['description-vectorizer']), joblib.load(model.files['user-encoder']), context)\\n\\n # 2. Load model & other required files\\n trained_model = joblib.load(model.files['model'])\\n categories = pd.read_csv(model.files['categories'], index_col=0)\\n\\n # 3. Predict\\n pred = trained_model.predict(features_df)\\n\\n # 4. Return the prediction\\n predicted_category = pd.DataFrame(pred, columns=categories['category']).idxmax(axis=1)[0]\\n\\n logger.compute(context.correlation_id, '[ {ctx} ] - [ PREDICTION ] - Model {model}.v{version} - Predicted category for description [{desc}]: {c}'.format(ctx=context.process, model=model.info['name'], version=model.info['version'], desc=data['description'], c=predicted_category), 'info')\\n \\n return ModelPrediction(prediction={\\\"category\\\": predicted_category})\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self, X):\\n ...\",\n \"def predict(self):\\n train_array = np.array(self.labels != 0, dtype=float)\\n if not self.ising:\\n labels_logit = self.ising_weights['vertices']\\n else:\\n neigh_num = self.adj.dot(train_array)\\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\\n neigh_weights = self.ising_weights['edges'] * self.labels\\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\\n + self.ising_weights['vertices'])\\n self.prediction = np.where(labels_logit > 0, 1, -1)\\n return self\",\n \"def predict(self, data):\\n data['predicted'] = self.sentiment_classifier.predict_estimator(data)\\n return data\",\n \"def predict(model):\\n # load test dataset\\n test = dict(json.load(open('util_files/test.json')))\\n ids = test['ids']\\n data = test['data']\\n\\n df = pd.read_csv('data/document_departments.csv')\\n labels = dict(df.values.tolist())\\n\\n id2cls = dict(json.load(open('util_files/id2cls.json')))\\n \\n ytrue = []\\n ypredicted = []\\n \\n for i in range(len(data)):\\n \\n prediction = np.argmax(model.predict_on_batch(np.expand_dims(data[i], axis=0)))\\n \\n ypredicted.append(id2cls[str(prediction)])\\n \\n cls = labels[int(ids[i])]\\n ytrue.append(cls)\\n \\n print \\\"classification report\\\"\\n print classification_report(y_true=ytrue,\\n y_pred=ypredicted)\\n \\n print \\\"*********************\\\"\\n print \\\"Accuracy on test set\\\"\\n print accuracy_score(y_true=ytrue,\\n y_pred=ypredicted)\\n print \\\"*********************\\\"\",\n \"def predict(self, X: _DaskMatrixLike, **kwargs: Any) -> dask_Array:\\n return _predict(\\n model=self.to_local(),\\n data=X,\\n dtype=self.classes_.dtype,\\n **kwargs\\n )\",\n \"def predict(self, instances):\\r\\n raise NotImplementedError\",\n \"def classify(self, data):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.sklearn_classifier.predict(data)\",\n \"def predict(data, samples, classifier='SVM',\\r\\n classification='combined', selectFeatures=('CUK', 10)):\\r\\n if (classification == \\\"trained\\\"):\\r\\n classifyTrained = True\\r\\n classifySurface = False\\r\\n elif (classification == 'surface'):\\r\\n classifyTrained = False\\r\\n classifySurface = True\\r\\n else:\\r\\n classifyTrained = True\\r\\n classifySurface = True\\r\\n if (classifier == \\\"SVM\\\"):\\r\\n clf = cl.classifyDataSVM(data, classifyTrained,\\r\\n classifySurface, selectFeatures,scaling=False)\\r\\n elif (classifier == \\\"DT\\\"):\\r\\n clf = cl.classifyDataDT(data, classifyTrained,\\r\\n classifySurface, selectFeatures,scaling=False)\\r\\n elif (classifier == \\\"KNN\\\"):\\r\\n clf = cl.classifyDataKNN(data, classifyTrained,\\r\\n classifySurface, selectFeatures,scaling=False)\\r\\n elif (classifier == \\\"LogReg\\\"):\\r\\n clf = cl.classifyDataLR(data, classifyTrained,\\r\\n classifySurface, selectFeatures,scaling=False)\\r\\n else:\\r\\n print (str(classifier) + \\\" is not a valid option\\\")\\r\\n \\r\\n [samples, _,_,_] = clf.extractData(samples,scaling=False)\\r\\n \\r\\n predictions = [clf.predict(s) for s in samples]\\r\\n return predictions\",\n \"def predict(cls, input):\\n clf = cls.get_model()\\n print('input=')\\n print(input)\\n return clf.predict(input)\",\n \"def predict(self, estimator, blocks=None, cluster_by_stability=False, custom_order=False):\\n\\n return nmf_predict(estimator, blocks=blocks, leverage=self.leverage, cluster_by_stability=cluster_by_stability,\\n custom_order=custom_order, verbose=self.verbose)\",\n \"def predict(self, estimator, blocks=None, cluster_by_stability=False, custom_order=False):\\n\\n return nmf_predict(estimator, blocks=blocks, leverage=self.leverage, cluster_by_stability=cluster_by_stability,\\n custom_order=custom_order, verbose=self.verbose)\",\n \"def _predict(self, X):\\n # self._X should be the stored _X\\n dist_mat = self._distance(X, self._X)\\n\\n y_pred = self.knn_estimator_.predict(dist_mat)\\n\\n return y_pred\",\n \"def predict(self, X):\\n X = X['user_id']\\n return self.clf.predict(X)\",\n \"def predict(prediction_request):\\n\\n feature_type = prediction_request['feature_type']\\n\\n if feature_type not in [MFCC, C_CENS, C_CQT, C_STFT, MEL]:\\n raise Exception('Invalid Feature type for prediction: {}'.format(feature_type))\\n\\n model = model_from_feature[feature_type]\\n\\n prediction = np.argmax(model.predict([np.reshape(prediction_request['content'], (1, *prediction_request['content'].shape, 1))]), axis=1)[0]\\n\\n predicted_class = \\\"COPD\\\" if prediction == 0 else \\\"non-COPD\\\"\\n\\n print(\\\"Prediction for type {} = {}\\\".format(feature_type, predicted_class))\\n\\n socket.send_pyobj({\\n 'model': feature_type,\\n 'class': predicted_class\\n })\",\n \"def clf1_predict(self):\\n self._pred_clf_1 = self._clf1.predict(self._vectorized_input)[0]\",\n \"def make_predictions(df):\\n t_labels = get_labels(\\\"labels_pca\\\")\\n # clean data\\n df = clean_data(df)\\n # engineer data\\n df = engineer_features(df)\\n # predict\\n with open(\\\"model.pkl\\\",\\\"r\\\") as mdl:\\n model = pickle.load(mdl)\\n mdl.close()\\n predictions = model.predict(df[t_labels])\\n return predictions\",\n \"def predict(self, test_data):\\r\\n return self.gs.predict(test_data)\",\n \"def _predict(self, classify: np.array, n_preds=1):\\r\\n tmp = classify.argsort()[:, :n_preds] # Return the index of the best label classification\\r\\n preds = copy(tmp) # allow to copy tmp\\r\\n for index, target in enumerate(self.targets):\\r\\n preds = np.where(tmp == index, target, preds) # Return the target label corresponding to the index\\r\\n self.preds = preds\",\n \"def predict(self, data: List):\\r\\n return self._lda.predict(data)\",\n \"def classify(self, data):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.sklearn_svm.predict(data)\",\n \"def predict(cls, input):\\n clf = cls.get_model()\\n return clf.predict(input)\",\n \"def predict(dataset):\\n import capsnet\\n\\n # Load (standardized) input data and associated file names\\n test_x, _, names = _load_data(dataset)\\n\\n # Predict class probabilities for each model (epoch)\\n at_preds, sed_preds = [], []\\n\\n for epoch in _determine_epochs(cfg.prediction_epochs):\\n model = _load_model(epoch)\\n at_pred, sed_pred = utils.timeit(\\n lambda: capsnet.gccaps_predict(test_x, model),\\n '[Epoch %d] Predicted class probabilities' % epoch)\\n\\n at_preds.append(at_pred)\\n sed_preds.append(sed_pred)\\n\\n # Average predictions to give an overall output\\n total_at_pred = np.mean(at_preds, axis=0)\\n total_sed_pred = np.mean(sed_preds, axis=0)\\n\\n # Ensure output directory exists and set file path format\\n os.makedirs(os.path.dirname(cfg.predictions_path), exist_ok=True)\\n predictions_path = cfg.predictions_path.format('%s', dataset.name)\\n\\n # Save free parameters to disk\\n utils.log_parameters({'prediction_epochs': cfg.prediction_epochs},\\n os.path.join(os.path.dirname(cfg.predictions_path),\\n 'parameters.json'))\\n\\n # Write predictions to disk\\n utils.write_predictions(names, total_at_pred, predictions_path % 'at')\\n utils.write_predictions(names, total_sed_pred, predictions_path % 'sed')\",\n \"def supervised_predict(self, x):\\n z_ik = self.get_posterior(x)\\n em_label = np.argmax(z_ik, axis=1)\\n y_hat = [self.cluster_label_map[idx] for idx in em_label]\\n return np.array(y_hat)\",\n \"def predict(self, data_in):\\n pass\",\n \"def predict(self, to_predict):\\n\\t\\treturn self.model.predict(to_predict)\",\n \"def predict(self, model, batch):\\n device = list(model.parameters())[0].device\\n batch = batch.to(device)\\n inputs = batch.inputs\\n # Extract features with the model\\n h = model(*inputs)\\n # predictions\\n return self.predict_on_features(h)\",\n \"def predict(self, X):\\n return self.classifier.predict(X)\",\n \"def predict(self, x):\\n new_x = np.array(self.transform(x.reshape(1, -1)).flatten())\\n return self.clf.predict(new_x.T)\",\n \"def predict(self, load_script=False, variant=\\\"predict\\\"):\\n \\n # Interpret the request data based on the expected row and column structure\\n row_template = ['strData', 'strData']\\n col_headers = ['model_name', 'n_features']\\n feature_col_num = 1\\n \\n # An additional key field column is expected if the call is made through the load script\\n if load_script:\\n row_template = ['strData', 'strData', 'strData']\\n col_headers = ['model_name', 'key', 'n_features']\\n feature_col_num = 2\\n \\n # Create a Pandas Data Frame for the request data\\n self.request_df = utils.request_df(self.request, row_template, col_headers)\\n \\n # Initialize the persistent model\\n self.model = PersistentModel()\\n \\n # Get the model name from the request dataframe\\n self.model.name = self.request_df.loc[0, 'model_name']\\n \\n # Get the model from cache or disk\\n self._get_model()\\n \\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(3)\\n \\n if load_script:\\n # Set the key column as the index\\n self.request_df.set_index(\\\"key\\\", drop=False, inplace=True)\\n \\n try:\\n # Split the features provided as a string into individual columns\\n self.X = pd.DataFrame([x[feature_col_num].split(\\\"|\\\") for x in self.request_df.values.tolist()],\\\\\\n columns=self.model.features_df.loc[:,\\\"name\\\"].tolist(),\\\\\\n index=self.request_df.index)\\n except AssertionError as ae:\\n err = \\\"The number of input columns do not match feature definitions. Ensure you are using the | delimiter and that the target is not included in your input to the prediction function.\\\"\\n raise AssertionError(err) from ae\\n \\n # Convert the data types based on feature definitions \\n self.X = utils.convert_types(self.X, self.model.features_df, sort=False)\\n\\n if variant in ('predict_proba', 'predict_log_proba'):\\n # If probabilities need to be returned\\n if variant == 'predict_proba':\\n # Get the predicted probability for each sample \\n self.y = self.model.pipe.predict_proba(self.X)\\n elif variant == 'predict_log_proba':\\n # Get the log probability for each sample\\n self.y = self.model.pipe.predict_log_proba(self.X)\\n \\n # Prepare a list of probability by class for each sample\\n probabilities = []\\n\\n for a in self.y:\\n s = \\\"\\\"\\n i = 0\\n for b in a:\\n s = s + \\\", {0}: {1:.3f}\\\".format(self.model.pipe.named_steps['estimator'].classes_[i], b)\\n i = i + 1\\n probabilities.append(s[2:])\\n \\n self.y = probabilities\\n \\n else:\\n # Predict y for X using the previously fit pipeline\\n self.y = self.model.pipe.predict(self.X)\\n\\n # Inverse transformations on the targets if required\\n if self.model.scale_target or self.model.make_stationary:\\n # Apply the transformer to the test targets\\n self.y = self.model.target_transformer.inverse_transform(self.y) \\n\\n # Prepare the response\\n self.response = pd.DataFrame(self.y, columns=[\\\"result\\\"], index=self.X.index)\\n \\n if load_script:\\n # Add the key field column to the response\\n self.response = self.request_df.join(self.response).drop(['n_features'], axis=1)\\n \\n # If the function was called through the load script we return a Data Frame\\n self._send_table_description(\\\"predict\\\")\\n \\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(4)\\n \\n return self.response\\n \\n # If the function was called through a chart expression we return a Series\\n else:\\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(4)\\n \\n return self.response.loc[:,'result']\",\n \"def predict(\\r\\n model: sklearn_Pipeline, \\r\\n test_x: pd.DataFrame\\r\\n) -> pd.DataFrame:\\r\\n # Return predictions\\r\\n return model.predict(test_x)\",\n \"def predictClass(training_data, test_row, k):\\n\\n neighbors = getNeighbors(training_data, test_row, k)\\n output_vals = [row[-1] for row in neighbors]\\n \\n counts = dict()\\n\\n for i in output_vals:\\n counts[i] = counts.get(i, 0) + 1\\n\\n v = [value for value in counts.values()]\\n\\n #Pick a class on random if ties occur\\n prediction = choice([key for key in counts if counts[key] == max(v)])\\n\\n return prediction\",\n \"def predict(self, X):\\n pass\",\n \"def predict(self, X):\\n pass\",\n \"def predict(self, X):\\n pass\",\n \"def predict_only(self):\",\n \"def predict(self, X, k):\\n # Sanity check\\n if self.__trained == False:\\n return 'Model not trained yet'\\n \\n # Reshape data to 2D array if possible\\n if len(X.shape) == 1:\\n X = X[None, :]\\n \\n # Compute the distances between all given points and all training points\\n distances = np.sum((X[:, None, :] - self.__X[None, :, :]) ** 2, axis = -1)\\n \\n # Find the K nearest neighbors\\n k_nearest_neighbors = np.argsort(distances, axis=-1)[:,:k]\\n\\n # Run over all columns and find the most common neighbor in each, then return his label\\n n_observations = X.shape[0]\\n idx = [np.argmax(np.bincount(k_nearest_neighbors[i])) for i in range(n_observations)]\\n return self.__y[idx]\",\n \"def pre_train(self, dataset):\\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\\n pe = principleextractor.PrincipleExtractor()\\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\\n # not in the .json; or with argument given TODO\\n self.skm.add_syllogistic_data(data=pd_dataset)\\n\\n self.skm.generate_clusters(cutoff=self.cutoff)\\n\\n results = pe.extract_principles_from_k_clusters(self.skm.final_clusters_syll_list)\\n\\n participant_correspondence = principleextractor.compute_participant_correspondence(self.skm.subj_data_dict,\\n self.skm.final_clusters_num)\\n principleextractor.write_results(results[0], results[1], self.skm.final_clusters_syll_list,\\n participant_correspondence)\\n\\n self.k_clusters = self.skm.final_clusters_syll_list\\n\\n gen_skm = syllogistickmeans.SyllogisticKMeans(1)\\n gen_skm.add_syllogistic_data(data=pd_dataset)\\n\\n gen_skm.generate_clusters(cutoff=self.cutoff)\\n\\n self.current_k_cluster = gen_skm.final_clusters_syll_list[0]\",\n \"def predict_data(data: pd.DataFrame, model: list):\\n prediction = []\\n for i, row in data.iterrows():\\n prediction.append(predict_dataset(row, model))\\n return prediction\",\n \"def predict(self, X, k=1):\\n dists = self.compute_distances(X)\\n return self.predict_labels(dists, k=k)\",\n \"def clf2_predict(self):\\n self._pred_clf_2 = self._clf2.predict(self._vectorized_input)[0]\",\n \"def predict(self, x: DNDarray) -> DNDarray:\\n # input sanitation\\n if not isinstance(x, DNDarray):\\n raise ValueError(f\\\"input needs to be a ht.DNDarray, but was {type(x)}\\\")\\n if x.split is not None and x.split != 0:\\n raise NotImplementedError(\\\"Not implemented for other splitting-axes\\\")\\n\\n _, eigenvectors = self._spectral_embedding(x)\\n\\n components = eigenvectors[:, : self.n_clusters].copy()\\n\\n return self._cluster.predict(components)\",\n \"def predict():\\n\\n\\n json_payload = request.json\\n #LOG.info(f\\\"JSON payload: %s\\\" %json_payload)\\n inference_payload = pd.DataFrame(json_payload)\\n #LOG.info(\\\"inference payload DataFrame: %s\\\" %inference_payload)\\n scaled_payload = scale(inference_payload)\\n prediction = list(clf.predict(scaled_payload))\\n return jsonify({'prediction': prediction})\",\n \"def predict(model, X_testing):\\n predictions = model.predict(X_testing)\\n\\n return predictions\",\n \"def predict(self, X):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7522711","0.7326191","0.7257883","0.70320976","0.65632576","0.6549994","0.6549688","0.6518247","0.6481188","0.6445282","0.6443695","0.64254546","0.6385586","0.6377753","0.6368531","0.6351673","0.63453573","0.63428134","0.6336442","0.6334855","0.6315561","0.63102674","0.63067317","0.6289587","0.62386644","0.6228398","0.62282926","0.6204604","0.61968845","0.6186821","0.61805433","0.6176737","0.6173239","0.61716825","0.6167528","0.61624646","0.6156256","0.61552227","0.614851","0.6120157","0.61078453","0.61052626","0.60868","0.6069812","0.60695815","0.6055583","0.60457","0.60447294","0.6043269","0.60233057","0.60233057","0.60233057","0.60233057","0.6015827","0.5997295","0.5989626","0.5989626","0.5989626","0.5982612","0.5979345","0.5965101","0.59622073","0.5961152","0.5959694","0.5955713","0.59537566","0.5942699","0.5942699","0.5941463","0.5938505","0.59372103","0.5929669","0.59294397","0.5926857","0.59240043","0.5921004","0.5919185","0.59138834","0.59084827","0.5907014","0.5901813","0.5892315","0.58916575","0.58888286","0.5885665","0.58849305","0.5883764","0.5883201","0.5878167","0.5878167","0.5878167","0.5877619","0.5875132","0.5871621","0.5863794","0.5861356","0.58597934","0.5859378","0.58581996","0.5853668","0.5851371"],"string":"[\n \"0.7522711\",\n \"0.7326191\",\n \"0.7257883\",\n \"0.70320976\",\n \"0.65632576\",\n \"0.6549994\",\n \"0.6549688\",\n \"0.6518247\",\n \"0.6481188\",\n \"0.6445282\",\n \"0.6443695\",\n \"0.64254546\",\n \"0.6385586\",\n \"0.6377753\",\n \"0.6368531\",\n \"0.6351673\",\n \"0.63453573\",\n \"0.63428134\",\n \"0.6336442\",\n \"0.6334855\",\n \"0.6315561\",\n \"0.63102674\",\n \"0.63067317\",\n \"0.6289587\",\n \"0.62386644\",\n \"0.6228398\",\n \"0.62282926\",\n \"0.6204604\",\n \"0.61968845\",\n \"0.6186821\",\n \"0.61805433\",\n \"0.6176737\",\n \"0.6173239\",\n \"0.61716825\",\n \"0.6167528\",\n \"0.61624646\",\n \"0.6156256\",\n \"0.61552227\",\n \"0.614851\",\n \"0.6120157\",\n \"0.61078453\",\n \"0.61052626\",\n \"0.60868\",\n \"0.6069812\",\n \"0.60695815\",\n \"0.6055583\",\n \"0.60457\",\n \"0.60447294\",\n \"0.6043269\",\n \"0.60233057\",\n \"0.60233057\",\n \"0.60233057\",\n \"0.60233057\",\n \"0.6015827\",\n \"0.5997295\",\n \"0.5989626\",\n \"0.5989626\",\n \"0.5989626\",\n \"0.5982612\",\n \"0.5979345\",\n \"0.5965101\",\n \"0.59622073\",\n \"0.5961152\",\n \"0.5959694\",\n \"0.5955713\",\n \"0.59537566\",\n \"0.5942699\",\n \"0.5942699\",\n \"0.5941463\",\n \"0.5938505\",\n \"0.59372103\",\n \"0.5929669\",\n \"0.59294397\",\n \"0.5926857\",\n \"0.59240043\",\n \"0.5921004\",\n \"0.5919185\",\n \"0.59138834\",\n \"0.59084827\",\n \"0.5907014\",\n \"0.5901813\",\n \"0.5892315\",\n \"0.58916575\",\n \"0.58888286\",\n \"0.5885665\",\n \"0.58849305\",\n \"0.5883764\",\n \"0.5883201\",\n \"0.5878167\",\n \"0.5878167\",\n \"0.5878167\",\n \"0.5877619\",\n \"0.5875132\",\n \"0.5871621\",\n \"0.5863794\",\n \"0.5861356\",\n \"0.58597934\",\n \"0.5859378\",\n \"0.58581996\",\n \"0.5853668\",\n \"0.5851371\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":19493,"cells":{"query":{"kind":"string","value":"Trains selforganizing map and returns train and test datasets with predicted clusters."},"document":{"kind":"string","value":"def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\n learning_rate=0.01):\n\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\n random_seed=0)\n som.train(df_train, n_iter)\n\n # converting numpy arrays to dataframes\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\n\n # creating column with cluster basing on model prediction\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\n\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\n # the script\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\n lsuffix='_org')\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\n lsuffix='_org')\n\n return final_df_train, final_df_test"},"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 pre_train(self, dataset):\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\n pe = principleextractor.PrincipleExtractor()\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\n # not in the .json; or with argument given TODO\n self.skm.add_syllogistic_data(data=pd_dataset)\n\n self.skm.generate_clusters(cutoff=self.cutoff)\n\n results = pe.extract_principles_from_k_clusters(self.skm.final_clusters_syll_list)\n\n participant_correspondence = principleextractor.compute_participant_correspondence(self.skm.subj_data_dict,\n self.skm.final_clusters_num)\n principleextractor.write_results(results[0], results[1], self.skm.final_clusters_syll_list,\n participant_correspondence)\n\n self.k_clusters = self.skm.final_clusters_syll_list\n\n gen_skm = syllogistickmeans.SyllogisticKMeans(1)\n gen_skm.add_syllogistic_data(data=pd_dataset)\n\n gen_skm.generate_clusters(cutoff=self.cutoff)\n\n self.current_k_cluster = gen_skm.final_clusters_syll_list[0]","def predict(toPredict=None):\n\tif not toPredict:\n\t\ttoPredict = gc.generate_test_cases(1)[0]\n\ttoPredict = np.asarray(toPredict)\n\ttoPredict = toPredict.reshape(1, -1)\t\n\tclusterer = joblib.load(\"training_data.pkl\")\n\tprint(clusterer.predict(toPredict))","def kmeans_002():\n train_mmap_path = 'data/train_cropped_150_scale_15.memmap'\n test_mmap_path = 'data/test_cropped_150_scale_15.memmap'\n\n if not os.path.exists('data/train_cropped_150.memmap'):\n classes.crop_to_memmap(150, training=True)\n if not os.path.exists('data/test_cropped_150.memmap'):\n classes.crop_to_memmap(150, training=False)\n\n if not os.path.exists(train_mmap_path):\n logger.info(\"Prepping training images\")\n pre_scale = np.memmap('data/train_cropped_150.memmap', mode='r', shape=(N_TRAIN, 150, 150, 3))\n trainX = classes.rescale_memmap(15, pre_scale, train_mmap_path)\n del pre_scale\n else:\n trainX = np.memmap(train_mmap_path, mode='r', shape=(N_TRAIN, 15, 15, 3))\n\n if not os.path.exists(test_mmap_path):\n logger.info(\"Prepping testing images\")\n pre_scale = np.memmap('data/test_cropped_150.memmap', mode='r', shape=(N_TEST, 150, 150, 3))\n testX = classes.rescale_memmap(15, pre_scale, test_mmap_path)\n del pre_scale\n else:\n testX = np.memmap(test_mmap_path, mode='r', shape=(N_TEST, 15, 15, 3))\n\n\n n_jobs = multiprocessing.cpu_count()\n\n if not os.path.exists('data/mdl_kmeans_002_centroids.npy'):\n logger.info(\"Pretraining KMeans feature encoder\")\n km = models.KMeansFeatures.KMeansFeatures(rf_size=5, num_centroids=1600, num_patches=400000)\n km.fit(trainX)\n km.save_to_file('mdl_kmeans_002')\n else:\n logger.info(\"Loading KMeans feature encoder from file\")\n km = models.KMeansFeatures.KMeansFeatures.load_from_file('mdl_kmeans_002', rf_size=5)\n\n # Takes waaaay too long to finish. At least an hour per tree. Clearly too\n # many dimensions\n\n # Instead ran with ridge rf manually\n mdl = models.RandomForest.KMeansRandomForest(km, trainX, testX, n_jobs=n_jobs, cv_sample=0.5)\n # mdl.run('cv')\n mdl.run('train')\n res = mdl.run('predict')\n np.save('submissions/sub_kmeans_rf_002.npy', res)\n output = classes.Submission(res)\n output.to_file('sub_kmeans_rf_002.csv')","def run_classification_experiment ( feature_matrix, target_array, colmap ):\n np.random.seed ( 7062020 ) # Due date\n\n # Split off validation set and cross-validation set\n X_validation = feature_matrix [ : feature_matrix.shape [ 0 ] // 10 ]\n X_cross_validation = feature_matrix [ feature_matrix.shape [ 0 ] // 10 : ]\n y_validation = target_array [ : feature_matrix.shape [ 0 ] // 10 ]\n y_cross_validation = target_array [ feature_matrix.shape [ 0 ] // 10 : ]\n\n experiment_results = {}\n experiment_num = 1\n\n # Use 5-Fold stratified CV\n kfold_strat = KFoldStratifiedCV ( number_of_folds = 5, shuffle = True )\n\n for train, test in kfold_strat.split ( feature_matrix = X_cross_validation, target_array = y_cross_validation ):\n logger.info ( f\"Experiment Number: { experiment_num }\" )\n\n # Get training set\n X_train = X_cross_validation [ train, : ]\n y_train = y_cross_validation [ train ]\n\n # Fit the tree\n d_tree = DecisionTreeClassifier ( evaluate_function = entropy, map_column_node_type = colmap )\n d_tree.fit ( X_train, y_train )\n\n # Prune the tree\n pruned_tree = PostPruner (\n d_tree,\n X_validation = X_validation,\n y_validation = y_validation,\n evaluate_function = accuracy,\n ).prune_tree()\n\n # Get post-pruned predictions\n pruned_preds = pruned_tree.predict ( X_cross_validation [ test, : ] )\n\n # Save the results\n experiment_results [ experiment_num ] = {\n \"actuals\": y_cross_validation [ test ],\n \"preds\": pruned_preds,\n \"model\": pruned_tree,\n }\n experiment_num += 1\n\n return experiment_results\n # End run_classification_experiment","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def setup_datasets(self):\r\n\r\n train_transform = transforms.Compose(\r\n [\r\n transforms.Resize(self.crop_size),\r\n transforms.RandomRotation(degrees=self.random_angle, resample=Image.BILINEAR),\r\n transforms.RandomResizedCrop(\r\n size=self.crop_size, scale=(1-self.random_scale, 1+self.random_scale), ratio=(1, 1)),\r\n transforms.RandomHorizontalFlip(),\r\n transforms.ToTensor(),\r\n transforms.Normalize(\r\n mean=[0.485, 0.456, 0.406],\r\n std=[0.229, 0.224, 0.225]\r\n )\r\n ]\r\n )\r\n val_transform = transforms.Compose(\r\n [\r\n transforms.Resize(self.crop_size),\r\n transforms.CenterCrop(self.crop_size),\r\n transforms.ToTensor(),\r\n transforms.Normalize(\r\n mean=[0.485, 0.456, 0.406],\r\n std=[0.229, 0.224, 0.225]\r\n )\r\n ]\r\n )\r\n\r\n train_dataset = CocoDatasetPairs(\r\n root_dir=self.coco_path,\r\n set_name='train2014',\r\n transform=train_transform,\r\n dataset_size_ratio=self.dataset_size_ratio\r\n )\r\n train_subset_dataset = Subset(train_dataset, range(0, len(train_dataset), 5*self.dataset_size_ratio))\r\n val_dataset = CocoDatasetPairs(\r\n root_dir=self.coco_path,\r\n set_name='val2014',\r\n transform=val_transform,\r\n )\r\n\r\n train_loader = DataLoader(\r\n train_dataset,\r\n batch_size=self.batch_size,\r\n shuffle=True,\r\n num_workers=self.num_workers\r\n )\r\n train_subset_loader = DataLoader(\r\n train_subset_dataset,\r\n batch_size=self.batch_size,\r\n shuffle=False,\r\n num_workers=self.num_workers\r\n )\r\n val_loader = DataLoader(\r\n val_dataset,\r\n batch_size=self.batch_size,\r\n shuffle=False,\r\n num_workers=self.num_workers\r\n )\r\n return train_loader, train_subset_loader, val_loader","def __create_cluster_profiles(self,\n clustered_dataframes,\n shrunken_df,\n numerical_features,\n le_map,\n output_path,\n find_nearest_on_cols=False,\n show=True):\n\n def find_nearest(numbers, target):\n \"\"\"\n Find the closest fitting number to the target number\n \"\"\"\n numbers = np.asarray(numbers)\n idx = (np.abs(numbers - target)).argmin()\n return numbers[idx]\n\n cluster_profiles_df = pd.DataFrame(columns=shrunken_df.columns).drop(\n 'Cluster_Name', axis=1)\n rows_count = 0\n for cluster_identfier, cluster_dataframe in \\\n clustered_dataframes.items():\n df = pd.DataFrame(columns=cluster_dataframe.columns)\n df = df.append(cluster_dataframe.mean(), ignore_index=True)\n df.index = [cluster_identfier]\n\n if cluster_dataframe.shape[0] <= 1:\n continue\n\n # Attempt to convert numbers found within the full set of data\n for col in cluster_dataframe.columns:\n if col not in numerical_features or find_nearest_on_cols:\n df[col] = find_nearest(numbers=shrunken_df[\n col].value_counts().index.tolist(),\n target=df[col].values[0])\n\n # Evaluate cluster dataframe by dataframe\n eval_df = pd.DataFrame(columns=cluster_dataframe.columns)\n eval_df = eval_df.append(\n cluster_dataframe.mean(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.min(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.median(),\n ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.max(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.std(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.var(), ignore_index=True)\n eval_df.index = [\"Mean\", \"Min\", \"Median\",\n \"Max\", \"Standard Deviation\", \"Variance\"]\n\n if show:\n print(\"Total found in {0} is {1}\".format(\n cluster_identfier, cluster_dataframe.shape[0]))\n self.__render_mpl_table(\n df,\n sub_dir=output_path,\n filename=cluster_identfier +\n \"_Means_Rounded_To_Nearest_Real_Numbers\",\n header_columns=0,\n col_width=4.0)\n\n self.__render_mpl_table(\n eval_df,\n sub_dir=output_path,\n filename=cluster_identfier +\n \"_Eval_Df\",\n header_columns=0,\n col_width=4.0)\n display(df)\n display(eval_df)\n self.__vertical_spacing(7)\n\n cluster_profiles_df = cluster_profiles_df.append(\n self.__decode_df(df, le_map))\n\n rows_count += cluster_dataframe.shape[0]\n\n return rows_count, cluster_profiles_df","def predict(self, test_data):\n if self.centroids_.shape[0]==0:\n raise ValueError(\"No centroids present. Run KMeans.fit first.\")\n\n print test_data.shape\n part_of_cluster=np.zeros(test_data.shape[0])\n for i in range(test_data.shape[0]):\n dists=[]\n for c in range(self.centroids_.shape[0]):\n # compute distance between current train_data instance and each cluster\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\n \n # assign point to cluster with minimal distance\n part_of_cluster[i]=dists.index(min(dists))\n\n return part_of_cluster","def prepare_nfold_datasets(self): # i.e. split into different train/ground-truth(test) dataset\n for alpha in range(1, self.ALPHAs+1):\n if alpha != self.ALPHAs:\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI], separator='-')\n else:\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI+self.runoff_years], separator='-')\n new_cluster_dir = str(Path(self.tl_model.cluster_dir) / f'alpha_{alpha}_GT-{gt_years}')\n os.makedirs(new_cluster_dir, exist_ok=True)\n\n new_prepared_data_dir = str(Path(self.tl_model.prepared_data_dir) / f'alpha_{alpha}')\n os.makedirs(new_prepared_data_dir, exist_ok=True)\n \n if utils.find(f'*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir) and utils.find(f'*alpha_{alpha}_standardized_stacked_arr.pkl', new_prepared_data_dir):\n pass\n else:\n if not utils.find(f'*target*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\n print(f\"=> No input datasets pre-processed for alpha of {alpha}\")\n prepare.cut_target_dataset(self, alpha, new_prepared_data_dir)\n\n if not utils.find(f'*rf*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\n print(f\"=> No rainfall datasets pre-processed for alpha of {alpha}\")\n prepare.cut_rf_dataset(self, alpha, new_prepared_data_dir)\n \n print(f'Preprocessed pickles for alpha split {alpha} can be found @:\\n{new_prepared_data_dir}')","def kmeans_001(fit_centroids=False):\n trainX = np.memmap('data/train_cropped_150.memmap', mode='r', shape=(N_TRAIN, 150, 150, 3))\n # Not used yet\n testX = np.memmap('data/test_cropped_150.memmap', mode='r', shape=(N_TEST, 150, 150, 3))\n\n if fit_centroids:\n km = models.KMeansFeatures.KMeansFeatures(rf_size=6, num_centroids=1600, num_patches=400000)\n km.fit(trainX)\n\n km.save_to_file('mdl_kmeans_ridge_rf_001')\n # t0 = time.time()\n # pickle.dump(km, open('data/kmeans_centroids.pkl', mode='wb'))\n # print 'Pickling the KMeansFeatures object took {0} seconds'.format(time.time() - t0)\n else:\n km = models.KMeansFeatures.KMeansFeatures.load_from_file('mdl_kmeans_ridge_rf_001')\n # km = pickle.load(open('data/kmeans_centroids.pkl'))\n\n n = 10000\n\n train_x = km.transform(trainX[0:n, :])\n train_y = classes.train_solutions.data[0:n, :]\n # train_x = km.transform(trainX)\n # train_y = classes.train_solutions.data\n\n logger.info(\"Train x shape: {}\".format(train_x.shape))\n logger.info(\"Train y shape: {}\".format(train_y.shape))\n\n kf = KFold(n, n_folds=2, shuffle=True)\n\n for train, test in kf:\n # clf = models.Ridge.RidgeRFEstimator()\n # clf.rf_rgn = RandomForestRegressor(n_estimators=250, n_jobs=4, verbose=3)\n clf = RandomForestRegressor(n_estimators=20, n_jobs=4, verbose=3, random_state=0, oob_score=True)\n clf.fit(train_x[train], train_y[train])\n res = clf.predict(train_x[test])\n classes.rmse(train_y[test], res)","def train(self):\n\n print \"==> Running Kmeans on data set of shape: {}\".format(self.data.shape)\n km = KMeans(n_clusters = self.n_clusters)\n km.fit(self.data.values)\n self.labels = km.labels_\n self.inertia = km.inertia_","def train_and_test(self, data):\n\n np.random.shuffle(data)\n datalist = self.unpack_data(data)\n\n logger.info('[*] 75-25 partition of datasets ...')\n\n markline1 = math.floor(0.75*(len(datalist['features'])))\n markline2 = math.floor(0.75*len(datalist['labels']))\n\n train_features = datalist['features'][:(markline1)]\n test_features = datalist['features'][(markline1):]\n \n train_labels = datalist['labels'][:(markline2)]\n test_labels = datalist['labels'][(markline2):]\n\n logger.info('[*] Training started with 75% Dataset ...')\n\n self.knn_model.fit(train_features, train_labels)\n\n logger.info('[*] Testing started with 25% Dataset ...')\n print('\\n/---------------Accuracy----------------/') \n \n accuracy = self.knn_model.score(train_features, train_labels)\n print('Test set accuracy {:.2f} %'.format(accuracy*100))\n\n if accuracy < 0.40:\n logger.warning('[-.-!] Thanks for tryin\\' but this machine ain\\'t learning.')\n\n return True","def initSets(self):\n data_frame = pd.read_csv(self.train_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n if self.test_file is None:\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n else:\n data_frame = pd.read_csv(self.test_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n # kfold = KFold(n_splits=3)\n # self.train_index, self.test_index = kfold.split(features,labels)","def train(self):\r\n for class_ in set(self.train_classes):\r\n data = map(lambda (ind, datum): datum, filter(lambda (ind, datum): self.train_classes[ind] == class_, enumerate(self.train_data)))\r\n self.distribution.index_data(data, class_)","def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n\n # Scale the data so that Euclidian distance makes sense\n means = np.mean(data, axis = 0)\n stddevs = np.std(data, axis = 0, ddof = 1)\n\n #print(means)\n #print(stddevs)\n\n data_scaled = np.zeros((n_examples, n_features))\n\n for i in range(n_features):\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\n\n study_correlation(data_scaled)\n\n # Initialize the centroids\n idx = np.random.randint(n_examples, size = n_clusters)\n centroids = data_scaled[idx, :]\n\n counter = 0\n\n while True:\n\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\n centroid_idx = np.argmin(distances, axis = 1)\n old_centroids = centroids\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\n #displacement = get_displacement(old_centroids, centroids)\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\n\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\n\n if counter == 0:\n# print(\"Initial displacement = {}\".format(displacement))\n initial_displacement = displacement\n\n counter += 1\n\n if displacement < (initial_displacement / 10000): break\n\n #print(\"Total number of loops before ending : {}\".format(counter))\n converted_predictions = convert_predictions(centroid_idx)\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def train():\n\n # Load camera parameters\n rcams = cameras.load_cameras()\n\n # Load 3d data and 2d projections\n full_train_set_3d, full_test_set_3d, data_mean_3d, data_std_3d, dim_to_ignore_3d, dim_to_use_3d =\\\n data_utils.read_3d_data( FLAGS.camera_frame, rcams, FLAGS.origin_bc, FLAGS.augment_data,\n FLAGS.procrustes, FLAGS.lowpass )\n \n # Read stacked hourglass 2D predictions\n full_train_set_2d, full_test_set_2d, data_mean_2d, data_std_2d, dim_to_ignore_2d, dim_to_use_2d = \\\n data_utils.read_2d_predictions( FLAGS.origin_bc, FLAGS.augment_data )\n \n print(\"\\n[+] done reading and normalizing data\")\n # Getting the number of training and test subjects\n tr_subj = 0\n for v in full_train_set_3d.values():\n tr_subj += v.shape[0]\n te_subj = 0\n for v in full_test_set_3d.values():\n te_subj += v.shape[0]\n print(\"{0} training subjects, {1} test subjects\".format(tr_subj, te_subj))\n print(dim_to_use_2d)\n print(dim_to_use_3d)\n # Un-normalizing data for visualizations\n unNorm_ftrs2d = data_utils.unNormalize_dic(full_train_set_2d, data_mean_2d, data_std_2d, dim_to_use_2d)\n unNorm_ftrs3d = data_utils.unNormalize_dic(full_train_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\n unNorm_ftes3d = data_utils.unNormalize_dic(full_test_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\n # Visualize the data\n viz.visualize_train_sample(unNorm_ftrs2d, unNorm_ftrs3d, FLAGS.camera_frame)\n viz.visualize_files_oneatatime(unNorm_ftrs3d, unNorm_ftes3d)\n\n # Getting only the dimensions to use (get rid of body coxas, other limb, antennas, abdomen\n train_set_3d, train_set_2d, test_set_3d, test_set_2d = {}, {}, {}, {}\n for k in full_train_set_3d:\n (f, c) = k\n train_set_3d[k] = full_train_set_3d[k][:, dim_to_use_3d]\n train_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\n full_train_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\n for k in full_test_set_3d:\n (f, c) = k\n test_set_3d[k] = full_test_set_3d[k][:, dim_to_use_3d]\n test_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\n full_test_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\n \n print(\"3D data mean:\")\n print(data_mean_3d)\n print(\"3D data std:\")\n print(data_std_3d)\n\n print(\"2D data mean:\")\n print(data_mean_2d)\n print(\"2D data std:\")\n print(data_std_2d)\n \n input(\"Press Enter to continue...\")\n\n # Avoid using the GPU if requested\n device_count = {\"GPU\": 0} if FLAGS.use_cpu else {\"GPU\": 1}\n with tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(\n device_count=device_count,\n allow_soft_placement=True )) as sess:\n\n # === Create the model ===\n print(\"[*] creating %d bi-layers of %d units.\" % (FLAGS.num_layers, FLAGS.linear_size))\n model = create_model( sess, FLAGS.batch_size )\n model.train_writer.add_graph( sess.graph )\n print(\"[+] model created\")\n \n #=== This is the training loop ===\n step_time, loss, val_loss = 0.0, 0.0, 0.0\n current_step = 0 if FLAGS.load <= 0 else FLAGS.load + 1\n previous_losses = []\n\n step_time, loss = 0, 0\n current_epoch = 0\n log_every_n_batches = 100\n losses, errors, joint_errors = [], [], []\n for _ in range( FLAGS.epochs ):\n current_epoch = current_epoch + 1\n\n # === Load training batches for one epoch ===\n encoder_inputs, decoder_outputs =\\\n model.get_all_batches( train_set_2d, train_set_3d, FLAGS.camera_frame, training=True )\n nbatches = len( encoder_inputs )\n print(\"[*] there are {0} train batches\".format( nbatches ))\n start_time, loss = time.time(), 0.\n # === Loop through all the training batches ===\n for i in range( nbatches ):\n\n if (i+1) % log_every_n_batches == 0:\n # Print progress every log_every_n_batches batches\n print(\"Working on epoch {0}, batch {1} / {2}...\".format( current_epoch, i+1, nbatches),end=\"\" )\n\n enc_in, dec_out = encoder_inputs[i], decoder_outputs[i]\n step_loss, loss_summary, lr_summary, _ =\\\n model.step( sess, enc_in, dec_out, FLAGS.dropout, isTraining=True )\n\n if (i+1) % log_every_n_batches == 0:\n # Log and print progress every log_every_n_batches batchespixels = pixels / pixels[2,:]\n model.train_writer.add_summary( loss_summary, current_step )\n model.train_writer.add_summary( lr_summary, current_step )\n step_time = (time.time() - start_time)\n start_time = time.time()\n print(\"done in {0:.2f} ms\".format( 1000*step_time / log_every_n_batches ) )\n\n loss += step_loss\n current_step += 1\n # === end looping through training batches ===\n\n loss = loss / nbatches\n losses.append(loss)\n print(\"=============================\\n\"\n \"Global step: %d\\n\"\n \"Learning rate: %.2e\\n\"\n \"Train loss avg: %.4f\\n\"\n \"=============================\" % (model.global_step.eval(),\n model.learning_rate.eval(), loss) )\n # === End training for an epoch ===\n\n # === Testing after this epoch ===\n isTraining = False\n \n n_joints = len(data_utils.DIMENSIONS_TO_USE)\n if FLAGS.origin_bc:\n n_joints -= len(data_utils.ROOT_POSITIONS)\n\n encoder_inputs, decoder_outputs =\\\n model.get_all_batches( test_set_2d, test_set_3d, FLAGS.camera_frame, training=False)\n\n total_err, coordwise_err, joint_err, step_time, loss = evaluate_batches( sess, model,\n data_mean_3d, data_std_3d, dim_to_use_3d, dim_to_ignore_3d,\n data_mean_2d, data_std_2d, dim_to_use_2d, dim_to_ignore_2d,\n current_step, encoder_inputs, decoder_outputs, current_epoch )\n\n print(\"=============================\\n\"\n \"Step-time (ms): %.4f\\n\"\n \"Val loss avg: %.4f\\n\"\n \"Val error avg (mm): %.2f (%.2f, %.2f, %.2f)\\n\"\n \"=============================\" % ( 1000*step_time, loss, total_err,\n coordwise_err[0], coordwise_err[1], coordwise_err[2] ))\n\n for i in range(n_joints):\n # 6 spaces, right-aligned, 5 decimal places\n print(\"Error in joint {0:02d} (mm): {1:>5.2f}\".format(i+1, joint_err[i]))\n print(\"=============================\")\n errors.append(coordwise_err)\n joint_errors.append(joint_err)\n # Log the error to tensorboard\n summaries = sess.run( model.err_mm_summary, {model.err_mm: total_err} )\n model.test_writer.add_summary( summaries, current_step )\n\n # Save the model\n print( \"Saving the model... \", end=\"\" )\n start_time = time.time()\n model.saver.save(sess, os.path.join(train_dir, 'checkpoint'), global_step=current_step )\n print( \"done in {0:.2f} ms\".format(1000*(time.time() - start_time)) )\n\n # Reset global time and loss\n step_time, loss = 0, 0\n\n sys.stdout.flush()\n # Save losses for future plots\n def print_list_tofile(l, filename):\n with open(filename, 'wb') as f:\n pickle.dump(l, f)\n print_list_tofile(losses, train_dir+\"/losses.pkl\")\n print_list_tofile(errors, train_dir+\"/errors.pkl\")\n print_list_tofile(joint_errors, train_dir+\"/joint_errors.pkl\")","def train(self, tmp_dir):\n self.log_options()\n\n # Sync output of previous training run from cloud.\n train_uri = self.backend_opts.train_uri\n train_dir = get_local_path(train_uri, tmp_dir)\n make_dir(train_dir)\n sync_from_dir(train_uri, train_dir)\n\n # Get zip file for each group, and unzip them into chip_dir.\n chip_dir = join(tmp_dir, 'chips')\n make_dir(chip_dir)\n for zip_uri in list_paths(self.backend_opts.chip_uri, 'zip'):\n zip_path = download_if_needed(zip_uri, tmp_dir)\n with zipfile.ZipFile(zip_path, 'r') as zipf:\n zipf.extractall(chip_dir)\n\n # Setup data loader.\n def get_label_path(im_path):\n return Path(str(im_path.parent)[:-4] + '-labels') / im_path.name\n\n size = self.task_config.chip_size\n class_map = self.task_config.class_map\n classes = class_map.get_class_names()\n if 0 not in class_map.get_keys():\n classes = ['nodata'] + classes\n num_workers = 0 if self.train_opts.debug else 4\n\n data = (SegmentationItemList.from_folder(chip_dir)\n .split_by_folder(train='train-img', valid='val-img'))\n train_count = None\n if self.train_opts.train_count is not None:\n train_count = min(len(data.train), self.train_opts.train_count)\n elif self.train_opts.train_prop != 1.0:\n train_count = int(round(self.train_opts.train_prop * len(data.train)))\n train_items = data.train.items\n if train_count is not None:\n train_inds = np.random.permutation(np.arange(len(data.train)))[0:train_count]\n train_items = train_items[train_inds]\n items = np.concatenate([train_items, data.valid.items])\n\n data = (SegmentationItemList(items, chip_dir)\n .split_by_folder(train='train-img', valid='val-img')\n .label_from_func(get_label_path, classes=classes)\n .transform(get_transforms(flip_vert=self.train_opts.flip_vert),\n size=size, tfm_y=True)\n .databunch(bs=self.train_opts.batch_sz,\n num_workers=num_workers))\n print(data)\n\n # Setup learner.\n ignore_idx = 0\n metrics = [\n Precision(average='weighted', clas_idx=1, ignore_idx=ignore_idx),\n Recall(average='weighted', clas_idx=1, ignore_idx=ignore_idx),\n FBeta(average='weighted', clas_idx=1, beta=1, ignore_idx=ignore_idx)]\n model_arch = getattr(models, self.train_opts.model_arch)\n learn = unet_learner(\n data, model_arch, metrics=metrics, wd=self.train_opts.weight_decay,\n bottle=True, path=train_dir)\n learn.unfreeze()\n\n if self.train_opts.mixed_prec and torch.cuda.is_available():\n # This loss_scale works for Resnet 34 and 50. You might need to adjust this\n # for other models.\n learn = learn.to_fp16(loss_scale=256)\n\n # Setup callbacks and train model.\n model_path = get_local_path(self.backend_opts.model_uri, tmp_dir)\n\n pretrained_uri = self.backend_opts.pretrained_uri\n if pretrained_uri:\n print('Loading weights from pretrained_uri: {}'.format(\n pretrained_uri))\n pretrained_path = download_if_needed(pretrained_uri, tmp_dir)\n learn.model.load_state_dict(\n torch.load(pretrained_path, map_location=learn.data.device),\n strict=False)\n\n # Save every epoch so that resume functionality provided by\n # TrackEpochCallback will work.\n callbacks = [\n TrackEpochCallback(learn),\n MySaveModelCallback(learn, every='epoch'),\n MyCSVLogger(learn, filename='log'),\n ExportCallback(learn, model_path, monitor='f_beta'),\n SyncCallback(train_dir, self.backend_opts.train_uri,\n self.train_opts.sync_interval)\n ]\n\n oversample = self.train_opts.oversample\n if oversample:\n weights = get_oversampling_weights(\n data.train_ds, oversample['rare_class_ids'],\n oversample['rare_target_prop'])\n oversample_callback = OverSamplingCallback(learn, weights=weights)\n callbacks.append(oversample_callback)\n\n if self.train_opts.debug:\n if oversample:\n oversample_callback.on_train_begin()\n make_debug_chips(data, class_map, tmp_dir, train_uri)\n\n if self.train_opts.log_tensorboard:\n callbacks.append(TensorboardLogger(learn, 'run'))\n\n if self.train_opts.run_tensorboard:\n log.info('Starting tensorboard process')\n log_dir = join(train_dir, 'logs', 'run')\n tensorboard_process = Popen(\n ['tensorboard', '--logdir={}'.format(log_dir)])\n terminate_at_exit(tensorboard_process)\n\n lr = self.train_opts.lr\n num_epochs = self.train_opts.num_epochs\n if self.train_opts.one_cycle:\n if lr is None:\n learn.lr_find()\n learn.recorder.plot(suggestion=True, return_fig=True)\n lr = learn.recorder.min_grad_lr\n print('lr_find() found lr: {}'.format(lr))\n learn.fit_one_cycle(num_epochs, lr, callbacks=callbacks)\n else:\n learn.fit(num_epochs, lr, callbacks=callbacks)\n\n if self.train_opts.run_tensorboard:\n tensorboard_process.terminate()\n\n # Since model is exported every epoch, we need some other way to\n # show that training is finished.\n str_to_file('done!', self.backend_opts.train_done_uri)\n\n # Sync output to cloud.\n sync_to_dir(train_dir, self.backend_opts.train_uri)","def train(data, N, accuracy, Lout, Washout, Vin, Wres):\n print 'Training'\n args = [\n [data[i], N, accuracy, Washout, Vin, Wres] for i in xrange(Lout)\n ]\n pool = Pool(processes=Lout)\n clusters = pool.map(training, args)\n # TODO delete\n for i, cluster in enumerate(clusters):\n np.savetxt('dump_{0}'.format(i), cluster[1])\n return clusters","def atlas_clusters():\n pass","def test_main_split_cluster(self):\r\n\r\n command = \" \".join([\"denoiser.py\",\r\n \"-S\", \"--force\", '-c', '-n 2',\r\n \"-i\", \"%s/qiime/support_files/denoiser/TestData/denoiser_test_set.sff.txt\" % PROJECT_HOME,\r\n \"-f\", \"%s/qiime/support_files/denoiser/TestData/test_set_seqs.fna\" % PROJECT_HOME,\r\n \"-o\", self.test_dir])\r\n\r\n result = Popen(command, shell=True, universal_newlines=True,\r\n stdout=PIPE, stderr=STDOUT).stdout.read()\r\n self.result_dir = self.test_dir\r\n\r\n for subdir in [\"0/\", \"1/\"]:\r\n observed = \"\".join(\r\n list(open(self.result_dir + subdir + \"centroids.fasta\")))\r\n self.assertEqual(observed, expected_centroids[subdir])\r\n\r\n observed = \"\".join(\r\n list(open(self.result_dir + subdir + \"denoiser_mapping.txt\")))\r\n self.assertEqual(observed, expected_map_string_on_cluster[subdir])","def ensemble_001():\n n_centroids = 3000\n s = 15\n crop = 150\n n_patches = 400000\n rf_size = 5\n\n train_x_crop_scale = CropScaleImageTransformer(training=True,\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\n rf_size=rf_size,\n result_path='data/mdl_ensemble_001',\n n_iterations=20,\n n_jobs=-1,)\n\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\n patch_size=rf_size,\n n_jobs=-1)\n images = train_x_crop_scale.transform()\n patches = patch_extractor.transform(images)\n\n kmeans_generator.fit(patches)\n\n del patches\n gc.collect()\n\n X = kmeans_generator.transform(images, save_to_file='data/data_ensemble_001.npy', memmap=True)\n Y = classes.train_solutions.data\n\n # Unload some objects\n del images\n gc.collect()\n\n # Get the input for the RF so that we can split together\n sampler = SampleTransformer(training=True, steps=2, step_size=20, n_jobs=-1)\n pX = sampler.transform()\n\n # manual split of train and test\n train_x, test_x, ptrain_x, ptest_x, train_y, test_y = train_test_split(X, pX, Y, test_size=0.5)\n\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 500}, n_jobs=-1)\n wrapper.fit(train_x, train_y)\n kmeans_preds = wrapper.predict(test_x)\n\n pWrapper = ModelWrapper(RandomForestRegressor, {'n_estimators': 500, 'verbose': 3}, n_jobs=-1)\n pWrapper.fit(ptrain_x, train_y)\n pixel_preds = pWrapper.predict(ptest_x)\n\n logger.info('Kmeans')\n classes.colwise_rmse(kmeans_preds, test_y)\n classes.rmse(kmeans_preds, test_y)\n logger.info('Pixel RF')\n classes.colwise_rmse(pixel_preds, test_y)\n classes.rmse(pixel_preds, test_y)\n\n logger.info(\"Ensembling predictions\")\n etrain_x = np.hstack((wrapper.predict(train_x), pWrapper.predict(ptrain_x)))\n etest_x = np.hstack((kmeans_preds, pixel_preds))\n eWrapper = ModelWrapper(RandomForestRegressor, {'n_estimators': 500, 'verbose': 3}, n_jobs=-1)\n eWrapper.fit(etrain_x, train_y)\n ensemble_preds = eWrapper.predict(etest_x)\n classes.colwise_rmse(ensemble_preds, test_y)\n classes.rmse(ensemble_preds, test_y)","def generate_mnist_datasets(\n datapoints_per_task,\n K_list,\n cir_inner_loop_list, \n test_task_idx, \n val_task_idx,\n n_finetune_sets):\n\n # arbitrarily chosen, class-imbalance rate in outer and inner training loops\n cir_outer_loop = 0.5\n cir_inner_loop = 0.5\n # class-imbalance rate in the test sets of the test and validation tasks\n cir_test = 0.5\n # arbitrarily chosen, percentage of data that will be used in the inner training loop\n percent_data_inner_loop = 0.5\n\n percent_data_finetune_val = 0.8\n\n n_test_set = 4000\n\n test_task_idx, val_task_idx = test_task_idx, val_task_idx\n\n finetune_sets_per_K_cir = {}\n test_task_test_set, val_task = {}, {}\n \n\n train_task_list_inner, train_task_list_outer = [], []\n\n train_tasks_idxs = [i for i in range(0,10) if i not in [val_task_idx, test_task_idx]]\n\n base_path = '/home/USER/Documents'\n if (not (os.path.exists(base_path))):\n base_path = '/home/ubuntu/Projects'\n train_images, train_labels = loadlocal_mnist(\n images_path= base_path + '/MAML/raw_data/MNIST_data/train-images-idx3-ubyte', \n labels_path= base_path + '/MAML/raw_data/MNIST_data/train-labels-idx1-ubyte')\n\n test_images, test_labels = loadlocal_mnist(\n images_path= base_path + '/MAML/raw_data/MNIST_data/t10k-images-idx3-ubyte', \n labels_path= base_path + '/MAML/raw_data/MNIST_data/t10k-labels-idx1-ubyte')\n\n\n train_images, test_images = train_images.reshape((-1,28,28))/255.0, test_images.reshape((-1,28,28))/255.0\n images = np.concatenate((train_images, test_images))\n labels = np.concatenate((train_labels, test_labels))\n\n test_task_normal_indexes, val_task_normal_indexes = list(np.nonzero(labels == test_task_idx)[0]), list(np.nonzero(train_labels == val_task_idx)[0])\n test_task_X_normal, val_task_X_normal = images[test_task_normal_indexes],train_images[val_task_normal_indexes]\n test_task_Y_normal, val_task_Y_normal = np.zeros_like(labels[test_task_normal_indexes]), np.zeros_like(train_labels[val_task_normal_indexes])\n\n\n # val and test task have anomalies (samples of other numbers) that are not used for training\n # besides the two sets of anomalies (one for val task and one for test task are disjoint)\n test_task_anomalous_indexes = list(np.nonzero(test_labels[:5000] != test_task_idx)[0])\n val_task_anomalous_indexes= [index for index, element in enumerate(list(test_labels[5000:])) if element not in [val_task_idx, test_task_idx]]\n\n\n test_task_X_anomalous, val_task_X_anomalous = test_images[:5000][test_task_anomalous_indexes],test_images[5000:][val_task_anomalous_indexes]\n test_task_Y_anomalous, val_task_Y_anomalous = np.ones_like(test_labels[:5000][test_task_anomalous_indexes]), np.ones_like(test_labels[5000:][val_task_anomalous_indexes])\n\n test_task_X, val_task_X = np.concatenate((test_task_X_normal, test_task_X_anomalous)), np.concatenate((val_task_X_normal, val_task_X_anomalous))\n test_task_Y, val_task_Y = np.expand_dims(np.concatenate((test_task_Y_normal, test_task_Y_anomalous)),-1), np.expand_dims(np.concatenate((val_task_Y_normal, val_task_Y_anomalous)),-1)\n\n\n train_tasks_X_list, train_tasks_Y_list = [], []\n for task_idx in train_tasks_idxs:\n train_task_normal_indexes = list(np.nonzero(train_labels == task_idx)[0]) \n train_task_anomalous_indexes = [index for index, element in enumerate(list(train_labels)) if element not in [task_idx, val_task_idx, test_task_idx]]\n assert(len(np.nonzero(train_labels[train_task_anomalous_indexes] == val_task_idx)[0]) == 0)\n assert(len(np.nonzero(train_labels[train_task_anomalous_indexes] == test_task_idx)[0]) == 0)\n train_task_X_normal, train_task_X_anomalous = train_images[train_task_normal_indexes], train_images[train_task_anomalous_indexes]\n train_task_Y_normal, train_task_Y_anomalous = np.zeros_like(train_labels[train_task_normal_indexes]), np.ones_like(train_labels[train_task_anomalous_indexes])\n train_task_X, train_task_Y = np.concatenate((train_task_X_normal, train_task_X_anomalous)), np.concatenate((train_task_Y_normal, train_task_Y_anomalous))\n train_tasks_X_list.append(train_task_X)\n train_tasks_Y_list.append(np.expand_dims(train_task_Y,-1))\n\n\n\n # building test task sets of data\n normal_indexes, anomaly_indexes = list(np.nonzero(test_task_Y == 0)[0]), list(np.nonzero(test_task_Y == 1)[0])\n n_test_set_normal = int(n_test_set*cir_test)\n test_set_normal_indexes = random.sample(normal_indexes, n_test_set_normal)\n test_set_anomaly_indexes = random.sample(anomaly_indexes, n_test_set - n_test_set_normal)\n test_set_indexes = []\n test_set_indexes += test_set_normal_indexes\n test_set_indexes += test_set_anomaly_indexes\n\n test_task_test_set['test_X'], test_task_test_set['test_Y'] = test_task_X[test_set_indexes], test_task_Y[test_set_indexes]\n\n\n #shuffle\n s_test = np.arange(test_task_test_set['test_X'].shape[0])\n np.random.shuffle(s_test)\n test_task_test_set['test_X'], test_task_test_set['test_Y'] = test_task_test_set['test_X'][s_test], test_task_test_set['test_Y'][s_test]\n\n rest_normal_indexes = [index for index in normal_indexes if index not in test_set_normal_indexes]\n rest_anomaly_indexes = [index for index in anomaly_indexes if index not in test_set_anomaly_indexes]\n\n\n for K in K_list:\n finetune_sets_per_cir = {}\n for cir in cir_inner_loop_list:\n\n rest_normal_indexes = [index for index in normal_indexes if index not in test_set_normal_indexes]\n rest_anomaly_indexes = [index for index in anomaly_indexes if index not in test_set_anomaly_indexes]\n \n finetune_sets_list = []\n\n disjoint = False\n if(cir*K*n_finetune_sets<len(rest_normal_indexes)):\n disjoint = True\n\n n_finetune_normal = int(K*cir)\n n_finetune_anomaly = K - n_finetune_normal\n for i in range(n_finetune_sets):\n # if enough for disjoint do that\n # else sample randomly\n # store in a dict with keys cir_K\n finetune_normal_indexes = random.sample(rest_normal_indexes, n_finetune_normal)\n finetune_anomaly_indexes = random.sample(rest_anomaly_indexes, n_finetune_anomaly)\n finetune_indexes = []\n finetune_indexes += finetune_normal_indexes\n finetune_indexes += finetune_anomaly_indexes\n finetune_set = {}\n finetune_set['finetune_X'], finetune_set['finetune_Y'] = test_task_X[finetune_indexes], test_task_Y[finetune_indexes]\n\n #shuffle\n s_finetune = np.arange(finetune_set['finetune_X'].shape[0])\n np.random.shuffle(s_finetune)\n finetune_set['finetune_X'], finetune_set['finetune_Y'] = finetune_set['finetune_X'][s_finetune], finetune_set['finetune_Y'][s_finetune]\n\n finetune_sets_list.append(finetune_set)\n \n if(disjoint):\n rest_normal_indexes = [index for index in rest_normal_indexes if index not in finetune_normal_indexes]\n rest_anomaly_indexes = [index for index in rest_anomaly_indexes if index not in finetune_anomaly_indexes]\n\n finetune_sets_per_cir[str(cir)] = finetune_sets_list\n\n finetune_sets_per_K_cir[str(K)] = finetune_sets_per_cir\n\n\n #building val task sets of data\n normal_indexes, anomaly_indexes = list(np.nonzero(val_task_Y == 0)[0]), list(np.nonzero(val_task_Y == 1)[0])\n n_val_finetune = int(percent_data_finetune_val*datapoints_per_task)\n n_val_test_set = datapoints_per_task - n_val_finetune\n n_val_test_set_normal = int(n_val_test_set*cir_test)\n val_test_set_normal_indexes = random.sample(normal_indexes, n_val_test_set_normal)\n\n\n val_test_set_anomaly_indexes = random.sample(anomaly_indexes, n_val_test_set - n_val_test_set_normal)\n val_test_set_indexes = []\n val_test_set_indexes += val_test_set_normal_indexes\n val_test_set_indexes += val_test_set_anomaly_indexes\n val_task['test_X'], val_task['test_Y'] = val_task_X[val_test_set_indexes], val_task_Y[val_test_set_indexes]\n\n\n rest_normal_indexes = [index for index in normal_indexes if index not in val_test_set_normal_indexes]\n rest_anomaly_indexes = [index for index in anomaly_indexes if index not in val_test_set_anomaly_indexes]\n\n n_val_finetune_normal = int(n_val_finetune*cir_inner_loop)\n val_finetune_normal_indexes = random.sample(rest_normal_indexes, n_val_finetune_normal)\n val_finetune_anomaly_indexes = random.sample(rest_anomaly_indexes, n_val_finetune - n_val_finetune_normal)\n val_finetune_indexes = []\n val_finetune_indexes += val_finetune_normal_indexes\n val_finetune_indexes += val_finetune_anomaly_indexes\n\n val_task['finetune_X'], val_task['finetune_Y'] = val_task_X[val_finetune_indexes], val_task_Y[val_finetune_indexes]\n\n #shuffle\n s_val_finetune = np.arange(val_task['finetune_X'].shape[0])\n s_val_test = np.arange(val_task['test_X'].shape[0])\n np.random.shuffle(s_val_finetune)\n np.random.shuffle(s_val_test)\n\n val_task['finetune_X'], val_task['finetune_Y'] = val_task['finetune_X'][s_val_finetune], val_task['finetune_Y'][s_val_finetune]\n val_task['test_X'], val_task['test_Y'] = val_task['test_X'][s_val_test], val_task['test_Y'][s_val_test]\n\n\n\n # building sets of data of the training tasks\n for task_X, task_Y in zip(train_tasks_X_list, train_tasks_Y_list):\n normal_indexes, anomaly_indexes = list(np.nonzero(task_Y == 0)[0]), list(np.nonzero(task_Y == 1)[0])\n\n n_inner_loop = int(percent_data_inner_loop*datapoints_per_task)\n n_inner_loop_normal = int(n_inner_loop*cir_inner_loop)\n n_outer_loop = datapoints_per_task - n_inner_loop\n n_outer_loop_normal = int(n_outer_loop*cir_outer_loop)\n \n inner_loop_normal_indexes = random.sample(normal_indexes, n_inner_loop_normal)\n inner_loop_anomaly_indexes = random.sample(anomaly_indexes, n_inner_loop - n_inner_loop_normal)\n inner_loop_indexes = []\n inner_loop_indexes += inner_loop_normal_indexes\n inner_loop_indexes += inner_loop_anomaly_indexes\n\n train_task_inner_X, train_task_inner_Y = task_X[inner_loop_indexes], task_Y[inner_loop_indexes]\n\n rest_normal_indexes = [index for index in normal_indexes if index not in inner_loop_normal_indexes]\n rest_anomaly_indexes = [index for index in anomaly_indexes if index not in inner_loop_anomaly_indexes]\n\n \n outer_loop_normal_indexes = random.sample(rest_normal_indexes, n_outer_loop_normal)\n outer_loop_anomaly_indexes = random.sample(rest_anomaly_indexes, n_outer_loop - n_outer_loop_normal)\n outer_loop_indexes = []\n outer_loop_indexes += outer_loop_normal_indexes\n outer_loop_indexes += outer_loop_anomaly_indexes\n\n train_task_outer_X, train_task_outer_Y = task_X[outer_loop_indexes], task_Y[outer_loop_indexes]\n\n\n s_inner = np.arange(train_task_inner_X.shape[0])\n s_outer = np.arange(train_task_outer_X.shape[0])\n np.random.shuffle(s_inner)\n np.random.shuffle(s_outer)\n train_task_list_inner.append([train_task_inner_X[s_inner],train_task_inner_Y[s_inner]])\n train_task_list_outer.append([train_task_outer_X[s_outer],train_task_outer_Y[s_outer]])\n\n\n\n train_tasks_inner_X = np.stack([train_task_list_inner[i][0]\n for i in range(len(train_task_list_inner))], 0)\n train_tasks_inner_Y = np.stack([train_task_list_inner[i][1]\n for i in range(len(train_task_list_inner))], 0)\n train_tasks_outer_X = np.stack([train_task_list_outer[i][0]\n for i in range(len(train_task_list_outer))], 0)\n train_tasks_outer_Y = np.stack([train_task_list_outer[i][1]\n for i in range(len(train_task_list_outer))], 0)\n\n \n train_tasks = {'X_train_inner': train_tasks_inner_X,\n 'Y_train_inner': train_tasks_inner_Y,\n 'X_train_outer': train_tasks_outer_X,\n 'Y_train_outer': train_tasks_outer_Y\n }\n\n\n return train_tasks, val_task, test_task_test_set, finetune_sets_per_K_cir","def main():\n datasets = {}\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\"Processing datasets and fitting base models\"):\n logger.info(f\"processing dataset {dataset_name}\")\n clusters_path: Optional[str] = None\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \"_clusters.json\")\n train_pairs_path = None\n val_pairs_path = None\n test_pairs_path = None\n else:\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \"train_pairs.csv\")\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \"val_pairs.csv\")\n if not os.path.exists(val_pairs_path):\n val_pairs_path = None\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \"test_pairs.csv\")\n\n logger.info(f\"loading dataset {dataset_name}\")\n anddata = ANDData(\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_signatures.json\"),\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_papers.json\"),\n name=dataset_name,\n mode=\"train\",\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_specter.pickle\"),\n clusters=clusters_path,\n block_type=BLOCK_TYPE,\n train_pairs=train_pairs_path,\n val_pairs=val_pairs_path,\n test_pairs=test_pairs_path,\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\n val_pairs_size=N_VAL_TEST_SIZE,\n test_pairs_size=N_VAL_TEST_SIZE,\n preprocess=True,\n )\n\n logger.info(f\"featurizing {dataset_name}\")\n train, val, test = featurize(\n anddata,\n FEATURIZER_INFO,\n n_jobs=N_JOBS,\n use_cache=True,\n chunk_size=100,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\n nan_value=NAN_VALUE,\n )\n X_train, y_train, nameless_X_train = train\n X_val, y_val, nameless_X_val = val\n X_test, y_test, nameless_X_test = test\n\n dataset = {}\n dataset[\"anddata\"] = anddata\n dataset[\"X_train\"] = X_train\n dataset[\"y_train\"] = y_train\n dataset[\"X_val\"] = X_val\n dataset[\"y_val\"] = y_val\n dataset[\"X_test\"] = X_test\n dataset[\"y_test\"] = y_test\n dataset[\"nameless_X_train\"] = nameless_X_train\n dataset[\"nameless_X_val\"] = nameless_X_val\n dataset[\"nameless_X_test\"] = nameless_X_test\n dataset[\"name\"] = anddata.name\n datasets[dataset_name] = dataset\n\n anddatas = [\n datasets[dataset_name][\"anddata\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in PAIRWISE_ONLY_DATASETS\n ]\n\n X_train = np.vstack([datasets[dataset_name][\"X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n y_train = np.hstack([datasets[dataset_name][\"y_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n X_val = np.vstack(\n [datasets[dataset_name][\"X_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n y_val = np.hstack(\n [datasets[dataset_name][\"y_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n\n nameless_X_train = np.vstack([datasets[dataset_name][\"nameless_X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n nameless_X_val = np.vstack(\n [\n datasets[dataset_name][\"nameless_X_val\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in {\"augmented\"}\n ]\n )\n\n logger.info(\"fitting pairwise\")\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\n union_classifier.fit(X_train, y_train, X_val, y_val)\n\n nameless_union_classifier = None\n if USE_NAMELESS_MODEL:\n logger.info(\"nameless fitting pairwise for \" + str(SOURCE_DATASET_NAMES))\n nameless_union_classifier = PairwiseModeler(\n n_iter=N_ITER,\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\n )\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\n logger.info(\"nameless pairwise fit for \" + str(SOURCE_DATASET_NAMES))\n\n logger.info(\"fitting clusterer for\")\n union_clusterer = Clusterer(\n FEATURIZER_INFO,\n union_classifier.classifier,\n cluster_model=FastCluster(),\n search_space=search_space,\n n_jobs=N_JOBS,\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\n )\n union_clusterer.fit(anddatas)\n print(\n \"best clustering parameters:\",\n union_clusterer.best_params,\n )\n\n models = {}\n models[\"clusterer\"] = union_clusterer\n\n with open(\n f\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\",\n \"wb\",\n ) as _pickle_file:\n pickle.dump(models, _pickle_file)\n logger.info(\"Done.\")","def test_fit_predict() -> None:\n mapie = MapieClassifier()\n mapie.fit(X_toy, y_toy)\n mapie.predict(X_toy)","def load_data():\n global batch_size, num_batches\n # import data\n data, labels = original_clean()\n test_data = data[:test_size, :]\n test_labels = labels[:test_size]\n\n data = data[test_size:, :]\n\n # make landmarks with points with most neighbors\n N = NearestNeighbors(n_neighbors=k_start).fit(data).kneighbors_graph(data).todense()\n N = np.array(N)\n num_connections = N.sum(axis=0).argsort()[::-1] # see how many neighbors each point has\n top_landmarks_idxs = num_connections[:num_lm] # sort in descending order\n land_marks = data[top_landmarks_idxs, :] # pick the top ones\n data = np.delete(data, top_landmarks_idxs, axis=0) # delete the landmarks\n # find the nearest landmarks for the landmarks\n landmark_neighbors = NearestNeighbors(n_neighbors=k_lm).fit(land_marks).kneighbors_graph(land_marks).todense()\n # break data into batches, create empty holders\n batch_loader = np.zeros((num_batches, batch_size + num_lm, n))\n batch_graph = np.zeros((num_batches, batch_size + num_lm, batch_size + num_lm))\n # create the full neighborhood graph for each batch\n for i in range(num_batches):\n holder = data[batch_size * i: batch_size * (i + 1)]\n # find the nearest landmarks for the rest of the points\n holder_graph = NearestNeighbors(n_neighbors=k_other).fit(land_marks).kneighbors_graph(holder).todense()\n for j in range(batch_size): # copy over the holder graph\n for l in range(num_lm):\n if holder_graph[j, l] == 1:\n batch_graph[i, j, l + batch_size] = 1\n batch_graph[i, l + batch_size, j] = 1\n for j in range(num_lm): # copy over landmark neighbors\n for l in range(j, num_lm):\n if landmark_neighbors[j, l] == 1 and j != l:\n batch_graph[i, j + batch_size, l + batch_size] = 1\n batch_graph[i, l + batch_size, j + batch_size] = 1\n holder = np.concatenate((holder, land_marks))\n batch_loader[i] = holder\n batch_size += num_lm # adjust the batch size\n return batch_loader, data, batch_graph, landmark_neighbors, test_data, test_labels, land_marks","def run(self, data):\n\t\treduced_data = PCA(n_components=2).fit_transform(data)\n\n\t\t# Run the algorithm\n\t\tself.estimator.fit_transform(reduced_data)\n\n\t\t# Save all relevent properties\n\t\tself.input_data = data\n\t\tself.centroids = self.estimator.cluster_centers_\n\t\tself.node_positions = reduced_data\n\t\tself.labels = self.estimator.labels_\n\n\t\t# Enable visualising when debugging\n\t\t# self.visualize(reduced_data)","def train(self):\n for data_tier in self.data_tiers:\n fd = open(self.data_path + '/training_data_' + data_tier + '.json', 'r')\n self.preprocessed_data[data_tier] = json.load(fd)\n fd.close()\n tot = len(self.preprocessed_data[data_tier]['features'])\n p = int(math.ceil(tot*0.8))\n training_features = np.array(self.preprocessed_data[data_tier]['features'][:p])\n trend_training_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][:p])\n avg_training_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][:p])\n t1 = datetime.datetime.utcnow()\n self.clf_trend[data_tier].fit(training_features, trend_training_classifications)\n self.clf_avg[data_tier].fit(training_features, avg_training_classifications)\n t2 = datetime.datetime.utcnow()\n td = t2 - t1\n self.logger.info('Training %s for data tier %s took %s', self.name, data_tier, str(td))\n joblib.dump(self.clf_trend[data_tier], self.data_path + '/' + self.name + '_trend_' + data_tier + '.pkl')\n joblib.dump(self.clf_avg[data_tier], self.data_path + '/' + self.name + '_avg_' + data_tier + '.pkl')","def get_train_test_loaders(self, num_workers=2):\n print('Loading the image data...')\n \n train_path_info, test_path_info = self.get_train_test_info()\n\n train_transform = transforms.Compose([transforms.Resize((self.image_width, self.image_height)),\n transforms.RandomAffine(10,translate=(0.1,0.1)),\n transforms.ToTensor()])\n\n test_transform = transforms.Compose([transforms.Resize((self.image_width, self.image_height)),\n transforms.ToTensor()])\n\n trainset = PocovidDataset(train_path_info, transform = train_transform)\n testset = PocovidDataset(test_path_info, transform = test_transform)\n \n self.class_map = trainset.get_class_map()\n self.classes = [self.class_map[key] for key in sorted(self.class_map)]\n\n train_loader = torch.utils.data.DataLoader(trainset, num_workers=num_workers, shuffle=True,\n batch_size=self.batch_size, drop_last=True)\n\n test_loader = torch.utils.data.DataLoader(testset, num_workers=num_workers, shuffle=True,\n batch_size=self.batch_size)\n \n print('Image data is loaded with fold {} as the test data'.format(self.fold))\n print('Number of training images:', len(trainset))\n print('Number of testing images:', len(testset))\n print('*'*100)\n print('The classes are:', self.classes)\n print('*'*100)\n \n return train_loader, test_loader","def main(root_dir):\n # load annotations\n print('Loading instances and annotations...')\n captions_file = json.load(open('{}/annotations/captions_train2017.json'.format(root_dir), 'r'))\n categories_file = json.load(open('{}/annotations/instances_train2017.json'.format(root_dir), 'r'))\n print('Done.')\n\n # group categories by image\n image_categories = group_categories(categories_file)\n\n # group captions by image\n image_captions = group_captions(captions_file['annotations'])\n\n # get filename of each image\n image_file = get_filename(captions_file['images'])\n\n # assign each category an id.\n # we are not using the default ids given in the dataset because\n # the id ranges are not continuous.\n category_id, id_category = map_category_id(categories_file['categories'])\n \n # save parsed coco dataset\n save_dataset(image_categories, image_captions, image_file, category_id, id_category, root_dir)","def evaulate_clusters(self, pred_dict, model_dir):\n\t\tclustering_dict = {\"Topic\":[], \"Text\":[], \"Keywords\": []}\n\t\tfor cluster_num, sents_list in pred_dict.items():\n\t\t\tprint(\"\\n cluster number : \", cluster_num)\n\t\t\tprint(\"\\n number of sents : \", len(sents_list))\n\t\t\ttfidf_vec = TfidfVectorizer(use_idf=True, sublinear_tf=True, max_df=0.8, max_features=20, ngram_range=(1,5), min_df=1)\n\t\t\tX_tfidf = tfidf_vec.fit_transform(sents_list).toarray()\n\t\t\ttotal_tfidf = tfidf_vec.get_feature_names()\n\t\t\tfor sent in sents_list:\n\t\t\t\tclustering_dict[\"Topic\"].append(cluster_num)\n\t\t\t\tclustering_dict[\"Text\"].append(sent)\n\t\t\t\tclustering_dict[\"Keywords\"].append(\",\".join(total_tfidf))\n\t\t\"\"\" save the clusters to csv file \"\"\"\n\t\tdf_dominant_topic = defaultdict(list) \n\t\tdf_dominant_topic[\"Topic\"] = clustering_dict[\"Topic\"]\n\t\tdf_dominant_topic[\"Text\"] = clustering_dict[\"Text\"]\n\t\tdf_dominant_topic[\"Keywords\"] = clustering_dict[\"Keywords\"]\n\t\tdf_dominant_topic = pd.DataFrame(df_dominant_topic)\n\t\tdf_dominant_topic.to_csv(os.path.join(model_dir, \"cluster_sentence_topic_mapping.csv\"))\n\t\treturn df_dominant_topic","def main(source_dir, ksplit, out_dir, data_pattern, label_pattern, test_mode,\r\n numTopVars = [10, 50, 100, 500, 1000], compute_results=True):\r\n # Load input and labels.\r\n data, labels, data_file = load_data(source_dir, data_pattern)\r\n filename_base = path.splitext(path.basename(mname))[0]\r\n # Get classifiers and params.\r\n global NAMES\r\n if test_mode:\r\n NAMES = [\"Chance\", \"Nearest Neighbors\", \"Linear SVM\", \"Decision Tree\",\r\n \"Logistic Regression\", \"Naive Bayes\", \"LDA\"]\r\n ksplit = 3\r\n\r\n classifiers, params = make_classifiers(NAMES) # data.shape, ksplit)\r\n\r\n\r\n # Make the folds.\r\n logging.info(\"Making %d folds\" % ksplit)\r\n #kf = StratifiedKFold(labels, n_folds=ksplit)\r\n kf = KFold(labels.shape[0], n_folds=ksplit)\r\n\r\n # Extract the training and testing indices from the k-fold object,\r\n # which stores fold pairs of indices.\r\n fold_pairs = [(tr, ts) for (tr, ts) in kf]\r\n assert len(fold_pairs) == ksplit\r\n rank_per_fold = get_rank_per_fold(data, labels, fold_pairs,\r\n save_path=out_dir, parallel=True)\r\n #dhjelm: were we planning on using this dict?\r\n #score={}\r\n dscore=[]\r\n totalErrs = []\r\n if compute_results:\r\n for name in NAMES:\r\n mdl = classifiers[name]\r\n param = params[name]\r\n # get_score runs the classifier on each fold,\r\n # each subset of selected top variables and does a grid search for\r\n # classifier-specific parameters (selects the best)\r\n clf, allConfMats, allTotalErrs, allFittedClassifiers = \\\r\n get_score(data, labels, fold_pairs, name, mdl, param,\r\n numTopVars=numTopVars,\r\n rank_per_fold=rank_per_fold, parallel=True,\r\n rand_iter=-1)\r\n # save classifier object and results to file\r\n save_classifier_results(name, out_dir, allConfMats,\r\n allTotalErrs)\r\n save_classifier_object(clf, allFittedClassifiers, name, out_dir)\r\n # Append classifier results to list of all results\r\n dscore.append(allConfMats)\r\n totalErrs.append(allTotalErrs)\r\n '''\r\n First do some saving of total results\r\n '''\r\n save_combined_results(NAMES, dscore, totalErrs,\r\n numTopVars, out_dir, filename_base)\r\n\r\n plot_errors(NAMES, numTopVars, dscore, totalErrs,\r\n filename_base, out_dir,compute_results)\r\n\r\n logging.shutdown()","def main(version: str, data_root: str,\n split_name: str, output_dir: str, config_name: str = 'predict_2020_icra.json') -> None:\n\n print('Dataset dir:', data_root)\n nusc = NuScenes(version=version, dataroot=data_root)\n helper = PredictHelper(nusc)\n dataset = get_prediction_challenge_split(split_name, data_root)\n config = load_prediction_config(helper, config_name)\n\n oracle = PhysicsOracle(config.seconds, helper)\n cv_heading = ConstantVelocityHeading(config.seconds, helper)\n covernet = CoverNetBaseline(config.seconds, helper)\n\n cv_preds = []\n oracle_preds = []\n covernet_preds = []\n for idx, token in enumerate(tqdm(dataset)):\n # if idx > 20:\n # break\n\n cv_preds.append(cv_heading(token).serialize())\n oracle_preds.append(oracle(token).serialize())\n covernet_preds.append(covernet(token).serialize()) # The slowest one, by far\n\n json.dump(cv_preds, open(os.path.join(output_dir, \"cv_preds.json\"), \"w\"))\n json.dump(oracle_preds, open(os.path.join(output_dir, \"oracle_preds.json\"), \"w\"))\n json.dump(covernet_preds, open(os.path.join(output_dir, \"covernet_preds.json\"), \"w\"))","def kmeans_006():\n n_centroids_vals = [1000, 2000, 2500, 3000]\n scores = []\n\n for n_centroids in n_centroids_vals:\n s = 15\n crop = 150\n n_patches = 400000\n rf_size = 5\n logger.info(\"Training with n_centroids {}\".format(n_centroids))\n\n train_x_crop_scale = CropScaleImageTransformer(training=True,\n result_path='data/data_train_crop_{}_scale_{}.npy'.format(crop, s),\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n test_x_crop_scale = CropScaleImageTransformer(training=False,\n result_path='data/data_test_crop_{}_scale_{}.npy'.format(crop, s),\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\n rf_size=rf_size,\n result_path='data/mdl_kmeans_006_centroids_{}'.format(n_centroids),\n n_iterations=20,\n n_jobs=-1,)\n\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\n patch_size=rf_size,\n n_jobs=-1)\n images = train_x_crop_scale.transform()\n\n patches = patch_extractor.transform(images)\n\n kmeans_generator.fit(patches)\n\n del patches\n gc.collect()\n\n train_x = kmeans_generator.transform(images, save_to_file='data/data_kmeans_features_006_centroids_{}.npy'.format(n_centroids), memmap=True)\n train_y = classes.train_solutions.data\n # Unload some objects\n del images\n gc.collect()\n\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 250}, n_jobs=-1)\n wrapper.cross_validation(train_x, train_y, n_folds=2, parallel_estimator=True)\n\n score = (n_centroids, wrapper.cv_scores)\n logger.info(\"Scores: {}\".format(score))\n scores.append(score)\n\n del wrapper\n gc.collect()","def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\n self.merge_clusters([[6,98,99]])\n self.merge_clusters([[35,80]])\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\n self.merge_clusters([[76,98]])\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\n self.merge_clusters([[39,42]])\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\n self.merge_clusters([[70,101]])\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\n self.merge_clusters()\n return","def clustering(dataset, logger):\n all_instances = dataset\n meta_dataset = collections.defaultdict(list)\n for instance in all_instances:\n meta_dataset[instance['label']].append(instance['coordinate'])\n\n tasklist = map(\n lambda item, meta_dataset=meta_dataset, logger=logger: (\n item[0],\n clustering_by_label,\n (item[1], item[0], meta_dataset, logger)), meta_dataset.items())\n\n # pool = multiprocessing.pool.Pool(PROCESS_COUNT)\n # clusters = dict(pool.map(map_generate_tuple, tasklist))\n clusters = dict(map(map_generate_tuple, tasklist))\n # pool.close()\n # pool.join()\n\n return clusters","def _generate_datasets(self):\n\n degrade_test = False\n if self._opts['degrade_step'] == 'test':\n degrade_test = True\n\n use_trainset_for_tests = UseTrainForTest.IDENTICAL # can be different in few shot workflow\n\n train_dataset, test_dataset = self._gen_datasets_with_options(self._opts['train_classes'],\n self._opts['test_classes'],\n is_superclass=self._opts['superclass'],\n class_proportion=self._opts['class_proportion'],\n degrade_test=degrade_test,\n degrade_type=self._opts['degrade_type'], # only relevant if degrade_test = True\n degrade_val=self._opts['min_val'], # only relevant if degrade_test = True\n recurse_train=self._is_train_recursive(),\n recurse_test=self._is_inference_recursive(),\n num_batch_repeats=self._opts['num_repeats'],\n recurse_iterations=self._opts['recurse_iterations'],\n evaluate_step=self._opts['evaluate'],\n use_trainset_for_tests=use_trainset_for_tests,\n invert_images=self._opts['invert_images'],\n min_val=self._opts['min_val'])\n return train_dataset, test_dataset","def pre_process_for_classifying(block, scale=(0, 1, 1024)):\n print('\\nClassifying Data')\n lorentz_arrays_list = block[1]\n data_arrays_list = block[2]\n block_size = len(lorentz_arrays_list)\n cluster_labels = np.empty((0, 1))\n cluster_data = np.empty((0, scale[2]))\n pool = mp.Pool(mp.cpu_count())\n results = pool.map(\n classify, [\n (i, lorentz_arrays_list, data_arrays_list) for i in\n range(block_size)])\n pool.close()\n for result in results:\n cluster_labels = np.append(cluster_labels, result[0], axis=0)\n cluster_data = np.append(cluster_data, result[1], axis=0)\n return cluster_labels, cluster_data","def test_main_split_cluster(self):\n \n command = \" \".join( [\"%s/denoiser.py\" % get_qiime_scripts_dir(),\n \"-S\", \"--force\", '-c', '-n 2',\n \"-i\", \"%s/qiime/support_files/denoiser/TestData/denoiser_test_set.sff.txt\" % PROJECT_HOME,\n \"-f\", \"%s/qiime/support_files/denoiser/TestData/test_set_seqs.fna\" % PROJECT_HOME,\n \"-o\", self.test_dir] )\n\n result = Popen(command,shell=True,universal_newlines=True,\\\n stdout=PIPE,stderr=STDOUT).stdout.read()\n self.result_dir = self.test_dir\n\n for subdir in [\"0/\",\"1/\"]:\n observed = \"\".join(list(open(self.result_dir+ subdir+\"centroids.fasta\")))\n self.assertEqual(observed, expected_centroids[subdir])\n\n observed = \"\".join(list(open(self.result_dir+ subdir+\"denoiser_mapping.txt\")))\n self.assertEqual(observed, expected_map_string_on_cluster[subdir])","def single_supervise_evaluation(clf, x_train, y_train, x_test, y_test, r1_norm_step=0.05, r2_norm_step=0.05):\n # fit model\n clf.fit(x_train, y_train)\n\n # calc accuracy\n y_train_pred = clf.predict(x_train)\n accuracy_train = balanced_accuracy_score(y_true=y_train, y_pred=y_train_pred)\n print(f\"Balanced accuracy on the training set: {accuracy_train:.3f}\")\n y_test_pred = clf.predict(x_test)\n accuracy_test = balanced_accuracy_score(y_true=y_test, y_pred=y_test_pred)\n print(f\"Balanced accuracy on the hold-out set: {accuracy_test:.3f}\")\n\n # get confusion matrix\n y_pred = clf.predict(x_test)\n cmat = confusion_matrix(y_test, y_pred)\n\n # normalize confusion matrix\n r1_cmat = _r1_normalize(cmat)\n r2_cmat = _r2_normalize(cmat)\n m1 = np.max(r1_cmat)\n if np.isnan(m1):\n m1 = 1.0\n m2 = np.max(r2_cmat)\n\n cluster_map = {}\n while (len(cluster_map) == 0) and (m1 > 0) and (m2 > 0):\n m1 -= r1_norm_step\n m2 -= r2_norm_step\n\n # final binary matrix to calculate which clusters need to be merged\n judge = np.maximum.reduce([(r1_cmat > m1), (r2_cmat > m2)])\n if judge.sum() > 0:\n rows, cols = np.where(judge)\n edges = zip(rows.tolist(), cols.tolist())\n g = nx.Graph()\n g.add_edges_from(edges)\n for comp in nx.connected_components(g):\n to_label = comp.pop()\n for remain in comp:\n cluster_map[remain] = to_label\n return clf, accuracy_test, cluster_map, cmat, r1_cmat, r2_cmat","def _split_train_tst(self):\n num_samples = self.Y.shape[0]\n mapper_file = self.checkpointer.get_mapper_file_location()\n if not self.checkpointer.is_mapper_checkpointed():\n print 'No mapper checkpoint found. Fresh loading in progress ...'\n # Now shuffle the data\n sample_id = range(num_samples)\n random.shuffle(sample_id)\n print 'Dumping the mapper shuffle for reuse.'\n Pickle.dump(sample_id, open(mapper_file, 'wb'))\n print 'Dump complete. Moving Forward...'\n else:\n print 'Mapper Checkpoint found... Reading from mapper dump'\n sample_id = Pickle.load(open(mapper_file, 'rb'))\n print 'Mapping unpickling complete.. Moving forward...'\n\n self.X_fwd = self.X_fwd[sample_id]\n self.X_bwd = self.X_bwd[sample_id]\n self.Y = self.Y[sample_id]\n # Now divide the data into test ans train set\n test_fraction = 0.01\n self.test_size = int(test_fraction * num_samples)\n self.train_size = num_samples - self.test_size\n # Forward review\n self.X_trn_fwd = self.X_fwd[0:self.train_size]\n self.X_tst_fwd = self.X_fwd[self.train_size:num_samples]\n # Backward review\n self.X_trn_bwd = self.X_bwd[0:self.train_size]\n self.X_tst_bwd = self.X_bwd[self.train_size:num_samples]\n # Summary\n self.Y_trn = self.Y[0:self.train_size]\n self.Y_tst = self.Y[self.train_size:num_samples]","def load_kiba_dataset():\n trainn_fold = json.load(\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'folds', 'train_fold_setting1.txt')))\n train_fold = []\n for e in zip(*trainn_fold):\n for ee in e:\n train_fold.extend(ee)\n #train_fold = [ee for e in trainn_fold for ee in e]\n test_fold = json.load(\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'folds', 'test_fold_setting1.txt')))\n ligands = json.load(\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'ligands_can.txt')),\n object_pairs_hook=OrderedDict)\n proteins = json.load(\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'proteins.txt')),\n object_pairs_hook=OrderedDict)\n \n affinity = pickle.load(open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'Y'), \n 'rb'), encoding='latin1')\n smiles_lst, protein_lst = [], []\n\n for k in ligands.keys():\n smiles = ligands[k]\n smiles_lst.append(smiles)\n for k in proteins.keys():\n protein_lst.append(proteins[k])\n\n affinity = np.asarray(affinity)\n \n os.makedirs(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'processed'), exist_ok=True)\n train_test_dataset = []\n for split in ['train', 'test']:\n split_dir = os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'processed', split)\n os.makedirs(split_dir, exist_ok=True)\n fold = train_fold if split == 'train' else test_fold\n rows, cols = np.where(np.isnan(affinity) == False)\n rows, cols = rows[fold], cols[fold]\n \n data_lst = [[] for _ in range(1)]\n for idx in range(len(rows)):\n data = {}\n data['smiles'] = smiles_lst[rows[idx]]\n data['protein'] = protein_lst[cols[idx]]\n af = affinity[rows[idx], cols[idx]]\n data['aff'] = af\n\n data_lst[idx % 1].append(data)\n random.shuffle(data_lst)\n train_test_dataset.append(data_lst[0])\n return train_test_dataset","def predictionTime(encoder,data_):\n\n #initialize algorithm\n kmean = KMeansClustering()\n model = SpectralClustering(n_clusters=5, affinity='nearest_neighbors',\n assign_labels='kmeans')\n\n\n for i in range(20):\n iterate = 5000*(i+1)\n data = data_[0:iterate,:]\n print(data.shape)\n enc_output = encoder.predict(data)\n kmean.fit(enc_output)\n print(\"Time predicting \"+str(5000*(i+1))+\" images\")\n print(\"KMEAN\")\n start = time.time()\n enc_output = encoder.predict(data)\n pred = kmean.predict(enc_output)\n end = time.time()\n print(end - start)\n\n\n print(\"SC\")\n start = time.time()\n enc_output = encoder.predict(data)\n pred = model.fit_predict(enc_output)\n end = time.time()\n print(end - start)","def train(args):\n dataset = args.dataset\n ae_mode = args.mode\n train_input, train_labels = load_data(dataset, mode=ae_mode)\n num_clusters = len(np.unique(train_labels))\n data_initialization = dataset_parameters[dataset]['data_initialization']\n with_attention = args.attention\n interval_updation = dataset_parameters[dataset][\n 'interval_updation'] if args.interval_updation is None else args.interval_updation\n temperature = 1.\n auto_encoder_optimizer = SGD(lr=args.learning_rate, momentum=0.9)\n\n if ae_mode == \"ae\":\n if train_input.shape[-1] > 1024:\n print(\"Shape of training data before transformation: {}\".format(train_input.shape))\n train_input = PCA(n_components=728).fit_transform(train_input)\n print(\"Shape of training data after transformation: {}\".format(train_input.shape))\n\n dimensions = [train_input.shape[-1], 500, 500, 2000,\n len(np.unique(train_labels))] if args.include_layer is None else [train_input.shape[-1], 500, 500,\n 2000, args.include_layer,\n len(np.unique(train_labels))]\n else:\n dimensions = [32, 64]\n\n model = ClusteringNetwork(dimensions=dimensions, temperature=temperature, data_initialization=data_initialization,\n num_clusters=num_clusters, output_directory=args.output_directory, dataset=dataset,\n ae_mode=ae_mode, with_attention=with_attention)\n\n if args.ae_weights:\n model.auto_encoder.load_weights(args.ae_weights)\n else:\n model.train_auto_encoder(data=train_input, labels=train_labels, train_steps=args.ae_iterations,\n batch_size=args.batch_size, output_directory=args.output_directory,\n optimizer=auto_encoder_optimizer)\n\n model.model.summary()\n\n start_time = time.time()\n\n model.compile(optimizer=SGD(0.01, 0.9), loss='kld')\n p_labels = model.train_cluster_network(data=train_input, labels=train_labels,\n tolerance_threshold=args.tolerance_threshold,\n iterations=args.cluster_iterations, batch_size=args.batch_size,\n interval_updation=interval_updation)\n\n stop_time = time.time()\n print(\"Accuracy: {}\".format(EvaluatePerformance.accuracy(train_labels, p_labels)))\n print(\"Time taken to finish the training: {}s\".format((stop_time - start_time)))","def run(input_dir, output_dir, team_name=\"OrganizersTeam\", predict_window=12):\n\n models_dir = os.path.join(output_dir, \"models\")\n plots_dir = os.path.join(output_dir, \"plots\")\n sub_dir = os.path.join(output_dir, \"submissions\")\n submission_file_name_fmt = \"{}_{}.csv\"\n\n make_directory_tree([\"models\", \"plots\", \"submissions\"], output_dir)\n\n datasets = get_datasets(input_dir)\n\n print(\"Will train a total of {} models\".format(len(datasets) * 3))\n\n # create a scores table to keep MAE for each location:model pair\n scores = pd.DataFrame(columns=[\"Location\", \"Model\", \"MAE\"])\n\n for dataset in datasets:\n # load the dataset\n df = read_csv_series(os.path.join(input_dir, dataset))\n loc = dataset.split(\".\")[0]\n\n # shift PM10 for `predict_window` hours ahead\n df[\"PM10\"] = df[\"PM10\"].shift(-predict_window)\n\n # split dataset into train, test and evaluation by dates\n # additionally, leave the last 48 hours for final evaluation\n train_len = int(len(df) * 0.65) - (2 * predict_window)\n test_len = int(len(df) * 0.25) - (2 * predict_window)\n eval_len = len(df) - train_len - test_len - (2 * predict_window)\n train, test, evaluation = df[:train_len], df[train_len:train_len +\n test_len], df[train_len+test_len:train_len+test_len+eval_len]\n final_eval = df[-(2 * predict_window):-predict_window].copy()\n\n # initialize models\n models = [\n (\"Linear Regression\", LinearRegression()),\n (\"Extra Trees Regressor\", ExtraTreesRegressor(n_estimators=100, n_jobs=4, min_samples_split=25,\n min_samples_leaf=35, random_state=0)),\n (\"XGBoost Trees Regression\", xgb.XGBRegressor(objective=\"reg:linear\", random_state=0))\n ]\n\n mae_min = 1e10\n yhat_sub = []\n\n for model in models:\n # get predictions and MAE\n yhat, mae = train_and_evaluate(\"{} - {}\".format(loc,model[0]),model[1],train,test,evaluation,final_eval, output_dir)\n\n # save the score (MAE) for the model\n scores = scores.append(\n {\"Location\": loc, \"Model\": model[0], \"MAE\": mae}, ignore_index=True)\n\n # save the better predictions to `yhat_sub`\n if mae < mae_min:\n mae_min = mae\n yhat_sub = yhat\n\n sub_df = pd.DataFrame(yhat_sub, columns=[\"PM10\"])\n sub_df.to_csv(os.path.join(sub_dir, submission_file_name_fmt.format(team_name, loc)))\n\n scores.to_csv(os.path.join(output_dir, \"scores.csv\"))\n\n print(\"Done\")\n print(\"Saved models can be found at {}\".format(models_dir))\n print(\"Plots can be found at {}\".format(plots_dir))\n print(\"Submissions can be found at {}\".format(sub_dir))\n\n return scores","def train():\n # YOUR TRAINING CODE GOES HERE","def train_test_model_batch():\n train=learning.Train_kmer_clf()\n train.run()","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(x_train, y_train, x_test, y_test):\n\n print(\" Nearest centroid : \", end='')\n run(x_train, y_train, x_test, y_test, NearestCentroid())\n print(\" k-NN classifier (k=3) : \", end='')\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=3))\n print(\" k-NN classifier (k=7) : \", end='')\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=7))\n print(\" Naive Bayes (Gaussian) : \", end='')\n run(x_train, y_train, x_test, y_test, GaussianNB())\n print(\" Random Forest (trees= 5) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=5))\n print(\" Random Forest (trees= 50) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=50))\n print(\" Random Forest (trees=500) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=500))\n print(\" Random Forest (trees=1000): \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=1000))\n print(\" LinearSVM (C=0.01) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.01))\n print(\" LinearSVM (C=0.1) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.1))\n print(\" LinearSVM (C=1.0) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=1.0))\n print(\" LinearSVM (C=10.0) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=10.0))","def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\n distribute_training=False):\n train_set = np.array(train_set)\n test_set = np.array(test_set)\n\n print(\"The shape of training set before dimension reduction is {0}\".format(train_set.shape))\n print(\"The shape of test set before dimension reduction is {0}\".format(test_set.shape))\n print('Use distribute training ? >> {0}'.format(distribute_training))\n reg = linear_model.BayesianRidge()\n\n if dimension_reduce:\n pca = PCA(n_components=128)\n train_set = pca.fit_transform(train_set)\n test_set = pca.fit_transform(test_set)\n\n print(\"The shape of training set after dimension reduction is {0}\".format(train_set.shape))\n print(\"The shape of test set after dimension reduction is {0}\".format(test_set.shape))\n\n if not distribute_training:\n reg.fit(train_set, train_label)\n else:\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\n train_label), da.array(test_label)\n reg.fit(train_set, train_label)\n\n predicted_label = reg.predict(test_set)\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\n\n mkdirs_if_not_exist('./model')\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\n print('The regression model has been persisted...')\n\n mkdirs_if_not_exist('./result')\n\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\n\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\n df.to_csv('./result/%s.csv' % data_name, index=False)\n print('The result csv file has been generated...')","def train(self):\n return","def train(self, input_vects):\n \n #Training iterations\n for iter_no in range(self._n_iterations):\n print(iter_no)\n if (iter_no % 1==0) & (iter_no>0) :\n \n self.map_plot(iter_no)\n centroid_grid = [[] for i in range(self._m)]\n self._weightages = list(self._sess.run(self._weightage_vects))\n self._locations = list(self._sess.run(self._location_vects))\n \n for i, loc in enumerate(self._locations):\n centroid_grid[loc[0]].append(self._weightages[i])\n self._centroid_grid = centroid_grid \n \n #Train with each vector one by one\n for input_vect in input_vects:\n self._sess.run(self._training_op,\n feed_dict={self._vect_input: input_vect,\n self._iter_input: iter_no})\n print(iter_no)\n self.map_plot(iter_no) \n self._trained = True\n gif.build_gif(imgs, saveto='exoplaneta005s6 .gif')","def fit(self, X, epochs=50):\n self.clusters = [[] for _ in range(self.k)]\n for i in range(X.shape[0]):\n index = random.randint(0, self.k - 1)\n self.clusters[index].append(X[i])\n self.sample_in_cluster.append(index)\n for e in range(epochs):\n #beregn nye centers\n self.estimate_centers()\n #nullstill clusters\n self.reset_clusters()\n #legg til alle punkter på nytt i clusters\n self.make_clusters(X)\n if self.changed == False:\n break","def main():\n dataset_config = DatasetBuilder.copy_config(\n DatasetBuilder.KITTI_TRAIN)\n dataset_config.num_clusters[0] = 1\n dataset = DatasetBuilder.build_kitti_dataset(dataset_config)\n\n label_cluster_utils = LabelClusterUtils(dataset)\n clusters, _ = label_cluster_utils.get_clusters()\n\n # Options\n img_idx = 1\n # fake_clusters = np.array([[5, 4, 3], [6, 5, 4]])\n # fake_clusters = np.array([[3, 3, 3], [4, 4, 4]])\n\n fake_clusters = np.array([[4, 2, 3]])\n fake_anchor_stride = [5.0, 5.0]\n ground_plane = [0, -1, 0, 1.72]\n\n anchor_3d_generator = grid_anchor_3d_generator.GridAnchor3dGenerator()\n\n area_extents = np.array([[-40, 40], [-5, 5], [0, 70]])\n\n # Generate anchors for cars only\n start_time = time.time()\n anchor_boxes_3d = anchor_3d_generator.generate(\n area_3d=dataset.kitti_utils.area_extents,\n anchor_3d_sizes=fake_clusters,\n anchor_stride=fake_anchor_stride,\n ground_plane=ground_plane)\n all_anchors = box_3d_encoder.box_3d_to_anchor(anchor_boxes_3d)\n end_time = time.time()\n print(\"Anchors generated in {} s\".format(end_time - start_time))\n\n # Project into bev\n bev_boxes, bev_normalized_boxes = \\\n anchor_projector.project_to_bev(all_anchors, area_extents[[0, 2]])\n\n bev_fig, (bev_axes, bev_normalized_axes) = \\\n plt.subplots(1, 2, figsize=(16, 7))\n bev_axes.set_xlim(0, 80)\n bev_axes.set_ylim(70, 0)\n bev_normalized_axes.set_xlim(0, 1.0)\n bev_normalized_axes.set_ylim(1, 0.0)\n\n plt.show(block=False)\n\n for box in bev_boxes:\n box_w = box[2] - box[0]\n box_h = box[3] - box[1]\n\n rect = patches.Rectangle((box[0], box[1]),\n box_w, box_h,\n linewidth=2,\n edgecolor='b',\n facecolor='none')\n\n bev_axes.add_patch(rect)\n\n for normalized_box in bev_normalized_boxes:\n box_w = normalized_box[2] - normalized_box[0]\n box_h = normalized_box[3] - normalized_box[1]\n\n rect = patches.Rectangle((normalized_box[0], normalized_box[1]),\n box_w, box_h,\n linewidth=2,\n edgecolor='b',\n facecolor='none')\n\n bev_normalized_axes.add_patch(rect)\n\n rgb_fig, rgb_2d_axes, rgb_3d_axes = \\\n vis_utils.visualization(dataset.rgb_image_dir, img_idx)\n plt.show(block=False)\n\n image_path = dataset.get_rgb_image_path(dataset.sample_names[img_idx])\n image_shape = np.array(Image.open(image_path)).shape\n\n stereo_calib_p2 = calib_utils.read_calibration(dataset.calib_dir,\n img_idx).p2\n\n start_time = time.time()\n rgb_boxes, rgb_normalized_boxes = \\\n anchor_projector.project_to_image_space(all_anchors,\n stereo_calib_p2,\n image_shape)\n end_time = time.time()\n print(\"Anchors projected in {} s\".format(end_time - start_time))\n\n # Read the stereo calibration matrix for visualization\n stereo_calib = calib_utils.read_calibration(dataset.calib_dir, 0)\n p = stereo_calib.p2\n\n # Overlay boxes on images\n anchor_objects = []\n for anchor_idx in range(len(anchor_boxes_3d)):\n anchor_box_3d = anchor_boxes_3d[anchor_idx]\n\n obj_label = box_3d_encoder.box_3d_to_object_label(anchor_box_3d)\n\n # Append to a list for visualization in VTK later\n anchor_objects.append(obj_label)\n\n # Draw 3D boxes\n vis_utils.draw_box_3d(rgb_3d_axes, obj_label, p)\n\n # Draw 2D boxes\n rgb_box_2d = rgb_boxes[anchor_idx]\n\n box_x1 = rgb_box_2d[0]\n box_y1 = rgb_box_2d[1]\n box_w = rgb_box_2d[2] - box_x1\n box_h = rgb_box_2d[3] - box_y1\n\n rect = patches.Rectangle((box_x1, box_y1),\n box_w, box_h,\n linewidth=2,\n edgecolor='b',\n facecolor='none')\n\n rgb_2d_axes.add_patch(rect)\n\n if anchor_idx % 32 == 0:\n rgb_fig.canvas.draw()\n\n plt.show(block=False)\n\n # Create VtkGroundPlane for ground plane visualization\n vtk_ground_plane = VtkGroundPlane()\n vtk_ground_plane.set_plane(ground_plane, area_extents[[0, 2]])\n\n # Create VtkAxes\n axes = vtk.vtkAxesActor()\n axes.SetTotalLength(5, 5, 5)\n\n # Create VtkBoxes for boxes\n vtk_boxes = VtkBoxes()\n vtk_boxes.set_objects(anchor_objects, vtk_boxes.COLOUR_SCHEME_KITTI)\n\n # Create Voxel Grid Renderer in bottom half\n vtk_renderer = vtk.vtkRenderer()\n vtk_renderer.AddActor(vtk_boxes.vtk_actor)\n vtk_renderer.AddActor(vtk_ground_plane.vtk_actor)\n vtk_renderer.AddActor(axes)\n vtk_renderer.SetBackground(0.2, 0.3, 0.4)\n\n # Setup Camera\n current_cam = vtk_renderer.GetActiveCamera()\n current_cam.Pitch(170.0)\n current_cam.Roll(180.0)\n\n # Zooms out to fit all points on screen\n vtk_renderer.ResetCamera()\n\n # Zoom in slightly\n current_cam.Zoom(2.5)\n\n # Reset the clipping range to show all points\n vtk_renderer.ResetCameraClippingRange()\n\n # Setup Render Window\n vtk_render_window = vtk.vtkRenderWindow()\n vtk_render_window.SetWindowName(\"Anchors\")\n vtk_render_window.SetSize(900, 500)\n vtk_render_window.AddRenderer(vtk_renderer)\n\n # Setup custom interactor style, which handles mouse and key events\n vtk_render_window_interactor = vtk.vtkRenderWindowInteractor()\n vtk_render_window_interactor.SetRenderWindow(vtk_render_window)\n\n vtk_render_window_interactor.SetInteractorStyle(\n vtk.vtkInteractorStyleTrackballCamera())\n\n # Render in VTK\n vtk_render_window.Render()\n vtk_render_window_interactor.Start() # Blocking\n # vtk_render_window_interactor.Initialize() # Non-Blocking","def createTrainTestSets():\n tweets = open(noDuplicatesFilename, 'r').read().splitlines()\n name_mapping = loadNameMapping()\n holdoutLocations = [u'Frederiksberg, Danmark', u'T\\xe5rnby, Danmark', u'Kolding, Danmark', u'T\\xe4by, Sverige', u'Kungsbacka, Sverige', u'Kristianstad, Sverige', u'Bod\\xf8, Norge', u'Kvinnherad, Norge', u'Ullensaker, Norge']\n testSetLocation = []\n rest = []\n for tweet in tweets:\n if stringToTweet(tweet).getFullName() in holdoutLocations:\n testSetLocation.append(tweet)\n else:\n rest.append(tweet)\n tweets = rest\n testIndex = int(round(len(tweets) * (1 - test_set_ratio)))\n random.seed(1)\n random.shuffle(tweets)\n trainSet = tweets[:testIndex]\n testSet = tweets[testIndex:]\n open(trainSetFilename, 'w').write('\\n'.join(trainSet))\n open(testSetNormalFilename, 'w').write('\\n'.join(testSet))\n open(testSetLocationFilename, 'w').write('\\n'.join(testSetLocation))\n print \"Wrote %d tweets to train set\" % len(trainSet)\n print \"Wrote %d tweets to normal test set\" % len(testSet)\n print \"Wrote %d tweets to location test set\" % len(testSetLocation)","def predict_all():\n\n # need train dir to list category names\n cfg = configparser.ConfigParser()\n cfg.read(sys.argv[1])\n base = os.environ['DATA_ROOT']\n eval_type = cfg.get('args', 'eval_type')\n train_xml_dir = os.path.join(base, cfg.get('data', 'train_xml_dir'))\n\n if eval_type == 'sparse':\n predict_sparse(train_xml_dir)\n else:\n predict_dense(train_xml_dir)","def get_dataset(image_folder: str, img_size: str, self_training: bool = False, no_augmentation: bool = False, valid_dir: str = None):\n \n primary_img_paths = glob.glob(image_folder + os.sep + \"*/*.jpg\")\n primary_img_paths += glob.glob(image_folder + os.sep + \"*/*.png\")\n if valid_dir is None:\n \n y = [os.path.basename(os.path.dirname(path)) for path in primary_img_paths]\n\n train_img_paths, test_img_paths, _, _ = train_test_split(primary_img_paths, y, \n stratify = y, \n test_size = 1 - TRAIN_RATIO)\n #primary_img_paths = undersample(primary_img_paths)\n \n SIZE = len(primary_img_paths)\n shuffle(primary_img_paths)\n \n TRAIN = int(SIZE*TRAIN_RATIO)\n TEST = SIZE - TRAIN\n \n if self_training:\n print(\"Using predictions on unlabelled data in train set!\".rjust(70, \"#\").ljust(90, \"#\"))\n secondary_img_path = glob.glob(\"data/secondary_dataset\" + os.sep + \"*/*.jpg\")\n shuffle(secondary_img_path)\n\n #train_img_paths = primary_img_paths[:TRAIN] + secondary_img_path\n train_img_paths += secondary_img_path\n #else:\n # train_img_paths = primary_img_paths[:TRAIN]\n \n #test_img_paths = primary_img_paths[TRAIN:]\n TRAIN = len(train_img_paths) # For display purpose\n \n if self_training:\n TRAIN += len(secondary_img_path) # For display purpose\n else:\n train_img_paths = glob.glob(image_folder + os.sep + \"*/*.jpg\") + glob.glob(image_folder + os.sep + \"*/*.png\")\n test_img_paths = glob.glob(valid_dir + os.sep + \"*/*.jpg\") + glob.glob(valid_dir + os.sep + \"*/*.png\")\n TRAIN = len(train_img_paths)\n TEST = len(test_img_paths)\n\n label_names = os.listdir(image_folder)\n if no_augmentation:\n train_dataset = CustomImageDataset(train_img_paths, get_test_transforms(img_size), label_names)\n else:\n train_dataset = CustomImageDataset(train_img_paths, get_train_transforms(img_size), label_names)\n test_dataset = CustomImageDataset(test_img_paths, get_test_transforms(img_size), label_names)\n class_to_idx = train_dataset.class_to_idx\n \n # Create DataLoader for training\n train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE)\n \n \n \n weights = get_class_weights(train_img_paths, class_to_idx, label_names) # For balancing dataset using inverse-frequency\n \n\n print(f\"Number of classes {NUM_CLASSES}, Train size: {TRAIN} images, Test size: {TEST} images, Batch size: {BATCH_SIZE}, Image size: {img_size}x{img_size}\")\n return train_dataloader, test_dataloader, class_to_idx, weights","def process_dataset(self):\n\n logger.info('\\n')\n logger.info('=' * 40)\n logger.info('=\\t DeepRank Data Set')\n logger.info('=')\n logger.info('=\\t Training data')\n for f in self.train_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n if self.valid_database:\n logger.info('=\\t Validation data')\n for f in self.valid_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n if self.test_database:\n logger.info('=\\t Test data')\n for f in self.test_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n logger.info('=' * 40 + '\\n')\n sys.stdout.flush()\n\n # check if the files are ok\n self.check_hdf5_files(self.train_database)\n\n if self.valid_database:\n self.valid_database = self.check_hdf5_files(\n self.valid_database)\n\n if self.test_database:\n self.test_database = self.check_hdf5_files(\n self.test_database)\n\n # create the indexing system\n # alows to associate each mol to an index\n # and get fname and mol name from the index\n self.create_index_molecules()\n\n # get the actual feature name\n if self.mapfly:\n self.get_raw_feature_name()\n else:\n self.get_mapped_feature_name()\n\n # get the pairing\n self.get_pairing_feature()\n\n # get grid shape\n self.get_grid_shape()\n\n # get the input shape\n self.get_input_shape()\n\n # get renormalization factor\n if self.normalize_features or self.normalize_targets or self.clip_features:\n if self.mapfly:\n self.compute_norm()\n else:\n self.get_norm()\n\n logger.info('\\n')\n logger.info(\" Data Set Info:\")\n logger.info(\n f' Augmentation : {self.use_rotation} rotations')\n logger.info(\n f' Training set : {self.ntrain} conformations')\n logger.info(\n f' Validation set : {self.nvalid} conformations')\n logger.info(\n f' Test set : {self.ntest} conformations')\n logger.info(f' Number of channels : {self.input_shape[0]}')\n logger.info(f' Grid Size : {self.data_shape[1]}, '\n f'{self.data_shape[2]}, {self.data_shape[3]}')\n sys.stdout.flush()","def simulate_user_annotations(self):\r\n\r\n # Check existence of clustering results\r\n\r\n if len(self.recognized_faces) == 0:\r\n\r\n # Try to load YAML files\r\n if os.path.exists(self.cluster_files_path):\r\n\r\n print 'Loading YAML files with clustering results'\r\n logger.debug('Loading YAML file with clustering results')\r\n\r\n self.recognized_faces = []\r\n for yaml_file in os.listdir(self.cluster_files_path):\r\n yaml_file_path = os.path.join(\r\n self.cluster_files_path, yaml_file)\r\n with open(yaml_file_path) as f:\r\n self.recognized_faces.append(yaml.load(f))\r\n\r\n print 'YAML file with clustering results loaded'\r\n logger.debug('YAML file with clustering results loaded')\r\n\r\n else:\r\n\r\n print 'Warning! No clustering results found!'\r\n logger.warning('No clustering results found!')\r\n\r\n return\r\n\r\n auto_p_counter = 0\r\n\r\n user_rec_faces = []\r\n\r\n # Iterate through automatic recognized faces\r\n for auto_p_dict in self.recognized_faces:\r\n\r\n segment_list = auto_p_dict[c.SEGMENTS_KEY]\r\n\r\n # Get first segment\r\n if len(segment_list) >= 1:\r\n\r\n first_segment = segment_list[0]\r\n\r\n segment_ann_tag = first_segment[c.ANN_TAG_KEY]\r\n\r\n auto_p_dict[c.ASSIGNED_TAG_KEY] = segment_ann_tag\r\n\r\n user_rec_faces.append(auto_p_dict)\r\n\r\n auto_p_counter += 1\r\n\r\n self.recognized_faces = user_rec_faces\r\n\r\n # Save clustering result in YAML files\r\n\r\n # Remove previous files\r\n if os.path.exists(self.cluster_files_path):\r\n shutil.rmtree(self.cluster_files_path)\r\n # Create directory for people clustering results\r\n os.makedirs(self.cluster_files_path)\r\n\r\n counter = 0\r\n for person_dict in self.recognized_faces:\r\n yaml_file_name = str(counter) + '.YAML'\r\n yaml_file_path = os.path.join(self.cluster_files_path, yaml_file_name)\r\n utils.save_YAML_file(yaml_file_path, person_dict)\r\n counter += 1","def train_k():\n\n for i in range(n_families):\n print('[training-k] family:', i, '...')\n f1_fam_name = 'f1_fam_' + str(i) + '_features'\n feature_mat_fam1 = mask_features(f1_fam_name)\n n_samples = len(feature_mat_fam1)\n # use 80% of samples as training set\n feature_mat_fam1 = feature_mat_fam1[int(n_samples / 5):, :]\n my_k, my_result = train_with_inner_outer(feature_mat_fam1, 0)\n\n save_name = '/f1_fam_' + str(i) + '_validation'\n with open(saved_cluster_path + save_name, 'wb') as fp:\n pickle.dump(my_result, fp)","def get_pointcloud(dataset, NUM_POINT=2048, shuffle=True):\n if dataset == 'modelnet':\n train_file_idxs = np.arange(0, len(TRAIN_FILES_MODELNET))\n data_train = []\n label_train = []\n for fn in range(len(TRAIN_FILES_MODELNET)):\n print('----' + str(fn) + '-----')\n current_data, current_label = provider.loadDataFile(TRAIN_FILES_MODELNET[fn])\n current_data = current_data[:,0:NUM_POINT,:]\n current_label = np.squeeze(current_label)\n data_train.append(current_data)\n label_train.append(current_label)\n result_train = np.vstack(data_train)\n label_train = np.concatenate(label_train, axis=None)\n if shuffle:\n X_train, y_train, _ = provider.shuffle_data(result_train, np.squeeze(label_train)) \n else:\n X_train, y_train = result_train, np.squeeze(label_train)\n \n data_test = []\n label_test = []\n for fn in range(len(TEST_FILES_MODELNET)):\n print('----' + str(fn) + '-----')\n current_data, current_label = provider.loadDataFile(TEST_FILES_MODELNET[fn])\n current_data = current_data[:,0:NUM_POINT,:]\n current_label = np.squeeze(current_label)\n data_test.append(current_data)\n label_test.append(current_label)\n result_test = np.vstack(data_test)\n label_test = np.concatenate(label_test, axis=None)\n if shuffle:\n X_test, y_test, _ = provider.shuffle_data(result_test, np.squeeze(label_test))\n else:\n X_test, y_test = result_test, np.squeeze(label_test)\n elif dataset == 'shapenet':\n shapenet_data, shapenet_label = provider.get_shapenet_data()\n shapenet_data = shapenet_data[:,0:NUM_POINT,:]\n X_train, X_test, y_train, y_test = train_test_split(shapenet_data, shapenet_label, test_size=0.2, random_state=42, shuffle=shuffle)\n elif dataset == 'shapenet_chair':\n shapenet_data, shapenet_label = provider.get_shapenet_data()\n shapenet_data = shapenet_data[:,0:NUM_POINT,:]\n shapenet_data, shapenet_label = shapenet_data[shapenet_label==17], shapenet_label[shapenet_label==17]\n X_train, X_test, y_train, y_test = train_test_split(shapenet_data, shapenet_label, test_size=0.2, random_state=42, shuffle=shuffle)\n elif dataset == 'modelnet10':\n current_data, current_label = provider.loadDataFile(MODELNET10_TRAIN_FILE)\n current_data = current_data[:,0:NUM_POINT,:]\n if shuffle:\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \n current_label = np.squeeze(current_label)\n X_train, y_train = current_data, current_label\n\n current_data, current_label = provider.loadDataFile(MODELNET10_TEST_FILE)\n current_data = current_data[:,0:NUM_POINT,:]\n if shuffle:\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \n current_label = np.squeeze(current_label)\n X_test, y_test = current_data, current_label\n elif dataset == 'keypoint':\n current_data, current_label = provider.load_mat_keypts(TRAIN_CHAIR_FILES, KEYPOINT_CHAIR_PATH, NUM_POINT)\n if shuffle:\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \n for i in range(current_data.shape[0]): # shuffle order of points in a single model, otherwise keypoints are always at the end\n idx = np.arange(current_data.shape[1])\n np.random.shuffle(idx)\n current_data = current_data[:, idx, :]\n current_label = current_label[:, idx]\n current_label = np.squeeze(current_label)\n X_train, y_train = current_data, current_label\n\n current_data, current_label = provider.load_mat_keypts(TEST_CHAIR_FILES, KEYPOINT_CHAIR_PATH, NUM_POINT)\n if shuffle:\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \n for i in range(current_data.shape[0]):\n idx = np.arange(current_data.shape[1])\n np.random.shuffle(idx)\n current_data = current_data[:, idx, :]\n current_label = current_label[:, idx]\n current_label = np.squeeze(current_label)\n X_test, y_test = current_data, current_label\n elif dataset == 'keypoint_10class':\n current_data, current_label = provider.load_mat_keypts(TRAIN_CHAIR_FILES, KEYPOINT_CHAIR_PATH, NUM_POINT)\n current_label[:, -10:] = np.arange(1, 11)\n if shuffle:\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \n for i in range(current_data.shape[0]): # shuffle order of points in a single model, otherwise keypoints are always at the end\n idx = np.arange(current_data.shape[1])\n np.random.shuffle(idx)\n current_data = current_data[:, idx, :]\n current_label = current_label[:, idx]\n current_label = np.squeeze(current_label)\n X_train, y_train = current_data, current_label\n\n current_data, current_label = provider.load_mat_keypts(TEST_CHAIR_FILES, KEYPOINT_CHAIR_PATH, NUM_POINT)\n current_label[:, -10:] = np.arange(1, 11)\n if shuffle:\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \n for i in range(current_data.shape[0]):\n idx = np.arange(current_data.shape[1])\n np.random.shuffle(idx)\n current_data = current_data[:, idx, :]\n current_label = current_label[:, idx]\n current_label = np.squeeze(current_label)\n X_test, y_test = current_data, current_label\n elif dataset == \"keypointnet\":\n json_path = osp.join(KEYPOINTNET_PATH, \"annotations/all.json\")\n annots = json.load(open(json_path))\n X = []\n y = []\n for annot in annots:\n class_id = annot[\"class_id\"]\n model_id = annot[\"model_id\"]\n kpts = []\n for kpt in annot[\"keypoints\"]:\n kpts.append(kpt[\"xyz\"])\n pcd_path = osp.join(KEYPOINTNET_PATH, f\"pcds/{class_id}/{model_id}.pcd\")\n if os.path.exists(pcd_path):\n pcd = naive_read_pcd(pcd_path)\n pcd = pcd[0:NUM_POINT, :]\n else:\n continue\n if len(kpts) != 10:\n continue\n pcd = np.concatenate((pcd[:-10], kpts))\n label = np.zeros(NUM_POINT-10)\n label = np.concatenate((label, np.ones(10)))\n X.append(pcd)\n y.append(label)\n current_data = np.array(X)\n current_label = np.array(y)\n if False and shuffle:\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \n for i in range(current_data.shape[0]): # shuffle order of points in a single model, otherwise keypoints are always at the end\n idx = np.arange(current_data.shape[1])\n np.random.shuffle(idx)\n current_data = current_data[:, idx, :]\n current_label = current_label[:, idx]\n current_label = np.squeeze(current_label)\n X_train, X_test, y_train, y_test = train_test_split(current_data, current_label, test_size=0.2, random_state=42, shuffle=shuffle)\n else:\n raise NotImplementedError()\n print(f'Dataset name: {dataset}')\n print(f'X_train: {X_train.shape}')\n print(f'X_test: {X_test.shape}')\n print(f'y_train: {y_train.shape}')\n print(f'y_test: {y_test.shape}')\n return X_train, X_test, y_train, y_test","def predictClusters(self, df, k):\n self.models.fitModels(df)\n return self.models.predict()","def main(unused_argv):\n del unused_argv\n if not os.path.exists(FLAGS.data_dir):\n os.makedirs(FLAGS.data_dir)\n\n tfds_cached_dict = {}\n data_dir = FLAGS.tfds_data_dir if FLAGS.tfds_data_dir else None\n name = FLAGS.dataset_name\n tfds_cached_dict[name] = tfds.load(name, batch_size=-1, data_dir=data_dir)\n dataset_dict = tfds_cached_dict[name]\n dataset_dict[tfds.Split.TRAIN] = tfds.as_numpy(\n dataset_dict[tfds.Split.TRAIN])\n dataset_dict[tfds.Split.TEST] = tfds.as_numpy(\n dataset_dict[tfds.Split.TEST])\n # To mock the API of tfds.load to cache the downloaded datasets.\n # Used as an argument to `get_dataset`.\n def load_fn(name, data_dir=None, batch_size=-1):\n # This function will always return the whole dataset.\n assert batch_size == -1\n del data_dir\n del batch_size\n return tfds_cached_dict[name]\n class_ids = sorted([int(x) for x in FLAGS.class_ids])\n num_classes = len(class_ids)\n for i in range(num_classes):\n for j in range(i+1, num_classes):\n print('Generating pos {} neg {}'.format(i, j))\n positive_class = class_ids[i]\n negative_class = class_ids[j]\n random_seeds = range(FLAGS.min_data_seed, FLAGS.max_data_seed)\n for seed in random_seeds:\n dataset = create_projected_binary_dataset(\n FLAGS.dataset_name, positive_class, negative_class,\n FLAGS.num_train_examples, FLAGS.num_valid_examples,\n FLAGS.num_test_examples, FLAGS.projected_dim, seed, load_fn)\n filename = 'binary_{}-pos_{}-neg_{}-dim_{}-seed_{}'.format(\n FLAGS.dataset_name, positive_class, negative_class,\n FLAGS.projected_dim, seed)\n serialized_dataset = dataset.SerializeToString()\n\n with open(os.path.join(FLAGS.data_dir, filename), 'wb') as f:\n f.write(serialized_dataset)","def predict(self, images):\n\t\t#testing_dataset = tf.data.Dataset.from_tensor_slices(images)\n\t\ttf.keras.backend.set_learning_phase(0)\n\t\ttesting_dataset = tf.data.Dataset.from_tensor_slices(np.asarray(images)).map(lambda x: tf.image.resize(x, [self.image_size, self.image_size]) / 255.0)\n\t\t#testing_dataset_shape = tf.data.Dataset.from_tensor_slices(np.full((len(images), 2), 500, dtype=np.int32))\n\t\ttesting_iterator_X = tf.data.Dataset.zip((testing_dataset, )).batch(self.batch_size).make_initializable_iterator()\n\n\t\tself.sess.run(testing_iterator_X.initializer)\n\t\ttesting_handle_X = self.sess.run(testing_iterator_X.string_handle())\n\n\t\tfinal_output = np.zeros([len(images), 500, 500, num_classes])\n\t\tj = 0\n\t\tcount = 0\n\t\twhile True:\n\t\t\ttry:\n\t\t\t\t[test_output] = self.sess.run(\n\t\t\t\t\t[self.output],\n\t\t\t\t\t\tfeed_dict={\n\t\t\t\t\t\t\tself.is_training: False,\n\t\t\t\t\t\t\tself.handle_X: testing_handle_X,\n\t\t\t\t\t\t}\n\t\t\t\t)\n\t\t\t\tthis_len = len(test_output)\n\t\t\t\tfor z in range(len(test_output)):\n\t\t\t\t\tfor dim in range(num_classes):\n\t\t\t\t\t\tfinal_output[count+z:count+z+1, :, :, dim] = scipy.misc.imresize(test_output[z, :, :, dim], [500, 500])\n\n\t\t\t\t#final_output[count:count+this_len, :, :, :] = test_output\n\t\t\t\tto = final_output[count:count+this_len, :, :, :].argmax(axis=-1)\n\t\t\t\t'''\n\t\t\t\tpdb.set_trace()\n\t\t\t\tfor z in range(this_len):\n\t\t\t\t\tplt.matshow(to[z])\n\t\t\t\t\tplt.colorbar()\n\t\t\t\t\tplt.show()\n\t\t\t\t'''\n\t\t\t\tcount += this_len\n\t\t\t\tprint(f'Batch: {j}')\n\t\t\t\tj += 1\n\t\t\texcept tf.errors.OutOfRangeError:\n\t\t\t\tbreak\n\t\treturn final_output","def test_subset_classification(p_df_subset, p_weather):\n X = p_df_subset.drop(\"Direction\", axis=1)\n y = p_df_subset[\"Direction\"]\n print(\"Scale Data...\")\n scaler = StandardScaler()\n X_scaled_train = scaler.fit_transform(X)\n print(\"Do PCA...\")\n pca = PCA(n_components=15)\n pca.fit(X_scaled_train)\n X_train_transformed = pca.transform(X_scaled_train)\n # Read Models\n dummy = io.read_object(\"Dummy_classifier_model\"+p_weather+\".pkl\")\n clf = io.read_object(\"KNearestNeighbours_classifier_model\"+p_weather+\".pkl\")\n # Predict\n print(\"Predict...\")\n dummy_y_prediction = dummy.predict(X_train_transformed)\n kn_y_prediction = clf.predict(X_train_transformed)\n # Evaluate Predict\n prediction.evaluate.direction_error_metrics(y, dummy_y_prediction, \"Dummy_Classifier\"+p_weather, \"Testing\")\n prediction.evaluate.direction_error_metrics(y, kn_y_prediction, \"KNeighbors_Classifier\"+p_weather, \"Testing\")","def get_train_test(self, train=0.8, shuffle=False):\n if train <= 0 or train >= 1:\n raise ValueError(\"Train size should be the range (0, 1)\")\n test = 1 - train\n train_pathmap = {}\n test_pathmap = {}\n for label, paths in self.pathmap.items():\n if shuffle:\n np.random.shuffle(paths)\n num_images = len(paths)\n train_idx = int(num_images * train)\n test_idx = num_images - train_idx\n train_pathmap[label] = paths[:train_idx]\n test_pathmap[label] = paths[train_idx : train_idx + test_idx]\n return train_pathmap, test_pathmap","def prepare_cityscapes_data(seed=1, percent=30.0, version=2017):\n def _save_anno(name, images, annotations):\n \"\"\"Save annotation\n \"\"\"\n print('>> Processing data {}.json saved ({} images {} annotations)'.format(\n name, len(images), len(annotations)))\n new_anno = {}\n new_anno['images'] = images\n new_anno['annotations'] = annotations\n new_anno['categories'] = anno['categories']\n\n with open(\n '{root}/{save_name}.json'.format(\n save_name=name, root=DATA_DIR),\n 'w') as f:\n json.dump(new_anno, f)\n print('>> Data {}.json saved ({} images {} annotations)'.format(\n name, len(images), len(annotations)))\n\n np.random.seed(seed)\n \n anno = json.load(open(os.path.join(DATA_DIR, 'instancesonly_filtered_gtFine_train.json')))\n\n image_list = anno['images']\n labeled_tot = int(percent / 100. * len(image_list))\n #labeled_ind = np.random.choice(range(len(image_list)), size=labeled_tot)\n labeled_ind = np.arange(len(image_list))\n np.random.shuffle(labeled_ind)\n labeled_ind = labeled_ind[0:labeled_tot]\n\n labeled_id = []\n labeled_images = []\n unlabeled_images = []\n labeled_ind = set(labeled_ind)\n for i in range(len(image_list)):\n if i in labeled_ind:\n labeled_images.append(image_list[i])\n labeled_id.append(image_list[i]['id'])\n else:\n unlabeled_images.append(image_list[i])\n\n # get all annotations of labeled images\n labeled_id = set(labeled_id)\n labeled_annotations = []\n unlabeled_annotations = []\n for an in anno['annotations']:\n if an['image_id'] in labeled_id:\n labeled_annotations.append(an)\n else:\n unlabeled_annotations.append(an)\n\n # save labeled and unlabeled\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}'.format(\n version=version, seed=seed, tot=int(percent))\n _save_anno(save_name, labeled_images, labeled_annotations)\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}-unlabeled'.format(\n version=version, seed=seed, tot=int(percent))\n _save_anno(save_name, unlabeled_images, unlabeled_annotations)","def prepare_datasets(ref_map: np.ndarray, training_patch: float) -> tuple:\n samples_by_classes = [[] for _ in range(int(ref_map.max()) + abs(BG_CLASS))]\n rows, columns = list(range(int(ref_map.shape[ROW_AXIS]))), list(range((int(ref_map.shape[COLUMNS_AXIS]))))\n for i, j in product(rows, columns):\n if ref_map[i, j] != BG_CLASS:\n samples_by_classes[ref_map[i, j]].append([[i, j], ref_map[i, j]])\n lowest_class_population = np.min([samples_by_classes[i].__len__() for i in range(samples_by_classes.__len__())])\n train_set, test_set = [], []\n train_size = int(training_patch * lowest_class_population)\n for i in range(samples_by_classes.__len__()):\n train_set.extend(samples_by_classes[i][:train_size])\n test_set.extend(samples_by_classes[i][train_size:])\n train_samples, train_labels = list(map(list, zip(*train_set)))\n test_samples, test_labels = list(map(list, zip(*test_set)))\n return train_samples, np.asarray(train_labels), test_samples, np.asarray(test_labels)","def generate_maps(dl: DatasetLoader, model, map_out: str, graph, all_classes=True, batch_size=10, mode='cv2'):\n # o_generator = get_outputs_generator(model, 'CAM')\n input = model.input\n output = model.get_layer('CAM').output\n output_predict = model.get_layer('W').output\n output_fn = K.function([input], [output])\n fn_predict = K.function([input], [output_predict])\n\n o_resizer = tf.image.resize_images\n o_dot = K.dot\n\n # plot CAMs only for the validation data:\n k = 0\n counter = 0\n img_arr = []\n with K.get_session() as sess:\n in_place = tf.placeholder(tf.float32, [None, None, None, 512])\n size_place = tf.placeholder(tf.int32, [2])\n convert_place = tf.placeholder(tf.float32, [512, len(dl.directories)])\n first_func = o_resizer(in_place, size_place, ResizeMethod.BICUBIC)\n second_func = o_dot(in_place, convert_place)\n graph.finalize()\n\n for i in range(dl.number_of_imgs_for_train, dl.number_of_imgs):\n with graph.as_default() as gr:\n if i == dl.number_of_imgs - 1:\n k = batch_size - 1\n rpath = dl.baseDirectory + \"/\" + dl.imgDataArray[i].directory + \"/\" + dl.imgDataArray[i].name\n img = cv2.imread(rpath, cv2.IMREAD_COLOR)\n # print('!!!!!!!!debug', rpath, i)\n img_arr.append(img)\n k += 1\n if k == batch_size:\n start_time = time.time()\n predict_input = np.asarray(img_arr, dtype='float32')\n predict_input = preprocess_input(predict_input)\n\n k = 0\n img_arr = []\n\n layer_outputs = output_fn([predict_input])[0]\n predictions = fn_predict([predict_input])[0]\n\n if mode == 'cv2': # model, layer_outputs, nb_classes, im_width=256):\n maps_arr = cam_generate_cv2(model, layer_outputs, dl.nb_classes)\n else:\n maps_arr = cam_generate_tf_ops(model, layer_outputs, sess, first_func, second_func, in_place,\n size_place,\n convert_place)\n\n for l, prediction in enumerate(predictions):\n inc = i - batch_size + l + 1\n outpath = map_out + \"/\" + dl.imgDataArray[inc].directory + \"/\" + dl.imgDataArray[inc].name\n # print('[DEBUG]', outpath, inc, i, batch_size, l)\n\n try:\n os.makedirs(outpath)\n except OSError:\n continue\n\n value = np.argmax(prediction)\n if all_classes:\n a = 0\n b = dl.nb_classes\n else:\n a = value\n b = value + 1\n for j in range(a, b):\n outname = outpath + \"/\" + str(j) + '.tiff'\n if mode == 'cv2':\n Image.fromarray(maps_arr[l][j]).save(outname)\n else:\n Image.fromarray(maps_arr[l, :, :, j]).save(outname)\n with open(outpath + '/resuts.json', 'w') as outfile:\n json.dump({'predicted': str(value), \"true_label\": str(dl.imgDataArray[inc].img_class)},\n outfile)\n print(\"cam(\", counter, \"/\", dl.number_of_imgs_for_test, \"completed\")\n counter += 1\n print(\"got cams in\", time.time() - start_time)","def final_evaluation(self):\n print(\"\\n=== Assign final labels ===\")\n\n # skip if there is only one cluster\n n_cluster = len(set(self.label[self.label != -1]))\n if n_cluster < 2:\n print(f\"Skip final evaluation because only {n_cluster} cluster label exist.\")\n # name all cluster as c0\n self.label = np.zeros(self.label.size, dtype=int)\n self.cv_predicted_label = [f\"c{label}\" for label in self.label]\n self.label_proba = np.ones(self.label.size, dtype=int)\n self.final_accuracy = 1\n else:\n # predict outliers\n outlier_x = self.X[self.label == -1]\n outlier_idx = np.where(self.label == -1)[0]\n if len(outlier_idx) != 0:\n outlier_predict = pd.Series(self.supervise_model.predict(outlier_x), index=outlier_idx)\n for cell, pred_label in outlier_predict.items():\n self.label[cell] = pred_label\n print(\n \"Assigned all the multi-leiden clustering outliers into clusters \"\n \"using the prediction model from final clustering version.\"\n )\n\n # final evaluation of non-outliers using cross val predict\n final_predict_proba = cross_val_predict(\n self.supervise_model,\n self.X,\n y=self.label,\n method=\"predict_proba\",\n n_jobs=self.n_jobs,\n verbose=0,\n cv=10,\n )\n final_predict = pd.Series(np.argmax(final_predict_proba, axis=1))\n final_cell_proba = pd.Series(np.max(final_predict_proba, axis=1))\n final_acc = balanced_accuracy_score(self.label, final_predict.values)\n print(f\"Final ten-fold CV Accuracy on all the cells: {final_acc:.3f}\")\n self.cv_predicted_label = [f\"c{label}\" for label in final_predict]\n self.label_proba = final_cell_proba.values\n self.final_accuracy = final_acc\n\n self.label = [f\"c{label}\" for label in self.label]\n return","def train_clustermodel_nonsparse(self):\n \n segtimes_df, nonsparse_matrix = self.create_nonsparse_matrix(self.data)\n segtimes_df['index']=segtimes_df.index\n nonsparse_matrix['index']=nonsparse_matrix.index\n data_to_scale = pd.merge(segtimes_df, nonsparse_matrix, on=['index'])\n data_scaled = self.scale_matrix(data_to_scale)\n data_to_cluster = data_scaled.drop(columns = ['segment_id','level_0','date','time'])\n \n print('Clustering using nonsparse segment/time matrix and: ' + self.algorithm)\n clusterer = self.clustering_algorithms[self.algorithm]\n self.clustering_model = clusterer.fit(data_to_cluster)\n \n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_nonsparse'])\n clusters_df['segtimekey'] = clusters_df.index\n segtimes_df['segtimekey'] = segtimes_df.index\n clusters_df = clusters_df.reset_index(drop=True)\n self.clusters_df_final = pd.merge(segtimes_df, clusters_df, on=['segtimekey'])\n self.clusters_df_final['cluster_nonsparse'].value_counts()\n \n today = datetime.date.today()\n filename = self.algorithm + '_nonsparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\n joblib.dump(self.clustering_model, filename)\n \n print('Stored ' + filename)\n \n return self.clustering_model, self.clusters_df_final[['segment_id','date','time','cluster_nonsparse']]","def lets_train(debug_flag):\n # Directory structure\n parent_path = setup_debug(debug_flag)\n train_folder = parent_path + 'train_data/'\n test_folder = parent_path + 'test_data/'\n # File names\n train_label_path = train_folder + 'train_true_scores.pickle'\n train_data_path = train_folder + 'train_processed_data.csv'\n test_data_path = test_folder + 'test_processed_data.csv'\n\n # Training data and labels\n print('Loading training data...')\n train_df = pd.read_csv(train_data_path, index_col=0)\n with open(train_label_path, 'rb') as handle:\n train_labels = pickle.load(handle)\n # Test data\n print('Loading test data...')\n test_df = pd.read_csv(test_data_path, index_col=0)\n\n return(train_folder, test_folder, train_df, train_labels, test_df)","def train():\n fake_data, fake_labels = multiple_fake_clusters(500, 50, 10, 10, 20)\n X = np.array(fake_data)\n Y = np.array(fake_labels)\n\n model = Sequential()\n model.add(LSTM(units=128, input_shape=(2, 50)))\n model.add(Dropout(0.5))\n model.add(Dense(1, activation=\"sigmoid\"))\n\n my_callbacks = [EarlyStopping(monitor='auc_roc', patience=300, verbose=1, mode='max'),\n TensorBoard(log_dir=\"logs/{}\".format(time()))]\n\n model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=[\n 'accuracy', auc_roc, f1_score_threshold(), precision_threshold(), recall_threshold()])\n model.fit(\n X,\n Y,\n batch_size=100,\n epochs=10,\n validation_split=0.2,\n callbacks=my_callbacks,\n shuffle=True\n )\n\n # Use this to save the weights to be able to reload them while testing\n model.save_weights('./weights/my_model_clusters_weights.h5')","def clusters(self):\n raise NotImplementedError","def start_algorithm(self):\r\n vectors = self.vectorize_data()\r\n kmeans = KMeans(init='k-means++', n_clusters=self.cluster_amount, n_init=10)\r\n kmeans.fit(vectors)\r\n return self.cluster_tweet(kmeans.labels_)","def train(self):\n raise NotImplementedError","def __train__(self):\n if (self.type_camf == 'CAMF_CI'):\n #users, items, context, ratings\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = ci.fit()\n elif (self.type_camf == 'CAMF_CU'):\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = cu.fit()\n elif (self.type_camf == 'CAMF_C'):\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = c.fit()\n\n dummy_pred = np.zeros((predictions.shape))\n for r, pred_array in enumerate(predictions):\n for c, pred in enumerate(pred_array):\n dummy_pred[r][c] = self.__check_ratings__(pred)\n predictions = dummy_pred\n #save a plot with a loss function\n plots = prs.PlotRSData()\n #print(losses)\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\"_loop\"+str(self.loop))\n pd.DataFrame(losses).to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ +\"losses_loop\"+str(self.loop)+\".csv\")\n print('Saving the feature matrix...')\n # set predictions back to the pivot table\n self.__utility_saved_training__(predictions) \n # save results\n self.utility_predictions.to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ + \"_SGD_predictions_loop\"+str(self.loop)+\".csv\")","def do_segmentation(img_idxs=None, output=True, save_candidates=True, data='train'):\n \n zoom_levels = [1, 0.7, 0.5]\n \n # Load images\n dl = pipeline.DataLoader()\n \n if data == 'train':\n data_imgs = dl.get_original_images(dataset=\"train\")\n elif data == 'test':\n data_imgs = dl.get_original_images(dataset=\"test\")\n elif data == 'final':\n print('Final stage not started yet')\n exit()\n else:\n print('Unknown data set: ' + data)\n exit()\n \n data_x = data_imgs['x']\n data_meta = data_imgs['meta']\n \n if img_idxs is None:\n img_idxs = list(range(len(data_x)))\n\n if len(img_idxs) == 0:\n print('Empty index range given.')\n exit()\n if img_idxs[-1] >= len(data_x):\n print('Invalid index range ending in %d for used data set of size %d' % (img_idxs[-1], len(data_x)))\n exit()\n \n # Prepare output file\n if save_candidates:\n if data == 'train':\n classlist = dl.get_classes()\n out_train_json_objs = {}\n for cls in classlist:\n out_train_json_objs[cls] = []\n else:\n out_json_obj = []\n \n # Prepare performance measurements\n tp_boxes = [0 for _ in zoom_levels]\n tp_compact_boxes = [0 for _ in zoom_levels]\n num_boxes = 0\n tp_fish = [0 for _ in zoom_levels]\n tp_compact_fish = [0 for _ in zoom_levels]\n num_fish = 0\n \n # See how well the centroids match\n #lower = lambda centroid, dim: min(max(centroid[dim] - bbox_size/2.0, 0), img.shape[dim] - bbox_size)\n #upper = lambda centroid, dim: max(bbox_size, min(centroid[dim] + bbox_size/2.0, img.shape[dim]))\n #intersection_centroid = lambda bbox, centroid: max(0, min(upper(centroid, 1), bbox['x']+bbox['width']) - max(lower(centroid, 1), bbox['x'])) * max(0, min(upper(centroid, 0), bbox['y']+bbox['height']) - max(lower(centroid, 0), bbox['y']))\n #matches_centroid = lambda bbox, centroid: intersection_centroid(bbox, centroid) / float(bbox['width']*bbox['height']) >= min_overlap_ratio\n \n clust_bbox_to_dict = lambda cand: {'x': cand[1], 'width': cand[3]-cand[1], 'y': cand[0], 'height': cand[2]-cand[0]}\n intersection_bbox = lambda cand, fish: max(0, min(cand['x']+cand['width'], fish['x']+fish['width']) - max(cand['x'], fish['x'])) * max(0, min(cand['y']+cand['height'], fish['y']+fish['height']) - max(cand['y'], fish['y']))\n containment_ratio = lambda cand, fish: intersection_bbox(cand, fish) / float(fish['width']*fish['height'])\n \n # Prepare histogram matching template\n print('Computing histogram template...')\n if data == 'train':\n template = preprocessing.build_template(data_x, data_meta)\n else:\n hist_template_data_imgs = dl.get_original_images(file_filter=preprocessing.DEFAULT_HIST_MATCH_TEMPLATES)\n template = preprocessing.build_template(hist_template_data_imgs['x'], hist_template_data_imgs['meta'])\n print('Histogram template computed. Starting segmentation...')\n \n for idx_idx in range(len(img_idxs)):\n idx = img_idxs[idx_idx]\n \n # Load image\n img = data_x[idx]().astype('uint8')\n if 'bounding_boxes' in data_meta[idx]:\n imgboxes = data_meta[idx]['bounding_boxes']\n else:\n imgboxes = []\n \n # Use histogram matching for night vision images\n nvg = False\n if colour.is_night_vision(img): # night vision\n nvg = True\n img = preprocessing.hist_match(img, template)\n \n # Perform actual segmentation\n regions, centroids, clust_bboxes = colour_segmentation(img, max_clust_size=0.10)\n clust_bboxes = unique([clust_bbox_to_dict(clust) for clust in clust_bboxes], key=lambda cand: (cand['x'], cand['y']))\n \n #num_matching_boxes = sum(any(matches_centroid(bbox, centroid) for bbox in imgboxes) for centroid in centroids)\n #num_found_fish = sum(any(matches_centroid(bbox, centroid) for centroid in centroids) for bbox in imgboxes)\n #num_impossible_here = sum(overlap_ratio * max(bbox['width'], bbox['height']) >= bbox_size for bbox in imgboxes)\n \n num_compact_matching_boxes = [sum(any(containment_ratio(bbox, preprocessing.zoom_box(clust, img.shape, zoom_factor=zoom, output_dict=True)) >= min_containment_ratio for bbox in imgboxes) for clust in clust_bboxes) for zoom in zoom_levels]\n num_compact_found_fish = [sum(any(containment_ratio(bbox, preprocessing.zoom_box(clust, img.shape, zoom_factor=zoom, output_dict=True)) >= min_containment_ratio for clust in clust_bboxes) for bbox in imgboxes) for zoom in zoom_levels]\n num_matching_boxes = [sum(any(containment_ratio(preprocessing.zoom_box(clust, img.shape, zoom_factor=zoom, output_dict=True), bbox) >= min_overlap_ratio for bbox in imgboxes) for clust in clust_bboxes) for zoom in zoom_levels]\n num_found_fish = [sum(any(containment_ratio(preprocessing.zoom_box(clust, img.shape, zoom_factor=zoom, output_dict=True), bbox) >= min_overlap_ratio for clust in clust_bboxes) for bbox in imgboxes) for zoom in zoom_levels]\n \n # Record this information\n #tp_boxes += num_matching_boxes\n num_boxes += len(clust_bboxes)\n #tp_fish += num_found_fish\n num_fish += len(imgboxes)# - num_impossible_here\n #num_impossible += num_impossible_here\n tp_compact_boxes = [a+b for a,b in zip(tp_compact_boxes, num_compact_matching_boxes)]\n tp_compact_fish = [a+b for a,b in zip(tp_compact_fish, num_compact_found_fish)]\n tp_boxes = [a+b for a,b in zip(tp_boxes,num_matching_boxes)]\n tp_fish = [a+b for a,b in zip(tp_fish,num_found_fish)]\n \n if output:\n # Output performance for this image\n if data == 'train':\n #print('Image %d (found %d/%d%s, %d FPs%s)' % (idx, num_found_fish, len(imgboxes)-num_impossible_here, (', %d impossible' % num_impossible_here) if num_impossible_here > 0 else '', len(centroids)-num_matching_boxes, '; NVG' if nvg else ''))\n print('Image %d (compact: found %d/%d %d FPs none; %d/%d %d FPs 70%%; %d/%d %d FPs 50%%%s)' % (idx, num_compact_found_fish[0], len(imgboxes), len(centroids)-num_compact_matching_boxes[0], num_compact_found_fish[1], len(imgboxes), len(centroids)-num_compact_matching_boxes[1], num_compact_found_fish[2], len(imgboxes), len(centroids)-num_compact_matching_boxes[2], '; NVG' if nvg else ''))\n print('Image %d (encompassing: found %d/%d %d FPs none; %d/%d %d FPs 70%%; %d/%d %d FPs 50%%%s)' % (idx, num_found_fish[0], len(imgboxes), len(centroids)-num_matching_boxes[0], num_found_fish[1], len(imgboxes), len(centroids)-num_matching_boxes[1], num_found_fish[2], len(imgboxes), len(centroids)-num_matching_boxes[2], '; NVG' if nvg else ''))\n else:\n print('Image %d (%d candidates)' % (idx, len(centroids)))\n \n # Summarise performance up till now\n if idx_idx%50 == 49:\n if data == 'train':\n #box_precision = 100*tp_boxes / float(num_boxes) if num_boxes > 0 else -1\n #fish_recall = 100*tp_fish / float(num_fish) if num_fish > 0 else -1\n #print('Box precision after %d images: %g%% (%d/%d)\\nFish recall after %d images: %g%% (%d/%d%s)\\n' % (idx_idx+1, box_precision, tp_boxes, num_boxes, idx_idx+1, fish_recall, tp_fish, num_fish, (', %d impossible' % num_impossible) if num_impossible > 0 else ''))\n \n box_precision = [100*tp_boxes_i / float(num_boxes) if num_boxes > 0 else -1 for tp_boxes_i in tp_boxes]\n compact_box_precision = [100*tp_boxes_i / float(num_boxes) if num_boxes > 0 else -1 for tp_boxes_i in tp_compact_boxes]\n fish_recall = [100*tp_fish_i / float(num_fish) if num_fish > 0 else -1 for tp_fish_i in tp_fish]\n compact_fish_recall = [100*tp_fish_i / float(num_fish) if num_fish > 0 else -1 for tp_fish_i in tp_compact_fish]\n \n print('Box compact-match precision after %d images: %g%% (%d/%d) none; %g%% (%d/%d) 70%%; %g%% (%d/%d) 50%%\\nFish compact-match recall after %d images: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom' % (idx_idx+1, compact_box_precision[0], tp_compact_boxes[0], num_boxes, compact_box_precision[1], tp_compact_boxes[1], num_boxes, compact_box_precision[2], tp_compact_boxes[2], num_boxes, idx_idx+1, compact_fish_recall[0], tp_compact_fish[0], num_fish, compact_fish_recall[1], tp_compact_fish[1], num_fish, compact_fish_recall[2], tp_compact_fish[2], num_fish))\n print('Box encompassing-match precision after %d images: %g%% (%d/%d) none; %g%% (%d/%d) 70%%; %g%% (%d/%d) 50%%\\nFish encompassing-match recall after %d images: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom\\n' % (idx_idx+1, box_precision[0], tp_boxes[0], num_boxes, box_precision[1], tp_boxes[1], num_boxes, box_precision[2], tp_boxes[2], num_boxes, idx_idx+1, fish_recall[0], tp_fish[0], num_fish, fish_recall[1], tp_fish[1], num_fish, fish_recall[2], tp_fish[2], num_fish))\n else:\n print('%d images segmented (%d candidates in total)' % (idx_idx+1, num_boxes))\n \n if save_candidates:\n img_json_obj = {'filename': data_meta[idx]['filename']}\n #img_json_obj['candidates'] = unique([{'x': lower(centroid, 1), 'y': lower(centroid, 0), 'width': bbox_size, 'height': bbox_size} for centroid in centroids], key=lambda cand: (cand['x'], cand['y']))\n img_json_obj['candidates'] = clust_bboxes\n if data == 'train':\n out_train_json_objs[data_meta[idx]['class']].append(img_json_obj)\n else:\n out_json_obj.append(img_json_obj)\n \n \n if output:\n # Summarise total performance\n if data == 'train':\n #box_precision = 100*tp_boxes / float(num_boxes) if num_boxes > 0 else -1\n #fish_recall = 100*tp_fish / float(num_fish) if num_fish > 0 else -1\n #print('\\n%d images completed!\\nTotal box precision: %g%% (%d/%d)\\nTotal fish recall: %g%% (%d/%d%s)\\n' % (len(img_idxs), box_precision, tp_boxes, num_boxes, fish_recall, tp_fish, num_fish, (', %d impossible' % num_impossible) if num_impossible > 0 else ''))\n \n box_precision = [100*tp_boxes_i / float(num_boxes) if num_boxes > 0 else -1 for tp_boxes_i in tp_boxes]\n compact_box_precision = [100*tp_boxes_i / float(num_boxes) if num_boxes > 0 else -1 for tp_boxes_i in tp_compact_boxes]\n fish_recall = [100*tp_fish_i / float(num_fish) if num_fish > 0 else -1 for tp_fish_i in tp_fish]\n compact_fish_recall = [100*tp_fish_i / float(num_fish) if num_fish > 0 else -1 for tp_fish_i in tp_compact_fish]\n \n print('\\n%d images completed!\\nTotal compact box precision: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom\\nTotal compact fish recall: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom' % (idx_idx+1, compact_box_precision[0], tp_compact_boxes[0], num_boxes, compact_box_precision[1], tp_compact_boxes[1], num_boxes, compact_box_precision[2], tp_compact_boxes[2], num_boxes, compact_fish_recall[0], tp_compact_fish[0], num_fish, compact_fish_recall[1], tp_compact_fish[1], num_fish, compact_fish_recall[2], tp_compact_fish[2], num_fish))\n print('Total encompassing box precision: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom\\nTotal encompassing fish recall: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom\\n' % (box_precision[0], tp_boxes[0], num_boxes, box_precision[1], tp_boxes[1], num_boxes, box_precision[2], tp_boxes[2], num_boxes, fish_recall[0], tp_fish[0], num_fish, fish_recall[1], tp_fish[1], num_fish, fish_recall[2], tp_fish[2], num_fish))\n else:\n print('%d images segmented (%d candidates in total)' % (idx_idx+1, num_boxes))\n\n if save_candidates:\n outdir = settings.SEGMENTATION_CANDIDATES_OUTPUT_DIR\n os.makedirs(outdir)\n filename = 'candidates%s.json' % ('' if img_idxs is None else ('_%d-%d' % (min(img_idxs), max(img_idxs))))\n if data == 'train':\n for cls in classlist:\n with open(os.path.join(outdir, cls + '_' + filename), 'w') as outfile:\n json.dump(out_train_json_objs[cls], outfile)\n else:\n with open(os.path.join(outdir, filename), 'w') as outfile:\n json.dump(out_json_obj, outfile)","def run_evaluation(self, n_runs=1, n_points=1000, n_iterations=1, min_n_components=2, max_n_components=25,\n\t\t\t\t\t n_splits=3, save_data=False, file_label='',n_microstates=None, all_methods=True,\n\t\t\t\t\t assign_transition_points=True):\n\n\t\tif self.presampled_data is not None:\n\t\t\tsampled_data = self.presampled_data[0]\n\t\t\ttrue_clustering = self.presampled_data[1]\n\t\t\tn_runs = sampled_data.shape[0]\n\n\t\tself.cluster_score_ami_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tself.cluster_score_fm_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tself.cluster_score_vm_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tdata = self.toy_model_.sample(3)\n\n\t\t# Create free energy estimators\n\t\tgmm_FE = GMM_FE.FreeEnergyClustering(data, min_n_components=min_n_components, max_n_components=max_n_components,\n\t\t\t\t\t\t\t\t\t x_lims=self.x_lims_, n_grids=self.n_grids_, stack_landscapes=False,\n\t\t\t\t\t\t\t\t\t n_splits=n_splits, n_iterations=n_iterations,convergence_tol=self.convergence_tol_,\n\t\t\t\t\t\t\t\t\t verbose=self.verbose_)\n\n\t\tkm = kmc.KMeansCluster(min_n_components, max_n_components)\n\t\taw = awc.AWCluster(min_n_components, max_n_components)\n\t\tspectral = sc.SpectralCluster(min_n_components, max_n_components)\n\n\t\tall_data = []\n\t\tfor i_run in range(n_runs):\n\t\t\tprint(\"Run: \"+str(i_run+1)+'/'+str(n_runs))\n\n\t\t\tif self.presampled_data is None:\n\t\t\t\t# Sample data\n\t\t\t\tdata = self.toy_model_.sample(n_points)\n\t\t\telse:\n\t\t\t\tdata = sampled_data[i_run]\n\t\t\t\n\t\t\tall_data.append(data)\n\n\t\t\tprint('Shape data: ' + str(data.shape))\n\n\t\t\t# Set data in model and estimate GMM density\n\t\t\tgmm_FE.data_ = data\n\t\t\tcoords, est_FE_landsc, FE_points = gmm_FE.landscape()\n\n\t\t\t# Get true cluster labels\n\t\t\tif self.presampled_data is None:\n\t\t\t\tif hasattr(self.toy_model_, \"assign_cluster_labels\"):\n\t\t\t\t\tself.true_labels_ = self.toy_model_.assign_cluster_labels(data)\n\t\t\t\telse:\n\t\t\t\t\tprint('Setting true labels.')\n\t\t\t\t\tself.true_labels_, _ = self.true_FE_.cluster(data, np.zeros(data.shape[0]))\n\t\t\telse:\n\t\t\t\tself.true_labels_ = true_clustering[i_run]\n\t\t\t\n\t\t\t# Cluster data with different methods\n\t\t\tif n_microstates is None:\n\t\t\t\tself.FE_min_labels, _ = gmm_FE.cluster(data, FE_points, assign_transition_points=assign_transition_points)\n\t\t\telse:\n\t\t\t\tkmea = KMeans(n_clusters=n_microstates).fit(data[::2])\n\t\t\t\tmicrostate_centers = kmea.cluster_centers_\n\t\t\t\tself.FE_min_labels, _ = gmm_FE.cluster(microstate_centers, FE_points, data, assign_transition_points=assign_transition_points, unravel_grid=False)\n\n\t\t\tif all_methods:\n\t\t\t\tself.km_labels = km.cluster(data)\n\t\t\t\tself.aw_labels = aw.cluster(data)\n\t\t\t\tself.spectral_labels = spectral.cluster(data)\n\n\t\t\t# Score clustering using different scoring metrics\n\t\t\t# V-measure score\n\t\t\tself.cluster_score_vm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'vm')\n\t\t\tprint(self.cluster_score_vm_GMM_FE_min_[i_run])\n\t\t\tif all_methods:\n\t\t\t\tself.cluster_score_vm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'vm')\n\t\t\t\tself.cluster_score_vm_kmeans_[i_run] = self._score_clustering(self.km_labels,'vm')\n\t\t\t\tself.cluster_score_vm_AW_[i_run] = self._score_clustering(self.aw_labels,'vm')\n\t\t\t\tself.cluster_score_vm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'vm')\n\n\t\t\t\t# Adjusted MI\n\t\t\t\tself.cluster_score_ami_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'ami')\n\t\t\t\tself.cluster_score_ami_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'ami')\n\t\t\t\tself.cluster_score_ami_kmeans_[i_run] = self._score_clustering(self.km_labels,'ami')\n\t\t\t\tself.cluster_score_ami_AW_[i_run] = self._score_clustering(self.aw_labels,'ami')\n\t\t\t\tself.cluster_score_ami_spectral_[i_run] = self._score_clustering(self.spectral_labels,'ami')\n\n\t\t\t\t# Fowlkes Mallows\n\t\t\t\tself.cluster_score_fm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'fm')\n\t\t\t\tself.cluster_score_fm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'fm')\n\t\t\t\tself.cluster_score_fm_kmeans_[i_run] = self._score_clustering(self.km_labels,'fm')\n\t\t\t\tself.cluster_score_fm_AW_[i_run] = self._score_clustering(self.aw_labels,'fm')\n\t\t\t\tself.cluster_score_fm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'fm')\n\t\t\n\t\tif save_data:\n\t\t\tif self.presampled_data is None:\n\t\t\t\tnp.save('data_out/sampled_data_'+self.toy_model_.name+file_label+'.npy',all_data)\n\n\t\t\tif False:\n\t\t\t\tnp.save('data_out/cluster_score_fm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_fm_GMM_FE_min_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_kmeans_' + self.toy_model_.name +file_label +'.npy', self.cluster_score_fm_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_spectral_)\n\n\t\t\t\tnp.save('data_out/cluster_score_ami_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_ami_GMM_FE_min_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_spectral_)\n\n\t\t\tnp.save('data_out/cluster_score_vm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_vm_GMM_FE_min_)\n\t\t\tif all_methods:\n\t\t\t\tnp.save('data_out/cluster_score_vm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_spectral_)\n\t\treturn","def predict(self):\n for track in self.tracks:\n track.predict(self.kf)\n #track.du_doan(self.kf_test)","def train_real():\n real_clusters, ei = create_clusters()\n real_data, labels, step_nb = create_cheat_comparison_with_cluster(\n real_clusters, ei)\n X = np.array(real_data)\n Y = np.array(labels)\n\n model = Sequential()\n model.add(LSTM(units=128, input_shape=(2, 50)))\n model.add(Dropout(0.5))\n model.add(Dense(1, activation=\"sigmoid\"))\n\n my_callbacks = [EarlyStopping(monitor='auc_roc', patience=300, verbose=1, mode='max'),\n TensorBoard(log_dir=\"logs/{}\".format(time()))]\n\n model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=[\n 'accuracy', auc_roc, f1_score_threshold(), precision_threshold(), recall_threshold()])\n model.fit(\n X,\n Y,\n batch_size=100,\n epochs=30,\n validation_split=0.4,\n callbacks=my_callbacks,\n shuffle=True\n )\n\n # Use this to save the weights to be able to reload them while testing\n model.save_weights(WEIGHTS_DIR+'/my_real_model_clusters_weights.h5')","def cluster_assign(images_lists, dataset):\n assert images_lists is not None\n pseudolabels = []\n image_indexes = []\n for cluster, images in enumerate(images_lists):\n image_indexes.extend(images)\n pseudolabels.extend([cluster] * len(images))\n print(image_indexes)\n print(pseudolabels)\n \n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n t = transforms.Compose([transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n normalize])\n\n return ReassignedDataset(image_indexes, pseudolabels, dataset, t)","def train():\n pass","def predict(self, data):\n\t\treturn closestCluster(data, self.centers)","def main(feats_name, targets_name, model_name, n_boot, seed_start, output_filename, train_test_flag):\n\n #load feats and targets\n input_dict = {}\n input_dict['feats'] = 'data/%s' % (feats_name)\n input_dict['targets'] = 'data/%s' % (targets_name)\n #load the feats and targets\n df = pd.read_csv(\"%s\" % (input_dict['feats']))\n targets = pd.read_csv(\"%s\" % (input_dict['targets']))\n #drop columns not used for prediction\n drop_cols = [\"Unnamed: 0\",\"index\"]\n for dc in drop_cols:\n if dc in targets.columns:\n targets = targets.drop(dc,axis=1)\n if dc in df.columns:\n df = df.drop(dc,axis=1)\n #reduce to training or test set only if requested\n if (train_test_flag == 'train') and ('test_set' in df.columns):\n targets = targets[df['test_set'] == 0]\n df = df[df['test_set'] == 0]\n elif (train_test_flag == 'test') and ('test_set' in df.columns):\n targets = targets[df['test_set'] == 1]\n df = df[df['test_set'] == 1]\n df = df.drop('test_set', axis = 1)\n \n #broadcast the feats and targets\n df_b = sc.broadcast(df)\n targets_b = sc.broadcast(targets)\n\n #Set up the classifier. 3fold CV for selection of regularization term.\n if model_name == 'linear':\n model = LinearRegression(fit_intercept=True,\n normalize=False,\n copy_X=True,\n n_jobs=1) \n elif model_name == 'lasso':\n model = LassoCV(alphas = [.05,.1,.2],\n normalize = False,\n fit_intercept = True,\n verbose = False,\n copy_X = False,\n n_jobs = 3)\n elif model_name == 'ridge':\n model = RidgeCV(alphas = [.00001,.0001,.001,.01,.1,1,10,100,1000,10000],\n normalize = False,\n fit_intercept = True,\n verbose = 1,\n cv = 3)\n else:\n raise ValueError('model_name not recognized.')\n \n #Create an RDD that specifies prng seed to use\n samp_list = [(n,) for n in np.arange(seed_start, seed_start+n_boot)]\n samp_rdd = sc.parallelize(samp_list,n_boot) #create RDD with one partition for each row (second arg is number of partitions)\n #Create a function that takes a tuple as input and returns \n def func(tup):\n \"\"\"\n Takes as input a tuple containing an integer. The integer specifies the random seed that will be used to \n randomly sample, with replacement, observations from the feats set provided. The model is fitted to the \n sampled feats. Resulting best fit parameters, along with some other summary statistics and information are\n provided as input in a JSON string that will be written to the output file when all jobs are completed.\n \n Parameters\n ----------\n tup, rdd\n - series of tuples with different integer values defining the RNG seed to be used to sample observations\n \n Returns\n ----------\n tup[0], int\n - the seed that was used\n json.dumps(results_dict), str\n - dict in json format with the following keys:\n - alpha, the regularization term providing the best fit according to 3 fold cross-validation\n - random_state, the initial state used for fitting\n - training_feats, the name of the training_feats csv file\n - training_targets, the name of the target variable csv file\n - cv, the type of cross-validation used\n - sklearn_version, which version of sklearn was used\n - mse_min, the mean squared error for the test set on each fold\n - r2, the r-squared value (% var explained)\n - coef, parameter vector\n - intercept, intercept parameter\n - column_names, feature name corresponding to each parameter in the parameter vector\n \"\"\"\n #take a random sample with replacement\n np.random.seed(seed=tup[0]) #set the seed\n n_obs = np.shape(df_b.value)[0] #number of observations determines sample size\n samp = list(np.random.randint(0,high=n_obs,size=n_obs)) #draw the random sample with replacement\n #fit the model\n tic = time.time()\n results = model.fit(df_b.value.iloc[samp,:],np.ravel(targets_b.value.iloc[samp]))\n toc = tic - time.time()\n #save the results in a dict\n results_dict = {}\n results_dict['alpha'] = results.alpha_\n results_dict['random_state'] = results.random_state\n results_dict['training_feats'] = input_dict['feats']\n results_dict['training_targets'] = input_dict['targets']\n results_dict['cv'] = results.cv\n results_dict['sklearn_version'] = sklearn.__version__\n results_dict['mse_min'] = results.mse_path_.min()\n results_dict['r2'] = results.score(df_b.value.iloc[samp,:],np.ravel(targets_b.value.iloc[samp]))\n results_dict['coef'] = list(results.coef_)\n results_dict['intercept'] = results.intercept_\n results_dict['column_names'] = [i for i in df_b.value.columns]\n results_dict['fit_time'] = toc\n #convert results dict to json and save in tuple\n return(json.dumps(results_dict))\n\n #fit model in parallel\n results = samp_rdd.map(lambda p: func(p))\n #save to text file\n results.saveAsTextFile(output_filename)\n #stop the SparkContext.\n if not local_mode:\n sc.stop()","def train(self):\n\t\traise NotImplementedError","def load_data():\n data = gzip.open(\"mnist.pkl.gz\", \"rb\")\n train_set, valid_set, test_set = cPickle.load(data)\n data.close()\n\n # Combine validation and train folds to recreate the master 60k set.\n new_images = numpy.concatenate((train_set[0], valid_set[0]))\n new_labels = numpy.concatenate((train_set[1], valid_set[1]))\n\n train_set = (new_images, new_labels)\n \n return (train_set, test_set)","def _automatic_training_set(self, n_cutouts=100):\n dstl = Load_DSTL()\n np.random.seed(42)\n for ii in range(n_cutouts):\n # Get region around a shape\n triples, mask, ind_shape, img_dim = dstl.extract_region(object_class=self.class_type, image_id='6120_2_2', buffer_size=10)\n if self.radius is not None:\n triples, mask = self._sliding_window(triples.reshape(*img_dim, 3), mask.reshape(img_dim), window_radius=self.radius)\n # Add to Feature Matrix\n if ii == 0:\n features = triples\n labels = mask\n else:\n features = np.vstack([features, triples])\n labels = np.hstack([labels, mask])\n return features, labels","def main():\n\n logger.info('Process initiated - Building dataset')\n\n if os.path.isfile(train_path) and os.path.isfile(test_path):\n logger.info('Loading pickled data')\n return pd.read_pickle(train_path), pd.read_pickle(test_path)\n\n logger.info('Reading COSMIC Cancer Gene Census')\n gene_census = cancer_gene_census()\n gene_census.extend(civic_cancer_genes())\n\n gene_census = set(gene_census)\n\n training_data = pd.DataFrame()\n testing_data = pd.DataFrame()\n\n for cancer_type in cancer_types:\n data_file_name = cancer_type + \".meth.by_mean.data.txt\"\n data_file_location = os.path.join(data_location, data_file_name)\n\n logger.info('Reading Methylation data for {}'.format(cancer_type))\n\n methyl_data = pd.read_csv(data_file_location, delimiter='\\t', skiprows=[1], index_col=0)\n\n logger.info(\n 'Number of Genes: {0} | Number of Patients: {1}'.format(methyl_data.shape[0], methyl_data.shape[1]))\n logger.info('Preprocessing Methylation data')\n\n methyl_data = genes_feature_selection(methyl_data, gene_census)\n\n logger.info('Number of Genes after processing: {0}\\n'.format(methyl_data.shape[0]))\n\n methyl_data = add_classification_label(methyl_data)\n methyl_data = methyl_data.transpose()\n\n normal_cases = methyl_data[methyl_data['Tumor'] == 0]\n logger.info(normal_cases.shape)\n train_normal_cases = normal_cases.sample(frac=0.7, random_state=200)\n logger.info(train_normal_cases.shape)\n test_normal_cases = normal_cases.drop(train_normal_cases.index)\n logger.info(train_normal_cases.shape)\n\n tumor_cases = methyl_data[methyl_data['Tumor'] != 0]\n logger.info(tumor_cases.shape)\n train_tumor_cases = tumor_cases.sample(frac=0.7, random_state=200)\n logger.info(train_tumor_cases.shape)\n\n test_tumor_cases = tumor_cases.drop(train_tumor_cases.index)\n logger.info(test_tumor_cases.shape)\n\n training_data = training_data.append(train_normal_cases)\n training_data = training_data.append(train_tumor_cases)\n\n testing_data = testing_data.append(test_normal_cases)\n testing_data = testing_data.append(test_tumor_cases)\n\n training_data = training_data.sample(frac=1)\n testing_data = testing_data.sample(frac=1)\n\n logger.info('Pickling training and testing data')\n training_data.to_pickle(train_path)\n testing_data.to_pickle(test_path)\n\n logger.info('Processing completed!')\n visualize_data(training_data)\n\n return training_data, testing_data","def create_tf_datasets(self):\n images = []\n labels = []\n\n images = self.dataframe_labeled_samples.index.values\n\n labels.append(\n tuple(self.dataframe_labeled_samples['Intersection'].values.astype('uint8')))\n\n images = [\n os.path.join(\n os.path.dirname(\n self.summary_manager.current_labelgui_summary_filepath),\n img_name) for img_name in images]\n labels = list(chain.from_iterable(labels))\n\n\n if self.validation_split == 0:\n images = np.array([\n self.image_preprocessor(\n imageio.imread(f)) for f in tqdm(images)])\n images = tf.data.Dataset.from_tensor_slices(images)\n labels = tf.data.Dataset.from_tensor_slices(labels)\n dataset = tf.data.Dataset.zip((images, labels))\n return dataset, None\n\n images, images_val, labels, labels_val = train_test_split(\n images, labels, test_size=self.validation_split, random_state=0)\n\n train_split_filename = ((\n f'{self.save_checkpoint_filepath or self.checkpoint_filepath}'\n f'_train_split.txt'\n ))\n print(f\"Saving train split files to: {train_split_filename}\")\n with open(train_split_filename, 'w+')\\\n as train_split_file:\n for img in images:\n train_split_file.write(img + '\\n')\n \n val_split_filename = ((\n f'{self.save_checkpoint_filepath or self.checkpoint_filepath}'\n f'_val_split.txt'\n ))\n print(f\"Saving train split files to: {val_split_filename}\")\n with open(val_split_filename, 'w+')\\\n as val_split_file:\n for img in images_val:\n val_split_file.write(img + '\\n')\n\n print(f\"Loading validation image paths ({len(images)}) with preprocessor\")\n images = np.array([\n self.image_preprocessor(\n imageio.imread(f)) for f in tqdm(images)])\n images = tf.data.Dataset.from_tensor_slices(images)\n\n print(f\"Loading labels into tf tensor\")\n labels = tf.data.Dataset.from_tensor_slices(labels)\n print(f\"Creating zipped dataset with images and labels\")\n dataset = tf.data.Dataset.zip((images, labels))\n\n print(f\"Loading validation image paths ({len(images_val)}) with preprocessor\")\n images_val = np.array([\n self.image_preprocessor(\n imageio.imread(f)) for f in tqdm(images_val)])\n #images_val = np.array([self.image_preprocessor(f) for f in tqdm(images_val)])\n images_val = tf.data.Dataset.from_tensor_slices(images_val)\n #images_val = tf.data.Dataset.list_files(images_val)\n #images_val = images_val.map(tf.io.read_file)\n print(f\"Loading validation labels into tf tensor\")\n labels_val = tf.data.Dataset.from_tensor_slices(labels_val)\n print(f\"Creating validation zipped dataset with images and labels\")\n dataset_val = tf.data.Dataset.zip((images_val, labels_val))\n\n return dataset, dataset_val","def main_predefined_split():\n\n average_performance = []\n fold_num = 'predefined'\n output_file_folder = \"output/{}\".format(args.experiment_name)\n output_file_name = \"{}/lnnel_{}.csv\".format(output_file_folder, fold_num)\n Path(output_file_folder).mkdir(parents=True, exist_ok=True)\n args.output_file_name = output_file_name\n\n if args.use_blink:\n df_train = pd.read_csv(\"./data/lcquad/blink/lcquad_train_sorted.csv\")\n df_test = pd.read_csv(\"./data/lcquad/blink/lcquad_test_sorted.csv\")\n else:\n df_train = pd.read_csv(\"./data/lcquad/dbpedia/lcquad_train_sorted.csv\")\n df_test = pd.read_csv(\"./data/lcquad/dbpedia/lcquad_test_sorted.csv\")\n\n # filter out the questions with single positive or many negatives in trianing set\n filtered_question_mentions = []\n for qm in df_train.QuestionMention.unique():\n df_ = df_train[df_train.QuestionMention == qm]\n if df_.Label.sum() == 0:\n filtered_question_mentions.append(qm)\n if df_.Label.sum() == 1 and df_.shape[0] == 1:\n filtered_question_mentions.append(qm)\n # print(df_.Label.values)\n df_train_split_filtered = df_train[~df_train.QuestionMention.isin(filtered_question_mentions)]\n df_train_split_filtered = df_train_split_filtered.sort_values(by=['QuestionMention', 'Label'])\n df_train = df_train_split_filtered\n\n # train\n features_train = np.array(\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_train.Features.values])\n x_train = torch.from_numpy(features_train).float()\n y_train = torch.from_numpy(df_train.Label.values).float().reshape(-1, 1)\n m_labels_train = df_train.Mention_label.values\n ques_train = df_train.Question.values\n\n # test\n features_test = np.array(\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_test.Features.values])\n x_test = torch.from_numpy(features_test).float()\n y_test = torch.from_numpy(df_test.Label.values).float().reshape(-1, 1)\n m_labels_test = df_test.Mention_label.values\n ques_test = df_test.Question.values\n\n # train model and evaluate\n model = pick_model(args.model_name, args.alpha)\n model = model.to(device)\n\n # move to gpu\n x_train, y_train = x_train.to(device), y_train.to(device)\n x_test, y_test = x_test.to(device), y_test.to(device)\n\n print(model)\n\n print(\"model: \", args.model_name, args.alpha)\n print(model(x_train, m_labels_train))\n\n print(\"y_train sum\", sum(y_train), sum(y_train) / len(y_train))\n print(\"y_test sum\", sum(y_test), sum(y_test) / len(y_test))\n\n # aggregate the data into train, val, and test\n train_data = (x_train, y_train, m_labels_train, ques_train)\n print(\"train:\", x_train.shape, y_train.shape, m_labels_train.shape, ques_train.shape)\n test_data = (x_test, y_test, m_labels_test, ques_test)\n print(\"test:\", x_test.shape, y_test.shape, m_labels_test.shape, ques_test.shape)\n\n # check class distribution\n print(\"y_train sum\", sum(y_train), sum(y_train) / len(y_train))\n print(\"y_test sum\", sum(y_test), sum(y_test) / len(y_test))\n\n train(model, train_data, test_data, test_data, args.checkpoint_name, args.num_epoch, args.margin,\n args.learning_rate)\n test_pred, best_scores = test(x_test, m_labels_test, ques_test, args.alpha, args.checkpoint_name,\n args.model_name,\n args.output_file_name)\n with open(args.log_file_name, 'a') as f:\n f.write(\n \"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}; lr={}; margin={}\\n\".format(\n args.model_name,\n args.use_fixed_threshold,\n args.alpha,\n best_scores[\n 'precision'],\n best_scores[\n 'recall'],\n best_scores['f1'],\n args.learning_rate,\n args.margin))\n print(\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}\\n\".format(args.model_name,\n args.use_fixed_threshold,\n args.alpha,\n best_scores['precision'],\n best_scores['recall'],\n best_scores['f1']))\n average_performance.append([best_scores['precision'], best_scores['recall'], best_scores['f1']])\n\n average_performance = np.array(average_performance)\n print(\"Avg performance is prec - rec - f1: \", average_performance.mean(0))","def get_train(self, even=None):\n\n #self.images, self.labels, self.traces = trace_data.get_my_teacher()\n _, self.images, self.labels, self.traces, _ = trace_data.get_my_teacher()\n #print(self.labels)\n self.length = len(self.images)\n self.create_teacher()","def setUp(self):\n\n # Load the data\n dataset = tagging.data.DataSet.from_fits(DATA_PATH, extension=1)\n\n # Assign all as field.\n dataset.data[\"FIELD/CLUSTER\"] = \"FIELD\"\n\n # [TODO] Delete benchmarks\n clusters = (\"Cha_I\", \"Br81\", \"M15\", \"NGC2808\", \"NGC6633\", \"IC4665\", \n \"NGC104\", \"gamma2_Vel\", \"GJ880\", \"NGC4815\", \"NGC2547\", \"NGC5927\",\n \"NGC4833\", \"NGC1851\", \"NGC2243\", \"NGC3532\", \"NGC6752\", \"Br25\", \n \"NGC4372\", \"NGC6705\", \"M67\", \"NGC2516\", \"Trumpler20\")\n\n # Assign all as members.\n for cluster in clusters:\n members = dataset.assign_cluster_members(cluster,\n lambda row: row[\"TARGET\"].startswith(cluster))\n\n # Special hack:\n if cluster == \"Trumpler20\":\n members += dataset.assign_cluster_members(cluster,\n lambda row: row[\"TARGET\"].startswith(\"Trumpler_20\"))\n\n logger.info(\"Assigned stars to {} clusters\".format(len(clusters)))\n self.dataset = dataset\n return None","def init_loaders_predict(self, data_dict, label_dict):\n return self.init_loaders(data_dict, label_dict)","def setUp(self):\n self.batch_size = 8\n num_keypoints = 15\n self.data_batch = []\n self.data_samples = []\n\n for i in range(self.batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n\n self.data_batch.append(data)\n self.data_samples.append(data_sample)","def setUp(self):\n self.batch_size = 8\n num_keypoints = 15\n self.data_batch = []\n self.data_samples = []\n\n for i in range(self.batch_size):\n gt_instances = InstanceData()\n keypoints = np.zeros((1, num_keypoints, 2))\n keypoints[0, i] = [0.5 * i, 0.5 * i]\n gt_instances.keypoints = keypoints\n gt_instances.keypoints_visible = np.ones(\n (1, num_keypoints, 1)).astype(bool)\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\n\n pred_instances = InstanceData()\n pred_instances.keypoints = keypoints\n\n data = {'inputs': None}\n data_sample = {\n 'gt_instances': gt_instances.to_dict(),\n 'pred_instances': pred_instances.to_dict(),\n }\n\n self.data_batch.append(data)\n self.data_samples.append(data_sample)","def main():\n # Read in trainingSet and testSet as a DataFrame\n trainingOriginal = pd.read_csv(\n filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.train.5fold.csv\")\n testOriginal = pd.read_csv(filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.test.csv\")\n\n # Select only the numeric data\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\n training = pd.concat([training.reset_index(drop=True),\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Select only the numeric data\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\n test = pd.concat([test.reset_index(drop=True),\n testOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Normalize the columns for training and test\n # print training['age'].min()\n # print training['age'].max()\n # print training.head()\n\n # Run max-min normalization on numerical columns for testing and training data\n for i in range(6):\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\n\n # Convert the 'earns' column to boolean as follows\n training['earns'] = training['earns'] == '>50K'\n test['earns'] = test['earns'] == ' >50K'\n\n # Group the training set by the fold attribute as given by the dataset\n trainingForFinal = training\n training = training.groupby('fold')\n\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\n kList = []\n for i in range(40):\n if i % 2 == 1:\n kList.append(i)\n\n # Empty dictionary to hold performance of each k-values and its accuracy\n performance = {}\n\n # Compute the performance for each k-value\n for k in kList:\n performance = crossValidation(training, k, performance)\n\n # Sort the performance dictionary by its accuracy (value)\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\n\n # Open file to write results\n file = open('grid.results.txt', 'w')\n # Write the results to file\n file.write(\"K | Accuracy\\n\")\n for item in performance:\n if item[0] < 10:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n else:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n # Close file\n file.close()\n\n # The best K is the one at the top of the list after the sorting\n bestK = performance[0][0]\n\n print 'Running Test Set with K = ' + str(bestK)\n\n applyModel(test,trainingForFinal,bestK)","def init_centroids(self, data_points):\n # print(\"Init centroid\")\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\n\n # Project the data: this step will take several seconds\n\n centroids_scaled = self.naive_sharding(data_points, self.k)\n return list(centroids_scaled)\n\n #sample = np.random.permutation(len(labelled_data))[:self.k]\n\n #return list(map(lambda x: labelled_data[x][1], sample))"],"string":"[\n \"def pre_train(self, dataset):\\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\\n pe = principleextractor.PrincipleExtractor()\\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\\n # not in the .json; or with argument given TODO\\n self.skm.add_syllogistic_data(data=pd_dataset)\\n\\n self.skm.generate_clusters(cutoff=self.cutoff)\\n\\n results = pe.extract_principles_from_k_clusters(self.skm.final_clusters_syll_list)\\n\\n participant_correspondence = principleextractor.compute_participant_correspondence(self.skm.subj_data_dict,\\n self.skm.final_clusters_num)\\n principleextractor.write_results(results[0], results[1], self.skm.final_clusters_syll_list,\\n participant_correspondence)\\n\\n self.k_clusters = self.skm.final_clusters_syll_list\\n\\n gen_skm = syllogistickmeans.SyllogisticKMeans(1)\\n gen_skm.add_syllogistic_data(data=pd_dataset)\\n\\n gen_skm.generate_clusters(cutoff=self.cutoff)\\n\\n self.current_k_cluster = gen_skm.final_clusters_syll_list[0]\",\n \"def predict(toPredict=None):\\n\\tif not toPredict:\\n\\t\\ttoPredict = gc.generate_test_cases(1)[0]\\n\\ttoPredict = np.asarray(toPredict)\\n\\ttoPredict = toPredict.reshape(1, -1)\\t\\n\\tclusterer = joblib.load(\\\"training_data.pkl\\\")\\n\\tprint(clusterer.predict(toPredict))\",\n \"def kmeans_002():\\n train_mmap_path = 'data/train_cropped_150_scale_15.memmap'\\n test_mmap_path = 'data/test_cropped_150_scale_15.memmap'\\n\\n if not os.path.exists('data/train_cropped_150.memmap'):\\n classes.crop_to_memmap(150, training=True)\\n if not os.path.exists('data/test_cropped_150.memmap'):\\n classes.crop_to_memmap(150, training=False)\\n\\n if not os.path.exists(train_mmap_path):\\n logger.info(\\\"Prepping training images\\\")\\n pre_scale = np.memmap('data/train_cropped_150.memmap', mode='r', shape=(N_TRAIN, 150, 150, 3))\\n trainX = classes.rescale_memmap(15, pre_scale, train_mmap_path)\\n del pre_scale\\n else:\\n trainX = np.memmap(train_mmap_path, mode='r', shape=(N_TRAIN, 15, 15, 3))\\n\\n if not os.path.exists(test_mmap_path):\\n logger.info(\\\"Prepping testing images\\\")\\n pre_scale = np.memmap('data/test_cropped_150.memmap', mode='r', shape=(N_TEST, 150, 150, 3))\\n testX = classes.rescale_memmap(15, pre_scale, test_mmap_path)\\n del pre_scale\\n else:\\n testX = np.memmap(test_mmap_path, mode='r', shape=(N_TEST, 15, 15, 3))\\n\\n\\n n_jobs = multiprocessing.cpu_count()\\n\\n if not os.path.exists('data/mdl_kmeans_002_centroids.npy'):\\n logger.info(\\\"Pretraining KMeans feature encoder\\\")\\n km = models.KMeansFeatures.KMeansFeatures(rf_size=5, num_centroids=1600, num_patches=400000)\\n km.fit(trainX)\\n km.save_to_file('mdl_kmeans_002')\\n else:\\n logger.info(\\\"Loading KMeans feature encoder from file\\\")\\n km = models.KMeansFeatures.KMeansFeatures.load_from_file('mdl_kmeans_002', rf_size=5)\\n\\n # Takes waaaay too long to finish. At least an hour per tree. Clearly too\\n # many dimensions\\n\\n # Instead ran with ridge rf manually\\n mdl = models.RandomForest.KMeansRandomForest(km, trainX, testX, n_jobs=n_jobs, cv_sample=0.5)\\n # mdl.run('cv')\\n mdl.run('train')\\n res = mdl.run('predict')\\n np.save('submissions/sub_kmeans_rf_002.npy', res)\\n output = classes.Submission(res)\\n output.to_file('sub_kmeans_rf_002.csv')\",\n \"def run_classification_experiment ( feature_matrix, target_array, colmap ):\\n np.random.seed ( 7062020 ) # Due date\\n\\n # Split off validation set and cross-validation set\\n X_validation = feature_matrix [ : feature_matrix.shape [ 0 ] // 10 ]\\n X_cross_validation = feature_matrix [ feature_matrix.shape [ 0 ] // 10 : ]\\n y_validation = target_array [ : feature_matrix.shape [ 0 ] // 10 ]\\n y_cross_validation = target_array [ feature_matrix.shape [ 0 ] // 10 : ]\\n\\n experiment_results = {}\\n experiment_num = 1\\n\\n # Use 5-Fold stratified CV\\n kfold_strat = KFoldStratifiedCV ( number_of_folds = 5, shuffle = True )\\n\\n for train, test in kfold_strat.split ( feature_matrix = X_cross_validation, target_array = y_cross_validation ):\\n logger.info ( f\\\"Experiment Number: { experiment_num }\\\" )\\n\\n # Get training set\\n X_train = X_cross_validation [ train, : ]\\n y_train = y_cross_validation [ train ]\\n\\n # Fit the tree\\n d_tree = DecisionTreeClassifier ( evaluate_function = entropy, map_column_node_type = colmap )\\n d_tree.fit ( X_train, y_train )\\n\\n # Prune the tree\\n pruned_tree = PostPruner (\\n d_tree,\\n X_validation = X_validation,\\n y_validation = y_validation,\\n evaluate_function = accuracy,\\n ).prune_tree()\\n\\n # Get post-pruned predictions\\n pruned_preds = pruned_tree.predict ( X_cross_validation [ test, : ] )\\n\\n # Save the results\\n experiment_results [ experiment_num ] = {\\n \\\"actuals\\\": y_cross_validation [ test ],\\n \\\"preds\\\": pruned_preds,\\n \\\"model\\\": pruned_tree,\\n }\\n experiment_num += 1\\n\\n return experiment_results\\n # End run_classification_experiment\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def setup_datasets(self):\\r\\n\\r\\n train_transform = transforms.Compose(\\r\\n [\\r\\n transforms.Resize(self.crop_size),\\r\\n transforms.RandomRotation(degrees=self.random_angle, resample=Image.BILINEAR),\\r\\n transforms.RandomResizedCrop(\\r\\n size=self.crop_size, scale=(1-self.random_scale, 1+self.random_scale), ratio=(1, 1)),\\r\\n transforms.RandomHorizontalFlip(),\\r\\n transforms.ToTensor(),\\r\\n transforms.Normalize(\\r\\n mean=[0.485, 0.456, 0.406],\\r\\n std=[0.229, 0.224, 0.225]\\r\\n )\\r\\n ]\\r\\n )\\r\\n val_transform = transforms.Compose(\\r\\n [\\r\\n transforms.Resize(self.crop_size),\\r\\n transforms.CenterCrop(self.crop_size),\\r\\n transforms.ToTensor(),\\r\\n transforms.Normalize(\\r\\n mean=[0.485, 0.456, 0.406],\\r\\n std=[0.229, 0.224, 0.225]\\r\\n )\\r\\n ]\\r\\n )\\r\\n\\r\\n train_dataset = CocoDatasetPairs(\\r\\n root_dir=self.coco_path,\\r\\n set_name='train2014',\\r\\n transform=train_transform,\\r\\n dataset_size_ratio=self.dataset_size_ratio\\r\\n )\\r\\n train_subset_dataset = Subset(train_dataset, range(0, len(train_dataset), 5*self.dataset_size_ratio))\\r\\n val_dataset = CocoDatasetPairs(\\r\\n root_dir=self.coco_path,\\r\\n set_name='val2014',\\r\\n transform=val_transform,\\r\\n )\\r\\n\\r\\n train_loader = DataLoader(\\r\\n train_dataset,\\r\\n batch_size=self.batch_size,\\r\\n shuffle=True,\\r\\n num_workers=self.num_workers\\r\\n )\\r\\n train_subset_loader = DataLoader(\\r\\n train_subset_dataset,\\r\\n batch_size=self.batch_size,\\r\\n shuffle=False,\\r\\n num_workers=self.num_workers\\r\\n )\\r\\n val_loader = DataLoader(\\r\\n val_dataset,\\r\\n batch_size=self.batch_size,\\r\\n shuffle=False,\\r\\n num_workers=self.num_workers\\r\\n )\\r\\n return train_loader, train_subset_loader, val_loader\",\n \"def __create_cluster_profiles(self,\\n clustered_dataframes,\\n shrunken_df,\\n numerical_features,\\n le_map,\\n output_path,\\n find_nearest_on_cols=False,\\n show=True):\\n\\n def find_nearest(numbers, target):\\n \\\"\\\"\\\"\\n Find the closest fitting number to the target number\\n \\\"\\\"\\\"\\n numbers = np.asarray(numbers)\\n idx = (np.abs(numbers - target)).argmin()\\n return numbers[idx]\\n\\n cluster_profiles_df = pd.DataFrame(columns=shrunken_df.columns).drop(\\n 'Cluster_Name', axis=1)\\n rows_count = 0\\n for cluster_identfier, cluster_dataframe in \\\\\\n clustered_dataframes.items():\\n df = pd.DataFrame(columns=cluster_dataframe.columns)\\n df = df.append(cluster_dataframe.mean(), ignore_index=True)\\n df.index = [cluster_identfier]\\n\\n if cluster_dataframe.shape[0] <= 1:\\n continue\\n\\n # Attempt to convert numbers found within the full set of data\\n for col in cluster_dataframe.columns:\\n if col not in numerical_features or find_nearest_on_cols:\\n df[col] = find_nearest(numbers=shrunken_df[\\n col].value_counts().index.tolist(),\\n target=df[col].values[0])\\n\\n # Evaluate cluster dataframe by dataframe\\n eval_df = pd.DataFrame(columns=cluster_dataframe.columns)\\n eval_df = eval_df.append(\\n cluster_dataframe.mean(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.min(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.median(),\\n ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.max(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.std(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.var(), ignore_index=True)\\n eval_df.index = [\\\"Mean\\\", \\\"Min\\\", \\\"Median\\\",\\n \\\"Max\\\", \\\"Standard Deviation\\\", \\\"Variance\\\"]\\n\\n if show:\\n print(\\\"Total found in {0} is {1}\\\".format(\\n cluster_identfier, cluster_dataframe.shape[0]))\\n self.__render_mpl_table(\\n df,\\n sub_dir=output_path,\\n filename=cluster_identfier +\\n \\\"_Means_Rounded_To_Nearest_Real_Numbers\\\",\\n header_columns=0,\\n col_width=4.0)\\n\\n self.__render_mpl_table(\\n eval_df,\\n sub_dir=output_path,\\n filename=cluster_identfier +\\n \\\"_Eval_Df\\\",\\n header_columns=0,\\n col_width=4.0)\\n display(df)\\n display(eval_df)\\n self.__vertical_spacing(7)\\n\\n cluster_profiles_df = cluster_profiles_df.append(\\n self.__decode_df(df, le_map))\\n\\n rows_count += cluster_dataframe.shape[0]\\n\\n return rows_count, cluster_profiles_df\",\n \"def predict(self, test_data):\\n if self.centroids_.shape[0]==0:\\n raise ValueError(\\\"No centroids present. Run KMeans.fit first.\\\")\\n\\n print test_data.shape\\n part_of_cluster=np.zeros(test_data.shape[0])\\n for i in range(test_data.shape[0]):\\n dists=[]\\n for c in range(self.centroids_.shape[0]):\\n # compute distance between current train_data instance and each cluster\\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\\n \\n # assign point to cluster with minimal distance\\n part_of_cluster[i]=dists.index(min(dists))\\n\\n return part_of_cluster\",\n \"def prepare_nfold_datasets(self): # i.e. split into different train/ground-truth(test) dataset\\n for alpha in range(1, self.ALPHAs+1):\\n if alpha != self.ALPHAs:\\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI], separator='-')\\n else:\\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI+self.runoff_years], separator='-')\\n new_cluster_dir = str(Path(self.tl_model.cluster_dir) / f'alpha_{alpha}_GT-{gt_years}')\\n os.makedirs(new_cluster_dir, exist_ok=True)\\n\\n new_prepared_data_dir = str(Path(self.tl_model.prepared_data_dir) / f'alpha_{alpha}')\\n os.makedirs(new_prepared_data_dir, exist_ok=True)\\n \\n if utils.find(f'*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir) and utils.find(f'*alpha_{alpha}_standardized_stacked_arr.pkl', new_prepared_data_dir):\\n pass\\n else:\\n if not utils.find(f'*target*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\\n print(f\\\"=> No input datasets pre-processed for alpha of {alpha}\\\")\\n prepare.cut_target_dataset(self, alpha, new_prepared_data_dir)\\n\\n if not utils.find(f'*rf*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\\n print(f\\\"=> No rainfall datasets pre-processed for alpha of {alpha}\\\")\\n prepare.cut_rf_dataset(self, alpha, new_prepared_data_dir)\\n \\n print(f'Preprocessed pickles for alpha split {alpha} can be found @:\\\\n{new_prepared_data_dir}')\",\n \"def kmeans_001(fit_centroids=False):\\n trainX = np.memmap('data/train_cropped_150.memmap', mode='r', shape=(N_TRAIN, 150, 150, 3))\\n # Not used yet\\n testX = np.memmap('data/test_cropped_150.memmap', mode='r', shape=(N_TEST, 150, 150, 3))\\n\\n if fit_centroids:\\n km = models.KMeansFeatures.KMeansFeatures(rf_size=6, num_centroids=1600, num_patches=400000)\\n km.fit(trainX)\\n\\n km.save_to_file('mdl_kmeans_ridge_rf_001')\\n # t0 = time.time()\\n # pickle.dump(km, open('data/kmeans_centroids.pkl', mode='wb'))\\n # print 'Pickling the KMeansFeatures object took {0} seconds'.format(time.time() - t0)\\n else:\\n km = models.KMeansFeatures.KMeansFeatures.load_from_file('mdl_kmeans_ridge_rf_001')\\n # km = pickle.load(open('data/kmeans_centroids.pkl'))\\n\\n n = 10000\\n\\n train_x = km.transform(trainX[0:n, :])\\n train_y = classes.train_solutions.data[0:n, :]\\n # train_x = km.transform(trainX)\\n # train_y = classes.train_solutions.data\\n\\n logger.info(\\\"Train x shape: {}\\\".format(train_x.shape))\\n logger.info(\\\"Train y shape: {}\\\".format(train_y.shape))\\n\\n kf = KFold(n, n_folds=2, shuffle=True)\\n\\n for train, test in kf:\\n # clf = models.Ridge.RidgeRFEstimator()\\n # clf.rf_rgn = RandomForestRegressor(n_estimators=250, n_jobs=4, verbose=3)\\n clf = RandomForestRegressor(n_estimators=20, n_jobs=4, verbose=3, random_state=0, oob_score=True)\\n clf.fit(train_x[train], train_y[train])\\n res = clf.predict(train_x[test])\\n classes.rmse(train_y[test], res)\",\n \"def train(self):\\n\\n print \\\"==> Running Kmeans on data set of shape: {}\\\".format(self.data.shape)\\n km = KMeans(n_clusters = self.n_clusters)\\n km.fit(self.data.values)\\n self.labels = km.labels_\\n self.inertia = km.inertia_\",\n \"def train_and_test(self, data):\\n\\n np.random.shuffle(data)\\n datalist = self.unpack_data(data)\\n\\n logger.info('[*] 75-25 partition of datasets ...')\\n\\n markline1 = math.floor(0.75*(len(datalist['features'])))\\n markline2 = math.floor(0.75*len(datalist['labels']))\\n\\n train_features = datalist['features'][:(markline1)]\\n test_features = datalist['features'][(markline1):]\\n \\n train_labels = datalist['labels'][:(markline2)]\\n test_labels = datalist['labels'][(markline2):]\\n\\n logger.info('[*] Training started with 75% Dataset ...')\\n\\n self.knn_model.fit(train_features, train_labels)\\n\\n logger.info('[*] Testing started with 25% Dataset ...')\\n print('\\\\n/---------------Accuracy----------------/') \\n \\n accuracy = self.knn_model.score(train_features, train_labels)\\n print('Test set accuracy {:.2f} %'.format(accuracy*100))\\n\\n if accuracy < 0.40:\\n logger.warning('[-.-!] Thanks for tryin\\\\' but this machine ain\\\\'t learning.')\\n\\n return True\",\n \"def initSets(self):\\n data_frame = pd.read_csv(self.train_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n if self.test_file is None:\\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n else:\\n data_frame = pd.read_csv(self.test_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n # kfold = KFold(n_splits=3)\\n # self.train_index, self.test_index = kfold.split(features,labels)\",\n \"def train(self):\\r\\n for class_ in set(self.train_classes):\\r\\n data = map(lambda (ind, datum): datum, filter(lambda (ind, datum): self.train_classes[ind] == class_, enumerate(self.train_data)))\\r\\n self.distribution.index_data(data, class_)\",\n \"def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n\\n # Scale the data so that Euclidian distance makes sense\\n means = np.mean(data, axis = 0)\\n stddevs = np.std(data, axis = 0, ddof = 1)\\n\\n #print(means)\\n #print(stddevs)\\n\\n data_scaled = np.zeros((n_examples, n_features))\\n\\n for i in range(n_features):\\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\\n\\n study_correlation(data_scaled)\\n\\n # Initialize the centroids\\n idx = np.random.randint(n_examples, size = n_clusters)\\n centroids = data_scaled[idx, :]\\n\\n counter = 0\\n\\n while True:\\n\\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\\n centroid_idx = np.argmin(distances, axis = 1)\\n old_centroids = centroids\\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\\n #displacement = get_displacement(old_centroids, centroids)\\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\\n\\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\\n\\n if counter == 0:\\n# print(\\\"Initial displacement = {}\\\".format(displacement))\\n initial_displacement = displacement\\n\\n counter += 1\\n\\n if displacement < (initial_displacement / 10000): break\\n\\n #print(\\\"Total number of loops before ending : {}\\\".format(counter))\\n converted_predictions = convert_predictions(centroid_idx)\\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def train():\\n\\n # Load camera parameters\\n rcams = cameras.load_cameras()\\n\\n # Load 3d data and 2d projections\\n full_train_set_3d, full_test_set_3d, data_mean_3d, data_std_3d, dim_to_ignore_3d, dim_to_use_3d =\\\\\\n data_utils.read_3d_data( FLAGS.camera_frame, rcams, FLAGS.origin_bc, FLAGS.augment_data,\\n FLAGS.procrustes, FLAGS.lowpass )\\n \\n # Read stacked hourglass 2D predictions\\n full_train_set_2d, full_test_set_2d, data_mean_2d, data_std_2d, dim_to_ignore_2d, dim_to_use_2d = \\\\\\n data_utils.read_2d_predictions( FLAGS.origin_bc, FLAGS.augment_data )\\n \\n print(\\\"\\\\n[+] done reading and normalizing data\\\")\\n # Getting the number of training and test subjects\\n tr_subj = 0\\n for v in full_train_set_3d.values():\\n tr_subj += v.shape[0]\\n te_subj = 0\\n for v in full_test_set_3d.values():\\n te_subj += v.shape[0]\\n print(\\\"{0} training subjects, {1} test subjects\\\".format(tr_subj, te_subj))\\n print(dim_to_use_2d)\\n print(dim_to_use_3d)\\n # Un-normalizing data for visualizations\\n unNorm_ftrs2d = data_utils.unNormalize_dic(full_train_set_2d, data_mean_2d, data_std_2d, dim_to_use_2d)\\n unNorm_ftrs3d = data_utils.unNormalize_dic(full_train_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\\n unNorm_ftes3d = data_utils.unNormalize_dic(full_test_set_3d, data_mean_3d, data_std_3d, dim_to_use_3d)\\n # Visualize the data\\n viz.visualize_train_sample(unNorm_ftrs2d, unNorm_ftrs3d, FLAGS.camera_frame)\\n viz.visualize_files_oneatatime(unNorm_ftrs3d, unNorm_ftes3d)\\n\\n # Getting only the dimensions to use (get rid of body coxas, other limb, antennas, abdomen\\n train_set_3d, train_set_2d, test_set_3d, test_set_2d = {}, {}, {}, {}\\n for k in full_train_set_3d:\\n (f, c) = k\\n train_set_3d[k] = full_train_set_3d[k][:, dim_to_use_3d]\\n train_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\\\\n full_train_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\\n for k in full_test_set_3d:\\n (f, c) = k\\n test_set_3d[k] = full_test_set_3d[k][:, dim_to_use_3d]\\n test_set_2d[(f, data_utils.CAMERA_TO_USE)] =\\\\\\n full_test_set_2d[(f, data_utils.CAMERA_TO_USE)][:, dim_to_use_2d]\\n \\n print(\\\"3D data mean:\\\")\\n print(data_mean_3d)\\n print(\\\"3D data std:\\\")\\n print(data_std_3d)\\n\\n print(\\\"2D data mean:\\\")\\n print(data_mean_2d)\\n print(\\\"2D data std:\\\")\\n print(data_std_2d)\\n \\n input(\\\"Press Enter to continue...\\\")\\n\\n # Avoid using the GPU if requested\\n device_count = {\\\"GPU\\\": 0} if FLAGS.use_cpu else {\\\"GPU\\\": 1}\\n with tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(\\n device_count=device_count,\\n allow_soft_placement=True )) as sess:\\n\\n # === Create the model ===\\n print(\\\"[*] creating %d bi-layers of %d units.\\\" % (FLAGS.num_layers, FLAGS.linear_size))\\n model = create_model( sess, FLAGS.batch_size )\\n model.train_writer.add_graph( sess.graph )\\n print(\\\"[+] model created\\\")\\n \\n #=== This is the training loop ===\\n step_time, loss, val_loss = 0.0, 0.0, 0.0\\n current_step = 0 if FLAGS.load <= 0 else FLAGS.load + 1\\n previous_losses = []\\n\\n step_time, loss = 0, 0\\n current_epoch = 0\\n log_every_n_batches = 100\\n losses, errors, joint_errors = [], [], []\\n for _ in range( FLAGS.epochs ):\\n current_epoch = current_epoch + 1\\n\\n # === Load training batches for one epoch ===\\n encoder_inputs, decoder_outputs =\\\\\\n model.get_all_batches( train_set_2d, train_set_3d, FLAGS.camera_frame, training=True )\\n nbatches = len( encoder_inputs )\\n print(\\\"[*] there are {0} train batches\\\".format( nbatches ))\\n start_time, loss = time.time(), 0.\\n # === Loop through all the training batches ===\\n for i in range( nbatches ):\\n\\n if (i+1) % log_every_n_batches == 0:\\n # Print progress every log_every_n_batches batches\\n print(\\\"Working on epoch {0}, batch {1} / {2}...\\\".format( current_epoch, i+1, nbatches),end=\\\"\\\" )\\n\\n enc_in, dec_out = encoder_inputs[i], decoder_outputs[i]\\n step_loss, loss_summary, lr_summary, _ =\\\\\\n model.step( sess, enc_in, dec_out, FLAGS.dropout, isTraining=True )\\n\\n if (i+1) % log_every_n_batches == 0:\\n # Log and print progress every log_every_n_batches batchespixels = pixels / pixels[2,:]\\n model.train_writer.add_summary( loss_summary, current_step )\\n model.train_writer.add_summary( lr_summary, current_step )\\n step_time = (time.time() - start_time)\\n start_time = time.time()\\n print(\\\"done in {0:.2f} ms\\\".format( 1000*step_time / log_every_n_batches ) )\\n\\n loss += step_loss\\n current_step += 1\\n # === end looping through training batches ===\\n\\n loss = loss / nbatches\\n losses.append(loss)\\n print(\\\"=============================\\\\n\\\"\\n \\\"Global step: %d\\\\n\\\"\\n \\\"Learning rate: %.2e\\\\n\\\"\\n \\\"Train loss avg: %.4f\\\\n\\\"\\n \\\"=============================\\\" % (model.global_step.eval(),\\n model.learning_rate.eval(), loss) )\\n # === End training for an epoch ===\\n\\n # === Testing after this epoch ===\\n isTraining = False\\n \\n n_joints = len(data_utils.DIMENSIONS_TO_USE)\\n if FLAGS.origin_bc:\\n n_joints -= len(data_utils.ROOT_POSITIONS)\\n\\n encoder_inputs, decoder_outputs =\\\\\\n model.get_all_batches( test_set_2d, test_set_3d, FLAGS.camera_frame, training=False)\\n\\n total_err, coordwise_err, joint_err, step_time, loss = evaluate_batches( sess, model,\\n data_mean_3d, data_std_3d, dim_to_use_3d, dim_to_ignore_3d,\\n data_mean_2d, data_std_2d, dim_to_use_2d, dim_to_ignore_2d,\\n current_step, encoder_inputs, decoder_outputs, current_epoch )\\n\\n print(\\\"=============================\\\\n\\\"\\n \\\"Step-time (ms): %.4f\\\\n\\\"\\n \\\"Val loss avg: %.4f\\\\n\\\"\\n \\\"Val error avg (mm): %.2f (%.2f, %.2f, %.2f)\\\\n\\\"\\n \\\"=============================\\\" % ( 1000*step_time, loss, total_err,\\n coordwise_err[0], coordwise_err[1], coordwise_err[2] ))\\n\\n for i in range(n_joints):\\n # 6 spaces, right-aligned, 5 decimal places\\n print(\\\"Error in joint {0:02d} (mm): {1:>5.2f}\\\".format(i+1, joint_err[i]))\\n print(\\\"=============================\\\")\\n errors.append(coordwise_err)\\n joint_errors.append(joint_err)\\n # Log the error to tensorboard\\n summaries = sess.run( model.err_mm_summary, {model.err_mm: total_err} )\\n model.test_writer.add_summary( summaries, current_step )\\n\\n # Save the model\\n print( \\\"Saving the model... \\\", end=\\\"\\\" )\\n start_time = time.time()\\n model.saver.save(sess, os.path.join(train_dir, 'checkpoint'), global_step=current_step )\\n print( \\\"done in {0:.2f} ms\\\".format(1000*(time.time() - start_time)) )\\n\\n # Reset global time and loss\\n step_time, loss = 0, 0\\n\\n sys.stdout.flush()\\n # Save losses for future plots\\n def print_list_tofile(l, filename):\\n with open(filename, 'wb') as f:\\n pickle.dump(l, f)\\n print_list_tofile(losses, train_dir+\\\"/losses.pkl\\\")\\n print_list_tofile(errors, train_dir+\\\"/errors.pkl\\\")\\n print_list_tofile(joint_errors, train_dir+\\\"/joint_errors.pkl\\\")\",\n \"def train(self, tmp_dir):\\n self.log_options()\\n\\n # Sync output of previous training run from cloud.\\n train_uri = self.backend_opts.train_uri\\n train_dir = get_local_path(train_uri, tmp_dir)\\n make_dir(train_dir)\\n sync_from_dir(train_uri, train_dir)\\n\\n # Get zip file for each group, and unzip them into chip_dir.\\n chip_dir = join(tmp_dir, 'chips')\\n make_dir(chip_dir)\\n for zip_uri in list_paths(self.backend_opts.chip_uri, 'zip'):\\n zip_path = download_if_needed(zip_uri, tmp_dir)\\n with zipfile.ZipFile(zip_path, 'r') as zipf:\\n zipf.extractall(chip_dir)\\n\\n # Setup data loader.\\n def get_label_path(im_path):\\n return Path(str(im_path.parent)[:-4] + '-labels') / im_path.name\\n\\n size = self.task_config.chip_size\\n class_map = self.task_config.class_map\\n classes = class_map.get_class_names()\\n if 0 not in class_map.get_keys():\\n classes = ['nodata'] + classes\\n num_workers = 0 if self.train_opts.debug else 4\\n\\n data = (SegmentationItemList.from_folder(chip_dir)\\n .split_by_folder(train='train-img', valid='val-img'))\\n train_count = None\\n if self.train_opts.train_count is not None:\\n train_count = min(len(data.train), self.train_opts.train_count)\\n elif self.train_opts.train_prop != 1.0:\\n train_count = int(round(self.train_opts.train_prop * len(data.train)))\\n train_items = data.train.items\\n if train_count is not None:\\n train_inds = np.random.permutation(np.arange(len(data.train)))[0:train_count]\\n train_items = train_items[train_inds]\\n items = np.concatenate([train_items, data.valid.items])\\n\\n data = (SegmentationItemList(items, chip_dir)\\n .split_by_folder(train='train-img', valid='val-img')\\n .label_from_func(get_label_path, classes=classes)\\n .transform(get_transforms(flip_vert=self.train_opts.flip_vert),\\n size=size, tfm_y=True)\\n .databunch(bs=self.train_opts.batch_sz,\\n num_workers=num_workers))\\n print(data)\\n\\n # Setup learner.\\n ignore_idx = 0\\n metrics = [\\n Precision(average='weighted', clas_idx=1, ignore_idx=ignore_idx),\\n Recall(average='weighted', clas_idx=1, ignore_idx=ignore_idx),\\n FBeta(average='weighted', clas_idx=1, beta=1, ignore_idx=ignore_idx)]\\n model_arch = getattr(models, self.train_opts.model_arch)\\n learn = unet_learner(\\n data, model_arch, metrics=metrics, wd=self.train_opts.weight_decay,\\n bottle=True, path=train_dir)\\n learn.unfreeze()\\n\\n if self.train_opts.mixed_prec and torch.cuda.is_available():\\n # This loss_scale works for Resnet 34 and 50. You might need to adjust this\\n # for other models.\\n learn = learn.to_fp16(loss_scale=256)\\n\\n # Setup callbacks and train model.\\n model_path = get_local_path(self.backend_opts.model_uri, tmp_dir)\\n\\n pretrained_uri = self.backend_opts.pretrained_uri\\n if pretrained_uri:\\n print('Loading weights from pretrained_uri: {}'.format(\\n pretrained_uri))\\n pretrained_path = download_if_needed(pretrained_uri, tmp_dir)\\n learn.model.load_state_dict(\\n torch.load(pretrained_path, map_location=learn.data.device),\\n strict=False)\\n\\n # Save every epoch so that resume functionality provided by\\n # TrackEpochCallback will work.\\n callbacks = [\\n TrackEpochCallback(learn),\\n MySaveModelCallback(learn, every='epoch'),\\n MyCSVLogger(learn, filename='log'),\\n ExportCallback(learn, model_path, monitor='f_beta'),\\n SyncCallback(train_dir, self.backend_opts.train_uri,\\n self.train_opts.sync_interval)\\n ]\\n\\n oversample = self.train_opts.oversample\\n if oversample:\\n weights = get_oversampling_weights(\\n data.train_ds, oversample['rare_class_ids'],\\n oversample['rare_target_prop'])\\n oversample_callback = OverSamplingCallback(learn, weights=weights)\\n callbacks.append(oversample_callback)\\n\\n if self.train_opts.debug:\\n if oversample:\\n oversample_callback.on_train_begin()\\n make_debug_chips(data, class_map, tmp_dir, train_uri)\\n\\n if self.train_opts.log_tensorboard:\\n callbacks.append(TensorboardLogger(learn, 'run'))\\n\\n if self.train_opts.run_tensorboard:\\n log.info('Starting tensorboard process')\\n log_dir = join(train_dir, 'logs', 'run')\\n tensorboard_process = Popen(\\n ['tensorboard', '--logdir={}'.format(log_dir)])\\n terminate_at_exit(tensorboard_process)\\n\\n lr = self.train_opts.lr\\n num_epochs = self.train_opts.num_epochs\\n if self.train_opts.one_cycle:\\n if lr is None:\\n learn.lr_find()\\n learn.recorder.plot(suggestion=True, return_fig=True)\\n lr = learn.recorder.min_grad_lr\\n print('lr_find() found lr: {}'.format(lr))\\n learn.fit_one_cycle(num_epochs, lr, callbacks=callbacks)\\n else:\\n learn.fit(num_epochs, lr, callbacks=callbacks)\\n\\n if self.train_opts.run_tensorboard:\\n tensorboard_process.terminate()\\n\\n # Since model is exported every epoch, we need some other way to\\n # show that training is finished.\\n str_to_file('done!', self.backend_opts.train_done_uri)\\n\\n # Sync output to cloud.\\n sync_to_dir(train_dir, self.backend_opts.train_uri)\",\n \"def train(data, N, accuracy, Lout, Washout, Vin, Wres):\\n print 'Training'\\n args = [\\n [data[i], N, accuracy, Washout, Vin, Wres] for i in xrange(Lout)\\n ]\\n pool = Pool(processes=Lout)\\n clusters = pool.map(training, args)\\n # TODO delete\\n for i, cluster in enumerate(clusters):\\n np.savetxt('dump_{0}'.format(i), cluster[1])\\n return clusters\",\n \"def atlas_clusters():\\n pass\",\n \"def test_main_split_cluster(self):\\r\\n\\r\\n command = \\\" \\\".join([\\\"denoiser.py\\\",\\r\\n \\\"-S\\\", \\\"--force\\\", '-c', '-n 2',\\r\\n \\\"-i\\\", \\\"%s/qiime/support_files/denoiser/TestData/denoiser_test_set.sff.txt\\\" % PROJECT_HOME,\\r\\n \\\"-f\\\", \\\"%s/qiime/support_files/denoiser/TestData/test_set_seqs.fna\\\" % PROJECT_HOME,\\r\\n \\\"-o\\\", self.test_dir])\\r\\n\\r\\n result = Popen(command, shell=True, universal_newlines=True,\\r\\n stdout=PIPE, stderr=STDOUT).stdout.read()\\r\\n self.result_dir = self.test_dir\\r\\n\\r\\n for subdir in [\\\"0/\\\", \\\"1/\\\"]:\\r\\n observed = \\\"\\\".join(\\r\\n list(open(self.result_dir + subdir + \\\"centroids.fasta\\\")))\\r\\n self.assertEqual(observed, expected_centroids[subdir])\\r\\n\\r\\n observed = \\\"\\\".join(\\r\\n list(open(self.result_dir + subdir + \\\"denoiser_mapping.txt\\\")))\\r\\n self.assertEqual(observed, expected_map_string_on_cluster[subdir])\",\n \"def ensemble_001():\\n n_centroids = 3000\\n s = 15\\n crop = 150\\n n_patches = 400000\\n rf_size = 5\\n\\n train_x_crop_scale = CropScaleImageTransformer(training=True,\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n\\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\\n rf_size=rf_size,\\n result_path='data/mdl_ensemble_001',\\n n_iterations=20,\\n n_jobs=-1,)\\n\\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\\n patch_size=rf_size,\\n n_jobs=-1)\\n images = train_x_crop_scale.transform()\\n patches = patch_extractor.transform(images)\\n\\n kmeans_generator.fit(patches)\\n\\n del patches\\n gc.collect()\\n\\n X = kmeans_generator.transform(images, save_to_file='data/data_ensemble_001.npy', memmap=True)\\n Y = classes.train_solutions.data\\n\\n # Unload some objects\\n del images\\n gc.collect()\\n\\n # Get the input for the RF so that we can split together\\n sampler = SampleTransformer(training=True, steps=2, step_size=20, n_jobs=-1)\\n pX = sampler.transform()\\n\\n # manual split of train and test\\n train_x, test_x, ptrain_x, ptest_x, train_y, test_y = train_test_split(X, pX, Y, test_size=0.5)\\n\\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 500}, n_jobs=-1)\\n wrapper.fit(train_x, train_y)\\n kmeans_preds = wrapper.predict(test_x)\\n\\n pWrapper = ModelWrapper(RandomForestRegressor, {'n_estimators': 500, 'verbose': 3}, n_jobs=-1)\\n pWrapper.fit(ptrain_x, train_y)\\n pixel_preds = pWrapper.predict(ptest_x)\\n\\n logger.info('Kmeans')\\n classes.colwise_rmse(kmeans_preds, test_y)\\n classes.rmse(kmeans_preds, test_y)\\n logger.info('Pixel RF')\\n classes.colwise_rmse(pixel_preds, test_y)\\n classes.rmse(pixel_preds, test_y)\\n\\n logger.info(\\\"Ensembling predictions\\\")\\n etrain_x = np.hstack((wrapper.predict(train_x), pWrapper.predict(ptrain_x)))\\n etest_x = np.hstack((kmeans_preds, pixel_preds))\\n eWrapper = ModelWrapper(RandomForestRegressor, {'n_estimators': 500, 'verbose': 3}, n_jobs=-1)\\n eWrapper.fit(etrain_x, train_y)\\n ensemble_preds = eWrapper.predict(etest_x)\\n classes.colwise_rmse(ensemble_preds, test_y)\\n classes.rmse(ensemble_preds, test_y)\",\n \"def generate_mnist_datasets(\\n datapoints_per_task,\\n K_list,\\n cir_inner_loop_list, \\n test_task_idx, \\n val_task_idx,\\n n_finetune_sets):\\n\\n # arbitrarily chosen, class-imbalance rate in outer and inner training loops\\n cir_outer_loop = 0.5\\n cir_inner_loop = 0.5\\n # class-imbalance rate in the test sets of the test and validation tasks\\n cir_test = 0.5\\n # arbitrarily chosen, percentage of data that will be used in the inner training loop\\n percent_data_inner_loop = 0.5\\n\\n percent_data_finetune_val = 0.8\\n\\n n_test_set = 4000\\n\\n test_task_idx, val_task_idx = test_task_idx, val_task_idx\\n\\n finetune_sets_per_K_cir = {}\\n test_task_test_set, val_task = {}, {}\\n \\n\\n train_task_list_inner, train_task_list_outer = [], []\\n\\n train_tasks_idxs = [i for i in range(0,10) if i not in [val_task_idx, test_task_idx]]\\n\\n base_path = '/home/USER/Documents'\\n if (not (os.path.exists(base_path))):\\n base_path = '/home/ubuntu/Projects'\\n train_images, train_labels = loadlocal_mnist(\\n images_path= base_path + '/MAML/raw_data/MNIST_data/train-images-idx3-ubyte', \\n labels_path= base_path + '/MAML/raw_data/MNIST_data/train-labels-idx1-ubyte')\\n\\n test_images, test_labels = loadlocal_mnist(\\n images_path= base_path + '/MAML/raw_data/MNIST_data/t10k-images-idx3-ubyte', \\n labels_path= base_path + '/MAML/raw_data/MNIST_data/t10k-labels-idx1-ubyte')\\n\\n\\n train_images, test_images = train_images.reshape((-1,28,28))/255.0, test_images.reshape((-1,28,28))/255.0\\n images = np.concatenate((train_images, test_images))\\n labels = np.concatenate((train_labels, test_labels))\\n\\n test_task_normal_indexes, val_task_normal_indexes = list(np.nonzero(labels == test_task_idx)[0]), list(np.nonzero(train_labels == val_task_idx)[0])\\n test_task_X_normal, val_task_X_normal = images[test_task_normal_indexes],train_images[val_task_normal_indexes]\\n test_task_Y_normal, val_task_Y_normal = np.zeros_like(labels[test_task_normal_indexes]), np.zeros_like(train_labels[val_task_normal_indexes])\\n\\n\\n # val and test task have anomalies (samples of other numbers) that are not used for training\\n # besides the two sets of anomalies (one for val task and one for test task are disjoint)\\n test_task_anomalous_indexes = list(np.nonzero(test_labels[:5000] != test_task_idx)[0])\\n val_task_anomalous_indexes= [index for index, element in enumerate(list(test_labels[5000:])) if element not in [val_task_idx, test_task_idx]]\\n\\n\\n test_task_X_anomalous, val_task_X_anomalous = test_images[:5000][test_task_anomalous_indexes],test_images[5000:][val_task_anomalous_indexes]\\n test_task_Y_anomalous, val_task_Y_anomalous = np.ones_like(test_labels[:5000][test_task_anomalous_indexes]), np.ones_like(test_labels[5000:][val_task_anomalous_indexes])\\n\\n test_task_X, val_task_X = np.concatenate((test_task_X_normal, test_task_X_anomalous)), np.concatenate((val_task_X_normal, val_task_X_anomalous))\\n test_task_Y, val_task_Y = np.expand_dims(np.concatenate((test_task_Y_normal, test_task_Y_anomalous)),-1), np.expand_dims(np.concatenate((val_task_Y_normal, val_task_Y_anomalous)),-1)\\n\\n\\n train_tasks_X_list, train_tasks_Y_list = [], []\\n for task_idx in train_tasks_idxs:\\n train_task_normal_indexes = list(np.nonzero(train_labels == task_idx)[0]) \\n train_task_anomalous_indexes = [index for index, element in enumerate(list(train_labels)) if element not in [task_idx, val_task_idx, test_task_idx]]\\n assert(len(np.nonzero(train_labels[train_task_anomalous_indexes] == val_task_idx)[0]) == 0)\\n assert(len(np.nonzero(train_labels[train_task_anomalous_indexes] == test_task_idx)[0]) == 0)\\n train_task_X_normal, train_task_X_anomalous = train_images[train_task_normal_indexes], train_images[train_task_anomalous_indexes]\\n train_task_Y_normal, train_task_Y_anomalous = np.zeros_like(train_labels[train_task_normal_indexes]), np.ones_like(train_labels[train_task_anomalous_indexes])\\n train_task_X, train_task_Y = np.concatenate((train_task_X_normal, train_task_X_anomalous)), np.concatenate((train_task_Y_normal, train_task_Y_anomalous))\\n train_tasks_X_list.append(train_task_X)\\n train_tasks_Y_list.append(np.expand_dims(train_task_Y,-1))\\n\\n\\n\\n # building test task sets of data\\n normal_indexes, anomaly_indexes = list(np.nonzero(test_task_Y == 0)[0]), list(np.nonzero(test_task_Y == 1)[0])\\n n_test_set_normal = int(n_test_set*cir_test)\\n test_set_normal_indexes = random.sample(normal_indexes, n_test_set_normal)\\n test_set_anomaly_indexes = random.sample(anomaly_indexes, n_test_set - n_test_set_normal)\\n test_set_indexes = []\\n test_set_indexes += test_set_normal_indexes\\n test_set_indexes += test_set_anomaly_indexes\\n\\n test_task_test_set['test_X'], test_task_test_set['test_Y'] = test_task_X[test_set_indexes], test_task_Y[test_set_indexes]\\n\\n\\n #shuffle\\n s_test = np.arange(test_task_test_set['test_X'].shape[0])\\n np.random.shuffle(s_test)\\n test_task_test_set['test_X'], test_task_test_set['test_Y'] = test_task_test_set['test_X'][s_test], test_task_test_set['test_Y'][s_test]\\n\\n rest_normal_indexes = [index for index in normal_indexes if index not in test_set_normal_indexes]\\n rest_anomaly_indexes = [index for index in anomaly_indexes if index not in test_set_anomaly_indexes]\\n\\n\\n for K in K_list:\\n finetune_sets_per_cir = {}\\n for cir in cir_inner_loop_list:\\n\\n rest_normal_indexes = [index for index in normal_indexes if index not in test_set_normal_indexes]\\n rest_anomaly_indexes = [index for index in anomaly_indexes if index not in test_set_anomaly_indexes]\\n \\n finetune_sets_list = []\\n\\n disjoint = False\\n if(cir*K*n_finetune_sets<len(rest_normal_indexes)):\\n disjoint = True\\n\\n n_finetune_normal = int(K*cir)\\n n_finetune_anomaly = K - n_finetune_normal\\n for i in range(n_finetune_sets):\\n # if enough for disjoint do that\\n # else sample randomly\\n # store in a dict with keys cir_K\\n finetune_normal_indexes = random.sample(rest_normal_indexes, n_finetune_normal)\\n finetune_anomaly_indexes = random.sample(rest_anomaly_indexes, n_finetune_anomaly)\\n finetune_indexes = []\\n finetune_indexes += finetune_normal_indexes\\n finetune_indexes += finetune_anomaly_indexes\\n finetune_set = {}\\n finetune_set['finetune_X'], finetune_set['finetune_Y'] = test_task_X[finetune_indexes], test_task_Y[finetune_indexes]\\n\\n #shuffle\\n s_finetune = np.arange(finetune_set['finetune_X'].shape[0])\\n np.random.shuffle(s_finetune)\\n finetune_set['finetune_X'], finetune_set['finetune_Y'] = finetune_set['finetune_X'][s_finetune], finetune_set['finetune_Y'][s_finetune]\\n\\n finetune_sets_list.append(finetune_set)\\n \\n if(disjoint):\\n rest_normal_indexes = [index for index in rest_normal_indexes if index not in finetune_normal_indexes]\\n rest_anomaly_indexes = [index for index in rest_anomaly_indexes if index not in finetune_anomaly_indexes]\\n\\n finetune_sets_per_cir[str(cir)] = finetune_sets_list\\n\\n finetune_sets_per_K_cir[str(K)] = finetune_sets_per_cir\\n\\n\\n #building val task sets of data\\n normal_indexes, anomaly_indexes = list(np.nonzero(val_task_Y == 0)[0]), list(np.nonzero(val_task_Y == 1)[0])\\n n_val_finetune = int(percent_data_finetune_val*datapoints_per_task)\\n n_val_test_set = datapoints_per_task - n_val_finetune\\n n_val_test_set_normal = int(n_val_test_set*cir_test)\\n val_test_set_normal_indexes = random.sample(normal_indexes, n_val_test_set_normal)\\n\\n\\n val_test_set_anomaly_indexes = random.sample(anomaly_indexes, n_val_test_set - n_val_test_set_normal)\\n val_test_set_indexes = []\\n val_test_set_indexes += val_test_set_normal_indexes\\n val_test_set_indexes += val_test_set_anomaly_indexes\\n val_task['test_X'], val_task['test_Y'] = val_task_X[val_test_set_indexes], val_task_Y[val_test_set_indexes]\\n\\n\\n rest_normal_indexes = [index for index in normal_indexes if index not in val_test_set_normal_indexes]\\n rest_anomaly_indexes = [index for index in anomaly_indexes if index not in val_test_set_anomaly_indexes]\\n\\n n_val_finetune_normal = int(n_val_finetune*cir_inner_loop)\\n val_finetune_normal_indexes = random.sample(rest_normal_indexes, n_val_finetune_normal)\\n val_finetune_anomaly_indexes = random.sample(rest_anomaly_indexes, n_val_finetune - n_val_finetune_normal)\\n val_finetune_indexes = []\\n val_finetune_indexes += val_finetune_normal_indexes\\n val_finetune_indexes += val_finetune_anomaly_indexes\\n\\n val_task['finetune_X'], val_task['finetune_Y'] = val_task_X[val_finetune_indexes], val_task_Y[val_finetune_indexes]\\n\\n #shuffle\\n s_val_finetune = np.arange(val_task['finetune_X'].shape[0])\\n s_val_test = np.arange(val_task['test_X'].shape[0])\\n np.random.shuffle(s_val_finetune)\\n np.random.shuffle(s_val_test)\\n\\n val_task['finetune_X'], val_task['finetune_Y'] = val_task['finetune_X'][s_val_finetune], val_task['finetune_Y'][s_val_finetune]\\n val_task['test_X'], val_task['test_Y'] = val_task['test_X'][s_val_test], val_task['test_Y'][s_val_test]\\n\\n\\n\\n # building sets of data of the training tasks\\n for task_X, task_Y in zip(train_tasks_X_list, train_tasks_Y_list):\\n normal_indexes, anomaly_indexes = list(np.nonzero(task_Y == 0)[0]), list(np.nonzero(task_Y == 1)[0])\\n\\n n_inner_loop = int(percent_data_inner_loop*datapoints_per_task)\\n n_inner_loop_normal = int(n_inner_loop*cir_inner_loop)\\n n_outer_loop = datapoints_per_task - n_inner_loop\\n n_outer_loop_normal = int(n_outer_loop*cir_outer_loop)\\n \\n inner_loop_normal_indexes = random.sample(normal_indexes, n_inner_loop_normal)\\n inner_loop_anomaly_indexes = random.sample(anomaly_indexes, n_inner_loop - n_inner_loop_normal)\\n inner_loop_indexes = []\\n inner_loop_indexes += inner_loop_normal_indexes\\n inner_loop_indexes += inner_loop_anomaly_indexes\\n\\n train_task_inner_X, train_task_inner_Y = task_X[inner_loop_indexes], task_Y[inner_loop_indexes]\\n\\n rest_normal_indexes = [index for index in normal_indexes if index not in inner_loop_normal_indexes]\\n rest_anomaly_indexes = [index for index in anomaly_indexes if index not in inner_loop_anomaly_indexes]\\n\\n \\n outer_loop_normal_indexes = random.sample(rest_normal_indexes, n_outer_loop_normal)\\n outer_loop_anomaly_indexes = random.sample(rest_anomaly_indexes, n_outer_loop - n_outer_loop_normal)\\n outer_loop_indexes = []\\n outer_loop_indexes += outer_loop_normal_indexes\\n outer_loop_indexes += outer_loop_anomaly_indexes\\n\\n train_task_outer_X, train_task_outer_Y = task_X[outer_loop_indexes], task_Y[outer_loop_indexes]\\n\\n\\n s_inner = np.arange(train_task_inner_X.shape[0])\\n s_outer = np.arange(train_task_outer_X.shape[0])\\n np.random.shuffle(s_inner)\\n np.random.shuffle(s_outer)\\n train_task_list_inner.append([train_task_inner_X[s_inner],train_task_inner_Y[s_inner]])\\n train_task_list_outer.append([train_task_outer_X[s_outer],train_task_outer_Y[s_outer]])\\n\\n\\n\\n train_tasks_inner_X = np.stack([train_task_list_inner[i][0]\\n for i in range(len(train_task_list_inner))], 0)\\n train_tasks_inner_Y = np.stack([train_task_list_inner[i][1]\\n for i in range(len(train_task_list_inner))], 0)\\n train_tasks_outer_X = np.stack([train_task_list_outer[i][0]\\n for i in range(len(train_task_list_outer))], 0)\\n train_tasks_outer_Y = np.stack([train_task_list_outer[i][1]\\n for i in range(len(train_task_list_outer))], 0)\\n\\n \\n train_tasks = {'X_train_inner': train_tasks_inner_X,\\n 'Y_train_inner': train_tasks_inner_Y,\\n 'X_train_outer': train_tasks_outer_X,\\n 'Y_train_outer': train_tasks_outer_Y\\n }\\n\\n\\n return train_tasks, val_task, test_task_test_set, finetune_sets_per_K_cir\",\n \"def main():\\n datasets = {}\\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\\\"Processing datasets and fitting base models\\\"):\\n logger.info(f\\\"processing dataset {dataset_name}\\\")\\n clusters_path: Optional[str] = None\\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_clusters.json\\\")\\n train_pairs_path = None\\n val_pairs_path = None\\n test_pairs_path = None\\n else:\\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"train_pairs.csv\\\")\\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"val_pairs.csv\\\")\\n if not os.path.exists(val_pairs_path):\\n val_pairs_path = None\\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"test_pairs.csv\\\")\\n\\n logger.info(f\\\"loading dataset {dataset_name}\\\")\\n anddata = ANDData(\\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_signatures.json\\\"),\\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_papers.json\\\"),\\n name=dataset_name,\\n mode=\\\"train\\\",\\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_specter.pickle\\\"),\\n clusters=clusters_path,\\n block_type=BLOCK_TYPE,\\n train_pairs=train_pairs_path,\\n val_pairs=val_pairs_path,\\n test_pairs=test_pairs_path,\\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\\n val_pairs_size=N_VAL_TEST_SIZE,\\n test_pairs_size=N_VAL_TEST_SIZE,\\n preprocess=True,\\n )\\n\\n logger.info(f\\\"featurizing {dataset_name}\\\")\\n train, val, test = featurize(\\n anddata,\\n FEATURIZER_INFO,\\n n_jobs=N_JOBS,\\n use_cache=True,\\n chunk_size=100,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\\n nan_value=NAN_VALUE,\\n )\\n X_train, y_train, nameless_X_train = train\\n X_val, y_val, nameless_X_val = val\\n X_test, y_test, nameless_X_test = test\\n\\n dataset = {}\\n dataset[\\\"anddata\\\"] = anddata\\n dataset[\\\"X_train\\\"] = X_train\\n dataset[\\\"y_train\\\"] = y_train\\n dataset[\\\"X_val\\\"] = X_val\\n dataset[\\\"y_val\\\"] = y_val\\n dataset[\\\"X_test\\\"] = X_test\\n dataset[\\\"y_test\\\"] = y_test\\n dataset[\\\"nameless_X_train\\\"] = nameless_X_train\\n dataset[\\\"nameless_X_val\\\"] = nameless_X_val\\n dataset[\\\"nameless_X_test\\\"] = nameless_X_test\\n dataset[\\\"name\\\"] = anddata.name\\n datasets[dataset_name] = dataset\\n\\n anddatas = [\\n datasets[dataset_name][\\\"anddata\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in PAIRWISE_ONLY_DATASETS\\n ]\\n\\n X_train = np.vstack([datasets[dataset_name][\\\"X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n y_train = np.hstack([datasets[dataset_name][\\\"y_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n X_val = np.vstack(\\n [datasets[dataset_name][\\\"X_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n y_val = np.hstack(\\n [datasets[dataset_name][\\\"y_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n\\n nameless_X_train = np.vstack([datasets[dataset_name][\\\"nameless_X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n nameless_X_val = np.vstack(\\n [\\n datasets[dataset_name][\\\"nameless_X_val\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in {\\\"augmented\\\"}\\n ]\\n )\\n\\n logger.info(\\\"fitting pairwise\\\")\\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\\n union_classifier.fit(X_train, y_train, X_val, y_val)\\n\\n nameless_union_classifier = None\\n if USE_NAMELESS_MODEL:\\n logger.info(\\\"nameless fitting pairwise for \\\" + str(SOURCE_DATASET_NAMES))\\n nameless_union_classifier = PairwiseModeler(\\n n_iter=N_ITER,\\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\\n )\\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\\n logger.info(\\\"nameless pairwise fit for \\\" + str(SOURCE_DATASET_NAMES))\\n\\n logger.info(\\\"fitting clusterer for\\\")\\n union_clusterer = Clusterer(\\n FEATURIZER_INFO,\\n union_classifier.classifier,\\n cluster_model=FastCluster(),\\n search_space=search_space,\\n n_jobs=N_JOBS,\\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\\n )\\n union_clusterer.fit(anddatas)\\n print(\\n \\\"best clustering parameters:\\\",\\n union_clusterer.best_params,\\n )\\n\\n models = {}\\n models[\\\"clusterer\\\"] = union_clusterer\\n\\n with open(\\n f\\\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\\\",\\n \\\"wb\\\",\\n ) as _pickle_file:\\n pickle.dump(models, _pickle_file)\\n logger.info(\\\"Done.\\\")\",\n \"def test_fit_predict() -> None:\\n mapie = MapieClassifier()\\n mapie.fit(X_toy, y_toy)\\n mapie.predict(X_toy)\",\n \"def load_data():\\n global batch_size, num_batches\\n # import data\\n data, labels = original_clean()\\n test_data = data[:test_size, :]\\n test_labels = labels[:test_size]\\n\\n data = data[test_size:, :]\\n\\n # make landmarks with points with most neighbors\\n N = NearestNeighbors(n_neighbors=k_start).fit(data).kneighbors_graph(data).todense()\\n N = np.array(N)\\n num_connections = N.sum(axis=0).argsort()[::-1] # see how many neighbors each point has\\n top_landmarks_idxs = num_connections[:num_lm] # sort in descending order\\n land_marks = data[top_landmarks_idxs, :] # pick the top ones\\n data = np.delete(data, top_landmarks_idxs, axis=0) # delete the landmarks\\n # find the nearest landmarks for the landmarks\\n landmark_neighbors = NearestNeighbors(n_neighbors=k_lm).fit(land_marks).kneighbors_graph(land_marks).todense()\\n # break data into batches, create empty holders\\n batch_loader = np.zeros((num_batches, batch_size + num_lm, n))\\n batch_graph = np.zeros((num_batches, batch_size + num_lm, batch_size + num_lm))\\n # create the full neighborhood graph for each batch\\n for i in range(num_batches):\\n holder = data[batch_size * i: batch_size * (i + 1)]\\n # find the nearest landmarks for the rest of the points\\n holder_graph = NearestNeighbors(n_neighbors=k_other).fit(land_marks).kneighbors_graph(holder).todense()\\n for j in range(batch_size): # copy over the holder graph\\n for l in range(num_lm):\\n if holder_graph[j, l] == 1:\\n batch_graph[i, j, l + batch_size] = 1\\n batch_graph[i, l + batch_size, j] = 1\\n for j in range(num_lm): # copy over landmark neighbors\\n for l in range(j, num_lm):\\n if landmark_neighbors[j, l] == 1 and j != l:\\n batch_graph[i, j + batch_size, l + batch_size] = 1\\n batch_graph[i, l + batch_size, j + batch_size] = 1\\n holder = np.concatenate((holder, land_marks))\\n batch_loader[i] = holder\\n batch_size += num_lm # adjust the batch size\\n return batch_loader, data, batch_graph, landmark_neighbors, test_data, test_labels, land_marks\",\n \"def run(self, data):\\n\\t\\treduced_data = PCA(n_components=2).fit_transform(data)\\n\\n\\t\\t# Run the algorithm\\n\\t\\tself.estimator.fit_transform(reduced_data)\\n\\n\\t\\t# Save all relevent properties\\n\\t\\tself.input_data = data\\n\\t\\tself.centroids = self.estimator.cluster_centers_\\n\\t\\tself.node_positions = reduced_data\\n\\t\\tself.labels = self.estimator.labels_\\n\\n\\t\\t# Enable visualising when debugging\\n\\t\\t# self.visualize(reduced_data)\",\n \"def train(self):\\n for data_tier in self.data_tiers:\\n fd = open(self.data_path + '/training_data_' + data_tier + '.json', 'r')\\n self.preprocessed_data[data_tier] = json.load(fd)\\n fd.close()\\n tot = len(self.preprocessed_data[data_tier]['features'])\\n p = int(math.ceil(tot*0.8))\\n training_features = np.array(self.preprocessed_data[data_tier]['features'][:p])\\n trend_training_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][:p])\\n avg_training_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][:p])\\n t1 = datetime.datetime.utcnow()\\n self.clf_trend[data_tier].fit(training_features, trend_training_classifications)\\n self.clf_avg[data_tier].fit(training_features, avg_training_classifications)\\n t2 = datetime.datetime.utcnow()\\n td = t2 - t1\\n self.logger.info('Training %s for data tier %s took %s', self.name, data_tier, str(td))\\n joblib.dump(self.clf_trend[data_tier], self.data_path + '/' + self.name + '_trend_' + data_tier + '.pkl')\\n joblib.dump(self.clf_avg[data_tier], self.data_path + '/' + self.name + '_avg_' + data_tier + '.pkl')\",\n \"def get_train_test_loaders(self, num_workers=2):\\n print('Loading the image data...')\\n \\n train_path_info, test_path_info = self.get_train_test_info()\\n\\n train_transform = transforms.Compose([transforms.Resize((self.image_width, self.image_height)),\\n transforms.RandomAffine(10,translate=(0.1,0.1)),\\n transforms.ToTensor()])\\n\\n test_transform = transforms.Compose([transforms.Resize((self.image_width, self.image_height)),\\n transforms.ToTensor()])\\n\\n trainset = PocovidDataset(train_path_info, transform = train_transform)\\n testset = PocovidDataset(test_path_info, transform = test_transform)\\n \\n self.class_map = trainset.get_class_map()\\n self.classes = [self.class_map[key] for key in sorted(self.class_map)]\\n\\n train_loader = torch.utils.data.DataLoader(trainset, num_workers=num_workers, shuffle=True,\\n batch_size=self.batch_size, drop_last=True)\\n\\n test_loader = torch.utils.data.DataLoader(testset, num_workers=num_workers, shuffle=True,\\n batch_size=self.batch_size)\\n \\n print('Image data is loaded with fold {} as the test data'.format(self.fold))\\n print('Number of training images:', len(trainset))\\n print('Number of testing images:', len(testset))\\n print('*'*100)\\n print('The classes are:', self.classes)\\n print('*'*100)\\n \\n return train_loader, test_loader\",\n \"def main(root_dir):\\n # load annotations\\n print('Loading instances and annotations...')\\n captions_file = json.load(open('{}/annotations/captions_train2017.json'.format(root_dir), 'r'))\\n categories_file = json.load(open('{}/annotations/instances_train2017.json'.format(root_dir), 'r'))\\n print('Done.')\\n\\n # group categories by image\\n image_categories = group_categories(categories_file)\\n\\n # group captions by image\\n image_captions = group_captions(captions_file['annotations'])\\n\\n # get filename of each image\\n image_file = get_filename(captions_file['images'])\\n\\n # assign each category an id.\\n # we are not using the default ids given in the dataset because\\n # the id ranges are not continuous.\\n category_id, id_category = map_category_id(categories_file['categories'])\\n \\n # save parsed coco dataset\\n save_dataset(image_categories, image_captions, image_file, category_id, id_category, root_dir)\",\n \"def evaulate_clusters(self, pred_dict, model_dir):\\n\\t\\tclustering_dict = {\\\"Topic\\\":[], \\\"Text\\\":[], \\\"Keywords\\\": []}\\n\\t\\tfor cluster_num, sents_list in pred_dict.items():\\n\\t\\t\\tprint(\\\"\\\\n cluster number : \\\", cluster_num)\\n\\t\\t\\tprint(\\\"\\\\n number of sents : \\\", len(sents_list))\\n\\t\\t\\ttfidf_vec = TfidfVectorizer(use_idf=True, sublinear_tf=True, max_df=0.8, max_features=20, ngram_range=(1,5), min_df=1)\\n\\t\\t\\tX_tfidf = tfidf_vec.fit_transform(sents_list).toarray()\\n\\t\\t\\ttotal_tfidf = tfidf_vec.get_feature_names()\\n\\t\\t\\tfor sent in sents_list:\\n\\t\\t\\t\\tclustering_dict[\\\"Topic\\\"].append(cluster_num)\\n\\t\\t\\t\\tclustering_dict[\\\"Text\\\"].append(sent)\\n\\t\\t\\t\\tclustering_dict[\\\"Keywords\\\"].append(\\\",\\\".join(total_tfidf))\\n\\t\\t\\\"\\\"\\\" save the clusters to csv file \\\"\\\"\\\"\\n\\t\\tdf_dominant_topic = defaultdict(list) \\n\\t\\tdf_dominant_topic[\\\"Topic\\\"] = clustering_dict[\\\"Topic\\\"]\\n\\t\\tdf_dominant_topic[\\\"Text\\\"] = clustering_dict[\\\"Text\\\"]\\n\\t\\tdf_dominant_topic[\\\"Keywords\\\"] = clustering_dict[\\\"Keywords\\\"]\\n\\t\\tdf_dominant_topic = pd.DataFrame(df_dominant_topic)\\n\\t\\tdf_dominant_topic.to_csv(os.path.join(model_dir, \\\"cluster_sentence_topic_mapping.csv\\\"))\\n\\t\\treturn df_dominant_topic\",\n \"def main(source_dir, ksplit, out_dir, data_pattern, label_pattern, test_mode,\\r\\n numTopVars = [10, 50, 100, 500, 1000], compute_results=True):\\r\\n # Load input and labels.\\r\\n data, labels, data_file = load_data(source_dir, data_pattern)\\r\\n filename_base = path.splitext(path.basename(mname))[0]\\r\\n # Get classifiers and params.\\r\\n global NAMES\\r\\n if test_mode:\\r\\n NAMES = [\\\"Chance\\\", \\\"Nearest Neighbors\\\", \\\"Linear SVM\\\", \\\"Decision Tree\\\",\\r\\n \\\"Logistic Regression\\\", \\\"Naive Bayes\\\", \\\"LDA\\\"]\\r\\n ksplit = 3\\r\\n\\r\\n classifiers, params = make_classifiers(NAMES) # data.shape, ksplit)\\r\\n\\r\\n\\r\\n # Make the folds.\\r\\n logging.info(\\\"Making %d folds\\\" % ksplit)\\r\\n #kf = StratifiedKFold(labels, n_folds=ksplit)\\r\\n kf = KFold(labels.shape[0], n_folds=ksplit)\\r\\n\\r\\n # Extract the training and testing indices from the k-fold object,\\r\\n # which stores fold pairs of indices.\\r\\n fold_pairs = [(tr, ts) for (tr, ts) in kf]\\r\\n assert len(fold_pairs) == ksplit\\r\\n rank_per_fold = get_rank_per_fold(data, labels, fold_pairs,\\r\\n save_path=out_dir, parallel=True)\\r\\n #dhjelm: were we planning on using this dict?\\r\\n #score={}\\r\\n dscore=[]\\r\\n totalErrs = []\\r\\n if compute_results:\\r\\n for name in NAMES:\\r\\n mdl = classifiers[name]\\r\\n param = params[name]\\r\\n # get_score runs the classifier on each fold,\\r\\n # each subset of selected top variables and does a grid search for\\r\\n # classifier-specific parameters (selects the best)\\r\\n clf, allConfMats, allTotalErrs, allFittedClassifiers = \\\\\\r\\n get_score(data, labels, fold_pairs, name, mdl, param,\\r\\n numTopVars=numTopVars,\\r\\n rank_per_fold=rank_per_fold, parallel=True,\\r\\n rand_iter=-1)\\r\\n # save classifier object and results to file\\r\\n save_classifier_results(name, out_dir, allConfMats,\\r\\n allTotalErrs)\\r\\n save_classifier_object(clf, allFittedClassifiers, name, out_dir)\\r\\n # Append classifier results to list of all results\\r\\n dscore.append(allConfMats)\\r\\n totalErrs.append(allTotalErrs)\\r\\n '''\\r\\n First do some saving of total results\\r\\n '''\\r\\n save_combined_results(NAMES, dscore, totalErrs,\\r\\n numTopVars, out_dir, filename_base)\\r\\n\\r\\n plot_errors(NAMES, numTopVars, dscore, totalErrs,\\r\\n filename_base, out_dir,compute_results)\\r\\n\\r\\n logging.shutdown()\",\n \"def main(version: str, data_root: str,\\n split_name: str, output_dir: str, config_name: str = 'predict_2020_icra.json') -> None:\\n\\n print('Dataset dir:', data_root)\\n nusc = NuScenes(version=version, dataroot=data_root)\\n helper = PredictHelper(nusc)\\n dataset = get_prediction_challenge_split(split_name, data_root)\\n config = load_prediction_config(helper, config_name)\\n\\n oracle = PhysicsOracle(config.seconds, helper)\\n cv_heading = ConstantVelocityHeading(config.seconds, helper)\\n covernet = CoverNetBaseline(config.seconds, helper)\\n\\n cv_preds = []\\n oracle_preds = []\\n covernet_preds = []\\n for idx, token in enumerate(tqdm(dataset)):\\n # if idx > 20:\\n # break\\n\\n cv_preds.append(cv_heading(token).serialize())\\n oracle_preds.append(oracle(token).serialize())\\n covernet_preds.append(covernet(token).serialize()) # The slowest one, by far\\n\\n json.dump(cv_preds, open(os.path.join(output_dir, \\\"cv_preds.json\\\"), \\\"w\\\"))\\n json.dump(oracle_preds, open(os.path.join(output_dir, \\\"oracle_preds.json\\\"), \\\"w\\\"))\\n json.dump(covernet_preds, open(os.path.join(output_dir, \\\"covernet_preds.json\\\"), \\\"w\\\"))\",\n \"def kmeans_006():\\n n_centroids_vals = [1000, 2000, 2500, 3000]\\n scores = []\\n\\n for n_centroids in n_centroids_vals:\\n s = 15\\n crop = 150\\n n_patches = 400000\\n rf_size = 5\\n logger.info(\\\"Training with n_centroids {}\\\".format(n_centroids))\\n\\n train_x_crop_scale = CropScaleImageTransformer(training=True,\\n result_path='data/data_train_crop_{}_scale_{}.npy'.format(crop, s),\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n test_x_crop_scale = CropScaleImageTransformer(training=False,\\n result_path='data/data_test_crop_{}_scale_{}.npy'.format(crop, s),\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n\\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\\n rf_size=rf_size,\\n result_path='data/mdl_kmeans_006_centroids_{}'.format(n_centroids),\\n n_iterations=20,\\n n_jobs=-1,)\\n\\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\\n patch_size=rf_size,\\n n_jobs=-1)\\n images = train_x_crop_scale.transform()\\n\\n patches = patch_extractor.transform(images)\\n\\n kmeans_generator.fit(patches)\\n\\n del patches\\n gc.collect()\\n\\n train_x = kmeans_generator.transform(images, save_to_file='data/data_kmeans_features_006_centroids_{}.npy'.format(n_centroids), memmap=True)\\n train_y = classes.train_solutions.data\\n # Unload some objects\\n del images\\n gc.collect()\\n\\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 250}, n_jobs=-1)\\n wrapper.cross_validation(train_x, train_y, n_folds=2, parallel_estimator=True)\\n\\n score = (n_centroids, wrapper.cv_scores)\\n logger.info(\\\"Scores: {}\\\".format(score))\\n scores.append(score)\\n\\n del wrapper\\n gc.collect()\",\n \"def fit(self):\\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\\n self.merge_clusters([[6,33,52],[17,14]])\\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\\n self.merge_clusters([[6,98,99]])\\n self.merge_clusters([[35,80]])\\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[76,98]])\\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[39,42]])\\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\\n self.merge_clusters([[70,101]])\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\\n self.merge_clusters()\\n return\",\n \"def clustering(dataset, logger):\\n all_instances = dataset\\n meta_dataset = collections.defaultdict(list)\\n for instance in all_instances:\\n meta_dataset[instance['label']].append(instance['coordinate'])\\n\\n tasklist = map(\\n lambda item, meta_dataset=meta_dataset, logger=logger: (\\n item[0],\\n clustering_by_label,\\n (item[1], item[0], meta_dataset, logger)), meta_dataset.items())\\n\\n # pool = multiprocessing.pool.Pool(PROCESS_COUNT)\\n # clusters = dict(pool.map(map_generate_tuple, tasklist))\\n clusters = dict(map(map_generate_tuple, tasklist))\\n # pool.close()\\n # pool.join()\\n\\n return clusters\",\n \"def _generate_datasets(self):\\n\\n degrade_test = False\\n if self._opts['degrade_step'] == 'test':\\n degrade_test = True\\n\\n use_trainset_for_tests = UseTrainForTest.IDENTICAL # can be different in few shot workflow\\n\\n train_dataset, test_dataset = self._gen_datasets_with_options(self._opts['train_classes'],\\n self._opts['test_classes'],\\n is_superclass=self._opts['superclass'],\\n class_proportion=self._opts['class_proportion'],\\n degrade_test=degrade_test,\\n degrade_type=self._opts['degrade_type'], # only relevant if degrade_test = True\\n degrade_val=self._opts['min_val'], # only relevant if degrade_test = True\\n recurse_train=self._is_train_recursive(),\\n recurse_test=self._is_inference_recursive(),\\n num_batch_repeats=self._opts['num_repeats'],\\n recurse_iterations=self._opts['recurse_iterations'],\\n evaluate_step=self._opts['evaluate'],\\n use_trainset_for_tests=use_trainset_for_tests,\\n invert_images=self._opts['invert_images'],\\n min_val=self._opts['min_val'])\\n return train_dataset, test_dataset\",\n \"def pre_process_for_classifying(block, scale=(0, 1, 1024)):\\n print('\\\\nClassifying Data')\\n lorentz_arrays_list = block[1]\\n data_arrays_list = block[2]\\n block_size = len(lorentz_arrays_list)\\n cluster_labels = np.empty((0, 1))\\n cluster_data = np.empty((0, scale[2]))\\n pool = mp.Pool(mp.cpu_count())\\n results = pool.map(\\n classify, [\\n (i, lorentz_arrays_list, data_arrays_list) for i in\\n range(block_size)])\\n pool.close()\\n for result in results:\\n cluster_labels = np.append(cluster_labels, result[0], axis=0)\\n cluster_data = np.append(cluster_data, result[1], axis=0)\\n return cluster_labels, cluster_data\",\n \"def test_main_split_cluster(self):\\n \\n command = \\\" \\\".join( [\\\"%s/denoiser.py\\\" % get_qiime_scripts_dir(),\\n \\\"-S\\\", \\\"--force\\\", '-c', '-n 2',\\n \\\"-i\\\", \\\"%s/qiime/support_files/denoiser/TestData/denoiser_test_set.sff.txt\\\" % PROJECT_HOME,\\n \\\"-f\\\", \\\"%s/qiime/support_files/denoiser/TestData/test_set_seqs.fna\\\" % PROJECT_HOME,\\n \\\"-o\\\", self.test_dir] )\\n\\n result = Popen(command,shell=True,universal_newlines=True,\\\\\\n stdout=PIPE,stderr=STDOUT).stdout.read()\\n self.result_dir = self.test_dir\\n\\n for subdir in [\\\"0/\\\",\\\"1/\\\"]:\\n observed = \\\"\\\".join(list(open(self.result_dir+ subdir+\\\"centroids.fasta\\\")))\\n self.assertEqual(observed, expected_centroids[subdir])\\n\\n observed = \\\"\\\".join(list(open(self.result_dir+ subdir+\\\"denoiser_mapping.txt\\\")))\\n self.assertEqual(observed, expected_map_string_on_cluster[subdir])\",\n \"def single_supervise_evaluation(clf, x_train, y_train, x_test, y_test, r1_norm_step=0.05, r2_norm_step=0.05):\\n # fit model\\n clf.fit(x_train, y_train)\\n\\n # calc accuracy\\n y_train_pred = clf.predict(x_train)\\n accuracy_train = balanced_accuracy_score(y_true=y_train, y_pred=y_train_pred)\\n print(f\\\"Balanced accuracy on the training set: {accuracy_train:.3f}\\\")\\n y_test_pred = clf.predict(x_test)\\n accuracy_test = balanced_accuracy_score(y_true=y_test, y_pred=y_test_pred)\\n print(f\\\"Balanced accuracy on the hold-out set: {accuracy_test:.3f}\\\")\\n\\n # get confusion matrix\\n y_pred = clf.predict(x_test)\\n cmat = confusion_matrix(y_test, y_pred)\\n\\n # normalize confusion matrix\\n r1_cmat = _r1_normalize(cmat)\\n r2_cmat = _r2_normalize(cmat)\\n m1 = np.max(r1_cmat)\\n if np.isnan(m1):\\n m1 = 1.0\\n m2 = np.max(r2_cmat)\\n\\n cluster_map = {}\\n while (len(cluster_map) == 0) and (m1 > 0) and (m2 > 0):\\n m1 -= r1_norm_step\\n m2 -= r2_norm_step\\n\\n # final binary matrix to calculate which clusters need to be merged\\n judge = np.maximum.reduce([(r1_cmat > m1), (r2_cmat > m2)])\\n if judge.sum() > 0:\\n rows, cols = np.where(judge)\\n edges = zip(rows.tolist(), cols.tolist())\\n g = nx.Graph()\\n g.add_edges_from(edges)\\n for comp in nx.connected_components(g):\\n to_label = comp.pop()\\n for remain in comp:\\n cluster_map[remain] = to_label\\n return clf, accuracy_test, cluster_map, cmat, r1_cmat, r2_cmat\",\n \"def _split_train_tst(self):\\n num_samples = self.Y.shape[0]\\n mapper_file = self.checkpointer.get_mapper_file_location()\\n if not self.checkpointer.is_mapper_checkpointed():\\n print 'No mapper checkpoint found. Fresh loading in progress ...'\\n # Now shuffle the data\\n sample_id = range(num_samples)\\n random.shuffle(sample_id)\\n print 'Dumping the mapper shuffle for reuse.'\\n Pickle.dump(sample_id, open(mapper_file, 'wb'))\\n print 'Dump complete. Moving Forward...'\\n else:\\n print 'Mapper Checkpoint found... Reading from mapper dump'\\n sample_id = Pickle.load(open(mapper_file, 'rb'))\\n print 'Mapping unpickling complete.. Moving forward...'\\n\\n self.X_fwd = self.X_fwd[sample_id]\\n self.X_bwd = self.X_bwd[sample_id]\\n self.Y = self.Y[sample_id]\\n # Now divide the data into test ans train set\\n test_fraction = 0.01\\n self.test_size = int(test_fraction * num_samples)\\n self.train_size = num_samples - self.test_size\\n # Forward review\\n self.X_trn_fwd = self.X_fwd[0:self.train_size]\\n self.X_tst_fwd = self.X_fwd[self.train_size:num_samples]\\n # Backward review\\n self.X_trn_bwd = self.X_bwd[0:self.train_size]\\n self.X_tst_bwd = self.X_bwd[self.train_size:num_samples]\\n # Summary\\n self.Y_trn = self.Y[0:self.train_size]\\n self.Y_tst = self.Y[self.train_size:num_samples]\",\n \"def load_kiba_dataset():\\n trainn_fold = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'folds', 'train_fold_setting1.txt')))\\n train_fold = []\\n for e in zip(*trainn_fold):\\n for ee in e:\\n train_fold.extend(ee)\\n #train_fold = [ee for e in trainn_fold for ee in e]\\n test_fold = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'folds', 'test_fold_setting1.txt')))\\n ligands = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'ligands_can.txt')),\\n object_pairs_hook=OrderedDict)\\n proteins = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'proteins.txt')),\\n object_pairs_hook=OrderedDict)\\n \\n affinity = pickle.load(open(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'Y'), \\n 'rb'), encoding='latin1')\\n smiles_lst, protein_lst = [], []\\n\\n for k in ligands.keys():\\n smiles = ligands[k]\\n smiles_lst.append(smiles)\\n for k in proteins.keys():\\n protein_lst.append(proteins[k])\\n\\n affinity = np.asarray(affinity)\\n \\n os.makedirs(os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'processed'), exist_ok=True)\\n train_test_dataset = []\\n for split in ['train', 'test']:\\n split_dir = os.path.join('dataset', 'regression', 'benchmark', 'KIBAtest', 'processed', split)\\n os.makedirs(split_dir, exist_ok=True)\\n fold = train_fold if split == 'train' else test_fold\\n rows, cols = np.where(np.isnan(affinity) == False)\\n rows, cols = rows[fold], cols[fold]\\n \\n data_lst = [[] for _ in range(1)]\\n for idx in range(len(rows)):\\n data = {}\\n data['smiles'] = smiles_lst[rows[idx]]\\n data['protein'] = protein_lst[cols[idx]]\\n af = affinity[rows[idx], cols[idx]]\\n data['aff'] = af\\n\\n data_lst[idx % 1].append(data)\\n random.shuffle(data_lst)\\n train_test_dataset.append(data_lst[0])\\n return train_test_dataset\",\n \"def predictionTime(encoder,data_):\\n\\n #initialize algorithm\\n kmean = KMeansClustering()\\n model = SpectralClustering(n_clusters=5, affinity='nearest_neighbors',\\n assign_labels='kmeans')\\n\\n\\n for i in range(20):\\n iterate = 5000*(i+1)\\n data = data_[0:iterate,:]\\n print(data.shape)\\n enc_output = encoder.predict(data)\\n kmean.fit(enc_output)\\n print(\\\"Time predicting \\\"+str(5000*(i+1))+\\\" images\\\")\\n print(\\\"KMEAN\\\")\\n start = time.time()\\n enc_output = encoder.predict(data)\\n pred = kmean.predict(enc_output)\\n end = time.time()\\n print(end - start)\\n\\n\\n print(\\\"SC\\\")\\n start = time.time()\\n enc_output = encoder.predict(data)\\n pred = model.fit_predict(enc_output)\\n end = time.time()\\n print(end - start)\",\n \"def train(args):\\n dataset = args.dataset\\n ae_mode = args.mode\\n train_input, train_labels = load_data(dataset, mode=ae_mode)\\n num_clusters = len(np.unique(train_labels))\\n data_initialization = dataset_parameters[dataset]['data_initialization']\\n with_attention = args.attention\\n interval_updation = dataset_parameters[dataset][\\n 'interval_updation'] if args.interval_updation is None else args.interval_updation\\n temperature = 1.\\n auto_encoder_optimizer = SGD(lr=args.learning_rate, momentum=0.9)\\n\\n if ae_mode == \\\"ae\\\":\\n if train_input.shape[-1] > 1024:\\n print(\\\"Shape of training data before transformation: {}\\\".format(train_input.shape))\\n train_input = PCA(n_components=728).fit_transform(train_input)\\n print(\\\"Shape of training data after transformation: {}\\\".format(train_input.shape))\\n\\n dimensions = [train_input.shape[-1], 500, 500, 2000,\\n len(np.unique(train_labels))] if args.include_layer is None else [train_input.shape[-1], 500, 500,\\n 2000, args.include_layer,\\n len(np.unique(train_labels))]\\n else:\\n dimensions = [32, 64]\\n\\n model = ClusteringNetwork(dimensions=dimensions, temperature=temperature, data_initialization=data_initialization,\\n num_clusters=num_clusters, output_directory=args.output_directory, dataset=dataset,\\n ae_mode=ae_mode, with_attention=with_attention)\\n\\n if args.ae_weights:\\n model.auto_encoder.load_weights(args.ae_weights)\\n else:\\n model.train_auto_encoder(data=train_input, labels=train_labels, train_steps=args.ae_iterations,\\n batch_size=args.batch_size, output_directory=args.output_directory,\\n optimizer=auto_encoder_optimizer)\\n\\n model.model.summary()\\n\\n start_time = time.time()\\n\\n model.compile(optimizer=SGD(0.01, 0.9), loss='kld')\\n p_labels = model.train_cluster_network(data=train_input, labels=train_labels,\\n tolerance_threshold=args.tolerance_threshold,\\n iterations=args.cluster_iterations, batch_size=args.batch_size,\\n interval_updation=interval_updation)\\n\\n stop_time = time.time()\\n print(\\\"Accuracy: {}\\\".format(EvaluatePerformance.accuracy(train_labels, p_labels)))\\n print(\\\"Time taken to finish the training: {}s\\\".format((stop_time - start_time)))\",\n \"def run(input_dir, output_dir, team_name=\\\"OrganizersTeam\\\", predict_window=12):\\n\\n models_dir = os.path.join(output_dir, \\\"models\\\")\\n plots_dir = os.path.join(output_dir, \\\"plots\\\")\\n sub_dir = os.path.join(output_dir, \\\"submissions\\\")\\n submission_file_name_fmt = \\\"{}_{}.csv\\\"\\n\\n make_directory_tree([\\\"models\\\", \\\"plots\\\", \\\"submissions\\\"], output_dir)\\n\\n datasets = get_datasets(input_dir)\\n\\n print(\\\"Will train a total of {} models\\\".format(len(datasets) * 3))\\n\\n # create a scores table to keep MAE for each location:model pair\\n scores = pd.DataFrame(columns=[\\\"Location\\\", \\\"Model\\\", \\\"MAE\\\"])\\n\\n for dataset in datasets:\\n # load the dataset\\n df = read_csv_series(os.path.join(input_dir, dataset))\\n loc = dataset.split(\\\".\\\")[0]\\n\\n # shift PM10 for `predict_window` hours ahead\\n df[\\\"PM10\\\"] = df[\\\"PM10\\\"].shift(-predict_window)\\n\\n # split dataset into train, test and evaluation by dates\\n # additionally, leave the last 48 hours for final evaluation\\n train_len = int(len(df) * 0.65) - (2 * predict_window)\\n test_len = int(len(df) * 0.25) - (2 * predict_window)\\n eval_len = len(df) - train_len - test_len - (2 * predict_window)\\n train, test, evaluation = df[:train_len], df[train_len:train_len +\\n test_len], df[train_len+test_len:train_len+test_len+eval_len]\\n final_eval = df[-(2 * predict_window):-predict_window].copy()\\n\\n # initialize models\\n models = [\\n (\\\"Linear Regression\\\", LinearRegression()),\\n (\\\"Extra Trees Regressor\\\", ExtraTreesRegressor(n_estimators=100, n_jobs=4, min_samples_split=25,\\n min_samples_leaf=35, random_state=0)),\\n (\\\"XGBoost Trees Regression\\\", xgb.XGBRegressor(objective=\\\"reg:linear\\\", random_state=0))\\n ]\\n\\n mae_min = 1e10\\n yhat_sub = []\\n\\n for model in models:\\n # get predictions and MAE\\n yhat, mae = train_and_evaluate(\\\"{} - {}\\\".format(loc,model[0]),model[1],train,test,evaluation,final_eval, output_dir)\\n\\n # save the score (MAE) for the model\\n scores = scores.append(\\n {\\\"Location\\\": loc, \\\"Model\\\": model[0], \\\"MAE\\\": mae}, ignore_index=True)\\n\\n # save the better predictions to `yhat_sub`\\n if mae < mae_min:\\n mae_min = mae\\n yhat_sub = yhat\\n\\n sub_df = pd.DataFrame(yhat_sub, columns=[\\\"PM10\\\"])\\n sub_df.to_csv(os.path.join(sub_dir, submission_file_name_fmt.format(team_name, loc)))\\n\\n scores.to_csv(os.path.join(output_dir, \\\"scores.csv\\\"))\\n\\n print(\\\"Done\\\")\\n print(\\\"Saved models can be found at {}\\\".format(models_dir))\\n print(\\\"Plots can be found at {}\\\".format(plots_dir))\\n print(\\\"Submissions can be found at {}\\\".format(sub_dir))\\n\\n return scores\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def train_test_model_batch():\\n train=learning.Train_kmer_clf()\\n train.run()\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(x_train, y_train, x_test, y_test):\\n\\n print(\\\" Nearest centroid : \\\", end='')\\n run(x_train, y_train, x_test, y_test, NearestCentroid())\\n print(\\\" k-NN classifier (k=3) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=3))\\n print(\\\" k-NN classifier (k=7) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=7))\\n print(\\\" Naive Bayes (Gaussian) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, GaussianNB())\\n print(\\\" Random Forest (trees= 5) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=5))\\n print(\\\" Random Forest (trees= 50) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=50))\\n print(\\\" Random Forest (trees=500) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=500))\\n print(\\\" Random Forest (trees=1000): \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=1000))\\n print(\\\" LinearSVM (C=0.01) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.01))\\n print(\\\" LinearSVM (C=0.1) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.1))\\n print(\\\" LinearSVM (C=1.0) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=1.0))\\n print(\\\" LinearSVM (C=10.0) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=10.0))\",\n \"def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\\n distribute_training=False):\\n train_set = np.array(train_set)\\n test_set = np.array(test_set)\\n\\n print(\\\"The shape of training set before dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set before dimension reduction is {0}\\\".format(test_set.shape))\\n print('Use distribute training ? >> {0}'.format(distribute_training))\\n reg = linear_model.BayesianRidge()\\n\\n if dimension_reduce:\\n pca = PCA(n_components=128)\\n train_set = pca.fit_transform(train_set)\\n test_set = pca.fit_transform(test_set)\\n\\n print(\\\"The shape of training set after dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set after dimension reduction is {0}\\\".format(test_set.shape))\\n\\n if not distribute_training:\\n reg.fit(train_set, train_label)\\n else:\\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\\n train_label), da.array(test_label)\\n reg.fit(train_set, train_label)\\n\\n predicted_label = reg.predict(test_set)\\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\\n\\n mkdirs_if_not_exist('./model')\\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\\n print('The regression model has been persisted...')\\n\\n mkdirs_if_not_exist('./result')\\n\\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\\n\\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\\n df.to_csv('./result/%s.csv' % data_name, index=False)\\n print('The result csv file has been generated...')\",\n \"def train(self):\\n return\",\n \"def train(self, input_vects):\\n \\n #Training iterations\\n for iter_no in range(self._n_iterations):\\n print(iter_no)\\n if (iter_no % 1==0) & (iter_no>0) :\\n \\n self.map_plot(iter_no)\\n centroid_grid = [[] for i in range(self._m)]\\n self._weightages = list(self._sess.run(self._weightage_vects))\\n self._locations = list(self._sess.run(self._location_vects))\\n \\n for i, loc in enumerate(self._locations):\\n centroid_grid[loc[0]].append(self._weightages[i])\\n self._centroid_grid = centroid_grid \\n \\n #Train with each vector one by one\\n for input_vect in input_vects:\\n self._sess.run(self._training_op,\\n feed_dict={self._vect_input: input_vect,\\n self._iter_input: iter_no})\\n print(iter_no)\\n self.map_plot(iter_no) \\n self._trained = True\\n gif.build_gif(imgs, saveto='exoplaneta005s6 .gif')\",\n \"def fit(self, X, epochs=50):\\n self.clusters = [[] for _ in range(self.k)]\\n for i in range(X.shape[0]):\\n index = random.randint(0, self.k - 1)\\n self.clusters[index].append(X[i])\\n self.sample_in_cluster.append(index)\\n for e in range(epochs):\\n #beregn nye centers\\n self.estimate_centers()\\n #nullstill clusters\\n self.reset_clusters()\\n #legg til alle punkter på nytt i clusters\\n self.make_clusters(X)\\n if self.changed == False:\\n break\",\n \"def main():\\n dataset_config = DatasetBuilder.copy_config(\\n DatasetBuilder.KITTI_TRAIN)\\n dataset_config.num_clusters[0] = 1\\n dataset = DatasetBuilder.build_kitti_dataset(dataset_config)\\n\\n label_cluster_utils = LabelClusterUtils(dataset)\\n clusters, _ = label_cluster_utils.get_clusters()\\n\\n # Options\\n img_idx = 1\\n # fake_clusters = np.array([[5, 4, 3], [6, 5, 4]])\\n # fake_clusters = np.array([[3, 3, 3], [4, 4, 4]])\\n\\n fake_clusters = np.array([[4, 2, 3]])\\n fake_anchor_stride = [5.0, 5.0]\\n ground_plane = [0, -1, 0, 1.72]\\n\\n anchor_3d_generator = grid_anchor_3d_generator.GridAnchor3dGenerator()\\n\\n area_extents = np.array([[-40, 40], [-5, 5], [0, 70]])\\n\\n # Generate anchors for cars only\\n start_time = time.time()\\n anchor_boxes_3d = anchor_3d_generator.generate(\\n area_3d=dataset.kitti_utils.area_extents,\\n anchor_3d_sizes=fake_clusters,\\n anchor_stride=fake_anchor_stride,\\n ground_plane=ground_plane)\\n all_anchors = box_3d_encoder.box_3d_to_anchor(anchor_boxes_3d)\\n end_time = time.time()\\n print(\\\"Anchors generated in {} s\\\".format(end_time - start_time))\\n\\n # Project into bev\\n bev_boxes, bev_normalized_boxes = \\\\\\n anchor_projector.project_to_bev(all_anchors, area_extents[[0, 2]])\\n\\n bev_fig, (bev_axes, bev_normalized_axes) = \\\\\\n plt.subplots(1, 2, figsize=(16, 7))\\n bev_axes.set_xlim(0, 80)\\n bev_axes.set_ylim(70, 0)\\n bev_normalized_axes.set_xlim(0, 1.0)\\n bev_normalized_axes.set_ylim(1, 0.0)\\n\\n plt.show(block=False)\\n\\n for box in bev_boxes:\\n box_w = box[2] - box[0]\\n box_h = box[3] - box[1]\\n\\n rect = patches.Rectangle((box[0], box[1]),\\n box_w, box_h,\\n linewidth=2,\\n edgecolor='b',\\n facecolor='none')\\n\\n bev_axes.add_patch(rect)\\n\\n for normalized_box in bev_normalized_boxes:\\n box_w = normalized_box[2] - normalized_box[0]\\n box_h = normalized_box[3] - normalized_box[1]\\n\\n rect = patches.Rectangle((normalized_box[0], normalized_box[1]),\\n box_w, box_h,\\n linewidth=2,\\n edgecolor='b',\\n facecolor='none')\\n\\n bev_normalized_axes.add_patch(rect)\\n\\n rgb_fig, rgb_2d_axes, rgb_3d_axes = \\\\\\n vis_utils.visualization(dataset.rgb_image_dir, img_idx)\\n plt.show(block=False)\\n\\n image_path = dataset.get_rgb_image_path(dataset.sample_names[img_idx])\\n image_shape = np.array(Image.open(image_path)).shape\\n\\n stereo_calib_p2 = calib_utils.read_calibration(dataset.calib_dir,\\n img_idx).p2\\n\\n start_time = time.time()\\n rgb_boxes, rgb_normalized_boxes = \\\\\\n anchor_projector.project_to_image_space(all_anchors,\\n stereo_calib_p2,\\n image_shape)\\n end_time = time.time()\\n print(\\\"Anchors projected in {} s\\\".format(end_time - start_time))\\n\\n # Read the stereo calibration matrix for visualization\\n stereo_calib = calib_utils.read_calibration(dataset.calib_dir, 0)\\n p = stereo_calib.p2\\n\\n # Overlay boxes on images\\n anchor_objects = []\\n for anchor_idx in range(len(anchor_boxes_3d)):\\n anchor_box_3d = anchor_boxes_3d[anchor_idx]\\n\\n obj_label = box_3d_encoder.box_3d_to_object_label(anchor_box_3d)\\n\\n # Append to a list for visualization in VTK later\\n anchor_objects.append(obj_label)\\n\\n # Draw 3D boxes\\n vis_utils.draw_box_3d(rgb_3d_axes, obj_label, p)\\n\\n # Draw 2D boxes\\n rgb_box_2d = rgb_boxes[anchor_idx]\\n\\n box_x1 = rgb_box_2d[0]\\n box_y1 = rgb_box_2d[1]\\n box_w = rgb_box_2d[2] - box_x1\\n box_h = rgb_box_2d[3] - box_y1\\n\\n rect = patches.Rectangle((box_x1, box_y1),\\n box_w, box_h,\\n linewidth=2,\\n edgecolor='b',\\n facecolor='none')\\n\\n rgb_2d_axes.add_patch(rect)\\n\\n if anchor_idx % 32 == 0:\\n rgb_fig.canvas.draw()\\n\\n plt.show(block=False)\\n\\n # Create VtkGroundPlane for ground plane visualization\\n vtk_ground_plane = VtkGroundPlane()\\n vtk_ground_plane.set_plane(ground_plane, area_extents[[0, 2]])\\n\\n # Create VtkAxes\\n axes = vtk.vtkAxesActor()\\n axes.SetTotalLength(5, 5, 5)\\n\\n # Create VtkBoxes for boxes\\n vtk_boxes = VtkBoxes()\\n vtk_boxes.set_objects(anchor_objects, vtk_boxes.COLOUR_SCHEME_KITTI)\\n\\n # Create Voxel Grid Renderer in bottom half\\n vtk_renderer = vtk.vtkRenderer()\\n vtk_renderer.AddActor(vtk_boxes.vtk_actor)\\n vtk_renderer.AddActor(vtk_ground_plane.vtk_actor)\\n vtk_renderer.AddActor(axes)\\n vtk_renderer.SetBackground(0.2, 0.3, 0.4)\\n\\n # Setup Camera\\n current_cam = vtk_renderer.GetActiveCamera()\\n current_cam.Pitch(170.0)\\n current_cam.Roll(180.0)\\n\\n # Zooms out to fit all points on screen\\n vtk_renderer.ResetCamera()\\n\\n # Zoom in slightly\\n current_cam.Zoom(2.5)\\n\\n # Reset the clipping range to show all points\\n vtk_renderer.ResetCameraClippingRange()\\n\\n # Setup Render Window\\n vtk_render_window = vtk.vtkRenderWindow()\\n vtk_render_window.SetWindowName(\\\"Anchors\\\")\\n vtk_render_window.SetSize(900, 500)\\n vtk_render_window.AddRenderer(vtk_renderer)\\n\\n # Setup custom interactor style, which handles mouse and key events\\n vtk_render_window_interactor = vtk.vtkRenderWindowInteractor()\\n vtk_render_window_interactor.SetRenderWindow(vtk_render_window)\\n\\n vtk_render_window_interactor.SetInteractorStyle(\\n vtk.vtkInteractorStyleTrackballCamera())\\n\\n # Render in VTK\\n vtk_render_window.Render()\\n vtk_render_window_interactor.Start() # Blocking\\n # vtk_render_window_interactor.Initialize() # Non-Blocking\",\n \"def createTrainTestSets():\\n tweets = open(noDuplicatesFilename, 'r').read().splitlines()\\n name_mapping = loadNameMapping()\\n holdoutLocations = [u'Frederiksberg, Danmark', u'T\\\\xe5rnby, Danmark', u'Kolding, Danmark', u'T\\\\xe4by, Sverige', u'Kungsbacka, Sverige', u'Kristianstad, Sverige', u'Bod\\\\xf8, Norge', u'Kvinnherad, Norge', u'Ullensaker, Norge']\\n testSetLocation = []\\n rest = []\\n for tweet in tweets:\\n if stringToTweet(tweet).getFullName() in holdoutLocations:\\n testSetLocation.append(tweet)\\n else:\\n rest.append(tweet)\\n tweets = rest\\n testIndex = int(round(len(tweets) * (1 - test_set_ratio)))\\n random.seed(1)\\n random.shuffle(tweets)\\n trainSet = tweets[:testIndex]\\n testSet = tweets[testIndex:]\\n open(trainSetFilename, 'w').write('\\\\n'.join(trainSet))\\n open(testSetNormalFilename, 'w').write('\\\\n'.join(testSet))\\n open(testSetLocationFilename, 'w').write('\\\\n'.join(testSetLocation))\\n print \\\"Wrote %d tweets to train set\\\" % len(trainSet)\\n print \\\"Wrote %d tweets to normal test set\\\" % len(testSet)\\n print \\\"Wrote %d tweets to location test set\\\" % len(testSetLocation)\",\n \"def predict_all():\\n\\n # need train dir to list category names\\n cfg = configparser.ConfigParser()\\n cfg.read(sys.argv[1])\\n base = os.environ['DATA_ROOT']\\n eval_type = cfg.get('args', 'eval_type')\\n train_xml_dir = os.path.join(base, cfg.get('data', 'train_xml_dir'))\\n\\n if eval_type == 'sparse':\\n predict_sparse(train_xml_dir)\\n else:\\n predict_dense(train_xml_dir)\",\n \"def get_dataset(image_folder: str, img_size: str, self_training: bool = False, no_augmentation: bool = False, valid_dir: str = None):\\n \\n primary_img_paths = glob.glob(image_folder + os.sep + \\\"*/*.jpg\\\")\\n primary_img_paths += glob.glob(image_folder + os.sep + \\\"*/*.png\\\")\\n if valid_dir is None:\\n \\n y = [os.path.basename(os.path.dirname(path)) for path in primary_img_paths]\\n\\n train_img_paths, test_img_paths, _, _ = train_test_split(primary_img_paths, y, \\n stratify = y, \\n test_size = 1 - TRAIN_RATIO)\\n #primary_img_paths = undersample(primary_img_paths)\\n \\n SIZE = len(primary_img_paths)\\n shuffle(primary_img_paths)\\n \\n TRAIN = int(SIZE*TRAIN_RATIO)\\n TEST = SIZE - TRAIN\\n \\n if self_training:\\n print(\\\"Using predictions on unlabelled data in train set!\\\".rjust(70, \\\"#\\\").ljust(90, \\\"#\\\"))\\n secondary_img_path = glob.glob(\\\"data/secondary_dataset\\\" + os.sep + \\\"*/*.jpg\\\")\\n shuffle(secondary_img_path)\\n\\n #train_img_paths = primary_img_paths[:TRAIN] + secondary_img_path\\n train_img_paths += secondary_img_path\\n #else:\\n # train_img_paths = primary_img_paths[:TRAIN]\\n \\n #test_img_paths = primary_img_paths[TRAIN:]\\n TRAIN = len(train_img_paths) # For display purpose\\n \\n if self_training:\\n TRAIN += len(secondary_img_path) # For display purpose\\n else:\\n train_img_paths = glob.glob(image_folder + os.sep + \\\"*/*.jpg\\\") + glob.glob(image_folder + os.sep + \\\"*/*.png\\\")\\n test_img_paths = glob.glob(valid_dir + os.sep + \\\"*/*.jpg\\\") + glob.glob(valid_dir + os.sep + \\\"*/*.png\\\")\\n TRAIN = len(train_img_paths)\\n TEST = len(test_img_paths)\\n\\n label_names = os.listdir(image_folder)\\n if no_augmentation:\\n train_dataset = CustomImageDataset(train_img_paths, get_test_transforms(img_size), label_names)\\n else:\\n train_dataset = CustomImageDataset(train_img_paths, get_train_transforms(img_size), label_names)\\n test_dataset = CustomImageDataset(test_img_paths, get_test_transforms(img_size), label_names)\\n class_to_idx = train_dataset.class_to_idx\\n \\n # Create DataLoader for training\\n train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\\n test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE)\\n \\n \\n \\n weights = get_class_weights(train_img_paths, class_to_idx, label_names) # For balancing dataset using inverse-frequency\\n \\n\\n print(f\\\"Number of classes {NUM_CLASSES}, Train size: {TRAIN} images, Test size: {TEST} images, Batch size: {BATCH_SIZE}, Image size: {img_size}x{img_size}\\\")\\n return train_dataloader, test_dataloader, class_to_idx, weights\",\n \"def process_dataset(self):\\n\\n logger.info('\\\\n')\\n logger.info('=' * 40)\\n logger.info('=\\\\t DeepRank Data Set')\\n logger.info('=')\\n logger.info('=\\\\t Training data')\\n for f in self.train_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n if self.valid_database:\\n logger.info('=\\\\t Validation data')\\n for f in self.valid_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n if self.test_database:\\n logger.info('=\\\\t Test data')\\n for f in self.test_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n logger.info('=' * 40 + '\\\\n')\\n sys.stdout.flush()\\n\\n # check if the files are ok\\n self.check_hdf5_files(self.train_database)\\n\\n if self.valid_database:\\n self.valid_database = self.check_hdf5_files(\\n self.valid_database)\\n\\n if self.test_database:\\n self.test_database = self.check_hdf5_files(\\n self.test_database)\\n\\n # create the indexing system\\n # alows to associate each mol to an index\\n # and get fname and mol name from the index\\n self.create_index_molecules()\\n\\n # get the actual feature name\\n if self.mapfly:\\n self.get_raw_feature_name()\\n else:\\n self.get_mapped_feature_name()\\n\\n # get the pairing\\n self.get_pairing_feature()\\n\\n # get grid shape\\n self.get_grid_shape()\\n\\n # get the input shape\\n self.get_input_shape()\\n\\n # get renormalization factor\\n if self.normalize_features or self.normalize_targets or self.clip_features:\\n if self.mapfly:\\n self.compute_norm()\\n else:\\n self.get_norm()\\n\\n logger.info('\\\\n')\\n logger.info(\\\" Data Set Info:\\\")\\n logger.info(\\n f' Augmentation : {self.use_rotation} rotations')\\n logger.info(\\n f' Training set : {self.ntrain} conformations')\\n logger.info(\\n f' Validation set : {self.nvalid} conformations')\\n logger.info(\\n f' Test set : {self.ntest} conformations')\\n logger.info(f' Number of channels : {self.input_shape[0]}')\\n logger.info(f' Grid Size : {self.data_shape[1]}, '\\n f'{self.data_shape[2]}, {self.data_shape[3]}')\\n sys.stdout.flush()\",\n \"def simulate_user_annotations(self):\\r\\n\\r\\n # Check existence of clustering results\\r\\n\\r\\n if len(self.recognized_faces) == 0:\\r\\n\\r\\n # Try to load YAML files\\r\\n if os.path.exists(self.cluster_files_path):\\r\\n\\r\\n print 'Loading YAML files with clustering results'\\r\\n logger.debug('Loading YAML file with clustering results')\\r\\n\\r\\n self.recognized_faces = []\\r\\n for yaml_file in os.listdir(self.cluster_files_path):\\r\\n yaml_file_path = os.path.join(\\r\\n self.cluster_files_path, yaml_file)\\r\\n with open(yaml_file_path) as f:\\r\\n self.recognized_faces.append(yaml.load(f))\\r\\n\\r\\n print 'YAML file with clustering results loaded'\\r\\n logger.debug('YAML file with clustering results loaded')\\r\\n\\r\\n else:\\r\\n\\r\\n print 'Warning! No clustering results found!'\\r\\n logger.warning('No clustering results found!')\\r\\n\\r\\n return\\r\\n\\r\\n auto_p_counter = 0\\r\\n\\r\\n user_rec_faces = []\\r\\n\\r\\n # Iterate through automatic recognized faces\\r\\n for auto_p_dict in self.recognized_faces:\\r\\n\\r\\n segment_list = auto_p_dict[c.SEGMENTS_KEY]\\r\\n\\r\\n # Get first segment\\r\\n if len(segment_list) >= 1:\\r\\n\\r\\n first_segment = segment_list[0]\\r\\n\\r\\n segment_ann_tag = first_segment[c.ANN_TAG_KEY]\\r\\n\\r\\n auto_p_dict[c.ASSIGNED_TAG_KEY] = segment_ann_tag\\r\\n\\r\\n user_rec_faces.append(auto_p_dict)\\r\\n\\r\\n auto_p_counter += 1\\r\\n\\r\\n self.recognized_faces = user_rec_faces\\r\\n\\r\\n # Save clustering result in YAML files\\r\\n\\r\\n # Remove previous files\\r\\n if os.path.exists(self.cluster_files_path):\\r\\n shutil.rmtree(self.cluster_files_path)\\r\\n # Create directory for people clustering results\\r\\n os.makedirs(self.cluster_files_path)\\r\\n\\r\\n counter = 0\\r\\n for person_dict in self.recognized_faces:\\r\\n yaml_file_name = str(counter) + '.YAML'\\r\\n yaml_file_path = os.path.join(self.cluster_files_path, yaml_file_name)\\r\\n utils.save_YAML_file(yaml_file_path, person_dict)\\r\\n counter += 1\",\n \"def train_k():\\n\\n for i in range(n_families):\\n print('[training-k] family:', i, '...')\\n f1_fam_name = 'f1_fam_' + str(i) + '_features'\\n feature_mat_fam1 = mask_features(f1_fam_name)\\n n_samples = len(feature_mat_fam1)\\n # use 80% of samples as training set\\n feature_mat_fam1 = feature_mat_fam1[int(n_samples / 5):, :]\\n my_k, my_result = train_with_inner_outer(feature_mat_fam1, 0)\\n\\n save_name = '/f1_fam_' + str(i) + '_validation'\\n with open(saved_cluster_path + save_name, 'wb') as fp:\\n pickle.dump(my_result, fp)\",\n \"def get_pointcloud(dataset, NUM_POINT=2048, shuffle=True):\\n if dataset == 'modelnet':\\n train_file_idxs = np.arange(0, len(TRAIN_FILES_MODELNET))\\n data_train = []\\n label_train = []\\n for fn in range(len(TRAIN_FILES_MODELNET)):\\n print('----' + str(fn) + '-----')\\n current_data, current_label = provider.loadDataFile(TRAIN_FILES_MODELNET[fn])\\n current_data = current_data[:,0:NUM_POINT,:]\\n current_label = np.squeeze(current_label)\\n data_train.append(current_data)\\n label_train.append(current_label)\\n result_train = np.vstack(data_train)\\n label_train = np.concatenate(label_train, axis=None)\\n if shuffle:\\n X_train, y_train, _ = provider.shuffle_data(result_train, np.squeeze(label_train)) \\n else:\\n X_train, y_train = result_train, np.squeeze(label_train)\\n \\n data_test = []\\n label_test = []\\n for fn in range(len(TEST_FILES_MODELNET)):\\n print('----' + str(fn) + '-----')\\n current_data, current_label = provider.loadDataFile(TEST_FILES_MODELNET[fn])\\n current_data = current_data[:,0:NUM_POINT,:]\\n current_label = np.squeeze(current_label)\\n data_test.append(current_data)\\n label_test.append(current_label)\\n result_test = np.vstack(data_test)\\n label_test = np.concatenate(label_test, axis=None)\\n if shuffle:\\n X_test, y_test, _ = provider.shuffle_data(result_test, np.squeeze(label_test))\\n else:\\n X_test, y_test = result_test, np.squeeze(label_test)\\n elif dataset == 'shapenet':\\n shapenet_data, shapenet_label = provider.get_shapenet_data()\\n shapenet_data = shapenet_data[:,0:NUM_POINT,:]\\n X_train, X_test, y_train, y_test = train_test_split(shapenet_data, shapenet_label, test_size=0.2, random_state=42, shuffle=shuffle)\\n elif dataset == 'shapenet_chair':\\n shapenet_data, shapenet_label = provider.get_shapenet_data()\\n shapenet_data = shapenet_data[:,0:NUM_POINT,:]\\n shapenet_data, shapenet_label = shapenet_data[shapenet_label==17], shapenet_label[shapenet_label==17]\\n X_train, X_test, y_train, y_test = train_test_split(shapenet_data, shapenet_label, test_size=0.2, random_state=42, shuffle=shuffle)\\n elif dataset == 'modelnet10':\\n current_data, current_label = provider.loadDataFile(MODELNET10_TRAIN_FILE)\\n current_data = current_data[:,0:NUM_POINT,:]\\n if shuffle:\\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \\n current_label = np.squeeze(current_label)\\n X_train, y_train = current_data, current_label\\n\\n current_data, current_label = provider.loadDataFile(MODELNET10_TEST_FILE)\\n current_data = current_data[:,0:NUM_POINT,:]\\n if shuffle:\\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \\n current_label = np.squeeze(current_label)\\n X_test, y_test = current_data, current_label\\n elif dataset == 'keypoint':\\n current_data, current_label = provider.load_mat_keypts(TRAIN_CHAIR_FILES, KEYPOINT_CHAIR_PATH, NUM_POINT)\\n if shuffle:\\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \\n for i in range(current_data.shape[0]): # shuffle order of points in a single model, otherwise keypoints are always at the end\\n idx = np.arange(current_data.shape[1])\\n np.random.shuffle(idx)\\n current_data = current_data[:, idx, :]\\n current_label = current_label[:, idx]\\n current_label = np.squeeze(current_label)\\n X_train, y_train = current_data, current_label\\n\\n current_data, current_label = provider.load_mat_keypts(TEST_CHAIR_FILES, KEYPOINT_CHAIR_PATH, NUM_POINT)\\n if shuffle:\\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \\n for i in range(current_data.shape[0]):\\n idx = np.arange(current_data.shape[1])\\n np.random.shuffle(idx)\\n current_data = current_data[:, idx, :]\\n current_label = current_label[:, idx]\\n current_label = np.squeeze(current_label)\\n X_test, y_test = current_data, current_label\\n elif dataset == 'keypoint_10class':\\n current_data, current_label = provider.load_mat_keypts(TRAIN_CHAIR_FILES, KEYPOINT_CHAIR_PATH, NUM_POINT)\\n current_label[:, -10:] = np.arange(1, 11)\\n if shuffle:\\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \\n for i in range(current_data.shape[0]): # shuffle order of points in a single model, otherwise keypoints are always at the end\\n idx = np.arange(current_data.shape[1])\\n np.random.shuffle(idx)\\n current_data = current_data[:, idx, :]\\n current_label = current_label[:, idx]\\n current_label = np.squeeze(current_label)\\n X_train, y_train = current_data, current_label\\n\\n current_data, current_label = provider.load_mat_keypts(TEST_CHAIR_FILES, KEYPOINT_CHAIR_PATH, NUM_POINT)\\n current_label[:, -10:] = np.arange(1, 11)\\n if shuffle:\\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \\n for i in range(current_data.shape[0]):\\n idx = np.arange(current_data.shape[1])\\n np.random.shuffle(idx)\\n current_data = current_data[:, idx, :]\\n current_label = current_label[:, idx]\\n current_label = np.squeeze(current_label)\\n X_test, y_test = current_data, current_label\\n elif dataset == \\\"keypointnet\\\":\\n json_path = osp.join(KEYPOINTNET_PATH, \\\"annotations/all.json\\\")\\n annots = json.load(open(json_path))\\n X = []\\n y = []\\n for annot in annots:\\n class_id = annot[\\\"class_id\\\"]\\n model_id = annot[\\\"model_id\\\"]\\n kpts = []\\n for kpt in annot[\\\"keypoints\\\"]:\\n kpts.append(kpt[\\\"xyz\\\"])\\n pcd_path = osp.join(KEYPOINTNET_PATH, f\\\"pcds/{class_id}/{model_id}.pcd\\\")\\n if os.path.exists(pcd_path):\\n pcd = naive_read_pcd(pcd_path)\\n pcd = pcd[0:NUM_POINT, :]\\n else:\\n continue\\n if len(kpts) != 10:\\n continue\\n pcd = np.concatenate((pcd[:-10], kpts))\\n label = np.zeros(NUM_POINT-10)\\n label = np.concatenate((label, np.ones(10)))\\n X.append(pcd)\\n y.append(label)\\n current_data = np.array(X)\\n current_label = np.array(y)\\n if False and shuffle:\\n current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) \\n for i in range(current_data.shape[0]): # shuffle order of points in a single model, otherwise keypoints are always at the end\\n idx = np.arange(current_data.shape[1])\\n np.random.shuffle(idx)\\n current_data = current_data[:, idx, :]\\n current_label = current_label[:, idx]\\n current_label = np.squeeze(current_label)\\n X_train, X_test, y_train, y_test = train_test_split(current_data, current_label, test_size=0.2, random_state=42, shuffle=shuffle)\\n else:\\n raise NotImplementedError()\\n print(f'Dataset name: {dataset}')\\n print(f'X_train: {X_train.shape}')\\n print(f'X_test: {X_test.shape}')\\n print(f'y_train: {y_train.shape}')\\n print(f'y_test: {y_test.shape}')\\n return X_train, X_test, y_train, y_test\",\n \"def predictClusters(self, df, k):\\n self.models.fitModels(df)\\n return self.models.predict()\",\n \"def main(unused_argv):\\n del unused_argv\\n if not os.path.exists(FLAGS.data_dir):\\n os.makedirs(FLAGS.data_dir)\\n\\n tfds_cached_dict = {}\\n data_dir = FLAGS.tfds_data_dir if FLAGS.tfds_data_dir else None\\n name = FLAGS.dataset_name\\n tfds_cached_dict[name] = tfds.load(name, batch_size=-1, data_dir=data_dir)\\n dataset_dict = tfds_cached_dict[name]\\n dataset_dict[tfds.Split.TRAIN] = tfds.as_numpy(\\n dataset_dict[tfds.Split.TRAIN])\\n dataset_dict[tfds.Split.TEST] = tfds.as_numpy(\\n dataset_dict[tfds.Split.TEST])\\n # To mock the API of tfds.load to cache the downloaded datasets.\\n # Used as an argument to `get_dataset`.\\n def load_fn(name, data_dir=None, batch_size=-1):\\n # This function will always return the whole dataset.\\n assert batch_size == -1\\n del data_dir\\n del batch_size\\n return tfds_cached_dict[name]\\n class_ids = sorted([int(x) for x in FLAGS.class_ids])\\n num_classes = len(class_ids)\\n for i in range(num_classes):\\n for j in range(i+1, num_classes):\\n print('Generating pos {} neg {}'.format(i, j))\\n positive_class = class_ids[i]\\n negative_class = class_ids[j]\\n random_seeds = range(FLAGS.min_data_seed, FLAGS.max_data_seed)\\n for seed in random_seeds:\\n dataset = create_projected_binary_dataset(\\n FLAGS.dataset_name, positive_class, negative_class,\\n FLAGS.num_train_examples, FLAGS.num_valid_examples,\\n FLAGS.num_test_examples, FLAGS.projected_dim, seed, load_fn)\\n filename = 'binary_{}-pos_{}-neg_{}-dim_{}-seed_{}'.format(\\n FLAGS.dataset_name, positive_class, negative_class,\\n FLAGS.projected_dim, seed)\\n serialized_dataset = dataset.SerializeToString()\\n\\n with open(os.path.join(FLAGS.data_dir, filename), 'wb') as f:\\n f.write(serialized_dataset)\",\n \"def predict(self, images):\\n\\t\\t#testing_dataset = tf.data.Dataset.from_tensor_slices(images)\\n\\t\\ttf.keras.backend.set_learning_phase(0)\\n\\t\\ttesting_dataset = tf.data.Dataset.from_tensor_slices(np.asarray(images)).map(lambda x: tf.image.resize(x, [self.image_size, self.image_size]) / 255.0)\\n\\t\\t#testing_dataset_shape = tf.data.Dataset.from_tensor_slices(np.full((len(images), 2), 500, dtype=np.int32))\\n\\t\\ttesting_iterator_X = tf.data.Dataset.zip((testing_dataset, )).batch(self.batch_size).make_initializable_iterator()\\n\\n\\t\\tself.sess.run(testing_iterator_X.initializer)\\n\\t\\ttesting_handle_X = self.sess.run(testing_iterator_X.string_handle())\\n\\n\\t\\tfinal_output = np.zeros([len(images), 500, 500, num_classes])\\n\\t\\tj = 0\\n\\t\\tcount = 0\\n\\t\\twhile True:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\t[test_output] = self.sess.run(\\n\\t\\t\\t\\t\\t[self.output],\\n\\t\\t\\t\\t\\t\\tfeed_dict={\\n\\t\\t\\t\\t\\t\\t\\tself.is_training: False,\\n\\t\\t\\t\\t\\t\\t\\tself.handle_X: testing_handle_X,\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\tthis_len = len(test_output)\\n\\t\\t\\t\\tfor z in range(len(test_output)):\\n\\t\\t\\t\\t\\tfor dim in range(num_classes):\\n\\t\\t\\t\\t\\t\\tfinal_output[count+z:count+z+1, :, :, dim] = scipy.misc.imresize(test_output[z, :, :, dim], [500, 500])\\n\\n\\t\\t\\t\\t#final_output[count:count+this_len, :, :, :] = test_output\\n\\t\\t\\t\\tto = final_output[count:count+this_len, :, :, :].argmax(axis=-1)\\n\\t\\t\\t\\t'''\\n\\t\\t\\t\\tpdb.set_trace()\\n\\t\\t\\t\\tfor z in range(this_len):\\n\\t\\t\\t\\t\\tplt.matshow(to[z])\\n\\t\\t\\t\\t\\tplt.colorbar()\\n\\t\\t\\t\\t\\tplt.show()\\n\\t\\t\\t\\t'''\\n\\t\\t\\t\\tcount += this_len\\n\\t\\t\\t\\tprint(f'Batch: {j}')\\n\\t\\t\\t\\tj += 1\\n\\t\\t\\texcept tf.errors.OutOfRangeError:\\n\\t\\t\\t\\tbreak\\n\\t\\treturn final_output\",\n \"def test_subset_classification(p_df_subset, p_weather):\\n X = p_df_subset.drop(\\\"Direction\\\", axis=1)\\n y = p_df_subset[\\\"Direction\\\"]\\n print(\\\"Scale Data...\\\")\\n scaler = StandardScaler()\\n X_scaled_train = scaler.fit_transform(X)\\n print(\\\"Do PCA...\\\")\\n pca = PCA(n_components=15)\\n pca.fit(X_scaled_train)\\n X_train_transformed = pca.transform(X_scaled_train)\\n # Read Models\\n dummy = io.read_object(\\\"Dummy_classifier_model\\\"+p_weather+\\\".pkl\\\")\\n clf = io.read_object(\\\"KNearestNeighbours_classifier_model\\\"+p_weather+\\\".pkl\\\")\\n # Predict\\n print(\\\"Predict...\\\")\\n dummy_y_prediction = dummy.predict(X_train_transformed)\\n kn_y_prediction = clf.predict(X_train_transformed)\\n # Evaluate Predict\\n prediction.evaluate.direction_error_metrics(y, dummy_y_prediction, \\\"Dummy_Classifier\\\"+p_weather, \\\"Testing\\\")\\n prediction.evaluate.direction_error_metrics(y, kn_y_prediction, \\\"KNeighbors_Classifier\\\"+p_weather, \\\"Testing\\\")\",\n \"def get_train_test(self, train=0.8, shuffle=False):\\n if train <= 0 or train >= 1:\\n raise ValueError(\\\"Train size should be the range (0, 1)\\\")\\n test = 1 - train\\n train_pathmap = {}\\n test_pathmap = {}\\n for label, paths in self.pathmap.items():\\n if shuffle:\\n np.random.shuffle(paths)\\n num_images = len(paths)\\n train_idx = int(num_images * train)\\n test_idx = num_images - train_idx\\n train_pathmap[label] = paths[:train_idx]\\n test_pathmap[label] = paths[train_idx : train_idx + test_idx]\\n return train_pathmap, test_pathmap\",\n \"def prepare_cityscapes_data(seed=1, percent=30.0, version=2017):\\n def _save_anno(name, images, annotations):\\n \\\"\\\"\\\"Save annotation\\n \\\"\\\"\\\"\\n print('>> Processing data {}.json saved ({} images {} annotations)'.format(\\n name, len(images), len(annotations)))\\n new_anno = {}\\n new_anno['images'] = images\\n new_anno['annotations'] = annotations\\n new_anno['categories'] = anno['categories']\\n\\n with open(\\n '{root}/{save_name}.json'.format(\\n save_name=name, root=DATA_DIR),\\n 'w') as f:\\n json.dump(new_anno, f)\\n print('>> Data {}.json saved ({} images {} annotations)'.format(\\n name, len(images), len(annotations)))\\n\\n np.random.seed(seed)\\n \\n anno = json.load(open(os.path.join(DATA_DIR, 'instancesonly_filtered_gtFine_train.json')))\\n\\n image_list = anno['images']\\n labeled_tot = int(percent / 100. * len(image_list))\\n #labeled_ind = np.random.choice(range(len(image_list)), size=labeled_tot)\\n labeled_ind = np.arange(len(image_list))\\n np.random.shuffle(labeled_ind)\\n labeled_ind = labeled_ind[0:labeled_tot]\\n\\n labeled_id = []\\n labeled_images = []\\n unlabeled_images = []\\n labeled_ind = set(labeled_ind)\\n for i in range(len(image_list)):\\n if i in labeled_ind:\\n labeled_images.append(image_list[i])\\n labeled_id.append(image_list[i]['id'])\\n else:\\n unlabeled_images.append(image_list[i])\\n\\n # get all annotations of labeled images\\n labeled_id = set(labeled_id)\\n labeled_annotations = []\\n unlabeled_annotations = []\\n for an in anno['annotations']:\\n if an['image_id'] in labeled_id:\\n labeled_annotations.append(an)\\n else:\\n unlabeled_annotations.append(an)\\n\\n # save labeled and unlabeled\\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}'.format(\\n version=version, seed=seed, tot=int(percent))\\n _save_anno(save_name, labeled_images, labeled_annotations)\\n save_name = 'instancesonly_filtered_gtFine_train.{seed}@{tot}-unlabeled'.format(\\n version=version, seed=seed, tot=int(percent))\\n _save_anno(save_name, unlabeled_images, unlabeled_annotations)\",\n \"def prepare_datasets(ref_map: np.ndarray, training_patch: float) -> tuple:\\n samples_by_classes = [[] for _ in range(int(ref_map.max()) + abs(BG_CLASS))]\\n rows, columns = list(range(int(ref_map.shape[ROW_AXIS]))), list(range((int(ref_map.shape[COLUMNS_AXIS]))))\\n for i, j in product(rows, columns):\\n if ref_map[i, j] != BG_CLASS:\\n samples_by_classes[ref_map[i, j]].append([[i, j], ref_map[i, j]])\\n lowest_class_population = np.min([samples_by_classes[i].__len__() for i in range(samples_by_classes.__len__())])\\n train_set, test_set = [], []\\n train_size = int(training_patch * lowest_class_population)\\n for i in range(samples_by_classes.__len__()):\\n train_set.extend(samples_by_classes[i][:train_size])\\n test_set.extend(samples_by_classes[i][train_size:])\\n train_samples, train_labels = list(map(list, zip(*train_set)))\\n test_samples, test_labels = list(map(list, zip(*test_set)))\\n return train_samples, np.asarray(train_labels), test_samples, np.asarray(test_labels)\",\n \"def generate_maps(dl: DatasetLoader, model, map_out: str, graph, all_classes=True, batch_size=10, mode='cv2'):\\n # o_generator = get_outputs_generator(model, 'CAM')\\n input = model.input\\n output = model.get_layer('CAM').output\\n output_predict = model.get_layer('W').output\\n output_fn = K.function([input], [output])\\n fn_predict = K.function([input], [output_predict])\\n\\n o_resizer = tf.image.resize_images\\n o_dot = K.dot\\n\\n # plot CAMs only for the validation data:\\n k = 0\\n counter = 0\\n img_arr = []\\n with K.get_session() as sess:\\n in_place = tf.placeholder(tf.float32, [None, None, None, 512])\\n size_place = tf.placeholder(tf.int32, [2])\\n convert_place = tf.placeholder(tf.float32, [512, len(dl.directories)])\\n first_func = o_resizer(in_place, size_place, ResizeMethod.BICUBIC)\\n second_func = o_dot(in_place, convert_place)\\n graph.finalize()\\n\\n for i in range(dl.number_of_imgs_for_train, dl.number_of_imgs):\\n with graph.as_default() as gr:\\n if i == dl.number_of_imgs - 1:\\n k = batch_size - 1\\n rpath = dl.baseDirectory + \\\"/\\\" + dl.imgDataArray[i].directory + \\\"/\\\" + dl.imgDataArray[i].name\\n img = cv2.imread(rpath, cv2.IMREAD_COLOR)\\n # print('!!!!!!!!debug', rpath, i)\\n img_arr.append(img)\\n k += 1\\n if k == batch_size:\\n start_time = time.time()\\n predict_input = np.asarray(img_arr, dtype='float32')\\n predict_input = preprocess_input(predict_input)\\n\\n k = 0\\n img_arr = []\\n\\n layer_outputs = output_fn([predict_input])[0]\\n predictions = fn_predict([predict_input])[0]\\n\\n if mode == 'cv2': # model, layer_outputs, nb_classes, im_width=256):\\n maps_arr = cam_generate_cv2(model, layer_outputs, dl.nb_classes)\\n else:\\n maps_arr = cam_generate_tf_ops(model, layer_outputs, sess, first_func, second_func, in_place,\\n size_place,\\n convert_place)\\n\\n for l, prediction in enumerate(predictions):\\n inc = i - batch_size + l + 1\\n outpath = map_out + \\\"/\\\" + dl.imgDataArray[inc].directory + \\\"/\\\" + dl.imgDataArray[inc].name\\n # print('[DEBUG]', outpath, inc, i, batch_size, l)\\n\\n try:\\n os.makedirs(outpath)\\n except OSError:\\n continue\\n\\n value = np.argmax(prediction)\\n if all_classes:\\n a = 0\\n b = dl.nb_classes\\n else:\\n a = value\\n b = value + 1\\n for j in range(a, b):\\n outname = outpath + \\\"/\\\" + str(j) + '.tiff'\\n if mode == 'cv2':\\n Image.fromarray(maps_arr[l][j]).save(outname)\\n else:\\n Image.fromarray(maps_arr[l, :, :, j]).save(outname)\\n with open(outpath + '/resuts.json', 'w') as outfile:\\n json.dump({'predicted': str(value), \\\"true_label\\\": str(dl.imgDataArray[inc].img_class)},\\n outfile)\\n print(\\\"cam(\\\", counter, \\\"/\\\", dl.number_of_imgs_for_test, \\\"completed\\\")\\n counter += 1\\n print(\\\"got cams in\\\", time.time() - start_time)\",\n \"def final_evaluation(self):\\n print(\\\"\\\\n=== Assign final labels ===\\\")\\n\\n # skip if there is only one cluster\\n n_cluster = len(set(self.label[self.label != -1]))\\n if n_cluster < 2:\\n print(f\\\"Skip final evaluation because only {n_cluster} cluster label exist.\\\")\\n # name all cluster as c0\\n self.label = np.zeros(self.label.size, dtype=int)\\n self.cv_predicted_label = [f\\\"c{label}\\\" for label in self.label]\\n self.label_proba = np.ones(self.label.size, dtype=int)\\n self.final_accuracy = 1\\n else:\\n # predict outliers\\n outlier_x = self.X[self.label == -1]\\n outlier_idx = np.where(self.label == -1)[0]\\n if len(outlier_idx) != 0:\\n outlier_predict = pd.Series(self.supervise_model.predict(outlier_x), index=outlier_idx)\\n for cell, pred_label in outlier_predict.items():\\n self.label[cell] = pred_label\\n print(\\n \\\"Assigned all the multi-leiden clustering outliers into clusters \\\"\\n \\\"using the prediction model from final clustering version.\\\"\\n )\\n\\n # final evaluation of non-outliers using cross val predict\\n final_predict_proba = cross_val_predict(\\n self.supervise_model,\\n self.X,\\n y=self.label,\\n method=\\\"predict_proba\\\",\\n n_jobs=self.n_jobs,\\n verbose=0,\\n cv=10,\\n )\\n final_predict = pd.Series(np.argmax(final_predict_proba, axis=1))\\n final_cell_proba = pd.Series(np.max(final_predict_proba, axis=1))\\n final_acc = balanced_accuracy_score(self.label, final_predict.values)\\n print(f\\\"Final ten-fold CV Accuracy on all the cells: {final_acc:.3f}\\\")\\n self.cv_predicted_label = [f\\\"c{label}\\\" for label in final_predict]\\n self.label_proba = final_cell_proba.values\\n self.final_accuracy = final_acc\\n\\n self.label = [f\\\"c{label}\\\" for label in self.label]\\n return\",\n \"def train_clustermodel_nonsparse(self):\\n \\n segtimes_df, nonsparse_matrix = self.create_nonsparse_matrix(self.data)\\n segtimes_df['index']=segtimes_df.index\\n nonsparse_matrix['index']=nonsparse_matrix.index\\n data_to_scale = pd.merge(segtimes_df, nonsparse_matrix, on=['index'])\\n data_scaled = self.scale_matrix(data_to_scale)\\n data_to_cluster = data_scaled.drop(columns = ['segment_id','level_0','date','time'])\\n \\n print('Clustering using nonsparse segment/time matrix and: ' + self.algorithm)\\n clusterer = self.clustering_algorithms[self.algorithm]\\n self.clustering_model = clusterer.fit(data_to_cluster)\\n \\n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_nonsparse'])\\n clusters_df['segtimekey'] = clusters_df.index\\n segtimes_df['segtimekey'] = segtimes_df.index\\n clusters_df = clusters_df.reset_index(drop=True)\\n self.clusters_df_final = pd.merge(segtimes_df, clusters_df, on=['segtimekey'])\\n self.clusters_df_final['cluster_nonsparse'].value_counts()\\n \\n today = datetime.date.today()\\n filename = self.algorithm + '_nonsparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\\n joblib.dump(self.clustering_model, filename)\\n \\n print('Stored ' + filename)\\n \\n return self.clustering_model, self.clusters_df_final[['segment_id','date','time','cluster_nonsparse']]\",\n \"def lets_train(debug_flag):\\n # Directory structure\\n parent_path = setup_debug(debug_flag)\\n train_folder = parent_path + 'train_data/'\\n test_folder = parent_path + 'test_data/'\\n # File names\\n train_label_path = train_folder + 'train_true_scores.pickle'\\n train_data_path = train_folder + 'train_processed_data.csv'\\n test_data_path = test_folder + 'test_processed_data.csv'\\n\\n # Training data and labels\\n print('Loading training data...')\\n train_df = pd.read_csv(train_data_path, index_col=0)\\n with open(train_label_path, 'rb') as handle:\\n train_labels = pickle.load(handle)\\n # Test data\\n print('Loading test data...')\\n test_df = pd.read_csv(test_data_path, index_col=0)\\n\\n return(train_folder, test_folder, train_df, train_labels, test_df)\",\n \"def train():\\n fake_data, fake_labels = multiple_fake_clusters(500, 50, 10, 10, 20)\\n X = np.array(fake_data)\\n Y = np.array(fake_labels)\\n\\n model = Sequential()\\n model.add(LSTM(units=128, input_shape=(2, 50)))\\n model.add(Dropout(0.5))\\n model.add(Dense(1, activation=\\\"sigmoid\\\"))\\n\\n my_callbacks = [EarlyStopping(monitor='auc_roc', patience=300, verbose=1, mode='max'),\\n TensorBoard(log_dir=\\\"logs/{}\\\".format(time()))]\\n\\n model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=[\\n 'accuracy', auc_roc, f1_score_threshold(), precision_threshold(), recall_threshold()])\\n model.fit(\\n X,\\n Y,\\n batch_size=100,\\n epochs=10,\\n validation_split=0.2,\\n callbacks=my_callbacks,\\n shuffle=True\\n )\\n\\n # Use this to save the weights to be able to reload them while testing\\n model.save_weights('./weights/my_model_clusters_weights.h5')\",\n \"def clusters(self):\\n raise NotImplementedError\",\n \"def start_algorithm(self):\\r\\n vectors = self.vectorize_data()\\r\\n kmeans = KMeans(init='k-means++', n_clusters=self.cluster_amount, n_init=10)\\r\\n kmeans.fit(vectors)\\r\\n return self.cluster_tweet(kmeans.labels_)\",\n \"def train(self):\\n raise NotImplementedError\",\n \"def __train__(self):\\n if (self.type_camf == 'CAMF_CI'):\\n #users, items, context, ratings\\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = ci.fit()\\n elif (self.type_camf == 'CAMF_CU'):\\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = cu.fit()\\n elif (self.type_camf == 'CAMF_C'):\\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = c.fit()\\n\\n dummy_pred = np.zeros((predictions.shape))\\n for r, pred_array in enumerate(predictions):\\n for c, pred in enumerate(pred_array):\\n dummy_pred[r][c] = self.__check_ratings__(pred)\\n predictions = dummy_pred\\n #save a plot with a loss function\\n plots = prs.PlotRSData()\\n #print(losses)\\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\\\"_loop\\\"+str(self.loop))\\n pd.DataFrame(losses).to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ +\\\"losses_loop\\\"+str(self.loop)+\\\".csv\\\")\\n print('Saving the feature matrix...')\\n # set predictions back to the pivot table\\n self.__utility_saved_training__(predictions) \\n # save results\\n self.utility_predictions.to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ + \\\"_SGD_predictions_loop\\\"+str(self.loop)+\\\".csv\\\")\",\n \"def do_segmentation(img_idxs=None, output=True, save_candidates=True, data='train'):\\n \\n zoom_levels = [1, 0.7, 0.5]\\n \\n # Load images\\n dl = pipeline.DataLoader()\\n \\n if data == 'train':\\n data_imgs = dl.get_original_images(dataset=\\\"train\\\")\\n elif data == 'test':\\n data_imgs = dl.get_original_images(dataset=\\\"test\\\")\\n elif data == 'final':\\n print('Final stage not started yet')\\n exit()\\n else:\\n print('Unknown data set: ' + data)\\n exit()\\n \\n data_x = data_imgs['x']\\n data_meta = data_imgs['meta']\\n \\n if img_idxs is None:\\n img_idxs = list(range(len(data_x)))\\n\\n if len(img_idxs) == 0:\\n print('Empty index range given.')\\n exit()\\n if img_idxs[-1] >= len(data_x):\\n print('Invalid index range ending in %d for used data set of size %d' % (img_idxs[-1], len(data_x)))\\n exit()\\n \\n # Prepare output file\\n if save_candidates:\\n if data == 'train':\\n classlist = dl.get_classes()\\n out_train_json_objs = {}\\n for cls in classlist:\\n out_train_json_objs[cls] = []\\n else:\\n out_json_obj = []\\n \\n # Prepare performance measurements\\n tp_boxes = [0 for _ in zoom_levels]\\n tp_compact_boxes = [0 for _ in zoom_levels]\\n num_boxes = 0\\n tp_fish = [0 for _ in zoom_levels]\\n tp_compact_fish = [0 for _ in zoom_levels]\\n num_fish = 0\\n \\n # See how well the centroids match\\n #lower = lambda centroid, dim: min(max(centroid[dim] - bbox_size/2.0, 0), img.shape[dim] - bbox_size)\\n #upper = lambda centroid, dim: max(bbox_size, min(centroid[dim] + bbox_size/2.0, img.shape[dim]))\\n #intersection_centroid = lambda bbox, centroid: max(0, min(upper(centroid, 1), bbox['x']+bbox['width']) - max(lower(centroid, 1), bbox['x'])) * max(0, min(upper(centroid, 0), bbox['y']+bbox['height']) - max(lower(centroid, 0), bbox['y']))\\n #matches_centroid = lambda bbox, centroid: intersection_centroid(bbox, centroid) / float(bbox['width']*bbox['height']) >= min_overlap_ratio\\n \\n clust_bbox_to_dict = lambda cand: {'x': cand[1], 'width': cand[3]-cand[1], 'y': cand[0], 'height': cand[2]-cand[0]}\\n intersection_bbox = lambda cand, fish: max(0, min(cand['x']+cand['width'], fish['x']+fish['width']) - max(cand['x'], fish['x'])) * max(0, min(cand['y']+cand['height'], fish['y']+fish['height']) - max(cand['y'], fish['y']))\\n containment_ratio = lambda cand, fish: intersection_bbox(cand, fish) / float(fish['width']*fish['height'])\\n \\n # Prepare histogram matching template\\n print('Computing histogram template...')\\n if data == 'train':\\n template = preprocessing.build_template(data_x, data_meta)\\n else:\\n hist_template_data_imgs = dl.get_original_images(file_filter=preprocessing.DEFAULT_HIST_MATCH_TEMPLATES)\\n template = preprocessing.build_template(hist_template_data_imgs['x'], hist_template_data_imgs['meta'])\\n print('Histogram template computed. Starting segmentation...')\\n \\n for idx_idx in range(len(img_idxs)):\\n idx = img_idxs[idx_idx]\\n \\n # Load image\\n img = data_x[idx]().astype('uint8')\\n if 'bounding_boxes' in data_meta[idx]:\\n imgboxes = data_meta[idx]['bounding_boxes']\\n else:\\n imgboxes = []\\n \\n # Use histogram matching for night vision images\\n nvg = False\\n if colour.is_night_vision(img): # night vision\\n nvg = True\\n img = preprocessing.hist_match(img, template)\\n \\n # Perform actual segmentation\\n regions, centroids, clust_bboxes = colour_segmentation(img, max_clust_size=0.10)\\n clust_bboxes = unique([clust_bbox_to_dict(clust) for clust in clust_bboxes], key=lambda cand: (cand['x'], cand['y']))\\n \\n #num_matching_boxes = sum(any(matches_centroid(bbox, centroid) for bbox in imgboxes) for centroid in centroids)\\n #num_found_fish = sum(any(matches_centroid(bbox, centroid) for centroid in centroids) for bbox in imgboxes)\\n #num_impossible_here = sum(overlap_ratio * max(bbox['width'], bbox['height']) >= bbox_size for bbox in imgboxes)\\n \\n num_compact_matching_boxes = [sum(any(containment_ratio(bbox, preprocessing.zoom_box(clust, img.shape, zoom_factor=zoom, output_dict=True)) >= min_containment_ratio for bbox in imgboxes) for clust in clust_bboxes) for zoom in zoom_levels]\\n num_compact_found_fish = [sum(any(containment_ratio(bbox, preprocessing.zoom_box(clust, img.shape, zoom_factor=zoom, output_dict=True)) >= min_containment_ratio for clust in clust_bboxes) for bbox in imgboxes) for zoom in zoom_levels]\\n num_matching_boxes = [sum(any(containment_ratio(preprocessing.zoom_box(clust, img.shape, zoom_factor=zoom, output_dict=True), bbox) >= min_overlap_ratio for bbox in imgboxes) for clust in clust_bboxes) for zoom in zoom_levels]\\n num_found_fish = [sum(any(containment_ratio(preprocessing.zoom_box(clust, img.shape, zoom_factor=zoom, output_dict=True), bbox) >= min_overlap_ratio for clust in clust_bboxes) for bbox in imgboxes) for zoom in zoom_levels]\\n \\n # Record this information\\n #tp_boxes += num_matching_boxes\\n num_boxes += len(clust_bboxes)\\n #tp_fish += num_found_fish\\n num_fish += len(imgboxes)# - num_impossible_here\\n #num_impossible += num_impossible_here\\n tp_compact_boxes = [a+b for a,b in zip(tp_compact_boxes, num_compact_matching_boxes)]\\n tp_compact_fish = [a+b for a,b in zip(tp_compact_fish, num_compact_found_fish)]\\n tp_boxes = [a+b for a,b in zip(tp_boxes,num_matching_boxes)]\\n tp_fish = [a+b for a,b in zip(tp_fish,num_found_fish)]\\n \\n if output:\\n # Output performance for this image\\n if data == 'train':\\n #print('Image %d (found %d/%d%s, %d FPs%s)' % (idx, num_found_fish, len(imgboxes)-num_impossible_here, (', %d impossible' % num_impossible_here) if num_impossible_here > 0 else '', len(centroids)-num_matching_boxes, '; NVG' if nvg else ''))\\n print('Image %d (compact: found %d/%d %d FPs none; %d/%d %d FPs 70%%; %d/%d %d FPs 50%%%s)' % (idx, num_compact_found_fish[0], len(imgboxes), len(centroids)-num_compact_matching_boxes[0], num_compact_found_fish[1], len(imgboxes), len(centroids)-num_compact_matching_boxes[1], num_compact_found_fish[2], len(imgboxes), len(centroids)-num_compact_matching_boxes[2], '; NVG' if nvg else ''))\\n print('Image %d (encompassing: found %d/%d %d FPs none; %d/%d %d FPs 70%%; %d/%d %d FPs 50%%%s)' % (idx, num_found_fish[0], len(imgboxes), len(centroids)-num_matching_boxes[0], num_found_fish[1], len(imgboxes), len(centroids)-num_matching_boxes[1], num_found_fish[2], len(imgboxes), len(centroids)-num_matching_boxes[2], '; NVG' if nvg else ''))\\n else:\\n print('Image %d (%d candidates)' % (idx, len(centroids)))\\n \\n # Summarise performance up till now\\n if idx_idx%50 == 49:\\n if data == 'train':\\n #box_precision = 100*tp_boxes / float(num_boxes) if num_boxes > 0 else -1\\n #fish_recall = 100*tp_fish / float(num_fish) if num_fish > 0 else -1\\n #print('Box precision after %d images: %g%% (%d/%d)\\\\nFish recall after %d images: %g%% (%d/%d%s)\\\\n' % (idx_idx+1, box_precision, tp_boxes, num_boxes, idx_idx+1, fish_recall, tp_fish, num_fish, (', %d impossible' % num_impossible) if num_impossible > 0 else ''))\\n \\n box_precision = [100*tp_boxes_i / float(num_boxes) if num_boxes > 0 else -1 for tp_boxes_i in tp_boxes]\\n compact_box_precision = [100*tp_boxes_i / float(num_boxes) if num_boxes > 0 else -1 for tp_boxes_i in tp_compact_boxes]\\n fish_recall = [100*tp_fish_i / float(num_fish) if num_fish > 0 else -1 for tp_fish_i in tp_fish]\\n compact_fish_recall = [100*tp_fish_i / float(num_fish) if num_fish > 0 else -1 for tp_fish_i in tp_compact_fish]\\n \\n print('Box compact-match precision after %d images: %g%% (%d/%d) none; %g%% (%d/%d) 70%%; %g%% (%d/%d) 50%%\\\\nFish compact-match recall after %d images: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom' % (idx_idx+1, compact_box_precision[0], tp_compact_boxes[0], num_boxes, compact_box_precision[1], tp_compact_boxes[1], num_boxes, compact_box_precision[2], tp_compact_boxes[2], num_boxes, idx_idx+1, compact_fish_recall[0], tp_compact_fish[0], num_fish, compact_fish_recall[1], tp_compact_fish[1], num_fish, compact_fish_recall[2], tp_compact_fish[2], num_fish))\\n print('Box encompassing-match precision after %d images: %g%% (%d/%d) none; %g%% (%d/%d) 70%%; %g%% (%d/%d) 50%%\\\\nFish encompassing-match recall after %d images: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom\\\\n' % (idx_idx+1, box_precision[0], tp_boxes[0], num_boxes, box_precision[1], tp_boxes[1], num_boxes, box_precision[2], tp_boxes[2], num_boxes, idx_idx+1, fish_recall[0], tp_fish[0], num_fish, fish_recall[1], tp_fish[1], num_fish, fish_recall[2], tp_fish[2], num_fish))\\n else:\\n print('%d images segmented (%d candidates in total)' % (idx_idx+1, num_boxes))\\n \\n if save_candidates:\\n img_json_obj = {'filename': data_meta[idx]['filename']}\\n #img_json_obj['candidates'] = unique([{'x': lower(centroid, 1), 'y': lower(centroid, 0), 'width': bbox_size, 'height': bbox_size} for centroid in centroids], key=lambda cand: (cand['x'], cand['y']))\\n img_json_obj['candidates'] = clust_bboxes\\n if data == 'train':\\n out_train_json_objs[data_meta[idx]['class']].append(img_json_obj)\\n else:\\n out_json_obj.append(img_json_obj)\\n \\n \\n if output:\\n # Summarise total performance\\n if data == 'train':\\n #box_precision = 100*tp_boxes / float(num_boxes) if num_boxes > 0 else -1\\n #fish_recall = 100*tp_fish / float(num_fish) if num_fish > 0 else -1\\n #print('\\\\n%d images completed!\\\\nTotal box precision: %g%% (%d/%d)\\\\nTotal fish recall: %g%% (%d/%d%s)\\\\n' % (len(img_idxs), box_precision, tp_boxes, num_boxes, fish_recall, tp_fish, num_fish, (', %d impossible' % num_impossible) if num_impossible > 0 else ''))\\n \\n box_precision = [100*tp_boxes_i / float(num_boxes) if num_boxes > 0 else -1 for tp_boxes_i in tp_boxes]\\n compact_box_precision = [100*tp_boxes_i / float(num_boxes) if num_boxes > 0 else -1 for tp_boxes_i in tp_compact_boxes]\\n fish_recall = [100*tp_fish_i / float(num_fish) if num_fish > 0 else -1 for tp_fish_i in tp_fish]\\n compact_fish_recall = [100*tp_fish_i / float(num_fish) if num_fish > 0 else -1 for tp_fish_i in tp_compact_fish]\\n \\n print('\\\\n%d images completed!\\\\nTotal compact box precision: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom\\\\nTotal compact fish recall: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom' % (idx_idx+1, compact_box_precision[0], tp_compact_boxes[0], num_boxes, compact_box_precision[1], tp_compact_boxes[1], num_boxes, compact_box_precision[2], tp_compact_boxes[2], num_boxes, compact_fish_recall[0], tp_compact_fish[0], num_fish, compact_fish_recall[1], tp_compact_fish[1], num_fish, compact_fish_recall[2], tp_compact_fish[2], num_fish))\\n print('Total encompassing box precision: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom\\\\nTotal encompassing fish recall: %g%% (%d/%d) no zoom; %g%% (%d/%d) 70%% zoom; %g%% (%d/%d) 50%% zoom\\\\n' % (box_precision[0], tp_boxes[0], num_boxes, box_precision[1], tp_boxes[1], num_boxes, box_precision[2], tp_boxes[2], num_boxes, fish_recall[0], tp_fish[0], num_fish, fish_recall[1], tp_fish[1], num_fish, fish_recall[2], tp_fish[2], num_fish))\\n else:\\n print('%d images segmented (%d candidates in total)' % (idx_idx+1, num_boxes))\\n\\n if save_candidates:\\n outdir = settings.SEGMENTATION_CANDIDATES_OUTPUT_DIR\\n os.makedirs(outdir)\\n filename = 'candidates%s.json' % ('' if img_idxs is None else ('_%d-%d' % (min(img_idxs), max(img_idxs))))\\n if data == 'train':\\n for cls in classlist:\\n with open(os.path.join(outdir, cls + '_' + filename), 'w') as outfile:\\n json.dump(out_train_json_objs[cls], outfile)\\n else:\\n with open(os.path.join(outdir, filename), 'w') as outfile:\\n json.dump(out_json_obj, outfile)\",\n \"def run_evaluation(self, n_runs=1, n_points=1000, n_iterations=1, min_n_components=2, max_n_components=25,\\n\\t\\t\\t\\t\\t n_splits=3, save_data=False, file_label='',n_microstates=None, all_methods=True,\\n\\t\\t\\t\\t\\t assign_transition_points=True):\\n\\n\\t\\tif self.presampled_data is not None:\\n\\t\\t\\tsampled_data = self.presampled_data[0]\\n\\t\\t\\ttrue_clustering = self.presampled_data[1]\\n\\t\\t\\tn_runs = sampled_data.shape[0]\\n\\n\\t\\tself.cluster_score_ami_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tself.cluster_score_fm_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tself.cluster_score_vm_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tdata = self.toy_model_.sample(3)\\n\\n\\t\\t# Create free energy estimators\\n\\t\\tgmm_FE = GMM_FE.FreeEnergyClustering(data, min_n_components=min_n_components, max_n_components=max_n_components,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t x_lims=self.x_lims_, n_grids=self.n_grids_, stack_landscapes=False,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t n_splits=n_splits, n_iterations=n_iterations,convergence_tol=self.convergence_tol_,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t verbose=self.verbose_)\\n\\n\\t\\tkm = kmc.KMeansCluster(min_n_components, max_n_components)\\n\\t\\taw = awc.AWCluster(min_n_components, max_n_components)\\n\\t\\tspectral = sc.SpectralCluster(min_n_components, max_n_components)\\n\\n\\t\\tall_data = []\\n\\t\\tfor i_run in range(n_runs):\\n\\t\\t\\tprint(\\\"Run: \\\"+str(i_run+1)+'/'+str(n_runs))\\n\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\t# Sample data\\n\\t\\t\\t\\tdata = self.toy_model_.sample(n_points)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdata = sampled_data[i_run]\\n\\t\\t\\t\\n\\t\\t\\tall_data.append(data)\\n\\n\\t\\t\\tprint('Shape data: ' + str(data.shape))\\n\\n\\t\\t\\t# Set data in model and estimate GMM density\\n\\t\\t\\tgmm_FE.data_ = data\\n\\t\\t\\tcoords, est_FE_landsc, FE_points = gmm_FE.landscape()\\n\\n\\t\\t\\t# Get true cluster labels\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\tif hasattr(self.toy_model_, \\\"assign_cluster_labels\\\"):\\n\\t\\t\\t\\t\\tself.true_labels_ = self.toy_model_.assign_cluster_labels(data)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tprint('Setting true labels.')\\n\\t\\t\\t\\t\\tself.true_labels_, _ = self.true_FE_.cluster(data, np.zeros(data.shape[0]))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.true_labels_ = true_clustering[i_run]\\n\\t\\t\\t\\n\\t\\t\\t# Cluster data with different methods\\n\\t\\t\\tif n_microstates is None:\\n\\t\\t\\t\\tself.FE_min_labels, _ = gmm_FE.cluster(data, FE_points, assign_transition_points=assign_transition_points)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tkmea = KMeans(n_clusters=n_microstates).fit(data[::2])\\n\\t\\t\\t\\tmicrostate_centers = kmea.cluster_centers_\\n\\t\\t\\t\\tself.FE_min_labels, _ = gmm_FE.cluster(microstate_centers, FE_points, data, assign_transition_points=assign_transition_points, unravel_grid=False)\\n\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tself.km_labels = km.cluster(data)\\n\\t\\t\\t\\tself.aw_labels = aw.cluster(data)\\n\\t\\t\\t\\tself.spectral_labels = spectral.cluster(data)\\n\\n\\t\\t\\t# Score clustering using different scoring metrics\\n\\t\\t\\t# V-measure score\\n\\t\\t\\tself.cluster_score_vm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'vm')\\n\\t\\t\\tprint(self.cluster_score_vm_GMM_FE_min_[i_run])\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tself.cluster_score_vm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_kmeans_[i_run] = self._score_clustering(self.km_labels,'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_AW_[i_run] = self._score_clustering(self.aw_labels,'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'vm')\\n\\n\\t\\t\\t\\t# Adjusted MI\\n\\t\\t\\t\\tself.cluster_score_ami_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_kmeans_[i_run] = self._score_clustering(self.km_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_AW_[i_run] = self._score_clustering(self.aw_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_spectral_[i_run] = self._score_clustering(self.spectral_labels,'ami')\\n\\n\\t\\t\\t\\t# Fowlkes Mallows\\n\\t\\t\\t\\tself.cluster_score_fm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_kmeans_[i_run] = self._score_clustering(self.km_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_AW_[i_run] = self._score_clustering(self.aw_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'fm')\\n\\t\\t\\n\\t\\tif save_data:\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\tnp.save('data_out/sampled_data_'+self.toy_model_.name+file_label+'.npy',all_data)\\n\\n\\t\\t\\tif False:\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_fm_GMM_FE_min_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_kmeans_' + self.toy_model_.name +file_label +'.npy', self.cluster_score_fm_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_spectral_)\\n\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_ami_GMM_FE_min_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_spectral_)\\n\\n\\t\\t\\tnp.save('data_out/cluster_score_vm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_vm_GMM_FE_min_)\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_spectral_)\\n\\t\\treturn\",\n \"def predict(self):\\n for track in self.tracks:\\n track.predict(self.kf)\\n #track.du_doan(self.kf_test)\",\n \"def train_real():\\n real_clusters, ei = create_clusters()\\n real_data, labels, step_nb = create_cheat_comparison_with_cluster(\\n real_clusters, ei)\\n X = np.array(real_data)\\n Y = np.array(labels)\\n\\n model = Sequential()\\n model.add(LSTM(units=128, input_shape=(2, 50)))\\n model.add(Dropout(0.5))\\n model.add(Dense(1, activation=\\\"sigmoid\\\"))\\n\\n my_callbacks = [EarlyStopping(monitor='auc_roc', patience=300, verbose=1, mode='max'),\\n TensorBoard(log_dir=\\\"logs/{}\\\".format(time()))]\\n\\n model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=[\\n 'accuracy', auc_roc, f1_score_threshold(), precision_threshold(), recall_threshold()])\\n model.fit(\\n X,\\n Y,\\n batch_size=100,\\n epochs=30,\\n validation_split=0.4,\\n callbacks=my_callbacks,\\n shuffle=True\\n )\\n\\n # Use this to save the weights to be able to reload them while testing\\n model.save_weights(WEIGHTS_DIR+'/my_real_model_clusters_weights.h5')\",\n \"def cluster_assign(images_lists, dataset):\\n assert images_lists is not None\\n pseudolabels = []\\n image_indexes = []\\n for cluster, images in enumerate(images_lists):\\n image_indexes.extend(images)\\n pseudolabels.extend([cluster] * len(images))\\n print(image_indexes)\\n print(pseudolabels)\\n \\n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\\n std=[0.229, 0.224, 0.225])\\n t = transforms.Compose([transforms.RandomResizedCrop(224),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n normalize])\\n\\n return ReassignedDataset(image_indexes, pseudolabels, dataset, t)\",\n \"def train():\\n pass\",\n \"def predict(self, data):\\n\\t\\treturn closestCluster(data, self.centers)\",\n \"def main(feats_name, targets_name, model_name, n_boot, seed_start, output_filename, train_test_flag):\\n\\n #load feats and targets\\n input_dict = {}\\n input_dict['feats'] = 'data/%s' % (feats_name)\\n input_dict['targets'] = 'data/%s' % (targets_name)\\n #load the feats and targets\\n df = pd.read_csv(\\\"%s\\\" % (input_dict['feats']))\\n targets = pd.read_csv(\\\"%s\\\" % (input_dict['targets']))\\n #drop columns not used for prediction\\n drop_cols = [\\\"Unnamed: 0\\\",\\\"index\\\"]\\n for dc in drop_cols:\\n if dc in targets.columns:\\n targets = targets.drop(dc,axis=1)\\n if dc in df.columns:\\n df = df.drop(dc,axis=1)\\n #reduce to training or test set only if requested\\n if (train_test_flag == 'train') and ('test_set' in df.columns):\\n targets = targets[df['test_set'] == 0]\\n df = df[df['test_set'] == 0]\\n elif (train_test_flag == 'test') and ('test_set' in df.columns):\\n targets = targets[df['test_set'] == 1]\\n df = df[df['test_set'] == 1]\\n df = df.drop('test_set', axis = 1)\\n \\n #broadcast the feats and targets\\n df_b = sc.broadcast(df)\\n targets_b = sc.broadcast(targets)\\n\\n #Set up the classifier. 3fold CV for selection of regularization term.\\n if model_name == 'linear':\\n model = LinearRegression(fit_intercept=True,\\n normalize=False,\\n copy_X=True,\\n n_jobs=1) \\n elif model_name == 'lasso':\\n model = LassoCV(alphas = [.05,.1,.2],\\n normalize = False,\\n fit_intercept = True,\\n verbose = False,\\n copy_X = False,\\n n_jobs = 3)\\n elif model_name == 'ridge':\\n model = RidgeCV(alphas = [.00001,.0001,.001,.01,.1,1,10,100,1000,10000],\\n normalize = False,\\n fit_intercept = True,\\n verbose = 1,\\n cv = 3)\\n else:\\n raise ValueError('model_name not recognized.')\\n \\n #Create an RDD that specifies prng seed to use\\n samp_list = [(n,) for n in np.arange(seed_start, seed_start+n_boot)]\\n samp_rdd = sc.parallelize(samp_list,n_boot) #create RDD with one partition for each row (second arg is number of partitions)\\n #Create a function that takes a tuple as input and returns \\n def func(tup):\\n \\\"\\\"\\\"\\n Takes as input a tuple containing an integer. The integer specifies the random seed that will be used to \\n randomly sample, with replacement, observations from the feats set provided. The model is fitted to the \\n sampled feats. Resulting best fit parameters, along with some other summary statistics and information are\\n provided as input in a JSON string that will be written to the output file when all jobs are completed.\\n \\n Parameters\\n ----------\\n tup, rdd\\n - series of tuples with different integer values defining the RNG seed to be used to sample observations\\n \\n Returns\\n ----------\\n tup[0], int\\n - the seed that was used\\n json.dumps(results_dict), str\\n - dict in json format with the following keys:\\n - alpha, the regularization term providing the best fit according to 3 fold cross-validation\\n - random_state, the initial state used for fitting\\n - training_feats, the name of the training_feats csv file\\n - training_targets, the name of the target variable csv file\\n - cv, the type of cross-validation used\\n - sklearn_version, which version of sklearn was used\\n - mse_min, the mean squared error for the test set on each fold\\n - r2, the r-squared value (% var explained)\\n - coef, parameter vector\\n - intercept, intercept parameter\\n - column_names, feature name corresponding to each parameter in the parameter vector\\n \\\"\\\"\\\"\\n #take a random sample with replacement\\n np.random.seed(seed=tup[0]) #set the seed\\n n_obs = np.shape(df_b.value)[0] #number of observations determines sample size\\n samp = list(np.random.randint(0,high=n_obs,size=n_obs)) #draw the random sample with replacement\\n #fit the model\\n tic = time.time()\\n results = model.fit(df_b.value.iloc[samp,:],np.ravel(targets_b.value.iloc[samp]))\\n toc = tic - time.time()\\n #save the results in a dict\\n results_dict = {}\\n results_dict['alpha'] = results.alpha_\\n results_dict['random_state'] = results.random_state\\n results_dict['training_feats'] = input_dict['feats']\\n results_dict['training_targets'] = input_dict['targets']\\n results_dict['cv'] = results.cv\\n results_dict['sklearn_version'] = sklearn.__version__\\n results_dict['mse_min'] = results.mse_path_.min()\\n results_dict['r2'] = results.score(df_b.value.iloc[samp,:],np.ravel(targets_b.value.iloc[samp]))\\n results_dict['coef'] = list(results.coef_)\\n results_dict['intercept'] = results.intercept_\\n results_dict['column_names'] = [i for i in df_b.value.columns]\\n results_dict['fit_time'] = toc\\n #convert results dict to json and save in tuple\\n return(json.dumps(results_dict))\\n\\n #fit model in parallel\\n results = samp_rdd.map(lambda p: func(p))\\n #save to text file\\n results.saveAsTextFile(output_filename)\\n #stop the SparkContext.\\n if not local_mode:\\n sc.stop()\",\n \"def train(self):\\n\\t\\traise NotImplementedError\",\n \"def load_data():\\n data = gzip.open(\\\"mnist.pkl.gz\\\", \\\"rb\\\")\\n train_set, valid_set, test_set = cPickle.load(data)\\n data.close()\\n\\n # Combine validation and train folds to recreate the master 60k set.\\n new_images = numpy.concatenate((train_set[0], valid_set[0]))\\n new_labels = numpy.concatenate((train_set[1], valid_set[1]))\\n\\n train_set = (new_images, new_labels)\\n \\n return (train_set, test_set)\",\n \"def _automatic_training_set(self, n_cutouts=100):\\n dstl = Load_DSTL()\\n np.random.seed(42)\\n for ii in range(n_cutouts):\\n # Get region around a shape\\n triples, mask, ind_shape, img_dim = dstl.extract_region(object_class=self.class_type, image_id='6120_2_2', buffer_size=10)\\n if self.radius is not None:\\n triples, mask = self._sliding_window(triples.reshape(*img_dim, 3), mask.reshape(img_dim), window_radius=self.radius)\\n # Add to Feature Matrix\\n if ii == 0:\\n features = triples\\n labels = mask\\n else:\\n features = np.vstack([features, triples])\\n labels = np.hstack([labels, mask])\\n return features, labels\",\n \"def main():\\n\\n logger.info('Process initiated - Building dataset')\\n\\n if os.path.isfile(train_path) and os.path.isfile(test_path):\\n logger.info('Loading pickled data')\\n return pd.read_pickle(train_path), pd.read_pickle(test_path)\\n\\n logger.info('Reading COSMIC Cancer Gene Census')\\n gene_census = cancer_gene_census()\\n gene_census.extend(civic_cancer_genes())\\n\\n gene_census = set(gene_census)\\n\\n training_data = pd.DataFrame()\\n testing_data = pd.DataFrame()\\n\\n for cancer_type in cancer_types:\\n data_file_name = cancer_type + \\\".meth.by_mean.data.txt\\\"\\n data_file_location = os.path.join(data_location, data_file_name)\\n\\n logger.info('Reading Methylation data for {}'.format(cancer_type))\\n\\n methyl_data = pd.read_csv(data_file_location, delimiter='\\\\t', skiprows=[1], index_col=0)\\n\\n logger.info(\\n 'Number of Genes: {0} | Number of Patients: {1}'.format(methyl_data.shape[0], methyl_data.shape[1]))\\n logger.info('Preprocessing Methylation data')\\n\\n methyl_data = genes_feature_selection(methyl_data, gene_census)\\n\\n logger.info('Number of Genes after processing: {0}\\\\n'.format(methyl_data.shape[0]))\\n\\n methyl_data = add_classification_label(methyl_data)\\n methyl_data = methyl_data.transpose()\\n\\n normal_cases = methyl_data[methyl_data['Tumor'] == 0]\\n logger.info(normal_cases.shape)\\n train_normal_cases = normal_cases.sample(frac=0.7, random_state=200)\\n logger.info(train_normal_cases.shape)\\n test_normal_cases = normal_cases.drop(train_normal_cases.index)\\n logger.info(train_normal_cases.shape)\\n\\n tumor_cases = methyl_data[methyl_data['Tumor'] != 0]\\n logger.info(tumor_cases.shape)\\n train_tumor_cases = tumor_cases.sample(frac=0.7, random_state=200)\\n logger.info(train_tumor_cases.shape)\\n\\n test_tumor_cases = tumor_cases.drop(train_tumor_cases.index)\\n logger.info(test_tumor_cases.shape)\\n\\n training_data = training_data.append(train_normal_cases)\\n training_data = training_data.append(train_tumor_cases)\\n\\n testing_data = testing_data.append(test_normal_cases)\\n testing_data = testing_data.append(test_tumor_cases)\\n\\n training_data = training_data.sample(frac=1)\\n testing_data = testing_data.sample(frac=1)\\n\\n logger.info('Pickling training and testing data')\\n training_data.to_pickle(train_path)\\n testing_data.to_pickle(test_path)\\n\\n logger.info('Processing completed!')\\n visualize_data(training_data)\\n\\n return training_data, testing_data\",\n \"def create_tf_datasets(self):\\n images = []\\n labels = []\\n\\n images = self.dataframe_labeled_samples.index.values\\n\\n labels.append(\\n tuple(self.dataframe_labeled_samples['Intersection'].values.astype('uint8')))\\n\\n images = [\\n os.path.join(\\n os.path.dirname(\\n self.summary_manager.current_labelgui_summary_filepath),\\n img_name) for img_name in images]\\n labels = list(chain.from_iterable(labels))\\n\\n\\n if self.validation_split == 0:\\n images = np.array([\\n self.image_preprocessor(\\n imageio.imread(f)) for f in tqdm(images)])\\n images = tf.data.Dataset.from_tensor_slices(images)\\n labels = tf.data.Dataset.from_tensor_slices(labels)\\n dataset = tf.data.Dataset.zip((images, labels))\\n return dataset, None\\n\\n images, images_val, labels, labels_val = train_test_split(\\n images, labels, test_size=self.validation_split, random_state=0)\\n\\n train_split_filename = ((\\n f'{self.save_checkpoint_filepath or self.checkpoint_filepath}'\\n f'_train_split.txt'\\n ))\\n print(f\\\"Saving train split files to: {train_split_filename}\\\")\\n with open(train_split_filename, 'w+')\\\\\\n as train_split_file:\\n for img in images:\\n train_split_file.write(img + '\\\\n')\\n \\n val_split_filename = ((\\n f'{self.save_checkpoint_filepath or self.checkpoint_filepath}'\\n f'_val_split.txt'\\n ))\\n print(f\\\"Saving train split files to: {val_split_filename}\\\")\\n with open(val_split_filename, 'w+')\\\\\\n as val_split_file:\\n for img in images_val:\\n val_split_file.write(img + '\\\\n')\\n\\n print(f\\\"Loading validation image paths ({len(images)}) with preprocessor\\\")\\n images = np.array([\\n self.image_preprocessor(\\n imageio.imread(f)) for f in tqdm(images)])\\n images = tf.data.Dataset.from_tensor_slices(images)\\n\\n print(f\\\"Loading labels into tf tensor\\\")\\n labels = tf.data.Dataset.from_tensor_slices(labels)\\n print(f\\\"Creating zipped dataset with images and labels\\\")\\n dataset = tf.data.Dataset.zip((images, labels))\\n\\n print(f\\\"Loading validation image paths ({len(images_val)}) with preprocessor\\\")\\n images_val = np.array([\\n self.image_preprocessor(\\n imageio.imread(f)) for f in tqdm(images_val)])\\n #images_val = np.array([self.image_preprocessor(f) for f in tqdm(images_val)])\\n images_val = tf.data.Dataset.from_tensor_slices(images_val)\\n #images_val = tf.data.Dataset.list_files(images_val)\\n #images_val = images_val.map(tf.io.read_file)\\n print(f\\\"Loading validation labels into tf tensor\\\")\\n labels_val = tf.data.Dataset.from_tensor_slices(labels_val)\\n print(f\\\"Creating validation zipped dataset with images and labels\\\")\\n dataset_val = tf.data.Dataset.zip((images_val, labels_val))\\n\\n return dataset, dataset_val\",\n \"def main_predefined_split():\\n\\n average_performance = []\\n fold_num = 'predefined'\\n output_file_folder = \\\"output/{}\\\".format(args.experiment_name)\\n output_file_name = \\\"{}/lnnel_{}.csv\\\".format(output_file_folder, fold_num)\\n Path(output_file_folder).mkdir(parents=True, exist_ok=True)\\n args.output_file_name = output_file_name\\n\\n if args.use_blink:\\n df_train = pd.read_csv(\\\"./data/lcquad/blink/lcquad_train_sorted.csv\\\")\\n df_test = pd.read_csv(\\\"./data/lcquad/blink/lcquad_test_sorted.csv\\\")\\n else:\\n df_train = pd.read_csv(\\\"./data/lcquad/dbpedia/lcquad_train_sorted.csv\\\")\\n df_test = pd.read_csv(\\\"./data/lcquad/dbpedia/lcquad_test_sorted.csv\\\")\\n\\n # filter out the questions with single positive or many negatives in trianing set\\n filtered_question_mentions = []\\n for qm in df_train.QuestionMention.unique():\\n df_ = df_train[df_train.QuestionMention == qm]\\n if df_.Label.sum() == 0:\\n filtered_question_mentions.append(qm)\\n if df_.Label.sum() == 1 and df_.shape[0] == 1:\\n filtered_question_mentions.append(qm)\\n # print(df_.Label.values)\\n df_train_split_filtered = df_train[~df_train.QuestionMention.isin(filtered_question_mentions)]\\n df_train_split_filtered = df_train_split_filtered.sort_values(by=['QuestionMention', 'Label'])\\n df_train = df_train_split_filtered\\n\\n # train\\n features_train = np.array(\\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_train.Features.values])\\n x_train = torch.from_numpy(features_train).float()\\n y_train = torch.from_numpy(df_train.Label.values).float().reshape(-1, 1)\\n m_labels_train = df_train.Mention_label.values\\n ques_train = df_train.Question.values\\n\\n # test\\n features_test = np.array(\\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_test.Features.values])\\n x_test = torch.from_numpy(features_test).float()\\n y_test = torch.from_numpy(df_test.Label.values).float().reshape(-1, 1)\\n m_labels_test = df_test.Mention_label.values\\n ques_test = df_test.Question.values\\n\\n # train model and evaluate\\n model = pick_model(args.model_name, args.alpha)\\n model = model.to(device)\\n\\n # move to gpu\\n x_train, y_train = x_train.to(device), y_train.to(device)\\n x_test, y_test = x_test.to(device), y_test.to(device)\\n\\n print(model)\\n\\n print(\\\"model: \\\", args.model_name, args.alpha)\\n print(model(x_train, m_labels_train))\\n\\n print(\\\"y_train sum\\\", sum(y_train), sum(y_train) / len(y_train))\\n print(\\\"y_test sum\\\", sum(y_test), sum(y_test) / len(y_test))\\n\\n # aggregate the data into train, val, and test\\n train_data = (x_train, y_train, m_labels_train, ques_train)\\n print(\\\"train:\\\", x_train.shape, y_train.shape, m_labels_train.shape, ques_train.shape)\\n test_data = (x_test, y_test, m_labels_test, ques_test)\\n print(\\\"test:\\\", x_test.shape, y_test.shape, m_labels_test.shape, ques_test.shape)\\n\\n # check class distribution\\n print(\\\"y_train sum\\\", sum(y_train), sum(y_train) / len(y_train))\\n print(\\\"y_test sum\\\", sum(y_test), sum(y_test) / len(y_test))\\n\\n train(model, train_data, test_data, test_data, args.checkpoint_name, args.num_epoch, args.margin,\\n args.learning_rate)\\n test_pred, best_scores = test(x_test, m_labels_test, ques_test, args.alpha, args.checkpoint_name,\\n args.model_name,\\n args.output_file_name)\\n with open(args.log_file_name, 'a') as f:\\n f.write(\\n \\\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}; lr={}; margin={}\\\\n\\\".format(\\n args.model_name,\\n args.use_fixed_threshold,\\n args.alpha,\\n best_scores[\\n 'precision'],\\n best_scores[\\n 'recall'],\\n best_scores['f1'],\\n args.learning_rate,\\n args.margin))\\n print(\\\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}\\\\n\\\".format(args.model_name,\\n args.use_fixed_threshold,\\n args.alpha,\\n best_scores['precision'],\\n best_scores['recall'],\\n best_scores['f1']))\\n average_performance.append([best_scores['precision'], best_scores['recall'], best_scores['f1']])\\n\\n average_performance = np.array(average_performance)\\n print(\\\"Avg performance is prec - rec - f1: \\\", average_performance.mean(0))\",\n \"def get_train(self, even=None):\\n\\n #self.images, self.labels, self.traces = trace_data.get_my_teacher()\\n _, self.images, self.labels, self.traces, _ = trace_data.get_my_teacher()\\n #print(self.labels)\\n self.length = len(self.images)\\n self.create_teacher()\",\n \"def setUp(self):\\n\\n # Load the data\\n dataset = tagging.data.DataSet.from_fits(DATA_PATH, extension=1)\\n\\n # Assign all as field.\\n dataset.data[\\\"FIELD/CLUSTER\\\"] = \\\"FIELD\\\"\\n\\n # [TODO] Delete benchmarks\\n clusters = (\\\"Cha_I\\\", \\\"Br81\\\", \\\"M15\\\", \\\"NGC2808\\\", \\\"NGC6633\\\", \\\"IC4665\\\", \\n \\\"NGC104\\\", \\\"gamma2_Vel\\\", \\\"GJ880\\\", \\\"NGC4815\\\", \\\"NGC2547\\\", \\\"NGC5927\\\",\\n \\\"NGC4833\\\", \\\"NGC1851\\\", \\\"NGC2243\\\", \\\"NGC3532\\\", \\\"NGC6752\\\", \\\"Br25\\\", \\n \\\"NGC4372\\\", \\\"NGC6705\\\", \\\"M67\\\", \\\"NGC2516\\\", \\\"Trumpler20\\\")\\n\\n # Assign all as members.\\n for cluster in clusters:\\n members = dataset.assign_cluster_members(cluster,\\n lambda row: row[\\\"TARGET\\\"].startswith(cluster))\\n\\n # Special hack:\\n if cluster == \\\"Trumpler20\\\":\\n members += dataset.assign_cluster_members(cluster,\\n lambda row: row[\\\"TARGET\\\"].startswith(\\\"Trumpler_20\\\"))\\n\\n logger.info(\\\"Assigned stars to {} clusters\\\".format(len(clusters)))\\n self.dataset = dataset\\n return None\",\n \"def init_loaders_predict(self, data_dict, label_dict):\\n return self.init_loaders(data_dict, label_dict)\",\n \"def setUp(self):\\n self.batch_size = 8\\n num_keypoints = 15\\n self.data_batch = []\\n self.data_samples = []\\n\\n for i in range(self.batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n\\n self.data_batch.append(data)\\n self.data_samples.append(data_sample)\",\n \"def setUp(self):\\n self.batch_size = 8\\n num_keypoints = 15\\n self.data_batch = []\\n self.data_samples = []\\n\\n for i in range(self.batch_size):\\n gt_instances = InstanceData()\\n keypoints = np.zeros((1, num_keypoints, 2))\\n keypoints[0, i] = [0.5 * i, 0.5 * i]\\n gt_instances.keypoints = keypoints\\n gt_instances.keypoints_visible = np.ones(\\n (1, num_keypoints, 1)).astype(bool)\\n gt_instances.keypoints_visible[0, (2 * i) % 8, 0] = False\\n gt_instances.bboxes = np.random.random((1, 4)) * 20 * i\\n gt_instances.head_size = np.random.random((1, 1)) * 10 * i\\n\\n pred_instances = InstanceData()\\n pred_instances.keypoints = keypoints\\n\\n data = {'inputs': None}\\n data_sample = {\\n 'gt_instances': gt_instances.to_dict(),\\n 'pred_instances': pred_instances.to_dict(),\\n }\\n\\n self.data_batch.append(data)\\n self.data_samples.append(data_sample)\",\n \"def main():\\n # Read in trainingSet and testSet as a DataFrame\\n trainingOriginal = pd.read_csv(\\n filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.train.5fold.csv\\\")\\n testOriginal = pd.read_csv(filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.test.csv\\\")\\n\\n # Select only the numeric data\\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\\n training = pd.concat([training.reset_index(drop=True),\\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Select only the numeric data\\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\\n test = pd.concat([test.reset_index(drop=True),\\n testOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Normalize the columns for training and test\\n # print training['age'].min()\\n # print training['age'].max()\\n # print training.head()\\n\\n # Run max-min normalization on numerical columns for testing and training data\\n for i in range(6):\\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\\n\\n # Convert the 'earns' column to boolean as follows\\n training['earns'] = training['earns'] == '>50K'\\n test['earns'] = test['earns'] == ' >50K'\\n\\n # Group the training set by the fold attribute as given by the dataset\\n trainingForFinal = training\\n training = training.groupby('fold')\\n\\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\\n kList = []\\n for i in range(40):\\n if i % 2 == 1:\\n kList.append(i)\\n\\n # Empty dictionary to hold performance of each k-values and its accuracy\\n performance = {}\\n\\n # Compute the performance for each k-value\\n for k in kList:\\n performance = crossValidation(training, k, performance)\\n\\n # Sort the performance dictionary by its accuracy (value)\\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\\n\\n # Open file to write results\\n file = open('grid.results.txt', 'w')\\n # Write the results to file\\n file.write(\\\"K | Accuracy\\\\n\\\")\\n for item in performance:\\n if item[0] < 10:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n else:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n # Close file\\n file.close()\\n\\n # The best K is the one at the top of the list after the sorting\\n bestK = performance[0][0]\\n\\n print 'Running Test Set with K = ' + str(bestK)\\n\\n applyModel(test,trainingForFinal,bestK)\",\n \"def init_centroids(self, data_points):\\n # print(\\\"Init centroid\\\")\\n # return list(map(lambda x: x[1], random.sample(labelled_data, self.k)))\\n\\n # Project the data: this step will take several seconds\\n\\n centroids_scaled = self.naive_sharding(data_points, self.k)\\n return list(centroids_scaled)\\n\\n #sample = np.random.permutation(len(labelled_data))[:self.k]\\n\\n #return list(map(lambda x: labelled_data[x][1], sample))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65929526","0.61541826","0.6041843","0.59890664","0.5949455","0.5890738","0.58586735","0.5857667","0.5801546","0.57741946","0.5761678","0.5756762","0.575235","0.57209086","0.57159173","0.569669","0.5683529","0.5674185","0.5626972","0.5618207","0.56169873","0.56118625","0.5592201","0.5589964","0.5589361","0.558534","0.5569634","0.5568028","0.5548054","0.5541952","0.5516214","0.55159277","0.5510281","0.550921","0.55066854","0.55035305","0.549913","0.54978865","0.54961246","0.5488328","0.5483323","0.54656976","0.54654366","0.54606366","0.54536724","0.54496336","0.5441901","0.5441901","0.5441901","0.5441901","0.5441901","0.5439478","0.54379964","0.5433699","0.5432541","0.54303616","0.54240793","0.54207844","0.5418939","0.5418871","0.5410895","0.54042846","0.5403844","0.54019517","0.5400222","0.53983426","0.5391658","0.5383353","0.5376376","0.5376296","0.53727615","0.53596276","0.535611","0.535239","0.53487307","0.53471726","0.5342961","0.53397614","0.53394026","0.5336673","0.5333061","0.5332103","0.5327847","0.5325813","0.53239506","0.5318854","0.5318326","0.5317298","0.5316856","0.5316499","0.5312918","0.53128964","0.53128165","0.53127104","0.53119713","0.5311105","0.5310726","0.5309428","0.5309428","0.5309201","0.5308119"],"string":"[\n \"0.65929526\",\n \"0.61541826\",\n \"0.6041843\",\n \"0.59890664\",\n \"0.5949455\",\n \"0.5890738\",\n \"0.58586735\",\n \"0.5857667\",\n \"0.5801546\",\n \"0.57741946\",\n \"0.5761678\",\n \"0.5756762\",\n \"0.575235\",\n \"0.57209086\",\n \"0.57159173\",\n \"0.569669\",\n \"0.5683529\",\n \"0.5674185\",\n \"0.5626972\",\n \"0.5618207\",\n \"0.56169873\",\n \"0.56118625\",\n \"0.5592201\",\n \"0.5589964\",\n \"0.5589361\",\n \"0.558534\",\n \"0.5569634\",\n \"0.5568028\",\n \"0.5548054\",\n \"0.5541952\",\n \"0.5516214\",\n \"0.55159277\",\n \"0.5510281\",\n \"0.550921\",\n \"0.55066854\",\n \"0.55035305\",\n \"0.549913\",\n \"0.54978865\",\n \"0.54961246\",\n \"0.5488328\",\n \"0.5483323\",\n \"0.54656976\",\n \"0.54654366\",\n \"0.54606366\",\n \"0.54536724\",\n \"0.54496336\",\n \"0.5441901\",\n \"0.5441901\",\n \"0.5441901\",\n \"0.5441901\",\n \"0.5441901\",\n \"0.5439478\",\n \"0.54379964\",\n \"0.5433699\",\n \"0.5432541\",\n \"0.54303616\",\n \"0.54240793\",\n \"0.54207844\",\n \"0.5418939\",\n \"0.5418871\",\n \"0.5410895\",\n \"0.54042846\",\n \"0.5403844\",\n \"0.54019517\",\n \"0.5400222\",\n \"0.53983426\",\n \"0.5391658\",\n \"0.5383353\",\n \"0.5376376\",\n \"0.5376296\",\n \"0.53727615\",\n \"0.53596276\",\n \"0.535611\",\n \"0.535239\",\n \"0.53487307\",\n \"0.53471726\",\n \"0.5342961\",\n \"0.53397614\",\n \"0.53394026\",\n \"0.5336673\",\n \"0.5333061\",\n \"0.5332103\",\n \"0.5327847\",\n \"0.5325813\",\n \"0.53239506\",\n \"0.5318854\",\n \"0.5318326\",\n \"0.5317298\",\n \"0.5316856\",\n \"0.5316499\",\n \"0.5312918\",\n \"0.53128964\",\n \"0.53128165\",\n \"0.53127104\",\n \"0.53119713\",\n \"0.5311105\",\n \"0.5310726\",\n \"0.5309428\",\n \"0.5309428\",\n \"0.5309201\",\n \"0.5308119\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":19494,"cells":{"query":{"kind":"string","value":"Returns dataframe with mean profit per cluster basing on a df given as an argument"},"document":{"kind":"string","value":"def get_profit_per_cluster(df: pd.core.frame.DataFrame) -> pd.core.frame.DataFrame:\n return pd.DataFrame(df.groupby(by='cluster')['profit'].mean(), columns=['profit']).reset_index()"},"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_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(df_profit_per_cluster_train) >= 3, \"Algorithm, returned less than 3 clusters.\"\n\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\n group_size = int(len(df_profit_per_cluster) / 3)\n\n buy_clusters_mean_profit = df_profit_per_cluster.iloc[:group_size]['profit'].mean()\n sell_clusters_mean_profit = df_profit_per_cluster.iloc[-group_size:]['profit'].mean()\n\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\n\n return buy_clusters_mean_profit, buy_clusters_list, sell_clusters_mean_profit, sell_clusters_list","def get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test: pd.core.frame.DataFrame,\n buy_clusters_list: List[int], sell_clusters_list: List[int]) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(buy_clusters_list) != 0 and len(sell_clusters_list) != 0, \"Clusters list can't be empty.\"\n\n buy_clusters_mean_profit = \\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(buy_clusters_list)]['profit'].mean()\n sell_clusters_mean_profit = \\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(sell_clusters_list)]['profit'].mean()\n\n return buy_clusters_mean_profit, sell_clusters_mean_profit","def wca_mean(X, k, df):\n\t\n\n\t# Intializing the clusters\t\n\tC = dict()\n\tfor cluster in range(k):\n\t C[cluster] = pd.DataFrame()\n\n\t# Calculating the mean vector\n\tmean_vector = X.mean()\n\n\t# Choosing the seed points based on the minimum distance from the mean vector\n\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\n\tdist_means = X.sort_values(by='dist_mean')\n\t\n\t# Dropping the the datapoints which have already been assigned as seed\n\tidx_to_drop = dist_means.index[:k]\n\tdist_means.reset_index(drop=True,inplace=True)\n\tX.drop('dist_mean',axis=1,inplace=True)\n\tX.drop(idx_to_drop, inplace=True)\n\n\t# Assigning seed points to the clusters\n\tmu = list()\n\tfor cluster in range(k):\n\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\n\t mu.append(C[cluster].mean())\n\t\n\t# Running the algorithm\t\n\t\n\t# Initializing the p-value list which would be used for plotting\n\tpval = dict()\n\n\tfor cluster in range(k):\n\t pval[cluster] = dict()\n\t for i in C[0].columns:\n\t pval[cluster][i] = list()\n\n\t# Algorithm\n\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\n\t for cluster in range(k):\n\n\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\n\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\n\t dist_means = X.sort_values(by='dist_mean', ascending=False)\n\t idx_to_drop = dist_means.index[0]\n\t dist_means.reset_index(drop=True,inplace=True)\n\t X.drop('dist_mean',axis=1,inplace=True)\n\n\t # Assigning the top value to the cluster\n\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\n\t C[cluster] = C[cluster].reset_index(drop=True)\n\t \n\t # Updating means of each cluster\n\t mu[cluster] = C[cluster].mean()\n\n\t # Remove datapoint from X?\n\t X.drop(idx_to_drop,inplace=True)\n\t \n\t for i in C[0].columns:\n\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\n\n\treturn(C,pval)","def clusterting_feature_importance (df, cluster_col):\r\n scores = pd.DataFrame()\r\n df0 = df.copy()\r\n df0 = df.select_dtypes(include=np.number)\r\n\r\n for i in df0[cluster_col].unique():\r\n df2 = df0[df0[cluster_col] == i]\r\n df2.drop(cluster_col,axis=1, inplace=True)\r\n #df2 = df.select_dtypes(include=np.number)\r\n scores[i] = df2.std() / (df2.max() - df2.min())\r\n scores['mean'] = scores.mean(axis = 1)\r\n\r\n scores = 1 - scores\r\n\r\n return scores","def cluster_means(self):\n if self.evaluate_by is not None:\n return(self.merged_data.groupby(\n 'labels').mean().sort_values(self.evaluate_by).transpose())\n else:\n return(self.merged_data.groupby('labels').mean().transpose())","def calculate_kmeans(df, clusters=10):\r\n kmeans = KMeans(n_clusters=clusters)\r\n labels = kmeans.fit_predict(df)\r\n\r\n return kmeans, labels","def mean(df):\r\n\r\n\tdf_mean_dict = dict()\r\n\r\n\tfor i, col in enumerate(df.columns):\r\n\t\tdf_mean_dict[col] = df[col].mean()\r\n\r\n\tdf_mean = pd.DataFrame(df_mean_dict, index=['Mean'])\r\n\tpd.set_option('precision', 2) # set output display precision in 2 decimal places\r\n\r\n\treturn df_mean","def disaggregate_by_cluster(self):\n # wt = np.zeros((1, self.ds.shape[1]))\n # total = np.zeros((self.n_ahead, self.ds.shape[1]))\n \n agg_cluster_ds = np.zeros((self.n_ahead+1, self.n_clusters))\n agg_cluster_ds[0] = self.ds_agg_by_c[-1]\n agg_cluster_ds[1:] = self.ds_c_for\n cluster_perc_change = np.diff(agg_cluster_ds, axis = 0) / agg_cluster_ds[:-1]\n\n cluster_scaling_vector = np.zeros((2, self.ds.shape[1]))\n\n # break down proportionally -> don't work well\n # for c in range(self.n_clusters):\n # c_m = self.ds.iloc[-self.cluster_n_period:, np.where(self.ds_c == c)[0]]\n # c_sum = sum(c_m)\n # indiv_sum = np.sum(c_m, axis = 0)\n # wt[:,np.where(self.ds_c == c)[0]] = (indiv_sum/c_sum)\n # total[:,np.where(self.ds_c == c)[0]] = np.reshape(\n # np.repeat(self.ds_c_for[:,c], c_m.shape[1]), (self.n_ahead, c_m.shape[1]))\n \n # multiply by the perc change\n \n for i in range(self.ds_c.shape[0]):\n cluster_scaling_vector[:,i] = cluster_perc_change[:,self.ds_c[i]]\n cluster_scaling_vector = cluster_scaling_vector+1\n cluster_scaling_vector = np.array(cluster_scaling_vector)\n \n self.ds_for = self.ds.copy()\n\n for yr in range(self.n_ahead)[::-1]:\n # forecast on foretasted number\n yr_ind = self.ds_for.index[-(yr+1)]\n self.ds_for.ix[yr_ind] = self.ds_for.iloc[-(yr+2),:].values * cluster_scaling_vector[-(yr+1)]\n\n # self.ds_for.iloc[-(self.n_ahead):,:] = self.ds_for.iloc[-(self.n_ahead+1):-1,:].values * np.array(cluster_scaling_vector)\n\n # if negative -> 0\n self.ds_for[self.ds_for < 0] = 0","def _compute_cluster_averages(self, key=\"_scvi_labels\"):\n # find cell label column\n label_col = self.adata.uns[\"_scvi\"][\"categorical_mappings\"][key][\"original_key\"]\n\n # find data slot\n x_dict = self.adata.uns[\"_scvi\"][\"data_registry\"][\"X\"]\n if x_dict[\"attr_name\"] == \"X\":\n use_raw = False\n else:\n use_raw = True\n if x_dict[\"attr_name\"] == \"layers\":\n layer = x_dict[\"attr_key\"]\n else:\n layer = None\n\n # compute mean expression of each gene in each cluster/batch\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\n\n return aver","def k_means_model(df, numOfClusters):\n # Perform scaling on the dataframe containing the selected features\n data = scale(df)\n\n # Train a model\n model = KMeans(init=\"k-means++\", n_clusters=numOfClusters, n_init=20).fit(data)\n return model","def grouping(data_clust):\n data_grouped = data_clust.groupby('Clusters').mean()\n return data_grouped","def cluster(players_df, columns):\n\toptimal_n=None\n\toptimal_clusters=None\n\toptimal_clusterer=None\n\toptimal_silhouette=-99\n\tfor n in range(2,9):\n\t\tclusterer=KMeans(n_clusters=n)\n\t\tcluster_labels=clusterer.fit_predict(players_df[columns])\n\t\tavg_silhouette=silhouette_score(players_df[columns], cluster_labels)\n\t\tprint('The avg silhouette score for {} clusters is {}'.format(n, avg_silhouette))\n\t\tif avg_silhouette > optimal_silhouette:\n\t\t\toptimal_silhouette=avg_silhouette\n\t\t\toptimal_clusterer=clusterer\n\t\t\toptimal_clusters=cluster_labels\n\t\t\toptimal_n=n\n\tprint('Returning optimal clusters found with n={}'.format(optimal_n))\n\tclusters = {n: [] for n in range(optimal_n)}\n\tfor i, label in enumerate(optimal_clusters):\n\t\tclusters[label].append(\n\t\t\tdict(\n\t\t\t\tplayer_id=players_df.iloc[i]['PERSON_ID'],\n\t\t\t\tfirst_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[-1],\n\t\t\t\tlast_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[0],\n\t\t\t\t)\n\t\t\t)\n\treturn clusters","def get_clusters_with_all_features(df, n_clusters):\n pipe = _build_model(df, use_pca=False, n_components=0, use_kmeans=True, n_clusters=n_clusters)\n labels = pipe.named_steps['kmeans'].labels_\n df.loc[:, 'labels'] = labels\n print(df.groupby('labels').agg(\n {'Fresh': 'mean', 'Milk': 'mean', 'Grocery': 'mean', 'Frozen': 'mean', 'Detergents_Paper': 'mean',\n 'Delicassen': 'mean'}))\n print(pipe.named_steps['scaler'].inverse_transform(pipe.named_steps['kmeans'].cluster_centers_))\n # cluster 1: low spending behaviour in general\n # cluster 2: high spending in detergents_paper, milk, grocery\n # cluster 3: high spending in fresh, rest low\n # cluster 4: high spending in everything except detergents_paper, extremely high in delicassen\n # cluster 5: medium spending in general, low in frozen, high in detergents and paper","def get_product_means(df):\n try:\n mean_dataframe = df.groupby(['asin'])['overall'].mean()\n print mean_dataframe[:10]\n write_df_tocsv(mean_dataframe, 'product_means.csv')\n return mean_dataframe\n except Exception as e:\n print \"Error getting product means\"\n print str(e)\n pass","def mean_cluster(self, labelled_cluster):\n sum_of_points = self.sum_cluster(labelled_cluster)\n size_cluster = len(labelled_cluster)\n if self.sigma_cl1:\n size_cluster += np.sqrt(2)*self.sigma_cl1*np.random.randn()\n mean_of_points = sum_of_points * (1.0 / size_cluster)\n return mean_of_points","def byMeans(dataset, number_of_clusters, class_header=\"Class\", verbosity=0, return_clusters=False):\n if verbosity >= 2: # optionally print dataset shape and info\n print(dataset.shape)\n print(dataset)\n\n old_dataset = dataset.copy()\n dataset = dataset.drop(columns=class_header) # remove non-float class column\n\n # Assign centroids to random values which fit into dataset space.\n centroids = pandas.DataFrame(columns=dataset.columns,\n data=numpy.random.uniform(dataset.min(), dataset.max(),\n (number_of_clusters, dataset.shape[1])))\n if verbosity >= 1: # optionally print centroids and random dataset\n print(\"INITIAL CENTROIDS\")\n print(centroids)\n if verbosity >= 2:\n print(\"DATAFRAME DATASET\")\n print(dataset)\n\n for iterations in range(MAX_ITERATIONS): # Loop until MAX_ITERATIONS or settled\n if verbosity >= 1: # optionally print iteration count\n print(\"ITERATIONS\")\n print(iterations)\n\n # calculate clustering of data\n clusters = Cluster.calcClusters(dataset, centroids, number_of_clusters, verbosity=verbosity)\n\n old_centroids = centroids.copy() # copy centroid dataframe\n\n if verbosity >= 2: # optionally print cluster list\n print(\"DATAFRAME ARRAY CLUSTERS\")\n print(clusters)\n\n for cluster_index, cluster in enumerate(clusters): # Calculate new centroids\n cluster_mean = cluster.mean()\n if not cluster_mean.isnull().any(): # make sure we dont write null means to centroid list\n centroids.loc[cluster_index] = cluster_mean\n\n if verbosity >= 1:\n print(\"OLD CENTROIDS\")\n print(old_centroids)\n print(\"NEW CENTROIDS\")\n print(centroids)\n\n if old_centroids is not None: # Calculate sum of centroid movements.\n centroid_change = 0\n for centroid_index, centroid in centroids.iterrows():\n centroid_change += abs(Cluster.calcDistance(centroid, old_centroids.loc[centroid_index]))\n\n if verbosity >= 1:\n print(\"CENTROID DIFF\")\n print(centroid_change)\n\n if centroid_change < SETTLE_THRESHOLD: # break if centroid movement is below threshold.\n break\n\n # Final Cluster re-calculation\n clusters = Cluster.calcClusters(old_dataset, centroids, number_of_clusters,\n verbosity=verbosity, class_header=class_header)\n # Create new dataframe with class column of and row for each centroid\n centroids_class = pandas.DataFrame(data=[\"NOCLASS\"] * centroids.shape[0], columns=[class_header])\n if verbosity >= 2:\n print(centroids_class)\n print(centroids)\n for cluster_index, cluster in enumerate(clusters): # For each cluster\n if verbosity >= 2:\n print(cluster_index)\n print(cluster)\n if cluster.size > 0: # If cluster is not empty set centroid class to most common class in cluster\n centroids_class.iat[cluster_index, 0] = cluster.mode().loc[0][0]\n if old_dataset.columns[0] == class_header: # check if class column should be first or last.\n print(\"CLASS IS FIRST COL\")\n centroids = pandas.concat([centroids_class, centroids], axis=1) # merge class to centroids as first column\n else:\n print(\"CLASS IS NOT FIRST COL\")\n centroids = pandas.concat([centroids, centroids_class], axis=1) # merge class to centroids as last column\n for centroid in centroids.iterrows(): # For each centroid\n if centroid[1][class_header] is \"NOCLASS\": # Trim NOCLASS centroids (empty cluster)\n centroids = centroids.drop(centroid[0])\n centroids = centroids.reset_index(drop=True) # Reindex centroids\n\n if return_clusters is True: # optionally return cluster list\n return centroids, clusters\n pass\n else:\n return centroids # return centroids dataframe","def cluster_means_scaled(self):\n if self.evaluate_by is not None:\n return(self.merged_scaled_data.groupby(\n 'labels').mean().sort_values(self.evaluate_by).transpose())\n else:\n return(self.merged_scaled_data.groupby(\n 'labels').mean().transpose())","def kMeans(df, k, threshold = 0.05, index_list = []):\n\tr.assign('df', df)\n\tr('df_transpose = t(df)')\n\tif len(index_list) == 0:\n\t \t\tindex_list = [2, 3, 4, 5, 6]\n\tr.assign('index_list', index_list)\n\tr('testframe = df_transpose[index_list,]')\n\tr.assign('k', k)\n\tr.assign('threshold', threshold)\n\tresults = r('kMeans(testframe, k, threshold)')\n\tr.assign('results', results)\n\treturn r('results')","def kmeans_clustering(proj_df, k):\r\n k_means= k_means = KMeans(random_state=25, n_clusters=k)\r\n k_means.fit(proj_df)\r\n labels= k_means.predict(proj_df)\r\n \r\n return labels","def __create_cluster_profiles(self,\n clustered_dataframes,\n shrunken_df,\n numerical_features,\n le_map,\n output_path,\n find_nearest_on_cols=False,\n show=True):\n\n def find_nearest(numbers, target):\n \"\"\"\n Find the closest fitting number to the target number\n \"\"\"\n numbers = np.asarray(numbers)\n idx = (np.abs(numbers - target)).argmin()\n return numbers[idx]\n\n cluster_profiles_df = pd.DataFrame(columns=shrunken_df.columns).drop(\n 'Cluster_Name', axis=1)\n rows_count = 0\n for cluster_identfier, cluster_dataframe in \\\n clustered_dataframes.items():\n df = pd.DataFrame(columns=cluster_dataframe.columns)\n df = df.append(cluster_dataframe.mean(), ignore_index=True)\n df.index = [cluster_identfier]\n\n if cluster_dataframe.shape[0] <= 1:\n continue\n\n # Attempt to convert numbers found within the full set of data\n for col in cluster_dataframe.columns:\n if col not in numerical_features or find_nearest_on_cols:\n df[col] = find_nearest(numbers=shrunken_df[\n col].value_counts().index.tolist(),\n target=df[col].values[0])\n\n # Evaluate cluster dataframe by dataframe\n eval_df = pd.DataFrame(columns=cluster_dataframe.columns)\n eval_df = eval_df.append(\n cluster_dataframe.mean(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.min(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.median(),\n ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.max(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.std(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.var(), ignore_index=True)\n eval_df.index = [\"Mean\", \"Min\", \"Median\",\n \"Max\", \"Standard Deviation\", \"Variance\"]\n\n if show:\n print(\"Total found in {0} is {1}\".format(\n cluster_identfier, cluster_dataframe.shape[0]))\n self.__render_mpl_table(\n df,\n sub_dir=output_path,\n filename=cluster_identfier +\n \"_Means_Rounded_To_Nearest_Real_Numbers\",\n header_columns=0,\n col_width=4.0)\n\n self.__render_mpl_table(\n eval_df,\n sub_dir=output_path,\n filename=cluster_identfier +\n \"_Eval_Df\",\n header_columns=0,\n col_width=4.0)\n display(df)\n display(eval_df)\n self.__vertical_spacing(7)\n\n cluster_profiles_df = cluster_profiles_df.append(\n self.__decode_df(df, le_map))\n\n rows_count += cluster_dataframe.shape[0]\n\n return rows_count, cluster_profiles_df","def average_consensus(self, cluster):\n\t\tcenterk = 0\n\t\tindex = 0\n\t\tfor value in cluster:\n\t\t\tcenterk += value\n\t\t\tindex += 1\n\t\tcenterk = centerk / index\n\t\treturn centerk","def k_means(n_clust, data_frame, true_labels):\n k_means = KMeans(n_clusters=n_clust, random_state=123, n_init=30)\n k_means.fit(data_frame)\n c_labels = k_means.labels_\n df = pd.DataFrame({'clust_label': c_labels, 'orig_label': true_labels.tolist()})\n ct = pd.crosstab(df['clust_label'], df['orig_label'])\n y_clust = k_means.predict(data_frame)\n display(ct)\n print('% 9s' % 'inertia homo compl v-meas ARI AMI silhouette')\n print('%i %.3f %.3f %.3f %.3f %.3f %.3f'\n % (k_means.inertia_,\n homogeneity_score(true_labels, y_clust),\n completeness_score(true_labels, y_clust),\n v_measure_score(true_labels, y_clust),\n adjusted_rand_score(true_labels, y_clust),\n adjusted_mutual_info_score(true_labels, y_clust),\n silhouette_score(data_frame, y_clust, metric='euclidean')))","def clustering(df, mode):\n # split into list of dfs containing only one reference node\n df_list = [df.loc[i : i + 8 - 1, :] for i in range(0, len(df), 8)]\n\n df_coefficient = pd.DataFrame()\n\n # loop over every single node\n for df_single in df_list:\n df_single = df_single.reset_index()\n total_value = 0\n\n # loop over the weights of all connected nodes\n for j in range(len(df_single) - 1):\n if mode == \"geometric\":\n # geometric\n total_value = total_value + math.sqrt(df_single.chi_sq[j] * df_single.chi_sq[j + 1])\n if mode == \"arithmetic\": \n # arithmetic\n total_value = total_value + ((df_single.chi_sq[j] * df_single.chi_sq[j + 1]) / 2)\n if mode == \"argmax\": \n # max\n total_value = total_value + max(df_single.chi_sq[j], df_single.chi_sq[j + 1])\n if mode == \"argmin\":\n # min\n total_value = total_value + min(df_single.chi_sq[j], df_single.chi_sq[j + 1])\n\n for i in range(len(df_single) - 1):\n if mode == \"geometric\":\n # geometric\n triplet_value = math.sqrt(df_single.chi_sq[i] * df_single.chi_sq[i + 1])\n if mode == \"arithmetic\":\n # arithmetic\n triplet_value = (df_single.chi_sq[i] * df_single.chi_sq[i + 1]) / 2\n if mode == \"argmax\":\n # max\n triplet_value = max(df_single.chi_sq[i], df_single.chi_sq[i + 1])\n if mode == \"argmin\": \n # min\n triplet_value = min(df_single.chi_sq[i], df_single.chi_sq[i + 1])\n\n cluster_coefficient = triplet_value / total_value\n buffer = [\n [\n df_single.reference[i],\n df_single.comparison[i],\n df_single.comparison[i + 1],\n triplet_value,\n cluster_coefficient,\n ]\n ]\n df_coefficient = df_coefficient.append(buffer)\n\n df_coefficient = df_coefficient.reset_index()\n\n print(\"\\n\\n threshold 0.5*c_omega\")\n check_list = []\n # print out triangles that have a cluster coefficient bigger, than X\n for i in range(len(df_coefficient)):\n if df_coefficient[4][i] >= ((0.5) * df_coefficient[4].max()):\n print(list(df_coefficient.loc[i][1:4]))\n check_list.append(list(df_coefficient.loc[i][1:4]))\n else:\n continue\n\n print(\"\\n\\n threshold 0.75*c_omega\")\n check_list = []\n for i in range(len(df_coefficient)):\n if df_coefficient[4][i] >= ((0.75) * df_coefficient[4].max()):\n print(list(df_coefficient.loc[i][1:4]))\n check_list.append(list(df_coefficient.loc[i][1:4]))\n else:\n continue\n\n print(\"\\n\\n threshold 0.8*c_omega\")\n check_list = []\n for i in range(len(df_coefficient)):\n if df_coefficient[4][i] >= ((0.9) * df_coefficient[4].max()):\n print(list(df_coefficient.loc[i][1:4]))\n check_list.append(list(df_coefficient.loc[i][1:4]))\n else:\n continue\n\n\n print(\"\\n\\n threshold 0.9*c_omega\")\n check_list = []\n for i in range(len(df_coefficient)):\n if df_coefficient[4][i] >= ((0.9) * df_coefficient[4].max()):\n print(list(df_coefficient.loc[i][1:4]))\n check_list.append(list(df_coefficient.loc[i][1:4]))\n else:\n continue\n\n return","def cluster_by_split(filtered_df):\n global features_in_range\n global table\n # make a copy of the entire data set\n unfiltered_df = table\n # get total number of robot faces in data set\n total_rows = len(unfiltered_df)\n\n # drop any column that is not included in our list of 11 features\n # 11 features = 16 features with no dependencies filtered via 20-80% range\n for col in unfiltered_df:\n if not unfiltered_df[col].name in features_in_range:\n unfiltered_df = unfiltered_df.drop(unfiltered_df[col].name, 1)\n\n # iterate over the dataframe of columns generated by the range\n for col in filtered_df:\n try:\n # for each column, call groupby() and calculate percentage\n check_for_20 = unfiltered_df.groupby(col).size().reset_index(name='count')\n check_for_20['as_percent'] = 100 * check_for_20['count'] / float(total_rows)\n # ignore feature values that represent less than 20% of all faces\n cluster_by_feature = check_for_20[check_for_20['as_percent'] >= 20]\n # if feature has values over 20%, iterate over\n # each feature_value and generate clusters\n if not cluster_by_feature.empty:\n # iterate over every value of the feature\n for index, row in cluster_by_feature.iterrows():\n # use feature value to call groupby() on the entire data set\n results = unfiltered_df[unfiltered_df[col] == row[0]]\n results = results \\\n .groupby(list(unfiltered_df)) \\\n .size() \\\n .reset_index(name='count')\n # calculate count as a percentage\n results['as_percent'] = 100 * results['count'] / float(total_rows)\n results = results.sort_values(by='as_percent', ascending=False)\n # store results in a .tsv file\n filename = str(col) + \"_\" + str(row[0]) + '_feature_cluster.tsv'\n results.to_csv(filename.replace(\"/\", \"-\"), header=True, sep='\\t')\n print(\"results written to file\")\n except:\n # 'count' and 'percentage' columns will generate errors\n # since they don't exist in the original data set\n pass","def create_cluster(df,validate, test, X, k, name):\n \n scaler = StandardScaler(copy=True).fit(df[X])\n X_scaled = pd.DataFrame(scaler.transform(df[X]), columns=df[X].columns.values).set_index([df[X].index.values])\n kmeans = KMeans(n_clusters = k, random_state = 42)\n kmeans.fit(X_scaled)\n kmeans.predict(X_scaled)\n df[name] = kmeans.predict(X_scaled)\n df[name] = 'cluster_' + df[name].astype(str)\n \n v_scaled = pd.DataFrame(scaler.transform(validate[X]), columns=validate[X].columns.values).set_index([validate[X].index.values])\n validate[name] = kmeans.predict(v_scaled)\n validate[name] = 'cluster_' + validate[name].astype(str)\n \n t_scaled = pd.DataFrame(scaler.transform(test[X]), columns=test[X].columns.values).set_index([test[X].index.values])\n test[name] = kmeans.predict(t_scaled)\n test[name] = 'cluster_' + test[name].astype(str)\n \n centroids = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=X_scaled.columns)\n return df, X_scaled, scaler, kmeans, centroids","def cluster_kmeans(df, k):\r\n # Sample fron the original df\r\n sample_df=df.sample(n = k)\r\n obs, attr= df.shape\r\n # Make copies \r\n copy_df=df.copy()\r\n flag=0\r\n sse_old=0\r\n while (flag==0): \r\n sse=0\r\n Labels=[]\r\n for i in range(0, obs):\r\n dist= []\r\n for j in range(0,k):\r\n #Calculate Eucledian distance\r\n diff=list((df.iloc[i,:]-sample_df.iloc[j,:])**2)\r\n eu_dist=(sum(diff))**(1/attr)\r\n dist.append(eu_dist) \r\n #Add Labels to the observations based on the variable they are close to\r\n label=(dist.index(min(dist)))\r\n Labels.append(label)\r\n # Calculate SSE\r\n sse=sse+((min(dist) )**2)\r\n sse=sse**(1/2)\r\n copy_df['labels']=Labels\r\n # Stopping criteria is change in SSE should be 2 %\r\n if (sse_old !=0):\r\n if(abs(sse_old-sse)/sse_old<=0.05):\r\n flag=1 \r\n return_df=copy_df['labels'].to_frame()\r\n return (return_df, sse)\r\n else:\r\n sse_old=sse\r\n #Empty the sample df\r\n sample_df.drop(sample_df.index, inplace=True)\r\n # Now pick random values from each label and add it to the sample df\r\n for val in range(0,k):\r\n #Create new sample df\r\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\r\n else:\r\n sse_old=sse\r\n #Empty the sample df\r\n sample_df.drop(sample_df.index, inplace=True)\r\n for val in range(0,k):\r\n #Create new sample df \r\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])","def cluster(dfi, samples, num_clusters=8, random_state=1):\n df = dfi.fillna(0)\n X = df[samples].values\n kmeans = KMeans(n_clusters=num_clusters,\n random_state=random_state).fit(X)\n cluster_number = kmeans.labels_\n df['kmeans_cluster_number'] = cluster_number\n return df","def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\n\n num_clusters = maxIndices.shape[0]\n if len(var.shape) == 1:\n meanvar = np.zeros((num_clusters,))\n elif len(var.shape) == 2:\n meanvar = np.zeros((var.shape[0],num_clusters))\n else:\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\n meanvar = None\n\n for aCluster, maxInd in enumerate(maxIndices):\n # get particles in cluster\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\n\n # compute mean depending upon size of array\n if len(var.shape) == 1:\n meanvar[aCluster] = np.mean(var[particles])\n if len(var.shape) == 2:\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\n\n return meanvar #}}}","def get_clusters_with_pca(df_full, df, n_clusters, n_components):\n pipe = _build_model(df, use_pca=True, n_components=2, use_kmeans=True, n_clusters=n_clusters)\n df.loc[:, ['PC-1', 'PC-2']] = pipe.named_steps['pca'].transform(df)\n labels = pipe.named_steps['kmeans'].labels_\n df.loc[:, 'labels'] = labels\n df_centers = df.groupby('labels').agg({'PC-1': 'mean', 'PC-2': 'mean'})\n print(df_centers)\n\n df.loc[:, 'Channel'] = df_full['Channel']\n df.loc[:, 'Channel_str'] = df['Channel'].replace([1, 2], ['Horeca', 'Retail'])\n plt.figure(8, figsize=(12, 6))\n for channel in ['Horeca', 'Retail']:\n plt.scatter(x='PC-1', y='PC-2', data=df[df['Channel_str'] == channel],\n s=200, alpha=0.5, label=channel)\n plt.xlabel('PC-1'), plt.ylabel('PC-2')\n plt.title('PC-1 vs PC-2 concerning Channel')\n plt.legend()\n plt.show()\n\n plt.figure(9, figsize=(12, 6))\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 0], s=100, c='red', label='Cluster 1')\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 1], s=100, c='blue', label='Cluster 2')\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 2], s=100, c='green', label='Cluster 3')\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 3], s=100, c='cyan', label='Cluster 4')\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 4], s=100, c='magenta', label='Cluster 5')\n plt.scatter(df_centers.iloc[:, 0], df_centers.iloc[:, 1],\n s=100, c='yellow', label='Centroids')\n plt.title('Clusters of customers')\n plt.xlabel('Spending in PC-1')\n plt.ylabel('Spending in PC-2')\n plt.legend()\n plt.show()","def cluster_stats(df):\r\n pattern = list(df.iloc[0])[-2]\r\n n_days = len(pattern)\r\n \r\n cls = [(day + 1, hour) for day in range(n_days) for hour in range(24)]\r\n tp = pd.DataFrame(columns = cls)\r\n tp.columns = pd.MultiIndex.from_tuples(tp.columns, names = ['day', 'hour'])\r\n tp.index.name = 'cluster'\r\n \r\n for (key, value) in df.groupby('cluster'):\r\n d, total = np.zeros((n_days, 24)), len(value)\r\n for arr in value.iloc[:, :-2].values:\r\n for i, ax in enumerate(np.split(arr, n_days)):\r\n ax = np.array([[0, 1][x > 0] for x in ax])\r\n d[i] += ax\r\n d /= total\r\n s = pd.Series({(x + 1, y) : d[x][y] for x in range(n_days) for y in range(24)})\r\n s.name = key\r\n tp = tp.append(s)\r\n \r\n tp['pattern'] = [pattern] * len(tp)\r\n return tp","def cluster_size(result, var):\n df=calculate_cluster_size(result, var)\n df['cus']=df.index\n return df","def cluster_distr(adata, cluster_key = 'louvain', batch_key = 'batch', eps = 0.4):\n\n from scipy.stats import entropy\n\n # check the input\n if cluster_key not in adata.obs.keys():\n raise ValueError('The key \\'{}\\' does not exist in adata.obs'.format(cluster_key))\n if batch_key not in adata.obs.keys():\n raise ValueError('The key \\'{}\\' does not exist in adata.obs'.format(batch_key))\n\n # get the clusters and batches\n clusters = adata.obs[cluster_key].cat.categories\n batches = adata.obs[batch_key].cat.categories\n\n # initialise dataframe\n batch_distr = pd.DataFrame(index = clusters, columns= 'perc_' + batches)\n\n # how many cells are there in total per cluster\n cells_per_cluster = [np.sum(adata.obs[cluster_key] == cluster) for cluster in clusters]\n batch_distr['total number'] = cells_per_cluster\n\n # loop over the batches\n for batch in batches:\n assignment = adata[adata.obs[batch_key] == batch].obs[cluster_key]\n cells_per_cluster_batch = [np.sum(assignment == cluster) for cluster in clusters]\n perc = np.round(np.array(cells_per_cluster_batch) / \\\n np.array(cells_per_cluster), 2)\n batch_distr['perc_' + batch] = perc\n\n # compute the entropy\n en = []\n for cluster in clusters:\n data = batch_distr.loc[cluster][list('perc_' + batches)]\n entropy_cluster = entropy(data)\n en.append(entropy_cluster)\n\n # warn if very small entropy\n if entropy_cluster <= eps:\n print('Warning: Cluster {} has a very uneven batch assignment.'.format(cluster))\n batch_distr['entropy'] = np.round(en, 2)\n\n # ideally the proportion n_batch_0/n_batch_1 will be equal to the proportion across batches\n # a good quality meassure of clustering will be how much the proportion acrros batches deviates from the proportion\n # of the whole data set\n b0 = sum(adata.obs[batch_key] == batches[0])\n b1 = sum(adata.obs[batch_key] == batches[1])\n prop_ds = b0/b1\n prop_cluster = batch_distr['perc_' + batches[0]] / batch_distr['perc_' + batches[1]]\n batch_distr['relative error b0/b1'] = np.round( np.abs(prop_ds - prop_cluster)/prop_ds , 2)\n\n\n\n return batch_distr","def run_split_cluster(cluster_df, keep_df=None, remove_df=None):\n if keep_df is None:\n keep_df = pd.DataFrame(columns=cluster_df.columns)\n if remove_df is None:\n remove_df = pd.DataFrame(columns=cluster_df.columns)\n for label, group_df in cluster_df.groupby([\"label\"]):\n # only keep the maximum cluster\n center_count = {center: len(group_df[group_df.center == center]) for center in group_df.center.unique()}\n max_center = sorted(center_count.items(), key=lambda i: i[1], reverse=True)[0][0]\n keep_df = keep_df.append(group_df[group_df.center == max_center], ignore_index=True)\n remove_df = remove_df.append(group_df[group_df.center != max_center], ignore_index=True)\n return keep_df, remove_df","def mean_of_group(gb):\n if type(gb.get_group(1)) is pd.DataFrame:\n d = {}\n for name, df in gb:\n mean = np.nanmean(df.values)\n d.update({name: mean})\n s = pd.Series(d)\n return s\n \n else:\n items= gb.get_group(1).items\n d = {key: {} for key in items}\n for name, p in gb:\n for i in items:\n mean = np.nanmean(p[i].values)\n d[i].update({name: mean})\n df = pd.DataFrame(d)\n return df","def pseudo_seurat(adata, arg_minpct, arg_mindiffpct, arg_logfcdiff):\n # define cells\n cluster_cells_ind = which_ind(adata.obs[\"idents\"] == \"1\")\n other_cells_ind = which_ind(adata.obs[\"idents\"] == \"0\")\n\n # compute perecentage expressed\n # from normnalised but not scaled data\n # remember cells are rows and genes are columns\n\n # note: I don't know why norm_counts[cluster_cell_ind:, col_ind] deosn\"t work, but it doesn't\n cluster_pct = (adata.X[cluster_cells_ind, :] > 0).sum(axis=0) / len(cluster_cells_ind)\n other_pct = (adata.X[other_cells_ind, :] > 0).sum(axis=0) / len(other_cells_ind)\n\n pcts = pd.DataFrame(np.vstack((cluster_pct, other_pct)).transpose())\n max_pct = pcts.max(axis=1)\n min_pct = pcts.min(axis=1)\n diff_pct = max_pct - min_pct\n take_diff_pct = diff_pct > arg_mindiffpct\n\n # remove genes that are not expressed higher than 0.1 in one of the groups\n take_min_pct = max_pct > arg_minpct\n\n\n # KEEP IN CASE NP.ARRAY METHOD USES TOO MUCH MEMORY\n # import time\n # this has the potential to be very slow. Transposeing it speeds it up a bit.\n # I need to understand sparse matrices better to make it work\n # start = time.time()\n # nct = adata.X.T[:,cluster_cells_ind]\n # cluster_mean0 = [exp_mean_sparse(nct[x,:]) for x in range(0,nct.shape[0])]\n # end = time.time()\n # print(end - start)\n #\n # start = time.time()\n # nct = adata.X.T[:, other_cells_ind]\n # other_mean0 = [exp_mean_sparse(nct[x,:]) for x in range(0, nct.shape[0])]\n # end = time.time()\n # print(end - start)\n\n # extract the counts for cluster cells and calculate exp means on each row\n nct = adata.X.T[:, cluster_cells_ind]\n cluster_mean = np.apply_along_axis(exp_mean_dense, 1, nct.todense())\n\n # likewise for non-cluster cells\n nct = adata.X.T[:, other_cells_ind]\n other_mean = np.apply_along_axis(exp_mean_dense, 1, nct.todense())\n diff_mean = abs(cluster_mean - other_mean)\n\n # remove genes with less than threshold difference\n take_thresh = diff_mean > arg_logfcdiff\n # take = if a cell passes all the tests then it is to be kept.\n take = [a and b and c for a, b, c in zip(take_thresh, take_min_pct, take_diff_pct)]\n print(\"saving universe for fisher test\")\n stats_df = pd.DataFrame(np.vstack((adata.var_names, cluster_mean, other_mean, diff_mean,\n cluster_pct, other_pct, max_pct, min_pct, diff_pct, take)).transpose(),\n columns=[\"gene\", \"cluster_mean\", \"other_mean\", \"diff_mean\",\n \"cluster_pct\", \"other_pct\",\n \"max_pct\", \"min_pct\", \"diff_pct\", \"background\"])\n return stats_df","def make_df_averaged_across_replicates(self, df, scheme):\n\n by_prot = collections.defaultdict(list)\n for col in self.positives.numeric_columns(df):\n prot = scheme.gene_from_fname(col)\n by_prot[prot].append(df[col].values)\n\n for prot in by_prot:\n arrs = by_prot[prot]\n n = len(by_prot[prot])\n by_prot[prot] = np.sum(arrs, axis=0)/n\n\n by_prot['gene_name'] = df['gene_name']\n by_prot['Gene type'] = df['Gene type']\n _df = pandas.DataFrame(by_prot)\n _df.index = _df['gene_name']\n return _df","def predictClusters(self, df, k):\n self.models.fitModels(df)\n return self.models.predict()","def generate_clusters(df):\n\n df_size = df.shape[0]\n print(df_size)\n n_clusters = 0\n percent_min_pts = 0.105\n min_clusters = 3\n while (n_clusters != min_clusters):\n print(\"percent_min_pts\", percent_min_pts)\n min_cluster_pts = math.floor(df_size * percent_min_pts)\n print(\"min_cluster_pts\", min_cluster_pts)\n\n clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_pts)\n print(df.head())\n clusterer.fit(df)\n cluster_groups = {}\n labels = clusterer.labels_\n for i in labels:\n if cluster_groups.get(i):\n cluster_groups[i] = cluster_groups[i] + 1\n else:\n cluster_groups[i] = 1\n print(\"cluster_groups\", cluster_groups)\n n_clusters = len(set(labels))\n print(\"n_clusters\", n_clusters)\n multiplier = abs(n_clusters - min_clusters) * 0.001\n print(\"multiplier\", multiplier)\n if n_clusters > min_clusters:\n percent_min_pts += multiplier\n else:\n percent_min_pts -= multiplier\n print(\"percent_min_pts\", percent_min_pts)\n return labels","def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\n learning_rate=0.01):\n\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\n random_seed=0)\n som.train(df_train, n_iter)\n\n # converting numpy arrays to dataframes\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\n\n # creating column with cluster basing on model prediction\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\n\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\n # the script\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\n lsuffix='_org')\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\n lsuffix='_org')\n\n return final_df_train, final_df_test","def pca_and_cluster(\n df: pd.DataFrame,\n columns: str,\n n_components: Union[int, None],\n n_clusters: Union[int, None],\n keep: bool = False\n) -> pd.DataFrame:\n col_id = columns.upper()\n print(\"Executing dimension reduction (pca + kmean) on {}* features...\".format(col_id))\n selected_columns = [x for x in df.columns if x.startswith(col_id)]\n print(\"Number of corresponding columns before processing: {}\".format(len(selected_columns)))\n for col in selected_columns:\n # Fill Nans with -2. Tentative.\n df[col].fillna((df[col].min() - 2), inplace=True)\n df[col] = preprocessing.minmax_scale(df[col], feature_range=(0, 1))\n df = PCA_reduction(df, selected_columns, prefix=\"PCA_{}_\".format(col_id), n_components=n_components, keep=keep)\n\n # Apply kmeans on PCA columns\n print(\"Executing k-means on dataset...\")\n s = \"PCA_{}_\".format(col_id)\n pca_columns = [x for x in df.columns if x.startswith(s)]\n kmean = cluster.KMeans(n_clusters=n_clusters)\n kmean_fit = kmean.fit(df[pca_columns])\n df[\"cluster_{}\".format(col_id)] = kmean_fit.predict(df[pca_columns])\n # predicted_indices = kmean_fit.predict(df[pca_columns])\n # df[\"cluster_{}\".format(col_id)] = kmean_fit.cluster_centers_[predicted_indices]\n return df","def compute_means(self):\n ###TODO\n vector_means = []\n for doc in self.fin_clust.values():\n vec = defaultdict(float)\n for d_id in doc:\n doc_keys = self.docs[d_id].keys()\n for key in self.docs[d_id]:\n vec[key] = vec[key] + self.docs[d_id][key]\n tot = len(doc)\n x = defaultdict(float)\n for k,v in vec.items():\n x[k] = float(v)/tot\n vec = Counter(x)\n vector_means.append(vec)\n return vector_means","def compute_clusters(addons_df, num_clusters, random_seed):\n\n # Build the stages of the pipeline. We need hashing to make the next\n # steps work.\n hashing_stage = HashingTF(inputCol=\"addon_ids\", outputCol=\"hashed_features\")\n idf_stage = IDF(inputCol=\"hashed_features\", outputCol=\"features\", minDocFreq=1)\n # As a future improvement, we may add a sane value for the minimum cluster size\n # to BisectingKMeans (e.g. minDivisibleClusterSize). For now, just make sure\n # to pass along the random seed if needed for tests.\n kmeans_kwargs = {\"seed\": random_seed} if random_seed else {}\n bkmeans_stage = BisectingKMeans(k=num_clusters, **kmeans_kwargs)\n pipeline = Pipeline(stages=[hashing_stage, idf_stage, bkmeans_stage])\n\n # Run the pipeline and compute the results.\n model = pipeline.fit(addons_df)\n return model.transform(addons_df).select([\"client_id\", \"prediction\"])","def cluster_membership_occupancy(data):\n \n \n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n\n if n_clusters == 0:\n membership=[Cluster_Membership_Features()]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n areas=[Cluster_Area_Features()]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features()]\n density = pd.DataFrame([o.__dict__ for o in density])\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n \n elif n_clusters ==1:\n #obtain_total_cluster_areas_set_everything_else_to_default\n membership=[Cluster_Membership_Features()]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n \n try:\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\n except:\n cluster_chull_areas=[0,0,0]\n \n Total_cluster_area=np.sum(cluster_chull_areas)\n areas=[Cluster_Area_Features([Total_cluster_area,0,0,0,0,0,0,0,0])]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features()]\n density = pd.DataFrame([o.__dict__ for o in density])\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n \n elif n_clusters >1:\n #Summarizing the cluster membership distribution characteristics\n cluster_size_nums=np.delete(np.array(data.groupby(['clusters']).size()),0)\n (cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD)= distribution_statistics(cluster_size_nums)\n\n #For each cluster calculate the area by calculating the area of the convex hull of cluster members\n # Note: concavehull implementation here might be a good addition as it will provide more imformative values. \n\n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n try:\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\n except:\n cluster_chull_areas=[0,0,0,0,0]\n \n\n (avg_cluster_area,min_cluster_area,max_cluster_area,\n std_cluster_area,CV_cluster_area,CD_cluster_area,\n IQR_cluster_area,Quartile_CD_cluster_area)= distribution_statistics(cluster_chull_areas)\n Total_cluster_area=np.sum(cluster_chull_areas)\n\n #Calculate cluster density: number of nuclei/ convex area of cluster\n cluster_density=np.divide(cluster_size_nums,cluster_chull_areas)\n (avg_cluster_density,min_cluster_density,max_cluster_density,\n std_cluster_density,CV_cluster_density,CD_cluster_density,\n IQR_cluster_density,Quartile_CD_cluster_density)= distribution_statistics(cluster_density)\n\n #return dataframe of features\n membership=[Cluster_Membership_Features([cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD])]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n areas=[Cluster_Area_Features([Total_cluster_area,\n avg_cluster_area,min_cluster_area,max_cluster_area,\n std_cluster_area,CV_cluster_area,CD_cluster_area,\n IQR_cluster_area,Quartile_CD_cluster_area])]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features([avg_cluster_density,min_cluster_density,max_cluster_density,\n std_cluster_density,CV_cluster_density,CD_cluster_density,\n IQR_cluster_density,Quartile_CD_cluster_density])]\n density = pd.DataFrame([o.__dict__ for o in density])\n\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n return all_features","def get_avg_score(df, score):\n avg_score = (df.groupby(['condition', 'gene_a', 'gene_b'])\n .agg({score: 'mean'})\n .reset_index())\n return avg_score","def add_cluster_to_ratings(user_df):\n # Read in ratings file\n #Get ratings file - create Spark instance for loading JSON\n spark = pyspark.sql.SparkSession.builder.getOrCreate()\n sc = spark.sparkContext\n ratings_df = spark.read.json('data/ratings.json').toPandas()\n \n # Set up clusters\n cluster_dict = {}\n for k, v in zip(user_df['id'].tolist(), user_df['cluster'].tolist()):\n cluster_dict[k] = v\n \n # Add cluster to ratings\n ratings_df['cluster'] = ratings_df['user_id'].apply(lambda x: cluster_dict[x])\n \n return ratings_df","def create_sigma_df(df_grouped, class_=0):\n sigma_all_list = []\n sigma_peak_list = []\n snid_list = []\n pred_class_list = []\n for SNID, SNID_df in df_grouped:\n arr_proba = SNID_df[f\"all_class{class_}\"]\n perc_16 = np.percentile(arr_proba, 16)\n perc_84 = np.percentile(arr_proba, 84)\n sigma_all_list.append(perc_84 - perc_16)\n\n arr_proba = SNID_df[f\"PEAKMJD_class{class_}\"]\n perc_16 = np.percentile(arr_proba, 16)\n perc_84 = np.percentile(arr_proba, 84)\n sigma_peak_list.append(perc_84 - perc_16)\n snid_list.append(SNID)\n\n # get predicition for this SNID\n k_all_probas = [k for k in SNID_df.keys() if \"all_class\" in k]\n median_prob_forSNID = SNID_df[k_all_probas].median()\n pred_class = median_prob_forSNID.idxmax()\n arr_proba = SNID_df[pred_class]\n # get sigma for this class\n perc_16 = np.percentile(arr_proba, 16)\n perc_84 = np.percentile(arr_proba, 84)\n pred_class_list.append(perc_84 - perc_16)\n\n df = pd.DataFrame()\n df[\"SNID\"] = np.array(snid_list)\n df[\"sigma_all\"] = np.array(sigma_all_list)\n df[\"sigma_peak\"] = np.array(sigma_peak_list)\n df[\"pred_sigma_all\"] = np.array(pred_class_list)\n return df","def get_cluster_assignments(self, data, n_clusters=10):\n kmeans = KMeans(n_clusters=n_clusters)\n kmeans.fit(data)\n pred = kmeans.predict(data)\n return pd.DataFrame(pred)","def avg_tx_fees_BTC(df):\n result = df['Tx fees (BTC)'].div(df['Txs'])\n result.name = 'Avg Tx Fees (BTC)'\n return out(SETTINGS, df, result)","def get_clusters(df, allow_unassigned, variance_coefficient, letters):\n\n logging.info('Calculating cluster assignments')\n\n # Calculate minimum thresholds to call cluster assignments.\n\n min_thresholds = pd.Series(np.tile(1e-6, df.shape[1]), index=df.columns)\n\n if allow_unassigned:\n\n # Estimate the variance for each factor by fixing the MLE estimate of\n # the mean to 0.\n\n min_thresholds = df.apply(\n get_mle_variance, mean=0).apply(np.sqrt) * variance_coefficient\n\n unassigned_mask = (df >= min_thresholds).sum(axis=1) < 1\n\n result = df.apply(pd.Series.argmax, axis=1)\n\n # Apply letters if required.\n\n if letters:\n\n result = (\n result.astype(int) - 1).apply(string.ascii_uppercase.__getitem__)\n\n # Set unassigned patients.\n\n result.loc[unassigned_mask] = 0\n\n return result","def mean_rate(df):\n mean_of_rate = dict(df.mean())\n return mean_of_rate","def clust_strength(mat,groups):\n cluster_strengths = []\n for group in range(len(np.unique(groups))):\n this_cluster = mat[groups==group,:]\n this_cluster_mean = np.mean(this_cluster,axis=0)\n all_dists = mat - this_cluster_mean\n out_dists = np.linalg.norm(all_dists[groups!=group],axis=1)\n in_dists = np.linalg.norm(all_dists[groups==group],axis=1)\n this_strength = np.mean(out_dists)/np.mean(in_dists)\n cluster_strengths.append(this_strength)\n \n return np.mean(cluster_strengths)","def cluster_cal(self):\n self.Cluster = []\n for i in range(self.nodenum):\n neighborhood_node = self.neighbor_node(i)\n Node_num = len(neighborhood_node)\n Count = self.neighbor_edge(neighborhood_node)\n if(Node_num == 0 or Node_num == 1):\n self.Cluster.append(0.5)\n else:\n self.Cluster.append(Count/(Node_num*(Node_num - 1)))\n \n self.cluster_coeff = np.average(self.Cluster)","def get_feature_weights(df, pca, cluster, columns):\r\n feature_weights = df.inverse_transform(pca.cluster_centers_[cluster-1])\r\n\r\n return pd.Series(feature_weights, index=columns).sort_values()","def GLM_cluster_de_test_multi(df, y, n_processes=None):\n table = []\n with Pool(n_processes) as workers:\n\n for r in workers.imap_unordered(pool_wrapper,((\n\n _GLM_cluster_de_test_single_gene\n ,{\n 'gene':gene,\n 'cuts_frame':df,\n 'clusters':y\n }\n )\n for gene in df\n ), chunksize=200):\n if r is None:\n continue\n\n (gene, f_score, p_value, coeff, model, null_model) = r\n table.append([gene,f_score,p_value, coeff['model_std_err']['cluster'], coeff['model_coefficients']['cluster']])\n\n\n return pd.DataFrame(table, columns=['gene','f_score','p_value','cluster_stderr','cluster_coeff'])","def assign_to_current_mean(img: np.ndarray, clustermask: np.ndarray) -> float:\n\n rows, cols = img.shape[:2]\n distances = np.zeros((numclusters, 1))\n overall_dist = 0\n\n for i in range(rows):\n for j in range(cols):\n distances = distance(img[i, j, :]) # returned shape: (numclusters, 1)\n \n k = np.argmin(distances) # closest cluster\n clustermask.itemset((i, j), k) # update cluster mask\n overall_dist += distances[k, 0] # sum distance\n\n return overall_dist","def avg_tx_fees_USD(df):\n result = df['Tx fees (USD)'].div(df['Txs'])\n result.name = 'Avg Tx Fees (USD)'\n return out(SETTINGS, df, result)","def computeMeans(X, idx, K):\n\tm, n = X.shape\n\tcentroids = np.zeros((K, n))\n\tcount = np.zeros(K)\n\n\tfor j in range(m):\n\t\tcentroids[int(idx[j])] += X[j]\n\n\tfor i in range(m):\n\t\tcount[int(idx[i])] += 1\n\n\treturn centroids / np.tile(count.reshape((K, 1)), n)","def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\n res = []\n for n_clusters in n_clusters_considered:\n res.append([])\n for _ in range(n_repeats):\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\n print(X.val.shape)\n print(X_restricted.val.shape)\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\n res[-1].append(evaluator_X.weighted_average) \n return res","def mean(dfs):\n df_mean = sum(dfs)\n return df_mean/len(dfs)","def mean_cluster(gene_info, grouping, modality='ATAC'):\n\n\t# if grouping == 'annotation':\n\t# \tgene_info.fillna({'annotation_'+modality: 'None'}, inplace=True)\n\t# if grouping != 'dataset':\n\t# \treturn gene_info.groupby(grouping+'_'+modality, sort=False)['normalized_counts'].mean()\n\t# else:\n\t# \treturn gene_info.groupby(grouping, sort=False)['normalized_counts'].mean()\n\n\tif grouping == 'annotation':\n\t\tgene_info.fillna({'annotation_'+modality: 'None'}, inplace=True)\n\t\treturn gene_info.groupby('annotation_'+modality, sort=False)['normalized_counts'].mean()\n\telif grouping == 'cluster':\n\t\treturn gene_info.groupby('cluster_'+modality, sort=False)['normalized_counts'].mean()\n\telif grouping == 'dataset':\n\t\treturn gene_info.groupby('dataset', sort=False)['normalized_counts'].mean()\n\telif grouping == 'target_region':\n\t\tgene_info['target_region'].fillna('N/A', inplace=True)\n\t\treturn gene_info.groupby('target_region', sort=False)['normalized_counts'].mean()\n\telse:\n\t\treturn None","def _mean_of_monthly_means_basic_method(df: pd.DataFrame) -> pd.DataFrame:\n monthly_df: pd.DataFrame = df.groupby(df.index.month).mean().mean().to_frame()\n monthly_df.columns = ['MOMM']\n return monthly_df","def k_means_montage(self, df, class_col):\n\n n_classes = df[class_col].nunique()\n for cl in sorted(df[class_col].unique()):\n montage_df = df[df[class_col] == cl].path\n imgs = [np.array(Image.open(img)) for img in montage_df]\n imgs = np.stack(imgs)\n plt.figure(figsize=(12, 15))\n plt.imshow(montage(imgs, multichannel=True).astype(np.uint8))\n plt.title(f\"Montage for Class{cl}\")","def pred_agg1_train(df):\n new_feats = []\n pred_cols = [column for column in df.columns if \"pred\" in column]\n for c in pred_cols:\n tmp = (\n df.groupby([\"StudyInstanceUID\"])[c]\n .agg([\"min\", \"max\", \"mean\", \"std\"])\n .reset_index()\n )\n tmp.columns = [\n \"StudyInstanceUID\",\n c + \"_min\",\n c + \"_max\",\n c + \"_mean\",\n c + \"_std\",\n ]\n if c != \"any_pred_model_base\":\n del tmp[\"StudyInstanceUID\"]\n new_feats.append(tmp)\n new_feats = pd.concat(new_feats, axis=1)\n df = pd.merge(df, new_feats, on=\"StudyInstanceUID\", how=\"left\")\n for c in pred_cols:\n df[c + \"_diff\"] = df[c] - df[c + \"_mean\"]\n df[c + \"_div\"] = df[c] / df[c + \"_mean\"]\n df[c + \"_scaled\"] = (df[c] - df[c + \"_mean\"]) / df[c + \"_std\"]\n return df","def _avg_cluster_hitprobability(self, x, y, n_clusters=30):\n\n # Compute the individual Hit probability\n proba = self._shufflesplit(x, y)\n\n # average the individual hit probability for each cluster\n ind = self._cluster(x, x.shape[0]/2.)\n\n avg_proba = np.copy(proba)\n\n for cluster in np.unique(ind):\n mask_ = ind == cluster\n avg_proba[mask_] = avg_proba[mask_].mean()\n\n return avg_proba","def cluster_centroids(self,mydata, clusters, k=None):\n\t\tif k is None:\n\t\t\tk = np.max(clusters) + 1\n\t\tresult = np.empty(shape=(k,) + mydata.shape[1:])\n\t\tfor i in range(k):\n\t\t\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\n\t\treturn result","def get_cold_start_rating(user_id, movie_id, user_df, u_clusters, ratings_df):\n\n # Load files \n #user_df = pd.read_csv('data/user_cluster.csv', index_col=0) \n #u_clusters = pd.read_csv('data/u_info.csv', index_col=0)\n #ratings_df = pd.read_csv('data/movie_cluster_avg.csv', index_col=0)\n \n # User Cluster\n user_cluster = u_clusters.loc[u_clusters['id'] == user_id]['cluster'].tolist()[0]\n \n # Get score components\n if len(ratings_df.loc[(ratings_df['cluster'] == user_cluster) & (ratings_df['movie_id'] == movie_id)]) > 0:\n# if (movie_id in ratings_df['movie_id'].tolist()):\n avg = ratings_df.loc[(ratings_df['cluster'] == user_cluster) & (ratings_df['movie_id'] == movie_id)]['rating'].tolist()\n else:\n cluster_rating = ratings_df.loc[ratings_df['cluster'] == user_cluster]['rating'].tolist()\n avg = sum(cluster_rating)/len(cluster_rating)\n if user_id in user_df['user_id'].tolist():\n u = user_bias(user_df, user_id)\n i = item_bias(user_df, movie_id)\n pred_rating = avg + u + i\n else:\n pred_rating = avg\n \n return pred_rating","def cont_feature_clusters_sklearn(self, n_clusters = 5): \n \n #Import the library\n from sklearn.cluster import FeatureAgglomeration\n \n Cluster = FeatureAgglomeration(n_clusters=n_clusters)\n Cluster.fit(self._dataset.iloc[:,self._cont_index_predictors])\n \n df = pd.DataFrame({'Variable':self._dataset.columns[self._cont_index_predictors], 'Cluster':Cluster.labels_})\n \n return df.sort_values(by='Cluster')","def feat_imp_MDI_clustered(fit, feat_names, clstrs):\n df0 = {i:tree.feature_importances_ for i, tree in enumerate(fit.estimators_)}\n df0 = pd.DataFrame.from_dict(df0, orient='index')\n df0.columns = feat_names\n df0 = df0.replace(0, np.nan) #because max_features=1\n imp = group_mean_std(df0, clstrs)\n imp /= imp['mean'].sum()\n return imp","def gen_clust_summ_agg(proj, map_dict, proj_data, comp='slope'):\n err_dict = rank_err(proj_data, map_dict)\n assert (comp in err_dict.keys()), 'missing comp in errdict: {}'.format(comp)\n err_diff = err_dict[comp]-err_dict['rbf']\n df_clust_sum = pd.DataFrame(zip(map_dict['rbf'].z, err_diff[:,0], proj_data['SI']), columns=['rbf_clust_num', 'err_diff', 'SI'])\n df_cluster_aggregate = df_clust_sum.groupby('rbf_clust_num')[['err_diff']].mean().join(df_clust_sum['rbf_clust_num'].value_counts())\n df_cluster_aggregate.sort_values('err_diff', ascending=False, inplace=True)\n \n return df_cluster_aggregate","def mean_payoffs(dist,benefit_function,b,c,*params):\n dist['A_pay'] = (b*benefit_function(dist.j+1,dist.k+1,*params)-c)*dist.A\n dist['B_pay'] = (b*benefit_function(dist.j,dist.k+1,*params))*dist.B\n return dist.groupby('n')[['A_pay','B_pay']].sum()","def compute_centers(points, labels):\n df = pd.DataFrame(points)\n return df.groupby(labels).mean().values","def clustering_pc(df):\n nb_clusters = 5\n kmeans = KMeans(n_clusters=nb_clusters, random_state=0).fit(df)\n labels = pd.DataFrame(kmeans.labels_,columns=['labels'], index=df.index)\n df_values_labels = pd.concat([df,labels],axis=1,join='outer')\n\n palette = ['#e41a1c', '#377eb8', '#4eae4b',\n '#994fa1', '#ff8101', '#fdfc33',\n '#a8572c', '#f482be', '#999999']\n return labels, kmeans.cluster_centers_","def get_mean(self):\n average = self.df[self.col_name].mean()\n return average","def findK_centroids_average(self, features, clusters):\n\n class InnerFeatures:\n def __init__(self, kps, des, pos):\n self.kps = kps\n self.des = des\n self.pos = pos\n\n kmeans = KMeans(n_clusters=clusters)\n\n pts = np.array(features.pos)\n kps = np.array(features.kps)\n des = np.array(features.des)\n\n kmeans.fit(pts)\n m_clusters = np.array(kmeans.labels_.tolist())\n centers = np.array(kmeans.cluster_centers_)\n\n # KeyPoint(x,y,size) -required\n\n final_kps = []\n final_des = []\n final_pts = []\n\n for cluster in range(clusters):\n indices = np.where(m_clusters == cluster)\n cluster_kps_size = np.mean(np.array([x.size for x in kps[indices]]))\n cluster_des = des[indices]\n\n average_des = np.mean(cluster_des, axis=0)\n cluster_kps = cv2.KeyPoint(x=centers[cluster][0], y=centers[cluster][1], _size=cluster_kps_size)\n\n final_kps.append(cluster_kps)\n final_des.append(average_des)\n final_pts.append([centers[cluster][0], centers[cluster][1]])\n\n final_pts = np.array(final_pts)\n final_des = np.array(final_des)\n final_kps = np.array(final_kps)\n\n result = InnerFeatures(kps=final_kps, des=final_des, pos=final_pts)\n return result","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def GLM_cluster_de_test(cuts_frame, clusters):\n\n table = []\n for gene in cuts_frame.columns:\n\n r = _GLM_cluster_de_test_single_gene(gene, 1+cuts_frame, clusters)\n\n if r is None:\n continue\n\n (gene, f_score, p_value, coeff, model, null_model) = r\n table.append([gene,f_score,p_value, coeff['model_std_err']['cluster'], coeff['model_coefficients']['cluster']])\n\n return pd.DataFrame(table, columns=['gene','f_score','p_value','cluster_stderr','cluster_coeff'])","def select_cluster(self, clusters):\n min_sim = float(\"inf\")\n min_cluster = None\n \n for cluster in clusters:\n sim = 0.0\n for index, value in cluster.centroid.items():\n sim += value * value\n \n if sim < min_sim:\n min_sim = sim\n min_cluster = cluster\n \n return min_cluster","def update_mean(img: np.ndarray, clustermask: np.ndarray):\n\n for k in range(numclusters):\n current_cluster_centers[k, 0, :] = np.mean(img[clustermask==k], axis=0)","def evaulate_clusters(self, pred_dict, model_dir):\n\t\tclustering_dict = {\"Topic\":[], \"Text\":[], \"Keywords\": []}\n\t\tfor cluster_num, sents_list in pred_dict.items():\n\t\t\tprint(\"\\n cluster number : \", cluster_num)\n\t\t\tprint(\"\\n number of sents : \", len(sents_list))\n\t\t\ttfidf_vec = TfidfVectorizer(use_idf=True, sublinear_tf=True, max_df=0.8, max_features=20, ngram_range=(1,5), min_df=1)\n\t\t\tX_tfidf = tfidf_vec.fit_transform(sents_list).toarray()\n\t\t\ttotal_tfidf = tfidf_vec.get_feature_names()\n\t\t\tfor sent in sents_list:\n\t\t\t\tclustering_dict[\"Topic\"].append(cluster_num)\n\t\t\t\tclustering_dict[\"Text\"].append(sent)\n\t\t\t\tclustering_dict[\"Keywords\"].append(\",\".join(total_tfidf))\n\t\t\"\"\" save the clusters to csv file \"\"\"\n\t\tdf_dominant_topic = defaultdict(list) \n\t\tdf_dominant_topic[\"Topic\"] = clustering_dict[\"Topic\"]\n\t\tdf_dominant_topic[\"Text\"] = clustering_dict[\"Text\"]\n\t\tdf_dominant_topic[\"Keywords\"] = clustering_dict[\"Keywords\"]\n\t\tdf_dominant_topic = pd.DataFrame(df_dominant_topic)\n\t\tdf_dominant_topic.to_csv(os.path.join(model_dir, \"cluster_sentence_topic_mapping.csv\"))\n\t\treturn df_dominant_topic","def means_and_pval(self, means, df):\n list = np.arange(len(df))\n for i, (key, item) in zip(list, df):\n res = self.mcnemar(item)\n means.loc[means.index[i], \"p_value\"] = res[\"results\"][1]\n return means","def slg_average(df,start_year,end_year,bat_met,player_name):\n base_fields = ['AB','HR','X3B','X2B','SLG']\n emp_list = check_base_fields(df,base_fields)\n\n if not emp_list:\n df['X1B'] = round(df['SLG']*df['AB'] - (4*df['HR'] + 3*df['X3B'] + 2*df['X2B']),0)\n return round((df['X1B'].sum(axis = 0) + df['X2B'].sum(axis = 0) * 2 + df['X3B'].sum(axis = 0) * 3 + df['HR'].sum(axis = 0) * 4) / df['AB'].sum(axis = 0),3)\n\n else:\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\n df['X1B'] = round(df['SLG']*df['AB'] - (4*df['HR'] + 3*df['X3B'] + 2*df['X2B']),0)\n SLG = round((df['X1B'].sum(axis = 0) + df['X2B'].sum(axis = 0) * 2 + df['X3B'].sum(axis = 0) * 3 + df['HR'].sum(axis = 0) * 4) / df['AB'].sum(axis = 0),3)\n del df['X1B']\n return SLG","def find_mean_max_min(df, count_columns: dict, group_columns = ['Fabric_name', 'Fabric_label']):\n \n summary_df = pd.DataFrame()\n for count_column, rename_column in count_columns.items():\n current_df = df.groupby(by = group_columns)[count_column].agg(['mean', 'max', 'min'])\n current_df['mean'] = current_df['mean'].round(1)\n rename_dct = {}\n for column in current_df.columns:\n rename_dct[column] = rename_column + '_' + column\n current_df.rename(columns=rename_dct, inplace=True)\n current_df.reset_index(inplace=True)\n if summary_df.empty:\n summary_df = current_df.copy()\n else:\n summary_df = summary_df.merge(current_df, how='outer', on=group_columns) \n return summary_df","def strategy_returns(df, df_price_of_strategy):\r\n df_return_of_strategy = pd.DataFrame(index=df_price_of_strategy.index)\r\n cols = df_price_of_strategy.columns\r\n\r\n for priceSeries in cols:\r\n df_return_of_strategy[priceSeries] = (df_price_of_strategy[priceSeries]\r\n - df_price_of_strategy[priceSeries].shift()) / (\r\n df_price_of_strategy[priceSeries])\r\n\r\n return df_return_of_strategy","def strategy_returns(df, df_price_of_strategy):\r\n df_return_of_strategy = pd.DataFrame(index=df_price_of_strategy.index)\r\n cols = df_price_of_strategy.columns\r\n\r\n for priceSeries in cols:\r\n df_return_of_strategy[priceSeries] = (df_price_of_strategy[priceSeries]\r\n - df_price_of_strategy[priceSeries].shift()) / (\r\n df_price_of_strategy[priceSeries])\r\n\r\n return df_return_of_strategy","def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\n self.merge_clusters([[6,98,99]])\n self.merge_clusters([[35,80]])\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\n self.merge_clusters([[76,98]])\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\n self.merge_clusters([[39,42]])\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\n self.merge_clusters([[70,101]])\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\n self.merge_clusters()\n return","def fit(self, df):\n self.center = df.tail(self.rows).mean()\n self.center = self.center.replace(0, np.nan)\n if self.center.isnull().any():\n surrogate = df.replace(0, np.nan).median().fillna(1)\n self.center = self.center.fillna(surrogate)\n return self","def _GLM_cluster_de_test_single_gene(gene, cuts_frame, clusters):\n\n data = copy(cuts_frame[[gene]])+1\n data.columns = ['ncuts']\n data['plate'] = [x.split('_')[0] for x in data.index]\n data['cluster'] = clusters\n data['n_total_cuts'] = cuts_frame.sum(1)\n\n\n fam = sm.families.Poisson()\n try:\n model = smf.glm(\"ncuts ~ 1 + plate + cluster\", data= data,\n # cov_struct=ind,\n offset=np.log(data['n_total_cuts']),\n family=fam).fit()\n\n null_model = smf.glm(f\"ncuts ~ 1 + plate\", data= data,\n # cov_struct=ind,\n offset=np.log(data['n_total_cuts']),\n family=fam).fit()\n except Exception as e:\n if 'estimation infeasible.' in str(e) or 'PerfectSeparationError' in str(e) :\n return None\n else:\n raise\n\n coeff = pd.DataFrame( {'model_std_err':model.bse,\n 'model_coefficients':model.params,\n 'null_std_err':null_model.bse,\n 'null_coefficients':null_model.params,\n\n })\n\n return [gene, *calculate_nested_f_statistic(null_model,model), coeff, model, null_model]","def update_avg_f1(ccs, gold_clusters, pred_clusters):\n gold_clusters, mention_to_gold = ccs.get_gold_clusters(gold_clusters)\n pred_clusters, mention_to_pred = ccs.get_gold_clusters(pred_clusters)\n\n # update scores\n scorers = ccs.scorers\n\n for scorer in scorers:\n scorer.update(pred_clusters, gold_clusters,\n mention_to_pred, mention_to_gold)","def merge_clusters(self, other_cluster):\n if len(other_cluster.fips_codes()) == 0:\n return self\n else:\n self._fips_codes.update(set(other_cluster.fips_codes()))\n \n # compute weights for averaging\n self_weight = float(self._total_population) \n other_weight = float(other_cluster.total_population())\n self._total_population = self._total_population + other_cluster.total_population()\n self_weight /= self._total_population\n other_weight /= self._total_population\n \n # update center and risk using weights\n self._vert_center = self_weight * self._vert_center + other_weight * other_cluster.vert_center()\n self._horiz_center = self_weight * self._horiz_center + other_weight * other_cluster.horiz_center()\n self._averaged_risk = self_weight * self._averaged_risk + other_weight * other_cluster.averaged_risk()\n return self","def merge_clusters(self, other_cluster):\n if len(other_cluster.fips_codes()) == 0:\n return self\n else:\n self._fips_codes.update(set(other_cluster.fips_codes()))\n \n # compute weights for averaging\n self_weight = float(self._total_population) \n other_weight = float(other_cluster.total_population())\n self._total_population = self._total_population + other_cluster.total_population()\n self_weight /= self._total_population\n other_weight /= self._total_population\n \n # update center and risk using weights\n self._vert_center = self_weight * self._vert_center + other_weight * other_cluster.vert_center()\n self._horiz_center = self_weight * self._horiz_center + other_weight * other_cluster.horiz_center()\n self._averaged_risk = self_weight * self._averaged_risk + other_weight * other_cluster.averaged_risk()\n return self","def calc_clust_slope(model, data):\n df_slope_si = calc_slope_mogp_data(data)\n df_slope_clust = pd.DataFrame(zip(data['SI'], model.z), columns=['SI', 'cluster']).set_index('SI')\n df_slope_clust = df_slope_clust.join(df_slope_si, how='left')\n df_slope_clust = pd.DataFrame(df_slope_clust.groupby('cluster')['slope'].mean())\n return df_slope_clust","def crude_policy_selection(actor, clusters):\n # read in results from optimisation\n results = []\n\n for _, case in the_cases(actor).items():\n temp = pd.read_csv(\"simulation/optimisation/\" + actor + \"/results_\" + case + \".csv\")\n temp_ = pd.read_csv(\"simulation/optimisation/\" + actor + \"/convergence_\" + case + \".csv\")\n results.append([temp, temp_])\n\n # collapse in 1 dataframe\n opt_df = pd.DataFrame()\n for i, (result, convergence) in enumerate(results):\n result[\"scenario\"] = i\n opt_df = pd.concat([opt_df, result], axis=0)\n\n # clean up\n opt_df.reset_index(inplace=True, drop=True)\n opt_df.drop_duplicates(inplace=True)\n\n # select policies + add scenario back\n policies = opt_df.iloc[:, :-4]\n policies = pd.concat([policies, opt_df[\"scenario\"]], axis=1)\n\n kmeans = KMeans(n_clusters=clusters, random_state=0).fit(policies.iloc[:, :-1])\n\n # get all policies in each cluster\n policies['cluster'] = kmeans.labels_\n groups = policies.groupby(by=\"cluster\")\n groups = groups.obj.sort_values(\"cluster\", ascending=True)\n\n # assign values to each policy in each cluster\n groups[\"value\"] = 0\n for i in range(clusters):\n group = groups.loc[groups[\"cluster\"] == i]\n group = group.iloc[:, :-3]\n scaler = preprocessing.MinMaxScaler().fit(group)\n data_scaled = scaler.transform(group)\n groups.at[group.index.values, 'value'] = data_scaled.sum(axis=1)\n\n # get the most extreme two per cluster\n idx = []\n for cluster in range(clusters):\n idx.extend(groups.loc[groups[\"cluster\"] == cluster].sort_values(by=\"value\", ascending=False)[:2].index.values.tolist())\n\n return opt_df.iloc[idx]","def calcAvgDistances(centroids, clusters, class_header=\"Class\"):\n avg_distances = [0] * len(centroids)\n multiprocess_count = multiprocessing.cpu_count() # Find processor count\n for centroid_row_index, centroid_tuple in enumerate(centroids.iterrows()): # For each cluster\n work_list = [] # initialize multiprocessing structures\n set_list = []\n for _, datum in clusters[centroid_row_index].iterrows(): # For each point in the medoid cluster\n work_list.append((centroid_tuple[1], datum, class_header)) # add calculation to work list\n\n partition_size = math.ceil(len(work_list) / multiprocess_count) # find size of each work subeset\n for i in range(multiprocess_count - 1): # repeat for every subset\n sample = work_list[i * partition_size: (i + 1) * partition_size] # break work list into fair subsets\n set_list.append(sample)\n set_list.append((work_list[(multiprocess_count - 1) * partition_size:]))\n pool = multiprocessing.Pool(processes=multiprocess_count) # create multiprocessing pool\n # calculate sum of list of all distances from work list tasks\n avg_distances[centroid_row_index] = sum(sum(pool.map(Cluster.calcDistanceList, set_list), []))\n pool.close()\n pool.join()\n\n if avg_distances[centroid_row_index] is not 0: # make sure we do not divide by 0\n # calculate average of distance list\n avg_distances[centroid_row_index] = avg_distances[centroid_row_index] / len(clusters[centroid_row_index])\n return avg_distances","def kmeans_cluster(X_train_input, n_clusters=100):\r\n from sklearn.cluster import MiniBatchKMeans\r\n image_descriptors = []\r\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\r\n image_descriptors = np.array(image_descriptors) \r\n \r\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\r\n random_state=34, batch_size=128).fit(image_descriptors)\r\n \r\n return kmeans_model","def kmeansClustering(data, x_scaled, clust, random_s):\n np.random.seed(random_s)\n #Performs clustering with the right number of clusters\n kmeans = KMeans(n_clusters=clust, random_state=random_s, n_jobs=-1).fit(x_scaled)\n kmeans = pd.DataFrame(kmeans.labels_, index=data.index, columns=[\"Clusters\"])\n #Merge on our main dataframe for better vizualisation of the clusters\n data_clust = pd.merge(data, kmeans, left_index=True, right_index=True, how='left')\n return data_clust","def cluster_center_update_dataset(spn, dataset):\n\n if isinstance(spn, Categorical):\n\n insert_into_categorical_leaf(spn, np.array([dataset]), np.array([1.0]))\n\n return spn\n elif isinstance(spn, IdentityNumericLeaf):\n\n insert_into_identity_numeric_leaf(spn, np.array([dataset]), np.array([1.0]))\n\n return spn\n elif isinstance(spn, Sum):\n cc = spn.cluster_centers\n\n node_idx = 0\n\n min_dist = np.inf\n min_idx = -1\n for n in spn.children:\n # distance calculation between the dataset and the different clusters\n # (there exist a much faster version on scipy)\n # this? https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html\n #\n proj = projection(dataset, n.scope)\n dist = distance.euclidean(cc[node_idx], proj)\n if dist < min_dist:\n min_dist = dist\n min_idx = node_idx\n\n node_idx += 1\n assert min_idx > -1\n assert min_idx < len(spn.children)\n adapt_weights(spn, min_idx)\n cluster_center_update_dataset(spn.children[min_idx], dataset)\n elif isinstance(spn, Product):\n\n for n in spn.children:\n cluster_center_update_dataset(n, dataset)\n else:\n raise Exception(\"Invalid node type \" + str(type(spn)))\n spn.cardinality += 1","def evaluate_clusters(self, cluster_formulas, value='weighted_sum'):\n num_elems = len(self.labels)\n total_val = {}\n num_cl = len(cluster_formulas)\n clustered_points_num = 0\n print(\"\\n\\n\")\n print(\"Sufficiently big clusters: {}\".format(num_cl))\n for c, formula, val in cluster_formulas:\n c_size = len([l for l in self.labels if l == c])\n clustered_points_num += c_size\n\n if value == 'weighted_sum':\n total_val[c] = val * c_size / num_elems\n elif value == 'sum':\n total_val[c] = val * 1\n\n clust_val = sum(total_val.values())\n self.clustering_value = total_val\n print(\"Value of clustering: {}\".format(clust_val))\n return clust_val","def get_number_of_clusters(df, use_pca, n_components):\n n_clusters = 10\n cluster_with_distances = []\n for i in range(n_clusters):\n pipe = _build_model(df, use_pca, n_components, use_kmeans=True, n_clusters=i + 1)\n cluster_with_distances.append(pipe.named_steps['kmeans'].inertia_)\n plt.figure(6, figsize=(12, 6))\n plt.plot(range(1, 11), cluster_with_distances, 'o')\n plt.plot(range(1, 11), cluster_with_distances, '-', alpha=0.5)\n plt.title('The Elbow Criterion')\n plt.xlabel('number of cluster')\n plt.ylabel('Sum of squared distances of samples to their closest cluster center')\n plt.show()","def add_accumulation_features(df, config):\n if config.has_option(\"clustering\", \"bin\"):\n bin_size = float(config.get(\"clustering\", \"bin\"))\n logger.info(\n \"Computation of the accumulation features with bin_size=%s\",\n bin_size\n )\n df = accumulation_2d_neighborhood(df, bin_size)\n df.fillna(0, inplace=True)\n for c in (\"bin_z_range\", \"bin_z_std\", \"bin_density\"):\n df[c] = max_normalize(df[c])\n return df","def cre_confidence1(df):\r\n func = lambda x: 1 - np.abs(x.mean())\r\n return df.groupby('creline')['ffb_c'].transform(func)"],"string":"[\n \"def get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\\n # if condition returns False, AssertionError is raised:\\n assert len(df_profit_per_cluster_train) >= 3, \\\"Algorithm, returned less than 3 clusters.\\\"\\n\\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\\n group_size = int(len(df_profit_per_cluster) / 3)\\n\\n buy_clusters_mean_profit = df_profit_per_cluster.iloc[:group_size]['profit'].mean()\\n sell_clusters_mean_profit = df_profit_per_cluster.iloc[-group_size:]['profit'].mean()\\n\\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\\n\\n return buy_clusters_mean_profit, buy_clusters_list, sell_clusters_mean_profit, sell_clusters_list\",\n \"def get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test: pd.core.frame.DataFrame,\\n buy_clusters_list: List[int], sell_clusters_list: List[int]) -> tuple:\\n # if condition returns False, AssertionError is raised:\\n assert len(buy_clusters_list) != 0 and len(sell_clusters_list) != 0, \\\"Clusters list can't be empty.\\\"\\n\\n buy_clusters_mean_profit = \\\\\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(buy_clusters_list)]['profit'].mean()\\n sell_clusters_mean_profit = \\\\\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(sell_clusters_list)]['profit'].mean()\\n\\n return buy_clusters_mean_profit, sell_clusters_mean_profit\",\n \"def wca_mean(X, k, df):\\n\\t\\n\\n\\t# Intializing the clusters\\t\\n\\tC = dict()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = pd.DataFrame()\\n\\n\\t# Calculating the mean vector\\n\\tmean_vector = X.mean()\\n\\n\\t# Choosing the seed points based on the minimum distance from the mean vector\\n\\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\\n\\tdist_means = X.sort_values(by='dist_mean')\\n\\t\\n\\t# Dropping the the datapoints which have already been assigned as seed\\n\\tidx_to_drop = dist_means.index[:k]\\n\\tdist_means.reset_index(drop=True,inplace=True)\\n\\tX.drop('dist_mean',axis=1,inplace=True)\\n\\tX.drop(idx_to_drop, inplace=True)\\n\\n\\t# Assigning seed points to the clusters\\n\\tmu = list()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\\n\\t mu.append(C[cluster].mean())\\n\\t\\n\\t# Running the algorithm\\t\\n\\t\\n\\t# Initializing the p-value list which would be used for plotting\\n\\tpval = dict()\\n\\n\\tfor cluster in range(k):\\n\\t pval[cluster] = dict()\\n\\t for i in C[0].columns:\\n\\t pval[cluster][i] = list()\\n\\n\\t# Algorithm\\n\\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\\n\\t for cluster in range(k):\\n\\n\\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\\n\\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\\n\\t dist_means = X.sort_values(by='dist_mean', ascending=False)\\n\\t idx_to_drop = dist_means.index[0]\\n\\t dist_means.reset_index(drop=True,inplace=True)\\n\\t X.drop('dist_mean',axis=1,inplace=True)\\n\\n\\t # Assigning the top value to the cluster\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\\n\\t C[cluster] = C[cluster].reset_index(drop=True)\\n\\t \\n\\t # Updating means of each cluster\\n\\t mu[cluster] = C[cluster].mean()\\n\\n\\t # Remove datapoint from X?\\n\\t X.drop(idx_to_drop,inplace=True)\\n\\t \\n\\t for i in C[0].columns:\\n\\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\\n\\n\\treturn(C,pval)\",\n \"def clusterting_feature_importance (df, cluster_col):\\r\\n scores = pd.DataFrame()\\r\\n df0 = df.copy()\\r\\n df0 = df.select_dtypes(include=np.number)\\r\\n\\r\\n for i in df0[cluster_col].unique():\\r\\n df2 = df0[df0[cluster_col] == i]\\r\\n df2.drop(cluster_col,axis=1, inplace=True)\\r\\n #df2 = df.select_dtypes(include=np.number)\\r\\n scores[i] = df2.std() / (df2.max() - df2.min())\\r\\n scores['mean'] = scores.mean(axis = 1)\\r\\n\\r\\n scores = 1 - scores\\r\\n\\r\\n return scores\",\n \"def cluster_means(self):\\n if self.evaluate_by is not None:\\n return(self.merged_data.groupby(\\n 'labels').mean().sort_values(self.evaluate_by).transpose())\\n else:\\n return(self.merged_data.groupby('labels').mean().transpose())\",\n \"def calculate_kmeans(df, clusters=10):\\r\\n kmeans = KMeans(n_clusters=clusters)\\r\\n labels = kmeans.fit_predict(df)\\r\\n\\r\\n return kmeans, labels\",\n \"def mean(df):\\r\\n\\r\\n\\tdf_mean_dict = dict()\\r\\n\\r\\n\\tfor i, col in enumerate(df.columns):\\r\\n\\t\\tdf_mean_dict[col] = df[col].mean()\\r\\n\\r\\n\\tdf_mean = pd.DataFrame(df_mean_dict, index=['Mean'])\\r\\n\\tpd.set_option('precision', 2) # set output display precision in 2 decimal places\\r\\n\\r\\n\\treturn df_mean\",\n \"def disaggregate_by_cluster(self):\\n # wt = np.zeros((1, self.ds.shape[1]))\\n # total = np.zeros((self.n_ahead, self.ds.shape[1]))\\n \\n agg_cluster_ds = np.zeros((self.n_ahead+1, self.n_clusters))\\n agg_cluster_ds[0] = self.ds_agg_by_c[-1]\\n agg_cluster_ds[1:] = self.ds_c_for\\n cluster_perc_change = np.diff(agg_cluster_ds, axis = 0) / agg_cluster_ds[:-1]\\n\\n cluster_scaling_vector = np.zeros((2, self.ds.shape[1]))\\n\\n # break down proportionally -> don't work well\\n # for c in range(self.n_clusters):\\n # c_m = self.ds.iloc[-self.cluster_n_period:, np.where(self.ds_c == c)[0]]\\n # c_sum = sum(c_m)\\n # indiv_sum = np.sum(c_m, axis = 0)\\n # wt[:,np.where(self.ds_c == c)[0]] = (indiv_sum/c_sum)\\n # total[:,np.where(self.ds_c == c)[0]] = np.reshape(\\n # np.repeat(self.ds_c_for[:,c], c_m.shape[1]), (self.n_ahead, c_m.shape[1]))\\n \\n # multiply by the perc change\\n \\n for i in range(self.ds_c.shape[0]):\\n cluster_scaling_vector[:,i] = cluster_perc_change[:,self.ds_c[i]]\\n cluster_scaling_vector = cluster_scaling_vector+1\\n cluster_scaling_vector = np.array(cluster_scaling_vector)\\n \\n self.ds_for = self.ds.copy()\\n\\n for yr in range(self.n_ahead)[::-1]:\\n # forecast on foretasted number\\n yr_ind = self.ds_for.index[-(yr+1)]\\n self.ds_for.ix[yr_ind] = self.ds_for.iloc[-(yr+2),:].values * cluster_scaling_vector[-(yr+1)]\\n\\n # self.ds_for.iloc[-(self.n_ahead):,:] = self.ds_for.iloc[-(self.n_ahead+1):-1,:].values * np.array(cluster_scaling_vector)\\n\\n # if negative -> 0\\n self.ds_for[self.ds_for < 0] = 0\",\n \"def _compute_cluster_averages(self, key=\\\"_scvi_labels\\\"):\\n # find cell label column\\n label_col = self.adata.uns[\\\"_scvi\\\"][\\\"categorical_mappings\\\"][key][\\\"original_key\\\"]\\n\\n # find data slot\\n x_dict = self.adata.uns[\\\"_scvi\\\"][\\\"data_registry\\\"][\\\"X\\\"]\\n if x_dict[\\\"attr_name\\\"] == \\\"X\\\":\\n use_raw = False\\n else:\\n use_raw = True\\n if x_dict[\\\"attr_name\\\"] == \\\"layers\\\":\\n layer = x_dict[\\\"attr_key\\\"]\\n else:\\n layer = None\\n\\n # compute mean expression of each gene in each cluster/batch\\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\\n\\n return aver\",\n \"def k_means_model(df, numOfClusters):\\n # Perform scaling on the dataframe containing the selected features\\n data = scale(df)\\n\\n # Train a model\\n model = KMeans(init=\\\"k-means++\\\", n_clusters=numOfClusters, n_init=20).fit(data)\\n return model\",\n \"def grouping(data_clust):\\n data_grouped = data_clust.groupby('Clusters').mean()\\n return data_grouped\",\n \"def cluster(players_df, columns):\\n\\toptimal_n=None\\n\\toptimal_clusters=None\\n\\toptimal_clusterer=None\\n\\toptimal_silhouette=-99\\n\\tfor n in range(2,9):\\n\\t\\tclusterer=KMeans(n_clusters=n)\\n\\t\\tcluster_labels=clusterer.fit_predict(players_df[columns])\\n\\t\\tavg_silhouette=silhouette_score(players_df[columns], cluster_labels)\\n\\t\\tprint('The avg silhouette score for {} clusters is {}'.format(n, avg_silhouette))\\n\\t\\tif avg_silhouette > optimal_silhouette:\\n\\t\\t\\toptimal_silhouette=avg_silhouette\\n\\t\\t\\toptimal_clusterer=clusterer\\n\\t\\t\\toptimal_clusters=cluster_labels\\n\\t\\t\\toptimal_n=n\\n\\tprint('Returning optimal clusters found with n={}'.format(optimal_n))\\n\\tclusters = {n: [] for n in range(optimal_n)}\\n\\tfor i, label in enumerate(optimal_clusters):\\n\\t\\tclusters[label].append(\\n\\t\\t\\tdict(\\n\\t\\t\\t\\tplayer_id=players_df.iloc[i]['PERSON_ID'],\\n\\t\\t\\t\\tfirst_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[-1],\\n\\t\\t\\t\\tlast_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[0],\\n\\t\\t\\t\\t)\\n\\t\\t\\t)\\n\\treturn clusters\",\n \"def get_clusters_with_all_features(df, n_clusters):\\n pipe = _build_model(df, use_pca=False, n_components=0, use_kmeans=True, n_clusters=n_clusters)\\n labels = pipe.named_steps['kmeans'].labels_\\n df.loc[:, 'labels'] = labels\\n print(df.groupby('labels').agg(\\n {'Fresh': 'mean', 'Milk': 'mean', 'Grocery': 'mean', 'Frozen': 'mean', 'Detergents_Paper': 'mean',\\n 'Delicassen': 'mean'}))\\n print(pipe.named_steps['scaler'].inverse_transform(pipe.named_steps['kmeans'].cluster_centers_))\\n # cluster 1: low spending behaviour in general\\n # cluster 2: high spending in detergents_paper, milk, grocery\\n # cluster 3: high spending in fresh, rest low\\n # cluster 4: high spending in everything except detergents_paper, extremely high in delicassen\\n # cluster 5: medium spending in general, low in frozen, high in detergents and paper\",\n \"def get_product_means(df):\\n try:\\n mean_dataframe = df.groupby(['asin'])['overall'].mean()\\n print mean_dataframe[:10]\\n write_df_tocsv(mean_dataframe, 'product_means.csv')\\n return mean_dataframe\\n except Exception as e:\\n print \\\"Error getting product means\\\"\\n print str(e)\\n pass\",\n \"def mean_cluster(self, labelled_cluster):\\n sum_of_points = self.sum_cluster(labelled_cluster)\\n size_cluster = len(labelled_cluster)\\n if self.sigma_cl1:\\n size_cluster += np.sqrt(2)*self.sigma_cl1*np.random.randn()\\n mean_of_points = sum_of_points * (1.0 / size_cluster)\\n return mean_of_points\",\n \"def byMeans(dataset, number_of_clusters, class_header=\\\"Class\\\", verbosity=0, return_clusters=False):\\n if verbosity >= 2: # optionally print dataset shape and info\\n print(dataset.shape)\\n print(dataset)\\n\\n old_dataset = dataset.copy()\\n dataset = dataset.drop(columns=class_header) # remove non-float class column\\n\\n # Assign centroids to random values which fit into dataset space.\\n centroids = pandas.DataFrame(columns=dataset.columns,\\n data=numpy.random.uniform(dataset.min(), dataset.max(),\\n (number_of_clusters, dataset.shape[1])))\\n if verbosity >= 1: # optionally print centroids and random dataset\\n print(\\\"INITIAL CENTROIDS\\\")\\n print(centroids)\\n if verbosity >= 2:\\n print(\\\"DATAFRAME DATASET\\\")\\n print(dataset)\\n\\n for iterations in range(MAX_ITERATIONS): # Loop until MAX_ITERATIONS or settled\\n if verbosity >= 1: # optionally print iteration count\\n print(\\\"ITERATIONS\\\")\\n print(iterations)\\n\\n # calculate clustering of data\\n clusters = Cluster.calcClusters(dataset, centroids, number_of_clusters, verbosity=verbosity)\\n\\n old_centroids = centroids.copy() # copy centroid dataframe\\n\\n if verbosity >= 2: # optionally print cluster list\\n print(\\\"DATAFRAME ARRAY CLUSTERS\\\")\\n print(clusters)\\n\\n for cluster_index, cluster in enumerate(clusters): # Calculate new centroids\\n cluster_mean = cluster.mean()\\n if not cluster_mean.isnull().any(): # make sure we dont write null means to centroid list\\n centroids.loc[cluster_index] = cluster_mean\\n\\n if verbosity >= 1:\\n print(\\\"OLD CENTROIDS\\\")\\n print(old_centroids)\\n print(\\\"NEW CENTROIDS\\\")\\n print(centroids)\\n\\n if old_centroids is not None: # Calculate sum of centroid movements.\\n centroid_change = 0\\n for centroid_index, centroid in centroids.iterrows():\\n centroid_change += abs(Cluster.calcDistance(centroid, old_centroids.loc[centroid_index]))\\n\\n if verbosity >= 1:\\n print(\\\"CENTROID DIFF\\\")\\n print(centroid_change)\\n\\n if centroid_change < SETTLE_THRESHOLD: # break if centroid movement is below threshold.\\n break\\n\\n # Final Cluster re-calculation\\n clusters = Cluster.calcClusters(old_dataset, centroids, number_of_clusters,\\n verbosity=verbosity, class_header=class_header)\\n # Create new dataframe with class column of and row for each centroid\\n centroids_class = pandas.DataFrame(data=[\\\"NOCLASS\\\"] * centroids.shape[0], columns=[class_header])\\n if verbosity >= 2:\\n print(centroids_class)\\n print(centroids)\\n for cluster_index, cluster in enumerate(clusters): # For each cluster\\n if verbosity >= 2:\\n print(cluster_index)\\n print(cluster)\\n if cluster.size > 0: # If cluster is not empty set centroid class to most common class in cluster\\n centroids_class.iat[cluster_index, 0] = cluster.mode().loc[0][0]\\n if old_dataset.columns[0] == class_header: # check if class column should be first or last.\\n print(\\\"CLASS IS FIRST COL\\\")\\n centroids = pandas.concat([centroids_class, centroids], axis=1) # merge class to centroids as first column\\n else:\\n print(\\\"CLASS IS NOT FIRST COL\\\")\\n centroids = pandas.concat([centroids, centroids_class], axis=1) # merge class to centroids as last column\\n for centroid in centroids.iterrows(): # For each centroid\\n if centroid[1][class_header] is \\\"NOCLASS\\\": # Trim NOCLASS centroids (empty cluster)\\n centroids = centroids.drop(centroid[0])\\n centroids = centroids.reset_index(drop=True) # Reindex centroids\\n\\n if return_clusters is True: # optionally return cluster list\\n return centroids, clusters\\n pass\\n else:\\n return centroids # return centroids dataframe\",\n \"def cluster_means_scaled(self):\\n if self.evaluate_by is not None:\\n return(self.merged_scaled_data.groupby(\\n 'labels').mean().sort_values(self.evaluate_by).transpose())\\n else:\\n return(self.merged_scaled_data.groupby(\\n 'labels').mean().transpose())\",\n \"def kMeans(df, k, threshold = 0.05, index_list = []):\\n\\tr.assign('df', df)\\n\\tr('df_transpose = t(df)')\\n\\tif len(index_list) == 0:\\n\\t \\t\\tindex_list = [2, 3, 4, 5, 6]\\n\\tr.assign('index_list', index_list)\\n\\tr('testframe = df_transpose[index_list,]')\\n\\tr.assign('k', k)\\n\\tr.assign('threshold', threshold)\\n\\tresults = r('kMeans(testframe, k, threshold)')\\n\\tr.assign('results', results)\\n\\treturn r('results')\",\n \"def kmeans_clustering(proj_df, k):\\r\\n k_means= k_means = KMeans(random_state=25, n_clusters=k)\\r\\n k_means.fit(proj_df)\\r\\n labels= k_means.predict(proj_df)\\r\\n \\r\\n return labels\",\n \"def __create_cluster_profiles(self,\\n clustered_dataframes,\\n shrunken_df,\\n numerical_features,\\n le_map,\\n output_path,\\n find_nearest_on_cols=False,\\n show=True):\\n\\n def find_nearest(numbers, target):\\n \\\"\\\"\\\"\\n Find the closest fitting number to the target number\\n \\\"\\\"\\\"\\n numbers = np.asarray(numbers)\\n idx = (np.abs(numbers - target)).argmin()\\n return numbers[idx]\\n\\n cluster_profiles_df = pd.DataFrame(columns=shrunken_df.columns).drop(\\n 'Cluster_Name', axis=1)\\n rows_count = 0\\n for cluster_identfier, cluster_dataframe in \\\\\\n clustered_dataframes.items():\\n df = pd.DataFrame(columns=cluster_dataframe.columns)\\n df = df.append(cluster_dataframe.mean(), ignore_index=True)\\n df.index = [cluster_identfier]\\n\\n if cluster_dataframe.shape[0] <= 1:\\n continue\\n\\n # Attempt to convert numbers found within the full set of data\\n for col in cluster_dataframe.columns:\\n if col not in numerical_features or find_nearest_on_cols:\\n df[col] = find_nearest(numbers=shrunken_df[\\n col].value_counts().index.tolist(),\\n target=df[col].values[0])\\n\\n # Evaluate cluster dataframe by dataframe\\n eval_df = pd.DataFrame(columns=cluster_dataframe.columns)\\n eval_df = eval_df.append(\\n cluster_dataframe.mean(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.min(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.median(),\\n ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.max(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.std(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.var(), ignore_index=True)\\n eval_df.index = [\\\"Mean\\\", \\\"Min\\\", \\\"Median\\\",\\n \\\"Max\\\", \\\"Standard Deviation\\\", \\\"Variance\\\"]\\n\\n if show:\\n print(\\\"Total found in {0} is {1}\\\".format(\\n cluster_identfier, cluster_dataframe.shape[0]))\\n self.__render_mpl_table(\\n df,\\n sub_dir=output_path,\\n filename=cluster_identfier +\\n \\\"_Means_Rounded_To_Nearest_Real_Numbers\\\",\\n header_columns=0,\\n col_width=4.0)\\n\\n self.__render_mpl_table(\\n eval_df,\\n sub_dir=output_path,\\n filename=cluster_identfier +\\n \\\"_Eval_Df\\\",\\n header_columns=0,\\n col_width=4.0)\\n display(df)\\n display(eval_df)\\n self.__vertical_spacing(7)\\n\\n cluster_profiles_df = cluster_profiles_df.append(\\n self.__decode_df(df, le_map))\\n\\n rows_count += cluster_dataframe.shape[0]\\n\\n return rows_count, cluster_profiles_df\",\n \"def average_consensus(self, cluster):\\n\\t\\tcenterk = 0\\n\\t\\tindex = 0\\n\\t\\tfor value in cluster:\\n\\t\\t\\tcenterk += value\\n\\t\\t\\tindex += 1\\n\\t\\tcenterk = centerk / index\\n\\t\\treturn centerk\",\n \"def k_means(n_clust, data_frame, true_labels):\\n k_means = KMeans(n_clusters=n_clust, random_state=123, n_init=30)\\n k_means.fit(data_frame)\\n c_labels = k_means.labels_\\n df = pd.DataFrame({'clust_label': c_labels, 'orig_label': true_labels.tolist()})\\n ct = pd.crosstab(df['clust_label'], df['orig_label'])\\n y_clust = k_means.predict(data_frame)\\n display(ct)\\n print('% 9s' % 'inertia homo compl v-meas ARI AMI silhouette')\\n print('%i %.3f %.3f %.3f %.3f %.3f %.3f'\\n % (k_means.inertia_,\\n homogeneity_score(true_labels, y_clust),\\n completeness_score(true_labels, y_clust),\\n v_measure_score(true_labels, y_clust),\\n adjusted_rand_score(true_labels, y_clust),\\n adjusted_mutual_info_score(true_labels, y_clust),\\n silhouette_score(data_frame, y_clust, metric='euclidean')))\",\n \"def clustering(df, mode):\\n # split into list of dfs containing only one reference node\\n df_list = [df.loc[i : i + 8 - 1, :] for i in range(0, len(df), 8)]\\n\\n df_coefficient = pd.DataFrame()\\n\\n # loop over every single node\\n for df_single in df_list:\\n df_single = df_single.reset_index()\\n total_value = 0\\n\\n # loop over the weights of all connected nodes\\n for j in range(len(df_single) - 1):\\n if mode == \\\"geometric\\\":\\n # geometric\\n total_value = total_value + math.sqrt(df_single.chi_sq[j] * df_single.chi_sq[j + 1])\\n if mode == \\\"arithmetic\\\": \\n # arithmetic\\n total_value = total_value + ((df_single.chi_sq[j] * df_single.chi_sq[j + 1]) / 2)\\n if mode == \\\"argmax\\\": \\n # max\\n total_value = total_value + max(df_single.chi_sq[j], df_single.chi_sq[j + 1])\\n if mode == \\\"argmin\\\":\\n # min\\n total_value = total_value + min(df_single.chi_sq[j], df_single.chi_sq[j + 1])\\n\\n for i in range(len(df_single) - 1):\\n if mode == \\\"geometric\\\":\\n # geometric\\n triplet_value = math.sqrt(df_single.chi_sq[i] * df_single.chi_sq[i + 1])\\n if mode == \\\"arithmetic\\\":\\n # arithmetic\\n triplet_value = (df_single.chi_sq[i] * df_single.chi_sq[i + 1]) / 2\\n if mode == \\\"argmax\\\":\\n # max\\n triplet_value = max(df_single.chi_sq[i], df_single.chi_sq[i + 1])\\n if mode == \\\"argmin\\\": \\n # min\\n triplet_value = min(df_single.chi_sq[i], df_single.chi_sq[i + 1])\\n\\n cluster_coefficient = triplet_value / total_value\\n buffer = [\\n [\\n df_single.reference[i],\\n df_single.comparison[i],\\n df_single.comparison[i + 1],\\n triplet_value,\\n cluster_coefficient,\\n ]\\n ]\\n df_coefficient = df_coefficient.append(buffer)\\n\\n df_coefficient = df_coefficient.reset_index()\\n\\n print(\\\"\\\\n\\\\n threshold 0.5*c_omega\\\")\\n check_list = []\\n # print out triangles that have a cluster coefficient bigger, than X\\n for i in range(len(df_coefficient)):\\n if df_coefficient[4][i] >= ((0.5) * df_coefficient[4].max()):\\n print(list(df_coefficient.loc[i][1:4]))\\n check_list.append(list(df_coefficient.loc[i][1:4]))\\n else:\\n continue\\n\\n print(\\\"\\\\n\\\\n threshold 0.75*c_omega\\\")\\n check_list = []\\n for i in range(len(df_coefficient)):\\n if df_coefficient[4][i] >= ((0.75) * df_coefficient[4].max()):\\n print(list(df_coefficient.loc[i][1:4]))\\n check_list.append(list(df_coefficient.loc[i][1:4]))\\n else:\\n continue\\n\\n print(\\\"\\\\n\\\\n threshold 0.8*c_omega\\\")\\n check_list = []\\n for i in range(len(df_coefficient)):\\n if df_coefficient[4][i] >= ((0.9) * df_coefficient[4].max()):\\n print(list(df_coefficient.loc[i][1:4]))\\n check_list.append(list(df_coefficient.loc[i][1:4]))\\n else:\\n continue\\n\\n\\n print(\\\"\\\\n\\\\n threshold 0.9*c_omega\\\")\\n check_list = []\\n for i in range(len(df_coefficient)):\\n if df_coefficient[4][i] >= ((0.9) * df_coefficient[4].max()):\\n print(list(df_coefficient.loc[i][1:4]))\\n check_list.append(list(df_coefficient.loc[i][1:4]))\\n else:\\n continue\\n\\n return\",\n \"def cluster_by_split(filtered_df):\\n global features_in_range\\n global table\\n # make a copy of the entire data set\\n unfiltered_df = table\\n # get total number of robot faces in data set\\n total_rows = len(unfiltered_df)\\n\\n # drop any column that is not included in our list of 11 features\\n # 11 features = 16 features with no dependencies filtered via 20-80% range\\n for col in unfiltered_df:\\n if not unfiltered_df[col].name in features_in_range:\\n unfiltered_df = unfiltered_df.drop(unfiltered_df[col].name, 1)\\n\\n # iterate over the dataframe of columns generated by the range\\n for col in filtered_df:\\n try:\\n # for each column, call groupby() and calculate percentage\\n check_for_20 = unfiltered_df.groupby(col).size().reset_index(name='count')\\n check_for_20['as_percent'] = 100 * check_for_20['count'] / float(total_rows)\\n # ignore feature values that represent less than 20% of all faces\\n cluster_by_feature = check_for_20[check_for_20['as_percent'] >= 20]\\n # if feature has values over 20%, iterate over\\n # each feature_value and generate clusters\\n if not cluster_by_feature.empty:\\n # iterate over every value of the feature\\n for index, row in cluster_by_feature.iterrows():\\n # use feature value to call groupby() on the entire data set\\n results = unfiltered_df[unfiltered_df[col] == row[0]]\\n results = results \\\\\\n .groupby(list(unfiltered_df)) \\\\\\n .size() \\\\\\n .reset_index(name='count')\\n # calculate count as a percentage\\n results['as_percent'] = 100 * results['count'] / float(total_rows)\\n results = results.sort_values(by='as_percent', ascending=False)\\n # store results in a .tsv file\\n filename = str(col) + \\\"_\\\" + str(row[0]) + '_feature_cluster.tsv'\\n results.to_csv(filename.replace(\\\"/\\\", \\\"-\\\"), header=True, sep='\\\\t')\\n print(\\\"results written to file\\\")\\n except:\\n # 'count' and 'percentage' columns will generate errors\\n # since they don't exist in the original data set\\n pass\",\n \"def create_cluster(df,validate, test, X, k, name):\\n \\n scaler = StandardScaler(copy=True).fit(df[X])\\n X_scaled = pd.DataFrame(scaler.transform(df[X]), columns=df[X].columns.values).set_index([df[X].index.values])\\n kmeans = KMeans(n_clusters = k, random_state = 42)\\n kmeans.fit(X_scaled)\\n kmeans.predict(X_scaled)\\n df[name] = kmeans.predict(X_scaled)\\n df[name] = 'cluster_' + df[name].astype(str)\\n \\n v_scaled = pd.DataFrame(scaler.transform(validate[X]), columns=validate[X].columns.values).set_index([validate[X].index.values])\\n validate[name] = kmeans.predict(v_scaled)\\n validate[name] = 'cluster_' + validate[name].astype(str)\\n \\n t_scaled = pd.DataFrame(scaler.transform(test[X]), columns=test[X].columns.values).set_index([test[X].index.values])\\n test[name] = kmeans.predict(t_scaled)\\n test[name] = 'cluster_' + test[name].astype(str)\\n \\n centroids = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=X_scaled.columns)\\n return df, X_scaled, scaler, kmeans, centroids\",\n \"def cluster_kmeans(df, k):\\r\\n # Sample fron the original df\\r\\n sample_df=df.sample(n = k)\\r\\n obs, attr= df.shape\\r\\n # Make copies \\r\\n copy_df=df.copy()\\r\\n flag=0\\r\\n sse_old=0\\r\\n while (flag==0): \\r\\n sse=0\\r\\n Labels=[]\\r\\n for i in range(0, obs):\\r\\n dist= []\\r\\n for j in range(0,k):\\r\\n #Calculate Eucledian distance\\r\\n diff=list((df.iloc[i,:]-sample_df.iloc[j,:])**2)\\r\\n eu_dist=(sum(diff))**(1/attr)\\r\\n dist.append(eu_dist) \\r\\n #Add Labels to the observations based on the variable they are close to\\r\\n label=(dist.index(min(dist)))\\r\\n Labels.append(label)\\r\\n # Calculate SSE\\r\\n sse=sse+((min(dist) )**2)\\r\\n sse=sse**(1/2)\\r\\n copy_df['labels']=Labels\\r\\n # Stopping criteria is change in SSE should be 2 %\\r\\n if (sse_old !=0):\\r\\n if(abs(sse_old-sse)/sse_old<=0.05):\\r\\n flag=1 \\r\\n return_df=copy_df['labels'].to_frame()\\r\\n return (return_df, sse)\\r\\n else:\\r\\n sse_old=sse\\r\\n #Empty the sample df\\r\\n sample_df.drop(sample_df.index, inplace=True)\\r\\n # Now pick random values from each label and add it to the sample df\\r\\n for val in range(0,k):\\r\\n #Create new sample df\\r\\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\\r\\n else:\\r\\n sse_old=sse\\r\\n #Empty the sample df\\r\\n sample_df.drop(sample_df.index, inplace=True)\\r\\n for val in range(0,k):\\r\\n #Create new sample df \\r\\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\",\n \"def cluster(dfi, samples, num_clusters=8, random_state=1):\\n df = dfi.fillna(0)\\n X = df[samples].values\\n kmeans = KMeans(n_clusters=num_clusters,\\n random_state=random_state).fit(X)\\n cluster_number = kmeans.labels_\\n df['kmeans_cluster_number'] = cluster_number\\n return df\",\n \"def compute_cluster_ensemble(var, indicesOnCluster, maxIndices, indicesToParticle): #{{{\\n\\n num_clusters = maxIndices.shape[0]\\n if len(var.shape) == 1:\\n meanvar = np.zeros((num_clusters,))\\n elif len(var.shape) == 2:\\n meanvar = np.zeros((var.shape[0],num_clusters))\\n else:\\n warnings.warn('did not have correct shape for ' + str(var) + ' with len(var.shape)='+ str(len(var.shape)))\\n meanvar = None\\n\\n for aCluster, maxInd in enumerate(maxIndices):\\n # get particles in cluster\\n particles = indicesToParticle[indicesOnCluster[aCluster,0:maxInd]]\\n\\n # compute mean depending upon size of array\\n if len(var.shape) == 1:\\n meanvar[aCluster] = np.mean(var[particles])\\n if len(var.shape) == 2:\\n meanvar[:,aCluster] = np.mean(var[:,particles], axis=1)\\n\\n return meanvar #}}}\",\n \"def get_clusters_with_pca(df_full, df, n_clusters, n_components):\\n pipe = _build_model(df, use_pca=True, n_components=2, use_kmeans=True, n_clusters=n_clusters)\\n df.loc[:, ['PC-1', 'PC-2']] = pipe.named_steps['pca'].transform(df)\\n labels = pipe.named_steps['kmeans'].labels_\\n df.loc[:, 'labels'] = labels\\n df_centers = df.groupby('labels').agg({'PC-1': 'mean', 'PC-2': 'mean'})\\n print(df_centers)\\n\\n df.loc[:, 'Channel'] = df_full['Channel']\\n df.loc[:, 'Channel_str'] = df['Channel'].replace([1, 2], ['Horeca', 'Retail'])\\n plt.figure(8, figsize=(12, 6))\\n for channel in ['Horeca', 'Retail']:\\n plt.scatter(x='PC-1', y='PC-2', data=df[df['Channel_str'] == channel],\\n s=200, alpha=0.5, label=channel)\\n plt.xlabel('PC-1'), plt.ylabel('PC-2')\\n plt.title('PC-1 vs PC-2 concerning Channel')\\n plt.legend()\\n plt.show()\\n\\n plt.figure(9, figsize=(12, 6))\\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 0], s=100, c='red', label='Cluster 1')\\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 1], s=100, c='blue', label='Cluster 2')\\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 2], s=100, c='green', label='Cluster 3')\\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 3], s=100, c='cyan', label='Cluster 4')\\n plt.scatter(x='PC-1', y='PC-2', data=df[df['labels'] == 4], s=100, c='magenta', label='Cluster 5')\\n plt.scatter(df_centers.iloc[:, 0], df_centers.iloc[:, 1],\\n s=100, c='yellow', label='Centroids')\\n plt.title('Clusters of customers')\\n plt.xlabel('Spending in PC-1')\\n plt.ylabel('Spending in PC-2')\\n plt.legend()\\n plt.show()\",\n \"def cluster_stats(df):\\r\\n pattern = list(df.iloc[0])[-2]\\r\\n n_days = len(pattern)\\r\\n \\r\\n cls = [(day + 1, hour) for day in range(n_days) for hour in range(24)]\\r\\n tp = pd.DataFrame(columns = cls)\\r\\n tp.columns = pd.MultiIndex.from_tuples(tp.columns, names = ['day', 'hour'])\\r\\n tp.index.name = 'cluster'\\r\\n \\r\\n for (key, value) in df.groupby('cluster'):\\r\\n d, total = np.zeros((n_days, 24)), len(value)\\r\\n for arr in value.iloc[:, :-2].values:\\r\\n for i, ax in enumerate(np.split(arr, n_days)):\\r\\n ax = np.array([[0, 1][x > 0] for x in ax])\\r\\n d[i] += ax\\r\\n d /= total\\r\\n s = pd.Series({(x + 1, y) : d[x][y] for x in range(n_days) for y in range(24)})\\r\\n s.name = key\\r\\n tp = tp.append(s)\\r\\n \\r\\n tp['pattern'] = [pattern] * len(tp)\\r\\n return tp\",\n \"def cluster_size(result, var):\\n df=calculate_cluster_size(result, var)\\n df['cus']=df.index\\n return df\",\n \"def cluster_distr(adata, cluster_key = 'louvain', batch_key = 'batch', eps = 0.4):\\n\\n from scipy.stats import entropy\\n\\n # check the input\\n if cluster_key not in adata.obs.keys():\\n raise ValueError('The key \\\\'{}\\\\' does not exist in adata.obs'.format(cluster_key))\\n if batch_key not in adata.obs.keys():\\n raise ValueError('The key \\\\'{}\\\\' does not exist in adata.obs'.format(batch_key))\\n\\n # get the clusters and batches\\n clusters = adata.obs[cluster_key].cat.categories\\n batches = adata.obs[batch_key].cat.categories\\n\\n # initialise dataframe\\n batch_distr = pd.DataFrame(index = clusters, columns= 'perc_' + batches)\\n\\n # how many cells are there in total per cluster\\n cells_per_cluster = [np.sum(adata.obs[cluster_key] == cluster) for cluster in clusters]\\n batch_distr['total number'] = cells_per_cluster\\n\\n # loop over the batches\\n for batch in batches:\\n assignment = adata[adata.obs[batch_key] == batch].obs[cluster_key]\\n cells_per_cluster_batch = [np.sum(assignment == cluster) for cluster in clusters]\\n perc = np.round(np.array(cells_per_cluster_batch) / \\\\\\n np.array(cells_per_cluster), 2)\\n batch_distr['perc_' + batch] = perc\\n\\n # compute the entropy\\n en = []\\n for cluster in clusters:\\n data = batch_distr.loc[cluster][list('perc_' + batches)]\\n entropy_cluster = entropy(data)\\n en.append(entropy_cluster)\\n\\n # warn if very small entropy\\n if entropy_cluster <= eps:\\n print('Warning: Cluster {} has a very uneven batch assignment.'.format(cluster))\\n batch_distr['entropy'] = np.round(en, 2)\\n\\n # ideally the proportion n_batch_0/n_batch_1 will be equal to the proportion across batches\\n # a good quality meassure of clustering will be how much the proportion acrros batches deviates from the proportion\\n # of the whole data set\\n b0 = sum(adata.obs[batch_key] == batches[0])\\n b1 = sum(adata.obs[batch_key] == batches[1])\\n prop_ds = b0/b1\\n prop_cluster = batch_distr['perc_' + batches[0]] / batch_distr['perc_' + batches[1]]\\n batch_distr['relative error b0/b1'] = np.round( np.abs(prop_ds - prop_cluster)/prop_ds , 2)\\n\\n\\n\\n return batch_distr\",\n \"def run_split_cluster(cluster_df, keep_df=None, remove_df=None):\\n if keep_df is None:\\n keep_df = pd.DataFrame(columns=cluster_df.columns)\\n if remove_df is None:\\n remove_df = pd.DataFrame(columns=cluster_df.columns)\\n for label, group_df in cluster_df.groupby([\\\"label\\\"]):\\n # only keep the maximum cluster\\n center_count = {center: len(group_df[group_df.center == center]) for center in group_df.center.unique()}\\n max_center = sorted(center_count.items(), key=lambda i: i[1], reverse=True)[0][0]\\n keep_df = keep_df.append(group_df[group_df.center == max_center], ignore_index=True)\\n remove_df = remove_df.append(group_df[group_df.center != max_center], ignore_index=True)\\n return keep_df, remove_df\",\n \"def mean_of_group(gb):\\n if type(gb.get_group(1)) is pd.DataFrame:\\n d = {}\\n for name, df in gb:\\n mean = np.nanmean(df.values)\\n d.update({name: mean})\\n s = pd.Series(d)\\n return s\\n \\n else:\\n items= gb.get_group(1).items\\n d = {key: {} for key in items}\\n for name, p in gb:\\n for i in items:\\n mean = np.nanmean(p[i].values)\\n d[i].update({name: mean})\\n df = pd.DataFrame(d)\\n return df\",\n \"def pseudo_seurat(adata, arg_minpct, arg_mindiffpct, arg_logfcdiff):\\n # define cells\\n cluster_cells_ind = which_ind(adata.obs[\\\"idents\\\"] == \\\"1\\\")\\n other_cells_ind = which_ind(adata.obs[\\\"idents\\\"] == \\\"0\\\")\\n\\n # compute perecentage expressed\\n # from normnalised but not scaled data\\n # remember cells are rows and genes are columns\\n\\n # note: I don't know why norm_counts[cluster_cell_ind:, col_ind] deosn\\\"t work, but it doesn't\\n cluster_pct = (adata.X[cluster_cells_ind, :] > 0).sum(axis=0) / len(cluster_cells_ind)\\n other_pct = (adata.X[other_cells_ind, :] > 0).sum(axis=0) / len(other_cells_ind)\\n\\n pcts = pd.DataFrame(np.vstack((cluster_pct, other_pct)).transpose())\\n max_pct = pcts.max(axis=1)\\n min_pct = pcts.min(axis=1)\\n diff_pct = max_pct - min_pct\\n take_diff_pct = diff_pct > arg_mindiffpct\\n\\n # remove genes that are not expressed higher than 0.1 in one of the groups\\n take_min_pct = max_pct > arg_minpct\\n\\n\\n # KEEP IN CASE NP.ARRAY METHOD USES TOO MUCH MEMORY\\n # import time\\n # this has the potential to be very slow. Transposeing it speeds it up a bit.\\n # I need to understand sparse matrices better to make it work\\n # start = time.time()\\n # nct = adata.X.T[:,cluster_cells_ind]\\n # cluster_mean0 = [exp_mean_sparse(nct[x,:]) for x in range(0,nct.shape[0])]\\n # end = time.time()\\n # print(end - start)\\n #\\n # start = time.time()\\n # nct = adata.X.T[:, other_cells_ind]\\n # other_mean0 = [exp_mean_sparse(nct[x,:]) for x in range(0, nct.shape[0])]\\n # end = time.time()\\n # print(end - start)\\n\\n # extract the counts for cluster cells and calculate exp means on each row\\n nct = adata.X.T[:, cluster_cells_ind]\\n cluster_mean = np.apply_along_axis(exp_mean_dense, 1, nct.todense())\\n\\n # likewise for non-cluster cells\\n nct = adata.X.T[:, other_cells_ind]\\n other_mean = np.apply_along_axis(exp_mean_dense, 1, nct.todense())\\n diff_mean = abs(cluster_mean - other_mean)\\n\\n # remove genes with less than threshold difference\\n take_thresh = diff_mean > arg_logfcdiff\\n # take = if a cell passes all the tests then it is to be kept.\\n take = [a and b and c for a, b, c in zip(take_thresh, take_min_pct, take_diff_pct)]\\n print(\\\"saving universe for fisher test\\\")\\n stats_df = pd.DataFrame(np.vstack((adata.var_names, cluster_mean, other_mean, diff_mean,\\n cluster_pct, other_pct, max_pct, min_pct, diff_pct, take)).transpose(),\\n columns=[\\\"gene\\\", \\\"cluster_mean\\\", \\\"other_mean\\\", \\\"diff_mean\\\",\\n \\\"cluster_pct\\\", \\\"other_pct\\\",\\n \\\"max_pct\\\", \\\"min_pct\\\", \\\"diff_pct\\\", \\\"background\\\"])\\n return stats_df\",\n \"def make_df_averaged_across_replicates(self, df, scheme):\\n\\n by_prot = collections.defaultdict(list)\\n for col in self.positives.numeric_columns(df):\\n prot = scheme.gene_from_fname(col)\\n by_prot[prot].append(df[col].values)\\n\\n for prot in by_prot:\\n arrs = by_prot[prot]\\n n = len(by_prot[prot])\\n by_prot[prot] = np.sum(arrs, axis=0)/n\\n\\n by_prot['gene_name'] = df['gene_name']\\n by_prot['Gene type'] = df['Gene type']\\n _df = pandas.DataFrame(by_prot)\\n _df.index = _df['gene_name']\\n return _df\",\n \"def predictClusters(self, df, k):\\n self.models.fitModels(df)\\n return self.models.predict()\",\n \"def generate_clusters(df):\\n\\n df_size = df.shape[0]\\n print(df_size)\\n n_clusters = 0\\n percent_min_pts = 0.105\\n min_clusters = 3\\n while (n_clusters != min_clusters):\\n print(\\\"percent_min_pts\\\", percent_min_pts)\\n min_cluster_pts = math.floor(df_size * percent_min_pts)\\n print(\\\"min_cluster_pts\\\", min_cluster_pts)\\n\\n clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_pts)\\n print(df.head())\\n clusterer.fit(df)\\n cluster_groups = {}\\n labels = clusterer.labels_\\n for i in labels:\\n if cluster_groups.get(i):\\n cluster_groups[i] = cluster_groups[i] + 1\\n else:\\n cluster_groups[i] = 1\\n print(\\\"cluster_groups\\\", cluster_groups)\\n n_clusters = len(set(labels))\\n print(\\\"n_clusters\\\", n_clusters)\\n multiplier = abs(n_clusters - min_clusters) * 0.001\\n print(\\\"multiplier\\\", multiplier)\\n if n_clusters > min_clusters:\\n percent_min_pts += multiplier\\n else:\\n percent_min_pts -= multiplier\\n print(\\\"percent_min_pts\\\", percent_min_pts)\\n return labels\",\n \"def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\\n learning_rate=0.01):\\n\\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\\n random_seed=0)\\n som.train(df_train, n_iter)\\n\\n # converting numpy arrays to dataframes\\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\\n\\n # creating column with cluster basing on model prediction\\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\\n\\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\\n # the script\\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\\n lsuffix='_org')\\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\\n lsuffix='_org')\\n\\n return final_df_train, final_df_test\",\n \"def pca_and_cluster(\\n df: pd.DataFrame,\\n columns: str,\\n n_components: Union[int, None],\\n n_clusters: Union[int, None],\\n keep: bool = False\\n) -> pd.DataFrame:\\n col_id = columns.upper()\\n print(\\\"Executing dimension reduction (pca + kmean) on {}* features...\\\".format(col_id))\\n selected_columns = [x for x in df.columns if x.startswith(col_id)]\\n print(\\\"Number of corresponding columns before processing: {}\\\".format(len(selected_columns)))\\n for col in selected_columns:\\n # Fill Nans with -2. Tentative.\\n df[col].fillna((df[col].min() - 2), inplace=True)\\n df[col] = preprocessing.minmax_scale(df[col], feature_range=(0, 1))\\n df = PCA_reduction(df, selected_columns, prefix=\\\"PCA_{}_\\\".format(col_id), n_components=n_components, keep=keep)\\n\\n # Apply kmeans on PCA columns\\n print(\\\"Executing k-means on dataset...\\\")\\n s = \\\"PCA_{}_\\\".format(col_id)\\n pca_columns = [x for x in df.columns if x.startswith(s)]\\n kmean = cluster.KMeans(n_clusters=n_clusters)\\n kmean_fit = kmean.fit(df[pca_columns])\\n df[\\\"cluster_{}\\\".format(col_id)] = kmean_fit.predict(df[pca_columns])\\n # predicted_indices = kmean_fit.predict(df[pca_columns])\\n # df[\\\"cluster_{}\\\".format(col_id)] = kmean_fit.cluster_centers_[predicted_indices]\\n return df\",\n \"def compute_means(self):\\n ###TODO\\n vector_means = []\\n for doc in self.fin_clust.values():\\n vec = defaultdict(float)\\n for d_id in doc:\\n doc_keys = self.docs[d_id].keys()\\n for key in self.docs[d_id]:\\n vec[key] = vec[key] + self.docs[d_id][key]\\n tot = len(doc)\\n x = defaultdict(float)\\n for k,v in vec.items():\\n x[k] = float(v)/tot\\n vec = Counter(x)\\n vector_means.append(vec)\\n return vector_means\",\n \"def compute_clusters(addons_df, num_clusters, random_seed):\\n\\n # Build the stages of the pipeline. We need hashing to make the next\\n # steps work.\\n hashing_stage = HashingTF(inputCol=\\\"addon_ids\\\", outputCol=\\\"hashed_features\\\")\\n idf_stage = IDF(inputCol=\\\"hashed_features\\\", outputCol=\\\"features\\\", minDocFreq=1)\\n # As a future improvement, we may add a sane value for the minimum cluster size\\n # to BisectingKMeans (e.g. minDivisibleClusterSize). For now, just make sure\\n # to pass along the random seed if needed for tests.\\n kmeans_kwargs = {\\\"seed\\\": random_seed} if random_seed else {}\\n bkmeans_stage = BisectingKMeans(k=num_clusters, **kmeans_kwargs)\\n pipeline = Pipeline(stages=[hashing_stage, idf_stage, bkmeans_stage])\\n\\n # Run the pipeline and compute the results.\\n model = pipeline.fit(addons_df)\\n return model.transform(addons_df).select([\\\"client_id\\\", \\\"prediction\\\"])\",\n \"def cluster_membership_occupancy(data):\\n \\n \\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n\\n if n_clusters == 0:\\n membership=[Cluster_Membership_Features()]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n areas=[Cluster_Area_Features()]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features()]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n \\n elif n_clusters ==1:\\n #obtain_total_cluster_areas_set_everything_else_to_default\\n membership=[Cluster_Membership_Features()]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n \\n try:\\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\\n except:\\n cluster_chull_areas=[0,0,0]\\n \\n Total_cluster_area=np.sum(cluster_chull_areas)\\n areas=[Cluster_Area_Features([Total_cluster_area,0,0,0,0,0,0,0,0])]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features()]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n \\n elif n_clusters >1:\\n #Summarizing the cluster membership distribution characteristics\\n cluster_size_nums=np.delete(np.array(data.groupby(['clusters']).size()),0)\\n (cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD)= distribution_statistics(cluster_size_nums)\\n\\n #For each cluster calculate the area by calculating the area of the convex hull of cluster members\\n # Note: concavehull implementation here might be a good addition as it will provide more imformative values. \\n\\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n try:\\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\\n except:\\n cluster_chull_areas=[0,0,0,0,0]\\n \\n\\n (avg_cluster_area,min_cluster_area,max_cluster_area,\\n std_cluster_area,CV_cluster_area,CD_cluster_area,\\n IQR_cluster_area,Quartile_CD_cluster_area)= distribution_statistics(cluster_chull_areas)\\n Total_cluster_area=np.sum(cluster_chull_areas)\\n\\n #Calculate cluster density: number of nuclei/ convex area of cluster\\n cluster_density=np.divide(cluster_size_nums,cluster_chull_areas)\\n (avg_cluster_density,min_cluster_density,max_cluster_density,\\n std_cluster_density,CV_cluster_density,CD_cluster_density,\\n IQR_cluster_density,Quartile_CD_cluster_density)= distribution_statistics(cluster_density)\\n\\n #return dataframe of features\\n membership=[Cluster_Membership_Features([cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD])]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n areas=[Cluster_Area_Features([Total_cluster_area,\\n avg_cluster_area,min_cluster_area,max_cluster_area,\\n std_cluster_area,CV_cluster_area,CD_cluster_area,\\n IQR_cluster_area,Quartile_CD_cluster_area])]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features([avg_cluster_density,min_cluster_density,max_cluster_density,\\n std_cluster_density,CV_cluster_density,CD_cluster_density,\\n IQR_cluster_density,Quartile_CD_cluster_density])]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n return all_features\",\n \"def get_avg_score(df, score):\\n avg_score = (df.groupby(['condition', 'gene_a', 'gene_b'])\\n .agg({score: 'mean'})\\n .reset_index())\\n return avg_score\",\n \"def add_cluster_to_ratings(user_df):\\n # Read in ratings file\\n #Get ratings file - create Spark instance for loading JSON\\n spark = pyspark.sql.SparkSession.builder.getOrCreate()\\n sc = spark.sparkContext\\n ratings_df = spark.read.json('data/ratings.json').toPandas()\\n \\n # Set up clusters\\n cluster_dict = {}\\n for k, v in zip(user_df['id'].tolist(), user_df['cluster'].tolist()):\\n cluster_dict[k] = v\\n \\n # Add cluster to ratings\\n ratings_df['cluster'] = ratings_df['user_id'].apply(lambda x: cluster_dict[x])\\n \\n return ratings_df\",\n \"def create_sigma_df(df_grouped, class_=0):\\n sigma_all_list = []\\n sigma_peak_list = []\\n snid_list = []\\n pred_class_list = []\\n for SNID, SNID_df in df_grouped:\\n arr_proba = SNID_df[f\\\"all_class{class_}\\\"]\\n perc_16 = np.percentile(arr_proba, 16)\\n perc_84 = np.percentile(arr_proba, 84)\\n sigma_all_list.append(perc_84 - perc_16)\\n\\n arr_proba = SNID_df[f\\\"PEAKMJD_class{class_}\\\"]\\n perc_16 = np.percentile(arr_proba, 16)\\n perc_84 = np.percentile(arr_proba, 84)\\n sigma_peak_list.append(perc_84 - perc_16)\\n snid_list.append(SNID)\\n\\n # get predicition for this SNID\\n k_all_probas = [k for k in SNID_df.keys() if \\\"all_class\\\" in k]\\n median_prob_forSNID = SNID_df[k_all_probas].median()\\n pred_class = median_prob_forSNID.idxmax()\\n arr_proba = SNID_df[pred_class]\\n # get sigma for this class\\n perc_16 = np.percentile(arr_proba, 16)\\n perc_84 = np.percentile(arr_proba, 84)\\n pred_class_list.append(perc_84 - perc_16)\\n\\n df = pd.DataFrame()\\n df[\\\"SNID\\\"] = np.array(snid_list)\\n df[\\\"sigma_all\\\"] = np.array(sigma_all_list)\\n df[\\\"sigma_peak\\\"] = np.array(sigma_peak_list)\\n df[\\\"pred_sigma_all\\\"] = np.array(pred_class_list)\\n return df\",\n \"def get_cluster_assignments(self, data, n_clusters=10):\\n kmeans = KMeans(n_clusters=n_clusters)\\n kmeans.fit(data)\\n pred = kmeans.predict(data)\\n return pd.DataFrame(pred)\",\n \"def avg_tx_fees_BTC(df):\\n result = df['Tx fees (BTC)'].div(df['Txs'])\\n result.name = 'Avg Tx Fees (BTC)'\\n return out(SETTINGS, df, result)\",\n \"def get_clusters(df, allow_unassigned, variance_coefficient, letters):\\n\\n logging.info('Calculating cluster assignments')\\n\\n # Calculate minimum thresholds to call cluster assignments.\\n\\n min_thresholds = pd.Series(np.tile(1e-6, df.shape[1]), index=df.columns)\\n\\n if allow_unassigned:\\n\\n # Estimate the variance for each factor by fixing the MLE estimate of\\n # the mean to 0.\\n\\n min_thresholds = df.apply(\\n get_mle_variance, mean=0).apply(np.sqrt) * variance_coefficient\\n\\n unassigned_mask = (df >= min_thresholds).sum(axis=1) < 1\\n\\n result = df.apply(pd.Series.argmax, axis=1)\\n\\n # Apply letters if required.\\n\\n if letters:\\n\\n result = (\\n result.astype(int) - 1).apply(string.ascii_uppercase.__getitem__)\\n\\n # Set unassigned patients.\\n\\n result.loc[unassigned_mask] = 0\\n\\n return result\",\n \"def mean_rate(df):\\n mean_of_rate = dict(df.mean())\\n return mean_of_rate\",\n \"def clust_strength(mat,groups):\\n cluster_strengths = []\\n for group in range(len(np.unique(groups))):\\n this_cluster = mat[groups==group,:]\\n this_cluster_mean = np.mean(this_cluster,axis=0)\\n all_dists = mat - this_cluster_mean\\n out_dists = np.linalg.norm(all_dists[groups!=group],axis=1)\\n in_dists = np.linalg.norm(all_dists[groups==group],axis=1)\\n this_strength = np.mean(out_dists)/np.mean(in_dists)\\n cluster_strengths.append(this_strength)\\n \\n return np.mean(cluster_strengths)\",\n \"def cluster_cal(self):\\n self.Cluster = []\\n for i in range(self.nodenum):\\n neighborhood_node = self.neighbor_node(i)\\n Node_num = len(neighborhood_node)\\n Count = self.neighbor_edge(neighborhood_node)\\n if(Node_num == 0 or Node_num == 1):\\n self.Cluster.append(0.5)\\n else:\\n self.Cluster.append(Count/(Node_num*(Node_num - 1)))\\n \\n self.cluster_coeff = np.average(self.Cluster)\",\n \"def get_feature_weights(df, pca, cluster, columns):\\r\\n feature_weights = df.inverse_transform(pca.cluster_centers_[cluster-1])\\r\\n\\r\\n return pd.Series(feature_weights, index=columns).sort_values()\",\n \"def GLM_cluster_de_test_multi(df, y, n_processes=None):\\n table = []\\n with Pool(n_processes) as workers:\\n\\n for r in workers.imap_unordered(pool_wrapper,((\\n\\n _GLM_cluster_de_test_single_gene\\n ,{\\n 'gene':gene,\\n 'cuts_frame':df,\\n 'clusters':y\\n }\\n )\\n for gene in df\\n ), chunksize=200):\\n if r is None:\\n continue\\n\\n (gene, f_score, p_value, coeff, model, null_model) = r\\n table.append([gene,f_score,p_value, coeff['model_std_err']['cluster'], coeff['model_coefficients']['cluster']])\\n\\n\\n return pd.DataFrame(table, columns=['gene','f_score','p_value','cluster_stderr','cluster_coeff'])\",\n \"def assign_to_current_mean(img: np.ndarray, clustermask: np.ndarray) -> float:\\n\\n rows, cols = img.shape[:2]\\n distances = np.zeros((numclusters, 1))\\n overall_dist = 0\\n\\n for i in range(rows):\\n for j in range(cols):\\n distances = distance(img[i, j, :]) # returned shape: (numclusters, 1)\\n \\n k = np.argmin(distances) # closest cluster\\n clustermask.itemset((i, j), k) # update cluster mask\\n overall_dist += distances[k, 0] # sum distance\\n\\n return overall_dist\",\n \"def avg_tx_fees_USD(df):\\n result = df['Tx fees (USD)'].div(df['Txs'])\\n result.name = 'Avg Tx Fees (USD)'\\n return out(SETTINGS, df, result)\",\n \"def computeMeans(X, idx, K):\\n\\tm, n = X.shape\\n\\tcentroids = np.zeros((K, n))\\n\\tcount = np.zeros(K)\\n\\n\\tfor j in range(m):\\n\\t\\tcentroids[int(idx[j])] += X[j]\\n\\n\\tfor i in range(m):\\n\\t\\tcount[int(idx[i])] += 1\\n\\n\\treturn centroids / np.tile(count.reshape((K, 1)), n)\",\n \"def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\\n res = []\\n for n_clusters in n_clusters_considered:\\n res.append([])\\n for _ in range(n_repeats):\\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\\n print(X.val.shape)\\n print(X_restricted.val.shape)\\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\\n res[-1].append(evaluator_X.weighted_average) \\n return res\",\n \"def mean(dfs):\\n df_mean = sum(dfs)\\n return df_mean/len(dfs)\",\n \"def mean_cluster(gene_info, grouping, modality='ATAC'):\\n\\n\\t# if grouping == 'annotation':\\n\\t# \\tgene_info.fillna({'annotation_'+modality: 'None'}, inplace=True)\\n\\t# if grouping != 'dataset':\\n\\t# \\treturn gene_info.groupby(grouping+'_'+modality, sort=False)['normalized_counts'].mean()\\n\\t# else:\\n\\t# \\treturn gene_info.groupby(grouping, sort=False)['normalized_counts'].mean()\\n\\n\\tif grouping == 'annotation':\\n\\t\\tgene_info.fillna({'annotation_'+modality: 'None'}, inplace=True)\\n\\t\\treturn gene_info.groupby('annotation_'+modality, sort=False)['normalized_counts'].mean()\\n\\telif grouping == 'cluster':\\n\\t\\treturn gene_info.groupby('cluster_'+modality, sort=False)['normalized_counts'].mean()\\n\\telif grouping == 'dataset':\\n\\t\\treturn gene_info.groupby('dataset', sort=False)['normalized_counts'].mean()\\n\\telif grouping == 'target_region':\\n\\t\\tgene_info['target_region'].fillna('N/A', inplace=True)\\n\\t\\treturn gene_info.groupby('target_region', sort=False)['normalized_counts'].mean()\\n\\telse:\\n\\t\\treturn None\",\n \"def _mean_of_monthly_means_basic_method(df: pd.DataFrame) -> pd.DataFrame:\\n monthly_df: pd.DataFrame = df.groupby(df.index.month).mean().mean().to_frame()\\n monthly_df.columns = ['MOMM']\\n return monthly_df\",\n \"def k_means_montage(self, df, class_col):\\n\\n n_classes = df[class_col].nunique()\\n for cl in sorted(df[class_col].unique()):\\n montage_df = df[df[class_col] == cl].path\\n imgs = [np.array(Image.open(img)) for img in montage_df]\\n imgs = np.stack(imgs)\\n plt.figure(figsize=(12, 15))\\n plt.imshow(montage(imgs, multichannel=True).astype(np.uint8))\\n plt.title(f\\\"Montage for Class{cl}\\\")\",\n \"def pred_agg1_train(df):\\n new_feats = []\\n pred_cols = [column for column in df.columns if \\\"pred\\\" in column]\\n for c in pred_cols:\\n tmp = (\\n df.groupby([\\\"StudyInstanceUID\\\"])[c]\\n .agg([\\\"min\\\", \\\"max\\\", \\\"mean\\\", \\\"std\\\"])\\n .reset_index()\\n )\\n tmp.columns = [\\n \\\"StudyInstanceUID\\\",\\n c + \\\"_min\\\",\\n c + \\\"_max\\\",\\n c + \\\"_mean\\\",\\n c + \\\"_std\\\",\\n ]\\n if c != \\\"any_pred_model_base\\\":\\n del tmp[\\\"StudyInstanceUID\\\"]\\n new_feats.append(tmp)\\n new_feats = pd.concat(new_feats, axis=1)\\n df = pd.merge(df, new_feats, on=\\\"StudyInstanceUID\\\", how=\\\"left\\\")\\n for c in pred_cols:\\n df[c + \\\"_diff\\\"] = df[c] - df[c + \\\"_mean\\\"]\\n df[c + \\\"_div\\\"] = df[c] / df[c + \\\"_mean\\\"]\\n df[c + \\\"_scaled\\\"] = (df[c] - df[c + \\\"_mean\\\"]) / df[c + \\\"_std\\\"]\\n return df\",\n \"def _avg_cluster_hitprobability(self, x, y, n_clusters=30):\\n\\n # Compute the individual Hit probability\\n proba = self._shufflesplit(x, y)\\n\\n # average the individual hit probability for each cluster\\n ind = self._cluster(x, x.shape[0]/2.)\\n\\n avg_proba = np.copy(proba)\\n\\n for cluster in np.unique(ind):\\n mask_ = ind == cluster\\n avg_proba[mask_] = avg_proba[mask_].mean()\\n\\n return avg_proba\",\n \"def cluster_centroids(self,mydata, clusters, k=None):\\n\\t\\tif k is None:\\n\\t\\t\\tk = np.max(clusters) + 1\\n\\t\\tresult = np.empty(shape=(k,) + mydata.shape[1:])\\n\\t\\tfor i in range(k):\\n\\t\\t\\tnp.mean(mydata[clusters == i], axis=0, out=result[i])\\n\\t\\treturn result\",\n \"def get_cold_start_rating(user_id, movie_id, user_df, u_clusters, ratings_df):\\n\\n # Load files \\n #user_df = pd.read_csv('data/user_cluster.csv', index_col=0) \\n #u_clusters = pd.read_csv('data/u_info.csv', index_col=0)\\n #ratings_df = pd.read_csv('data/movie_cluster_avg.csv', index_col=0)\\n \\n # User Cluster\\n user_cluster = u_clusters.loc[u_clusters['id'] == user_id]['cluster'].tolist()[0]\\n \\n # Get score components\\n if len(ratings_df.loc[(ratings_df['cluster'] == user_cluster) & (ratings_df['movie_id'] == movie_id)]) > 0:\\n# if (movie_id in ratings_df['movie_id'].tolist()):\\n avg = ratings_df.loc[(ratings_df['cluster'] == user_cluster) & (ratings_df['movie_id'] == movie_id)]['rating'].tolist()\\n else:\\n cluster_rating = ratings_df.loc[ratings_df['cluster'] == user_cluster]['rating'].tolist()\\n avg = sum(cluster_rating)/len(cluster_rating)\\n if user_id in user_df['user_id'].tolist():\\n u = user_bias(user_df, user_id)\\n i = item_bias(user_df, movie_id)\\n pred_rating = avg + u + i\\n else:\\n pred_rating = avg\\n \\n return pred_rating\",\n \"def cont_feature_clusters_sklearn(self, n_clusters = 5): \\n \\n #Import the library\\n from sklearn.cluster import FeatureAgglomeration\\n \\n Cluster = FeatureAgglomeration(n_clusters=n_clusters)\\n Cluster.fit(self._dataset.iloc[:,self._cont_index_predictors])\\n \\n df = pd.DataFrame({'Variable':self._dataset.columns[self._cont_index_predictors], 'Cluster':Cluster.labels_})\\n \\n return df.sort_values(by='Cluster')\",\n \"def feat_imp_MDI_clustered(fit, feat_names, clstrs):\\n df0 = {i:tree.feature_importances_ for i, tree in enumerate(fit.estimators_)}\\n df0 = pd.DataFrame.from_dict(df0, orient='index')\\n df0.columns = feat_names\\n df0 = df0.replace(0, np.nan) #because max_features=1\\n imp = group_mean_std(df0, clstrs)\\n imp /= imp['mean'].sum()\\n return imp\",\n \"def gen_clust_summ_agg(proj, map_dict, proj_data, comp='slope'):\\n err_dict = rank_err(proj_data, map_dict)\\n assert (comp in err_dict.keys()), 'missing comp in errdict: {}'.format(comp)\\n err_diff = err_dict[comp]-err_dict['rbf']\\n df_clust_sum = pd.DataFrame(zip(map_dict['rbf'].z, err_diff[:,0], proj_data['SI']), columns=['rbf_clust_num', 'err_diff', 'SI'])\\n df_cluster_aggregate = df_clust_sum.groupby('rbf_clust_num')[['err_diff']].mean().join(df_clust_sum['rbf_clust_num'].value_counts())\\n df_cluster_aggregate.sort_values('err_diff', ascending=False, inplace=True)\\n \\n return df_cluster_aggregate\",\n \"def mean_payoffs(dist,benefit_function,b,c,*params):\\n dist['A_pay'] = (b*benefit_function(dist.j+1,dist.k+1,*params)-c)*dist.A\\n dist['B_pay'] = (b*benefit_function(dist.j,dist.k+1,*params))*dist.B\\n return dist.groupby('n')[['A_pay','B_pay']].sum()\",\n \"def compute_centers(points, labels):\\n df = pd.DataFrame(points)\\n return df.groupby(labels).mean().values\",\n \"def clustering_pc(df):\\n nb_clusters = 5\\n kmeans = KMeans(n_clusters=nb_clusters, random_state=0).fit(df)\\n labels = pd.DataFrame(kmeans.labels_,columns=['labels'], index=df.index)\\n df_values_labels = pd.concat([df,labels],axis=1,join='outer')\\n\\n palette = ['#e41a1c', '#377eb8', '#4eae4b',\\n '#994fa1', '#ff8101', '#fdfc33',\\n '#a8572c', '#f482be', '#999999']\\n return labels, kmeans.cluster_centers_\",\n \"def get_mean(self):\\n average = self.df[self.col_name].mean()\\n return average\",\n \"def findK_centroids_average(self, features, clusters):\\n\\n class InnerFeatures:\\n def __init__(self, kps, des, pos):\\n self.kps = kps\\n self.des = des\\n self.pos = pos\\n\\n kmeans = KMeans(n_clusters=clusters)\\n\\n pts = np.array(features.pos)\\n kps = np.array(features.kps)\\n des = np.array(features.des)\\n\\n kmeans.fit(pts)\\n m_clusters = np.array(kmeans.labels_.tolist())\\n centers = np.array(kmeans.cluster_centers_)\\n\\n # KeyPoint(x,y,size) -required\\n\\n final_kps = []\\n final_des = []\\n final_pts = []\\n\\n for cluster in range(clusters):\\n indices = np.where(m_clusters == cluster)\\n cluster_kps_size = np.mean(np.array([x.size for x in kps[indices]]))\\n cluster_des = des[indices]\\n\\n average_des = np.mean(cluster_des, axis=0)\\n cluster_kps = cv2.KeyPoint(x=centers[cluster][0], y=centers[cluster][1], _size=cluster_kps_size)\\n\\n final_kps.append(cluster_kps)\\n final_des.append(average_des)\\n final_pts.append([centers[cluster][0], centers[cluster][1]])\\n\\n final_pts = np.array(final_pts)\\n final_des = np.array(final_des)\\n final_kps = np.array(final_kps)\\n\\n result = InnerFeatures(kps=final_kps, des=final_des, pos=final_pts)\\n return result\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def GLM_cluster_de_test(cuts_frame, clusters):\\n\\n table = []\\n for gene in cuts_frame.columns:\\n\\n r = _GLM_cluster_de_test_single_gene(gene, 1+cuts_frame, clusters)\\n\\n if r is None:\\n continue\\n\\n (gene, f_score, p_value, coeff, model, null_model) = r\\n table.append([gene,f_score,p_value, coeff['model_std_err']['cluster'], coeff['model_coefficients']['cluster']])\\n\\n return pd.DataFrame(table, columns=['gene','f_score','p_value','cluster_stderr','cluster_coeff'])\",\n \"def select_cluster(self, clusters):\\n min_sim = float(\\\"inf\\\")\\n min_cluster = None\\n \\n for cluster in clusters:\\n sim = 0.0\\n for index, value in cluster.centroid.items():\\n sim += value * value\\n \\n if sim < min_sim:\\n min_sim = sim\\n min_cluster = cluster\\n \\n return min_cluster\",\n \"def update_mean(img: np.ndarray, clustermask: np.ndarray):\\n\\n for k in range(numclusters):\\n current_cluster_centers[k, 0, :] = np.mean(img[clustermask==k], axis=0)\",\n \"def evaulate_clusters(self, pred_dict, model_dir):\\n\\t\\tclustering_dict = {\\\"Topic\\\":[], \\\"Text\\\":[], \\\"Keywords\\\": []}\\n\\t\\tfor cluster_num, sents_list in pred_dict.items():\\n\\t\\t\\tprint(\\\"\\\\n cluster number : \\\", cluster_num)\\n\\t\\t\\tprint(\\\"\\\\n number of sents : \\\", len(sents_list))\\n\\t\\t\\ttfidf_vec = TfidfVectorizer(use_idf=True, sublinear_tf=True, max_df=0.8, max_features=20, ngram_range=(1,5), min_df=1)\\n\\t\\t\\tX_tfidf = tfidf_vec.fit_transform(sents_list).toarray()\\n\\t\\t\\ttotal_tfidf = tfidf_vec.get_feature_names()\\n\\t\\t\\tfor sent in sents_list:\\n\\t\\t\\t\\tclustering_dict[\\\"Topic\\\"].append(cluster_num)\\n\\t\\t\\t\\tclustering_dict[\\\"Text\\\"].append(sent)\\n\\t\\t\\t\\tclustering_dict[\\\"Keywords\\\"].append(\\\",\\\".join(total_tfidf))\\n\\t\\t\\\"\\\"\\\" save the clusters to csv file \\\"\\\"\\\"\\n\\t\\tdf_dominant_topic = defaultdict(list) \\n\\t\\tdf_dominant_topic[\\\"Topic\\\"] = clustering_dict[\\\"Topic\\\"]\\n\\t\\tdf_dominant_topic[\\\"Text\\\"] = clustering_dict[\\\"Text\\\"]\\n\\t\\tdf_dominant_topic[\\\"Keywords\\\"] = clustering_dict[\\\"Keywords\\\"]\\n\\t\\tdf_dominant_topic = pd.DataFrame(df_dominant_topic)\\n\\t\\tdf_dominant_topic.to_csv(os.path.join(model_dir, \\\"cluster_sentence_topic_mapping.csv\\\"))\\n\\t\\treturn df_dominant_topic\",\n \"def means_and_pval(self, means, df):\\n list = np.arange(len(df))\\n for i, (key, item) in zip(list, df):\\n res = self.mcnemar(item)\\n means.loc[means.index[i], \\\"p_value\\\"] = res[\\\"results\\\"][1]\\n return means\",\n \"def slg_average(df,start_year,end_year,bat_met,player_name):\\n base_fields = ['AB','HR','X3B','X2B','SLG']\\n emp_list = check_base_fields(df,base_fields)\\n\\n if not emp_list:\\n df['X1B'] = round(df['SLG']*df['AB'] - (4*df['HR'] + 3*df['X3B'] + 2*df['X2B']),0)\\n return round((df['X1B'].sum(axis = 0) + df['X2B'].sum(axis = 0) * 2 + df['X3B'].sum(axis = 0) * 3 + df['HR'].sum(axis = 0) * 4) / df['AB'].sum(axis = 0),3)\\n\\n else:\\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\\n df['X1B'] = round(df['SLG']*df['AB'] - (4*df['HR'] + 3*df['X3B'] + 2*df['X2B']),0)\\n SLG = round((df['X1B'].sum(axis = 0) + df['X2B'].sum(axis = 0) * 2 + df['X3B'].sum(axis = 0) * 3 + df['HR'].sum(axis = 0) * 4) / df['AB'].sum(axis = 0),3)\\n del df['X1B']\\n return SLG\",\n \"def find_mean_max_min(df, count_columns: dict, group_columns = ['Fabric_name', 'Fabric_label']):\\n \\n summary_df = pd.DataFrame()\\n for count_column, rename_column in count_columns.items():\\n current_df = df.groupby(by = group_columns)[count_column].agg(['mean', 'max', 'min'])\\n current_df['mean'] = current_df['mean'].round(1)\\n rename_dct = {}\\n for column in current_df.columns:\\n rename_dct[column] = rename_column + '_' + column\\n current_df.rename(columns=rename_dct, inplace=True)\\n current_df.reset_index(inplace=True)\\n if summary_df.empty:\\n summary_df = current_df.copy()\\n else:\\n summary_df = summary_df.merge(current_df, how='outer', on=group_columns) \\n return summary_df\",\n \"def strategy_returns(df, df_price_of_strategy):\\r\\n df_return_of_strategy = pd.DataFrame(index=df_price_of_strategy.index)\\r\\n cols = df_price_of_strategy.columns\\r\\n\\r\\n for priceSeries in cols:\\r\\n df_return_of_strategy[priceSeries] = (df_price_of_strategy[priceSeries]\\r\\n - df_price_of_strategy[priceSeries].shift()) / (\\r\\n df_price_of_strategy[priceSeries])\\r\\n\\r\\n return df_return_of_strategy\",\n \"def strategy_returns(df, df_price_of_strategy):\\r\\n df_return_of_strategy = pd.DataFrame(index=df_price_of_strategy.index)\\r\\n cols = df_price_of_strategy.columns\\r\\n\\r\\n for priceSeries in cols:\\r\\n df_return_of_strategy[priceSeries] = (df_price_of_strategy[priceSeries]\\r\\n - df_price_of_strategy[priceSeries].shift()) / (\\r\\n df_price_of_strategy[priceSeries])\\r\\n\\r\\n return df_return_of_strategy\",\n \"def fit(self):\\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\\n self.merge_clusters([[6,33,52],[17,14]])\\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\\n self.merge_clusters([[6,98,99]])\\n self.merge_clusters([[35,80]])\\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[76,98]])\\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[39,42]])\\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\\n self.merge_clusters([[70,101]])\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\\n self.merge_clusters()\\n return\",\n \"def fit(self, df):\\n self.center = df.tail(self.rows).mean()\\n self.center = self.center.replace(0, np.nan)\\n if self.center.isnull().any():\\n surrogate = df.replace(0, np.nan).median().fillna(1)\\n self.center = self.center.fillna(surrogate)\\n return self\",\n \"def _GLM_cluster_de_test_single_gene(gene, cuts_frame, clusters):\\n\\n data = copy(cuts_frame[[gene]])+1\\n data.columns = ['ncuts']\\n data['plate'] = [x.split('_')[0] for x in data.index]\\n data['cluster'] = clusters\\n data['n_total_cuts'] = cuts_frame.sum(1)\\n\\n\\n fam = sm.families.Poisson()\\n try:\\n model = smf.glm(\\\"ncuts ~ 1 + plate + cluster\\\", data= data,\\n # cov_struct=ind,\\n offset=np.log(data['n_total_cuts']),\\n family=fam).fit()\\n\\n null_model = smf.glm(f\\\"ncuts ~ 1 + plate\\\", data= data,\\n # cov_struct=ind,\\n offset=np.log(data['n_total_cuts']),\\n family=fam).fit()\\n except Exception as e:\\n if 'estimation infeasible.' in str(e) or 'PerfectSeparationError' in str(e) :\\n return None\\n else:\\n raise\\n\\n coeff = pd.DataFrame( {'model_std_err':model.bse,\\n 'model_coefficients':model.params,\\n 'null_std_err':null_model.bse,\\n 'null_coefficients':null_model.params,\\n\\n })\\n\\n return [gene, *calculate_nested_f_statistic(null_model,model), coeff, model, null_model]\",\n \"def update_avg_f1(ccs, gold_clusters, pred_clusters):\\n gold_clusters, mention_to_gold = ccs.get_gold_clusters(gold_clusters)\\n pred_clusters, mention_to_pred = ccs.get_gold_clusters(pred_clusters)\\n\\n # update scores\\n scorers = ccs.scorers\\n\\n for scorer in scorers:\\n scorer.update(pred_clusters, gold_clusters,\\n mention_to_pred, mention_to_gold)\",\n \"def merge_clusters(self, other_cluster):\\n if len(other_cluster.fips_codes()) == 0:\\n return self\\n else:\\n self._fips_codes.update(set(other_cluster.fips_codes()))\\n \\n # compute weights for averaging\\n self_weight = float(self._total_population) \\n other_weight = float(other_cluster.total_population())\\n self._total_population = self._total_population + other_cluster.total_population()\\n self_weight /= self._total_population\\n other_weight /= self._total_population\\n \\n # update center and risk using weights\\n self._vert_center = self_weight * self._vert_center + other_weight * other_cluster.vert_center()\\n self._horiz_center = self_weight * self._horiz_center + other_weight * other_cluster.horiz_center()\\n self._averaged_risk = self_weight * self._averaged_risk + other_weight * other_cluster.averaged_risk()\\n return self\",\n \"def merge_clusters(self, other_cluster):\\n if len(other_cluster.fips_codes()) == 0:\\n return self\\n else:\\n self._fips_codes.update(set(other_cluster.fips_codes()))\\n \\n # compute weights for averaging\\n self_weight = float(self._total_population) \\n other_weight = float(other_cluster.total_population())\\n self._total_population = self._total_population + other_cluster.total_population()\\n self_weight /= self._total_population\\n other_weight /= self._total_population\\n \\n # update center and risk using weights\\n self._vert_center = self_weight * self._vert_center + other_weight * other_cluster.vert_center()\\n self._horiz_center = self_weight * self._horiz_center + other_weight * other_cluster.horiz_center()\\n self._averaged_risk = self_weight * self._averaged_risk + other_weight * other_cluster.averaged_risk()\\n return self\",\n \"def calc_clust_slope(model, data):\\n df_slope_si = calc_slope_mogp_data(data)\\n df_slope_clust = pd.DataFrame(zip(data['SI'], model.z), columns=['SI', 'cluster']).set_index('SI')\\n df_slope_clust = df_slope_clust.join(df_slope_si, how='left')\\n df_slope_clust = pd.DataFrame(df_slope_clust.groupby('cluster')['slope'].mean())\\n return df_slope_clust\",\n \"def crude_policy_selection(actor, clusters):\\n # read in results from optimisation\\n results = []\\n\\n for _, case in the_cases(actor).items():\\n temp = pd.read_csv(\\\"simulation/optimisation/\\\" + actor + \\\"/results_\\\" + case + \\\".csv\\\")\\n temp_ = pd.read_csv(\\\"simulation/optimisation/\\\" + actor + \\\"/convergence_\\\" + case + \\\".csv\\\")\\n results.append([temp, temp_])\\n\\n # collapse in 1 dataframe\\n opt_df = pd.DataFrame()\\n for i, (result, convergence) in enumerate(results):\\n result[\\\"scenario\\\"] = i\\n opt_df = pd.concat([opt_df, result], axis=0)\\n\\n # clean up\\n opt_df.reset_index(inplace=True, drop=True)\\n opt_df.drop_duplicates(inplace=True)\\n\\n # select policies + add scenario back\\n policies = opt_df.iloc[:, :-4]\\n policies = pd.concat([policies, opt_df[\\\"scenario\\\"]], axis=1)\\n\\n kmeans = KMeans(n_clusters=clusters, random_state=0).fit(policies.iloc[:, :-1])\\n\\n # get all policies in each cluster\\n policies['cluster'] = kmeans.labels_\\n groups = policies.groupby(by=\\\"cluster\\\")\\n groups = groups.obj.sort_values(\\\"cluster\\\", ascending=True)\\n\\n # assign values to each policy in each cluster\\n groups[\\\"value\\\"] = 0\\n for i in range(clusters):\\n group = groups.loc[groups[\\\"cluster\\\"] == i]\\n group = group.iloc[:, :-3]\\n scaler = preprocessing.MinMaxScaler().fit(group)\\n data_scaled = scaler.transform(group)\\n groups.at[group.index.values, 'value'] = data_scaled.sum(axis=1)\\n\\n # get the most extreme two per cluster\\n idx = []\\n for cluster in range(clusters):\\n idx.extend(groups.loc[groups[\\\"cluster\\\"] == cluster].sort_values(by=\\\"value\\\", ascending=False)[:2].index.values.tolist())\\n\\n return opt_df.iloc[idx]\",\n \"def calcAvgDistances(centroids, clusters, class_header=\\\"Class\\\"):\\n avg_distances = [0] * len(centroids)\\n multiprocess_count = multiprocessing.cpu_count() # Find processor count\\n for centroid_row_index, centroid_tuple in enumerate(centroids.iterrows()): # For each cluster\\n work_list = [] # initialize multiprocessing structures\\n set_list = []\\n for _, datum in clusters[centroid_row_index].iterrows(): # For each point in the medoid cluster\\n work_list.append((centroid_tuple[1], datum, class_header)) # add calculation to work list\\n\\n partition_size = math.ceil(len(work_list) / multiprocess_count) # find size of each work subeset\\n for i in range(multiprocess_count - 1): # repeat for every subset\\n sample = work_list[i * partition_size: (i + 1) * partition_size] # break work list into fair subsets\\n set_list.append(sample)\\n set_list.append((work_list[(multiprocess_count - 1) * partition_size:]))\\n pool = multiprocessing.Pool(processes=multiprocess_count) # create multiprocessing pool\\n # calculate sum of list of all distances from work list tasks\\n avg_distances[centroid_row_index] = sum(sum(pool.map(Cluster.calcDistanceList, set_list), []))\\n pool.close()\\n pool.join()\\n\\n if avg_distances[centroid_row_index] is not 0: # make sure we do not divide by 0\\n # calculate average of distance list\\n avg_distances[centroid_row_index] = avg_distances[centroid_row_index] / len(clusters[centroid_row_index])\\n return avg_distances\",\n \"def kmeans_cluster(X_train_input, n_clusters=100):\\r\\n from sklearn.cluster import MiniBatchKMeans\\r\\n image_descriptors = []\\r\\n [image_descriptors.extend(ORB_feature_extractor(img)) for img in X_train_input]\\r\\n image_descriptors = np.array(image_descriptors) \\r\\n \\r\\n kmeans_model = MiniBatchKMeans(n_clusters=n_clusters, init_size=5*n_clusters,\\r\\n random_state=34, batch_size=128).fit(image_descriptors)\\r\\n \\r\\n return kmeans_model\",\n \"def kmeansClustering(data, x_scaled, clust, random_s):\\n np.random.seed(random_s)\\n #Performs clustering with the right number of clusters\\n kmeans = KMeans(n_clusters=clust, random_state=random_s, n_jobs=-1).fit(x_scaled)\\n kmeans = pd.DataFrame(kmeans.labels_, index=data.index, columns=[\\\"Clusters\\\"])\\n #Merge on our main dataframe for better vizualisation of the clusters\\n data_clust = pd.merge(data, kmeans, left_index=True, right_index=True, how='left')\\n return data_clust\",\n \"def cluster_center_update_dataset(spn, dataset):\\n\\n if isinstance(spn, Categorical):\\n\\n insert_into_categorical_leaf(spn, np.array([dataset]), np.array([1.0]))\\n\\n return spn\\n elif isinstance(spn, IdentityNumericLeaf):\\n\\n insert_into_identity_numeric_leaf(spn, np.array([dataset]), np.array([1.0]))\\n\\n return spn\\n elif isinstance(spn, Sum):\\n cc = spn.cluster_centers\\n\\n node_idx = 0\\n\\n min_dist = np.inf\\n min_idx = -1\\n for n in spn.children:\\n # distance calculation between the dataset and the different clusters\\n # (there exist a much faster version on scipy)\\n # this? https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html\\n #\\n proj = projection(dataset, n.scope)\\n dist = distance.euclidean(cc[node_idx], proj)\\n if dist < min_dist:\\n min_dist = dist\\n min_idx = node_idx\\n\\n node_idx += 1\\n assert min_idx > -1\\n assert min_idx < len(spn.children)\\n adapt_weights(spn, min_idx)\\n cluster_center_update_dataset(spn.children[min_idx], dataset)\\n elif isinstance(spn, Product):\\n\\n for n in spn.children:\\n cluster_center_update_dataset(n, dataset)\\n else:\\n raise Exception(\\\"Invalid node type \\\" + str(type(spn)))\\n spn.cardinality += 1\",\n \"def evaluate_clusters(self, cluster_formulas, value='weighted_sum'):\\n num_elems = len(self.labels)\\n total_val = {}\\n num_cl = len(cluster_formulas)\\n clustered_points_num = 0\\n print(\\\"\\\\n\\\\n\\\")\\n print(\\\"Sufficiently big clusters: {}\\\".format(num_cl))\\n for c, formula, val in cluster_formulas:\\n c_size = len([l for l in self.labels if l == c])\\n clustered_points_num += c_size\\n\\n if value == 'weighted_sum':\\n total_val[c] = val * c_size / num_elems\\n elif value == 'sum':\\n total_val[c] = val * 1\\n\\n clust_val = sum(total_val.values())\\n self.clustering_value = total_val\\n print(\\\"Value of clustering: {}\\\".format(clust_val))\\n return clust_val\",\n \"def get_number_of_clusters(df, use_pca, n_components):\\n n_clusters = 10\\n cluster_with_distances = []\\n for i in range(n_clusters):\\n pipe = _build_model(df, use_pca, n_components, use_kmeans=True, n_clusters=i + 1)\\n cluster_with_distances.append(pipe.named_steps['kmeans'].inertia_)\\n plt.figure(6, figsize=(12, 6))\\n plt.plot(range(1, 11), cluster_with_distances, 'o')\\n plt.plot(range(1, 11), cluster_with_distances, '-', alpha=0.5)\\n plt.title('The Elbow Criterion')\\n plt.xlabel('number of cluster')\\n plt.ylabel('Sum of squared distances of samples to their closest cluster center')\\n plt.show()\",\n \"def add_accumulation_features(df, config):\\n if config.has_option(\\\"clustering\\\", \\\"bin\\\"):\\n bin_size = float(config.get(\\\"clustering\\\", \\\"bin\\\"))\\n logger.info(\\n \\\"Computation of the accumulation features with bin_size=%s\\\",\\n bin_size\\n )\\n df = accumulation_2d_neighborhood(df, bin_size)\\n df.fillna(0, inplace=True)\\n for c in (\\\"bin_z_range\\\", \\\"bin_z_std\\\", \\\"bin_density\\\"):\\n df[c] = max_normalize(df[c])\\n return df\",\n \"def cre_confidence1(df):\\r\\n func = lambda x: 1 - np.abs(x.mean())\\r\\n return df.groupby('creline')['ffb_c'].transform(func)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77887636","0.71788836","0.68467784","0.64547867","0.62752557","0.62094164","0.6097976","0.6032077","0.59859556","0.5968796","0.5952526","0.5906807","0.59013987","0.58965117","0.58917665","0.5887675","0.5864871","0.5808137","0.5738972","0.5717941","0.56477034","0.5637867","0.56281066","0.5615782","0.56156254","0.5612784","0.5595809","0.55820537","0.5569827","0.5517969","0.5500925","0.54903316","0.5486868","0.5456738","0.545496","0.54456127","0.5412356","0.5409169","0.54058355","0.5374357","0.5369637","0.53621966","0.53582805","0.5329246","0.5319618","0.52797544","0.5269833","0.5238429","0.5236669","0.5227587","0.5209946","0.5205338","0.52030367","0.52001894","0.5198649","0.5197124","0.5197086","0.51942116","0.5183269","0.5180552","0.5179404","0.5178904","0.5152321","0.5135476","0.5135316","0.51109535","0.5107341","0.5101368","0.50993955","0.5098423","0.50943464","0.5078841","0.50695425","0.506456","0.5061105","0.50503075","0.50490093","0.50350237","0.5023334","0.50195163","0.50139755","0.5009571","0.5006126","0.5006126","0.49977806","0.49977013","0.49949488","0.49916157","0.49892414","0.49892414","0.49891952","0.49855536","0.49625766","0.49597174","0.4959357","0.4953362","0.4950731","0.49489203","0.4947868","0.49470064"],"string":"[\n \"0.77887636\",\n \"0.71788836\",\n \"0.68467784\",\n \"0.64547867\",\n \"0.62752557\",\n \"0.62094164\",\n \"0.6097976\",\n \"0.6032077\",\n \"0.59859556\",\n \"0.5968796\",\n \"0.5952526\",\n \"0.5906807\",\n \"0.59013987\",\n \"0.58965117\",\n \"0.58917665\",\n \"0.5887675\",\n \"0.5864871\",\n \"0.5808137\",\n \"0.5738972\",\n \"0.5717941\",\n \"0.56477034\",\n \"0.5637867\",\n \"0.56281066\",\n \"0.5615782\",\n \"0.56156254\",\n \"0.5612784\",\n \"0.5595809\",\n \"0.55820537\",\n \"0.5569827\",\n \"0.5517969\",\n \"0.5500925\",\n \"0.54903316\",\n \"0.5486868\",\n \"0.5456738\",\n \"0.545496\",\n \"0.54456127\",\n \"0.5412356\",\n \"0.5409169\",\n \"0.54058355\",\n \"0.5374357\",\n \"0.5369637\",\n \"0.53621966\",\n \"0.53582805\",\n \"0.5329246\",\n \"0.5319618\",\n \"0.52797544\",\n \"0.5269833\",\n \"0.5238429\",\n \"0.5236669\",\n \"0.5227587\",\n \"0.5209946\",\n \"0.5205338\",\n \"0.52030367\",\n \"0.52001894\",\n \"0.5198649\",\n \"0.5197124\",\n \"0.5197086\",\n \"0.51942116\",\n \"0.5183269\",\n \"0.5180552\",\n \"0.5179404\",\n \"0.5178904\",\n \"0.5152321\",\n \"0.5135476\",\n \"0.5135316\",\n \"0.51109535\",\n \"0.5107341\",\n \"0.5101368\",\n \"0.50993955\",\n \"0.5098423\",\n \"0.50943464\",\n \"0.5078841\",\n \"0.50695425\",\n \"0.506456\",\n \"0.5061105\",\n \"0.50503075\",\n \"0.50490093\",\n \"0.50350237\",\n \"0.5023334\",\n \"0.50195163\",\n \"0.50139755\",\n \"0.5009571\",\n \"0.5006126\",\n \"0.5006126\",\n \"0.49977806\",\n \"0.49977013\",\n \"0.49949488\",\n \"0.49916157\",\n \"0.49892414\",\n \"0.49892414\",\n \"0.49891952\",\n \"0.49855536\",\n \"0.49625766\",\n \"0.49597174\",\n \"0.4959357\",\n \"0.4953362\",\n \"0.4950731\",\n \"0.49489203\",\n \"0.4947868\",\n \"0.49470064\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.87321883"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19495,"cells":{"query":{"kind":"string","value":"Basing on a dataframe given as an argument, returns mean profit per class (buy, sell) in training dataset. sort dataframe descending by profit marks 1/3 of clusters with the highest profit as buy marks 1/3 of clusters with the lowest profit as sell if data contains less than 3 different clusters returns AssertionError"},"document":{"kind":"string","value":"def get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(df_profit_per_cluster_train) >= 3, \"Algorithm, returned less than 3 clusters.\"\n\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\n group_size = int(len(df_profit_per_cluster) / 3)\n\n buy_clusters_mean_profit = df_profit_per_cluster.iloc[:group_size]['profit'].mean()\n sell_clusters_mean_profit = df_profit_per_cluster.iloc[-group_size:]['profit'].mean()\n\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\n\n return buy_clusters_mean_profit, buy_clusters_list, sell_clusters_mean_profit, sell_clusters_list"},"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_mean_profit_per_class_from_test_df(df_profit_per_cluster_test: pd.core.frame.DataFrame,\n buy_clusters_list: List[int], sell_clusters_list: List[int]) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(buy_clusters_list) != 0 and len(sell_clusters_list) != 0, \"Clusters list can't be empty.\"\n\n buy_clusters_mean_profit = \\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(buy_clusters_list)]['profit'].mean()\n sell_clusters_mean_profit = \\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(sell_clusters_list)]['profit'].mean()\n\n return buy_clusters_mean_profit, sell_clusters_mean_profit","def get_profit_per_cluster(df: pd.core.frame.DataFrame) -> pd.core.frame.DataFrame:\n return pd.DataFrame(df.groupby(by='cluster')['profit'].mean(), columns=['profit']).reset_index()","def clusterting_feature_importance (df, cluster_col):\r\n scores = pd.DataFrame()\r\n df0 = df.copy()\r\n df0 = df.select_dtypes(include=np.number)\r\n\r\n for i in df0[cluster_col].unique():\r\n df2 = df0[df0[cluster_col] == i]\r\n df2.drop(cluster_col,axis=1, inplace=True)\r\n #df2 = df.select_dtypes(include=np.number)\r\n scores[i] = df2.std() / (df2.max() - df2.min())\r\n scores['mean'] = scores.mean(axis = 1)\r\n\r\n scores = 1 - scores\r\n\r\n return scores","def purity_score(label, pred):\n \n df = pd.concat([label, pd.DataFrame(pred)], axis=1)\n df.set_axis(['label', 'pred'], axis=1, inplace=True)\n \n s = 0\n\n for x, cluster in df.groupby('pred'):\n s += cluster['label'].value_counts().iloc[0] # adding the most occuring class in a cluster\n\n return s / label.shape[0]","def score(self, df_X, ser_y):\n df_predict = self.predict(df_X)\n accuracies = []\n for instance in ser_y.index:\n # Accuracy is the probability of selecting the correct class\n try:\n accuracy = df_predict.loc[instance, ser_y.loc[instance]]\n except:\n import pdb; pdb.set_trace()\n accuracies.append(accuracy)\n return np.mean(accuracies)","def ranking_metric(df, method, phenoPos, phenoNeg, classes, ascending): \n \n A = phenoPos\n B = phenoNeg\n df2 = df.T \n df2['class'] = classes\n df_mean= df2.groupby('class').mean().T\n df_std = df2.groupby('class').std().T \n #exclude any zero stds.\n df_mean = df_mean[df_std.sum(axis=1) !=0]\n df_std = df_std[df_std.sum(axis=1) !=0]\n \n if method == 'signal_to_noise':\n sr = (df_mean[A] - df_mean[B])/(df_std[A] + df_std[B])\n elif method == 't_test':\n sr = (df_mean[A] - df_mean[B])/ np.sqrt(df_std[A]**2/len(df_std)+df_std[B]**2/len(df_std) )\n elif method == 'ratio_of_classes':\n sr = df_mean[A] / df_mean[B]\n elif method == 'diff_of_classes':\n sr = df_mean[A] - df_mean[B]\n elif method == 'log2_ratio_of_classes':\n sr = np.log2(df_mean[A] / df_mean[B])\n else:\n logging.error(\"Please provide correct method name!!!\") \n sys.exit()\n sr.sort_values(ascending=ascending, inplace=True)\n df3 = sr.to_frame().reset_index()\n df3.columns = ['gene_name','rank']\n df3['rank2'] = df3['rank']\n\n return df3","def cluster_means(self):\n if self.evaluate_by is not None:\n return(self.merged_data.groupby(\n 'labels').mean().sort_values(self.evaluate_by).transpose())\n else:\n return(self.merged_data.groupby('labels').mean().transpose())","def score(self, df_X, ser_y):\n df_predict = self.predict(df_X)\n missing_columns = set(ser_y).difference(\n df_predict.columns)\n for column in missing_columns:\n df_predict[column] = np.repeat(0,\n len(df_predict))\n accuracies = []\n for instance in ser_y.index:\n # Accuracy is the probability of selecting the correct class\n try:\n accuracy = df_predict.loc[instance, ser_y.loc[instance]]\n except:\n import pdb; pdb.set_trace()\n accuracies.append(accuracy)\n return np.mean(accuracies)","def classify():\n yes_dataset = df[df[\"_class\"] == 1] # 470588\n no_dataset = df[df[\"_class\"] == 0] # 1971\n\n parameter_analysis = list()\n for criterion in np.arange(0.05, 0.91, 0.05):\n print(\"doing experiment at criterion = %s ...\" % criterion)\n rate_list = list()\n for i in range(10):\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\n yes_index = yes_dataset.index.tolist()\n random.shuffle(yes_index)\n no_index = no_dataset.index.tolist()\n random.shuffle(no_index)\n \n # concatenate 90%yes + 90%no, 10%yes + 10%no\n train = pd.concat([\n yes_dataset.loc[yes_index[:1774], :],\n no_dataset.loc[no_index[:423530], :]\n ])\n test = pd.concat([\n yes_dataset.loc[yes_index[1774:], :],\n no_dataset.loc[no_index[423530:], :]\n ]) \n \n # split data and label\n train_data, train_label = (train[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n train[\"_class\"])\n test_data, test_label = (test[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n test[\"_class\"])\n \n # apply classifier\n clf = GaussianNB()\n clf.fit(train_data, train_label)\n probability = clf.predict_proba(test_data).T[1]\n \n result = pd.DataFrame()\n result[\"_class\"] = test_label\n result[\"_predict\"] = probability >= criterion\n \n result_yes = result[result[\"_class\"] == 1]\n yes_yes_rate = sum(result_yes[\"_class\"] == result_yes[\"_predict\"])/len(result_yes[\"_predict\"])\n \n result_no = result[result[\"_class\"] == 0]\n no_no_rate = sum(result_no[\"_class\"] == result_no[\"_predict\"])/len(result_no[\"_predict\"])\n \n rate_list.append((yes_yes_rate, no_no_rate))\n\n rate_list = pd.DataFrame(rate_list)\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\n \n # save data to excel spreadsheet\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\"criterion\", \"yes_yes_rate\", \"no_no_rate\"])\n writer = pd.ExcelWriter(\"parameter_analysis.xlsx\")\n parameter_analysis.to_excel(writer, \"parameter_analysis\", index=False)\n writer.save()","def wca_mean(X, k, df):\n\t\n\n\t# Intializing the clusters\t\n\tC = dict()\n\tfor cluster in range(k):\n\t C[cluster] = pd.DataFrame()\n\n\t# Calculating the mean vector\n\tmean_vector = X.mean()\n\n\t# Choosing the seed points based on the minimum distance from the mean vector\n\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\n\tdist_means = X.sort_values(by='dist_mean')\n\t\n\t# Dropping the the datapoints which have already been assigned as seed\n\tidx_to_drop = dist_means.index[:k]\n\tdist_means.reset_index(drop=True,inplace=True)\n\tX.drop('dist_mean',axis=1,inplace=True)\n\tX.drop(idx_to_drop, inplace=True)\n\n\t# Assigning seed points to the clusters\n\tmu = list()\n\tfor cluster in range(k):\n\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\n\t mu.append(C[cluster].mean())\n\t\n\t# Running the algorithm\t\n\t\n\t# Initializing the p-value list which would be used for plotting\n\tpval = dict()\n\n\tfor cluster in range(k):\n\t pval[cluster] = dict()\n\t for i in C[0].columns:\n\t pval[cluster][i] = list()\n\n\t# Algorithm\n\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\n\t for cluster in range(k):\n\n\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\n\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\n\t dist_means = X.sort_values(by='dist_mean', ascending=False)\n\t idx_to_drop = dist_means.index[0]\n\t dist_means.reset_index(drop=True,inplace=True)\n\t X.drop('dist_mean',axis=1,inplace=True)\n\n\t # Assigning the top value to the cluster\n\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\n\t C[cluster] = C[cluster].reset_index(drop=True)\n\t \n\t # Updating means of each cluster\n\t mu[cluster] = C[cluster].mean()\n\n\t # Remove datapoint from X?\n\t X.drop(idx_to_drop,inplace=True)\n\t \n\t for i in C[0].columns:\n\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\n\n\treturn(C,pval)","def get_split(data):\n \"\"\" gets the best feature, and best value \"\"\"\n\n best_feature = None\n best_value = 0.0\n columns = data.columns\n gini_base = gini_impurity(data)\n n_rows = len(data.index) # total number of rows of data before split\n\n # Fininding which split yields the best gini gain\n max_gain = 0\n\n for i in range(len(columns)-1): # -1 b.c. class is final column\n xs = data[columns[i]].unique() # get values to test\n for x in xs: # test values\n # split dataset\n df_left = data[data[columns[i]] < x]\n df_right = data[data[columns[i]] >= x]\n\n # get gini impurities\n gini_left = gini_impurity(df_left)\n gini_right = gini_impurity(df_right)\n \n\n # Calculated weighted gini impurity\n w_left = len(df_left.index) / n_rows\n w_right = len(df_right.index) / n_rows\n\n w_gini = gini_left * w_left + gini_right * w_right\n \n\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\n gini_gain = gini_base - w_gini\n\n # check if this is the best split so far, store values, update max_gini\n if gini_gain > max_gain:\n best_feature = columns[i]\n best_value = x\n max_gain = gini_gain\n\n df_left = data.loc[data[best_feature] < best_value]\n df_right = data.loc[data[best_feature] >= best_value]\n \n\n return best_feature, best_value, df_left, df_right","def balance_classes(df):\n df_class_0 = df[df[65]==0]\n df_class_1 = df[df[65]==1]\n df_count = df[65].value_counts()\n count_0 = df_count[0]\n count_1 = df_count[1]\n\n if count_0 > count_1:\n df_class_1_over = df_class_1.sample(count_0, replace=True)\n df_over = pd.concat([df_class_0, df_class_1_over], axis=0)\n elif count_0 < count_1:\n df_class_0_over = df_class_0.sample(count_1, replace=True)\n df_over = pd.concat([df_class_1, df_class_0_over], axis=0)\n else:\n df_over = df\n \n return df_over","def mid_market_price(orders: pandas.DataFrame):\n return numpy.mean((best_bid_price(orders), best_ask_price(orders)))","def create_strategy(filename: str, columns_list: List[str], som_width: int, som_height: int, n_iter: int, sigma=0.3,\n learning_rate=0.01) -> tuple:\n # get prepared data\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\n\n # train som\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\n sigma=sigma, learning_rate=learning_rate)\n\n # get profit per cluster in train and test datasets\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\n df_profit_per_cluster_test = get_profit_per_cluster(final_df_test)\n\n # get mean profit for sell and buy class in training and testing datasets\n try:\n buy_clusters_mean_profit_train, buy_clusters_list, sell_clusters_mean_profit_train, sell_clusters_list = \\\n get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train)\n\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = \\\n get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test, buy_clusters_list, sell_clusters_list)\n # if the data was assigned to less than to 3 clusters\n except:\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = None, None, None, None\n\n return len(df_profit_per_cluster_train), len(df_profit_per_cluster_test), \\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test","def stdConfidenceTrades(predictions, buy_confidence=1.5, sell_confidence=1.1):\n smooth_preds = pd.Series(predictions).rolling(5).mean()\n buy_thresh = np.mean(smooth_preds) + buy_confidence * np.std(smooth_preds)\n sell_thresh = np.mean(smooth_preds) - sell_confidence * np.std(smooth_preds)\n buy_positions = np.where(predictions > buy_thresh)[0]\n sell_positions = np.where(predictions < sell_thresh)[0]\n \n buys = buy_positions\n sells = []\n curSell = 0\n for curBuy in buys:\n arr = np.where(sell_positions > curBuy)[0]\n if len(arr):\n sells.append(sell_positions[arr[0]])\n tradePairs = list(zip(buys, sells))\n return tradePairs","def balence_classes(df, btol):\r\n #Find the least supported class and muliply by the tolerance coefficient to get max_count:\r\n ccounts = df['classification'].value_counts()\r\n max_count = np.min(ccounts.values) * btol\r\n #Create a new dataframe with balenced support:\r\n newdf = pd.DataFrame(columns=df.columns.values)\r\n for x in df.groupby('classification'):\r\n if x[1].shape[0] > max_count:\r\n newdf = newdf.append(x[1].sample(max_count).reset_index(drop=True))\r\n else:\r\n newdf = newdf.append(x[1].reset_index(drop=True))\r\n return newdf.reset_index(drop=True)","def knn(trainingSetData, testSetData, k):\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\n testSet = testSetData.drop([14], axis=1) # drop income\n\n distances = {}\n # this will store the distances re-sorted in ascending/descending order\n sort = {}\n # income band results (>=50k or <50K)\n incomePredictions = []\n\n # Calculating euclidean distance between each row of training data and test data instance\n for testInstance in range(len(testSet)): # len(testSet)\n \n # Store current test Point:\n testInstance = testSet.iloc[testInstance] \n \n distances = euclideanDistanceRow(testInstance, trainingSet)\n\n # sort the distances in order of smallest first:\n sorted_d = sorted(distances.items(), key=lambda x: x[1], reverse=False)\n\n neighbors = []\n\n # Extracting top k neighbors\n for x in range(k):\n neighbors.append(sorted_d[x])\n\n\n classVotes = {}\n\n # Calculating the most freq class in the neighbors\n results = {\"lessThan50\": 0, \"moreThan50\": 0}\n\n # creating a dataframe to which we will add the income values:\n\n for x in range(len(neighbors)):\n if (trainingSetData.iloc[neighbors[x][0]][14] == 0.0):\n results[\"lessThan50\"] += 1\n elif (trainingSetData.iloc[neighbors[x][0]][14] == 1.0):\n results[\"moreThan50\"] += 1\n\n print('results',results)\n\n if (results[\"lessThan50\"] > results[\"moreThan50\"]):\n incomePredictions.append(0.0)\n elif (results[\"lessThan50\"] < results[\"moreThan50\"]):\n incomePredictions.append(1.0)\n\n return incomePredictions","def prepareSplitClassifier(df, models, choice):\n\n\n def classificationOutput(clf, X, Y):\n \"\"\"\n Fit the model and print the classification results\n - confusion_matrix\n - avg scores etc\n \"\"\"\n n_samples = 36\n\n print \"\\n\\nClassifier: \\n %s\" % (clf)\n print \"#\" * 79\n # classifier_gnb = naive_bayes.GaussianNB() # initiating the classifier\n\n clf.fit(X[:n_samples], Y[:n_samples]) # train on first n_samples and test on last 10\n\n expected = Y[n_samples:]\n predicted = clf.predict(X[n_samples:])\n print(\"Classification report:\\n%s\\n\" % (metrics.classification_report(expected, predicted)))\n print(\"\\nConfusion matrix:\\n%s\" % metrics.confusion_matrix(expected, predicted))\n\n\n\n\n def splitclassify(cDf):\n \"\"\"\n Given the dataframe combined with equal fair and unfair apps,\n classify them\n \"\"\"\n cDf = cDf.reindex(np.random.permutation(cDf.index)) # shuffle the dataframe\n featCols = set(cDf.columns)\n featCols.remove('appLabel')\n\n features = cDf[list(featCols)].astype('float')\n\n ## Scale the features to a common range\n min_max_scaler = preprocessing.MinMaxScaler()\n X = min_max_scaler.fit_transform(features.values)\n\n Y = cDf['appLabel'].values\n\n\n if choice == 'all':\n for key in models:\n classifier = models[key]\n classificationOutput(classifier, X, Y)\n else:\n if choice in models:\n classifier = models[choice]\n classificationOutput(classifier, X, Y)\n else:\n print \"Incorrect Choice\"\n\n\n\n fairDf = df[df['appLabel'] == False]\n unfairDf = df[df['appLabel'] == True]\n\n\n # calculate total possible splits of fair data frame relatie to\n # size of unfair dataframe\n splits = len(fairDf) // len(unfairDf)\n\n for i in range(splits):\n clDf = fairDf[i : i+len(unfairDf)].append(unfairDf)\n\n # print fairDf.values, unfairDf.values\n print \"Classifying %d th split of fair apps with unfair app\" % (i)\n print \"-\" * 79\n splitclassify(clDf)\n print \"\\n\\n\"","def get_perf(self) :\n self.train()\n\n prediction = self.clf.predict(self.df_test.drop(columns = 'up')[:-1])\n self.accuracy = accuracy_score(df_test['up'][length:].values, prediction)\n tn, fp, fn, tp = confusion_matrix(df_test['up'][length:].values, prediction).ravel()\n self.recall = tp/(tp+fn)\n self.specificity = tn / (tn+fp)\n\n\n self.df_true = self.df_true[self.length:]\n\n profit = 1\n mini = 1\n maxi = 1\n self.df_true['close'] = self.df_true['close'].map(lambda x : np.exp(x))\n for s in range(1,len(self.df_true)):\n if prediction[x-1] == 1 :\n result = ((self.df_true['close'].iloc[s] -self.df_true['close'].iloc[s-1]) / self.df_true['close'].iloc[s-1]) + 1\n profit = profit * result\n if result < mini :\n mini = result\n if maxi < result :\n maxi = result\n self.mini = mini\n self.maxi = maxi\n self.profit = profit","def generate_clusters(df):\n\n df_size = df.shape[0]\n print(df_size)\n n_clusters = 0\n percent_min_pts = 0.105\n min_clusters = 3\n while (n_clusters != min_clusters):\n print(\"percent_min_pts\", percent_min_pts)\n min_cluster_pts = math.floor(df_size * percent_min_pts)\n print(\"min_cluster_pts\", min_cluster_pts)\n\n clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_pts)\n print(df.head())\n clusterer.fit(df)\n cluster_groups = {}\n labels = clusterer.labels_\n for i in labels:\n if cluster_groups.get(i):\n cluster_groups[i] = cluster_groups[i] + 1\n else:\n cluster_groups[i] = 1\n print(\"cluster_groups\", cluster_groups)\n n_clusters = len(set(labels))\n print(\"n_clusters\", n_clusters)\n multiplier = abs(n_clusters - min_clusters) * 0.001\n print(\"multiplier\", multiplier)\n if n_clusters > min_clusters:\n percent_min_pts += multiplier\n else:\n percent_min_pts -= multiplier\n print(\"percent_min_pts\", percent_min_pts)\n return labels","def cluster_by_split(filtered_df):\n global features_in_range\n global table\n # make a copy of the entire data set\n unfiltered_df = table\n # get total number of robot faces in data set\n total_rows = len(unfiltered_df)\n\n # drop any column that is not included in our list of 11 features\n # 11 features = 16 features with no dependencies filtered via 20-80% range\n for col in unfiltered_df:\n if not unfiltered_df[col].name in features_in_range:\n unfiltered_df = unfiltered_df.drop(unfiltered_df[col].name, 1)\n\n # iterate over the dataframe of columns generated by the range\n for col in filtered_df:\n try:\n # for each column, call groupby() and calculate percentage\n check_for_20 = unfiltered_df.groupby(col).size().reset_index(name='count')\n check_for_20['as_percent'] = 100 * check_for_20['count'] / float(total_rows)\n # ignore feature values that represent less than 20% of all faces\n cluster_by_feature = check_for_20[check_for_20['as_percent'] >= 20]\n # if feature has values over 20%, iterate over\n # each feature_value and generate clusters\n if not cluster_by_feature.empty:\n # iterate over every value of the feature\n for index, row in cluster_by_feature.iterrows():\n # use feature value to call groupby() on the entire data set\n results = unfiltered_df[unfiltered_df[col] == row[0]]\n results = results \\\n .groupby(list(unfiltered_df)) \\\n .size() \\\n .reset_index(name='count')\n # calculate count as a percentage\n results['as_percent'] = 100 * results['count'] / float(total_rows)\n results = results.sort_values(by='as_percent', ascending=False)\n # store results in a .tsv file\n filename = str(col) + \"_\" + str(row[0]) + '_feature_cluster.tsv'\n results.to_csv(filename.replace(\"/\", \"-\"), header=True, sep='\\t')\n print(\"results written to file\")\n except:\n # 'count' and 'percentage' columns will generate errors\n # since they don't exist in the original data set\n pass","def byMeans(dataset, number_of_clusters, class_header=\"Class\", verbosity=0, return_clusters=False):\n if verbosity >= 2: # optionally print dataset shape and info\n print(dataset.shape)\n print(dataset)\n\n old_dataset = dataset.copy()\n dataset = dataset.drop(columns=class_header) # remove non-float class column\n\n # Assign centroids to random values which fit into dataset space.\n centroids = pandas.DataFrame(columns=dataset.columns,\n data=numpy.random.uniform(dataset.min(), dataset.max(),\n (number_of_clusters, dataset.shape[1])))\n if verbosity >= 1: # optionally print centroids and random dataset\n print(\"INITIAL CENTROIDS\")\n print(centroids)\n if verbosity >= 2:\n print(\"DATAFRAME DATASET\")\n print(dataset)\n\n for iterations in range(MAX_ITERATIONS): # Loop until MAX_ITERATIONS or settled\n if verbosity >= 1: # optionally print iteration count\n print(\"ITERATIONS\")\n print(iterations)\n\n # calculate clustering of data\n clusters = Cluster.calcClusters(dataset, centroids, number_of_clusters, verbosity=verbosity)\n\n old_centroids = centroids.copy() # copy centroid dataframe\n\n if verbosity >= 2: # optionally print cluster list\n print(\"DATAFRAME ARRAY CLUSTERS\")\n print(clusters)\n\n for cluster_index, cluster in enumerate(clusters): # Calculate new centroids\n cluster_mean = cluster.mean()\n if not cluster_mean.isnull().any(): # make sure we dont write null means to centroid list\n centroids.loc[cluster_index] = cluster_mean\n\n if verbosity >= 1:\n print(\"OLD CENTROIDS\")\n print(old_centroids)\n print(\"NEW CENTROIDS\")\n print(centroids)\n\n if old_centroids is not None: # Calculate sum of centroid movements.\n centroid_change = 0\n for centroid_index, centroid in centroids.iterrows():\n centroid_change += abs(Cluster.calcDistance(centroid, old_centroids.loc[centroid_index]))\n\n if verbosity >= 1:\n print(\"CENTROID DIFF\")\n print(centroid_change)\n\n if centroid_change < SETTLE_THRESHOLD: # break if centroid movement is below threshold.\n break\n\n # Final Cluster re-calculation\n clusters = Cluster.calcClusters(old_dataset, centroids, number_of_clusters,\n verbosity=verbosity, class_header=class_header)\n # Create new dataframe with class column of and row for each centroid\n centroids_class = pandas.DataFrame(data=[\"NOCLASS\"] * centroids.shape[0], columns=[class_header])\n if verbosity >= 2:\n print(centroids_class)\n print(centroids)\n for cluster_index, cluster in enumerate(clusters): # For each cluster\n if verbosity >= 2:\n print(cluster_index)\n print(cluster)\n if cluster.size > 0: # If cluster is not empty set centroid class to most common class in cluster\n centroids_class.iat[cluster_index, 0] = cluster.mode().loc[0][0]\n if old_dataset.columns[0] == class_header: # check if class column should be first or last.\n print(\"CLASS IS FIRST COL\")\n centroids = pandas.concat([centroids_class, centroids], axis=1) # merge class to centroids as first column\n else:\n print(\"CLASS IS NOT FIRST COL\")\n centroids = pandas.concat([centroids, centroids_class], axis=1) # merge class to centroids as last column\n for centroid in centroids.iterrows(): # For each centroid\n if centroid[1][class_header] is \"NOCLASS\": # Trim NOCLASS centroids (empty cluster)\n centroids = centroids.drop(centroid[0])\n centroids = centroids.reset_index(drop=True) # Reindex centroids\n\n if return_clusters is True: # optionally return cluster list\n return centroids, clusters\n pass\n else:\n return centroids # return centroids dataframe","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def calculate_kmeans(df, clusters=10):\r\n kmeans = KMeans(n_clusters=clusters)\r\n labels = kmeans.fit_predict(df)\r\n\r\n return kmeans, labels","def cluster_importance(self, clf=DecisionTreeClassifier(), n_most_important=3):\n\n for k in xrange(self.n_clusters):\n labels = (self.labels == k)\n clf.fit(self.data.values, labels)\n\n print \"\\n ======== cluster {} / {} ========\".format(k + 1, self.n_clusters)\n\n sorted_importance = sorted(zip(clf.feature_importances_, self.data.columns), key=lambda (imp, col): imp, reverse=True)\n sorted_importance = sorted_importance[:n_most_important]\n\n for imp, col in sorted_importance:\n print \"[{:.5f} relative importance] {}\".format(imp, col)\n print self.data.loc[labels, col].describe()","def cluster_membership_occupancy(data):\n \n \n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n\n if n_clusters == 0:\n membership=[Cluster_Membership_Features()]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n areas=[Cluster_Area_Features()]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features()]\n density = pd.DataFrame([o.__dict__ for o in density])\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n \n elif n_clusters ==1:\n #obtain_total_cluster_areas_set_everything_else_to_default\n membership=[Cluster_Membership_Features()]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n \n try:\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\n except:\n cluster_chull_areas=[0,0,0]\n \n Total_cluster_area=np.sum(cluster_chull_areas)\n areas=[Cluster_Area_Features([Total_cluster_area,0,0,0,0,0,0,0,0])]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features()]\n density = pd.DataFrame([o.__dict__ for o in density])\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n \n elif n_clusters >1:\n #Summarizing the cluster membership distribution characteristics\n cluster_size_nums=np.delete(np.array(data.groupby(['clusters']).size()),0)\n (cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD)= distribution_statistics(cluster_size_nums)\n\n #For each cluster calculate the area by calculating the area of the convex hull of cluster members\n # Note: concavehull implementation here might be a good addition as it will provide more imformative values. \n\n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n try:\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\n except:\n cluster_chull_areas=[0,0,0,0,0]\n \n\n (avg_cluster_area,min_cluster_area,max_cluster_area,\n std_cluster_area,CV_cluster_area,CD_cluster_area,\n IQR_cluster_area,Quartile_CD_cluster_area)= distribution_statistics(cluster_chull_areas)\n Total_cluster_area=np.sum(cluster_chull_areas)\n\n #Calculate cluster density: number of nuclei/ convex area of cluster\n cluster_density=np.divide(cluster_size_nums,cluster_chull_areas)\n (avg_cluster_density,min_cluster_density,max_cluster_density,\n std_cluster_density,CV_cluster_density,CD_cluster_density,\n IQR_cluster_density,Quartile_CD_cluster_density)= distribution_statistics(cluster_density)\n\n #return dataframe of features\n membership=[Cluster_Membership_Features([cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD])]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n areas=[Cluster_Area_Features([Total_cluster_area,\n avg_cluster_area,min_cluster_area,max_cluster_area,\n std_cluster_area,CV_cluster_area,CD_cluster_area,\n IQR_cluster_area,Quartile_CD_cluster_area])]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features([avg_cluster_density,min_cluster_density,max_cluster_density,\n std_cluster_density,CV_cluster_density,CD_cluster_density,\n IQR_cluster_density,Quartile_CD_cluster_density])]\n density = pd.DataFrame([o.__dict__ for o in density])\n\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n return all_features","def features_sparseness(dat,sort=0): \n \n lblst=dat.columns.tolist()\n ll=len(dat)\n res=pd.Series(index=lblst,name='sparseness')\n \n for lb in lblst:\n ct=dat[lb].value_counts()\n res[lb]= ct.iloc[0]/ll\n \n if sort==1:\n res.sort_values(ascending=True,inplace=True)\n elif sort==-1:\n res.sort_values(ascending=False,inplace=True)\n else:\n pass\n \n return res","def makeRankDF(self, class_selection=None):\n df_values = pd.DataFrame()\n for idx, clf in enumerate(self.clfs):\n df_values[idx] = pd.Series(self._orderFeatures(clf,\n class_selection=class_selection),\n index=self.features)\n df_result = self._makeFeatureDF(df_values)\n df_result = df_result.fillna(0)\n return df_result.sort_values(cn.MEAN)","def makeRankDF(self, class_selection=None):\n df_values = pd.DataFrame()\n for idx, clf in enumerate(self.clfs):\n df_values[idx] = pd.Series(self._orderFeatures(clf,\n class_selection=class_selection),\n index=self.features)\n df_result = self._makeFeatureDF(df_values)\n df_result = df_result.fillna(0)\n return df_result.sort_values(cn.MEAN)","def grouping(data_clust):\n data_grouped = data_clust.groupby('Clusters').mean()\n return data_grouped","def voting(y_pred_test, gnd_te):\n df = pd.DataFrame({'y':y_pred_test, 'gnd':gnd_te})\n df.sort_values(by=['y'], inplace=True, ascending=False)\n out = df.groupby(['gnd']).mean()\n return len(out[out['y'] > 0])/float(len(out))","def purity_score(clusters, classes):\n clusters = np.array(clusters)\n classes = np.array(classes)\n A = np.c_[(clusters,classes)]\n\n n_accurate = 0.\n\n for j in np.unique(A[:,0]):\n z = A[A[:,0] == j, 1]\n x = np.argmax(np.bincount(z))\n n_accurate += len(z[z == x])\n\n return n_accurate / A.shape[0]","def disaggregate_by_cluster(self):\n # wt = np.zeros((1, self.ds.shape[1]))\n # total = np.zeros((self.n_ahead, self.ds.shape[1]))\n \n agg_cluster_ds = np.zeros((self.n_ahead+1, self.n_clusters))\n agg_cluster_ds[0] = self.ds_agg_by_c[-1]\n agg_cluster_ds[1:] = self.ds_c_for\n cluster_perc_change = np.diff(agg_cluster_ds, axis = 0) / agg_cluster_ds[:-1]\n\n cluster_scaling_vector = np.zeros((2, self.ds.shape[1]))\n\n # break down proportionally -> don't work well\n # for c in range(self.n_clusters):\n # c_m = self.ds.iloc[-self.cluster_n_period:, np.where(self.ds_c == c)[0]]\n # c_sum = sum(c_m)\n # indiv_sum = np.sum(c_m, axis = 0)\n # wt[:,np.where(self.ds_c == c)[0]] = (indiv_sum/c_sum)\n # total[:,np.where(self.ds_c == c)[0]] = np.reshape(\n # np.repeat(self.ds_c_for[:,c], c_m.shape[1]), (self.n_ahead, c_m.shape[1]))\n \n # multiply by the perc change\n \n for i in range(self.ds_c.shape[0]):\n cluster_scaling_vector[:,i] = cluster_perc_change[:,self.ds_c[i]]\n cluster_scaling_vector = cluster_scaling_vector+1\n cluster_scaling_vector = np.array(cluster_scaling_vector)\n \n self.ds_for = self.ds.copy()\n\n for yr in range(self.n_ahead)[::-1]:\n # forecast on foretasted number\n yr_ind = self.ds_for.index[-(yr+1)]\n self.ds_for.ix[yr_ind] = self.ds_for.iloc[-(yr+2),:].values * cluster_scaling_vector[-(yr+1)]\n\n # self.ds_for.iloc[-(self.n_ahead):,:] = self.ds_for.iloc[-(self.n_ahead+1):-1,:].values * np.array(cluster_scaling_vector)\n\n # if negative -> 0\n self.ds_for[self.ds_for < 0] = 0","def OTU_table_ML(OTU_table,metadata,obj_col):\n for ele in OTU_table.index:\n #print(ele)\n X.append(df.loc[ele])\n Y.append(metadata[obj_col][ele])\n precisions = []\n for train_time in range(100): \n X,Y = shuffle(X,Y)\n sample_num = len(X)\n sep_num = int(0.8*sample_num)\n train_set = [X[:sep_num],Y[:sep_num]]\n test_set = [X[sep_num:],Y[sep_num:]]\n clf = svm.SVC(gamma='scale')\n clf.fit(train_set[0], train_set[1]) \n predict_result = clf.predict(test_set[0])\n count = 0\n for i in range(len(predict_result)):\n if predict_result[i] == test_set[1][i]:\n count += 1\n else:\n pass\n precisions.append(1.0*count/len(predict_result))\n print(np.mean(precisions))","def test_splits(ratings_df, predict_method, k, test_size=250, splits=3):\n mse_ls = []\n for _ in range(splits):\n test_ratings_df = ratings_df.sample(n=test_size)\n train_ratings_df = ratings_df.drop(test_ratings_df.index)\n model_params = matrix_cf.get_model_params(train_ratings_df)\n _, mse = predict_method(test_ratings_df, k, model_params)\n mse_ls.append(mse)\n return np.array(mse_ls).mean()","def naive_bayes(df):\n\n X = df.loc[:, :'perfs'].reset_index(drop=True)\n y = df.loc[:, 'Popularity'].reset_index(drop=True).values\n\n # convert categorical data to numerical\n for i in X.columns:\n if type(X[i][0]) == str:\n X[i] = X[i].astype(\"category\").cat.codes\n # normalize the data\n normDF = preprocessing.normalize(X, axis=0)\n\n X_train, X_validate, Y_train, Y_validate = train_test_split(normDF, y, test_size=0.2, random_state=42)\n\n gnb = GaussianNB()\n gnb.fit(X_train, Y_train)\n y_pred = gnb.predict(X_validate)\n\n kfold = KFold(n_splits=10, random_state=42, shuffle=False)\n cv_results = cross_val_score(gnb, X_train, Y_train, cv=kfold, scoring='accuracy')\n msg = \"%f (%f)\" % (cv_results.mean(), cv_results.std())\n\n print(\"Confusion Matrix\")\n print(confusion_matrix(Y_validate, y_pred))\n print(classification_report(Y_validate, y_pred))\n print(\"Accuracy score of training data: \", msg)\n print('Accuracy score of testing data: ', accuracy_score(Y_validate, y_pred))\n print(\"\")\n\n return","def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\n learning_rate=0.01):\n\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\n random_seed=0)\n som.train(df_train, n_iter)\n\n # converting numpy arrays to dataframes\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\n\n # creating column with cluster basing on model prediction\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\n\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\n # the script\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\n lsuffix='_org')\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\n lsuffix='_org')\n\n return final_df_train, final_df_test","def cluster_means_scaled(self):\n if self.evaluate_by is not None:\n return(self.merged_scaled_data.groupby(\n 'labels').mean().sort_values(self.evaluate_by).transpose())\n else:\n return(self.merged_scaled_data.groupby(\n 'labels').mean().transpose())","def eval_all(cls_prob, dtrain):\n #determine the top k predictions\n labels = dtrain.get_label()\n top_k = cls_prob.argsort(axis = 1)[:,::-1][:,:5]\n# top_k = cls_prob.argsort(axis = 1)[:,:k:-1]\n #convert true values and compared with predictions to check for equality\n labels = labels[:, None]\n return 'error', 1-ndcg(top_k, labels)/len(labels)","def purity(clusters, classes):\n\n d = defaultdict(list)\n\n # Get a list of class numbers of all examples in a cluster.\n for k, v in zip(clusters, classes):\n d[k].append(v)\n\n mayority = 0\n\n # Count the mayority class number and add it up over all clusters.\n for k in d:\n mayority += Counter(d[k]).most_common(1)[0][1]\n\n return float(mayority) / len(clusters)","def k_means(n_clust, data_frame, true_labels):\n k_means = KMeans(n_clusters=n_clust, random_state=123, n_init=30)\n k_means.fit(data_frame)\n c_labels = k_means.labels_\n df = pd.DataFrame({'clust_label': c_labels, 'orig_label': true_labels.tolist()})\n ct = pd.crosstab(df['clust_label'], df['orig_label'])\n y_clust = k_means.predict(data_frame)\n display(ct)\n print('% 9s' % 'inertia homo compl v-meas ARI AMI silhouette')\n print('%i %.3f %.3f %.3f %.3f %.3f %.3f'\n % (k_means.inertia_,\n homogeneity_score(true_labels, y_clust),\n completeness_score(true_labels, y_clust),\n v_measure_score(true_labels, y_clust),\n adjusted_rand_score(true_labels, y_clust),\n adjusted_mutual_info_score(true_labels, y_clust),\n silhouette_score(data_frame, y_clust, metric='euclidean')))","def crude_policy_selection(actor, clusters):\n # read in results from optimisation\n results = []\n\n for _, case in the_cases(actor).items():\n temp = pd.read_csv(\"simulation/optimisation/\" + actor + \"/results_\" + case + \".csv\")\n temp_ = pd.read_csv(\"simulation/optimisation/\" + actor + \"/convergence_\" + case + \".csv\")\n results.append([temp, temp_])\n\n # collapse in 1 dataframe\n opt_df = pd.DataFrame()\n for i, (result, convergence) in enumerate(results):\n result[\"scenario\"] = i\n opt_df = pd.concat([opt_df, result], axis=0)\n\n # clean up\n opt_df.reset_index(inplace=True, drop=True)\n opt_df.drop_duplicates(inplace=True)\n\n # select policies + add scenario back\n policies = opt_df.iloc[:, :-4]\n policies = pd.concat([policies, opt_df[\"scenario\"]], axis=1)\n\n kmeans = KMeans(n_clusters=clusters, random_state=0).fit(policies.iloc[:, :-1])\n\n # get all policies in each cluster\n policies['cluster'] = kmeans.labels_\n groups = policies.groupby(by=\"cluster\")\n groups = groups.obj.sort_values(\"cluster\", ascending=True)\n\n # assign values to each policy in each cluster\n groups[\"value\"] = 0\n for i in range(clusters):\n group = groups.loc[groups[\"cluster\"] == i]\n group = group.iloc[:, :-3]\n scaler = preprocessing.MinMaxScaler().fit(group)\n data_scaled = scaler.transform(group)\n groups.at[group.index.values, 'value'] = data_scaled.sum(axis=1)\n\n # get the most extreme two per cluster\n idx = []\n for cluster in range(clusters):\n idx.extend(groups.loc[groups[\"cluster\"] == cluster].sort_values(by=\"value\", ascending=False)[:2].index.values.tolist())\n\n return opt_df.iloc[idx]","def __evaluate(self, preds, labels, raw, fair, sort_by_unfairness=False,\n graph_prms=None):\n # Compute the distance from fair, then divide by fair to\n # compute the relative unfairness.\n diffs = (raw - fair) / fair\n if sort_by_unfairness:\n # Sort based on unfairness.\n diffs, indices = torch.sort(diffs)\n preds = preds[indices]\n labels = labels[indices]\n # Bucketize and compute bucket accuracies.\n num_samples = preds.size()[0]\n num_buckets = min(20 * (1 if sort_by_unfairness else 4), num_samples)\n num_per_bucket = math.floor(num_samples / num_buckets)\n assert num_per_bucket > 0, \\\n (\"There must be at least one sample per bucket, but there are \"\n f\"{num_samples} samples and only {num_buckets} buckets!\")\n # The resulting buckets are tuples of three values:\n # (x-axis value for bucket, number predicted correctly, total)\n buckets = [\n (x,\n self.check_output(preds_, labels_),\n preds_.size()[0])\n for x, preds_, labels_ in [\n # Each bucket is defined by a tuple of three values:\n # (x-axis value for bucket, predictions, ground truth labels).\n # The x-axis is the mean relative difference for this\n # bucket. A few values at the end may be discarded.\n (torch.mean(diffs[i:i + num_per_bucket]),\n preds[i:i + num_per_bucket],\n labels[i:i + num_per_bucket])\n for i in range(0, num_samples, num_per_bucket)]]\n if self.graph:\n assert graph_prms is not None, \\\n \"\\\"graph_prms\\\" must be a dict(), not None.\"\n assert \"flp\" in graph_prms, \"\\\"flp\\\" not in \\\"graph_prms\\\"!\"\n assert \"x_lim\" in graph_prms, \"\\\"x_lim\\\" not in \\\"graph_prms\\\"!\"\n # Plot each bucket's accuracy.\n pyplot.plot(\n ([x for x, _, _ in buckets]\n if sort_by_unfairness else list(range(len(buckets)))),\n [c / t for _, c, t in buckets], \"bo-\")\n pyplot.ylim((-0.1, 1.1))\n x_lim = graph_prms[\"x_lim\"]\n if x_lim is not None:\n pyplot.xlim(x_lim)\n pyplot.xlabel(\n \"Unfairness (fraction of fair)\"\n if sort_by_unfairness else \"Time\")\n pyplot.ylabel(\"Classification accuracy\")\n pyplot.tight_layout()\n pyplot.savefig(graph_prms[\"flp\"])\n pyplot.close()\n # Compute the overall accuracy.\n _, corrects, totals = zip(*buckets)\n acc = sum(corrects) / sum(totals)\n print(f\" Test accuracy: {acc * 100:.2f}%\")\n return acc","def topk_accuracy(scores, labels, ks, selected_class=None):\n if selected_class is not None:\n idx = labels == selected_class\n scores = scores[idx]\n labels = labels[idx]\n rankings = scores.argsort()[:, ::-1]\n # trim to max k to avoid extra computation\n maxk = np.max(ks)\n\n # compute true positives in the top-maxk predictions\n tp = rankings[:, :maxk] == labels.reshape(-1, 1)\n\n # trim to selected ks and compute accuracies\n return [tp[:, :k].max(1).mean() for k in ks]","def pred_agg1_train(df):\n new_feats = []\n pred_cols = [column for column in df.columns if \"pred\" in column]\n for c in pred_cols:\n tmp = (\n df.groupby([\"StudyInstanceUID\"])[c]\n .agg([\"min\", \"max\", \"mean\", \"std\"])\n .reset_index()\n )\n tmp.columns = [\n \"StudyInstanceUID\",\n c + \"_min\",\n c + \"_max\",\n c + \"_mean\",\n c + \"_std\",\n ]\n if c != \"any_pred_model_base\":\n del tmp[\"StudyInstanceUID\"]\n new_feats.append(tmp)\n new_feats = pd.concat(new_feats, axis=1)\n df = pd.merge(df, new_feats, on=\"StudyInstanceUID\", how=\"left\")\n for c in pred_cols:\n df[c + \"_diff\"] = df[c] - df[c + \"_mean\"]\n df[c + \"_div\"] = df[c] / df[c + \"_mean\"]\n df[c + \"_scaled\"] = (df[c] - df[c + \"_mean\"]) / df[c + \"_std\"]\n return df","def answer_q10():\n data_sources = [viz.DATA_111_URL, viz.DATA_290_URL, viz.DATA_896_URL]\n x_vals = range(6, 21)\n y_vals_hier = {}\n y_vals_kmean = {}\n for idx in range(len(data_sources)):\n # 0. Generate data_field & cluster_list\n clust_list, data_table = closest_pair.create_cluster_list(\n data_sources[idx])\n y_vals_hier[idx] = []\n # 1. calculate values for hierarchical - decreasing order\n for clust_size in reversed(x_vals):\n clust_list = closest_pair.hierarchical_clustering(clust_list,\n clust_size)\n clust_error = closest_pair.compute_distortions(clust_list,\n data_table)\n y_vals_hier[idx].insert(0, clust_error)\n # 2. calculate values for kmeans - decreasing order\n y_vals_kmean[idx] = []\n for clust_size in x_vals:\n clust_list, data_table = closest_pair.create_cluster_list(\n data_sources[idx])\n clust_list = closest_pair.kmeans_clustering(clust_list,\n clust_size, 5)\n clust_error = closest_pair.compute_distortions(clust_list,\n data_table)\n y_vals_kmean[idx].append(clust_error)\n return x_vals, y_vals_hier, y_vals_kmean","def test(df, partition, col='averageRating'):\n stats = community_stats(df, partition)\n stats = add_threshold(stats)\n df = df.merge(partition, on=['title']).merge(stats[['community', 'g']], on=['community'])\n g0, g1 = split_to_groups(df)\n\n summerize(col, df)\n levene_homogenity = run_levene(col, g0, g1)\n diff = g1[col] - g0[col]\n run_shapiro(diff)\n run_ttest(col, g0, g1, levene_homogenity.pvalue <= 0.05)","def getKSplitsStratified(df, n_splits, classColumn, seed = None):\n df_class1 = df[df[classColumn] == True]\n df_class2 = df[df[classColumn] == False]\n\n k_folds_class1 = getKSplits(df_class1, n_splits, seed)\n k_folds_class2 = getKSplits(df_class2, n_splits, seed)\n\n # combine\n k_folds_combined = []\n for i in range(n_splits):\n combined_fold = k_folds_class1[i].append(k_folds_class2[i])\n combined_fold_shuffled = combined_fold.sample(len(combined_fold), random_state = seed)\n k_folds_combined.append(combined_fold_shuffled)\n\n return k_folds_combined","def compute_random_baseline(self, classes):\n\n # based on the class distribution of the data\n sum_benefit = 0\n\n # c is the actual label\n # if the label in y is unseen when training, skip it, don't include it in the error\n for i, c in enumerate(self.y_chunk):\n for j, cprime in enumerate(classes):\n\n # (1) compute the benefit matrix\n benefit_c_cprime = 0\n if cprime == self.fraud_label:\n benefit_c_cprime = self.X_chunk[i][-1] - self.cost if c == self.fraud_label else -self.cost\n\n # (2) get the probability\n probab_ic = 1 / len(classes)\n sum_benefit += probab_ic * benefit_c_cprime\n\n return sum_benefit","def gen_class_weights(df):\n class_counts_df = df.select(\"tumor_score\").groupBy(\"tumor_score\").count()\n class_counts = {row[\"tumor_score\"]:row[\"count\"] for row in class_counts_df.collect()}\n max_count = max(class_counts.values())\n class_weights = {k-1:max_count/v for k,v in class_counts.items()}\n return class_weights","def cluster(players_df, columns):\n\toptimal_n=None\n\toptimal_clusters=None\n\toptimal_clusterer=None\n\toptimal_silhouette=-99\n\tfor n in range(2,9):\n\t\tclusterer=KMeans(n_clusters=n)\n\t\tcluster_labels=clusterer.fit_predict(players_df[columns])\n\t\tavg_silhouette=silhouette_score(players_df[columns], cluster_labels)\n\t\tprint('The avg silhouette score for {} clusters is {}'.format(n, avg_silhouette))\n\t\tif avg_silhouette > optimal_silhouette:\n\t\t\toptimal_silhouette=avg_silhouette\n\t\t\toptimal_clusterer=clusterer\n\t\t\toptimal_clusters=cluster_labels\n\t\t\toptimal_n=n\n\tprint('Returning optimal clusters found with n={}'.format(optimal_n))\n\tclusters = {n: [] for n in range(optimal_n)}\n\tfor i, label in enumerate(optimal_clusters):\n\t\tclusters[label].append(\n\t\t\tdict(\n\t\t\t\tplayer_id=players_df.iloc[i]['PERSON_ID'],\n\t\t\t\tfirst_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[-1],\n\t\t\t\tlast_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[0],\n\t\t\t\t)\n\t\t\t)\n\treturn clusters","def learn(self, Xtrain, ytrain):\n\n ### YOUR CODE HERE\n \n self.numfeatures = Xtrain.shape[1]\n numsamples = Xtrain.shape[0]\n #print (self.numfeatures)\n count = 0\n for i in ytrain:\n if (i>count):\n count+=1\n self.numclasses = count + 1\n \n if(self.params['usecolumnones']==False):\n b = np.ones((numsamples, self.numfeatures-1))\n b = Xtrain[:,:-1]\n Xtrain = b\n self.numfeatures -= 1\n # print(Xtrain.shape[1])\n\n ### END YOUR CODE\n\n origin_shape = (self.numclasses, self.numfeatures)\n self.means = np.zeros(origin_shape)\n self.stds = np.zeros(origin_shape)\n\n ### YOUR CODE HERE\n countclass = np.zeros(self.numclasses)\n for i in range (0, numsamples):\n k = int(ytrain[i])\n countclass[k] += 1\n for j in range (0, self.numfeatures):\n self.means[k][j]+=Xtrain[i][j]\n \n for i in range (0, self.numclasses):\n #np.true_divide(self.means[i], countclass[i])\n for j in range (0, self.numfeatures):\n self.means[i][j] = self.means[i][j]/(countclass[i]+1e-8)\n \n self.yprob = np.true_divide(countclass, numsamples)\n \n for i in range (0, numsamples):\n k = int(ytrain[i])\n for j in range (0, self.numfeatures):\n self.stds[k][j]+= (Xtrain[i][j] - self.means[k][j])**2\n # print (self.stds)\n \n for i in range (0, self.numclasses):\n #np.true_divide(self.stds[i], countclass[i])\n for j in range (0, self.numfeatures):\n self.stds[i][j] = self.stds[i][j]/(countclass[i]+1e-8)\n \n # print (self.means)\n # print (self.stds)\n ### END YOUR CODE\n\n assert self.means.shape == origin_shape\n assert self.stds.shape == origin_shape","def _orderFeatures(self, clf, class_selection=None):\n values = self.clf_desc.getImportance(clf,\n class_selection=class_selection)\n length = len(values)\n sorted_tuples = np.argsort(values).tolist()\n # Calculate rank in descending order\n result = [length - sorted_tuples.index(v) for v in range(length)]\n return result","def _orderFeatures(self, clf, class_selection=None):\n values = self.clf_desc.getImportance(clf,\n class_selection=class_selection)\n length = len(values)\n sorted_tuples = np.argsort(values).tolist()\n # Calculate rank in descending order\n result = [length - sorted_tuples.index(v) for v in range(length)]\n return result","def main():\n # Read in trainingSet and testSet as a DataFrame\n trainingOriginal = pd.read_csv(\n filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.train.5fold.csv\")\n testOriginal = pd.read_csv(filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.test.csv\")\n\n # Select only the numeric data\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\n training = pd.concat([training.reset_index(drop=True),\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Select only the numeric data\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\n test = pd.concat([test.reset_index(drop=True),\n testOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Normalize the columns for training and test\n # print training['age'].min()\n # print training['age'].max()\n # print training.head()\n\n # Run max-min normalization on numerical columns for testing and training data\n for i in range(6):\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\n\n # Convert the 'earns' column to boolean as follows\n training['earns'] = training['earns'] == '>50K'\n test['earns'] = test['earns'] == ' >50K'\n\n # Group the training set by the fold attribute as given by the dataset\n trainingForFinal = training\n training = training.groupby('fold')\n\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\n kList = []\n for i in range(40):\n if i % 2 == 1:\n kList.append(i)\n\n # Empty dictionary to hold performance of each k-values and its accuracy\n performance = {}\n\n # Compute the performance for each k-value\n for k in kList:\n performance = crossValidation(training, k, performance)\n\n # Sort the performance dictionary by its accuracy (value)\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\n\n # Open file to write results\n file = open('grid.results.txt', 'w')\n # Write the results to file\n file.write(\"K | Accuracy\\n\")\n for item in performance:\n if item[0] < 10:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n else:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n # Close file\n file.close()\n\n # The best K is the one at the top of the list after the sorting\n bestK = performance[0][0]\n\n print 'Running Test Set with K = ' + str(bestK)\n\n applyModel(test,trainingForFinal,bestK)","def score_classifier(\n X,\n y,\n clf,\n nfeats=None,\n scoring=default_scorers,\n score_aggreg=default_score_aggreg,\n scale=None,\n decompose=None,\n select=None,\n decompose_params={},\n nfolds=10,\n shuffle=True,\n random_fold_state=None,\n include_train_stats=False,\n):\n # give scoring and score_aggreg elements some names\n scoring = scoring or default_scorers\n scoring = mk_scoring_dict(scoring)\n score_aggreg = score_aggreg or default_score_aggreg\n score_aggreg = mk_score_aggreg_dict(score_aggreg)\n\n if nfeats is None:\n nfeats = np.shape(X)[1]\n\n # X = X[:, :nfeats]\n\n stratified_k_fold = StratifiedKFold(\n y, n_folds=nfolds, shuffle=shuffle, random_state=random_fold_state\n )\n score_info = list()\n for train, test in stratified_k_fold:\n d = dict()\n\n X_train, X_test, y_train, y_test = X[train], X[test], y[train], y[test]\n\n if include_train_stats:\n d['train_pts'] = np.shape(X_train)[0]\n d['train_nfeats'] = np.shape(X_train)[1]\n\n pipeline_steps = list()\n if scale: # preprocessing.StandardScaler(), preprocessing.MinMaxScaler()\n pipeline_steps.append(('scale', scale))\n if decompose:\n pipeline_steps.append(('decompose', decompose))\n if select:\n pipeline_steps.append(('select', feature_selection.SelectKBest(k=nfeats)))\n else:\n X = X[:, :nfeats]\n\n pipeline_steps.append(('clf', clf))\n\n pipeline = Pipeline(steps=pipeline_steps)\n\n pipeline.fit(X_train, y_train)\n y_pred = pipeline.predict(X_test)\n\n for score_name, score_fun in scoring.items():\n d[score_name] = score_fun(y_test, y_pred)\n score_info.append(d)\n\n # return score_info\n score_info = pd.DataFrame(score_info)\n score_result = pd.Series()\n for score_aggreg_name, score_aggreg_fun in score_aggreg.items():\n t = score_info.apply(score_aggreg_fun)\n t.set_axis(\n axis=0,\n labels=[\n mk_aggreg_score_name(score_aggreg_name, score_name)\n for score_name in t.index.values\n ],\n )\n score_result = score_result.append(t)\n\n return score_result","def decision_function(self, X):\n\n n, _ = X.shape\n\n # predict the cluster labels + distances to the clusters\n labels = self.base_clusterer.predict(X)\n # each dimension is the distance to the cluster centers (n_samples, n_clusters)\n distances = self.base_clusterer.transform(X)\n\n # compute scores\n scores = np.zeros(n, dtype=float)\n for i, l in enumerate(labels):\n if self.max_intra_cluster[l] < self.tol:\n point_deviation = 1.0\n else:\n point_deviation = distances[i, l] / self.max_intra_cluster[l]\n scores[i] = (\n point_deviation * self.cluster_deviation[l]\n ) / self.cluster_sizes[l]\n\n return scores","def createDecile(resp:pd.Series,score:pd.Series,buckets:int=10) -> pd.DataFrame: \n \n input_df=pd.DataFrame({'target_1':resp,'score':score}) \n input_df['target_0'] = 1-input_df['target_1'] \n input_df['decile'] = pd.qcut(input_df['score'],buckets,duplicates='drop')\n binned_df = input_df.groupby('decile', as_index = False)\n \n aggregated_df = pd.DataFrame()\n aggregated_df['min_score'] = binned_df.min().score.apply('{0:.3f}'.format)\n aggregated_df['max_score'] = binned_df.max().score.apply('{0:.3f}'.format)\n aggregated_df['target_1'] = binned_df.sum().target_1\n aggregated_df['target_0'] = binned_df.sum().target_0\n aggregated_df['total'] = (aggregated_df['target_1'] + aggregated_df['target_0'])\n aggregated_df['target_1_ratio'] = (aggregated_df['target_1'] / aggregated_df['total']).apply('{0:.1%}'.format)\n aggregated_df['mean_score'] = binned_df.mean().score.apply('{0:.3f}'.format) \n \n sorted_df = (aggregated_df.sort_values(by = 'max_score', ascending = False)).reset_index(drop = True)\n sorted_df['gain'] = (sorted_df['target_1'].cumsum()/sorted_df['target_1'].sum()).apply('{0:.1%}'.format)\n sorted_df['lift'] = ((sorted_df['target_1']/sorted_df.total)/(sorted_df['target_1'].sum()/sorted_df.total.sum())).apply('{0:.2f}'.format)\n sorted_df['KS'] = np.round(((sorted_df['target_1'] / sorted_df['target_1'].sum()).cumsum() - (sorted_df['target_0'] / sorted_df['target_0'].sum()).cumsum()), 4) * 100\n \n mark = lambda x: '◄─ ' if x == sorted_df.KS.max() else ''\n sorted_df['max_KS'] = sorted_df.KS.apply(mark)\n sorted_df.index +=1\n \n return sorted_df","def cluster_by_partitioning(active_sites):\n cls, sc = k_means(active_sites)\n\n return cls","def Demo_K_Means_Orch(log,\n\t\t\t\t train_data,\n\t\t\t\t class_label,\n\t\t\t\t cluster_range,\n\t\t\t\t silhouette_cluster_range,\n\t\t\t\t train_col_names = None, \n\t\t\t\t x_feature_index = 0,\n\t\t\t\t y_feature_index = 1,\n\t\t\t\t viz = False,\n\t\t\t\t show = False,\n\t\t\t\t viz_name = \"\",\n\t\t\t\t test_name = \"\"):\n\n\t\t\n\t#Strip and replace off any spaces\n\ttest_name = test_name.strip().replace(\" \",\"_\")\n\n\t#Initialize customer segmentation test\n\ttest = CustomerSegmentation(Method = KMeans(), \n\t\t\t\t\t\t\t\tdata = train_data,\n\t\t\t\t\t\t\t\tlog = log, \n\t\t\t\t\t\t\t\ttest_name = test_name)\n\n\n\t# Set train data and class labels\n\ttest.Preprocess.set_train_data(train_data, \n\t\t\t\t\t\t\t\t col_names = train_col_names)\n\ttest.Preprocess.set_class_label(class_label)\n\n\t# Conduct PCA, fit and transformation\n\ttest.Preprocess.PCA_fit(viz = viz, viz_name = viz_name, show = show)\n\ttest.Preprocess.PCA_transform()\n\n\n\tif viz:\n\t\t#Create cluster plot visualization if requested\n\t\tcluster_plot = cluster_viz(test.train_data, test.class_label, x_feature_index = x_feature_index, y_feature_index = y_feature_index)\n\t\t\n\t\t#Show the plot at runtime if requested\n\t\tif show:\n\t\t\tcluster_plot.show()\n\n\t\t#Save the image\n\t\ttest.Log.saveImage(cluster_plot, \"cluster_plot\", test.viz_folder_name)\n\n\t#Conduct elbow chart analysis\n\ttest.SegMethod.elbow_chart_test(cluster_range, viz = viz,show = show, viz_name = viz_name, profile = True)\n\n\t#Conduct Silhouette analysis\n\t#test.Preprocess.silhouette_analysis(silhouette_cluster_range, viz = viz, viz_name = viz_name, show = show)\n\n\t#Save Preprocess and Method logs\n\ttest.Preprocess.PreprocessLog.savePreprocessLog()\n\ttest.SegMethod.MethodLog.saveMethodLog()\n\n\t#Add final masterlog record\n\tlog.addMasterLogRecord(test)","def create_sigma_df(df_grouped, class_=0):\n sigma_all_list = []\n sigma_peak_list = []\n snid_list = []\n pred_class_list = []\n for SNID, SNID_df in df_grouped:\n arr_proba = SNID_df[f\"all_class{class_}\"]\n perc_16 = np.percentile(arr_proba, 16)\n perc_84 = np.percentile(arr_proba, 84)\n sigma_all_list.append(perc_84 - perc_16)\n\n arr_proba = SNID_df[f\"PEAKMJD_class{class_}\"]\n perc_16 = np.percentile(arr_proba, 16)\n perc_84 = np.percentile(arr_proba, 84)\n sigma_peak_list.append(perc_84 - perc_16)\n snid_list.append(SNID)\n\n # get predicition for this SNID\n k_all_probas = [k for k in SNID_df.keys() if \"all_class\" in k]\n median_prob_forSNID = SNID_df[k_all_probas].median()\n pred_class = median_prob_forSNID.idxmax()\n arr_proba = SNID_df[pred_class]\n # get sigma for this class\n perc_16 = np.percentile(arr_proba, 16)\n perc_84 = np.percentile(arr_proba, 84)\n pred_class_list.append(perc_84 - perc_16)\n\n df = pd.DataFrame()\n df[\"SNID\"] = np.array(snid_list)\n df[\"sigma_all\"] = np.array(sigma_all_list)\n df[\"sigma_peak\"] = np.array(sigma_peak_list)\n df[\"pred_sigma_all\"] = np.array(pred_class_list)\n return df","def calc_recommendation(df_train: pd.DataFrame, df_target: pd.DataFrame) -> pd.DataFrame:\n lookup_series = get_lookup_series(df_train)\n df_tc = df_target.copy()\n df_tc['item_recommendations'] = df_tc.apply(lambda x: sort_by_interaction(x, lookup_series), axis=1)\n df_out = df_tc[['user_id', 'session_id', 'timestamp', 'step', 'item_recommendations']]\n return df_out","def FormatAndSplit(df, cut_date):\n \n idx = np.isnan(df['NotionalEUR'])\n df = df.ix[~idx, :]\n ticker_idx = {tck: i for i, tck in enumerate(set(df['Ticker']))}\n df['TradeDateKey'] = pd.to_datetime(df['TradeDateKey'], format='%Y%m%d')\n train = df.ix[df[u'TradeDateKey'] <= cut_date, :]\n test = df.ix[df[u'TradeDateKey'] > cut_date, :]\n \n ddata = df.ix[df[\"BuySell\"] == \"Buy\", [u'CustomerNameIdx', u'NotionalEUR', u'Ticker', u'TradeDateKey']]\n\n data_train = pd.DataFrame.copy(ddata)\n data_train.ix[data_train[u'TradeDateKey'] <= cut_date, \"NotionalEUR\"] = 0\n \n data_test = pd.DataFrame.copy(ddata)\n data_test.ix[data_test[u'TradeDateKey'] > cut_date, \"NotionalEUR\"] = 0\n \n # Bucket ratings into quantiles.\n cut_count = 10\n n_bins = 4\n labels = range(1, n_bins + 1)\n \n train_dense = data_train.groupby(['CustomerNameIdx', 'Ticker'])\n train_dense = (train_dense['NotionalEUR']\n .agg({'NotionalSum' : np.sum, 'count' : 'count'})\n .reset_index())\n train_dense = (train_dense\n .groupby('CustomerNameIdx')\n .filter(lambda x: sum(x['count']) >= cut_count))\n# train_dense[u'NotionalRating'], bins = pd.qcut(\n# train_dense[u'NotionalSum'], n_bins, labels=labels, retbins=True)\n train_dense[u'NotionalRating'] = train_dense[u'NotionalSum']\n \n test_dense = data_test.groupby(['CustomerNameIdx', 'Ticker'])\n test_dense = (test_dense['NotionalEUR']\n .agg({'NotionalSum' : np.sum, 'count' : 'count'})\n .reset_index())\n test_dense = (test_dense.groupby('CustomerNameIdx')\n .filter(lambda x: sum(x['count']) >= cut_count))\n# test_dense[u'NotionalRating'] = pd.cut(\n# test_dense[u'NotionalSum'], bins, labels=labels)\n test_dense[u'NotionalRating'] = test_dense[u'NotionalSum']\n \n train_dense['Ticker'] = train_dense['Ticker'].map(lambda x: ticker_idx[x])\n test_dense['Ticker'] = test_dense['Ticker'].map(lambda x: ticker_idx[x])\n \n train_dense.drop(['count', 'NotionalSum'], axis=1, inplace=True)\n test_dense.drop(['count', 'NotionalSum'], axis=1, inplace=True)\n \n # Remove empty rows\n idx = ~np.isnan(np.array(train_dense['NotionalRating']))\n train_dense = train_dense[idx]\n idx = ~np.isnan(np.array(test_dense['NotionalRating']))\n test_dense = test_dense[idx]\n \n nb_CustomerNameIdxs = len(set(df['CustomerNameIdx']))\n nb_tickers = len(set(df['Ticker']))\n \n return (train, \n ToSparse(train_dense, nrow=nb_CustomerNameIdxs, ncol=nb_tickers),\n test, \n ToSparse(test_dense, nrow=nb_CustomerNameIdxs, ncol=nb_tickers), \n ticker_idx)","def k_fold_tree(data: pd.DataFrame, algorithm, folds: int = 5) -> (float, float):\n d = data.sample(frac=1)\n segments = np.array_split(d, folds)\n acc_test = []\n acc_train = []\n for i in range(folds):\n temp = segments.copy()\n test = temp.pop(i)\n\n test_labels = list(test['Labels'])\n\n train = pd.concat(temp)\n\n train_labels = list(train['Labels'])\n\n model = algorithm(train)\n\n test_predictions = predict_data(test, model)\n train_predictions = predict_data(train, model)\n\n acc_test.append(accuracy(test_predictions, test_labels))\n acc_train.append(accuracy(train_predictions, train_labels))\n\n return avg(acc_train), avg(acc_test)","def cross_val(model, data, n, target):\n scores = []\n splits = partition(data, n)\n for i in range(n):\n train_list = splits[:i] + splits[i+1:]\n train = pd.concat(train_list)\n test = splits[i]\n y_true = test[target]\n test = test.drop(columns=[target], axis=1)\n model.fit(train, estimator=BayesianEstimator, prior_type=\"BDeu\")\n y_pred = model.predict(test)\n acc = accuracy_score(y_pred[target], y_true)\n scores.append(acc)\n return scores","def k_fold_linear(data: pd.DataFrame, algorithm, folds: int = 5) -> (float, float):\n d = data.sample(frac=1)\n segments = np.array_split(d, folds)\n acc_test = []\n\n acc_train = []\n for i in range(folds):\n temp = segments.copy()\n\n test = temp.pop(i)\n train = pd.concat(temp)\n test_labels = list(test['Labels'])\n train_labels = list(train['Labels'])\n\n model = algorithm(train)\n test_predictions = [round(x, 1) for x in predict_linear_regression(test.drop(['Labels'], axis=1), model)]\n train_predictions = [round(x, 1) for x in predict_linear_regression(train.drop(['Labels'], axis=1), model)]\n\n Confusion_Matrix(test_predictions, test_labels)\n\n acc_test.append(accuracy(test_predictions, test_labels))\n acc_train.append(accuracy(train_predictions, train_labels))\n\n return avg(acc_train), avg(acc_test)","def k_means_montage(self, df, class_col):\n\n n_classes = df[class_col].nunique()\n for cl in sorted(df[class_col].unique()):\n montage_df = df[df[class_col] == cl].path\n imgs = [np.array(Image.open(img)) for img in montage_df]\n imgs = np.stack(imgs)\n plt.figure(figsize=(12, 15))\n plt.imshow(montage(imgs, multichannel=True).astype(np.uint8))\n plt.title(f\"Montage for Class{cl}\")","def get_best_split(rows):\n best_gain = 0\n best_question = None\n current_impurity = get_gini(rows)\n n_features = len(rows[0])\n\n for col in range(n_features):\n\n for row in rows:\n question = Question(col, row[col])\n true_rows, false_rows = partition(rows, question)\n\n if len(true_rows) == 0 or len(false_rows) == 0:\n break\n\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\n\n if question_gain >= best_gain:\n best_gain = question_gain\n best_question = question\n\n print(best_gain)\n print(best_question)\n return best_gain, best_question","def analyse_and_sort(self, df):\n if (type(df) is pd.Series):\n df = df.to_frame(\"score\")\n elif (type(df) is pd.DataFrame):\n df.columns = [\"score\"]\n df = self._filter(df)\n df = self._argrelmax(df)\n df = self._drop_close_extrema(df) # by = [deb1[0]]\n return df.sort_values(by=[\"score\"])[::-1]","def cal_hit_gbratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\n score = 0.0\n # golden items hit in the top_K items\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\n\n #print(np.mean(score_ratio))\n #print(score_1)\n #score = score_1 + score_2\n return np.mean(score_ratio)","def predictClusters(self, df, k):\n self.models.fitModels(df)\n return self.models.predict()","def get_product_means(df):\n try:\n mean_dataframe = df.groupby(['asin'])['overall'].mean()\n print mean_dataframe[:10]\n write_df_tocsv(mean_dataframe, 'product_means.csv')\n return mean_dataframe\n except Exception as e:\n print \"Error getting product means\"\n print str(e)\n pass","def calculate_average_precision_top_classes(local_list=local_list,\n class_names='',\n no_files_in_label=no_files_in_label,\n Q_stop='',\n no_of_points_for_zhou_precs=100,\n verbose=verbose):\n #\n # get the test class (this is the correct class or 'A')\n if class_names == '':\n top_mode_class, precs_of_tmc, no_of_classes_in_top_x, list_of_top_classes = find_zhou_precision(\n number_of_points=no_of_points_for_zhou_precs, local_list=local_list)\n # n.b.list_of_top_classes is not sorted on magnitude of items\n # test_class_list is sorted that way\n test_class_list=[x[0] for x in list_of_top_classes.most_common()]\n else:\n if class_names == str:\n print('Input test_class is not a list of classes! You probably wanted to use the function\\n'\n 'calculate_average_precision, not calculate_average_precision_top_class!\\n')\n else:\n test_class_list = class_name\n top_mode_class, precs_of_tmc, no_of_classes_in_top_x, list_of_top_classes = 0,0,0,0\n Ave_prec_x_list = []\n precs_x_list = []\n recall_x_list = []\n for test_class in test_class_list:\n Ave_precs_x, precs_x, recall_x = calculate_ave_precs_general(test_class=test_class,\n local_list=local_list,\n Q_stop=Q_stop,\n no_files_in_label=no_files_in_label,\n verbose=verbose)\n # have done all Q points now\n Ave_prec_x_list.append(Ave_precs_x)\n precs_x_list.append(precs_x)\n recall_x_list.append(recall_x)\n out = (top_mode_class, precs_of_tmc, no_of_classes_in_top_x,\n list_of_top_classes, Ave_prec_x_list, precs_x_list,\n recall_x_list, test_class_list)\n return out","def fit_predict(self, indexes, dataset_obj, sample_weight=None, sort_by_distance_to_mean=False):\n\n # Query data\n query_data = dataset_obj.data_matx[dataset_obj.query_idx]\n query_ids = dataset_obj.query_idx\n # Gallery data\n gallery_data = dataset_obj.data_matx[indexes]\n gallery_ids = indexes\n\n logging.info('Finding cluster mean positions.')\n # Fitted is the gallery id cluster labels in order\n fitted = sk_kmeans.fit_predict(\n self, dataset_obj.data_matx[indexes], None, sample_weight=sample_weight)\n logging.info('Done')\n cluster_means = self.cluster_centers_\n # Cluster ids for each different class\n cluster_ids = [[x for x in range(len(cluster_means))] for i in range(len(query_ids))]\n\n # Measure distances to cluster centres\n cluster_distance_matrix = pairwise_distances(query_data, cluster_means, metric=self.metric)\n\n cluster_ids_swapped = swap_indices(cluster_ids)\n\n cluster_gallery_ids = []\n cluster_gallery_data = []\n for cluster in range(len(cluster_ids_swapped)):\n valid_cluster_gallery_ids = gallery_ids[fitted == cluster]\n valid_cluster_gallery_data = dataset_obj.data_matx[valid_cluster_gallery_ids]\n cluster_gallery_ids.append(valid_cluster_gallery_ids)\n cluster_gallery_data.append(valid_cluster_gallery_data)\n\n gallery_distances_per_cluster = []\n for cluster in cluster_gallery_data:\n # Take only the gallery ids in the cluster\n gallery_distance_for_cluster = pairwise_distances(query_data, cluster, metric=self.metric)\n gallery_distances_per_cluster.append(gallery_distance_for_cluster)\n\n gallery_distances_per_cluster_swapped = swap_indices(gallery_distances_per_cluster) \n\n cluster_gallery_ids_stacked = [cluster_gallery_ids for i in range(len(gallery_distances_per_cluster_swapped))]\n\n sorted_gallery_distances_per_query = []\n sorted_gallery_ids_per_query = []\n for cluster_distances, gallery_distances, gallery_ids, index in zip(cluster_distance_matrix, gallery_distances_per_cluster_swapped, cluster_gallery_ids_stacked, range(len(cluster_distance_matrix))):\n sorted_gallery_distances_per_query.append(sort_by_another(gallery_distances, cluster_distances))\n sorted_gallery_ids_per_query.append(sort_by_another(gallery_ids, cluster_distances))\n\n num_query_items = len(sorted_gallery_distances_per_query)\n num_clusters = len(gallery_ids)\n num_gallery_items = len(gallery_data)\n\n double_sorted_gallery_distances_per_query = [[] for i in range(num_query_items)]\n double_sorted_gallery_ids_per_query = [[] for i in range(num_query_items)]\n for query_item, query_item_id, index1 in zip(sorted_gallery_distances_per_query, sorted_gallery_ids_per_query, range(len(sorted_gallery_distances_per_query))):\n for cluster, cluster_id, index2 in zip(query_item, query_item_id, range(len(query_item))):\n sorted_gallery_distances = sort_by_another(cluster, cluster)\n sorted_gallery_ids = sort_by_another(cluster_id, cluster)\n double_sorted_gallery_distances_per_query[index1].append(sorted_gallery_distances)\n double_sorted_gallery_ids_per_query[index1].append(sorted_gallery_ids)\n\n final_distance_array = []\n final_ids_array = []\n for distances, indexes in zip(double_sorted_gallery_distances_per_query, double_sorted_gallery_ids_per_query):\n final_distance_array.append([item for sublist in distances for item in sublist])\n final_ids_array.append([item for sublist in indexes for item in sublist])\n\n final_distance_array = np.array(final_distance_array)\n final_ids_array = np.array(final_ids_array)\n\n final_updated_distance_array = []\n final_updated_ids_array = []\n for distances, indexes, query_id in zip(final_distance_array, final_ids_array, range(num_query_items)):\n mask = [id_is_valid(gal_id, query_id, dataset_obj) for gal_id in indexes]\n redone_distances = np.append(distances[mask], ([-1] * 20))[:num_gallery_items]\n redone_indexes = np.append(indexes[mask], ([-1] * 20))[:num_gallery_items]\n final_updated_distance_array.append(redone_distances)\n final_updated_ids_array.append(redone_indexes)\n\n final_updated_distance_array = np.array(final_updated_distance_array)\n final_updated_ids_array = np.array(final_updated_ids_array)\n\n def gal_to_label(row_of_ids):\n return dataset_obj.labels[row_of_ids]\n\n final_updated_labels_array = np.stack([gal_to_label(row) for row in final_updated_ids_array])\n tensor_array = torch.tensor(np.array(final_updated_labels_array, dtype=np.int32))\n\n ranks = torch.stack([get_rank(row, i, dataset_obj) for i, row in enumerate(tensor_array)]).numpy()\n ranked_count = np.bincount(ranks.flatten())[1:-1]\n # CMC curve (percentage of query items which were in any particular rank or below)\n self.ranked_acc = np.cumsum(ranked_count / dataset_obj.query_idx.shape[0])\n\n return self","def calc_earning(self, data=None):\n result = Result()\n if data is None:\n data = self.security\n self.calcDecision()\n first_purchase_method = self.check_first_purchase_method()\n for i in np.arange(len(data['Close'])):\n if data['FinalDecision'].iloc[i] is None:\n pass\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\n self.buys_made += 1\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\n self.shares_own = self.stock_quantity\n self.buys_made += 1\n else:\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\n self.final_capital = self.final_capital % data['Close'].iloc[i]\n #print(self.shares_own)\n\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n pass\n else:\n self.final_capital += self.shares_own * data['Close'].iloc[i]\n self.shares_own = 0\n self.sells_made +=1\n #Checar si es el momento mas alto o bajo de ganancias\n if self.shares_own == 0:\n if (self.highest_point is None\n or self.highest_point < self.final_capital):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > self.final_capital\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n else:\n if (self.highest_point is None\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n self.calcRealFinalCapital()\n self.calcDiferencePercentage()","def create_classes(row):\n if(row[' shares'] <= 10):\n \n return 0\n elif( row[' shares'] > 10 and row[' shares'] <= 100 ):\n \n return 1\n elif( row[' shares'] > 100 and row[' shares'] <= 1000 ):\n \n return 2\n elif( row[' shares'] > 1000 and row[' shares'] <= 10000 ):\n \n return 3\n elif( row[' shares'] > 10000 and row[' shares'] <= 100000 ):\n \n return 4\n else:\n \n return 5","def compute_average_separability_score(self) -> Dict:\n avg_sep_score = {}\n for class_pair_key, class_pair_val in self.separability_scores.items():\n avg_sep_score[class_pair_key] = np.mean(np.array([val for _, val in class_pair_val.items()]))\n avg_sep_score['agg_with_risk'] = sum(\n np.array([val for _, val in avg_sep_score.items()]) *\n RISK\n ) \n avg_sep_score['agg'] = sum([val for key, val in avg_sep_score.items() if type(key)==int]) \n return avg_sep_score","def getKSplitsTwoClassesStratified(df, n_splits, classColumn1, classColumn2, seed = None):\n\n df_class1 = df[(df[classColumn1] == False) & (df[classColumn2] == False)]\n df_class2 = df[(df[classColumn1] == True) & (df[classColumn2] == True)]\n df_class3 = df[(df[classColumn1] == True) & (df[classColumn2] == False)]\n df_class4 = df[(df[classColumn1] == False) & (df[classColumn2] == True)]\n\n k_folds_class1 = getKSplits(df_class1, n_splits, seed)\n k_folds_class2 = getKSplits(df_class2, n_splits, seed)\n k_folds_class3 = getKSplits(df_class3, n_splits, seed)\n k_folds_class4 = getKSplits(df_class4, n_splits, seed)\n\n # combine\n k_folds_combined = []\n for i in range(n_splits):\n combined_fold = k_folds_class1[i].append(k_folds_class2[i]).append(k_folds_class3[i]).append(k_folds_class4[i])\n combined_fold_shuffled = combined_fold.sample(len(combined_fold), random_state = seed)\n k_folds_combined.append(combined_fold_shuffled)\n\n return k_folds_combined","def get_clusters_with_all_features(df, n_clusters):\n pipe = _build_model(df, use_pca=False, n_components=0, use_kmeans=True, n_clusters=n_clusters)\n labels = pipe.named_steps['kmeans'].labels_\n df.loc[:, 'labels'] = labels\n print(df.groupby('labels').agg(\n {'Fresh': 'mean', 'Milk': 'mean', 'Grocery': 'mean', 'Frozen': 'mean', 'Detergents_Paper': 'mean',\n 'Delicassen': 'mean'}))\n print(pipe.named_steps['scaler'].inverse_transform(pipe.named_steps['kmeans'].cluster_centers_))\n # cluster 1: low spending behaviour in general\n # cluster 2: high spending in detergents_paper, milk, grocery\n # cluster 3: high spending in fresh, rest low\n # cluster 4: high spending in everything except detergents_paper, extremely high in delicassen\n # cluster 5: medium spending in general, low in frozen, high in detergents and paper","def compute_cluster_class_fractions(k_means_model, y):\n\n n_classes = y.shape[1]\n class_labels = utils.one_hot_to_index(y)\n cluster_labels = k_means_model.labels_\n\n class_clustroid_counts = np.zeros((n_classes, K))\n for i in range(len(class_labels)):\n class_clustroid_counts[class_labels[i], cluster_labels[i]] += 1\n\n class_clustroid_fractions = class_clustroid_counts / np.sum(class_clustroid_counts, axis=1).reshape(n_classes, 1)\n\n print(\"\\n---- Class Clustroid Distribution ----\")\n for i in range(n_classes):\n print(\"Class {}: {}\".format(i, class_clustroid_fractions[i, :]))","def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\n res = []\n for n_clusters in n_clusters_considered:\n res.append([])\n for _ in range(n_repeats):\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\n print(X.val.shape)\n print(X_restricted.val.shape)\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\n res[-1].append(evaluator_X.weighted_average) \n return res","def choose_split_value(attrs, classes):\n indices = np.argsort(attrs)\n classes = classes[indices]\n attrs = attrs[indices]\n max_gain = 0.0\n max_gain_value = None\n for i in range(len(attrs) - 1):\n if classes[i] != classes[i+1]:\n mean = (attrs[i] + attrs[i+1]) / 2.0\n gain = inform_gain(attrs, classes, mean)\n if gain > max_gain:\n max_gain = gain\n max_gain_value = mean\n return max_gain_value, max_gain","def dataClust(resAttrDF, infCol = 'Dollars', resName = None):\n \n if resName is None:\n raise Exception('**** RESTAURANT NAME WAS NOT PROVIDED ****')\n \n ## COPY AND PREPROCESS RESTAURANT ATTRIBUTE DATA\n print(f'\\n**** PREPROCESSING AND CLUSTERING DATA ACCORDING TO...{infCol.upper()} COLUMN ****')\n\n k_clust = resAttrDF.copy()\n k_clust = k_clust.reset_index(drop = True)\n \n labelEncoder = LabelEncoder()\n k_clust['Name'] = labelEncoder.fit_transform(k_clust['Name'])\n for col in k_clust.columns:\n if k_clust[col].dtypes == 'object':\n k_clust[col] = pd.to_numeric(k_clust[col])\n\n kprot_data = k_clust.copy()\n for c in k_clust.select_dtypes(exclude='object').columns:\n pt = PowerTransformer()\n kprot_data[c] = pt.fit_transform(np.array(kprot_data[c]).reshape(-1, 1))\n\n categorical_columns = [0] ## MAKE SURE TO SPECIFY CURRECT INDICES\n\n ## ACTUAL CLUSTERING\n if infCol != 'Dollars':\n kproto = KPrototypes(n_clusters= len(k_clust[infCol].unique()), init='Cao', n_jobs = 4)\n clusters = kproto.fit_predict(kprot_data, categorical=categorical_columns)\n else:\n kproto = KPrototypes(n_clusters= len(k_clust['Dollars'].unique()), init='Cao', n_jobs = 4)\n clusters = kproto.fit_predict(kprot_data, categorical=categorical_columns) \n\n ## PRINT COUNT OF EACH CLUSTER GROUP\n print('The count for each cluster group is printed below')\n pd.Series(clusters).value_counts()\n \n ## EVALUATE CLUSTER ACCURACY WITH LGBMCLASSIFIER\n clf_kp = lgb.LGBMClassifier(colsample_by_tree=0.8, random_state=1)\n cv_scores_kp = cross_val_score(clf_kp, k_clust, clusters, scoring='f1_weighted')\n print(f'CV F1 score for K-Prototypes clusters is {np.mean(cv_scores_kp)}')\n\n ## PLOT INFLUENTIAL COLOUMNS\n clf_kp.fit(k_clust, clusters)\n explainer_kp = shap.TreeExplainer(clf_kp)\n shap_values_kp = explainer_kp.shap_values(k_clust)\n shap.summary_plot(shap_values_kp, k_clust, plot_type=\"bar\", plot_size=(15, 10))\n\n ## ADD CLUSTERS TO ORIGINAL DATAFRAME AND INVERSE LABEL ENCODE RESTAURANT NAMES\n k_clust['Cluster'] = clusters\n k_clust['Name'] = labelEncoder.inverse_transform(k_clust['Name'])\n\n ## FILTER RESTAURNAT CLUSTER OF CHOICE\n clusterVal = clusters[list(k_clust['Name']).index(resName)]\n k_clust = k_clust[k_clust['Cluster'] == clusterVal]\n k_clust = k_clust.reset_index(drop = True)\n k_clust = k_clust[['Name', 'ZipCode', 'Dollars', 'Photos']]\n\n print('**** CLUSTERING COMPLETED AND SAVING CLUSTER DATAFRAME LOCALLY ****\\n')\n resFileName = resName.replace(' ', '_')\n fileName = f'{resFileName.upper()}_CLUSTER_DATA.csv'\n k_clust.to_csv(fileName)\n\n return k_clust","def usefulness_score(model, test, train, k=20):\n distances = []\n test = test.tocsr()\n train = train.tocsr()\n (x, y, z) = sp.find(train.T)\n counts = np.bincount(x)\n counts += 1\n sums = np.bincount(x, weights=z)\n averages = sums / counts\n\n for user_id, row in enumerate(test):\n\n if not len(row.indices):\n continue\n\n predictions = -model.predict(user_id)\n\n if train is not None:\n rated = train[user_id].indices\n predictions[rated] = FLOAT_MAX\n\n rec_list = predictions.argsort()[:k]\n distances.append(np.mean(averages[rec_list]))\n return np.array(distances)","def predict(self, train_df: pd.DataFrame, test_df: pd.DataFrame) -> pd.DataFrame:\n\n # get feature list\n target_columns, features = PropensityModel.get_feature_and_target_columns(train_df)\n\n # predict propensities\n model_prediction_df_list = []\n for pred_df in [train_df, test_df]:\n x_test = pred_df[features]\n y_test = pred_df[target_columns]\n y_pred = self.model.predict_proba(x_test)\n \n # select second column (positive class) if there is only one target variable\n if len(self.target_variables) == 1:\n y_pred = y_pred[:,1]\n \n fold_predictions = pd.DataFrame(y_pred, columns=['prediction_'+x for x in self.target_variables])\n fold_predictions['sf_account_id'] = pred_df.index\n for column in target_columns:\n fold_predictions[column.replace('prediction_','target_')] = y_test[column].tolist()\n fold_predictions['train_or_test'] = pred_df.train_or_test.iloc[0]\n model_prediction_df_list += [fold_predictions]\n model_predictions = pd.concat(model_prediction_df_list, sort=False)\n\n return model_predictions","def train_predictors(market_data, functions_for_typical_price_data, functions_for_hlc_price_data, labels_for_typical_price_data, labels_for_hlc_price_data):\r\n standard = {}\r\n # high = market_data.loc[:, 'high'].values.tolist()\r\n # low = market_data.loc[:, 'low'].values.tolist()\r\n # close = market_data.loc[:, 'close'].values.tolist()\r\n volume = market_data.loc[:, 'volume'].values\r\n # typical_prices = typical_price(high, low, close)\r\n typical_prices = market_data.loc[:, 'weightedAverage'].values\r\n standard['volume'] = (np.nanmean(volume), np.nanstd(volume))\r\n standard['typical_price'] = (np.nanmean(typical_prices), np.nanstd(typical_prices))\r\n x = ((volume - standard['volume'][0])/standard['volume'][1])\r\n x = np.c_[(typical_prices - standard['typical_price'][0])/standard['typical_price'][1], x]\r\n typical_prices = typical_prices.tolist()\r\n for f, label in zip(functions_for_typical_price_data, labels_for_typical_price_data):\r\n values = np.array(f(typical_prices))\r\n standard[label] = (np.nanmean(values), np.nanstd(values))\r\n x = np.c_[x, (values - standard[label][0])/standard[label][1]]\r\n # for f, label in zip(functions_for_hlc_price_data, labels_for_hlc_price_data):\r\n # values = np.array(f(high, low, close))\r\n # if 'typical_price' in label and label != 'typical_price':\r\n # standard[label] = standard['typical_price']\r\n # else:\r\n # standard[label] = (np.nanmean(values), np.nanstd(values))\r\n # x = np.c_[x, (values - standard[label][0])/standard[label][1]]\r\n return pd.DataFrame(data=x, columns=['typical_price', 'volume']+labels_for_typical_price_data, index=market_data.index), standard","def cluster_by_range(df, lower_bound):\n global features_in_range\n # get total number of robot faces in data set\n total_rows = len(df)\n # determine the upper bound percentage\n upper_bound = 100 - lower_bound\n # lists of which columns to fix and which to cluster\n cols_to_fix = []\n cols_to_cluster = []\n # iterate over every column in dataframe\n for col in df:\n \"\"\"\n # drop any column we are ignoring\n if df[col].name in cols_to_ignore:\n df = df.drop(df[col].name, 1)\n continue\n \"\"\"\n if df[col].name not in cols_no_NA_option:\n df = df.drop(df[col].name, 1)\n continue\n # count & calculate percentage representation for each value of the column\n col_check = df.groupby(col).size().reset_index(name='count')\n col_check['as_percent'] = 100 * col_check['count'] / float(total_rows)\n # if percentage is over the upper bound, add it to list of features to fix\n if not col_check[col_check['as_percent'] >= upper_bound].empty:\n cols_to_fix.append(df[col].name)\n # if percentage is over the lower bound, add it to list of features to vary\n elif not col_check[col_check['as_percent'] >= lower_bound].empty \\\n and col_check[col_check['as_percent'] >= upper_bound].empty:\n cols_to_cluster.append(df[col].name)\n\n # generate clusters based on list of what features to vary\n groupby_result = df.groupby(cols_to_cluster).size().reset_index(name='count')\n groupby_result['as_percent'] = 100 * groupby_result['count'] / float(total_rows)\n groupby_result = groupby_result.sort_values(by='as_percent', ascending=False)\n\n # store list of features to test in a global list;\n # don't include count and percentage columns\n features_in_range = list(groupby_result)[:-2]\n\n cluster_by_split(groupby_result)\n\n \"\"\"\n # print results to file\n filename = str(lower_bound) + '_percent_clusters_noNA.tsv'\n groupby_result.to_csv(filename, header=True, sep='\\t')\n print(\"results written to file\")\n \"\"\"\n\n \"\"\"\n groupby_result = df.groupby(cols_to_fix).size().reset_index(name='count')\n groupby_result['as_percent'] = 100 * groupby_result['count'] / float(total_rows)\n groupby_result = groupby_result.sort_values(by='as_percent', ascending=False)\n print(\"cluster: %s, fix: %s, total: %s\"\n % (len(cols_to_cluster), len(cols_to_fix), count))\n print(\"RANGE: \", lower_bound, upper_bound)\n print(groupby_result.head(1))\n \"\"\"","def get_review_distribution(df):\n try:\n review_counts = df['overall'].value_counts()\n grouped = df.groupby(by='asin')['overall'].mean()\n grouped2 = df.groupby(['asin'])['overall'].agg(lambda x: x.value_counts().index[0])\n merged_group = pd.concat([grouped, grouped2], axis=1)\n merged_group.columns = ['mean', 'mode']\n merged_group['skew'] = np.where(merged_group['mean'] > merged_group['mode'], 'positive', 'negative')\n merged_group.ix[merged_group['mean'] == merged_group['mode'], 'skew'] = 'symmetrical'\n\n write_df_tocsv(merged_group, 'review_distribution.csv')\n except Exception as e:\n print \"Error getting review distribution\"\n print str(e)\n pass","def calc_skill_cluster_sets(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, blocks_one_clusnum, skill_str, seas):\r\n prec_arr, recall_arr, F1_arr, clus_num_arr = [], [], [], []\r\n\r\n prec_vals = sorted(np.unique(blocks_one_clusnum[skill_str].values), reverse = True)\r\n #loop through first element separately so that subsequent values can be appended\r\n node_cluster_set_test_str, ds_arr = [], []\r\n for prec in prec_vals:\r\n node_cluster_set_test_str_app = blocks_one_clusnum['set'][np.where(blocks_one_clusnum[skill_str]==prec)[0]].values\r\n for clus in node_cluster_set_test_str_app:\r\n #add cluster to cluster set\r\n node_cluster_set_test_str = np.append(node_cluster_set_test_str, clus)\r\n node_cluster_set_test_str = np.unique(node_cluster_set_test_str)\r\n node_num = len(node_cluster_set_test_str) # number of nodes in cluster set\r\n clus_num_arr.append(node_num)\r\n #calculate skill score of cluster set by calculating the number of days blocked from the GTD and selecting the season\r\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\r\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \"blocking\", dims={\"time\": GTD['time']})\r\n blocked_days_clus_xr['time'] = GTD['time']\r\n blocked_days_clus_sel = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\r\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_sel)\r\n prec_arr.append(prec)\r\n recall_arr.append(recall)\r\n F1_arr.append(F1)\r\n\r\n return clus_num_arr, prec_arr, recall_arr, F1_arr","def overfit_features(df):\r\n overfit = []\r\n for col in df.columns:\r\n counts = df[col].value_counts().iloc[0]\r\n if counts / len(df)*100 > 99.94:\r\n overfit.append(col)\r\n return overfit","def adjusted_ranking(df_ranking):\n\n # Creation of a list containing the Produtor, ordered by the maximum of Pontuacao that the Produtor gets in any\n # of its pairs\n\n # Transform the structure and contents of the Ranking DataFrame into something that can be useful\n df_ranking_usable = df_ranking.groupby([\"produtor\"]).max()\n df_ranking_usable = df_ranking_usable.reset_index()\n\n df_ranking_usable = df_ranking_usable[{\"produtor\", \"pontuacao\"}]\n df_ranking_usable = df_ranking_usable.sort_values(\"pontuacao\", ascending=False)\n\n # Create the list\n lista_prod = df_ranking_usable[\"produtor\"].tolist()\n\n # Create a DataFrame that has the ranking sorted by the name of the Produtor and that\n # for each Produtor, is sorted by the Pontuacao each of its Produtos has\n\n sorted_ranking = df_ranking.sort_values(\n by=[\"produtor\", \"pontuacao\"], ascending=False\n )\n\n # Create the final Adjusted Ranking\n\n ranking_ajustado = []\n\n for produtor in lista_prod:\n auxiliary_dict = {}\n auxiliary_dict[\"produtor\"] = produtor\n auxiliary_dict[\"produtos\"] = (\n sorted_ranking.loc[sorted_ranking[\"produtor\"] == produtor][\n {\"produto\", \"pontuacao\"}\n ]\n ).to_dict(\"records\")\n ranking_ajustado.append(auxiliary_dict)\n\n return ranking_ajustado","def find_best_split(rows):\n best_gain = 0 # keep track of the best information gain\n best_question = None # keep train of the feature / value that produced it\n current_uncertainty = gini(rows)\n n_features = len(rows[0]) - 1 # number of columns\n #print(\"n_features:\", n_features)\n\n for col in range(1,n_features): # for each feature\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\n values = set([row[col] for row in rows]) # unique values in the column\n for val in values: # for each value\n\n # Create a question object for each val under a column, holding the val and the col number\n question = Question(col, val)\n\n # try splitting the dataset\n true_rows, false_rows = partition(rows, question)\n\n # Skip this split if it doesn't divide the\n # dataset.\n if len(true_rows) == 0 or len(false_rows) == 0:\n continue\n\n # Calculate the information gain from this split\n gain = info_gain(true_rows, false_rows, current_uncertainty)\n\n # You actually can use '>' instead of '>=' here\n # but I wanted the tree to look a certain way for our\n # toy dataset.\n if gain >= best_gain:\n best_gain, best_question = gain, question\n\n return best_gain, best_question","def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\n self.merge_clusters([[6,98,99]])\n self.merge_clusters([[35,80]])\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\n self.merge_clusters([[76,98]])\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\n self.merge_clusters([[39,42]])\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\n self.merge_clusters([[70,101]])\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\n self.merge_clusters()\n return","def determine_best_split(data, potential_splits, mltask):\n\n first_iteration = True\n for column_index in potential_splits:\n for value in potential_splits[column_index]:\n data_below,data_above = split_data(data, column_index, value)\n \n if mltask == 'regression':\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\n \n # classification\n else:\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\n \n \n if first_iteration or current_overall_metric <= best_overall_metric:\n first_iteration = False\n \n best_overall_metric = current_overall_metric\n best_split_column = column_index\n best_split_value = value\n \n \n return best_split_column,best_split_value","def split_train_test(ratings):\r\n ratings = ratings.sample(frac=1).reset_index(drop=True)\r\n train_user_list = []\r\n train_item_list = []\r\n train_rating_list = []\r\n test_user_list = []\r\n test_item_list = []\r\n test_rating_list = []\r\n user_pool = set(ratings['userId'].unique())\r\n for idx in user_pool:\r\n flag = 0\r\n items = ratings[ratings['userId']==idx][['itemId','rating']]\r\n for i, row in items.iterrows():\r\n if flag == 0:\r\n test_user_list.append(int(idx))\r\n test_item_list.append(int(row['itemId']))\r\n test_rating_list.append(row['rating'])\r\n flag = 1\r\n else:\r\n train_user_list.append(int(idx))\r\n train_item_list.append(int(row['itemId']))\r\n train_rating_list.append(row['rating'])\r\n\r\n train = pd.DataFrame({'userId': train_user_list, 'itemId': train_item_list, 'rating': train_rating_list}, columns=['userId', 'itemId', 'rating'])\r\n test = pd.DataFrame({'userId': test_user_list, 'itemId': test_item_list, 'rating': test_rating_list}, columns=['userId', 'itemId', 'rating'])\r\n return [train, test]\r\n \r\n\r\n \r\n #train, test = train_test_split(ratings, test_size=0.1, shuffle=True)\r\n #return [train, test]\r","def k_means_model(df, numOfClusters):\n # Perform scaling on the dataframe containing the selected features\n data = scale(df)\n\n # Train a model\n model = KMeans(init=\"k-means++\", n_clusters=numOfClusters, n_init=20).fit(data)\n return model","def calculate_industry_neutral_nway_return(df, name, sorts, cuts, long_bucket, short_bucket, ind_col='sic1', ret_col='ret'):\n df = df.copy()\n\n # n-way sort\n keys = ['time_idx', ind_col]\n for sort, cut in zip(sorts, cuts):\n df[sort] = df.groupby(keys, as_index=False)[sort].transform(lambda x: pd.qcut(x, cut, range(cut)))\n keys.append(sort)\n\n # calculate bucket returns\n port_ret = df.groupby(['time_idx', ind_col] + sorts, as_index=False).agg({ret_col: 'mean', 'permno': 'count'})\n summary = port_ret.groupby(['time_idx'] + sorts, as_index=False)[[ret_col, 'permno']].apply(\n lambda x: pd.Series([np.average(x[ret_col], weights=x.permno), x.permno.sum()], index=['ret', 'avg count'])\n )\n\n hedged_bucket = summary.reset_index('time_idx').groupby('time_idx').apply(\n lambda x: pd.Series([\n (x.loc[long_bucket, 'ret'] - x.loc[short_bucket, 'ret']) / 2,\n (x.loc[long_bucket, 'avg count'] + x.loc[short_bucket, 'avg count']) / 2\n ], index=['ret', 'avg count'])\n )\n tmp = hedged_bucket.agg({'ret': ['mean', 'std'], 'avg count': 'mean'})\n hedged_bucket = pd.DataFrame({**{sorts[0]: ['hedged'],\n 'return': [tmp.loc['mean', 'ret']],\n 't stat': [tmp.loc['mean', 'ret'] / tmp.loc['std', 'ret']],\n 'avg count': [tmp.loc['mean', 'avg count']]}, **{x: '' for x in sorts[1:]}})\n\n summary = summary.groupby(sorts).agg({'ret': ['mean', 'std'], 'avg count': 'mean'}, axis=1)\n summary.columns = [\"_\".join(x) if x[1] != '' else x[0] for x in summary.columns.ravel()]\n summary['t stat'] = summary.ret_mean / summary.ret_std\n summary = summary.drop('ret_std', axis=1).rename({'ret_mean': 'return', 'avg count_mean': 'avg count'}, axis=1)\n summary = summary.reset_index()[sorts + ['return', 't stat', 'avg count']]\n summary = pd.concat([summary, hedged_bucket], axis=0, sort=False)\n\n # calculate hedged returns\n agg = port_ret.set_index(sorts).groupby(['time_idx', ind_col]).apply(\n lambda x: pd.Series([\n (x.loc[long_bucket, ret_col] - x.loc[short_bucket, ret_col]) / 2, # to maintain unit leverage\n (x.loc[long_bucket, ret_col]) / 2, # division by 2 to match same leverage of the long side\n (x.loc[short_bucket, ret_col]) / 2, # division by 2 to match same leverage of the short side\n (x.loc[long_bucket, 'permno'] + x.loc[short_bucket, 'permno']) / 2\n ], index=['ret', 'long_ret', 'short_ret', 'count'])\n )\n hedged = agg.groupby(level=0).apply(lambda x: np.average(x.ret, weights=x['count']))\n long = agg.groupby(level=0).apply(lambda x: np.average(x.long_ret, weights=x['count']))\n short = agg.groupby(level=0).apply(lambda x: np.average(x.short_ret, weights=x['count']))\n\n # plot\n avg = hedged.rolling(4, min_periods=4).sum()\n fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n fig.add_trace(go.Bar(y=avg, x=avg.index, name=name + ' Return'), secondary_y=False)\n fig.add_trace(go.Scatter(y=(1 + hedged).cumprod(), x=hedged.index, name=name + ' Equity'), secondary_y=True)\n fig.add_trace(go.Scatter(y=(1 + long).cumprod(), x=hedged.index, name=name + ' Long Equity'), secondary_y=True)\n fig.add_trace(go.Scatter(y=(1 + short).cumprod(), x=hedged.index, name=name + ' Short Equity'), secondary_y=True)\n fig.show()\n\n return {'name': name, 'equity': hedged, 'summary': summary, 'data': df}","def evaluate_percentage_of_class_for_each_flight(df_flights_info):\n df_new = df_flights_info[['FlightId', 'FareClass', 'Booking']]\n df_new = df_new.pivot(index='FlightId', columns='FareClass', values='Booking').astype(float)\n df_new.loc[:, 'Total'] = df_new.sum(axis=1).astype(float)\n for row, col in df_new.iterrows():\n for item in list(df_new):\n number_booking = df_new.loc[row, item]\n total_booking = df_new.loc[row]['Total']\n percentage = float(number_booking / total_booking)\n df_new.at[row, item] = percentage\n df_new = df_new.drop(columns=['Total'])\n df_new = df_new.stack()\n df_new = df_new.reset_index(level=[0, 1])\n df_flights_info = pandas.merge(df_flights_info, df_new, how='left', on=['FlightId', 'FareClass'])\n df_flights_info.rename(columns={0: 'Percentage'}, inplace=True)\n return df_flights_info","def cluster_kmeans(df, k):\r\n # Sample fron the original df\r\n sample_df=df.sample(n = k)\r\n obs, attr= df.shape\r\n # Make copies \r\n copy_df=df.copy()\r\n flag=0\r\n sse_old=0\r\n while (flag==0): \r\n sse=0\r\n Labels=[]\r\n for i in range(0, obs):\r\n dist= []\r\n for j in range(0,k):\r\n #Calculate Eucledian distance\r\n diff=list((df.iloc[i,:]-sample_df.iloc[j,:])**2)\r\n eu_dist=(sum(diff))**(1/attr)\r\n dist.append(eu_dist) \r\n #Add Labels to the observations based on the variable they are close to\r\n label=(dist.index(min(dist)))\r\n Labels.append(label)\r\n # Calculate SSE\r\n sse=sse+((min(dist) )**2)\r\n sse=sse**(1/2)\r\n copy_df['labels']=Labels\r\n # Stopping criteria is change in SSE should be 2 %\r\n if (sse_old !=0):\r\n if(abs(sse_old-sse)/sse_old<=0.05):\r\n flag=1 \r\n return_df=copy_df['labels'].to_frame()\r\n return (return_df, sse)\r\n else:\r\n sse_old=sse\r\n #Empty the sample df\r\n sample_df.drop(sample_df.index, inplace=True)\r\n # Now pick random values from each label and add it to the sample df\r\n for val in range(0,k):\r\n #Create new sample df\r\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\r\n else:\r\n sse_old=sse\r\n #Empty the sample df\r\n sample_df.drop(sample_df.index, inplace=True)\r\n for val in range(0,k):\r\n #Create new sample df \r\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])","def ite_best(train_df, test_df, features, outcome, treatment):\n train_t_df, train_c_df = split_treatment_control(train_df, treatment)\n\n by_feat_t = train_t_df.groupby(features)[outcome].mean()\n by_feat_c = train_c_df.groupby(features)[outcome].mean()\n by_feat = by_feat_t - by_feat_c\n\n return test_df[features].join(by_feat, on=features)[outcome].values"],"string":"[\n \"def get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test: pd.core.frame.DataFrame,\\n buy_clusters_list: List[int], sell_clusters_list: List[int]) -> tuple:\\n # if condition returns False, AssertionError is raised:\\n assert len(buy_clusters_list) != 0 and len(sell_clusters_list) != 0, \\\"Clusters list can't be empty.\\\"\\n\\n buy_clusters_mean_profit = \\\\\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(buy_clusters_list)]['profit'].mean()\\n sell_clusters_mean_profit = \\\\\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(sell_clusters_list)]['profit'].mean()\\n\\n return buy_clusters_mean_profit, sell_clusters_mean_profit\",\n \"def get_profit_per_cluster(df: pd.core.frame.DataFrame) -> pd.core.frame.DataFrame:\\n return pd.DataFrame(df.groupby(by='cluster')['profit'].mean(), columns=['profit']).reset_index()\",\n \"def clusterting_feature_importance (df, cluster_col):\\r\\n scores = pd.DataFrame()\\r\\n df0 = df.copy()\\r\\n df0 = df.select_dtypes(include=np.number)\\r\\n\\r\\n for i in df0[cluster_col].unique():\\r\\n df2 = df0[df0[cluster_col] == i]\\r\\n df2.drop(cluster_col,axis=1, inplace=True)\\r\\n #df2 = df.select_dtypes(include=np.number)\\r\\n scores[i] = df2.std() / (df2.max() - df2.min())\\r\\n scores['mean'] = scores.mean(axis = 1)\\r\\n\\r\\n scores = 1 - scores\\r\\n\\r\\n return scores\",\n \"def purity_score(label, pred):\\n \\n df = pd.concat([label, pd.DataFrame(pred)], axis=1)\\n df.set_axis(['label', 'pred'], axis=1, inplace=True)\\n \\n s = 0\\n\\n for x, cluster in df.groupby('pred'):\\n s += cluster['label'].value_counts().iloc[0] # adding the most occuring class in a cluster\\n\\n return s / label.shape[0]\",\n \"def score(self, df_X, ser_y):\\n df_predict = self.predict(df_X)\\n accuracies = []\\n for instance in ser_y.index:\\n # Accuracy is the probability of selecting the correct class\\n try:\\n accuracy = df_predict.loc[instance, ser_y.loc[instance]]\\n except:\\n import pdb; pdb.set_trace()\\n accuracies.append(accuracy)\\n return np.mean(accuracies)\",\n \"def ranking_metric(df, method, phenoPos, phenoNeg, classes, ascending): \\n \\n A = phenoPos\\n B = phenoNeg\\n df2 = df.T \\n df2['class'] = classes\\n df_mean= df2.groupby('class').mean().T\\n df_std = df2.groupby('class').std().T \\n #exclude any zero stds.\\n df_mean = df_mean[df_std.sum(axis=1) !=0]\\n df_std = df_std[df_std.sum(axis=1) !=0]\\n \\n if method == 'signal_to_noise':\\n sr = (df_mean[A] - df_mean[B])/(df_std[A] + df_std[B])\\n elif method == 't_test':\\n sr = (df_mean[A] - df_mean[B])/ np.sqrt(df_std[A]**2/len(df_std)+df_std[B]**2/len(df_std) )\\n elif method == 'ratio_of_classes':\\n sr = df_mean[A] / df_mean[B]\\n elif method == 'diff_of_classes':\\n sr = df_mean[A] - df_mean[B]\\n elif method == 'log2_ratio_of_classes':\\n sr = np.log2(df_mean[A] / df_mean[B])\\n else:\\n logging.error(\\\"Please provide correct method name!!!\\\") \\n sys.exit()\\n sr.sort_values(ascending=ascending, inplace=True)\\n df3 = sr.to_frame().reset_index()\\n df3.columns = ['gene_name','rank']\\n df3['rank2'] = df3['rank']\\n\\n return df3\",\n \"def cluster_means(self):\\n if self.evaluate_by is not None:\\n return(self.merged_data.groupby(\\n 'labels').mean().sort_values(self.evaluate_by).transpose())\\n else:\\n return(self.merged_data.groupby('labels').mean().transpose())\",\n \"def score(self, df_X, ser_y):\\n df_predict = self.predict(df_X)\\n missing_columns = set(ser_y).difference(\\n df_predict.columns)\\n for column in missing_columns:\\n df_predict[column] = np.repeat(0,\\n len(df_predict))\\n accuracies = []\\n for instance in ser_y.index:\\n # Accuracy is the probability of selecting the correct class\\n try:\\n accuracy = df_predict.loc[instance, ser_y.loc[instance]]\\n except:\\n import pdb; pdb.set_trace()\\n accuracies.append(accuracy)\\n return np.mean(accuracies)\",\n \"def classify():\\n yes_dataset = df[df[\\\"_class\\\"] == 1] # 470588\\n no_dataset = df[df[\\\"_class\\\"] == 0] # 1971\\n\\n parameter_analysis = list()\\n for criterion in np.arange(0.05, 0.91, 0.05):\\n print(\\\"doing experiment at criterion = %s ...\\\" % criterion)\\n rate_list = list()\\n for i in range(10):\\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\\n yes_index = yes_dataset.index.tolist()\\n random.shuffle(yes_index)\\n no_index = no_dataset.index.tolist()\\n random.shuffle(no_index)\\n \\n # concatenate 90%yes + 90%no, 10%yes + 10%no\\n train = pd.concat([\\n yes_dataset.loc[yes_index[:1774], :],\\n no_dataset.loc[no_index[:423530], :]\\n ])\\n test = pd.concat([\\n yes_dataset.loc[yes_index[1774:], :],\\n no_dataset.loc[no_index[423530:], :]\\n ]) \\n \\n # split data and label\\n train_data, train_label = (train[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n train[\\\"_class\\\"])\\n test_data, test_label = (test[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n test[\\\"_class\\\"])\\n \\n # apply classifier\\n clf = GaussianNB()\\n clf.fit(train_data, train_label)\\n probability = clf.predict_proba(test_data).T[1]\\n \\n result = pd.DataFrame()\\n result[\\\"_class\\\"] = test_label\\n result[\\\"_predict\\\"] = probability >= criterion\\n \\n result_yes = result[result[\\\"_class\\\"] == 1]\\n yes_yes_rate = sum(result_yes[\\\"_class\\\"] == result_yes[\\\"_predict\\\"])/len(result_yes[\\\"_predict\\\"])\\n \\n result_no = result[result[\\\"_class\\\"] == 0]\\n no_no_rate = sum(result_no[\\\"_class\\\"] == result_no[\\\"_predict\\\"])/len(result_no[\\\"_predict\\\"])\\n \\n rate_list.append((yes_yes_rate, no_no_rate))\\n\\n rate_list = pd.DataFrame(rate_list)\\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\\n \\n # save data to excel spreadsheet\\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\\\"criterion\\\", \\\"yes_yes_rate\\\", \\\"no_no_rate\\\"])\\n writer = pd.ExcelWriter(\\\"parameter_analysis.xlsx\\\")\\n parameter_analysis.to_excel(writer, \\\"parameter_analysis\\\", index=False)\\n writer.save()\",\n \"def wca_mean(X, k, df):\\n\\t\\n\\n\\t# Intializing the clusters\\t\\n\\tC = dict()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = pd.DataFrame()\\n\\n\\t# Calculating the mean vector\\n\\tmean_vector = X.mean()\\n\\n\\t# Choosing the seed points based on the minimum distance from the mean vector\\n\\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\\n\\tdist_means = X.sort_values(by='dist_mean')\\n\\t\\n\\t# Dropping the the datapoints which have already been assigned as seed\\n\\tidx_to_drop = dist_means.index[:k]\\n\\tdist_means.reset_index(drop=True,inplace=True)\\n\\tX.drop('dist_mean',axis=1,inplace=True)\\n\\tX.drop(idx_to_drop, inplace=True)\\n\\n\\t# Assigning seed points to the clusters\\n\\tmu = list()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\\n\\t mu.append(C[cluster].mean())\\n\\t\\n\\t# Running the algorithm\\t\\n\\t\\n\\t# Initializing the p-value list which would be used for plotting\\n\\tpval = dict()\\n\\n\\tfor cluster in range(k):\\n\\t pval[cluster] = dict()\\n\\t for i in C[0].columns:\\n\\t pval[cluster][i] = list()\\n\\n\\t# Algorithm\\n\\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\\n\\t for cluster in range(k):\\n\\n\\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\\n\\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\\n\\t dist_means = X.sort_values(by='dist_mean', ascending=False)\\n\\t idx_to_drop = dist_means.index[0]\\n\\t dist_means.reset_index(drop=True,inplace=True)\\n\\t X.drop('dist_mean',axis=1,inplace=True)\\n\\n\\t # Assigning the top value to the cluster\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\\n\\t C[cluster] = C[cluster].reset_index(drop=True)\\n\\t \\n\\t # Updating means of each cluster\\n\\t mu[cluster] = C[cluster].mean()\\n\\n\\t # Remove datapoint from X?\\n\\t X.drop(idx_to_drop,inplace=True)\\n\\t \\n\\t for i in C[0].columns:\\n\\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\\n\\n\\treturn(C,pval)\",\n \"def get_split(data):\\n \\\"\\\"\\\" gets the best feature, and best value \\\"\\\"\\\"\\n\\n best_feature = None\\n best_value = 0.0\\n columns = data.columns\\n gini_base = gini_impurity(data)\\n n_rows = len(data.index) # total number of rows of data before split\\n\\n # Fininding which split yields the best gini gain\\n max_gain = 0\\n\\n for i in range(len(columns)-1): # -1 b.c. class is final column\\n xs = data[columns[i]].unique() # get values to test\\n for x in xs: # test values\\n # split dataset\\n df_left = data[data[columns[i]] < x]\\n df_right = data[data[columns[i]] >= x]\\n\\n # get gini impurities\\n gini_left = gini_impurity(df_left)\\n gini_right = gini_impurity(df_right)\\n \\n\\n # Calculated weighted gini impurity\\n w_left = len(df_left.index) / n_rows\\n w_right = len(df_right.index) / n_rows\\n\\n w_gini = gini_left * w_left + gini_right * w_right\\n \\n\\n # Calculate gini gain (we want to minimize w_gini for the smallest impurity. Ideal split is perfect Left=c1, Right=c2)\\n # why not just find min w_gin instead of uding gini_gain and gini_base vaiables?\\n gini_gain = gini_base - w_gini\\n\\n # check if this is the best split so far, store values, update max_gini\\n if gini_gain > max_gain:\\n best_feature = columns[i]\\n best_value = x\\n max_gain = gini_gain\\n\\n df_left = data.loc[data[best_feature] < best_value]\\n df_right = data.loc[data[best_feature] >= best_value]\\n \\n\\n return best_feature, best_value, df_left, df_right\",\n \"def balance_classes(df):\\n df_class_0 = df[df[65]==0]\\n df_class_1 = df[df[65]==1]\\n df_count = df[65].value_counts()\\n count_0 = df_count[0]\\n count_1 = df_count[1]\\n\\n if count_0 > count_1:\\n df_class_1_over = df_class_1.sample(count_0, replace=True)\\n df_over = pd.concat([df_class_0, df_class_1_over], axis=0)\\n elif count_0 < count_1:\\n df_class_0_over = df_class_0.sample(count_1, replace=True)\\n df_over = pd.concat([df_class_1, df_class_0_over], axis=0)\\n else:\\n df_over = df\\n \\n return df_over\",\n \"def mid_market_price(orders: pandas.DataFrame):\\n return numpy.mean((best_bid_price(orders), best_ask_price(orders)))\",\n \"def create_strategy(filename: str, columns_list: List[str], som_width: int, som_height: int, n_iter: int, sigma=0.3,\\n learning_rate=0.01) -> tuple:\\n # get prepared data\\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\\n\\n # train som\\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\\n sigma=sigma, learning_rate=learning_rate)\\n\\n # get profit per cluster in train and test datasets\\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\\n df_profit_per_cluster_test = get_profit_per_cluster(final_df_test)\\n\\n # get mean profit for sell and buy class in training and testing datasets\\n try:\\n buy_clusters_mean_profit_train, buy_clusters_list, sell_clusters_mean_profit_train, sell_clusters_list = \\\\\\n get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train)\\n\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = \\\\\\n get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test, buy_clusters_list, sell_clusters_list)\\n # if the data was assigned to less than to 3 clusters\\n except:\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\\\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = None, None, None, None\\n\\n return len(df_profit_per_cluster_train), len(df_profit_per_cluster_test), \\\\\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\\\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test\",\n \"def stdConfidenceTrades(predictions, buy_confidence=1.5, sell_confidence=1.1):\\n smooth_preds = pd.Series(predictions).rolling(5).mean()\\n buy_thresh = np.mean(smooth_preds) + buy_confidence * np.std(smooth_preds)\\n sell_thresh = np.mean(smooth_preds) - sell_confidence * np.std(smooth_preds)\\n buy_positions = np.where(predictions > buy_thresh)[0]\\n sell_positions = np.where(predictions < sell_thresh)[0]\\n \\n buys = buy_positions\\n sells = []\\n curSell = 0\\n for curBuy in buys:\\n arr = np.where(sell_positions > curBuy)[0]\\n if len(arr):\\n sells.append(sell_positions[arr[0]])\\n tradePairs = list(zip(buys, sells))\\n return tradePairs\",\n \"def balence_classes(df, btol):\\r\\n #Find the least supported class and muliply by the tolerance coefficient to get max_count:\\r\\n ccounts = df['classification'].value_counts()\\r\\n max_count = np.min(ccounts.values) * btol\\r\\n #Create a new dataframe with balenced support:\\r\\n newdf = pd.DataFrame(columns=df.columns.values)\\r\\n for x in df.groupby('classification'):\\r\\n if x[1].shape[0] > max_count:\\r\\n newdf = newdf.append(x[1].sample(max_count).reset_index(drop=True))\\r\\n else:\\r\\n newdf = newdf.append(x[1].reset_index(drop=True))\\r\\n return newdf.reset_index(drop=True)\",\n \"def knn(trainingSetData, testSetData, k):\\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\\n testSet = testSetData.drop([14], axis=1) # drop income\\n\\n distances = {}\\n # this will store the distances re-sorted in ascending/descending order\\n sort = {}\\n # income band results (>=50k or <50K)\\n incomePredictions = []\\n\\n # Calculating euclidean distance between each row of training data and test data instance\\n for testInstance in range(len(testSet)): # len(testSet)\\n \\n # Store current test Point:\\n testInstance = testSet.iloc[testInstance] \\n \\n distances = euclideanDistanceRow(testInstance, trainingSet)\\n\\n # sort the distances in order of smallest first:\\n sorted_d = sorted(distances.items(), key=lambda x: x[1], reverse=False)\\n\\n neighbors = []\\n\\n # Extracting top k neighbors\\n for x in range(k):\\n neighbors.append(sorted_d[x])\\n\\n\\n classVotes = {}\\n\\n # Calculating the most freq class in the neighbors\\n results = {\\\"lessThan50\\\": 0, \\\"moreThan50\\\": 0}\\n\\n # creating a dataframe to which we will add the income values:\\n\\n for x in range(len(neighbors)):\\n if (trainingSetData.iloc[neighbors[x][0]][14] == 0.0):\\n results[\\\"lessThan50\\\"] += 1\\n elif (trainingSetData.iloc[neighbors[x][0]][14] == 1.0):\\n results[\\\"moreThan50\\\"] += 1\\n\\n print('results',results)\\n\\n if (results[\\\"lessThan50\\\"] > results[\\\"moreThan50\\\"]):\\n incomePredictions.append(0.0)\\n elif (results[\\\"lessThan50\\\"] < results[\\\"moreThan50\\\"]):\\n incomePredictions.append(1.0)\\n\\n return incomePredictions\",\n \"def prepareSplitClassifier(df, models, choice):\\n\\n\\n def classificationOutput(clf, X, Y):\\n \\\"\\\"\\\"\\n Fit the model and print the classification results\\n - confusion_matrix\\n - avg scores etc\\n \\\"\\\"\\\"\\n n_samples = 36\\n\\n print \\\"\\\\n\\\\nClassifier: \\\\n %s\\\" % (clf)\\n print \\\"#\\\" * 79\\n # classifier_gnb = naive_bayes.GaussianNB() # initiating the classifier\\n\\n clf.fit(X[:n_samples], Y[:n_samples]) # train on first n_samples and test on last 10\\n\\n expected = Y[n_samples:]\\n predicted = clf.predict(X[n_samples:])\\n print(\\\"Classification report:\\\\n%s\\\\n\\\" % (metrics.classification_report(expected, predicted)))\\n print(\\\"\\\\nConfusion matrix:\\\\n%s\\\" % metrics.confusion_matrix(expected, predicted))\\n\\n\\n\\n\\n def splitclassify(cDf):\\n \\\"\\\"\\\"\\n Given the dataframe combined with equal fair and unfair apps,\\n classify them\\n \\\"\\\"\\\"\\n cDf = cDf.reindex(np.random.permutation(cDf.index)) # shuffle the dataframe\\n featCols = set(cDf.columns)\\n featCols.remove('appLabel')\\n\\n features = cDf[list(featCols)].astype('float')\\n\\n ## Scale the features to a common range\\n min_max_scaler = preprocessing.MinMaxScaler()\\n X = min_max_scaler.fit_transform(features.values)\\n\\n Y = cDf['appLabel'].values\\n\\n\\n if choice == 'all':\\n for key in models:\\n classifier = models[key]\\n classificationOutput(classifier, X, Y)\\n else:\\n if choice in models:\\n classifier = models[choice]\\n classificationOutput(classifier, X, Y)\\n else:\\n print \\\"Incorrect Choice\\\"\\n\\n\\n\\n fairDf = df[df['appLabel'] == False]\\n unfairDf = df[df['appLabel'] == True]\\n\\n\\n # calculate total possible splits of fair data frame relatie to\\n # size of unfair dataframe\\n splits = len(fairDf) // len(unfairDf)\\n\\n for i in range(splits):\\n clDf = fairDf[i : i+len(unfairDf)].append(unfairDf)\\n\\n # print fairDf.values, unfairDf.values\\n print \\\"Classifying %d th split of fair apps with unfair app\\\" % (i)\\n print \\\"-\\\" * 79\\n splitclassify(clDf)\\n print \\\"\\\\n\\\\n\\\"\",\n \"def get_perf(self) :\\n self.train()\\n\\n prediction = self.clf.predict(self.df_test.drop(columns = 'up')[:-1])\\n self.accuracy = accuracy_score(df_test['up'][length:].values, prediction)\\n tn, fp, fn, tp = confusion_matrix(df_test['up'][length:].values, prediction).ravel()\\n self.recall = tp/(tp+fn)\\n self.specificity = tn / (tn+fp)\\n\\n\\n self.df_true = self.df_true[self.length:]\\n\\n profit = 1\\n mini = 1\\n maxi = 1\\n self.df_true['close'] = self.df_true['close'].map(lambda x : np.exp(x))\\n for s in range(1,len(self.df_true)):\\n if prediction[x-1] == 1 :\\n result = ((self.df_true['close'].iloc[s] -self.df_true['close'].iloc[s-1]) / self.df_true['close'].iloc[s-1]) + 1\\n profit = profit * result\\n if result < mini :\\n mini = result\\n if maxi < result :\\n maxi = result\\n self.mini = mini\\n self.maxi = maxi\\n self.profit = profit\",\n \"def generate_clusters(df):\\n\\n df_size = df.shape[0]\\n print(df_size)\\n n_clusters = 0\\n percent_min_pts = 0.105\\n min_clusters = 3\\n while (n_clusters != min_clusters):\\n print(\\\"percent_min_pts\\\", percent_min_pts)\\n min_cluster_pts = math.floor(df_size * percent_min_pts)\\n print(\\\"min_cluster_pts\\\", min_cluster_pts)\\n\\n clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_pts)\\n print(df.head())\\n clusterer.fit(df)\\n cluster_groups = {}\\n labels = clusterer.labels_\\n for i in labels:\\n if cluster_groups.get(i):\\n cluster_groups[i] = cluster_groups[i] + 1\\n else:\\n cluster_groups[i] = 1\\n print(\\\"cluster_groups\\\", cluster_groups)\\n n_clusters = len(set(labels))\\n print(\\\"n_clusters\\\", n_clusters)\\n multiplier = abs(n_clusters - min_clusters) * 0.001\\n print(\\\"multiplier\\\", multiplier)\\n if n_clusters > min_clusters:\\n percent_min_pts += multiplier\\n else:\\n percent_min_pts -= multiplier\\n print(\\\"percent_min_pts\\\", percent_min_pts)\\n return labels\",\n \"def cluster_by_split(filtered_df):\\n global features_in_range\\n global table\\n # make a copy of the entire data set\\n unfiltered_df = table\\n # get total number of robot faces in data set\\n total_rows = len(unfiltered_df)\\n\\n # drop any column that is not included in our list of 11 features\\n # 11 features = 16 features with no dependencies filtered via 20-80% range\\n for col in unfiltered_df:\\n if not unfiltered_df[col].name in features_in_range:\\n unfiltered_df = unfiltered_df.drop(unfiltered_df[col].name, 1)\\n\\n # iterate over the dataframe of columns generated by the range\\n for col in filtered_df:\\n try:\\n # for each column, call groupby() and calculate percentage\\n check_for_20 = unfiltered_df.groupby(col).size().reset_index(name='count')\\n check_for_20['as_percent'] = 100 * check_for_20['count'] / float(total_rows)\\n # ignore feature values that represent less than 20% of all faces\\n cluster_by_feature = check_for_20[check_for_20['as_percent'] >= 20]\\n # if feature has values over 20%, iterate over\\n # each feature_value and generate clusters\\n if not cluster_by_feature.empty:\\n # iterate over every value of the feature\\n for index, row in cluster_by_feature.iterrows():\\n # use feature value to call groupby() on the entire data set\\n results = unfiltered_df[unfiltered_df[col] == row[0]]\\n results = results \\\\\\n .groupby(list(unfiltered_df)) \\\\\\n .size() \\\\\\n .reset_index(name='count')\\n # calculate count as a percentage\\n results['as_percent'] = 100 * results['count'] / float(total_rows)\\n results = results.sort_values(by='as_percent', ascending=False)\\n # store results in a .tsv file\\n filename = str(col) + \\\"_\\\" + str(row[0]) + '_feature_cluster.tsv'\\n results.to_csv(filename.replace(\\\"/\\\", \\\"-\\\"), header=True, sep='\\\\t')\\n print(\\\"results written to file\\\")\\n except:\\n # 'count' and 'percentage' columns will generate errors\\n # since they don't exist in the original data set\\n pass\",\n \"def byMeans(dataset, number_of_clusters, class_header=\\\"Class\\\", verbosity=0, return_clusters=False):\\n if verbosity >= 2: # optionally print dataset shape and info\\n print(dataset.shape)\\n print(dataset)\\n\\n old_dataset = dataset.copy()\\n dataset = dataset.drop(columns=class_header) # remove non-float class column\\n\\n # Assign centroids to random values which fit into dataset space.\\n centroids = pandas.DataFrame(columns=dataset.columns,\\n data=numpy.random.uniform(dataset.min(), dataset.max(),\\n (number_of_clusters, dataset.shape[1])))\\n if verbosity >= 1: # optionally print centroids and random dataset\\n print(\\\"INITIAL CENTROIDS\\\")\\n print(centroids)\\n if verbosity >= 2:\\n print(\\\"DATAFRAME DATASET\\\")\\n print(dataset)\\n\\n for iterations in range(MAX_ITERATIONS): # Loop until MAX_ITERATIONS or settled\\n if verbosity >= 1: # optionally print iteration count\\n print(\\\"ITERATIONS\\\")\\n print(iterations)\\n\\n # calculate clustering of data\\n clusters = Cluster.calcClusters(dataset, centroids, number_of_clusters, verbosity=verbosity)\\n\\n old_centroids = centroids.copy() # copy centroid dataframe\\n\\n if verbosity >= 2: # optionally print cluster list\\n print(\\\"DATAFRAME ARRAY CLUSTERS\\\")\\n print(clusters)\\n\\n for cluster_index, cluster in enumerate(clusters): # Calculate new centroids\\n cluster_mean = cluster.mean()\\n if not cluster_mean.isnull().any(): # make sure we dont write null means to centroid list\\n centroids.loc[cluster_index] = cluster_mean\\n\\n if verbosity >= 1:\\n print(\\\"OLD CENTROIDS\\\")\\n print(old_centroids)\\n print(\\\"NEW CENTROIDS\\\")\\n print(centroids)\\n\\n if old_centroids is not None: # Calculate sum of centroid movements.\\n centroid_change = 0\\n for centroid_index, centroid in centroids.iterrows():\\n centroid_change += abs(Cluster.calcDistance(centroid, old_centroids.loc[centroid_index]))\\n\\n if verbosity >= 1:\\n print(\\\"CENTROID DIFF\\\")\\n print(centroid_change)\\n\\n if centroid_change < SETTLE_THRESHOLD: # break if centroid movement is below threshold.\\n break\\n\\n # Final Cluster re-calculation\\n clusters = Cluster.calcClusters(old_dataset, centroids, number_of_clusters,\\n verbosity=verbosity, class_header=class_header)\\n # Create new dataframe with class column of and row for each centroid\\n centroids_class = pandas.DataFrame(data=[\\\"NOCLASS\\\"] * centroids.shape[0], columns=[class_header])\\n if verbosity >= 2:\\n print(centroids_class)\\n print(centroids)\\n for cluster_index, cluster in enumerate(clusters): # For each cluster\\n if verbosity >= 2:\\n print(cluster_index)\\n print(cluster)\\n if cluster.size > 0: # If cluster is not empty set centroid class to most common class in cluster\\n centroids_class.iat[cluster_index, 0] = cluster.mode().loc[0][0]\\n if old_dataset.columns[0] == class_header: # check if class column should be first or last.\\n print(\\\"CLASS IS FIRST COL\\\")\\n centroids = pandas.concat([centroids_class, centroids], axis=1) # merge class to centroids as first column\\n else:\\n print(\\\"CLASS IS NOT FIRST COL\\\")\\n centroids = pandas.concat([centroids, centroids_class], axis=1) # merge class to centroids as last column\\n for centroid in centroids.iterrows(): # For each centroid\\n if centroid[1][class_header] is \\\"NOCLASS\\\": # Trim NOCLASS centroids (empty cluster)\\n centroids = centroids.drop(centroid[0])\\n centroids = centroids.reset_index(drop=True) # Reindex centroids\\n\\n if return_clusters is True: # optionally return cluster list\\n return centroids, clusters\\n pass\\n else:\\n return centroids # return centroids dataframe\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def calculate_kmeans(df, clusters=10):\\r\\n kmeans = KMeans(n_clusters=clusters)\\r\\n labels = kmeans.fit_predict(df)\\r\\n\\r\\n return kmeans, labels\",\n \"def cluster_importance(self, clf=DecisionTreeClassifier(), n_most_important=3):\\n\\n for k in xrange(self.n_clusters):\\n labels = (self.labels == k)\\n clf.fit(self.data.values, labels)\\n\\n print \\\"\\\\n ======== cluster {} / {} ========\\\".format(k + 1, self.n_clusters)\\n\\n sorted_importance = sorted(zip(clf.feature_importances_, self.data.columns), key=lambda (imp, col): imp, reverse=True)\\n sorted_importance = sorted_importance[:n_most_important]\\n\\n for imp, col in sorted_importance:\\n print \\\"[{:.5f} relative importance] {}\\\".format(imp, col)\\n print self.data.loc[labels, col].describe()\",\n \"def cluster_membership_occupancy(data):\\n \\n \\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n\\n if n_clusters == 0:\\n membership=[Cluster_Membership_Features()]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n areas=[Cluster_Area_Features()]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features()]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n \\n elif n_clusters ==1:\\n #obtain_total_cluster_areas_set_everything_else_to_default\\n membership=[Cluster_Membership_Features()]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n \\n try:\\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\\n except:\\n cluster_chull_areas=[0,0,0]\\n \\n Total_cluster_area=np.sum(cluster_chull_areas)\\n areas=[Cluster_Area_Features([Total_cluster_area,0,0,0,0,0,0,0,0])]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features()]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n \\n elif n_clusters >1:\\n #Summarizing the cluster membership distribution characteristics\\n cluster_size_nums=np.delete(np.array(data.groupby(['clusters']).size()),0)\\n (cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD)= distribution_statistics(cluster_size_nums)\\n\\n #For each cluster calculate the area by calculating the area of the convex hull of cluster members\\n # Note: concavehull implementation here might be a good addition as it will provide more imformative values. \\n\\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n try:\\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\\n except:\\n cluster_chull_areas=[0,0,0,0,0]\\n \\n\\n (avg_cluster_area,min_cluster_area,max_cluster_area,\\n std_cluster_area,CV_cluster_area,CD_cluster_area,\\n IQR_cluster_area,Quartile_CD_cluster_area)= distribution_statistics(cluster_chull_areas)\\n Total_cluster_area=np.sum(cluster_chull_areas)\\n\\n #Calculate cluster density: number of nuclei/ convex area of cluster\\n cluster_density=np.divide(cluster_size_nums,cluster_chull_areas)\\n (avg_cluster_density,min_cluster_density,max_cluster_density,\\n std_cluster_density,CV_cluster_density,CD_cluster_density,\\n IQR_cluster_density,Quartile_CD_cluster_density)= distribution_statistics(cluster_density)\\n\\n #return dataframe of features\\n membership=[Cluster_Membership_Features([cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD])]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n areas=[Cluster_Area_Features([Total_cluster_area,\\n avg_cluster_area,min_cluster_area,max_cluster_area,\\n std_cluster_area,CV_cluster_area,CD_cluster_area,\\n IQR_cluster_area,Quartile_CD_cluster_area])]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features([avg_cluster_density,min_cluster_density,max_cluster_density,\\n std_cluster_density,CV_cluster_density,CD_cluster_density,\\n IQR_cluster_density,Quartile_CD_cluster_density])]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n return all_features\",\n \"def features_sparseness(dat,sort=0): \\n \\n lblst=dat.columns.tolist()\\n ll=len(dat)\\n res=pd.Series(index=lblst,name='sparseness')\\n \\n for lb in lblst:\\n ct=dat[lb].value_counts()\\n res[lb]= ct.iloc[0]/ll\\n \\n if sort==1:\\n res.sort_values(ascending=True,inplace=True)\\n elif sort==-1:\\n res.sort_values(ascending=False,inplace=True)\\n else:\\n pass\\n \\n return res\",\n \"def makeRankDF(self, class_selection=None):\\n df_values = pd.DataFrame()\\n for idx, clf in enumerate(self.clfs):\\n df_values[idx] = pd.Series(self._orderFeatures(clf,\\n class_selection=class_selection),\\n index=self.features)\\n df_result = self._makeFeatureDF(df_values)\\n df_result = df_result.fillna(0)\\n return df_result.sort_values(cn.MEAN)\",\n \"def makeRankDF(self, class_selection=None):\\n df_values = pd.DataFrame()\\n for idx, clf in enumerate(self.clfs):\\n df_values[idx] = pd.Series(self._orderFeatures(clf,\\n class_selection=class_selection),\\n index=self.features)\\n df_result = self._makeFeatureDF(df_values)\\n df_result = df_result.fillna(0)\\n return df_result.sort_values(cn.MEAN)\",\n \"def grouping(data_clust):\\n data_grouped = data_clust.groupby('Clusters').mean()\\n return data_grouped\",\n \"def voting(y_pred_test, gnd_te):\\n df = pd.DataFrame({'y':y_pred_test, 'gnd':gnd_te})\\n df.sort_values(by=['y'], inplace=True, ascending=False)\\n out = df.groupby(['gnd']).mean()\\n return len(out[out['y'] > 0])/float(len(out))\",\n \"def purity_score(clusters, classes):\\n clusters = np.array(clusters)\\n classes = np.array(classes)\\n A = np.c_[(clusters,classes)]\\n\\n n_accurate = 0.\\n\\n for j in np.unique(A[:,0]):\\n z = A[A[:,0] == j, 1]\\n x = np.argmax(np.bincount(z))\\n n_accurate += len(z[z == x])\\n\\n return n_accurate / A.shape[0]\",\n \"def disaggregate_by_cluster(self):\\n # wt = np.zeros((1, self.ds.shape[1]))\\n # total = np.zeros((self.n_ahead, self.ds.shape[1]))\\n \\n agg_cluster_ds = np.zeros((self.n_ahead+1, self.n_clusters))\\n agg_cluster_ds[0] = self.ds_agg_by_c[-1]\\n agg_cluster_ds[1:] = self.ds_c_for\\n cluster_perc_change = np.diff(agg_cluster_ds, axis = 0) / agg_cluster_ds[:-1]\\n\\n cluster_scaling_vector = np.zeros((2, self.ds.shape[1]))\\n\\n # break down proportionally -> don't work well\\n # for c in range(self.n_clusters):\\n # c_m = self.ds.iloc[-self.cluster_n_period:, np.where(self.ds_c == c)[0]]\\n # c_sum = sum(c_m)\\n # indiv_sum = np.sum(c_m, axis = 0)\\n # wt[:,np.where(self.ds_c == c)[0]] = (indiv_sum/c_sum)\\n # total[:,np.where(self.ds_c == c)[0]] = np.reshape(\\n # np.repeat(self.ds_c_for[:,c], c_m.shape[1]), (self.n_ahead, c_m.shape[1]))\\n \\n # multiply by the perc change\\n \\n for i in range(self.ds_c.shape[0]):\\n cluster_scaling_vector[:,i] = cluster_perc_change[:,self.ds_c[i]]\\n cluster_scaling_vector = cluster_scaling_vector+1\\n cluster_scaling_vector = np.array(cluster_scaling_vector)\\n \\n self.ds_for = self.ds.copy()\\n\\n for yr in range(self.n_ahead)[::-1]:\\n # forecast on foretasted number\\n yr_ind = self.ds_for.index[-(yr+1)]\\n self.ds_for.ix[yr_ind] = self.ds_for.iloc[-(yr+2),:].values * cluster_scaling_vector[-(yr+1)]\\n\\n # self.ds_for.iloc[-(self.n_ahead):,:] = self.ds_for.iloc[-(self.n_ahead+1):-1,:].values * np.array(cluster_scaling_vector)\\n\\n # if negative -> 0\\n self.ds_for[self.ds_for < 0] = 0\",\n \"def OTU_table_ML(OTU_table,metadata,obj_col):\\n for ele in OTU_table.index:\\n #print(ele)\\n X.append(df.loc[ele])\\n Y.append(metadata[obj_col][ele])\\n precisions = []\\n for train_time in range(100): \\n X,Y = shuffle(X,Y)\\n sample_num = len(X)\\n sep_num = int(0.8*sample_num)\\n train_set = [X[:sep_num],Y[:sep_num]]\\n test_set = [X[sep_num:],Y[sep_num:]]\\n clf = svm.SVC(gamma='scale')\\n clf.fit(train_set[0], train_set[1]) \\n predict_result = clf.predict(test_set[0])\\n count = 0\\n for i in range(len(predict_result)):\\n if predict_result[i] == test_set[1][i]:\\n count += 1\\n else:\\n pass\\n precisions.append(1.0*count/len(predict_result))\\n print(np.mean(precisions))\",\n \"def test_splits(ratings_df, predict_method, k, test_size=250, splits=3):\\n mse_ls = []\\n for _ in range(splits):\\n test_ratings_df = ratings_df.sample(n=test_size)\\n train_ratings_df = ratings_df.drop(test_ratings_df.index)\\n model_params = matrix_cf.get_model_params(train_ratings_df)\\n _, mse = predict_method(test_ratings_df, k, model_params)\\n mse_ls.append(mse)\\n return np.array(mse_ls).mean()\",\n \"def naive_bayes(df):\\n\\n X = df.loc[:, :'perfs'].reset_index(drop=True)\\n y = df.loc[:, 'Popularity'].reset_index(drop=True).values\\n\\n # convert categorical data to numerical\\n for i in X.columns:\\n if type(X[i][0]) == str:\\n X[i] = X[i].astype(\\\"category\\\").cat.codes\\n # normalize the data\\n normDF = preprocessing.normalize(X, axis=0)\\n\\n X_train, X_validate, Y_train, Y_validate = train_test_split(normDF, y, test_size=0.2, random_state=42)\\n\\n gnb = GaussianNB()\\n gnb.fit(X_train, Y_train)\\n y_pred = gnb.predict(X_validate)\\n\\n kfold = KFold(n_splits=10, random_state=42, shuffle=False)\\n cv_results = cross_val_score(gnb, X_train, Y_train, cv=kfold, scoring='accuracy')\\n msg = \\\"%f (%f)\\\" % (cv_results.mean(), cv_results.std())\\n\\n print(\\\"Confusion Matrix\\\")\\n print(confusion_matrix(Y_validate, y_pred))\\n print(classification_report(Y_validate, y_pred))\\n print(\\\"Accuracy score of training data: \\\", msg)\\n print('Accuracy score of testing data: ', accuracy_score(Y_validate, y_pred))\\n print(\\\"\\\")\\n\\n return\",\n \"def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\\n learning_rate=0.01):\\n\\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\\n random_seed=0)\\n som.train(df_train, n_iter)\\n\\n # converting numpy arrays to dataframes\\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\\n\\n # creating column with cluster basing on model prediction\\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\\n\\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\\n # the script\\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\\n lsuffix='_org')\\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\\n lsuffix='_org')\\n\\n return final_df_train, final_df_test\",\n \"def cluster_means_scaled(self):\\n if self.evaluate_by is not None:\\n return(self.merged_scaled_data.groupby(\\n 'labels').mean().sort_values(self.evaluate_by).transpose())\\n else:\\n return(self.merged_scaled_data.groupby(\\n 'labels').mean().transpose())\",\n \"def eval_all(cls_prob, dtrain):\\n #determine the top k predictions\\n labels = dtrain.get_label()\\n top_k = cls_prob.argsort(axis = 1)[:,::-1][:,:5]\\n# top_k = cls_prob.argsort(axis = 1)[:,:k:-1]\\n #convert true values and compared with predictions to check for equality\\n labels = labels[:, None]\\n return 'error', 1-ndcg(top_k, labels)/len(labels)\",\n \"def purity(clusters, classes):\\n\\n d = defaultdict(list)\\n\\n # Get a list of class numbers of all examples in a cluster.\\n for k, v in zip(clusters, classes):\\n d[k].append(v)\\n\\n mayority = 0\\n\\n # Count the mayority class number and add it up over all clusters.\\n for k in d:\\n mayority += Counter(d[k]).most_common(1)[0][1]\\n\\n return float(mayority) / len(clusters)\",\n \"def k_means(n_clust, data_frame, true_labels):\\n k_means = KMeans(n_clusters=n_clust, random_state=123, n_init=30)\\n k_means.fit(data_frame)\\n c_labels = k_means.labels_\\n df = pd.DataFrame({'clust_label': c_labels, 'orig_label': true_labels.tolist()})\\n ct = pd.crosstab(df['clust_label'], df['orig_label'])\\n y_clust = k_means.predict(data_frame)\\n display(ct)\\n print('% 9s' % 'inertia homo compl v-meas ARI AMI silhouette')\\n print('%i %.3f %.3f %.3f %.3f %.3f %.3f'\\n % (k_means.inertia_,\\n homogeneity_score(true_labels, y_clust),\\n completeness_score(true_labels, y_clust),\\n v_measure_score(true_labels, y_clust),\\n adjusted_rand_score(true_labels, y_clust),\\n adjusted_mutual_info_score(true_labels, y_clust),\\n silhouette_score(data_frame, y_clust, metric='euclidean')))\",\n \"def crude_policy_selection(actor, clusters):\\n # read in results from optimisation\\n results = []\\n\\n for _, case in the_cases(actor).items():\\n temp = pd.read_csv(\\\"simulation/optimisation/\\\" + actor + \\\"/results_\\\" + case + \\\".csv\\\")\\n temp_ = pd.read_csv(\\\"simulation/optimisation/\\\" + actor + \\\"/convergence_\\\" + case + \\\".csv\\\")\\n results.append([temp, temp_])\\n\\n # collapse in 1 dataframe\\n opt_df = pd.DataFrame()\\n for i, (result, convergence) in enumerate(results):\\n result[\\\"scenario\\\"] = i\\n opt_df = pd.concat([opt_df, result], axis=0)\\n\\n # clean up\\n opt_df.reset_index(inplace=True, drop=True)\\n opt_df.drop_duplicates(inplace=True)\\n\\n # select policies + add scenario back\\n policies = opt_df.iloc[:, :-4]\\n policies = pd.concat([policies, opt_df[\\\"scenario\\\"]], axis=1)\\n\\n kmeans = KMeans(n_clusters=clusters, random_state=0).fit(policies.iloc[:, :-1])\\n\\n # get all policies in each cluster\\n policies['cluster'] = kmeans.labels_\\n groups = policies.groupby(by=\\\"cluster\\\")\\n groups = groups.obj.sort_values(\\\"cluster\\\", ascending=True)\\n\\n # assign values to each policy in each cluster\\n groups[\\\"value\\\"] = 0\\n for i in range(clusters):\\n group = groups.loc[groups[\\\"cluster\\\"] == i]\\n group = group.iloc[:, :-3]\\n scaler = preprocessing.MinMaxScaler().fit(group)\\n data_scaled = scaler.transform(group)\\n groups.at[group.index.values, 'value'] = data_scaled.sum(axis=1)\\n\\n # get the most extreme two per cluster\\n idx = []\\n for cluster in range(clusters):\\n idx.extend(groups.loc[groups[\\\"cluster\\\"] == cluster].sort_values(by=\\\"value\\\", ascending=False)[:2].index.values.tolist())\\n\\n return opt_df.iloc[idx]\",\n \"def __evaluate(self, preds, labels, raw, fair, sort_by_unfairness=False,\\n graph_prms=None):\\n # Compute the distance from fair, then divide by fair to\\n # compute the relative unfairness.\\n diffs = (raw - fair) / fair\\n if sort_by_unfairness:\\n # Sort based on unfairness.\\n diffs, indices = torch.sort(diffs)\\n preds = preds[indices]\\n labels = labels[indices]\\n # Bucketize and compute bucket accuracies.\\n num_samples = preds.size()[0]\\n num_buckets = min(20 * (1 if sort_by_unfairness else 4), num_samples)\\n num_per_bucket = math.floor(num_samples / num_buckets)\\n assert num_per_bucket > 0, \\\\\\n (\\\"There must be at least one sample per bucket, but there are \\\"\\n f\\\"{num_samples} samples and only {num_buckets} buckets!\\\")\\n # The resulting buckets are tuples of three values:\\n # (x-axis value for bucket, number predicted correctly, total)\\n buckets = [\\n (x,\\n self.check_output(preds_, labels_),\\n preds_.size()[0])\\n for x, preds_, labels_ in [\\n # Each bucket is defined by a tuple of three values:\\n # (x-axis value for bucket, predictions, ground truth labels).\\n # The x-axis is the mean relative difference for this\\n # bucket. A few values at the end may be discarded.\\n (torch.mean(diffs[i:i + num_per_bucket]),\\n preds[i:i + num_per_bucket],\\n labels[i:i + num_per_bucket])\\n for i in range(0, num_samples, num_per_bucket)]]\\n if self.graph:\\n assert graph_prms is not None, \\\\\\n \\\"\\\\\\\"graph_prms\\\\\\\" must be a dict(), not None.\\\"\\n assert \\\"flp\\\" in graph_prms, \\\"\\\\\\\"flp\\\\\\\" not in \\\\\\\"graph_prms\\\\\\\"!\\\"\\n assert \\\"x_lim\\\" in graph_prms, \\\"\\\\\\\"x_lim\\\\\\\" not in \\\\\\\"graph_prms\\\\\\\"!\\\"\\n # Plot each bucket's accuracy.\\n pyplot.plot(\\n ([x for x, _, _ in buckets]\\n if sort_by_unfairness else list(range(len(buckets)))),\\n [c / t for _, c, t in buckets], \\\"bo-\\\")\\n pyplot.ylim((-0.1, 1.1))\\n x_lim = graph_prms[\\\"x_lim\\\"]\\n if x_lim is not None:\\n pyplot.xlim(x_lim)\\n pyplot.xlabel(\\n \\\"Unfairness (fraction of fair)\\\"\\n if sort_by_unfairness else \\\"Time\\\")\\n pyplot.ylabel(\\\"Classification accuracy\\\")\\n pyplot.tight_layout()\\n pyplot.savefig(graph_prms[\\\"flp\\\"])\\n pyplot.close()\\n # Compute the overall accuracy.\\n _, corrects, totals = zip(*buckets)\\n acc = sum(corrects) / sum(totals)\\n print(f\\\" Test accuracy: {acc * 100:.2f}%\\\")\\n return acc\",\n \"def topk_accuracy(scores, labels, ks, selected_class=None):\\n if selected_class is not None:\\n idx = labels == selected_class\\n scores = scores[idx]\\n labels = labels[idx]\\n rankings = scores.argsort()[:, ::-1]\\n # trim to max k to avoid extra computation\\n maxk = np.max(ks)\\n\\n # compute true positives in the top-maxk predictions\\n tp = rankings[:, :maxk] == labels.reshape(-1, 1)\\n\\n # trim to selected ks and compute accuracies\\n return [tp[:, :k].max(1).mean() for k in ks]\",\n \"def pred_agg1_train(df):\\n new_feats = []\\n pred_cols = [column for column in df.columns if \\\"pred\\\" in column]\\n for c in pred_cols:\\n tmp = (\\n df.groupby([\\\"StudyInstanceUID\\\"])[c]\\n .agg([\\\"min\\\", \\\"max\\\", \\\"mean\\\", \\\"std\\\"])\\n .reset_index()\\n )\\n tmp.columns = [\\n \\\"StudyInstanceUID\\\",\\n c + \\\"_min\\\",\\n c + \\\"_max\\\",\\n c + \\\"_mean\\\",\\n c + \\\"_std\\\",\\n ]\\n if c != \\\"any_pred_model_base\\\":\\n del tmp[\\\"StudyInstanceUID\\\"]\\n new_feats.append(tmp)\\n new_feats = pd.concat(new_feats, axis=1)\\n df = pd.merge(df, new_feats, on=\\\"StudyInstanceUID\\\", how=\\\"left\\\")\\n for c in pred_cols:\\n df[c + \\\"_diff\\\"] = df[c] - df[c + \\\"_mean\\\"]\\n df[c + \\\"_div\\\"] = df[c] / df[c + \\\"_mean\\\"]\\n df[c + \\\"_scaled\\\"] = (df[c] - df[c + \\\"_mean\\\"]) / df[c + \\\"_std\\\"]\\n return df\",\n \"def answer_q10():\\n data_sources = [viz.DATA_111_URL, viz.DATA_290_URL, viz.DATA_896_URL]\\n x_vals = range(6, 21)\\n y_vals_hier = {}\\n y_vals_kmean = {}\\n for idx in range(len(data_sources)):\\n # 0. Generate data_field & cluster_list\\n clust_list, data_table = closest_pair.create_cluster_list(\\n data_sources[idx])\\n y_vals_hier[idx] = []\\n # 1. calculate values for hierarchical - decreasing order\\n for clust_size in reversed(x_vals):\\n clust_list = closest_pair.hierarchical_clustering(clust_list,\\n clust_size)\\n clust_error = closest_pair.compute_distortions(clust_list,\\n data_table)\\n y_vals_hier[idx].insert(0, clust_error)\\n # 2. calculate values for kmeans - decreasing order\\n y_vals_kmean[idx] = []\\n for clust_size in x_vals:\\n clust_list, data_table = closest_pair.create_cluster_list(\\n data_sources[idx])\\n clust_list = closest_pair.kmeans_clustering(clust_list,\\n clust_size, 5)\\n clust_error = closest_pair.compute_distortions(clust_list,\\n data_table)\\n y_vals_kmean[idx].append(clust_error)\\n return x_vals, y_vals_hier, y_vals_kmean\",\n \"def test(df, partition, col='averageRating'):\\n stats = community_stats(df, partition)\\n stats = add_threshold(stats)\\n df = df.merge(partition, on=['title']).merge(stats[['community', 'g']], on=['community'])\\n g0, g1 = split_to_groups(df)\\n\\n summerize(col, df)\\n levene_homogenity = run_levene(col, g0, g1)\\n diff = g1[col] - g0[col]\\n run_shapiro(diff)\\n run_ttest(col, g0, g1, levene_homogenity.pvalue <= 0.05)\",\n \"def getKSplitsStratified(df, n_splits, classColumn, seed = None):\\n df_class1 = df[df[classColumn] == True]\\n df_class2 = df[df[classColumn] == False]\\n\\n k_folds_class1 = getKSplits(df_class1, n_splits, seed)\\n k_folds_class2 = getKSplits(df_class2, n_splits, seed)\\n\\n # combine\\n k_folds_combined = []\\n for i in range(n_splits):\\n combined_fold = k_folds_class1[i].append(k_folds_class2[i])\\n combined_fold_shuffled = combined_fold.sample(len(combined_fold), random_state = seed)\\n k_folds_combined.append(combined_fold_shuffled)\\n\\n return k_folds_combined\",\n \"def compute_random_baseline(self, classes):\\n\\n # based on the class distribution of the data\\n sum_benefit = 0\\n\\n # c is the actual label\\n # if the label in y is unseen when training, skip it, don't include it in the error\\n for i, c in enumerate(self.y_chunk):\\n for j, cprime in enumerate(classes):\\n\\n # (1) compute the benefit matrix\\n benefit_c_cprime = 0\\n if cprime == self.fraud_label:\\n benefit_c_cprime = self.X_chunk[i][-1] - self.cost if c == self.fraud_label else -self.cost\\n\\n # (2) get the probability\\n probab_ic = 1 / len(classes)\\n sum_benefit += probab_ic * benefit_c_cprime\\n\\n return sum_benefit\",\n \"def gen_class_weights(df):\\n class_counts_df = df.select(\\\"tumor_score\\\").groupBy(\\\"tumor_score\\\").count()\\n class_counts = {row[\\\"tumor_score\\\"]:row[\\\"count\\\"] for row in class_counts_df.collect()}\\n max_count = max(class_counts.values())\\n class_weights = {k-1:max_count/v for k,v in class_counts.items()}\\n return class_weights\",\n \"def cluster(players_df, columns):\\n\\toptimal_n=None\\n\\toptimal_clusters=None\\n\\toptimal_clusterer=None\\n\\toptimal_silhouette=-99\\n\\tfor n in range(2,9):\\n\\t\\tclusterer=KMeans(n_clusters=n)\\n\\t\\tcluster_labels=clusterer.fit_predict(players_df[columns])\\n\\t\\tavg_silhouette=silhouette_score(players_df[columns], cluster_labels)\\n\\t\\tprint('The avg silhouette score for {} clusters is {}'.format(n, avg_silhouette))\\n\\t\\tif avg_silhouette > optimal_silhouette:\\n\\t\\t\\toptimal_silhouette=avg_silhouette\\n\\t\\t\\toptimal_clusterer=clusterer\\n\\t\\t\\toptimal_clusters=cluster_labels\\n\\t\\t\\toptimal_n=n\\n\\tprint('Returning optimal clusters found with n={}'.format(optimal_n))\\n\\tclusters = {n: [] for n in range(optimal_n)}\\n\\tfor i, label in enumerate(optimal_clusters):\\n\\t\\tclusters[label].append(\\n\\t\\t\\tdict(\\n\\t\\t\\t\\tplayer_id=players_df.iloc[i]['PERSON_ID'],\\n\\t\\t\\t\\tfirst_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[-1],\\n\\t\\t\\t\\tlast_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[0],\\n\\t\\t\\t\\t)\\n\\t\\t\\t)\\n\\treturn clusters\",\n \"def learn(self, Xtrain, ytrain):\\n\\n ### YOUR CODE HERE\\n \\n self.numfeatures = Xtrain.shape[1]\\n numsamples = Xtrain.shape[0]\\n #print (self.numfeatures)\\n count = 0\\n for i in ytrain:\\n if (i>count):\\n count+=1\\n self.numclasses = count + 1\\n \\n if(self.params['usecolumnones']==False):\\n b = np.ones((numsamples, self.numfeatures-1))\\n b = Xtrain[:,:-1]\\n Xtrain = b\\n self.numfeatures -= 1\\n # print(Xtrain.shape[1])\\n\\n ### END YOUR CODE\\n\\n origin_shape = (self.numclasses, self.numfeatures)\\n self.means = np.zeros(origin_shape)\\n self.stds = np.zeros(origin_shape)\\n\\n ### YOUR CODE HERE\\n countclass = np.zeros(self.numclasses)\\n for i in range (0, numsamples):\\n k = int(ytrain[i])\\n countclass[k] += 1\\n for j in range (0, self.numfeatures):\\n self.means[k][j]+=Xtrain[i][j]\\n \\n for i in range (0, self.numclasses):\\n #np.true_divide(self.means[i], countclass[i])\\n for j in range (0, self.numfeatures):\\n self.means[i][j] = self.means[i][j]/(countclass[i]+1e-8)\\n \\n self.yprob = np.true_divide(countclass, numsamples)\\n \\n for i in range (0, numsamples):\\n k = int(ytrain[i])\\n for j in range (0, self.numfeatures):\\n self.stds[k][j]+= (Xtrain[i][j] - self.means[k][j])**2\\n # print (self.stds)\\n \\n for i in range (0, self.numclasses):\\n #np.true_divide(self.stds[i], countclass[i])\\n for j in range (0, self.numfeatures):\\n self.stds[i][j] = self.stds[i][j]/(countclass[i]+1e-8)\\n \\n # print (self.means)\\n # print (self.stds)\\n ### END YOUR CODE\\n\\n assert self.means.shape == origin_shape\\n assert self.stds.shape == origin_shape\",\n \"def _orderFeatures(self, clf, class_selection=None):\\n values = self.clf_desc.getImportance(clf,\\n class_selection=class_selection)\\n length = len(values)\\n sorted_tuples = np.argsort(values).tolist()\\n # Calculate rank in descending order\\n result = [length - sorted_tuples.index(v) for v in range(length)]\\n return result\",\n \"def _orderFeatures(self, clf, class_selection=None):\\n values = self.clf_desc.getImportance(clf,\\n class_selection=class_selection)\\n length = len(values)\\n sorted_tuples = np.argsort(values).tolist()\\n # Calculate rank in descending order\\n result = [length - sorted_tuples.index(v) for v in range(length)]\\n return result\",\n \"def main():\\n # Read in trainingSet and testSet as a DataFrame\\n trainingOriginal = pd.read_csv(\\n filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.train.5fold.csv\\\")\\n testOriginal = pd.read_csv(filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.test.csv\\\")\\n\\n # Select only the numeric data\\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\\n training = pd.concat([training.reset_index(drop=True),\\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Select only the numeric data\\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\\n test = pd.concat([test.reset_index(drop=True),\\n testOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Normalize the columns for training and test\\n # print training['age'].min()\\n # print training['age'].max()\\n # print training.head()\\n\\n # Run max-min normalization on numerical columns for testing and training data\\n for i in range(6):\\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\\n\\n # Convert the 'earns' column to boolean as follows\\n training['earns'] = training['earns'] == '>50K'\\n test['earns'] = test['earns'] == ' >50K'\\n\\n # Group the training set by the fold attribute as given by the dataset\\n trainingForFinal = training\\n training = training.groupby('fold')\\n\\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\\n kList = []\\n for i in range(40):\\n if i % 2 == 1:\\n kList.append(i)\\n\\n # Empty dictionary to hold performance of each k-values and its accuracy\\n performance = {}\\n\\n # Compute the performance for each k-value\\n for k in kList:\\n performance = crossValidation(training, k, performance)\\n\\n # Sort the performance dictionary by its accuracy (value)\\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\\n\\n # Open file to write results\\n file = open('grid.results.txt', 'w')\\n # Write the results to file\\n file.write(\\\"K | Accuracy\\\\n\\\")\\n for item in performance:\\n if item[0] < 10:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n else:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n # Close file\\n file.close()\\n\\n # The best K is the one at the top of the list after the sorting\\n bestK = performance[0][0]\\n\\n print 'Running Test Set with K = ' + str(bestK)\\n\\n applyModel(test,trainingForFinal,bestK)\",\n \"def score_classifier(\\n X,\\n y,\\n clf,\\n nfeats=None,\\n scoring=default_scorers,\\n score_aggreg=default_score_aggreg,\\n scale=None,\\n decompose=None,\\n select=None,\\n decompose_params={},\\n nfolds=10,\\n shuffle=True,\\n random_fold_state=None,\\n include_train_stats=False,\\n):\\n # give scoring and score_aggreg elements some names\\n scoring = scoring or default_scorers\\n scoring = mk_scoring_dict(scoring)\\n score_aggreg = score_aggreg or default_score_aggreg\\n score_aggreg = mk_score_aggreg_dict(score_aggreg)\\n\\n if nfeats is None:\\n nfeats = np.shape(X)[1]\\n\\n # X = X[:, :nfeats]\\n\\n stratified_k_fold = StratifiedKFold(\\n y, n_folds=nfolds, shuffle=shuffle, random_state=random_fold_state\\n )\\n score_info = list()\\n for train, test in stratified_k_fold:\\n d = dict()\\n\\n X_train, X_test, y_train, y_test = X[train], X[test], y[train], y[test]\\n\\n if include_train_stats:\\n d['train_pts'] = np.shape(X_train)[0]\\n d['train_nfeats'] = np.shape(X_train)[1]\\n\\n pipeline_steps = list()\\n if scale: # preprocessing.StandardScaler(), preprocessing.MinMaxScaler()\\n pipeline_steps.append(('scale', scale))\\n if decompose:\\n pipeline_steps.append(('decompose', decompose))\\n if select:\\n pipeline_steps.append(('select', feature_selection.SelectKBest(k=nfeats)))\\n else:\\n X = X[:, :nfeats]\\n\\n pipeline_steps.append(('clf', clf))\\n\\n pipeline = Pipeline(steps=pipeline_steps)\\n\\n pipeline.fit(X_train, y_train)\\n y_pred = pipeline.predict(X_test)\\n\\n for score_name, score_fun in scoring.items():\\n d[score_name] = score_fun(y_test, y_pred)\\n score_info.append(d)\\n\\n # return score_info\\n score_info = pd.DataFrame(score_info)\\n score_result = pd.Series()\\n for score_aggreg_name, score_aggreg_fun in score_aggreg.items():\\n t = score_info.apply(score_aggreg_fun)\\n t.set_axis(\\n axis=0,\\n labels=[\\n mk_aggreg_score_name(score_aggreg_name, score_name)\\n for score_name in t.index.values\\n ],\\n )\\n score_result = score_result.append(t)\\n\\n return score_result\",\n \"def decision_function(self, X):\\n\\n n, _ = X.shape\\n\\n # predict the cluster labels + distances to the clusters\\n labels = self.base_clusterer.predict(X)\\n # each dimension is the distance to the cluster centers (n_samples, n_clusters)\\n distances = self.base_clusterer.transform(X)\\n\\n # compute scores\\n scores = np.zeros(n, dtype=float)\\n for i, l in enumerate(labels):\\n if self.max_intra_cluster[l] < self.tol:\\n point_deviation = 1.0\\n else:\\n point_deviation = distances[i, l] / self.max_intra_cluster[l]\\n scores[i] = (\\n point_deviation * self.cluster_deviation[l]\\n ) / self.cluster_sizes[l]\\n\\n return scores\",\n \"def createDecile(resp:pd.Series,score:pd.Series,buckets:int=10) -> pd.DataFrame: \\n \\n input_df=pd.DataFrame({'target_1':resp,'score':score}) \\n input_df['target_0'] = 1-input_df['target_1'] \\n input_df['decile'] = pd.qcut(input_df['score'],buckets,duplicates='drop')\\n binned_df = input_df.groupby('decile', as_index = False)\\n \\n aggregated_df = pd.DataFrame()\\n aggregated_df['min_score'] = binned_df.min().score.apply('{0:.3f}'.format)\\n aggregated_df['max_score'] = binned_df.max().score.apply('{0:.3f}'.format)\\n aggregated_df['target_1'] = binned_df.sum().target_1\\n aggregated_df['target_0'] = binned_df.sum().target_0\\n aggregated_df['total'] = (aggregated_df['target_1'] + aggregated_df['target_0'])\\n aggregated_df['target_1_ratio'] = (aggregated_df['target_1'] / aggregated_df['total']).apply('{0:.1%}'.format)\\n aggregated_df['mean_score'] = binned_df.mean().score.apply('{0:.3f}'.format) \\n \\n sorted_df = (aggregated_df.sort_values(by = 'max_score', ascending = False)).reset_index(drop = True)\\n sorted_df['gain'] = (sorted_df['target_1'].cumsum()/sorted_df['target_1'].sum()).apply('{0:.1%}'.format)\\n sorted_df['lift'] = ((sorted_df['target_1']/sorted_df.total)/(sorted_df['target_1'].sum()/sorted_df.total.sum())).apply('{0:.2f}'.format)\\n sorted_df['KS'] = np.round(((sorted_df['target_1'] / sorted_df['target_1'].sum()).cumsum() - (sorted_df['target_0'] / sorted_df['target_0'].sum()).cumsum()), 4) * 100\\n \\n mark = lambda x: '◄─ ' if x == sorted_df.KS.max() else ''\\n sorted_df['max_KS'] = sorted_df.KS.apply(mark)\\n sorted_df.index +=1\\n \\n return sorted_df\",\n \"def cluster_by_partitioning(active_sites):\\n cls, sc = k_means(active_sites)\\n\\n return cls\",\n \"def Demo_K_Means_Orch(log,\\n\\t\\t\\t\\t train_data,\\n\\t\\t\\t\\t class_label,\\n\\t\\t\\t\\t cluster_range,\\n\\t\\t\\t\\t silhouette_cluster_range,\\n\\t\\t\\t\\t train_col_names = None, \\n\\t\\t\\t\\t x_feature_index = 0,\\n\\t\\t\\t\\t y_feature_index = 1,\\n\\t\\t\\t\\t viz = False,\\n\\t\\t\\t\\t show = False,\\n\\t\\t\\t\\t viz_name = \\\"\\\",\\n\\t\\t\\t\\t test_name = \\\"\\\"):\\n\\n\\t\\t\\n\\t#Strip and replace off any spaces\\n\\ttest_name = test_name.strip().replace(\\\" \\\",\\\"_\\\")\\n\\n\\t#Initialize customer segmentation test\\n\\ttest = CustomerSegmentation(Method = KMeans(), \\n\\t\\t\\t\\t\\t\\t\\t\\tdata = train_data,\\n\\t\\t\\t\\t\\t\\t\\t\\tlog = log, \\n\\t\\t\\t\\t\\t\\t\\t\\ttest_name = test_name)\\n\\n\\n\\t# Set train data and class labels\\n\\ttest.Preprocess.set_train_data(train_data, \\n\\t\\t\\t\\t\\t\\t\\t\\t col_names = train_col_names)\\n\\ttest.Preprocess.set_class_label(class_label)\\n\\n\\t# Conduct PCA, fit and transformation\\n\\ttest.Preprocess.PCA_fit(viz = viz, viz_name = viz_name, show = show)\\n\\ttest.Preprocess.PCA_transform()\\n\\n\\n\\tif viz:\\n\\t\\t#Create cluster plot visualization if requested\\n\\t\\tcluster_plot = cluster_viz(test.train_data, test.class_label, x_feature_index = x_feature_index, y_feature_index = y_feature_index)\\n\\t\\t\\n\\t\\t#Show the plot at runtime if requested\\n\\t\\tif show:\\n\\t\\t\\tcluster_plot.show()\\n\\n\\t\\t#Save the image\\n\\t\\ttest.Log.saveImage(cluster_plot, \\\"cluster_plot\\\", test.viz_folder_name)\\n\\n\\t#Conduct elbow chart analysis\\n\\ttest.SegMethod.elbow_chart_test(cluster_range, viz = viz,show = show, viz_name = viz_name, profile = True)\\n\\n\\t#Conduct Silhouette analysis\\n\\t#test.Preprocess.silhouette_analysis(silhouette_cluster_range, viz = viz, viz_name = viz_name, show = show)\\n\\n\\t#Save Preprocess and Method logs\\n\\ttest.Preprocess.PreprocessLog.savePreprocessLog()\\n\\ttest.SegMethod.MethodLog.saveMethodLog()\\n\\n\\t#Add final masterlog record\\n\\tlog.addMasterLogRecord(test)\",\n \"def create_sigma_df(df_grouped, class_=0):\\n sigma_all_list = []\\n sigma_peak_list = []\\n snid_list = []\\n pred_class_list = []\\n for SNID, SNID_df in df_grouped:\\n arr_proba = SNID_df[f\\\"all_class{class_}\\\"]\\n perc_16 = np.percentile(arr_proba, 16)\\n perc_84 = np.percentile(arr_proba, 84)\\n sigma_all_list.append(perc_84 - perc_16)\\n\\n arr_proba = SNID_df[f\\\"PEAKMJD_class{class_}\\\"]\\n perc_16 = np.percentile(arr_proba, 16)\\n perc_84 = np.percentile(arr_proba, 84)\\n sigma_peak_list.append(perc_84 - perc_16)\\n snid_list.append(SNID)\\n\\n # get predicition for this SNID\\n k_all_probas = [k for k in SNID_df.keys() if \\\"all_class\\\" in k]\\n median_prob_forSNID = SNID_df[k_all_probas].median()\\n pred_class = median_prob_forSNID.idxmax()\\n arr_proba = SNID_df[pred_class]\\n # get sigma for this class\\n perc_16 = np.percentile(arr_proba, 16)\\n perc_84 = np.percentile(arr_proba, 84)\\n pred_class_list.append(perc_84 - perc_16)\\n\\n df = pd.DataFrame()\\n df[\\\"SNID\\\"] = np.array(snid_list)\\n df[\\\"sigma_all\\\"] = np.array(sigma_all_list)\\n df[\\\"sigma_peak\\\"] = np.array(sigma_peak_list)\\n df[\\\"pred_sigma_all\\\"] = np.array(pred_class_list)\\n return df\",\n \"def calc_recommendation(df_train: pd.DataFrame, df_target: pd.DataFrame) -> pd.DataFrame:\\n lookup_series = get_lookup_series(df_train)\\n df_tc = df_target.copy()\\n df_tc['item_recommendations'] = df_tc.apply(lambda x: sort_by_interaction(x, lookup_series), axis=1)\\n df_out = df_tc[['user_id', 'session_id', 'timestamp', 'step', 'item_recommendations']]\\n return df_out\",\n \"def FormatAndSplit(df, cut_date):\\n \\n idx = np.isnan(df['NotionalEUR'])\\n df = df.ix[~idx, :]\\n ticker_idx = {tck: i for i, tck in enumerate(set(df['Ticker']))}\\n df['TradeDateKey'] = pd.to_datetime(df['TradeDateKey'], format='%Y%m%d')\\n train = df.ix[df[u'TradeDateKey'] <= cut_date, :]\\n test = df.ix[df[u'TradeDateKey'] > cut_date, :]\\n \\n ddata = df.ix[df[\\\"BuySell\\\"] == \\\"Buy\\\", [u'CustomerNameIdx', u'NotionalEUR', u'Ticker', u'TradeDateKey']]\\n\\n data_train = pd.DataFrame.copy(ddata)\\n data_train.ix[data_train[u'TradeDateKey'] <= cut_date, \\\"NotionalEUR\\\"] = 0\\n \\n data_test = pd.DataFrame.copy(ddata)\\n data_test.ix[data_test[u'TradeDateKey'] > cut_date, \\\"NotionalEUR\\\"] = 0\\n \\n # Bucket ratings into quantiles.\\n cut_count = 10\\n n_bins = 4\\n labels = range(1, n_bins + 1)\\n \\n train_dense = data_train.groupby(['CustomerNameIdx', 'Ticker'])\\n train_dense = (train_dense['NotionalEUR']\\n .agg({'NotionalSum' : np.sum, 'count' : 'count'})\\n .reset_index())\\n train_dense = (train_dense\\n .groupby('CustomerNameIdx')\\n .filter(lambda x: sum(x['count']) >= cut_count))\\n# train_dense[u'NotionalRating'], bins = pd.qcut(\\n# train_dense[u'NotionalSum'], n_bins, labels=labels, retbins=True)\\n train_dense[u'NotionalRating'] = train_dense[u'NotionalSum']\\n \\n test_dense = data_test.groupby(['CustomerNameIdx', 'Ticker'])\\n test_dense = (test_dense['NotionalEUR']\\n .agg({'NotionalSum' : np.sum, 'count' : 'count'})\\n .reset_index())\\n test_dense = (test_dense.groupby('CustomerNameIdx')\\n .filter(lambda x: sum(x['count']) >= cut_count))\\n# test_dense[u'NotionalRating'] = pd.cut(\\n# test_dense[u'NotionalSum'], bins, labels=labels)\\n test_dense[u'NotionalRating'] = test_dense[u'NotionalSum']\\n \\n train_dense['Ticker'] = train_dense['Ticker'].map(lambda x: ticker_idx[x])\\n test_dense['Ticker'] = test_dense['Ticker'].map(lambda x: ticker_idx[x])\\n \\n train_dense.drop(['count', 'NotionalSum'], axis=1, inplace=True)\\n test_dense.drop(['count', 'NotionalSum'], axis=1, inplace=True)\\n \\n # Remove empty rows\\n idx = ~np.isnan(np.array(train_dense['NotionalRating']))\\n train_dense = train_dense[idx]\\n idx = ~np.isnan(np.array(test_dense['NotionalRating']))\\n test_dense = test_dense[idx]\\n \\n nb_CustomerNameIdxs = len(set(df['CustomerNameIdx']))\\n nb_tickers = len(set(df['Ticker']))\\n \\n return (train, \\n ToSparse(train_dense, nrow=nb_CustomerNameIdxs, ncol=nb_tickers),\\n test, \\n ToSparse(test_dense, nrow=nb_CustomerNameIdxs, ncol=nb_tickers), \\n ticker_idx)\",\n \"def k_fold_tree(data: pd.DataFrame, algorithm, folds: int = 5) -> (float, float):\\n d = data.sample(frac=1)\\n segments = np.array_split(d, folds)\\n acc_test = []\\n acc_train = []\\n for i in range(folds):\\n temp = segments.copy()\\n test = temp.pop(i)\\n\\n test_labels = list(test['Labels'])\\n\\n train = pd.concat(temp)\\n\\n train_labels = list(train['Labels'])\\n\\n model = algorithm(train)\\n\\n test_predictions = predict_data(test, model)\\n train_predictions = predict_data(train, model)\\n\\n acc_test.append(accuracy(test_predictions, test_labels))\\n acc_train.append(accuracy(train_predictions, train_labels))\\n\\n return avg(acc_train), avg(acc_test)\",\n \"def cross_val(model, data, n, target):\\n scores = []\\n splits = partition(data, n)\\n for i in range(n):\\n train_list = splits[:i] + splits[i+1:]\\n train = pd.concat(train_list)\\n test = splits[i]\\n y_true = test[target]\\n test = test.drop(columns=[target], axis=1)\\n model.fit(train, estimator=BayesianEstimator, prior_type=\\\"BDeu\\\")\\n y_pred = model.predict(test)\\n acc = accuracy_score(y_pred[target], y_true)\\n scores.append(acc)\\n return scores\",\n \"def k_fold_linear(data: pd.DataFrame, algorithm, folds: int = 5) -> (float, float):\\n d = data.sample(frac=1)\\n segments = np.array_split(d, folds)\\n acc_test = []\\n\\n acc_train = []\\n for i in range(folds):\\n temp = segments.copy()\\n\\n test = temp.pop(i)\\n train = pd.concat(temp)\\n test_labels = list(test['Labels'])\\n train_labels = list(train['Labels'])\\n\\n model = algorithm(train)\\n test_predictions = [round(x, 1) for x in predict_linear_regression(test.drop(['Labels'], axis=1), model)]\\n train_predictions = [round(x, 1) for x in predict_linear_regression(train.drop(['Labels'], axis=1), model)]\\n\\n Confusion_Matrix(test_predictions, test_labels)\\n\\n acc_test.append(accuracy(test_predictions, test_labels))\\n acc_train.append(accuracy(train_predictions, train_labels))\\n\\n return avg(acc_train), avg(acc_test)\",\n \"def k_means_montage(self, df, class_col):\\n\\n n_classes = df[class_col].nunique()\\n for cl in sorted(df[class_col].unique()):\\n montage_df = df[df[class_col] == cl].path\\n imgs = [np.array(Image.open(img)) for img in montage_df]\\n imgs = np.stack(imgs)\\n plt.figure(figsize=(12, 15))\\n plt.imshow(montage(imgs, multichannel=True).astype(np.uint8))\\n plt.title(f\\\"Montage for Class{cl}\\\")\",\n \"def get_best_split(rows):\\n best_gain = 0\\n best_question = None\\n current_impurity = get_gini(rows)\\n n_features = len(rows[0])\\n\\n for col in range(n_features):\\n\\n for row in rows:\\n question = Question(col, row[col])\\n true_rows, false_rows = partition(rows, question)\\n\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n break\\n\\n question_gain = get_info_gain(true_rows, false_rows, current_impurity)\\n\\n if question_gain >= best_gain:\\n best_gain = question_gain\\n best_question = question\\n\\n print(best_gain)\\n print(best_question)\\n return best_gain, best_question\",\n \"def analyse_and_sort(self, df):\\n if (type(df) is pd.Series):\\n df = df.to_frame(\\\"score\\\")\\n elif (type(df) is pd.DataFrame):\\n df.columns = [\\\"score\\\"]\\n df = self._filter(df)\\n df = self._argrelmax(df)\\n df = self._drop_close_extrema(df) # by = [deb1[0]]\\n return df.sort_values(by=[\\\"score\\\"])[::-1]\",\n \"def cal_hit_gbratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \\n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\\n\\n #print(np.mean(score_ratio))\\n #print(score_1)\\n #score = score_1 + score_2\\n return np.mean(score_ratio)\",\n \"def predictClusters(self, df, k):\\n self.models.fitModels(df)\\n return self.models.predict()\",\n \"def get_product_means(df):\\n try:\\n mean_dataframe = df.groupby(['asin'])['overall'].mean()\\n print mean_dataframe[:10]\\n write_df_tocsv(mean_dataframe, 'product_means.csv')\\n return mean_dataframe\\n except Exception as e:\\n print \\\"Error getting product means\\\"\\n print str(e)\\n pass\",\n \"def calculate_average_precision_top_classes(local_list=local_list,\\n class_names='',\\n no_files_in_label=no_files_in_label,\\n Q_stop='',\\n no_of_points_for_zhou_precs=100,\\n verbose=verbose):\\n #\\n # get the test class (this is the correct class or 'A')\\n if class_names == '':\\n top_mode_class, precs_of_tmc, no_of_classes_in_top_x, list_of_top_classes = find_zhou_precision(\\n number_of_points=no_of_points_for_zhou_precs, local_list=local_list)\\n # n.b.list_of_top_classes is not sorted on magnitude of items\\n # test_class_list is sorted that way\\n test_class_list=[x[0] for x in list_of_top_classes.most_common()]\\n else:\\n if class_names == str:\\n print('Input test_class is not a list of classes! You probably wanted to use the function\\\\n'\\n 'calculate_average_precision, not calculate_average_precision_top_class!\\\\n')\\n else:\\n test_class_list = class_name\\n top_mode_class, precs_of_tmc, no_of_classes_in_top_x, list_of_top_classes = 0,0,0,0\\n Ave_prec_x_list = []\\n precs_x_list = []\\n recall_x_list = []\\n for test_class in test_class_list:\\n Ave_precs_x, precs_x, recall_x = calculate_ave_precs_general(test_class=test_class,\\n local_list=local_list,\\n Q_stop=Q_stop,\\n no_files_in_label=no_files_in_label,\\n verbose=verbose)\\n # have done all Q points now\\n Ave_prec_x_list.append(Ave_precs_x)\\n precs_x_list.append(precs_x)\\n recall_x_list.append(recall_x)\\n out = (top_mode_class, precs_of_tmc, no_of_classes_in_top_x,\\n list_of_top_classes, Ave_prec_x_list, precs_x_list,\\n recall_x_list, test_class_list)\\n return out\",\n \"def fit_predict(self, indexes, dataset_obj, sample_weight=None, sort_by_distance_to_mean=False):\\n\\n # Query data\\n query_data = dataset_obj.data_matx[dataset_obj.query_idx]\\n query_ids = dataset_obj.query_idx\\n # Gallery data\\n gallery_data = dataset_obj.data_matx[indexes]\\n gallery_ids = indexes\\n\\n logging.info('Finding cluster mean positions.')\\n # Fitted is the gallery id cluster labels in order\\n fitted = sk_kmeans.fit_predict(\\n self, dataset_obj.data_matx[indexes], None, sample_weight=sample_weight)\\n logging.info('Done')\\n cluster_means = self.cluster_centers_\\n # Cluster ids for each different class\\n cluster_ids = [[x for x in range(len(cluster_means))] for i in range(len(query_ids))]\\n\\n # Measure distances to cluster centres\\n cluster_distance_matrix = pairwise_distances(query_data, cluster_means, metric=self.metric)\\n\\n cluster_ids_swapped = swap_indices(cluster_ids)\\n\\n cluster_gallery_ids = []\\n cluster_gallery_data = []\\n for cluster in range(len(cluster_ids_swapped)):\\n valid_cluster_gallery_ids = gallery_ids[fitted == cluster]\\n valid_cluster_gallery_data = dataset_obj.data_matx[valid_cluster_gallery_ids]\\n cluster_gallery_ids.append(valid_cluster_gallery_ids)\\n cluster_gallery_data.append(valid_cluster_gallery_data)\\n\\n gallery_distances_per_cluster = []\\n for cluster in cluster_gallery_data:\\n # Take only the gallery ids in the cluster\\n gallery_distance_for_cluster = pairwise_distances(query_data, cluster, metric=self.metric)\\n gallery_distances_per_cluster.append(gallery_distance_for_cluster)\\n\\n gallery_distances_per_cluster_swapped = swap_indices(gallery_distances_per_cluster) \\n\\n cluster_gallery_ids_stacked = [cluster_gallery_ids for i in range(len(gallery_distances_per_cluster_swapped))]\\n\\n sorted_gallery_distances_per_query = []\\n sorted_gallery_ids_per_query = []\\n for cluster_distances, gallery_distances, gallery_ids, index in zip(cluster_distance_matrix, gallery_distances_per_cluster_swapped, cluster_gallery_ids_stacked, range(len(cluster_distance_matrix))):\\n sorted_gallery_distances_per_query.append(sort_by_another(gallery_distances, cluster_distances))\\n sorted_gallery_ids_per_query.append(sort_by_another(gallery_ids, cluster_distances))\\n\\n num_query_items = len(sorted_gallery_distances_per_query)\\n num_clusters = len(gallery_ids)\\n num_gallery_items = len(gallery_data)\\n\\n double_sorted_gallery_distances_per_query = [[] for i in range(num_query_items)]\\n double_sorted_gallery_ids_per_query = [[] for i in range(num_query_items)]\\n for query_item, query_item_id, index1 in zip(sorted_gallery_distances_per_query, sorted_gallery_ids_per_query, range(len(sorted_gallery_distances_per_query))):\\n for cluster, cluster_id, index2 in zip(query_item, query_item_id, range(len(query_item))):\\n sorted_gallery_distances = sort_by_another(cluster, cluster)\\n sorted_gallery_ids = sort_by_another(cluster_id, cluster)\\n double_sorted_gallery_distances_per_query[index1].append(sorted_gallery_distances)\\n double_sorted_gallery_ids_per_query[index1].append(sorted_gallery_ids)\\n\\n final_distance_array = []\\n final_ids_array = []\\n for distances, indexes in zip(double_sorted_gallery_distances_per_query, double_sorted_gallery_ids_per_query):\\n final_distance_array.append([item for sublist in distances for item in sublist])\\n final_ids_array.append([item for sublist in indexes for item in sublist])\\n\\n final_distance_array = np.array(final_distance_array)\\n final_ids_array = np.array(final_ids_array)\\n\\n final_updated_distance_array = []\\n final_updated_ids_array = []\\n for distances, indexes, query_id in zip(final_distance_array, final_ids_array, range(num_query_items)):\\n mask = [id_is_valid(gal_id, query_id, dataset_obj) for gal_id in indexes]\\n redone_distances = np.append(distances[mask], ([-1] * 20))[:num_gallery_items]\\n redone_indexes = np.append(indexes[mask], ([-1] * 20))[:num_gallery_items]\\n final_updated_distance_array.append(redone_distances)\\n final_updated_ids_array.append(redone_indexes)\\n\\n final_updated_distance_array = np.array(final_updated_distance_array)\\n final_updated_ids_array = np.array(final_updated_ids_array)\\n\\n def gal_to_label(row_of_ids):\\n return dataset_obj.labels[row_of_ids]\\n\\n final_updated_labels_array = np.stack([gal_to_label(row) for row in final_updated_ids_array])\\n tensor_array = torch.tensor(np.array(final_updated_labels_array, dtype=np.int32))\\n\\n ranks = torch.stack([get_rank(row, i, dataset_obj) for i, row in enumerate(tensor_array)]).numpy()\\n ranked_count = np.bincount(ranks.flatten())[1:-1]\\n # CMC curve (percentage of query items which were in any particular rank or below)\\n self.ranked_acc = np.cumsum(ranked_count / dataset_obj.query_idx.shape[0])\\n\\n return self\",\n \"def calc_earning(self, data=None):\\n result = Result()\\n if data is None:\\n data = self.security\\n self.calcDecision()\\n first_purchase_method = self.check_first_purchase_method()\\n for i in np.arange(len(data['Close'])):\\n if data['FinalDecision'].iloc[i] is None:\\n pass\\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\\n self.buys_made += 1\\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\\n self.shares_own = self.stock_quantity\\n self.buys_made += 1\\n else:\\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\\n self.final_capital = self.final_capital % data['Close'].iloc[i]\\n #print(self.shares_own)\\n\\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n pass\\n else:\\n self.final_capital += self.shares_own * data['Close'].iloc[i]\\n self.shares_own = 0\\n self.sells_made +=1\\n #Checar si es el momento mas alto o bajo de ganancias\\n if self.shares_own == 0:\\n if (self.highest_point is None\\n or self.highest_point < self.final_capital):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > self.final_capital\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n else:\\n if (self.highest_point is None\\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n self.calcRealFinalCapital()\\n self.calcDiferencePercentage()\",\n \"def create_classes(row):\\n if(row[' shares'] <= 10):\\n \\n return 0\\n elif( row[' shares'] > 10 and row[' shares'] <= 100 ):\\n \\n return 1\\n elif( row[' shares'] > 100 and row[' shares'] <= 1000 ):\\n \\n return 2\\n elif( row[' shares'] > 1000 and row[' shares'] <= 10000 ):\\n \\n return 3\\n elif( row[' shares'] > 10000 and row[' shares'] <= 100000 ):\\n \\n return 4\\n else:\\n \\n return 5\",\n \"def compute_average_separability_score(self) -> Dict:\\n avg_sep_score = {}\\n for class_pair_key, class_pair_val in self.separability_scores.items():\\n avg_sep_score[class_pair_key] = np.mean(np.array([val for _, val in class_pair_val.items()]))\\n avg_sep_score['agg_with_risk'] = sum(\\n np.array([val for _, val in avg_sep_score.items()]) *\\n RISK\\n ) \\n avg_sep_score['agg'] = sum([val for key, val in avg_sep_score.items() if type(key)==int]) \\n return avg_sep_score\",\n \"def getKSplitsTwoClassesStratified(df, n_splits, classColumn1, classColumn2, seed = None):\\n\\n df_class1 = df[(df[classColumn1] == False) & (df[classColumn2] == False)]\\n df_class2 = df[(df[classColumn1] == True) & (df[classColumn2] == True)]\\n df_class3 = df[(df[classColumn1] == True) & (df[classColumn2] == False)]\\n df_class4 = df[(df[classColumn1] == False) & (df[classColumn2] == True)]\\n\\n k_folds_class1 = getKSplits(df_class1, n_splits, seed)\\n k_folds_class2 = getKSplits(df_class2, n_splits, seed)\\n k_folds_class3 = getKSplits(df_class3, n_splits, seed)\\n k_folds_class4 = getKSplits(df_class4, n_splits, seed)\\n\\n # combine\\n k_folds_combined = []\\n for i in range(n_splits):\\n combined_fold = k_folds_class1[i].append(k_folds_class2[i]).append(k_folds_class3[i]).append(k_folds_class4[i])\\n combined_fold_shuffled = combined_fold.sample(len(combined_fold), random_state = seed)\\n k_folds_combined.append(combined_fold_shuffled)\\n\\n return k_folds_combined\",\n \"def get_clusters_with_all_features(df, n_clusters):\\n pipe = _build_model(df, use_pca=False, n_components=0, use_kmeans=True, n_clusters=n_clusters)\\n labels = pipe.named_steps['kmeans'].labels_\\n df.loc[:, 'labels'] = labels\\n print(df.groupby('labels').agg(\\n {'Fresh': 'mean', 'Milk': 'mean', 'Grocery': 'mean', 'Frozen': 'mean', 'Detergents_Paper': 'mean',\\n 'Delicassen': 'mean'}))\\n print(pipe.named_steps['scaler'].inverse_transform(pipe.named_steps['kmeans'].cluster_centers_))\\n # cluster 1: low spending behaviour in general\\n # cluster 2: high spending in detergents_paper, milk, grocery\\n # cluster 3: high spending in fresh, rest low\\n # cluster 4: high spending in everything except detergents_paper, extremely high in delicassen\\n # cluster 5: medium spending in general, low in frozen, high in detergents and paper\",\n \"def compute_cluster_class_fractions(k_means_model, y):\\n\\n n_classes = y.shape[1]\\n class_labels = utils.one_hot_to_index(y)\\n cluster_labels = k_means_model.labels_\\n\\n class_clustroid_counts = np.zeros((n_classes, K))\\n for i in range(len(class_labels)):\\n class_clustroid_counts[class_labels[i], cluster_labels[i]] += 1\\n\\n class_clustroid_fractions = class_clustroid_counts / np.sum(class_clustroid_counts, axis=1).reshape(n_classes, 1)\\n\\n print(\\\"\\\\n---- Class Clustroid Distribution ----\\\")\\n for i in range(n_classes):\\n print(\\\"Class {}: {}\\\".format(i, class_clustroid_fractions[i, :]))\",\n \"def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\\n res = []\\n for n_clusters in n_clusters_considered:\\n res.append([])\\n for _ in range(n_repeats):\\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\\n print(X.val.shape)\\n print(X_restricted.val.shape)\\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\\n res[-1].append(evaluator_X.weighted_average) \\n return res\",\n \"def choose_split_value(attrs, classes):\\n indices = np.argsort(attrs)\\n classes = classes[indices]\\n attrs = attrs[indices]\\n max_gain = 0.0\\n max_gain_value = None\\n for i in range(len(attrs) - 1):\\n if classes[i] != classes[i+1]:\\n mean = (attrs[i] + attrs[i+1]) / 2.0\\n gain = inform_gain(attrs, classes, mean)\\n if gain > max_gain:\\n max_gain = gain\\n max_gain_value = mean\\n return max_gain_value, max_gain\",\n \"def dataClust(resAttrDF, infCol = 'Dollars', resName = None):\\n \\n if resName is None:\\n raise Exception('**** RESTAURANT NAME WAS NOT PROVIDED ****')\\n \\n ## COPY AND PREPROCESS RESTAURANT ATTRIBUTE DATA\\n print(f'\\\\n**** PREPROCESSING AND CLUSTERING DATA ACCORDING TO...{infCol.upper()} COLUMN ****')\\n\\n k_clust = resAttrDF.copy()\\n k_clust = k_clust.reset_index(drop = True)\\n \\n labelEncoder = LabelEncoder()\\n k_clust['Name'] = labelEncoder.fit_transform(k_clust['Name'])\\n for col in k_clust.columns:\\n if k_clust[col].dtypes == 'object':\\n k_clust[col] = pd.to_numeric(k_clust[col])\\n\\n kprot_data = k_clust.copy()\\n for c in k_clust.select_dtypes(exclude='object').columns:\\n pt = PowerTransformer()\\n kprot_data[c] = pt.fit_transform(np.array(kprot_data[c]).reshape(-1, 1))\\n\\n categorical_columns = [0] ## MAKE SURE TO SPECIFY CURRECT INDICES\\n\\n ## ACTUAL CLUSTERING\\n if infCol != 'Dollars':\\n kproto = KPrototypes(n_clusters= len(k_clust[infCol].unique()), init='Cao', n_jobs = 4)\\n clusters = kproto.fit_predict(kprot_data, categorical=categorical_columns)\\n else:\\n kproto = KPrototypes(n_clusters= len(k_clust['Dollars'].unique()), init='Cao', n_jobs = 4)\\n clusters = kproto.fit_predict(kprot_data, categorical=categorical_columns) \\n\\n ## PRINT COUNT OF EACH CLUSTER GROUP\\n print('The count for each cluster group is printed below')\\n pd.Series(clusters).value_counts()\\n \\n ## EVALUATE CLUSTER ACCURACY WITH LGBMCLASSIFIER\\n clf_kp = lgb.LGBMClassifier(colsample_by_tree=0.8, random_state=1)\\n cv_scores_kp = cross_val_score(clf_kp, k_clust, clusters, scoring='f1_weighted')\\n print(f'CV F1 score for K-Prototypes clusters is {np.mean(cv_scores_kp)}')\\n\\n ## PLOT INFLUENTIAL COLOUMNS\\n clf_kp.fit(k_clust, clusters)\\n explainer_kp = shap.TreeExplainer(clf_kp)\\n shap_values_kp = explainer_kp.shap_values(k_clust)\\n shap.summary_plot(shap_values_kp, k_clust, plot_type=\\\"bar\\\", plot_size=(15, 10))\\n\\n ## ADD CLUSTERS TO ORIGINAL DATAFRAME AND INVERSE LABEL ENCODE RESTAURANT NAMES\\n k_clust['Cluster'] = clusters\\n k_clust['Name'] = labelEncoder.inverse_transform(k_clust['Name'])\\n\\n ## FILTER RESTAURNAT CLUSTER OF CHOICE\\n clusterVal = clusters[list(k_clust['Name']).index(resName)]\\n k_clust = k_clust[k_clust['Cluster'] == clusterVal]\\n k_clust = k_clust.reset_index(drop = True)\\n k_clust = k_clust[['Name', 'ZipCode', 'Dollars', 'Photos']]\\n\\n print('**** CLUSTERING COMPLETED AND SAVING CLUSTER DATAFRAME LOCALLY ****\\\\n')\\n resFileName = resName.replace(' ', '_')\\n fileName = f'{resFileName.upper()}_CLUSTER_DATA.csv'\\n k_clust.to_csv(fileName)\\n\\n return k_clust\",\n \"def usefulness_score(model, test, train, k=20):\\n distances = []\\n test = test.tocsr()\\n train = train.tocsr()\\n (x, y, z) = sp.find(train.T)\\n counts = np.bincount(x)\\n counts += 1\\n sums = np.bincount(x, weights=z)\\n averages = sums / counts\\n\\n for user_id, row in enumerate(test):\\n\\n if not len(row.indices):\\n continue\\n\\n predictions = -model.predict(user_id)\\n\\n if train is not None:\\n rated = train[user_id].indices\\n predictions[rated] = FLOAT_MAX\\n\\n rec_list = predictions.argsort()[:k]\\n distances.append(np.mean(averages[rec_list]))\\n return np.array(distances)\",\n \"def predict(self, train_df: pd.DataFrame, test_df: pd.DataFrame) -> pd.DataFrame:\\n\\n # get feature list\\n target_columns, features = PropensityModel.get_feature_and_target_columns(train_df)\\n\\n # predict propensities\\n model_prediction_df_list = []\\n for pred_df in [train_df, test_df]:\\n x_test = pred_df[features]\\n y_test = pred_df[target_columns]\\n y_pred = self.model.predict_proba(x_test)\\n \\n # select second column (positive class) if there is only one target variable\\n if len(self.target_variables) == 1:\\n y_pred = y_pred[:,1]\\n \\n fold_predictions = pd.DataFrame(y_pred, columns=['prediction_'+x for x in self.target_variables])\\n fold_predictions['sf_account_id'] = pred_df.index\\n for column in target_columns:\\n fold_predictions[column.replace('prediction_','target_')] = y_test[column].tolist()\\n fold_predictions['train_or_test'] = pred_df.train_or_test.iloc[0]\\n model_prediction_df_list += [fold_predictions]\\n model_predictions = pd.concat(model_prediction_df_list, sort=False)\\n\\n return model_predictions\",\n \"def train_predictors(market_data, functions_for_typical_price_data, functions_for_hlc_price_data, labels_for_typical_price_data, labels_for_hlc_price_data):\\r\\n standard = {}\\r\\n # high = market_data.loc[:, 'high'].values.tolist()\\r\\n # low = market_data.loc[:, 'low'].values.tolist()\\r\\n # close = market_data.loc[:, 'close'].values.tolist()\\r\\n volume = market_data.loc[:, 'volume'].values\\r\\n # typical_prices = typical_price(high, low, close)\\r\\n typical_prices = market_data.loc[:, 'weightedAverage'].values\\r\\n standard['volume'] = (np.nanmean(volume), np.nanstd(volume))\\r\\n standard['typical_price'] = (np.nanmean(typical_prices), np.nanstd(typical_prices))\\r\\n x = ((volume - standard['volume'][0])/standard['volume'][1])\\r\\n x = np.c_[(typical_prices - standard['typical_price'][0])/standard['typical_price'][1], x]\\r\\n typical_prices = typical_prices.tolist()\\r\\n for f, label in zip(functions_for_typical_price_data, labels_for_typical_price_data):\\r\\n values = np.array(f(typical_prices))\\r\\n standard[label] = (np.nanmean(values), np.nanstd(values))\\r\\n x = np.c_[x, (values - standard[label][0])/standard[label][1]]\\r\\n # for f, label in zip(functions_for_hlc_price_data, labels_for_hlc_price_data):\\r\\n # values = np.array(f(high, low, close))\\r\\n # if 'typical_price' in label and label != 'typical_price':\\r\\n # standard[label] = standard['typical_price']\\r\\n # else:\\r\\n # standard[label] = (np.nanmean(values), np.nanstd(values))\\r\\n # x = np.c_[x, (values - standard[label][0])/standard[label][1]]\\r\\n return pd.DataFrame(data=x, columns=['typical_price', 'volume']+labels_for_typical_price_data, index=market_data.index), standard\",\n \"def cluster_by_range(df, lower_bound):\\n global features_in_range\\n # get total number of robot faces in data set\\n total_rows = len(df)\\n # determine the upper bound percentage\\n upper_bound = 100 - lower_bound\\n # lists of which columns to fix and which to cluster\\n cols_to_fix = []\\n cols_to_cluster = []\\n # iterate over every column in dataframe\\n for col in df:\\n \\\"\\\"\\\"\\n # drop any column we are ignoring\\n if df[col].name in cols_to_ignore:\\n df = df.drop(df[col].name, 1)\\n continue\\n \\\"\\\"\\\"\\n if df[col].name not in cols_no_NA_option:\\n df = df.drop(df[col].name, 1)\\n continue\\n # count & calculate percentage representation for each value of the column\\n col_check = df.groupby(col).size().reset_index(name='count')\\n col_check['as_percent'] = 100 * col_check['count'] / float(total_rows)\\n # if percentage is over the upper bound, add it to list of features to fix\\n if not col_check[col_check['as_percent'] >= upper_bound].empty:\\n cols_to_fix.append(df[col].name)\\n # if percentage is over the lower bound, add it to list of features to vary\\n elif not col_check[col_check['as_percent'] >= lower_bound].empty \\\\\\n and col_check[col_check['as_percent'] >= upper_bound].empty:\\n cols_to_cluster.append(df[col].name)\\n\\n # generate clusters based on list of what features to vary\\n groupby_result = df.groupby(cols_to_cluster).size().reset_index(name='count')\\n groupby_result['as_percent'] = 100 * groupby_result['count'] / float(total_rows)\\n groupby_result = groupby_result.sort_values(by='as_percent', ascending=False)\\n\\n # store list of features to test in a global list;\\n # don't include count and percentage columns\\n features_in_range = list(groupby_result)[:-2]\\n\\n cluster_by_split(groupby_result)\\n\\n \\\"\\\"\\\"\\n # print results to file\\n filename = str(lower_bound) + '_percent_clusters_noNA.tsv'\\n groupby_result.to_csv(filename, header=True, sep='\\\\t')\\n print(\\\"results written to file\\\")\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n groupby_result = df.groupby(cols_to_fix).size().reset_index(name='count')\\n groupby_result['as_percent'] = 100 * groupby_result['count'] / float(total_rows)\\n groupby_result = groupby_result.sort_values(by='as_percent', ascending=False)\\n print(\\\"cluster: %s, fix: %s, total: %s\\\"\\n % (len(cols_to_cluster), len(cols_to_fix), count))\\n print(\\\"RANGE: \\\", lower_bound, upper_bound)\\n print(groupby_result.head(1))\\n \\\"\\\"\\\"\",\n \"def get_review_distribution(df):\\n try:\\n review_counts = df['overall'].value_counts()\\n grouped = df.groupby(by='asin')['overall'].mean()\\n grouped2 = df.groupby(['asin'])['overall'].agg(lambda x: x.value_counts().index[0])\\n merged_group = pd.concat([grouped, grouped2], axis=1)\\n merged_group.columns = ['mean', 'mode']\\n merged_group['skew'] = np.where(merged_group['mean'] > merged_group['mode'], 'positive', 'negative')\\n merged_group.ix[merged_group['mean'] == merged_group['mode'], 'skew'] = 'symmetrical'\\n\\n write_df_tocsv(merged_group, 'review_distribution.csv')\\n except Exception as e:\\n print \\\"Error getting review distribution\\\"\\n print str(e)\\n pass\",\n \"def calc_skill_cluster_sets(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, blocks_one_clusnum, skill_str, seas):\\r\\n prec_arr, recall_arr, F1_arr, clus_num_arr = [], [], [], []\\r\\n\\r\\n prec_vals = sorted(np.unique(blocks_one_clusnum[skill_str].values), reverse = True)\\r\\n #loop through first element separately so that subsequent values can be appended\\r\\n node_cluster_set_test_str, ds_arr = [], []\\r\\n for prec in prec_vals:\\r\\n node_cluster_set_test_str_app = blocks_one_clusnum['set'][np.where(blocks_one_clusnum[skill_str]==prec)[0]].values\\r\\n for clus in node_cluster_set_test_str_app:\\r\\n #add cluster to cluster set\\r\\n node_cluster_set_test_str = np.append(node_cluster_set_test_str, clus)\\r\\n node_cluster_set_test_str = np.unique(node_cluster_set_test_str)\\r\\n node_num = len(node_cluster_set_test_str) # number of nodes in cluster set\\r\\n clus_num_arr.append(node_num)\\r\\n #calculate skill score of cluster set by calculating the number of days blocked from the GTD and selecting the season\\r\\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\\r\\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \\\"blocking\\\", dims={\\\"time\\\": GTD['time']})\\r\\n blocked_days_clus_xr['time'] = GTD['time']\\r\\n blocked_days_clus_sel = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\\r\\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_sel)\\r\\n prec_arr.append(prec)\\r\\n recall_arr.append(recall)\\r\\n F1_arr.append(F1)\\r\\n\\r\\n return clus_num_arr, prec_arr, recall_arr, F1_arr\",\n \"def overfit_features(df):\\r\\n overfit = []\\r\\n for col in df.columns:\\r\\n counts = df[col].value_counts().iloc[0]\\r\\n if counts / len(df)*100 > 99.94:\\r\\n overfit.append(col)\\r\\n return overfit\",\n \"def adjusted_ranking(df_ranking):\\n\\n # Creation of a list containing the Produtor, ordered by the maximum of Pontuacao that the Produtor gets in any\\n # of its pairs\\n\\n # Transform the structure and contents of the Ranking DataFrame into something that can be useful\\n df_ranking_usable = df_ranking.groupby([\\\"produtor\\\"]).max()\\n df_ranking_usable = df_ranking_usable.reset_index()\\n\\n df_ranking_usable = df_ranking_usable[{\\\"produtor\\\", \\\"pontuacao\\\"}]\\n df_ranking_usable = df_ranking_usable.sort_values(\\\"pontuacao\\\", ascending=False)\\n\\n # Create the list\\n lista_prod = df_ranking_usable[\\\"produtor\\\"].tolist()\\n\\n # Create a DataFrame that has the ranking sorted by the name of the Produtor and that\\n # for each Produtor, is sorted by the Pontuacao each of its Produtos has\\n\\n sorted_ranking = df_ranking.sort_values(\\n by=[\\\"produtor\\\", \\\"pontuacao\\\"], ascending=False\\n )\\n\\n # Create the final Adjusted Ranking\\n\\n ranking_ajustado = []\\n\\n for produtor in lista_prod:\\n auxiliary_dict = {}\\n auxiliary_dict[\\\"produtor\\\"] = produtor\\n auxiliary_dict[\\\"produtos\\\"] = (\\n sorted_ranking.loc[sorted_ranking[\\\"produtor\\\"] == produtor][\\n {\\\"produto\\\", \\\"pontuacao\\\"}\\n ]\\n ).to_dict(\\\"records\\\")\\n ranking_ajustado.append(auxiliary_dict)\\n\\n return ranking_ajustado\",\n \"def find_best_split(rows):\\n best_gain = 0 # keep track of the best information gain\\n best_question = None # keep train of the feature / value that produced it\\n current_uncertainty = gini(rows)\\n n_features = len(rows[0]) - 1 # number of columns\\n #print(\\\"n_features:\\\", n_features)\\n\\n for col in range(1,n_features): # for each feature\\n # for each iteration this is the set of all values of a specific column, eg, All pixels number 0\\n values = set([row[col] for row in rows]) # unique values in the column\\n for val in values: # for each value\\n\\n # Create a question object for each val under a column, holding the val and the col number\\n question = Question(col, val)\\n\\n # try splitting the dataset\\n true_rows, false_rows = partition(rows, question)\\n\\n # Skip this split if it doesn't divide the\\n # dataset.\\n if len(true_rows) == 0 or len(false_rows) == 0:\\n continue\\n\\n # Calculate the information gain from this split\\n gain = info_gain(true_rows, false_rows, current_uncertainty)\\n\\n # You actually can use '>' instead of '>=' here\\n # but I wanted the tree to look a certain way for our\\n # toy dataset.\\n if gain >= best_gain:\\n best_gain, best_question = gain, question\\n\\n return best_gain, best_question\",\n \"def fit(self):\\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\\n self.merge_clusters([[6,33,52],[17,14]])\\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\\n self.merge_clusters([[6,98,99]])\\n self.merge_clusters([[35,80]])\\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[76,98]])\\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[39,42]])\\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\\n self.merge_clusters([[70,101]])\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\\n self.merge_clusters()\\n return\",\n \"def determine_best_split(data, potential_splits, mltask):\\n\\n first_iteration = True\\n for column_index in potential_splits:\\n for value in potential_splits[column_index]:\\n data_below,data_above = split_data(data, column_index, value)\\n \\n if mltask == 'regression':\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_mse)\\n \\n # classification\\n else:\\n current_overall_metric = calculate_overall_metric(data_below, data_above, metric_function = calculate_entropy)\\n \\n \\n if first_iteration or current_overall_metric <= best_overall_metric:\\n first_iteration = False\\n \\n best_overall_metric = current_overall_metric\\n best_split_column = column_index\\n best_split_value = value\\n \\n \\n return best_split_column,best_split_value\",\n \"def split_train_test(ratings):\\r\\n ratings = ratings.sample(frac=1).reset_index(drop=True)\\r\\n train_user_list = []\\r\\n train_item_list = []\\r\\n train_rating_list = []\\r\\n test_user_list = []\\r\\n test_item_list = []\\r\\n test_rating_list = []\\r\\n user_pool = set(ratings['userId'].unique())\\r\\n for idx in user_pool:\\r\\n flag = 0\\r\\n items = ratings[ratings['userId']==idx][['itemId','rating']]\\r\\n for i, row in items.iterrows():\\r\\n if flag == 0:\\r\\n test_user_list.append(int(idx))\\r\\n test_item_list.append(int(row['itemId']))\\r\\n test_rating_list.append(row['rating'])\\r\\n flag = 1\\r\\n else:\\r\\n train_user_list.append(int(idx))\\r\\n train_item_list.append(int(row['itemId']))\\r\\n train_rating_list.append(row['rating'])\\r\\n\\r\\n train = pd.DataFrame({'userId': train_user_list, 'itemId': train_item_list, 'rating': train_rating_list}, columns=['userId', 'itemId', 'rating'])\\r\\n test = pd.DataFrame({'userId': test_user_list, 'itemId': test_item_list, 'rating': test_rating_list}, columns=['userId', 'itemId', 'rating'])\\r\\n return [train, test]\\r\\n \\r\\n\\r\\n \\r\\n #train, test = train_test_split(ratings, test_size=0.1, shuffle=True)\\r\\n #return [train, test]\\r\",\n \"def k_means_model(df, numOfClusters):\\n # Perform scaling on the dataframe containing the selected features\\n data = scale(df)\\n\\n # Train a model\\n model = KMeans(init=\\\"k-means++\\\", n_clusters=numOfClusters, n_init=20).fit(data)\\n return model\",\n \"def calculate_industry_neutral_nway_return(df, name, sorts, cuts, long_bucket, short_bucket, ind_col='sic1', ret_col='ret'):\\n df = df.copy()\\n\\n # n-way sort\\n keys = ['time_idx', ind_col]\\n for sort, cut in zip(sorts, cuts):\\n df[sort] = df.groupby(keys, as_index=False)[sort].transform(lambda x: pd.qcut(x, cut, range(cut)))\\n keys.append(sort)\\n\\n # calculate bucket returns\\n port_ret = df.groupby(['time_idx', ind_col] + sorts, as_index=False).agg({ret_col: 'mean', 'permno': 'count'})\\n summary = port_ret.groupby(['time_idx'] + sorts, as_index=False)[[ret_col, 'permno']].apply(\\n lambda x: pd.Series([np.average(x[ret_col], weights=x.permno), x.permno.sum()], index=['ret', 'avg count'])\\n )\\n\\n hedged_bucket = summary.reset_index('time_idx').groupby('time_idx').apply(\\n lambda x: pd.Series([\\n (x.loc[long_bucket, 'ret'] - x.loc[short_bucket, 'ret']) / 2,\\n (x.loc[long_bucket, 'avg count'] + x.loc[short_bucket, 'avg count']) / 2\\n ], index=['ret', 'avg count'])\\n )\\n tmp = hedged_bucket.agg({'ret': ['mean', 'std'], 'avg count': 'mean'})\\n hedged_bucket = pd.DataFrame({**{sorts[0]: ['hedged'],\\n 'return': [tmp.loc['mean', 'ret']],\\n 't stat': [tmp.loc['mean', 'ret'] / tmp.loc['std', 'ret']],\\n 'avg count': [tmp.loc['mean', 'avg count']]}, **{x: '' for x in sorts[1:]}})\\n\\n summary = summary.groupby(sorts).agg({'ret': ['mean', 'std'], 'avg count': 'mean'}, axis=1)\\n summary.columns = [\\\"_\\\".join(x) if x[1] != '' else x[0] for x in summary.columns.ravel()]\\n summary['t stat'] = summary.ret_mean / summary.ret_std\\n summary = summary.drop('ret_std', axis=1).rename({'ret_mean': 'return', 'avg count_mean': 'avg count'}, axis=1)\\n summary = summary.reset_index()[sorts + ['return', 't stat', 'avg count']]\\n summary = pd.concat([summary, hedged_bucket], axis=0, sort=False)\\n\\n # calculate hedged returns\\n agg = port_ret.set_index(sorts).groupby(['time_idx', ind_col]).apply(\\n lambda x: pd.Series([\\n (x.loc[long_bucket, ret_col] - x.loc[short_bucket, ret_col]) / 2, # to maintain unit leverage\\n (x.loc[long_bucket, ret_col]) / 2, # division by 2 to match same leverage of the long side\\n (x.loc[short_bucket, ret_col]) / 2, # division by 2 to match same leverage of the short side\\n (x.loc[long_bucket, 'permno'] + x.loc[short_bucket, 'permno']) / 2\\n ], index=['ret', 'long_ret', 'short_ret', 'count'])\\n )\\n hedged = agg.groupby(level=0).apply(lambda x: np.average(x.ret, weights=x['count']))\\n long = agg.groupby(level=0).apply(lambda x: np.average(x.long_ret, weights=x['count']))\\n short = agg.groupby(level=0).apply(lambda x: np.average(x.short_ret, weights=x['count']))\\n\\n # plot\\n avg = hedged.rolling(4, min_periods=4).sum()\\n fig = make_subplots(specs=[[{\\\"secondary_y\\\": True}]])\\n fig.add_trace(go.Bar(y=avg, x=avg.index, name=name + ' Return'), secondary_y=False)\\n fig.add_trace(go.Scatter(y=(1 + hedged).cumprod(), x=hedged.index, name=name + ' Equity'), secondary_y=True)\\n fig.add_trace(go.Scatter(y=(1 + long).cumprod(), x=hedged.index, name=name + ' Long Equity'), secondary_y=True)\\n fig.add_trace(go.Scatter(y=(1 + short).cumprod(), x=hedged.index, name=name + ' Short Equity'), secondary_y=True)\\n fig.show()\\n\\n return {'name': name, 'equity': hedged, 'summary': summary, 'data': df}\",\n \"def evaluate_percentage_of_class_for_each_flight(df_flights_info):\\n df_new = df_flights_info[['FlightId', 'FareClass', 'Booking']]\\n df_new = df_new.pivot(index='FlightId', columns='FareClass', values='Booking').astype(float)\\n df_new.loc[:, 'Total'] = df_new.sum(axis=1).astype(float)\\n for row, col in df_new.iterrows():\\n for item in list(df_new):\\n number_booking = df_new.loc[row, item]\\n total_booking = df_new.loc[row]['Total']\\n percentage = float(number_booking / total_booking)\\n df_new.at[row, item] = percentage\\n df_new = df_new.drop(columns=['Total'])\\n df_new = df_new.stack()\\n df_new = df_new.reset_index(level=[0, 1])\\n df_flights_info = pandas.merge(df_flights_info, df_new, how='left', on=['FlightId', 'FareClass'])\\n df_flights_info.rename(columns={0: 'Percentage'}, inplace=True)\\n return df_flights_info\",\n \"def cluster_kmeans(df, k):\\r\\n # Sample fron the original df\\r\\n sample_df=df.sample(n = k)\\r\\n obs, attr= df.shape\\r\\n # Make copies \\r\\n copy_df=df.copy()\\r\\n flag=0\\r\\n sse_old=0\\r\\n while (flag==0): \\r\\n sse=0\\r\\n Labels=[]\\r\\n for i in range(0, obs):\\r\\n dist= []\\r\\n for j in range(0,k):\\r\\n #Calculate Eucledian distance\\r\\n diff=list((df.iloc[i,:]-sample_df.iloc[j,:])**2)\\r\\n eu_dist=(sum(diff))**(1/attr)\\r\\n dist.append(eu_dist) \\r\\n #Add Labels to the observations based on the variable they are close to\\r\\n label=(dist.index(min(dist)))\\r\\n Labels.append(label)\\r\\n # Calculate SSE\\r\\n sse=sse+((min(dist) )**2)\\r\\n sse=sse**(1/2)\\r\\n copy_df['labels']=Labels\\r\\n # Stopping criteria is change in SSE should be 2 %\\r\\n if (sse_old !=0):\\r\\n if(abs(sse_old-sse)/sse_old<=0.05):\\r\\n flag=1 \\r\\n return_df=copy_df['labels'].to_frame()\\r\\n return (return_df, sse)\\r\\n else:\\r\\n sse_old=sse\\r\\n #Empty the sample df\\r\\n sample_df.drop(sample_df.index, inplace=True)\\r\\n # Now pick random values from each label and add it to the sample df\\r\\n for val in range(0,k):\\r\\n #Create new sample df\\r\\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\\r\\n else:\\r\\n sse_old=sse\\r\\n #Empty the sample df\\r\\n sample_df.drop(sample_df.index, inplace=True)\\r\\n for val in range(0,k):\\r\\n #Create new sample df \\r\\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\",\n \"def ite_best(train_df, test_df, features, outcome, treatment):\\n train_t_df, train_c_df = split_treatment_control(train_df, treatment)\\n\\n by_feat_t = train_t_df.groupby(features)[outcome].mean()\\n by_feat_c = train_c_df.groupby(features)[outcome].mean()\\n by_feat = by_feat_t - by_feat_c\\n\\n return test_df[features].join(by_feat, on=features)[outcome].values\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72233945","0.6792338","0.6017771","0.58476025","0.57573664","0.5649134","0.56137496","0.5605749","0.56018263","0.55858415","0.55482686","0.55418605","0.5532151","0.551682","0.5425047","0.54250115","0.5417848","0.5410822","0.5366402","0.53150505","0.52947503","0.5293667","0.52910036","0.5276034","0.52610314","0.5259408","0.5243734","0.5238531","0.5238531","0.5220504","0.5194224","0.5193532","0.5182987","0.51784927","0.51738405","0.5170466","0.5167272","0.5163793","0.51625645","0.5129703","0.51181567","0.5111878","0.5102139","0.5096606","0.5071599","0.5070834","0.50668263","0.5066736","0.50601983","0.5053917","0.50504535","0.50501496","0.50499326","0.50499326","0.50495744","0.5049475","0.50433505","0.50421846","0.5041582","0.50401783","0.5035417","0.5033135","0.50306636","0.50294185","0.50289357","0.50230134","0.5018649","0.5017281","0.50164217","0.5014116","0.5012625","0.5009713","0.50096095","0.5008825","0.50076175","0.5006018","0.49945197","0.49912742","0.49909088","0.49835664","0.49744555","0.4971027","0.49675742","0.49659744","0.49658808","0.496508","0.49612322","0.49587354","0.49500716","0.49496403","0.4943661","0.49435595","0.49393865","0.49366763","0.49364394","0.4936378","0.4936325","0.4935675","0.49298254","0.4926031"],"string":"[\n \"0.72233945\",\n \"0.6792338\",\n \"0.6017771\",\n \"0.58476025\",\n \"0.57573664\",\n \"0.5649134\",\n \"0.56137496\",\n \"0.5605749\",\n \"0.56018263\",\n \"0.55858415\",\n \"0.55482686\",\n \"0.55418605\",\n \"0.5532151\",\n \"0.551682\",\n \"0.5425047\",\n \"0.54250115\",\n \"0.5417848\",\n \"0.5410822\",\n \"0.5366402\",\n \"0.53150505\",\n \"0.52947503\",\n \"0.5293667\",\n \"0.52910036\",\n \"0.5276034\",\n \"0.52610314\",\n \"0.5259408\",\n \"0.5243734\",\n \"0.5238531\",\n \"0.5238531\",\n \"0.5220504\",\n \"0.5194224\",\n \"0.5193532\",\n \"0.5182987\",\n \"0.51784927\",\n \"0.51738405\",\n \"0.5170466\",\n \"0.5167272\",\n \"0.5163793\",\n \"0.51625645\",\n \"0.5129703\",\n \"0.51181567\",\n \"0.5111878\",\n \"0.5102139\",\n \"0.5096606\",\n \"0.5071599\",\n \"0.5070834\",\n \"0.50668263\",\n \"0.5066736\",\n \"0.50601983\",\n \"0.5053917\",\n \"0.50504535\",\n \"0.50501496\",\n \"0.50499326\",\n \"0.50499326\",\n \"0.50495744\",\n \"0.5049475\",\n \"0.50433505\",\n \"0.50421846\",\n \"0.5041582\",\n \"0.50401783\",\n \"0.5035417\",\n \"0.5033135\",\n \"0.50306636\",\n \"0.50294185\",\n \"0.50289357\",\n \"0.50230134\",\n \"0.5018649\",\n \"0.5017281\",\n \"0.50164217\",\n \"0.5014116\",\n \"0.5012625\",\n \"0.5009713\",\n \"0.50096095\",\n \"0.5008825\",\n \"0.50076175\",\n \"0.5006018\",\n \"0.49945197\",\n \"0.49912742\",\n \"0.49909088\",\n \"0.49835664\",\n \"0.49744555\",\n \"0.4971027\",\n \"0.49675742\",\n \"0.49659744\",\n \"0.49658808\",\n \"0.496508\",\n \"0.49612322\",\n \"0.49587354\",\n \"0.49500716\",\n \"0.49496403\",\n \"0.4943661\",\n \"0.49435595\",\n \"0.49393865\",\n \"0.49366763\",\n \"0.49364394\",\n \"0.4936378\",\n \"0.4936325\",\n \"0.4935675\",\n \"0.49298254\",\n \"0.4926031\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78250796"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19496,"cells":{"query":{"kind":"string","value":"Basing on a dataframe given as an argument, and list of buy and sell clusters returns mean profit per class (buy, sell) in testing dataset."},"document":{"kind":"string","value":"def get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test: pd.core.frame.DataFrame,\n buy_clusters_list: List[int], sell_clusters_list: List[int]) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(buy_clusters_list) != 0 and len(sell_clusters_list) != 0, \"Clusters list can't be empty.\"\n\n buy_clusters_mean_profit = \\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(buy_clusters_list)]['profit'].mean()\n sell_clusters_mean_profit = \\\n df_profit_per_cluster_test.loc[df_profit_per_cluster_test['cluster'].isin(sell_clusters_list)]['profit'].mean()\n\n return buy_clusters_mean_profit, sell_clusters_mean_profit"},"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_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(df_profit_per_cluster_train) >= 3, \"Algorithm, returned less than 3 clusters.\"\n\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\n group_size = int(len(df_profit_per_cluster) / 3)\n\n buy_clusters_mean_profit = df_profit_per_cluster.iloc[:group_size]['profit'].mean()\n sell_clusters_mean_profit = df_profit_per_cluster.iloc[-group_size:]['profit'].mean()\n\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\n\n return buy_clusters_mean_profit, buy_clusters_list, sell_clusters_mean_profit, sell_clusters_list","def get_profit_per_cluster(df: pd.core.frame.DataFrame) -> pd.core.frame.DataFrame:\n return pd.DataFrame(df.groupby(by='cluster')['profit'].mean(), columns=['profit']).reset_index()","def cluster_means(self):\n if self.evaluate_by is not None:\n return(self.merged_data.groupby(\n 'labels').mean().sort_values(self.evaluate_by).transpose())\n else:\n return(self.merged_data.groupby('labels').mean().transpose())","def score(self, df_X, ser_y):\n df_predict = self.predict(df_X)\n accuracies = []\n for instance in ser_y.index:\n # Accuracy is the probability of selecting the correct class\n try:\n accuracy = df_predict.loc[instance, ser_y.loc[instance]]\n except:\n import pdb; pdb.set_trace()\n accuracies.append(accuracy)\n return np.mean(accuracies)","def calculate_kmeans(df, clusters=10):\r\n kmeans = KMeans(n_clusters=clusters)\r\n labels = kmeans.fit_predict(df)\r\n\r\n return kmeans, labels","def calc_skill_cluster_sets(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, blocks_one_clusnum, skill_str, seas):\r\n prec_arr, recall_arr, F1_arr, clus_num_arr = [], [], [], []\r\n\r\n prec_vals = sorted(np.unique(blocks_one_clusnum[skill_str].values), reverse = True)\r\n #loop through first element separately so that subsequent values can be appended\r\n node_cluster_set_test_str, ds_arr = [], []\r\n for prec in prec_vals:\r\n node_cluster_set_test_str_app = blocks_one_clusnum['set'][np.where(blocks_one_clusnum[skill_str]==prec)[0]].values\r\n for clus in node_cluster_set_test_str_app:\r\n #add cluster to cluster set\r\n node_cluster_set_test_str = np.append(node_cluster_set_test_str, clus)\r\n node_cluster_set_test_str = np.unique(node_cluster_set_test_str)\r\n node_num = len(node_cluster_set_test_str) # number of nodes in cluster set\r\n clus_num_arr.append(node_num)\r\n #calculate skill score of cluster set by calculating the number of days blocked from the GTD and selecting the season\r\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\r\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \"blocking\", dims={\"time\": GTD['time']})\r\n blocked_days_clus_xr['time'] = GTD['time']\r\n blocked_days_clus_sel = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\r\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_sel)\r\n prec_arr.append(prec)\r\n recall_arr.append(recall)\r\n F1_arr.append(F1)\r\n\r\n return clus_num_arr, prec_arr, recall_arr, F1_arr","def evaluation(X_selected, X_test, n_clusters, y):\n k_means = KMeans(n_clusters=n_clusters, init='k-means++', n_init=10, max_iter=300,\n tol=0.0001, precompute_distances=True, verbose=0,\n random_state=None, copy_x=True, n_jobs=1)\n\n k_means.fit(X_selected)\n y_predict = k_means.predict(X_test)\n\n # calculate NMI\n nmi = normalized_mutual_info_score(y, y_predict, average_method='arithmetic')\n\n sil = silhouette_score(X_test, y_predict, metric=\"euclidean\")\n db_score = davies_bouldin_score(X_test, y_predict)\n ch_score = calinski_harabasz_score(X_test, y_predict)\n purity = calcolaPurity(y, y_predict)\n\n return nmi, sil, db_score, ch_score, purity","def classify():\n yes_dataset = df[df[\"_class\"] == 1] # 470588\n no_dataset = df[df[\"_class\"] == 0] # 1971\n\n parameter_analysis = list()\n for criterion in np.arange(0.05, 0.91, 0.05):\n print(\"doing experiment at criterion = %s ...\" % criterion)\n rate_list = list()\n for i in range(10):\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\n yes_index = yes_dataset.index.tolist()\n random.shuffle(yes_index)\n no_index = no_dataset.index.tolist()\n random.shuffle(no_index)\n \n # concatenate 90%yes + 90%no, 10%yes + 10%no\n train = pd.concat([\n yes_dataset.loc[yes_index[:1774], :],\n no_dataset.loc[no_index[:423530], :]\n ])\n test = pd.concat([\n yes_dataset.loc[yes_index[1774:], :],\n no_dataset.loc[no_index[423530:], :]\n ]) \n \n # split data and label\n train_data, train_label = (train[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n train[\"_class\"])\n test_data, test_label = (test[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n test[\"_class\"])\n \n # apply classifier\n clf = GaussianNB()\n clf.fit(train_data, train_label)\n probability = clf.predict_proba(test_data).T[1]\n \n result = pd.DataFrame()\n result[\"_class\"] = test_label\n result[\"_predict\"] = probability >= criterion\n \n result_yes = result[result[\"_class\"] == 1]\n yes_yes_rate = sum(result_yes[\"_class\"] == result_yes[\"_predict\"])/len(result_yes[\"_predict\"])\n \n result_no = result[result[\"_class\"] == 0]\n no_no_rate = sum(result_no[\"_class\"] == result_no[\"_predict\"])/len(result_no[\"_predict\"])\n \n rate_list.append((yes_yes_rate, no_no_rate))\n\n rate_list = pd.DataFrame(rate_list)\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\n \n # save data to excel spreadsheet\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\"criterion\", \"yes_yes_rate\", \"no_no_rate\"])\n writer = pd.ExcelWriter(\"parameter_analysis.xlsx\")\n parameter_analysis.to_excel(writer, \"parameter_analysis\", index=False)\n writer.save()","def calc_skill_clusters(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, SOM_clusters_block, seas):\r\n ds_arr_ones = []\r\n for clus in SOM_clusters_block:\r\n node_cluster_set_test = [clus]\r\n node_cluster_set_test_str = [str(clus).replace(',', '') for clus in node_cluster_set_test]\r\n #calculate the blocked days which the new cluster determines\r\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\r\n #define as DataArray and select JJA to remove the extended days included for classifying blocks\r\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \"blocking\", dims={\"time\": GTD['time']})\r\n blocked_days_clus_xr['time'] = GTD['time']\r\n blocked_days_clus_seas = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\r\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_seas)\r\n #calculate precision, recall and F1\r\n if len(str(node_cluster_set_test)) == 1:\r\n comb_str = f\"{node_cluster_set_test[0]}\".replace(\"'\", \"\")\r\n else:\r\n comb_str = f\"{str(node_cluster_set_test)[1:-1]}\".replace(\"'\", \"\") \r\n ds=xr.Dataset({'precision': prec, 'recall': recall, 'F1': F1, 'clus_num': int(len(node_cluster_set_test)), 'set': str(comb_str)})\r\n ds_arr_ones.append(ds)\r\n blocks_one_clusnum = xr.concat(ds_arr_ones, dim = \"set\")\r\n return blocks_one_clusnum","def wca_mean(X, k, df):\n\t\n\n\t# Intializing the clusters\t\n\tC = dict()\n\tfor cluster in range(k):\n\t C[cluster] = pd.DataFrame()\n\n\t# Calculating the mean vector\n\tmean_vector = X.mean()\n\n\t# Choosing the seed points based on the minimum distance from the mean vector\n\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\n\tdist_means = X.sort_values(by='dist_mean')\n\t\n\t# Dropping the the datapoints which have already been assigned as seed\n\tidx_to_drop = dist_means.index[:k]\n\tdist_means.reset_index(drop=True,inplace=True)\n\tX.drop('dist_mean',axis=1,inplace=True)\n\tX.drop(idx_to_drop, inplace=True)\n\n\t# Assigning seed points to the clusters\n\tmu = list()\n\tfor cluster in range(k):\n\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\n\t mu.append(C[cluster].mean())\n\t\n\t# Running the algorithm\t\n\t\n\t# Initializing the p-value list which would be used for plotting\n\tpval = dict()\n\n\tfor cluster in range(k):\n\t pval[cluster] = dict()\n\t for i in C[0].columns:\n\t pval[cluster][i] = list()\n\n\t# Algorithm\n\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\n\t for cluster in range(k):\n\n\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\n\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\n\t dist_means = X.sort_values(by='dist_mean', ascending=False)\n\t idx_to_drop = dist_means.index[0]\n\t dist_means.reset_index(drop=True,inplace=True)\n\t X.drop('dist_mean',axis=1,inplace=True)\n\n\t # Assigning the top value to the cluster\n\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\n\t C[cluster] = C[cluster].reset_index(drop=True)\n\t \n\t # Updating means of each cluster\n\t mu[cluster] = C[cluster].mean()\n\n\t # Remove datapoint from X?\n\t X.drop(idx_to_drop,inplace=True)\n\t \n\t for i in C[0].columns:\n\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\n\n\treturn(C,pval)","def score(self, df_X, ser_y):\n df_predict = self.predict(df_X)\n missing_columns = set(ser_y).difference(\n df_predict.columns)\n for column in missing_columns:\n df_predict[column] = np.repeat(0,\n len(df_predict))\n accuracies = []\n for instance in ser_y.index:\n # Accuracy is the probability of selecting the correct class\n try:\n accuracy = df_predict.loc[instance, ser_y.loc[instance]]\n except:\n import pdb; pdb.set_trace()\n accuracies.append(accuracy)\n return np.mean(accuracies)","def target_mean(train,test,train_index=None,holdout_index=None,col=[],\n target='click',num_folds=5,seed=23):\n feature_name='new_features'\n if holdout_index is None:\n train_cv = train.copy()\n holdout = None\n else:\n if train_index is None:\n warnings.warn('train index is None. Now need to calculate. If you parse the value, it will be more efficient ')\n train_index = list(set(train.index) - set(holdout_index))\n train_cv = train.loc[train_index].copy()\n holdout = train.loc[holdout_index].copy()\n holdout_list = []\n sf = StratifiedKFold(n_splits= num_folds, shuffle=True, random_state=seed)\n\n train_return = train[col].copy()\n test_return = test[col].copy()\n train_return[feature_name] = np.nan\n test_return[feature_name] = np.nan\n test_list = []\n \n val_index_monitor = []\n for t_index,v_index in sf.split(train_cv,train_cv[target]):\n history = train_cv.iloc[t_index].copy()\n mapping = history.groupby(col)[target].mean().reset_index().rename({target:feature_name},axis=1)\n val = train_cv.iloc[v_index].copy()\n val_index_monitor.extend(list(val.index))\n train_return.loc[val.index,feature_name] = val[col].merge(mapping,how='left',left_on=col,right_on=col).drop(col,axis=1)[feature_name].values\n if holdout is not None:\n holdout_list.append(holdout[col].merge(mapping,how='left',left_on=col,right_on=col).drop(col,axis=1)[feature_name].values)\n test_list.append(test[col].merge(mapping,how='left',left_on=col,right_on=col).drop(col,axis=1)[feature_name].values)\n if holdout is not None:\n train_return.loc[holdout.index,feature_name] = np.mean(np.array(holdout_list),axis=0)\n test_return[feature_name] = np.mean(np.array(test_list),axis=0)\n val_index_monitor.extend(list(holdout.index))\n return train_return[feature_name].values,test_return[feature_name].values","def create_strategy(filename: str, columns_list: List[str], som_width: int, som_height: int, n_iter: int, sigma=0.3,\n learning_rate=0.01) -> tuple:\n # get prepared data\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\n\n # train som\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\n sigma=sigma, learning_rate=learning_rate)\n\n # get profit per cluster in train and test datasets\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\n df_profit_per_cluster_test = get_profit_per_cluster(final_df_test)\n\n # get mean profit for sell and buy class in training and testing datasets\n try:\n buy_clusters_mean_profit_train, buy_clusters_list, sell_clusters_mean_profit_train, sell_clusters_list = \\\n get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train)\n\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = \\\n get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test, buy_clusters_list, sell_clusters_list)\n # if the data was assigned to less than to 3 clusters\n except:\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = None, None, None, None\n\n return len(df_profit_per_cluster_train), len(df_profit_per_cluster_test), \\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test","def purity_score(label, pred):\n \n df = pd.concat([label, pd.DataFrame(pred)], axis=1)\n df.set_axis(['label', 'pred'], axis=1, inplace=True)\n \n s = 0\n\n for x, cluster in df.groupby('pred'):\n s += cluster['label'].value_counts().iloc[0] # adding the most occuring class in a cluster\n\n return s / label.shape[0]","def grouping(data_clust):\n data_grouped = data_clust.groupby('Clusters').mean()\n return data_grouped","def test_splits(ratings_df, predict_method, k, test_size=250, splits=3):\n mse_ls = []\n for _ in range(splits):\n test_ratings_df = ratings_df.sample(n=test_size)\n train_ratings_df = ratings_df.drop(test_ratings_df.index)\n model_params = matrix_cf.get_model_params(train_ratings_df)\n _, mse = predict_method(test_ratings_df, k, model_params)\n mse_ls.append(mse)\n return np.array(mse_ls).mean()","def byMeans(dataset, number_of_clusters, class_header=\"Class\", verbosity=0, return_clusters=False):\n if verbosity >= 2: # optionally print dataset shape and info\n print(dataset.shape)\n print(dataset)\n\n old_dataset = dataset.copy()\n dataset = dataset.drop(columns=class_header) # remove non-float class column\n\n # Assign centroids to random values which fit into dataset space.\n centroids = pandas.DataFrame(columns=dataset.columns,\n data=numpy.random.uniform(dataset.min(), dataset.max(),\n (number_of_clusters, dataset.shape[1])))\n if verbosity >= 1: # optionally print centroids and random dataset\n print(\"INITIAL CENTROIDS\")\n print(centroids)\n if verbosity >= 2:\n print(\"DATAFRAME DATASET\")\n print(dataset)\n\n for iterations in range(MAX_ITERATIONS): # Loop until MAX_ITERATIONS or settled\n if verbosity >= 1: # optionally print iteration count\n print(\"ITERATIONS\")\n print(iterations)\n\n # calculate clustering of data\n clusters = Cluster.calcClusters(dataset, centroids, number_of_clusters, verbosity=verbosity)\n\n old_centroids = centroids.copy() # copy centroid dataframe\n\n if verbosity >= 2: # optionally print cluster list\n print(\"DATAFRAME ARRAY CLUSTERS\")\n print(clusters)\n\n for cluster_index, cluster in enumerate(clusters): # Calculate new centroids\n cluster_mean = cluster.mean()\n if not cluster_mean.isnull().any(): # make sure we dont write null means to centroid list\n centroids.loc[cluster_index] = cluster_mean\n\n if verbosity >= 1:\n print(\"OLD CENTROIDS\")\n print(old_centroids)\n print(\"NEW CENTROIDS\")\n print(centroids)\n\n if old_centroids is not None: # Calculate sum of centroid movements.\n centroid_change = 0\n for centroid_index, centroid in centroids.iterrows():\n centroid_change += abs(Cluster.calcDistance(centroid, old_centroids.loc[centroid_index]))\n\n if verbosity >= 1:\n print(\"CENTROID DIFF\")\n print(centroid_change)\n\n if centroid_change < SETTLE_THRESHOLD: # break if centroid movement is below threshold.\n break\n\n # Final Cluster re-calculation\n clusters = Cluster.calcClusters(old_dataset, centroids, number_of_clusters,\n verbosity=verbosity, class_header=class_header)\n # Create new dataframe with class column of and row for each centroid\n centroids_class = pandas.DataFrame(data=[\"NOCLASS\"] * centroids.shape[0], columns=[class_header])\n if verbosity >= 2:\n print(centroids_class)\n print(centroids)\n for cluster_index, cluster in enumerate(clusters): # For each cluster\n if verbosity >= 2:\n print(cluster_index)\n print(cluster)\n if cluster.size > 0: # If cluster is not empty set centroid class to most common class in cluster\n centroids_class.iat[cluster_index, 0] = cluster.mode().loc[0][0]\n if old_dataset.columns[0] == class_header: # check if class column should be first or last.\n print(\"CLASS IS FIRST COL\")\n centroids = pandas.concat([centroids_class, centroids], axis=1) # merge class to centroids as first column\n else:\n print(\"CLASS IS NOT FIRST COL\")\n centroids = pandas.concat([centroids, centroids_class], axis=1) # merge class to centroids as last column\n for centroid in centroids.iterrows(): # For each centroid\n if centroid[1][class_header] is \"NOCLASS\": # Trim NOCLASS centroids (empty cluster)\n centroids = centroids.drop(centroid[0])\n centroids = centroids.reset_index(drop=True) # Reindex centroids\n\n if return_clusters is True: # optionally return cluster list\n return centroids, clusters\n pass\n else:\n return centroids # return centroids dataframe","def _eval_clustering(self, gen_reviews, clusters, embedding_model, clustering):\n result = []\n preds = self.predict_gen(gen_reviews, embedding_model, clustering)\n\n acc = accuracy_score(np.array(clusters), np.array(preds))\n conf = confusion_matrix(np.array(clusters), np.array(preds))\n\n return acc, conf","def evaluateClusters( features, labels):\r\n\r\n\treturn silhouette_score( features, labels)","def get_perf(self) :\n self.train()\n\n prediction = self.clf.predict(self.df_test.drop(columns = 'up')[:-1])\n self.accuracy = accuracy_score(df_test['up'][length:].values, prediction)\n tn, fp, fn, tp = confusion_matrix(df_test['up'][length:].values, prediction).ravel()\n self.recall = tp/(tp+fn)\n self.specificity = tn / (tn+fp)\n\n\n self.df_true = self.df_true[self.length:]\n\n profit = 1\n mini = 1\n maxi = 1\n self.df_true['close'] = self.df_true['close'].map(lambda x : np.exp(x))\n for s in range(1,len(self.df_true)):\n if prediction[x-1] == 1 :\n result = ((self.df_true['close'].iloc[s] -self.df_true['close'].iloc[s-1]) / self.df_true['close'].iloc[s-1]) + 1\n profit = profit * result\n if result < mini :\n mini = result\n if maxi < result :\n maxi = result\n self.mini = mini\n self.maxi = maxi\n self.profit = profit","def evalute_subset(X_train, X_test, y_train, y_test):\r\n clf = KNeighborsClassifier(n_neighbors=3)\r\n clf.fit(X_train, y_train) \r\n y_pred = clf.predict(X_test)\r\n return accuracy_score(y_test, y_pred)","def clusterting_feature_importance (df, cluster_col):\r\n scores = pd.DataFrame()\r\n df0 = df.copy()\r\n df0 = df.select_dtypes(include=np.number)\r\n\r\n for i in df0[cluster_col].unique():\r\n df2 = df0[df0[cluster_col] == i]\r\n df2.drop(cluster_col,axis=1, inplace=True)\r\n #df2 = df.select_dtypes(include=np.number)\r\n scores[i] = df2.std() / (df2.max() - df2.min())\r\n scores['mean'] = scores.mean(axis = 1)\r\n\r\n scores = 1 - scores\r\n\r\n return scores","def _compute_cluster_averages(self, key=\"_scvi_labels\"):\n # find cell label column\n label_col = self.adata.uns[\"_scvi\"][\"categorical_mappings\"][key][\"original_key\"]\n\n # find data slot\n x_dict = self.adata.uns[\"_scvi\"][\"data_registry\"][\"X\"]\n if x_dict[\"attr_name\"] == \"X\":\n use_raw = False\n else:\n use_raw = True\n if x_dict[\"attr_name\"] == \"layers\":\n layer = x_dict[\"attr_key\"]\n else:\n layer = None\n\n # compute mean expression of each gene in each cluster/batch\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\n\n return aver","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def cluster_by_partitioning(active_sites):\n cls, sc = k_means(active_sites)\n\n return cls","def predict(self, train_df: pd.DataFrame, test_df: pd.DataFrame) -> pd.DataFrame:\n\n # get feature list\n target_columns, features = PropensityModel.get_feature_and_target_columns(train_df)\n\n # predict propensities\n model_prediction_df_list = []\n for pred_df in [train_df, test_df]:\n x_test = pred_df[features]\n y_test = pred_df[target_columns]\n y_pred = self.model.predict_proba(x_test)\n \n # select second column (positive class) if there is only one target variable\n if len(self.target_variables) == 1:\n y_pred = y_pred[:,1]\n \n fold_predictions = pd.DataFrame(y_pred, columns=['prediction_'+x for x in self.target_variables])\n fold_predictions['sf_account_id'] = pred_df.index\n for column in target_columns:\n fold_predictions[column.replace('prediction_','target_')] = y_test[column].tolist()\n fold_predictions['train_or_test'] = pred_df.train_or_test.iloc[0]\n model_prediction_df_list += [fold_predictions]\n model_predictions = pd.concat(model_prediction_df_list, sort=False)\n\n return model_predictions","def predict(self, test_data):\n if self.centroids_.shape[0]==0:\n raise ValueError(\"No centroids present. Run KMeans.fit first.\")\n\n print test_data.shape\n part_of_cluster=np.zeros(test_data.shape[0])\n for i in range(test_data.shape[0]):\n dists=[]\n for c in range(self.centroids_.shape[0]):\n # compute distance between current train_data instance and each cluster\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\n \n # assign point to cluster with minimal distance\n part_of_cluster[i]=dists.index(min(dists))\n\n return part_of_cluster","def cluster_means_scaled(self):\n if self.evaluate_by is not None:\n return(self.merged_scaled_data.groupby(\n 'labels').mean().sort_values(self.evaluate_by).transpose())\n else:\n return(self.merged_scaled_data.groupby(\n 'labels').mean().transpose())","def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\n learning_rate=0.01):\n\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\n random_seed=0)\n som.train(df_train, n_iter)\n\n # converting numpy arrays to dataframes\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\n\n # creating column with cluster basing on model prediction\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\n\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\n # the script\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\n lsuffix='_org')\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\n lsuffix='_org')\n\n return final_df_train, final_df_test","def profitCalculation(confusion_matrix):\n numberofClasses = 4\n profits = [[20, -7, -7, -7], [-7, 15, -7, -7], [-7, -7, 5, -7], [-3, -3, -3, -3]]\n totalProfit = 0\n for count in range(numberofClasses):\n for counter in range(numberofClasses):\n totalProfit += confusion_matrix[count][counter] * profits[count][counter]\n\n return totalProfit","def create_cluster(df,validate, test, X, k, name):\n \n scaler = StandardScaler(copy=True).fit(df[X])\n X_scaled = pd.DataFrame(scaler.transform(df[X]), columns=df[X].columns.values).set_index([df[X].index.values])\n kmeans = KMeans(n_clusters = k, random_state = 42)\n kmeans.fit(X_scaled)\n kmeans.predict(X_scaled)\n df[name] = kmeans.predict(X_scaled)\n df[name] = 'cluster_' + df[name].astype(str)\n \n v_scaled = pd.DataFrame(scaler.transform(validate[X]), columns=validate[X].columns.values).set_index([validate[X].index.values])\n validate[name] = kmeans.predict(v_scaled)\n validate[name] = 'cluster_' + validate[name].astype(str)\n \n t_scaled = pd.DataFrame(scaler.transform(test[X]), columns=test[X].columns.values).set_index([test[X].index.values])\n test[name] = kmeans.predict(t_scaled)\n test[name] = 'cluster_' + test[name].astype(str)\n \n centroids = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=X_scaled.columns)\n return df, X_scaled, scaler, kmeans, centroids","def Demo_K_Means_Orch(log,\n\t\t\t\t train_data,\n\t\t\t\t class_label,\n\t\t\t\t cluster_range,\n\t\t\t\t silhouette_cluster_range,\n\t\t\t\t train_col_names = None, \n\t\t\t\t x_feature_index = 0,\n\t\t\t\t y_feature_index = 1,\n\t\t\t\t viz = False,\n\t\t\t\t show = False,\n\t\t\t\t viz_name = \"\",\n\t\t\t\t test_name = \"\"):\n\n\t\t\n\t#Strip and replace off any spaces\n\ttest_name = test_name.strip().replace(\" \",\"_\")\n\n\t#Initialize customer segmentation test\n\ttest = CustomerSegmentation(Method = KMeans(), \n\t\t\t\t\t\t\t\tdata = train_data,\n\t\t\t\t\t\t\t\tlog = log, \n\t\t\t\t\t\t\t\ttest_name = test_name)\n\n\n\t# Set train data and class labels\n\ttest.Preprocess.set_train_data(train_data, \n\t\t\t\t\t\t\t\t col_names = train_col_names)\n\ttest.Preprocess.set_class_label(class_label)\n\n\t# Conduct PCA, fit and transformation\n\ttest.Preprocess.PCA_fit(viz = viz, viz_name = viz_name, show = show)\n\ttest.Preprocess.PCA_transform()\n\n\n\tif viz:\n\t\t#Create cluster plot visualization if requested\n\t\tcluster_plot = cluster_viz(test.train_data, test.class_label, x_feature_index = x_feature_index, y_feature_index = y_feature_index)\n\t\t\n\t\t#Show the plot at runtime if requested\n\t\tif show:\n\t\t\tcluster_plot.show()\n\n\t\t#Save the image\n\t\ttest.Log.saveImage(cluster_plot, \"cluster_plot\", test.viz_folder_name)\n\n\t#Conduct elbow chart analysis\n\ttest.SegMethod.elbow_chart_test(cluster_range, viz = viz,show = show, viz_name = viz_name, profile = True)\n\n\t#Conduct Silhouette analysis\n\t#test.Preprocess.silhouette_analysis(silhouette_cluster_range, viz = viz, viz_name = viz_name, show = show)\n\n\t#Save Preprocess and Method logs\n\ttest.Preprocess.PreprocessLog.savePreprocessLog()\n\ttest.SegMethod.MethodLog.saveMethodLog()\n\n\t#Add final masterlog record\n\tlog.addMasterLogRecord(test)","def knn(trainingSetData, testSetData, k):\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\n testSet = testSetData.drop([14], axis=1) # drop income\n\n distances = {}\n # this will store the distances re-sorted in ascending/descending order\n sort = {}\n # income band results (>=50k or <50K)\n incomePredictions = []\n\n # Calculating euclidean distance between each row of training data and test data instance\n for testInstance in range(len(testSet)): # len(testSet)\n \n # Store current test Point:\n testInstance = testSet.iloc[testInstance] \n \n distances = euclideanDistanceRow(testInstance, trainingSet)\n\n # sort the distances in order of smallest first:\n sorted_d = sorted(distances.items(), key=lambda x: x[1], reverse=False)\n\n neighbors = []\n\n # Extracting top k neighbors\n for x in range(k):\n neighbors.append(sorted_d[x])\n\n\n classVotes = {}\n\n # Calculating the most freq class in the neighbors\n results = {\"lessThan50\": 0, \"moreThan50\": 0}\n\n # creating a dataframe to which we will add the income values:\n\n for x in range(len(neighbors)):\n if (trainingSetData.iloc[neighbors[x][0]][14] == 0.0):\n results[\"lessThan50\"] += 1\n elif (trainingSetData.iloc[neighbors[x][0]][14] == 1.0):\n results[\"moreThan50\"] += 1\n\n print('results',results)\n\n if (results[\"lessThan50\"] > results[\"moreThan50\"]):\n incomePredictions.append(0.0)\n elif (results[\"lessThan50\"] < results[\"moreThan50\"]):\n incomePredictions.append(1.0)\n\n return incomePredictions","def cluster_membership_occupancy(data):\n \n \n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n\n if n_clusters == 0:\n membership=[Cluster_Membership_Features()]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n areas=[Cluster_Area_Features()]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features()]\n density = pd.DataFrame([o.__dict__ for o in density])\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n \n elif n_clusters ==1:\n #obtain_total_cluster_areas_set_everything_else_to_default\n membership=[Cluster_Membership_Features()]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n \n try:\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\n except:\n cluster_chull_areas=[0,0,0]\n \n Total_cluster_area=np.sum(cluster_chull_areas)\n areas=[Cluster_Area_Features([Total_cluster_area,0,0,0,0,0,0,0,0])]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features()]\n density = pd.DataFrame([o.__dict__ for o in density])\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n \n elif n_clusters >1:\n #Summarizing the cluster membership distribution characteristics\n cluster_size_nums=np.delete(np.array(data.groupby(['clusters']).size()),0)\n (cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD)= distribution_statistics(cluster_size_nums)\n\n #For each cluster calculate the area by calculating the area of the convex hull of cluster members\n # Note: concavehull implementation here might be a good addition as it will provide more imformative values. \n\n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n try:\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\n except:\n cluster_chull_areas=[0,0,0,0,0]\n \n\n (avg_cluster_area,min_cluster_area,max_cluster_area,\n std_cluster_area,CV_cluster_area,CD_cluster_area,\n IQR_cluster_area,Quartile_CD_cluster_area)= distribution_statistics(cluster_chull_areas)\n Total_cluster_area=np.sum(cluster_chull_areas)\n\n #Calculate cluster density: number of nuclei/ convex area of cluster\n cluster_density=np.divide(cluster_size_nums,cluster_chull_areas)\n (avg_cluster_density,min_cluster_density,max_cluster_density,\n std_cluster_density,CV_cluster_density,CD_cluster_density,\n IQR_cluster_density,Quartile_CD_cluster_density)= distribution_statistics(cluster_density)\n\n #return dataframe of features\n membership=[Cluster_Membership_Features([cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD])]\n membership = pd.DataFrame([o.__dict__ for o in membership])\n areas=[Cluster_Area_Features([Total_cluster_area,\n avg_cluster_area,min_cluster_area,max_cluster_area,\n std_cluster_area,CV_cluster_area,CD_cluster_area,\n IQR_cluster_area,Quartile_CD_cluster_area])]\n areas = pd.DataFrame([o.__dict__ for o in areas])\n density=[Cluster_Density_Features([avg_cluster_density,min_cluster_density,max_cluster_density,\n std_cluster_density,CV_cluster_density,CD_cluster_density,\n IQR_cluster_density,Quartile_CD_cluster_density])]\n density = pd.DataFrame([o.__dict__ for o in density])\n\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\n density], axis=1)\n return all_features","def compute_random_baseline(self, classes):\n\n # based on the class distribution of the data\n sum_benefit = 0\n\n # c is the actual label\n # if the label in y is unseen when training, skip it, don't include it in the error\n for i, c in enumerate(self.y_chunk):\n for j, cprime in enumerate(classes):\n\n # (1) compute the benefit matrix\n benefit_c_cprime = 0\n if cprime == self.fraud_label:\n benefit_c_cprime = self.X_chunk[i][-1] - self.cost if c == self.fraud_label else -self.cost\n\n # (2) get the probability\n probab_ic = 1 / len(classes)\n sum_benefit += probab_ic * benefit_c_cprime\n\n return sum_benefit","def compute_centers(points, labels):\n df = pd.DataFrame(points)\n return df.groupby(labels).mean().values","def fit_predict(self, train_x: pd.DataFrame, train_y: pd.Series, test_x: pd.DataFrame, test_y: pd.Series) -> dict:\n self.evaluator.fit(train_x, train_y, test_x, test_y)\n predictions = self.evaluator.predict(test_x)\n print(predictions)\n metrics = metrics_stat(predictions, test_y)\n return metrics","def naive_bayes(df):\n\n X = df.loc[:, :'perfs'].reset_index(drop=True)\n y = df.loc[:, 'Popularity'].reset_index(drop=True).values\n\n # convert categorical data to numerical\n for i in X.columns:\n if type(X[i][0]) == str:\n X[i] = X[i].astype(\"category\").cat.codes\n # normalize the data\n normDF = preprocessing.normalize(X, axis=0)\n\n X_train, X_validate, Y_train, Y_validate = train_test_split(normDF, y, test_size=0.2, random_state=42)\n\n gnb = GaussianNB()\n gnb.fit(X_train, Y_train)\n y_pred = gnb.predict(X_validate)\n\n kfold = KFold(n_splits=10, random_state=42, shuffle=False)\n cv_results = cross_val_score(gnb, X_train, Y_train, cv=kfold, scoring='accuracy')\n msg = \"%f (%f)\" % (cv_results.mean(), cv_results.std())\n\n print(\"Confusion Matrix\")\n print(confusion_matrix(Y_validate, y_pred))\n print(classification_report(Y_validate, y_pred))\n print(\"Accuracy score of training data: \", msg)\n print('Accuracy score of testing data: ', accuracy_score(Y_validate, y_pred))\n print(\"\")\n\n return","def MK(df_train, df_test):\n\n # number of periods\n T = df_train.shape[0]\n\n # matrix of individual forecasts\n F = df_train.iloc[:, 1:].values\n F_test = df_test.iloc[:, :].values\n\n # number of agents\n K = df_test.shape[1]\n\n # true outcomes\n y = df_train.iloc[:, 0].values\n\n # initialize agent wealth (sum equal to 1 -> results in convex combination)\n w = np.full(K, 1/K, dtype=float)\n\n # initialize standard deviations\n sigma = np.full(K, 1, dtype=float)\n\n # run market for all observations (training the market)\n for i in range(T):\n\n # individual predictions in the current market\n ind_pred = F[i, :]\n\n # size of bet at the true outcome (kernel evaluated at true outcome)\n kernel_val = sps.norm.pdf(y[i], loc=ind_pred, scale=sigma)\n\n # scale by the size of budget of each agent\n w_kernel_val = np.multiply(w, kernel_val)\n\n # reward agents\n w = w_kernel_val / np.sum(w_kernel_val)\n\n # update sigma\n abs_error = np.abs(y[i] - ind_pred)\n sigma = ((i+1)*sigma + abs_error) / (i + 2)\n\n # using the trained market for out of sample forecasts\n # obtain the aggregated market prediction in each test market\n market_pred = np.dot(F_test, w)\n\n # output\n df_pred = pd.DataFrame(\n {\"Market for Kernels\": market_pred},\n index=df_test.index\n )\n\n return df_pred","def prepareSplitClassifier(df, models, choice):\n\n\n def classificationOutput(clf, X, Y):\n \"\"\"\n Fit the model and print the classification results\n - confusion_matrix\n - avg scores etc\n \"\"\"\n n_samples = 36\n\n print \"\\n\\nClassifier: \\n %s\" % (clf)\n print \"#\" * 79\n # classifier_gnb = naive_bayes.GaussianNB() # initiating the classifier\n\n clf.fit(X[:n_samples], Y[:n_samples]) # train on first n_samples and test on last 10\n\n expected = Y[n_samples:]\n predicted = clf.predict(X[n_samples:])\n print(\"Classification report:\\n%s\\n\" % (metrics.classification_report(expected, predicted)))\n print(\"\\nConfusion matrix:\\n%s\" % metrics.confusion_matrix(expected, predicted))\n\n\n\n\n def splitclassify(cDf):\n \"\"\"\n Given the dataframe combined with equal fair and unfair apps,\n classify them\n \"\"\"\n cDf = cDf.reindex(np.random.permutation(cDf.index)) # shuffle the dataframe\n featCols = set(cDf.columns)\n featCols.remove('appLabel')\n\n features = cDf[list(featCols)].astype('float')\n\n ## Scale the features to a common range\n min_max_scaler = preprocessing.MinMaxScaler()\n X = min_max_scaler.fit_transform(features.values)\n\n Y = cDf['appLabel'].values\n\n\n if choice == 'all':\n for key in models:\n classifier = models[key]\n classificationOutput(classifier, X, Y)\n else:\n if choice in models:\n classifier = models[choice]\n classificationOutput(classifier, X, Y)\n else:\n print \"Incorrect Choice\"\n\n\n\n fairDf = df[df['appLabel'] == False]\n unfairDf = df[df['appLabel'] == True]\n\n\n # calculate total possible splits of fair data frame relatie to\n # size of unfair dataframe\n splits = len(fairDf) // len(unfairDf)\n\n for i in range(splits):\n clDf = fairDf[i : i+len(unfairDf)].append(unfairDf)\n\n # print fairDf.values, unfairDf.values\n print \"Classifying %d th split of fair apps with unfair app\" % (i)\n print \"-\" * 79\n splitclassify(clDf)\n print \"\\n\\n\"","def stdConfidenceTrades(predictions, buy_confidence=1.5, sell_confidence=1.1):\n smooth_preds = pd.Series(predictions).rolling(5).mean()\n buy_thresh = np.mean(smooth_preds) + buy_confidence * np.std(smooth_preds)\n sell_thresh = np.mean(smooth_preds) - sell_confidence * np.std(smooth_preds)\n buy_positions = np.where(predictions > buy_thresh)[0]\n sell_positions = np.where(predictions < sell_thresh)[0]\n \n buys = buy_positions\n sells = []\n curSell = 0\n for curBuy in buys:\n arr = np.where(sell_positions > curBuy)[0]\n if len(arr):\n sells.append(sell_positions[arr[0]])\n tradePairs = list(zip(buys, sells))\n return tradePairs","def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\n res = []\n for n_clusters in n_clusters_considered:\n res.append([])\n for _ in range(n_repeats):\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\n print(X.val.shape)\n print(X_restricted.val.shape)\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\n res[-1].append(evaluator_X.weighted_average) \n return res","def _avg_cluster_hitprobability(self, x, y, n_clusters=30):\n\n # Compute the individual Hit probability\n proba = self._shufflesplit(x, y)\n\n # average the individual hit probability for each cluster\n ind = self._cluster(x, x.shape[0]/2.)\n\n avg_proba = np.copy(proba)\n\n for cluster in np.unique(ind):\n mask_ = ind == cluster\n avg_proba[mask_] = avg_proba[mask_].mean()\n\n return avg_proba","def cluster(players_df, columns):\n\toptimal_n=None\n\toptimal_clusters=None\n\toptimal_clusterer=None\n\toptimal_silhouette=-99\n\tfor n in range(2,9):\n\t\tclusterer=KMeans(n_clusters=n)\n\t\tcluster_labels=clusterer.fit_predict(players_df[columns])\n\t\tavg_silhouette=silhouette_score(players_df[columns], cluster_labels)\n\t\tprint('The avg silhouette score for {} clusters is {}'.format(n, avg_silhouette))\n\t\tif avg_silhouette > optimal_silhouette:\n\t\t\toptimal_silhouette=avg_silhouette\n\t\t\toptimal_clusterer=clusterer\n\t\t\toptimal_clusters=cluster_labels\n\t\t\toptimal_n=n\n\tprint('Returning optimal clusters found with n={}'.format(optimal_n))\n\tclusters = {n: [] for n in range(optimal_n)}\n\tfor i, label in enumerate(optimal_clusters):\n\t\tclusters[label].append(\n\t\t\tdict(\n\t\t\t\tplayer_id=players_df.iloc[i]['PERSON_ID'],\n\t\t\t\tfirst_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[-1],\n\t\t\t\tlast_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[0],\n\t\t\t\t)\n\t\t\t)\n\treturn clusters","def k_means(n_clust, data_frame, true_labels):\n k_means = KMeans(n_clusters=n_clust, random_state=123, n_init=30)\n k_means.fit(data_frame)\n c_labels = k_means.labels_\n df = pd.DataFrame({'clust_label': c_labels, 'orig_label': true_labels.tolist()})\n ct = pd.crosstab(df['clust_label'], df['orig_label'])\n y_clust = k_means.predict(data_frame)\n display(ct)\n print('% 9s' % 'inertia homo compl v-meas ARI AMI silhouette')\n print('%i %.3f %.3f %.3f %.3f %.3f %.3f'\n % (k_means.inertia_,\n homogeneity_score(true_labels, y_clust),\n completeness_score(true_labels, y_clust),\n v_measure_score(true_labels, y_clust),\n adjusted_rand_score(true_labels, y_clust),\n adjusted_mutual_info_score(true_labels, y_clust),\n silhouette_score(data_frame, y_clust, metric='euclidean')))","def __kmeans__(cls, cluster_size, pca_reduced, names: list):\n import warnings\n warnings.filterwarnings(\"ignore\")\n clusterer = KMeans(n_clusters=cluster_size, random_state=10)\n cluster_labels = clusterer.fit_predict(pca_reduced)\n result = list()\n result.append(ClusterProcessor.davies_bouldin(cluster_labels, pca_reduced, cluster_size, names))\n result.append(ClusterProcessor.variance_ratio_criterion(cluster_labels, pca_reduced, cluster_size, names))\n result.append(ClusterProcessor.silhouette_coefficient(cluster_labels, pca_reduced, cluster_size, names))\n return result","def add_sales_per_customer(historical, test):\n # load historical - use this in data.py\n # historical = pd.read_csv('./data/raw/train.csv')\n\n data = historical.groupby('Store').mean()\n data.loc[:, 'sales-per-customer'] = data.loc[:, 'Sales'] / data.loc[:, 'Customers']\n data = data.loc[:, ['Customers', 'sales-per-customer']]\n data.columns = ['mean-customers', 'sales-per-customer']\n data.fillna({\n 'mean-customers': np.mean(data.loc[:, 'mean-customers']),\n 'sales-per-customer': np.mean(data.loc[:, 'sales-per-customer'])\n }, inplace=True)\n test = test.merge(data, on='Store')\n return test","def mid_market_price(orders: pandas.DataFrame):\n return numpy.mean((best_bid_price(orders), best_ask_price(orders)))","def __call__(self, clfs, dataset):\n if len(clfs)==0:\n return [] # to don't even bother\n\n all_predictions = []\n for clf in clfs:\n # Lets check first if necessary conditional attribute is enabled\n if not clf.ca.is_enabled(\"predictions\"):\n raise ValueError, \"MeanPrediction needs learners (such \" \\\n \" as %s) with state 'predictions' enabled\" % clf\n all_predictions.append(clf.ca.predictions)\n\n # compute mean\n all_predictions = np.asarray(all_predictions)\n predictions = np.mean(all_predictions, axis=0)\n\n ca = self.ca\n ca.estimates = all_predictions\n ca.predictions = predictions\n return predictions","def get_ephys_super_data(model, fit_data, ephys_raw):\n # cl_labels = np.arange(1, model.n_components + 1)\n # cl_labels = ['cluster_{}'.format(cl_idx + 1)\n # for cl_idx in range(model.n_components)]\n\n # get cluster prediction counts\n y_pred = model.predict(fit_data)\n # y_cnts = pd.Series(0, index=range(model.n_components))\n y_cnts = np.zeros(model.n_components, dtype=int)\n for cl_idx, cnt in Counter(y_pred).items():\n y_cnts[cl_idx] = cnt\n y_cnts = pd.Series(y_cnts)\n\n resp = model.predict_proba(fit_data)\n\n cluster_super_means = {}\n super_data_means = {}\n super_data_stds = {}\n for k in ephys_raw.keys():\n\n super_data = ephys_raw[k]\n super_data_means[k] = super_data.mean(axis=0)\n super_data_stds[k] = super_data.std(axis=0)\n\n cluster_super_means[k] = get_super_means(resp=resp,\n super_data=super_data,\n stand=False)\n\n return cluster_super_means, super_data_means, super_data_stds, y_cnts","def calculate_mean_average_precision(class_name='', current_neuron_index=current_neuron_index, acts=acts, verbose=verbose, minx=0.000000001):\n #\n current_neuron = acts.get_activations_for_neuron(current_neuron_index) # get the neuron's data\n x_data = current_neuron.vector # get the activations without classes\n # grab your list of points\n local_list, selected_activations = grab_points_for_a_cluster(current_neuron_index,\n min_selected_x_data=minx,\n max_selected_x_data=max(x_data),\n acts=acts,\n x_data=x_data,\n verbose=verbose)\n Q = len(local_list) # total length of list\n # get the test class (this is the correct class or 'A')\n if class_name == '':\n test_class = local_list[-1][0]\n else:\n test_class = class_name\n # set up counters\n MAP = 0 # mean average precision\n count_of_test_class = 0\n # loop backwards through the list, abs j is the position in a 1-indexed list\n for i in range(Q+1):\n j = -(i + 1) # 1 indexed\n current_class = local_list[j][0] # current class\n if j == -Q:\n # if the whole of local_list is the same class (this accounts for zero indexing)\n if verbose:\n print(current_class)\n print('{}/{}'.format(count_of_test_class, abs(j)))\n j = j -1 # really this is here so we can check j\n break\n if (current_class == test_class):\n count_of_test_class = count_of_test_class + 1\n MAP = MAP + count_of_test_class/(abs(j)) # N.b. this is the sum, we divide by j on the output\n return MAP/Q","def balance_classes(df):\n df_class_0 = df[df[65]==0]\n df_class_1 = df[df[65]==1]\n df_count = df[65].value_counts()\n count_0 = df_count[0]\n count_1 = df_count[1]\n\n if count_0 > count_1:\n df_class_1_over = df_class_1.sample(count_0, replace=True)\n df_over = pd.concat([df_class_0, df_class_1_over], axis=0)\n elif count_0 < count_1:\n df_class_0_over = df_class_0.sample(count_1, replace=True)\n df_over = pd.concat([df_class_1, df_class_0_over], axis=0)\n else:\n df_over = df\n \n return df_over","def predictClusters(self, df, k):\n self.models.fitModels(df)\n return self.models.predict()","def split_train_test(ratings):\r\n ratings = ratings.sample(frac=1).reset_index(drop=True)\r\n train_user_list = []\r\n train_item_list = []\r\n train_rating_list = []\r\n test_user_list = []\r\n test_item_list = []\r\n test_rating_list = []\r\n user_pool = set(ratings['userId'].unique())\r\n for idx in user_pool:\r\n flag = 0\r\n items = ratings[ratings['userId']==idx][['itemId','rating']]\r\n for i, row in items.iterrows():\r\n if flag == 0:\r\n test_user_list.append(int(idx))\r\n test_item_list.append(int(row['itemId']))\r\n test_rating_list.append(row['rating'])\r\n flag = 1\r\n else:\r\n train_user_list.append(int(idx))\r\n train_item_list.append(int(row['itemId']))\r\n train_rating_list.append(row['rating'])\r\n\r\n train = pd.DataFrame({'userId': train_user_list, 'itemId': train_item_list, 'rating': train_rating_list}, columns=['userId', 'itemId', 'rating'])\r\n test = pd.DataFrame({'userId': test_user_list, 'itemId': test_item_list, 'rating': test_rating_list}, columns=['userId', 'itemId', 'rating'])\r\n return [train, test]\r\n \r\n\r\n \r\n #train, test = train_test_split(ratings, test_size=0.1, shuffle=True)\r\n #return [train, test]\r","def _class_cov(X, y):\n classes = np.unique(y)\n covs = []\n for group in classes:\n Xg = X[y == group, :]\n covs.append(np.atleast_2d(_cov(Xg)))\n return np.average(covs, axis=0)","def calc_earning(self, data=None):\n result = Result()\n if data is None:\n data = self.security\n self.calcDecision()\n first_purchase_method = self.check_first_purchase_method()\n for i in np.arange(len(data['Close'])):\n if data['FinalDecision'].iloc[i] is None:\n pass\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\n self.buys_made += 1\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\n self.shares_own = self.stock_quantity\n self.buys_made += 1\n else:\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\n self.final_capital = self.final_capital % data['Close'].iloc[i]\n #print(self.shares_own)\n\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n pass\n else:\n self.final_capital += self.shares_own * data['Close'].iloc[i]\n self.shares_own = 0\n self.sells_made +=1\n #Checar si es el momento mas alto o bajo de ganancias\n if self.shares_own == 0:\n if (self.highest_point is None\n or self.highest_point < self.final_capital):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > self.final_capital\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n else:\n if (self.highest_point is None\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n self.calcRealFinalCapital()\n self.calcDiferencePercentage()","def cross_val(model, data, n, target):\n scores = []\n splits = partition(data, n)\n for i in range(n):\n train_list = splits[:i] + splits[i+1:]\n train = pd.concat(train_list)\n test = splits[i]\n y_true = test[target]\n test = test.drop(columns=[target], axis=1)\n model.fit(train, estimator=BayesianEstimator, prior_type=\"BDeu\")\n y_pred = model.predict(test)\n acc = accuracy_score(y_pred[target], y_true)\n scores.append(acc)\n return scores","def usefulness_score(model, test, train, k=20):\n distances = []\n test = test.tocsr()\n train = train.tocsr()\n (x, y, z) = sp.find(train.T)\n counts = np.bincount(x)\n counts += 1\n sums = np.bincount(x, weights=z)\n averages = sums / counts\n\n for user_id, row in enumerate(test):\n\n if not len(row.indices):\n continue\n\n predictions = -model.predict(user_id)\n\n if train is not None:\n rated = train[user_id].indices\n predictions[rated] = FLOAT_MAX\n\n rec_list = predictions.argsort()[:k]\n distances.append(np.mean(averages[rec_list]))\n return np.array(distances)","def evaluate(train: pd.DataFrame, test: pd.DataFrame, algorithm):\n\n model = algorithm(train)\n\n test_labels = test['Labels']\n\n predictions = predict_data(test, model)\n\n error = mean_square_error(predictions, test_labels)\n\n acc = accuracy(predictions, test_labels)\n\n return acc, error","def main():\n # Read in trainingSet and testSet as a DataFrame\n trainingOriginal = pd.read_csv(\n filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.train.5fold.csv\")\n testOriginal = pd.read_csv(filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.test.csv\")\n\n # Select only the numeric data\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\n training = pd.concat([training.reset_index(drop=True),\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Select only the numeric data\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\n test = pd.concat([test.reset_index(drop=True),\n testOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Normalize the columns for training and test\n # print training['age'].min()\n # print training['age'].max()\n # print training.head()\n\n # Run max-min normalization on numerical columns for testing and training data\n for i in range(6):\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\n\n # Convert the 'earns' column to boolean as follows\n training['earns'] = training['earns'] == '>50K'\n test['earns'] = test['earns'] == ' >50K'\n\n # Group the training set by the fold attribute as given by the dataset\n trainingForFinal = training\n training = training.groupby('fold')\n\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\n kList = []\n for i in range(40):\n if i % 2 == 1:\n kList.append(i)\n\n # Empty dictionary to hold performance of each k-values and its accuracy\n performance = {}\n\n # Compute the performance for each k-value\n for k in kList:\n performance = crossValidation(training, k, performance)\n\n # Sort the performance dictionary by its accuracy (value)\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\n\n # Open file to write results\n file = open('grid.results.txt', 'w')\n # Write the results to file\n file.write(\"K | Accuracy\\n\")\n for item in performance:\n if item[0] < 10:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n else:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n # Close file\n file.close()\n\n # The best K is the one at the top of the list after the sorting\n bestK = performance[0][0]\n\n print 'Running Test Set with K = ' + str(bestK)\n\n applyModel(test,trainingForFinal,bestK)","def __create_cluster_profiles(self,\n clustered_dataframes,\n shrunken_df,\n numerical_features,\n le_map,\n output_path,\n find_nearest_on_cols=False,\n show=True):\n\n def find_nearest(numbers, target):\n \"\"\"\n Find the closest fitting number to the target number\n \"\"\"\n numbers = np.asarray(numbers)\n idx = (np.abs(numbers - target)).argmin()\n return numbers[idx]\n\n cluster_profiles_df = pd.DataFrame(columns=shrunken_df.columns).drop(\n 'Cluster_Name', axis=1)\n rows_count = 0\n for cluster_identfier, cluster_dataframe in \\\n clustered_dataframes.items():\n df = pd.DataFrame(columns=cluster_dataframe.columns)\n df = df.append(cluster_dataframe.mean(), ignore_index=True)\n df.index = [cluster_identfier]\n\n if cluster_dataframe.shape[0] <= 1:\n continue\n\n # Attempt to convert numbers found within the full set of data\n for col in cluster_dataframe.columns:\n if col not in numerical_features or find_nearest_on_cols:\n df[col] = find_nearest(numbers=shrunken_df[\n col].value_counts().index.tolist(),\n target=df[col].values[0])\n\n # Evaluate cluster dataframe by dataframe\n eval_df = pd.DataFrame(columns=cluster_dataframe.columns)\n eval_df = eval_df.append(\n cluster_dataframe.mean(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.min(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.median(),\n ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.max(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.std(), ignore_index=True)\n eval_df = eval_df.append(\n cluster_dataframe.var(), ignore_index=True)\n eval_df.index = [\"Mean\", \"Min\", \"Median\",\n \"Max\", \"Standard Deviation\", \"Variance\"]\n\n if show:\n print(\"Total found in {0} is {1}\".format(\n cluster_identfier, cluster_dataframe.shape[0]))\n self.__render_mpl_table(\n df,\n sub_dir=output_path,\n filename=cluster_identfier +\n \"_Means_Rounded_To_Nearest_Real_Numbers\",\n header_columns=0,\n col_width=4.0)\n\n self.__render_mpl_table(\n eval_df,\n sub_dir=output_path,\n filename=cluster_identfier +\n \"_Eval_Df\",\n header_columns=0,\n col_width=4.0)\n display(df)\n display(eval_df)\n self.__vertical_spacing(7)\n\n cluster_profiles_df = cluster_profiles_df.append(\n self.__decode_df(df, le_map))\n\n rows_count += cluster_dataframe.shape[0]\n\n return rows_count, cluster_profiles_df","def decision_function(self, X):\n\n n, _ = X.shape\n\n # predict the cluster labels + distances to the clusters\n labels = self.base_clusterer.predict(X)\n # each dimension is the distance to the cluster centers (n_samples, n_clusters)\n distances = self.base_clusterer.transform(X)\n\n # compute scores\n scores = np.zeros(n, dtype=float)\n for i, l in enumerate(labels):\n if self.max_intra_cluster[l] < self.tol:\n point_deviation = 1.0\n else:\n point_deviation = distances[i, l] / self.max_intra_cluster[l]\n scores[i] = (\n point_deviation * self.cluster_deviation[l]\n ) / self.cluster_sizes[l]\n\n return scores","def voting(y_pred_test, gnd_te):\n df = pd.DataFrame({'y':y_pred_test, 'gnd':gnd_te})\n df.sort_values(by=['y'], inplace=True, ascending=False)\n out = df.groupby(['gnd']).mean()\n return len(out[out['y'] > 0])/float(len(out))","def groups_of_train_test_set(df, config, fbprophet=None):\n \n tvar = config.variables['tvar']\n xvar = config.variables['xvar'] + config.variables['xvar_derived']\n \n begin_date = config.timestamps['begin_date']\n end_date = config.timestamps['end_date']\n deltat = config.timestamps['deltat']\n\n begin_date = datetime.datetime.strptime(begin_date, \"%Y-%m-%d %H:%M:%S\")\n end_date = datetime.datetime.strptime(end_date, \"%Y-%m-%d %H:%M:%S\")\n\n \n # Check if ustar threshold is provided for year of interest\n if config.data['ustar']==True:\n if not begin_date.year in config.data['ustar_map'].keys():\n raise ValueError('{} is missing from config/data/ustar_map'.format(begin_date.year))\n if not end_date.year in config.data['ustar_map'].keys():\n raise ValueError('{} is missing from config/data/ustar_map'.format(end_date.year))\n\n\n if (end_date - begin_date).days < deltat:\n raise ValueError(\"Time difference in days between begin and end date\" + \n \"must be greater than deltat.\")\n\n\n df = df.loc[df[tvar] <= end_date]\n\n number_of_train_test_sets = int((end_date - begin_date).total_seconds()/\\\n datetime.timedelta(deltat).total_seconds())\n\n begin_test_timestamp = begin_date\n \n\n test_df = []\n train_df = [] \n for i in range(number_of_train_test_sets):\n if i == number_of_train_test_sets-1:\n end_test_timestamp = end_date\n else:\n end_test_timestamp = None\n\n\n i_test_set, i_train_set, end_test_timestamp =\\\n _train_test_split(df.copy(), config,\n begin_test_timestamp,\n deltat, end_test_timestamp,\n fbprophet)\n begin_test_timestamp = end_test_timestamp\n \n # Interpolating where x-var is nan.\n i_test_set[xvar] = i_test_set[xvar].interpolate()\n i_train_set[xvar] = i_train_set[xvar].interpolate()\n \n\n i_test_set['Set_rank'] = i\n i_train_set['Set_rank'] = i\n \n if i == 0:\n test_df = i_test_set\n train_df = i_train_set\n else:\n test_df = pd.concat((test_df, i_test_set))\n train_df = pd.concat((train_df, i_train_set))\n\n\n return test_df, train_df","def evaluation_k_means(X_selected, n_clusters, y, n_jobs = 1):\n k_means = KMeans(n_clusters=n_clusters, init='k-means++', n_init=10, max_iter=300,\n tol=0.0001, precompute_distances=True, verbose=0,\n random_state=None, copy_x=True, n_jobs=n_jobs)\n \n k_means.fit(X_selected)\n y_predict = k_means.labels_\n \n # calculate NMI\n nmi = normalized_mutual_info_score(y, y_predict)\n \n # calculate ACC\n y_permuted_predict = best_map(y, y_predict)\n acc = accuracy_score(y, y_permuted_predict)\n \n return nmi, acc","def compute_clusters(addons_df, num_clusters, random_seed):\n\n # Build the stages of the pipeline. We need hashing to make the next\n # steps work.\n hashing_stage = HashingTF(inputCol=\"addon_ids\", outputCol=\"hashed_features\")\n idf_stage = IDF(inputCol=\"hashed_features\", outputCol=\"features\", minDocFreq=1)\n # As a future improvement, we may add a sane value for the minimum cluster size\n # to BisectingKMeans (e.g. minDivisibleClusterSize). For now, just make sure\n # to pass along the random seed if needed for tests.\n kmeans_kwargs = {\"seed\": random_seed} if random_seed else {}\n bkmeans_stage = BisectingKMeans(k=num_clusters, **kmeans_kwargs)\n pipeline = Pipeline(stages=[hashing_stage, idf_stage, bkmeans_stage])\n\n # Run the pipeline and compute the results.\n model = pipeline.fit(addons_df)\n return model.transform(addons_df).select([\"client_id\", \"prediction\"])","def kmeans_clustering(proj_df, k):\r\n k_means= k_means = KMeans(random_state=25, n_clusters=k)\r\n k_means.fit(proj_df)\r\n labels= k_means.predict(proj_df)\r\n \r\n return labels","def train_val_test_split(df):\n from sklearn.model_selction import train_test_split\n train, test = train_test_split(df, train_size = 0.80, test_size=0.20,\n random_state = 42)\n train, val = train_test_split(train, train_size = 0.70, val_size=0.30)\n print(train.shape, val.shape, test.shape)\n\n return train, val, test","def k_means_model(df, numOfClusters):\n # Perform scaling on the dataframe containing the selected features\n data = scale(df)\n\n # Train a model\n model = KMeans(init=\"k-means++\", n_clusters=numOfClusters, n_init=20).fit(data)\n return model","def calculate_profit(self):","def apply_evaluation(x, label_true, params, names, database_name):\n rows = []\n\n for i in range(0, len(names)):\n act_name = names[i]\n act_data = x[i]\n\n algorithm = KMeans(k=params['k'], seed=params['seed'], max_it=params['max_it'], tol=params['tol'])\n labels = algorithm.fit_predict(act_data)\n\n unsupervised = evaluate_unsupervised_internal(act_data, labels)\n supervised = evaluate_supervised_external(label_true, labels)\n\n row = {**dict(Names=act_name), **supervised, **unsupervised}\n rows.append(row)\n df_results = pd.DataFrame(rows)\n set_output(df_results, 'pca_analysis_'+database_name)","def get_cluster_assignments(self, data, n_clusters=10):\n kmeans = KMeans(n_clusters=n_clusters)\n kmeans.fit(data)\n pred = kmeans.predict(data)\n return pd.DataFrame(pred)","def groupby_train_test_split(df, selected_features=None, test_ratio=0.2, seed=12345, groupby='user_id'):\n\n ############################################################\n # Train Test Split\n ############################################################\n\n grp = df[groupby]\n n_splits = int(1 / test_ratio)\n groupkfold = GroupKFold(n_splits=n_splits)\n random.seed(seed)\n folds = groupkfold.split(df, groups = grp)\n train_idx, test_idx = next(folds)\n df_train, df_test = df.iloc[train_idx], df.iloc[test_idx]\n \n return df_train, df_test","def evaluate_on_test(self, train_set, test_set):\n if train_set is not None and test_set is not None:\n print(\"Evaluate RMSE on test data\")\n self.LOG_HANDLE.info(\"Evaluate RMSE on test data\")\n\n similarity_options = {\n 'name': 'msd',\n 'user_based': False,\n }\n\n # Use the KNN algorithm\n algo = KNNWithMeans(sim_options = similarity_options)\n\n # Train the algorithm on the trainset, and predict ratings for the testset\n algo.fit(train_set)\n predictions = algo.test(test_set)\n\n # Then compute RMSE\n return accuracy.rmse(predictions)","def cluster(X=None, datalabels=None, nc=2):\n from sklearn.cluster import KMeans\n from sklearn.cluster import AffinityPropagation\n\n C = KMeans(n_clusters=nc,n_init=10,init='random')\n C.fit(X[:,:1])\n\n #C = AffinityPropagation(preference=-80,damping=0.5).fit(X)\n #cluster_centers_indices = C.cluster_centers_indices_\n\n clust = {}\n for (i, label) in enumerate(C.labels_):\n key = C.cluster_centers_[label][0]\n #print label,key, datalabels[i],X[i][1]\n if not clust.has_key(key):\n clust[key]=[]\n clust[key].append(datalabels[i])\n #print clust\n return C, clust","def clusterability(features,data):\n #Get together features describing clustering results\n n_nuclei=len(features['label'])\n n_ellongated_nuc=len(data['label'])\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n n_uncoupled_nuclei = list(data['clusters']).count(-1) # noise\n n_coupled_nuclei = len(data['clusters'])-n_uncoupled_nuclei\n \n if n_clusters>=2:\n #calculate clustering robustness without noise\n Silohhouette_score= sklm.silhouette_score(data.drop(['clusters','label'],axis=1)[data['clusters']> -1], data['clusters'][data['clusters']> -1])\n else:\n Silohhouette_score = 'NA'\n basic_clustering_features = [Clusterability_Features([n_nuclei,n_ellongated_nuc,n_clusters, n_uncoupled_nuclei,n_coupled_nuclei,Silohhouette_score])]\n basic_clustering_features = pd.DataFrame([o.__dict__ for o in basic_clustering_features])\n\n return basic_clustering_features","def clusters(self,rng):\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\n if self.extended:\n dat = self.training_data / rng\n else:\n dat = self.training_data[:,0:-1] / rng[0:-1]\n\n clusts = subclust(normalize(dat))\n\n print len(clusts),\"initial clusters for class\",self.name\n if self.extended:\n return np.array([self.training_data[i] for i in clusts])\n else:\n return np.array([self.training_data[i,0:-1] for i in clusts])","def cluster_kmeans(df, k):\r\n # Sample fron the original df\r\n sample_df=df.sample(n = k)\r\n obs, attr= df.shape\r\n # Make copies \r\n copy_df=df.copy()\r\n flag=0\r\n sse_old=0\r\n while (flag==0): \r\n sse=0\r\n Labels=[]\r\n for i in range(0, obs):\r\n dist= []\r\n for j in range(0,k):\r\n #Calculate Eucledian distance\r\n diff=list((df.iloc[i,:]-sample_df.iloc[j,:])**2)\r\n eu_dist=(sum(diff))**(1/attr)\r\n dist.append(eu_dist) \r\n #Add Labels to the observations based on the variable they are close to\r\n label=(dist.index(min(dist)))\r\n Labels.append(label)\r\n # Calculate SSE\r\n sse=sse+((min(dist) )**2)\r\n sse=sse**(1/2)\r\n copy_df['labels']=Labels\r\n # Stopping criteria is change in SSE should be 2 %\r\n if (sse_old !=0):\r\n if(abs(sse_old-sse)/sse_old<=0.05):\r\n flag=1 \r\n return_df=copy_df['labels'].to_frame()\r\n return (return_df, sse)\r\n else:\r\n sse_old=sse\r\n #Empty the sample df\r\n sample_df.drop(sample_df.index, inplace=True)\r\n # Now pick random values from each label and add it to the sample df\r\n for val in range(0,k):\r\n #Create new sample df\r\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\r\n else:\r\n sse_old=sse\r\n #Empty the sample df\r\n sample_df.drop(sample_df.index, inplace=True)\r\n for val in range(0,k):\r\n #Create new sample df \r\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])","def kmeans(points,n_clusters):\n # create kmeans object\n kmeans = KMeans(n_clusters=n_clusters)\n # fit kmeans object to data\n kmeans.fit(points)\n # print location of clusters learned by kmeans object\n print(kmeans.cluster_centers_)\n # save new clusters for chart\n y_km = kmeans.fit_predict(points)\n\n print('Clusters partition: ', Counter(y_km))\n \n return y_km, kmeans","def test_example(self): \n num_clusters = 2\n iterations = 5\n ts1 = 2.5 * np.random.randn(100,) + 3\n X_1 = pd.Series(ts1)\n ts2 = 2 * np.random.randn(100,) + 5\n X_2 = pd.Series(ts2)\n ts3 = -2.5 * np.random.randn(100,) + 3\n X_3 = pd.Series(ts3)\n list_of_series = [X_1, X_2, X_3]\n from pynuTS.clustering import DTWKmeans\n clts = DTWKmeans(num_clust = num_clusters, num_iter = iterations)\n clts.fit(list_of_series)\n ts4 = 3.5 * np.random.randn(100,) + 2\n ts5 = -3.5 * np.random.randn(100,) + 2\n X_4 = pd.Series(ts4)\n X_5 = pd.Series(ts5)\n list_new = [X_4, X_5]\n clustering_dict = clts.predict(list_new)\n\n assert type(clustering_dict) is dict\n assert len(clustering_dict) == num_clusters","def evaluate_clusters(self, cluster_formulas, value='weighted_sum'):\n num_elems = len(self.labels)\n total_val = {}\n num_cl = len(cluster_formulas)\n clustered_points_num = 0\n print(\"\\n\\n\")\n print(\"Sufficiently big clusters: {}\".format(num_cl))\n for c, formula, val in cluster_formulas:\n c_size = len([l for l in self.labels if l == c])\n clustered_points_num += c_size\n\n if value == 'weighted_sum':\n total_val[c] = val * c_size / num_elems\n elif value == 'sum':\n total_val[c] = val * 1\n\n clust_val = sum(total_val.values())\n self.clustering_value = total_val\n print(\"Value of clustering: {}\".format(clust_val))\n return clust_val","def get_train_test(df):\n train = df[[\"Sex\", \"Race/Ethnicity\", \"AgeGroup\"]\n ].to_numpy()\n test = df[col_names].to_numpy()\n return (train, test)","def make_sklearn_prediction_classification(logger, run_id, df_train_X,\n df_train_Y, df_test_X, kf,\n features=None, params=None,\n model_type=None, is_test=False,\n seed=42, model=None):\n yoof = np.zeros(len(df_train_X))\n yhat = np.zeros(len(df_test_X))\n cv_scores = []\n result_dict = {}\n\n fold = 0\n for in_index, oof_index in kf.split(df_train_X[features], df_train_Y):\n # Start a counter describing number of folds\n fold += 1\n # Number of splits defined as a part of KFold/StratifiedKFold\n n_splits = kf.get_n_splits()\n logger.info(f'fold {fold} of {n_splits}')\n X_in, X_oof = df_train_X.iloc[in_index].values, df_train_X.iloc[oof_index].values\n y_in, y_oof = df_train_Y.iloc[in_index].values, df_train_Y.iloc[oof_index].values\n\n model = model\n model.fit(X_in, y_in)\n\n yoof[oof_index] = model.predict_proba(X_oof)[:, 1]\n if is_test is False:\n yhat += model.predict_proba(df_test_X.values)[:, 1]\n\n cv_oof_score = roc_auc_score(y_oof, yoof[oof_index])\n logger.info(f'CV OOF Score for fold {fold} is {cv_oof_score}')\n cv_scores.append(cv_oof_score)\n\n del oof_index, X_oof, y_oof\n gc.collect()\n\n util.update_tracking(run_id, \"metric_fold_{}\".format(fold), cv_oof_score, is_integer=False)\n\n yhat /= n_splits\n\n oof_score = round(roc_auc_score(df_train_Y, yoof), 5)\n avg_cv_scores = round(sum(cv_scores)/len(cv_scores), 5)\n std_cv_scores = round(np.array(cv_scores).std(), 5)\n\n logger.info(f'Combined OOF score : {oof_score}')\n logger.info(f'Average of {fold} folds OOF score {avg_cv_scores}')\n logger.info(f'std of {fold} folds OOF score {std_cv_scores}')\n\n result_dict['yoof'] = yoof\n result_dict['prediction'] = yhat\n result_dict['oof_score'] = oof_score\n result_dict['cv_scores'] = cv_scores\n result_dict['avg_cv_scores'] = avg_cv_scores\n result_dict['std_cv_scores'] = std_cv_scores\n\n util.update_tracking(run_id, \"oof_score\", oof_score, is_integer=False)\n util.update_tracking(run_id, \"cv_avg_score\", avg_cv_scores, is_integer=False)\n util.update_tracking(run_id, \"cv_std_score\", std_cv_scores, is_integer=False)\n\n del yoof, yhat\n gc.collect()\n\n logger.info('Training/Prediction completed!')\n return result_dict","def _cluster_hitprobability(self, x, y):\n hm_count = np.zeros_like(y).astype(float)\n hm = np.zeros_like(y).astype(float)\n #skf = StratifiedShuffleSplit(n_splits=self.n_iter, test_size=self.shuffle_test_split, random_state=self.random_state)\n\n ind = self._cluster(x, 35)\n\n for cluster_id in np.unique(ind):\n test = np.argwhere(ind == cluster_id)[:, 0]\n train = np.argwhere(ind != cluster_id)[:, 0]\n #print test\n self.basemodel.fit(x[train, :], y[train], hyperparams_optim=False)\n hm_count[test] += 1.\n hm[test] += (self.basemodel.predict(x[test, :]) == y[test]).astype(float)\n\n proba = hm / hm_count\n if self.verbose:\n # print('H/M count:')\n # print(hm_count)\n print('Proba:')\n print(proba)\n self.basemodel.fit(x, y, hyperparams_optim=False)\n return proba","def mean_payoffs(dist,benefit_function,b,c,*params):\n dist['A_pay'] = (b*benefit_function(dist.j+1,dist.k+1,*params)-c)*dist.A\n dist['B_pay'] = (b*benefit_function(dist.j,dist.k+1,*params))*dist.B\n return dist.groupby('n')[['A_pay','B_pay']].sum()","def get_clusters(self,points):\n self.points = points\n self.__dabest = [self.__cmeans(points,i) for i in range(self.__start,self.__end)]\n ##self.hull = \n return self.__dabest","def classfy(data, clu, k):\n clulist = cal_dis(data, clu)\n clusterRes = grouping(data, clulist)\n clunew = new_Cen_Cal(data, clusterRes, k)\n err = clunew - clu\n\n return err, clunew, k, clusterRes","def sk_test_suit(X, y):\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)\r\n\r\n classifierDict = {\"Random Forest\": RandomForestClassifier(),\r\n \"Logistic Regression\": LogisticRegression(),\r\n \"Linear Discriminant Analysis\": LinearDiscriminantAnalysis(),\r\n \"Gaussian Naive Bayes\": GaussianNB(),\r\n \"Neural Network\": MLPClassifier()}\r\n\r\n\r\n try:\r\n for k, v in classifierDict.items():\r\n clf = v.fit(X_train, y_train)\r\n training_score = cross_val_score(clf, X_train, y_train)\r\n testing_score = cross_val_score(clf, X_test, y_test)\r\n print(k)\r\n print('Sk-learn {0} training accuracy: {1}'.format(k, training_score.mean()))\r\n print('Sk-learn {0} testing accuracy: {1}'.format(k, testing_score.mean()))\r\n except:\r\n pass\r\n # winsound.PlaySound('sound.wav', winsound.SND_FILENAME)\r","def _class_means_and_neighbor_means(X, y, k1, k2):\n means = []\n neighbor_means = []\n \n classes = np.unique(y)\n samples = np.size(y)\n \n for group in classes:\n Xg = X[y == group, :]\n Xg_count = Xg.shape[0]\n Xg_mean = Xg.mean(0)\n Xn = X[y != group, :]\n Xg_similarity = _similarity_function(Xg_mean, Xg)\n Xg_similarity_min = min(Xg_similarity)\n Xn_similarity = _similarity_function(Xg_mean, Xn)\n Xn_neighbor_count = len(Xn_similarity[Xn_similarity > Xg_similarity_min])\n Xn_neighbor_count = int(max(k1 * Xg_count, k2 * Xn_neighbor_count))\n Xn_neighbor_count = min(Xn_neighbor_count, samples - Xg_count)\n Xn_label = np.argsort(Xn_similarity)\n Xn_label = Xn_label[::-1]\n Xg_neighbor = np.array([Xn[Xn_label[i]] for i in range(Xn_neighbor_count)])\n Xg_neighbor_mean = Xg_neighbor.mean(0)\n \n means.append(Xg_mean)\n neighbor_means.append(Xg_neighbor_mean)\n \n return np.array(means), np.array(neighbor_means)","def getKSplitsStratified(df, n_splits, classColumn, seed = None):\n df_class1 = df[df[classColumn] == True]\n df_class2 = df[df[classColumn] == False]\n\n k_folds_class1 = getKSplits(df_class1, n_splits, seed)\n k_folds_class2 = getKSplits(df_class2, n_splits, seed)\n\n # combine\n k_folds_combined = []\n for i in range(n_splits):\n combined_fold = k_folds_class1[i].append(k_folds_class2[i])\n combined_fold_shuffled = combined_fold.sample(len(combined_fold), random_state = seed)\n k_folds_combined.append(combined_fold_shuffled)\n\n return k_folds_combined","def score(self):\n\n\t\tsplits = 10\n\t\tscore = 0\n\n\t\tkf = KFold(n_splits=splits, shuffle=True)\n\t\tkf.get_n_splits(self.data)\n\n\t\tfor train_ind, test_ind in kf.split(self.data):\n\n\t\t\ttrain = [self.data[ind] for ind in train_ind]\n\t\t\ttest = [self.data[ind] for ind in test_ind]\n\n\t\t\tself.model = self._fit(train)\n\t\t\ttemp_score = self.score_one(test)\n\t\t\tscore += temp_score\n\n\t\treturn score/float(splits)","def score(self):\n\n\t\tsplits = 10\n\t\tscore = 0\n\n\t\tkf = KFold(n_splits=splits, shuffle=True)\n\t\tkf.get_n_splits(self.data)\n\n\t\tfor train_ind, test_ind in kf.split(self.data):\n\n\t\t\ttrain = [self.data[ind] for ind in train_ind]\n\t\t\ttest = [self.data[ind] for ind in test_ind]\n\n\t\t\tself.model = self._fit(train)\n\t\t\ttemp_score = self.score_one(test)\n\t\t\tscore += temp_score\n\n\t\treturn score/float(splits)","def OTU_table_ML(OTU_table,metadata,obj_col):\n for ele in OTU_table.index:\n #print(ele)\n X.append(df.loc[ele])\n Y.append(metadata[obj_col][ele])\n precisions = []\n for train_time in range(100): \n X,Y = shuffle(X,Y)\n sample_num = len(X)\n sep_num = int(0.8*sample_num)\n train_set = [X[:sep_num],Y[:sep_num]]\n test_set = [X[sep_num:],Y[sep_num:]]\n clf = svm.SVC(gamma='scale')\n clf.fit(train_set[0], train_set[1]) \n predict_result = clf.predict(test_set[0])\n count = 0\n for i in range(len(predict_result)):\n if predict_result[i] == test_set[1][i]:\n count += 1\n else:\n pass\n precisions.append(1.0*count/len(predict_result))\n print(np.mean(precisions))","def mean_square_error(self, test_set, predicted_values):\r\n\r\n running_sum = 0\r\n for i in range(len(test_set)):\r\n running_sum += (test_set[i].classification - predicted_values[i])**2\r\n running_sum = running_sum / len(test_set)\r\n return running_sum","def purity(clusters, classes):\n\n d = defaultdict(list)\n\n # Get a list of class numbers of all examples in a cluster.\n for k, v in zip(clusters, classes):\n d[k].append(v)\n\n mayority = 0\n\n # Count the mayority class number and add it up over all clusters.\n for k in d:\n mayority += Counter(d[k]).most_common(1)[0][1]\n\n return float(mayority) / len(clusters)","def Client_K_Means_Orch(log,\n\t\t\t\t train_data,\n\t\t\t\t orig_data,\n\t\t\t\t cluster_range,\n\t\t\t\t silhouette_analysis = False,\n\t\t\t\t silhouette_cluster_range = range(0,0),\n\t\t\t\t train_col_names = None, \n\t\t\t\t x_feature_index = 0,\n\t\t\t\t y_feature_index = 1,\n\t\t\t\t viz = False,\n\t\t\t\t show = False,\n\t\t\t\t viz_name = \"\",\n\t\t\t\t test_name = \"\"):\n\n\n\t\n\tprint(\"\\nData\\n\")\n\t#Strip and replace off any spaces\n\ttest_name = test_name.strip().replace(\" \",\"_\")\n\n\t#Initialize customer segmentation test\n\ttest = CustomerSegmentation(Method = KMeans(), \n\t\t\t\t\t\t\t\tdata = train_data,\n\t\t\t\t\t\t\t\torig_data = orig_data,\n\t\t\t\t\t\t\t\tlog = log, \n\t\t\t\t\t\t\t\ttest_name = test_name)\n\n\t# Set train data and class labels\n\ttest.Preprocess.set_train_data(train_data)\n\n\tprint(\"\\nPCA\\n\")\n\t# Conduct PCA, fit and transformation\n\ttest.Preprocess.PCA_fit(viz = viz, viz_name = viz_name, show = show)\n\ttest.Preprocess.PCA_transform()\n\n\tprint(\"\\nElbow Chart Analysis\\n\")\n\t#Conduct elbow chart analysis\n\ttest.SegMethod.elbow_chart_test(cluster_range, viz = viz,show = show, viz_name = viz_name, profile = True)\n\n\tif silhouette_analysis:\n\t\tprint(\"\\nSilhouette Analysis\\n\")\n\t\t#Conduct Silhouette analysis\n\t\ttest.Preprocess.silhouette_analysis(silhouette_cluster_range, viz = viz, viz_name = viz_name, show = show)\n\n\tprint(\"\\nLog Saving\\n\")\n\t#Save Preprocess and Method logs\n\ttest.Preprocess.PreprocessLog.savePreprocessLog()\n\ttest.SegMethod.MethodLog.saveMethodLog()\n\n\t#Add final masterlog record\n\tlog.addMasterLogRecord(test)","def mean_impute(self):\n X_train, X_val, y_train, y_val = train_test_split(self.X_dev, self.y_dev, test_size=0.25, random_state=10)\n imputer = SimpleImputer(strategy='mean')\n imputer.fit(X_train)\n X_train_mean_imputed = pd.DataFrame(imputer.transform(X_train), columns=X_train.columns)\n X_val_mean_imputed = pd.DataFrame(imputer.transform(X_val), columns=X_val.columns)\n rf = RandomForestClassifier\n rf_mean_imputed, best_hyperparams_mean_imputed = holdout_grid_search(rf, X_train_mean_imputed, y_train,\n X_val_mean_imputed, y_val,\n hyperparams, {'random_state': 10})\n\n y_train_best = rf_mean_imputed.predict_proba(X_train_mean_imputed)[:, 1]\n train_c_index = cindex(y_train, y_train_best)\n \n y_val_best = rf_mean_imputed.predict_proba(X_val_mean_imputed)[:, 1]\n valid_c_index = cindex(y_val, y_val_best)\n \n y_test_imp = rf_mean_imputed.predict_proba(self.X_test)[:, 1]\n test_c_index = cindex(self.y_test, y_test_imp)\n \n return train_c_index, valid_c_index, test_c_index","def FE_kmeans_resampler(x_train, y_train, target, smote=\"\", verbose=0):\r\n x_train_c = copy.deepcopy(x_train)\r\n x_train_c[target] = y_train.values\r\n\r\n # Regression problem turned into Classification problem\r\n n_clusters = max(3, int(np.log10(len(y_train))) + 1)\r\n # Use KMeans to find natural clusters in your data\r\n km_model = KMeans(n_clusters=n_clusters,\r\n n_init=5,\r\n random_state=99)\r\n #### remember you must predict using only predictor variables!\r\n y_train_c = km_model.fit_predict(x_train)\r\n\r\n if verbose >= 1:\r\n print('Number of clusters created = %d' %n_clusters)\r\n\r\n #### Generate the over-sampled data\r\n #### ADASYN / SMOTE oversampling #####\r\n if isinstance(smote, str):\r\n x_train_ext, _ = oversample_SMOTE(x_train_c, y_train_c)\r\n else:\r\n x_train_ext, _ = smote.fit_resample(x_train_c, y_train_c)\r\n y_train_ext = x_train_ext[target].values\r\n x_train_ext.drop(target, axis=1, inplace=True)\r\n return (x_train_ext, y_train_ext)","def compute_average_separability_score(self) -> Dict:\n avg_sep_score = {}\n for class_pair_key, class_pair_val in self.separability_scores.items():\n avg_sep_score[class_pair_key] = np.mean(np.array([val for _, val in class_pair_val.items()]))\n avg_sep_score['agg_with_risk'] = sum(\n np.array([val for _, val in avg_sep_score.items()]) *\n RISK\n ) \n avg_sep_score['agg'] = sum([val for key, val in avg_sep_score.items() if type(key)==int]) \n return avg_sep_score","def get_output(data, capital=100000, leverage=1, commission=0, slippage=0):\n total_capital = capital * leverage\n df = data\n df['cnt'] = df.groupby('timestamp')['symbol'].transform(\n lambda x: len(x))\n df['qty'] = (total_capital/df['cnt']/df['price']).round()\n df['profit'] = df.eval('(sell-buy)*qty')\n df['commission'] = df.eval('(sell+buy)*qty') * commission * 0.01\n df['slippage'] = df.eval('(sell+buy)*qty') * slippage * 0.01\n df['net_profit'] = df.eval('profit - commission - slippage')\n return df"],"string":"[\n \"def get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\\n # if condition returns False, AssertionError is raised:\\n assert len(df_profit_per_cluster_train) >= 3, \\\"Algorithm, returned less than 3 clusters.\\\"\\n\\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\\n group_size = int(len(df_profit_per_cluster) / 3)\\n\\n buy_clusters_mean_profit = df_profit_per_cluster.iloc[:group_size]['profit'].mean()\\n sell_clusters_mean_profit = df_profit_per_cluster.iloc[-group_size:]['profit'].mean()\\n\\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\\n\\n return buy_clusters_mean_profit, buy_clusters_list, sell_clusters_mean_profit, sell_clusters_list\",\n \"def get_profit_per_cluster(df: pd.core.frame.DataFrame) -> pd.core.frame.DataFrame:\\n return pd.DataFrame(df.groupby(by='cluster')['profit'].mean(), columns=['profit']).reset_index()\",\n \"def cluster_means(self):\\n if self.evaluate_by is not None:\\n return(self.merged_data.groupby(\\n 'labels').mean().sort_values(self.evaluate_by).transpose())\\n else:\\n return(self.merged_data.groupby('labels').mean().transpose())\",\n \"def score(self, df_X, ser_y):\\n df_predict = self.predict(df_X)\\n accuracies = []\\n for instance in ser_y.index:\\n # Accuracy is the probability of selecting the correct class\\n try:\\n accuracy = df_predict.loc[instance, ser_y.loc[instance]]\\n except:\\n import pdb; pdb.set_trace()\\n accuracies.append(accuracy)\\n return np.mean(accuracies)\",\n \"def calculate_kmeans(df, clusters=10):\\r\\n kmeans = KMeans(n_clusters=clusters)\\r\\n labels = kmeans.fit_predict(df)\\r\\n\\r\\n return kmeans, labels\",\n \"def calc_skill_cluster_sets(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, blocks_one_clusnum, skill_str, seas):\\r\\n prec_arr, recall_arr, F1_arr, clus_num_arr = [], [], [], []\\r\\n\\r\\n prec_vals = sorted(np.unique(blocks_one_clusnum[skill_str].values), reverse = True)\\r\\n #loop through first element separately so that subsequent values can be appended\\r\\n node_cluster_set_test_str, ds_arr = [], []\\r\\n for prec in prec_vals:\\r\\n node_cluster_set_test_str_app = blocks_one_clusnum['set'][np.where(blocks_one_clusnum[skill_str]==prec)[0]].values\\r\\n for clus in node_cluster_set_test_str_app:\\r\\n #add cluster to cluster set\\r\\n node_cluster_set_test_str = np.append(node_cluster_set_test_str, clus)\\r\\n node_cluster_set_test_str = np.unique(node_cluster_set_test_str)\\r\\n node_num = len(node_cluster_set_test_str) # number of nodes in cluster set\\r\\n clus_num_arr.append(node_num)\\r\\n #calculate skill score of cluster set by calculating the number of days blocked from the GTD and selecting the season\\r\\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\\r\\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \\\"blocking\\\", dims={\\\"time\\\": GTD['time']})\\r\\n blocked_days_clus_xr['time'] = GTD['time']\\r\\n blocked_days_clus_sel = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\\r\\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_sel)\\r\\n prec_arr.append(prec)\\r\\n recall_arr.append(recall)\\r\\n F1_arr.append(F1)\\r\\n\\r\\n return clus_num_arr, prec_arr, recall_arr, F1_arr\",\n \"def evaluation(X_selected, X_test, n_clusters, y):\\n k_means = KMeans(n_clusters=n_clusters, init='k-means++', n_init=10, max_iter=300,\\n tol=0.0001, precompute_distances=True, verbose=0,\\n random_state=None, copy_x=True, n_jobs=1)\\n\\n k_means.fit(X_selected)\\n y_predict = k_means.predict(X_test)\\n\\n # calculate NMI\\n nmi = normalized_mutual_info_score(y, y_predict, average_method='arithmetic')\\n\\n sil = silhouette_score(X_test, y_predict, metric=\\\"euclidean\\\")\\n db_score = davies_bouldin_score(X_test, y_predict)\\n ch_score = calinski_harabasz_score(X_test, y_predict)\\n purity = calcolaPurity(y, y_predict)\\n\\n return nmi, sil, db_score, ch_score, purity\",\n \"def classify():\\n yes_dataset = df[df[\\\"_class\\\"] == 1] # 470588\\n no_dataset = df[df[\\\"_class\\\"] == 0] # 1971\\n\\n parameter_analysis = list()\\n for criterion in np.arange(0.05, 0.91, 0.05):\\n print(\\\"doing experiment at criterion = %s ...\\\" % criterion)\\n rate_list = list()\\n for i in range(10):\\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\\n yes_index = yes_dataset.index.tolist()\\n random.shuffle(yes_index)\\n no_index = no_dataset.index.tolist()\\n random.shuffle(no_index)\\n \\n # concatenate 90%yes + 90%no, 10%yes + 10%no\\n train = pd.concat([\\n yes_dataset.loc[yes_index[:1774], :],\\n no_dataset.loc[no_index[:423530], :]\\n ])\\n test = pd.concat([\\n yes_dataset.loc[yes_index[1774:], :],\\n no_dataset.loc[no_index[423530:], :]\\n ]) \\n \\n # split data and label\\n train_data, train_label = (train[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n train[\\\"_class\\\"])\\n test_data, test_label = (test[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n test[\\\"_class\\\"])\\n \\n # apply classifier\\n clf = GaussianNB()\\n clf.fit(train_data, train_label)\\n probability = clf.predict_proba(test_data).T[1]\\n \\n result = pd.DataFrame()\\n result[\\\"_class\\\"] = test_label\\n result[\\\"_predict\\\"] = probability >= criterion\\n \\n result_yes = result[result[\\\"_class\\\"] == 1]\\n yes_yes_rate = sum(result_yes[\\\"_class\\\"] == result_yes[\\\"_predict\\\"])/len(result_yes[\\\"_predict\\\"])\\n \\n result_no = result[result[\\\"_class\\\"] == 0]\\n no_no_rate = sum(result_no[\\\"_class\\\"] == result_no[\\\"_predict\\\"])/len(result_no[\\\"_predict\\\"])\\n \\n rate_list.append((yes_yes_rate, no_no_rate))\\n\\n rate_list = pd.DataFrame(rate_list)\\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\\n \\n # save data to excel spreadsheet\\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\\\"criterion\\\", \\\"yes_yes_rate\\\", \\\"no_no_rate\\\"])\\n writer = pd.ExcelWriter(\\\"parameter_analysis.xlsx\\\")\\n parameter_analysis.to_excel(writer, \\\"parameter_analysis\\\", index=False)\\n writer.save()\",\n \"def calc_skill_clusters(blocked_days, GTD, GTD_seas, persis_thresh, SOM_nodes, SOM_clusters_block, seas):\\r\\n ds_arr_ones = []\\r\\n for clus in SOM_clusters_block:\\r\\n node_cluster_set_test = [clus]\\r\\n node_cluster_set_test_str = [str(clus).replace(',', '') for clus in node_cluster_set_test]\\r\\n #calculate the blocked days which the new cluster determines\\r\\n blocked_days_clus = calc_blocked_days_clus(blocked_days, persis_thresh, SOM_nodes, node_cluster_set_test_str)\\r\\n #define as DataArray and select JJA to remove the extended days included for classifying blocks\\r\\n blocked_days_clus_xr = xr.DataArray(blocked_days_clus, name = \\\"blocking\\\", dims={\\\"time\\\": GTD['time']})\\r\\n blocked_days_clus_xr['time'] = GTD['time']\\r\\n blocked_days_clus_seas = blocked_days_clus_xr.sel(time=np.isin(blocked_days_clus_xr['time.season'], seas))\\r\\n prec, recall, F1 = calc_pr_rc_F1(GTD_seas, blocked_days_clus_seas)\\r\\n #calculate precision, recall and F1\\r\\n if len(str(node_cluster_set_test)) == 1:\\r\\n comb_str = f\\\"{node_cluster_set_test[0]}\\\".replace(\\\"'\\\", \\\"\\\")\\r\\n else:\\r\\n comb_str = f\\\"{str(node_cluster_set_test)[1:-1]}\\\".replace(\\\"'\\\", \\\"\\\") \\r\\n ds=xr.Dataset({'precision': prec, 'recall': recall, 'F1': F1, 'clus_num': int(len(node_cluster_set_test)), 'set': str(comb_str)})\\r\\n ds_arr_ones.append(ds)\\r\\n blocks_one_clusnum = xr.concat(ds_arr_ones, dim = \\\"set\\\")\\r\\n return blocks_one_clusnum\",\n \"def wca_mean(X, k, df):\\n\\t\\n\\n\\t# Intializing the clusters\\t\\n\\tC = dict()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = pd.DataFrame()\\n\\n\\t# Calculating the mean vector\\n\\tmean_vector = X.mean()\\n\\n\\t# Choosing the seed points based on the minimum distance from the mean vector\\n\\tX['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mean_vector)), axis=1)\\n\\tdist_means = X.sort_values(by='dist_mean')\\n\\t\\n\\t# Dropping the the datapoints which have already been assigned as seed\\n\\tidx_to_drop = dist_means.index[:k]\\n\\tdist_means.reset_index(drop=True,inplace=True)\\n\\tX.drop('dist_mean',axis=1,inplace=True)\\n\\tX.drop(idx_to_drop, inplace=True)\\n\\n\\t# Assigning seed points to the clusters\\n\\tmu = list()\\n\\tfor cluster in range(k):\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[cluster].drop('dist_mean'))\\n\\t mu.append(C[cluster].mean())\\n\\t\\n\\t# Running the algorithm\\t\\n\\t\\n\\t# Initializing the p-value list which would be used for plotting\\n\\tpval = dict()\\n\\n\\tfor cluster in range(k):\\n\\t pval[cluster] = dict()\\n\\t for i in C[0].columns:\\n\\t pval[cluster][i] = list()\\n\\n\\t# Algorithm\\n\\tfor i in tqdm(range(int(len(X)/k)), desc='Iterations: '):\\n\\t for cluster in range(k):\\n\\n\\t # Calculating the distances from the mean vector of eaimportch cluster (in Descending order)\\n\\t X['dist_mean'] = X.apply(lambda x: np.linalg.norm(np.asarray(x)- np.asarray(mu[cluster])), axis=1)\\n\\t dist_means = X.sort_values(by='dist_mean', ascending=False)\\n\\t idx_to_drop = dist_means.index[0]\\n\\t dist_means.reset_index(drop=True,inplace=True)\\n\\t X.drop('dist_mean',axis=1,inplace=True)\\n\\n\\t # Assigning the top value to the cluster\\n\\t C[cluster] = C[cluster].append(dist_means.iloc[0].drop('dist_mean'))\\n\\t C[cluster] = C[cluster].reset_index(drop=True)\\n\\t \\n\\t # Updating means of each cluster\\n\\t mu[cluster] = C[cluster].mean()\\n\\n\\t # Remove datapoint from X?\\n\\t X.drop(idx_to_drop,inplace=True)\\n\\t \\n\\t for i in C[0].columns:\\n\\t pval[cluster][i].append(sc.ks_2samp(C[cluster][i],df.drop('target',axis=1)[i])[1])\\n\\n\\treturn(C,pval)\",\n \"def score(self, df_X, ser_y):\\n df_predict = self.predict(df_X)\\n missing_columns = set(ser_y).difference(\\n df_predict.columns)\\n for column in missing_columns:\\n df_predict[column] = np.repeat(0,\\n len(df_predict))\\n accuracies = []\\n for instance in ser_y.index:\\n # Accuracy is the probability of selecting the correct class\\n try:\\n accuracy = df_predict.loc[instance, ser_y.loc[instance]]\\n except:\\n import pdb; pdb.set_trace()\\n accuracies.append(accuracy)\\n return np.mean(accuracies)\",\n \"def target_mean(train,test,train_index=None,holdout_index=None,col=[],\\n target='click',num_folds=5,seed=23):\\n feature_name='new_features'\\n if holdout_index is None:\\n train_cv = train.copy()\\n holdout = None\\n else:\\n if train_index is None:\\n warnings.warn('train index is None. Now need to calculate. If you parse the value, it will be more efficient ')\\n train_index = list(set(train.index) - set(holdout_index))\\n train_cv = train.loc[train_index].copy()\\n holdout = train.loc[holdout_index].copy()\\n holdout_list = []\\n sf = StratifiedKFold(n_splits= num_folds, shuffle=True, random_state=seed)\\n\\n train_return = train[col].copy()\\n test_return = test[col].copy()\\n train_return[feature_name] = np.nan\\n test_return[feature_name] = np.nan\\n test_list = []\\n \\n val_index_monitor = []\\n for t_index,v_index in sf.split(train_cv,train_cv[target]):\\n history = train_cv.iloc[t_index].copy()\\n mapping = history.groupby(col)[target].mean().reset_index().rename({target:feature_name},axis=1)\\n val = train_cv.iloc[v_index].copy()\\n val_index_monitor.extend(list(val.index))\\n train_return.loc[val.index,feature_name] = val[col].merge(mapping,how='left',left_on=col,right_on=col).drop(col,axis=1)[feature_name].values\\n if holdout is not None:\\n holdout_list.append(holdout[col].merge(mapping,how='left',left_on=col,right_on=col).drop(col,axis=1)[feature_name].values)\\n test_list.append(test[col].merge(mapping,how='left',left_on=col,right_on=col).drop(col,axis=1)[feature_name].values)\\n if holdout is not None:\\n train_return.loc[holdout.index,feature_name] = np.mean(np.array(holdout_list),axis=0)\\n test_return[feature_name] = np.mean(np.array(test_list),axis=0)\\n val_index_monitor.extend(list(holdout.index))\\n return train_return[feature_name].values,test_return[feature_name].values\",\n \"def create_strategy(filename: str, columns_list: List[str], som_width: int, som_height: int, n_iter: int, sigma=0.3,\\n learning_rate=0.01) -> tuple:\\n # get prepared data\\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\\n\\n # train som\\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\\n sigma=sigma, learning_rate=learning_rate)\\n\\n # get profit per cluster in train and test datasets\\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\\n df_profit_per_cluster_test = get_profit_per_cluster(final_df_test)\\n\\n # get mean profit for sell and buy class in training and testing datasets\\n try:\\n buy_clusters_mean_profit_train, buy_clusters_list, sell_clusters_mean_profit_train, sell_clusters_list = \\\\\\n get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train)\\n\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = \\\\\\n get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test, buy_clusters_list, sell_clusters_list)\\n # if the data was assigned to less than to 3 clusters\\n except:\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\\\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = None, None, None, None\\n\\n return len(df_profit_per_cluster_train), len(df_profit_per_cluster_test), \\\\\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\\\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test\",\n \"def purity_score(label, pred):\\n \\n df = pd.concat([label, pd.DataFrame(pred)], axis=1)\\n df.set_axis(['label', 'pred'], axis=1, inplace=True)\\n \\n s = 0\\n\\n for x, cluster in df.groupby('pred'):\\n s += cluster['label'].value_counts().iloc[0] # adding the most occuring class in a cluster\\n\\n return s / label.shape[0]\",\n \"def grouping(data_clust):\\n data_grouped = data_clust.groupby('Clusters').mean()\\n return data_grouped\",\n \"def test_splits(ratings_df, predict_method, k, test_size=250, splits=3):\\n mse_ls = []\\n for _ in range(splits):\\n test_ratings_df = ratings_df.sample(n=test_size)\\n train_ratings_df = ratings_df.drop(test_ratings_df.index)\\n model_params = matrix_cf.get_model_params(train_ratings_df)\\n _, mse = predict_method(test_ratings_df, k, model_params)\\n mse_ls.append(mse)\\n return np.array(mse_ls).mean()\",\n \"def byMeans(dataset, number_of_clusters, class_header=\\\"Class\\\", verbosity=0, return_clusters=False):\\n if verbosity >= 2: # optionally print dataset shape and info\\n print(dataset.shape)\\n print(dataset)\\n\\n old_dataset = dataset.copy()\\n dataset = dataset.drop(columns=class_header) # remove non-float class column\\n\\n # Assign centroids to random values which fit into dataset space.\\n centroids = pandas.DataFrame(columns=dataset.columns,\\n data=numpy.random.uniform(dataset.min(), dataset.max(),\\n (number_of_clusters, dataset.shape[1])))\\n if verbosity >= 1: # optionally print centroids and random dataset\\n print(\\\"INITIAL CENTROIDS\\\")\\n print(centroids)\\n if verbosity >= 2:\\n print(\\\"DATAFRAME DATASET\\\")\\n print(dataset)\\n\\n for iterations in range(MAX_ITERATIONS): # Loop until MAX_ITERATIONS or settled\\n if verbosity >= 1: # optionally print iteration count\\n print(\\\"ITERATIONS\\\")\\n print(iterations)\\n\\n # calculate clustering of data\\n clusters = Cluster.calcClusters(dataset, centroids, number_of_clusters, verbosity=verbosity)\\n\\n old_centroids = centroids.copy() # copy centroid dataframe\\n\\n if verbosity >= 2: # optionally print cluster list\\n print(\\\"DATAFRAME ARRAY CLUSTERS\\\")\\n print(clusters)\\n\\n for cluster_index, cluster in enumerate(clusters): # Calculate new centroids\\n cluster_mean = cluster.mean()\\n if not cluster_mean.isnull().any(): # make sure we dont write null means to centroid list\\n centroids.loc[cluster_index] = cluster_mean\\n\\n if verbosity >= 1:\\n print(\\\"OLD CENTROIDS\\\")\\n print(old_centroids)\\n print(\\\"NEW CENTROIDS\\\")\\n print(centroids)\\n\\n if old_centroids is not None: # Calculate sum of centroid movements.\\n centroid_change = 0\\n for centroid_index, centroid in centroids.iterrows():\\n centroid_change += abs(Cluster.calcDistance(centroid, old_centroids.loc[centroid_index]))\\n\\n if verbosity >= 1:\\n print(\\\"CENTROID DIFF\\\")\\n print(centroid_change)\\n\\n if centroid_change < SETTLE_THRESHOLD: # break if centroid movement is below threshold.\\n break\\n\\n # Final Cluster re-calculation\\n clusters = Cluster.calcClusters(old_dataset, centroids, number_of_clusters,\\n verbosity=verbosity, class_header=class_header)\\n # Create new dataframe with class column of and row for each centroid\\n centroids_class = pandas.DataFrame(data=[\\\"NOCLASS\\\"] * centroids.shape[0], columns=[class_header])\\n if verbosity >= 2:\\n print(centroids_class)\\n print(centroids)\\n for cluster_index, cluster in enumerate(clusters): # For each cluster\\n if verbosity >= 2:\\n print(cluster_index)\\n print(cluster)\\n if cluster.size > 0: # If cluster is not empty set centroid class to most common class in cluster\\n centroids_class.iat[cluster_index, 0] = cluster.mode().loc[0][0]\\n if old_dataset.columns[0] == class_header: # check if class column should be first or last.\\n print(\\\"CLASS IS FIRST COL\\\")\\n centroids = pandas.concat([centroids_class, centroids], axis=1) # merge class to centroids as first column\\n else:\\n print(\\\"CLASS IS NOT FIRST COL\\\")\\n centroids = pandas.concat([centroids, centroids_class], axis=1) # merge class to centroids as last column\\n for centroid in centroids.iterrows(): # For each centroid\\n if centroid[1][class_header] is \\\"NOCLASS\\\": # Trim NOCLASS centroids (empty cluster)\\n centroids = centroids.drop(centroid[0])\\n centroids = centroids.reset_index(drop=True) # Reindex centroids\\n\\n if return_clusters is True: # optionally return cluster list\\n return centroids, clusters\\n pass\\n else:\\n return centroids # return centroids dataframe\",\n \"def _eval_clustering(self, gen_reviews, clusters, embedding_model, clustering):\\n result = []\\n preds = self.predict_gen(gen_reviews, embedding_model, clustering)\\n\\n acc = accuracy_score(np.array(clusters), np.array(preds))\\n conf = confusion_matrix(np.array(clusters), np.array(preds))\\n\\n return acc, conf\",\n \"def evaluateClusters( features, labels):\\r\\n\\r\\n\\treturn silhouette_score( features, labels)\",\n \"def get_perf(self) :\\n self.train()\\n\\n prediction = self.clf.predict(self.df_test.drop(columns = 'up')[:-1])\\n self.accuracy = accuracy_score(df_test['up'][length:].values, prediction)\\n tn, fp, fn, tp = confusion_matrix(df_test['up'][length:].values, prediction).ravel()\\n self.recall = tp/(tp+fn)\\n self.specificity = tn / (tn+fp)\\n\\n\\n self.df_true = self.df_true[self.length:]\\n\\n profit = 1\\n mini = 1\\n maxi = 1\\n self.df_true['close'] = self.df_true['close'].map(lambda x : np.exp(x))\\n for s in range(1,len(self.df_true)):\\n if prediction[x-1] == 1 :\\n result = ((self.df_true['close'].iloc[s] -self.df_true['close'].iloc[s-1]) / self.df_true['close'].iloc[s-1]) + 1\\n profit = profit * result\\n if result < mini :\\n mini = result\\n if maxi < result :\\n maxi = result\\n self.mini = mini\\n self.maxi = maxi\\n self.profit = profit\",\n \"def evalute_subset(X_train, X_test, y_train, y_test):\\r\\n clf = KNeighborsClassifier(n_neighbors=3)\\r\\n clf.fit(X_train, y_train) \\r\\n y_pred = clf.predict(X_test)\\r\\n return accuracy_score(y_test, y_pred)\",\n \"def clusterting_feature_importance (df, cluster_col):\\r\\n scores = pd.DataFrame()\\r\\n df0 = df.copy()\\r\\n df0 = df.select_dtypes(include=np.number)\\r\\n\\r\\n for i in df0[cluster_col].unique():\\r\\n df2 = df0[df0[cluster_col] == i]\\r\\n df2.drop(cluster_col,axis=1, inplace=True)\\r\\n #df2 = df.select_dtypes(include=np.number)\\r\\n scores[i] = df2.std() / (df2.max() - df2.min())\\r\\n scores['mean'] = scores.mean(axis = 1)\\r\\n\\r\\n scores = 1 - scores\\r\\n\\r\\n return scores\",\n \"def _compute_cluster_averages(self, key=\\\"_scvi_labels\\\"):\\n # find cell label column\\n label_col = self.adata.uns[\\\"_scvi\\\"][\\\"categorical_mappings\\\"][key][\\\"original_key\\\"]\\n\\n # find data slot\\n x_dict = self.adata.uns[\\\"_scvi\\\"][\\\"data_registry\\\"][\\\"X\\\"]\\n if x_dict[\\\"attr_name\\\"] == \\\"X\\\":\\n use_raw = False\\n else:\\n use_raw = True\\n if x_dict[\\\"attr_name\\\"] == \\\"layers\\\":\\n layer = x_dict[\\\"attr_key\\\"]\\n else:\\n layer = None\\n\\n # compute mean expression of each gene in each cluster/batch\\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\\n\\n return aver\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def cluster_by_partitioning(active_sites):\\n cls, sc = k_means(active_sites)\\n\\n return cls\",\n \"def predict(self, train_df: pd.DataFrame, test_df: pd.DataFrame) -> pd.DataFrame:\\n\\n # get feature list\\n target_columns, features = PropensityModel.get_feature_and_target_columns(train_df)\\n\\n # predict propensities\\n model_prediction_df_list = []\\n for pred_df in [train_df, test_df]:\\n x_test = pred_df[features]\\n y_test = pred_df[target_columns]\\n y_pred = self.model.predict_proba(x_test)\\n \\n # select second column (positive class) if there is only one target variable\\n if len(self.target_variables) == 1:\\n y_pred = y_pred[:,1]\\n \\n fold_predictions = pd.DataFrame(y_pred, columns=['prediction_'+x for x in self.target_variables])\\n fold_predictions['sf_account_id'] = pred_df.index\\n for column in target_columns:\\n fold_predictions[column.replace('prediction_','target_')] = y_test[column].tolist()\\n fold_predictions['train_or_test'] = pred_df.train_or_test.iloc[0]\\n model_prediction_df_list += [fold_predictions]\\n model_predictions = pd.concat(model_prediction_df_list, sort=False)\\n\\n return model_predictions\",\n \"def predict(self, test_data):\\n if self.centroids_.shape[0]==0:\\n raise ValueError(\\\"No centroids present. Run KMeans.fit first.\\\")\\n\\n print test_data.shape\\n part_of_cluster=np.zeros(test_data.shape[0])\\n for i in range(test_data.shape[0]):\\n dists=[]\\n for c in range(self.centroids_.shape[0]):\\n # compute distance between current train_data instance and each cluster\\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\\n \\n # assign point to cluster with minimal distance\\n part_of_cluster[i]=dists.index(min(dists))\\n\\n return part_of_cluster\",\n \"def cluster_means_scaled(self):\\n if self.evaluate_by is not None:\\n return(self.merged_scaled_data.groupby(\\n 'labels').mean().sort_values(self.evaluate_by).transpose())\\n else:\\n return(self.merged_scaled_data.groupby(\\n 'labels').mean().transpose())\",\n \"def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\\n learning_rate=0.01):\\n\\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\\n random_seed=0)\\n som.train(df_train, n_iter)\\n\\n # converting numpy arrays to dataframes\\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\\n\\n # creating column with cluster basing on model prediction\\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\\n\\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\\n # the script\\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\\n lsuffix='_org')\\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\\n lsuffix='_org')\\n\\n return final_df_train, final_df_test\",\n \"def profitCalculation(confusion_matrix):\\n numberofClasses = 4\\n profits = [[20, -7, -7, -7], [-7, 15, -7, -7], [-7, -7, 5, -7], [-3, -3, -3, -3]]\\n totalProfit = 0\\n for count in range(numberofClasses):\\n for counter in range(numberofClasses):\\n totalProfit += confusion_matrix[count][counter] * profits[count][counter]\\n\\n return totalProfit\",\n \"def create_cluster(df,validate, test, X, k, name):\\n \\n scaler = StandardScaler(copy=True).fit(df[X])\\n X_scaled = pd.DataFrame(scaler.transform(df[X]), columns=df[X].columns.values).set_index([df[X].index.values])\\n kmeans = KMeans(n_clusters = k, random_state = 42)\\n kmeans.fit(X_scaled)\\n kmeans.predict(X_scaled)\\n df[name] = kmeans.predict(X_scaled)\\n df[name] = 'cluster_' + df[name].astype(str)\\n \\n v_scaled = pd.DataFrame(scaler.transform(validate[X]), columns=validate[X].columns.values).set_index([validate[X].index.values])\\n validate[name] = kmeans.predict(v_scaled)\\n validate[name] = 'cluster_' + validate[name].astype(str)\\n \\n t_scaled = pd.DataFrame(scaler.transform(test[X]), columns=test[X].columns.values).set_index([test[X].index.values])\\n test[name] = kmeans.predict(t_scaled)\\n test[name] = 'cluster_' + test[name].astype(str)\\n \\n centroids = pd.DataFrame(scaler.inverse_transform(kmeans.cluster_centers_), columns=X_scaled.columns)\\n return df, X_scaled, scaler, kmeans, centroids\",\n \"def Demo_K_Means_Orch(log,\\n\\t\\t\\t\\t train_data,\\n\\t\\t\\t\\t class_label,\\n\\t\\t\\t\\t cluster_range,\\n\\t\\t\\t\\t silhouette_cluster_range,\\n\\t\\t\\t\\t train_col_names = None, \\n\\t\\t\\t\\t x_feature_index = 0,\\n\\t\\t\\t\\t y_feature_index = 1,\\n\\t\\t\\t\\t viz = False,\\n\\t\\t\\t\\t show = False,\\n\\t\\t\\t\\t viz_name = \\\"\\\",\\n\\t\\t\\t\\t test_name = \\\"\\\"):\\n\\n\\t\\t\\n\\t#Strip and replace off any spaces\\n\\ttest_name = test_name.strip().replace(\\\" \\\",\\\"_\\\")\\n\\n\\t#Initialize customer segmentation test\\n\\ttest = CustomerSegmentation(Method = KMeans(), \\n\\t\\t\\t\\t\\t\\t\\t\\tdata = train_data,\\n\\t\\t\\t\\t\\t\\t\\t\\tlog = log, \\n\\t\\t\\t\\t\\t\\t\\t\\ttest_name = test_name)\\n\\n\\n\\t# Set train data and class labels\\n\\ttest.Preprocess.set_train_data(train_data, \\n\\t\\t\\t\\t\\t\\t\\t\\t col_names = train_col_names)\\n\\ttest.Preprocess.set_class_label(class_label)\\n\\n\\t# Conduct PCA, fit and transformation\\n\\ttest.Preprocess.PCA_fit(viz = viz, viz_name = viz_name, show = show)\\n\\ttest.Preprocess.PCA_transform()\\n\\n\\n\\tif viz:\\n\\t\\t#Create cluster plot visualization if requested\\n\\t\\tcluster_plot = cluster_viz(test.train_data, test.class_label, x_feature_index = x_feature_index, y_feature_index = y_feature_index)\\n\\t\\t\\n\\t\\t#Show the plot at runtime if requested\\n\\t\\tif show:\\n\\t\\t\\tcluster_plot.show()\\n\\n\\t\\t#Save the image\\n\\t\\ttest.Log.saveImage(cluster_plot, \\\"cluster_plot\\\", test.viz_folder_name)\\n\\n\\t#Conduct elbow chart analysis\\n\\ttest.SegMethod.elbow_chart_test(cluster_range, viz = viz,show = show, viz_name = viz_name, profile = True)\\n\\n\\t#Conduct Silhouette analysis\\n\\t#test.Preprocess.silhouette_analysis(silhouette_cluster_range, viz = viz, viz_name = viz_name, show = show)\\n\\n\\t#Save Preprocess and Method logs\\n\\ttest.Preprocess.PreprocessLog.savePreprocessLog()\\n\\ttest.SegMethod.MethodLog.saveMethodLog()\\n\\n\\t#Add final masterlog record\\n\\tlog.addMasterLogRecord(test)\",\n \"def knn(trainingSetData, testSetData, k):\\n trainingSet = trainingSetData.drop([14], axis=1) # drop income\\n testSet = testSetData.drop([14], axis=1) # drop income\\n\\n distances = {}\\n # this will store the distances re-sorted in ascending/descending order\\n sort = {}\\n # income band results (>=50k or <50K)\\n incomePredictions = []\\n\\n # Calculating euclidean distance between each row of training data and test data instance\\n for testInstance in range(len(testSet)): # len(testSet)\\n \\n # Store current test Point:\\n testInstance = testSet.iloc[testInstance] \\n \\n distances = euclideanDistanceRow(testInstance, trainingSet)\\n\\n # sort the distances in order of smallest first:\\n sorted_d = sorted(distances.items(), key=lambda x: x[1], reverse=False)\\n\\n neighbors = []\\n\\n # Extracting top k neighbors\\n for x in range(k):\\n neighbors.append(sorted_d[x])\\n\\n\\n classVotes = {}\\n\\n # Calculating the most freq class in the neighbors\\n results = {\\\"lessThan50\\\": 0, \\\"moreThan50\\\": 0}\\n\\n # creating a dataframe to which we will add the income values:\\n\\n for x in range(len(neighbors)):\\n if (trainingSetData.iloc[neighbors[x][0]][14] == 0.0):\\n results[\\\"lessThan50\\\"] += 1\\n elif (trainingSetData.iloc[neighbors[x][0]][14] == 1.0):\\n results[\\\"moreThan50\\\"] += 1\\n\\n print('results',results)\\n\\n if (results[\\\"lessThan50\\\"] > results[\\\"moreThan50\\\"]):\\n incomePredictions.append(0.0)\\n elif (results[\\\"lessThan50\\\"] < results[\\\"moreThan50\\\"]):\\n incomePredictions.append(1.0)\\n\\n return incomePredictions\",\n \"def cluster_membership_occupancy(data):\\n \\n \\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n\\n if n_clusters == 0:\\n membership=[Cluster_Membership_Features()]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n areas=[Cluster_Area_Features()]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features()]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n \\n elif n_clusters ==1:\\n #obtain_total_cluster_areas_set_everything_else_to_default\\n membership=[Cluster_Membership_Features()]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n \\n try:\\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\\n except:\\n cluster_chull_areas=[0,0,0]\\n \\n Total_cluster_area=np.sum(cluster_chull_areas)\\n areas=[Cluster_Area_Features([Total_cluster_area,0,0,0,0,0,0,0,0])]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features()]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n \\n elif n_clusters >1:\\n #Summarizing the cluster membership distribution characteristics\\n cluster_size_nums=np.delete(np.array(data.groupby(['clusters']).size()),0)\\n (cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD)= distribution_statistics(cluster_size_nums)\\n\\n #For each cluster calculate the area by calculating the area of the convex hull of cluster members\\n # Note: concavehull implementation here might be a good addition as it will provide more imformative values. \\n\\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n try:\\n cluster_chull_areas=[ss.ConvexHull(np.column_stack([d[i]['X'].array,d[i]['Y'].array])).volume for i in d.keys()]\\n except:\\n cluster_chull_areas=[0,0,0,0,0]\\n \\n\\n (avg_cluster_area,min_cluster_area,max_cluster_area,\\n std_cluster_area,CV_cluster_area,CD_cluster_area,\\n IQR_cluster_area,Quartile_CD_cluster_area)= distribution_statistics(cluster_chull_areas)\\n Total_cluster_area=np.sum(cluster_chull_areas)\\n\\n #Calculate cluster density: number of nuclei/ convex area of cluster\\n cluster_density=np.divide(cluster_size_nums,cluster_chull_areas)\\n (avg_cluster_density,min_cluster_density,max_cluster_density,\\n std_cluster_density,CV_cluster_density,CD_cluster_density,\\n IQR_cluster_density,Quartile_CD_cluster_density)= distribution_statistics(cluster_density)\\n\\n #return dataframe of features\\n membership=[Cluster_Membership_Features([cluster_size_nums_avg,cluster_size_nums_min,cluster_size_nums_max,\\n cluster_size_nums_std,cluster_size_nums_cv,cluster_size_nums_cd,\\n cluster_size_nums_IQR,cluster_size_nums_Quartile_CD])]\\n membership = pd.DataFrame([o.__dict__ for o in membership])\\n areas=[Cluster_Area_Features([Total_cluster_area,\\n avg_cluster_area,min_cluster_area,max_cluster_area,\\n std_cluster_area,CV_cluster_area,CD_cluster_area,\\n IQR_cluster_area,Quartile_CD_cluster_area])]\\n areas = pd.DataFrame([o.__dict__ for o in areas])\\n density=[Cluster_Density_Features([avg_cluster_density,min_cluster_density,max_cluster_density,\\n std_cluster_density,CV_cluster_density,CD_cluster_density,\\n IQR_cluster_density,Quartile_CD_cluster_density])]\\n density = pd.DataFrame([o.__dict__ for o in density])\\n\\n all_features = pd.concat([membership.reset_index(drop=True), areas.reset_index(drop=True),\\n density], axis=1)\\n return all_features\",\n \"def compute_random_baseline(self, classes):\\n\\n # based on the class distribution of the data\\n sum_benefit = 0\\n\\n # c is the actual label\\n # if the label in y is unseen when training, skip it, don't include it in the error\\n for i, c in enumerate(self.y_chunk):\\n for j, cprime in enumerate(classes):\\n\\n # (1) compute the benefit matrix\\n benefit_c_cprime = 0\\n if cprime == self.fraud_label:\\n benefit_c_cprime = self.X_chunk[i][-1] - self.cost if c == self.fraud_label else -self.cost\\n\\n # (2) get the probability\\n probab_ic = 1 / len(classes)\\n sum_benefit += probab_ic * benefit_c_cprime\\n\\n return sum_benefit\",\n \"def compute_centers(points, labels):\\n df = pd.DataFrame(points)\\n return df.groupby(labels).mean().values\",\n \"def fit_predict(self, train_x: pd.DataFrame, train_y: pd.Series, test_x: pd.DataFrame, test_y: pd.Series) -> dict:\\n self.evaluator.fit(train_x, train_y, test_x, test_y)\\n predictions = self.evaluator.predict(test_x)\\n print(predictions)\\n metrics = metrics_stat(predictions, test_y)\\n return metrics\",\n \"def naive_bayes(df):\\n\\n X = df.loc[:, :'perfs'].reset_index(drop=True)\\n y = df.loc[:, 'Popularity'].reset_index(drop=True).values\\n\\n # convert categorical data to numerical\\n for i in X.columns:\\n if type(X[i][0]) == str:\\n X[i] = X[i].astype(\\\"category\\\").cat.codes\\n # normalize the data\\n normDF = preprocessing.normalize(X, axis=0)\\n\\n X_train, X_validate, Y_train, Y_validate = train_test_split(normDF, y, test_size=0.2, random_state=42)\\n\\n gnb = GaussianNB()\\n gnb.fit(X_train, Y_train)\\n y_pred = gnb.predict(X_validate)\\n\\n kfold = KFold(n_splits=10, random_state=42, shuffle=False)\\n cv_results = cross_val_score(gnb, X_train, Y_train, cv=kfold, scoring='accuracy')\\n msg = \\\"%f (%f)\\\" % (cv_results.mean(), cv_results.std())\\n\\n print(\\\"Confusion Matrix\\\")\\n print(confusion_matrix(Y_validate, y_pred))\\n print(classification_report(Y_validate, y_pred))\\n print(\\\"Accuracy score of training data: \\\", msg)\\n print('Accuracy score of testing data: ', accuracy_score(Y_validate, y_pred))\\n print(\\\"\\\")\\n\\n return\",\n \"def MK(df_train, df_test):\\n\\n # number of periods\\n T = df_train.shape[0]\\n\\n # matrix of individual forecasts\\n F = df_train.iloc[:, 1:].values\\n F_test = df_test.iloc[:, :].values\\n\\n # number of agents\\n K = df_test.shape[1]\\n\\n # true outcomes\\n y = df_train.iloc[:, 0].values\\n\\n # initialize agent wealth (sum equal to 1 -> results in convex combination)\\n w = np.full(K, 1/K, dtype=float)\\n\\n # initialize standard deviations\\n sigma = np.full(K, 1, dtype=float)\\n\\n # run market for all observations (training the market)\\n for i in range(T):\\n\\n # individual predictions in the current market\\n ind_pred = F[i, :]\\n\\n # size of bet at the true outcome (kernel evaluated at true outcome)\\n kernel_val = sps.norm.pdf(y[i], loc=ind_pred, scale=sigma)\\n\\n # scale by the size of budget of each agent\\n w_kernel_val = np.multiply(w, kernel_val)\\n\\n # reward agents\\n w = w_kernel_val / np.sum(w_kernel_val)\\n\\n # update sigma\\n abs_error = np.abs(y[i] - ind_pred)\\n sigma = ((i+1)*sigma + abs_error) / (i + 2)\\n\\n # using the trained market for out of sample forecasts\\n # obtain the aggregated market prediction in each test market\\n market_pred = np.dot(F_test, w)\\n\\n # output\\n df_pred = pd.DataFrame(\\n {\\\"Market for Kernels\\\": market_pred},\\n index=df_test.index\\n )\\n\\n return df_pred\",\n \"def prepareSplitClassifier(df, models, choice):\\n\\n\\n def classificationOutput(clf, X, Y):\\n \\\"\\\"\\\"\\n Fit the model and print the classification results\\n - confusion_matrix\\n - avg scores etc\\n \\\"\\\"\\\"\\n n_samples = 36\\n\\n print \\\"\\\\n\\\\nClassifier: \\\\n %s\\\" % (clf)\\n print \\\"#\\\" * 79\\n # classifier_gnb = naive_bayes.GaussianNB() # initiating the classifier\\n\\n clf.fit(X[:n_samples], Y[:n_samples]) # train on first n_samples and test on last 10\\n\\n expected = Y[n_samples:]\\n predicted = clf.predict(X[n_samples:])\\n print(\\\"Classification report:\\\\n%s\\\\n\\\" % (metrics.classification_report(expected, predicted)))\\n print(\\\"\\\\nConfusion matrix:\\\\n%s\\\" % metrics.confusion_matrix(expected, predicted))\\n\\n\\n\\n\\n def splitclassify(cDf):\\n \\\"\\\"\\\"\\n Given the dataframe combined with equal fair and unfair apps,\\n classify them\\n \\\"\\\"\\\"\\n cDf = cDf.reindex(np.random.permutation(cDf.index)) # shuffle the dataframe\\n featCols = set(cDf.columns)\\n featCols.remove('appLabel')\\n\\n features = cDf[list(featCols)].astype('float')\\n\\n ## Scale the features to a common range\\n min_max_scaler = preprocessing.MinMaxScaler()\\n X = min_max_scaler.fit_transform(features.values)\\n\\n Y = cDf['appLabel'].values\\n\\n\\n if choice == 'all':\\n for key in models:\\n classifier = models[key]\\n classificationOutput(classifier, X, Y)\\n else:\\n if choice in models:\\n classifier = models[choice]\\n classificationOutput(classifier, X, Y)\\n else:\\n print \\\"Incorrect Choice\\\"\\n\\n\\n\\n fairDf = df[df['appLabel'] == False]\\n unfairDf = df[df['appLabel'] == True]\\n\\n\\n # calculate total possible splits of fair data frame relatie to\\n # size of unfair dataframe\\n splits = len(fairDf) // len(unfairDf)\\n\\n for i in range(splits):\\n clDf = fairDf[i : i+len(unfairDf)].append(unfairDf)\\n\\n # print fairDf.values, unfairDf.values\\n print \\\"Classifying %d th split of fair apps with unfair app\\\" % (i)\\n print \\\"-\\\" * 79\\n splitclassify(clDf)\\n print \\\"\\\\n\\\\n\\\"\",\n \"def stdConfidenceTrades(predictions, buy_confidence=1.5, sell_confidence=1.1):\\n smooth_preds = pd.Series(predictions).rolling(5).mean()\\n buy_thresh = np.mean(smooth_preds) + buy_confidence * np.std(smooth_preds)\\n sell_thresh = np.mean(smooth_preds) - sell_confidence * np.std(smooth_preds)\\n buy_positions = np.where(predictions > buy_thresh)[0]\\n sell_positions = np.where(predictions < sell_thresh)[0]\\n \\n buys = buy_positions\\n sells = []\\n curSell = 0\\n for curBuy in buys:\\n arr = np.where(sell_positions > curBuy)[0]\\n if len(arr):\\n sells.append(sell_positions[arr[0]])\\n tradePairs = list(zip(buys, sells))\\n return tradePairs\",\n \"def make_doppelganger_vs_clusters(n_clusters_considered,X,X_occam,n_repeats):\\n res = []\\n for n_clusters in n_clusters_considered:\\n res.append([])\\n for _ in range(n_repeats):\\n X_restricted,restricted_idxs = get_n_random_clusters(X_occam,n_clusters)\\n print(X.val.shape)\\n print(X_restricted.val.shape)\\n evaluator_X = evaluators.EvaluatorWithFiltering(X,X_restricted,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs[restricted_idxs])\\n res[-1].append(evaluator_X.weighted_average) \\n return res\",\n \"def _avg_cluster_hitprobability(self, x, y, n_clusters=30):\\n\\n # Compute the individual Hit probability\\n proba = self._shufflesplit(x, y)\\n\\n # average the individual hit probability for each cluster\\n ind = self._cluster(x, x.shape[0]/2.)\\n\\n avg_proba = np.copy(proba)\\n\\n for cluster in np.unique(ind):\\n mask_ = ind == cluster\\n avg_proba[mask_] = avg_proba[mask_].mean()\\n\\n return avg_proba\",\n \"def cluster(players_df, columns):\\n\\toptimal_n=None\\n\\toptimal_clusters=None\\n\\toptimal_clusterer=None\\n\\toptimal_silhouette=-99\\n\\tfor n in range(2,9):\\n\\t\\tclusterer=KMeans(n_clusters=n)\\n\\t\\tcluster_labels=clusterer.fit_predict(players_df[columns])\\n\\t\\tavg_silhouette=silhouette_score(players_df[columns], cluster_labels)\\n\\t\\tprint('The avg silhouette score for {} clusters is {}'.format(n, avg_silhouette))\\n\\t\\tif avg_silhouette > optimal_silhouette:\\n\\t\\t\\toptimal_silhouette=avg_silhouette\\n\\t\\t\\toptimal_clusterer=clusterer\\n\\t\\t\\toptimal_clusters=cluster_labels\\n\\t\\t\\toptimal_n=n\\n\\tprint('Returning optimal clusters found with n={}'.format(optimal_n))\\n\\tclusters = {n: [] for n in range(optimal_n)}\\n\\tfor i, label in enumerate(optimal_clusters):\\n\\t\\tclusters[label].append(\\n\\t\\t\\tdict(\\n\\t\\t\\t\\tplayer_id=players_df.iloc[i]['PERSON_ID'],\\n\\t\\t\\t\\tfirst_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[-1],\\n\\t\\t\\t\\tlast_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[0],\\n\\t\\t\\t\\t)\\n\\t\\t\\t)\\n\\treturn clusters\",\n \"def k_means(n_clust, data_frame, true_labels):\\n k_means = KMeans(n_clusters=n_clust, random_state=123, n_init=30)\\n k_means.fit(data_frame)\\n c_labels = k_means.labels_\\n df = pd.DataFrame({'clust_label': c_labels, 'orig_label': true_labels.tolist()})\\n ct = pd.crosstab(df['clust_label'], df['orig_label'])\\n y_clust = k_means.predict(data_frame)\\n display(ct)\\n print('% 9s' % 'inertia homo compl v-meas ARI AMI silhouette')\\n print('%i %.3f %.3f %.3f %.3f %.3f %.3f'\\n % (k_means.inertia_,\\n homogeneity_score(true_labels, y_clust),\\n completeness_score(true_labels, y_clust),\\n v_measure_score(true_labels, y_clust),\\n adjusted_rand_score(true_labels, y_clust),\\n adjusted_mutual_info_score(true_labels, y_clust),\\n silhouette_score(data_frame, y_clust, metric='euclidean')))\",\n \"def __kmeans__(cls, cluster_size, pca_reduced, names: list):\\n import warnings\\n warnings.filterwarnings(\\\"ignore\\\")\\n clusterer = KMeans(n_clusters=cluster_size, random_state=10)\\n cluster_labels = clusterer.fit_predict(pca_reduced)\\n result = list()\\n result.append(ClusterProcessor.davies_bouldin(cluster_labels, pca_reduced, cluster_size, names))\\n result.append(ClusterProcessor.variance_ratio_criterion(cluster_labels, pca_reduced, cluster_size, names))\\n result.append(ClusterProcessor.silhouette_coefficient(cluster_labels, pca_reduced, cluster_size, names))\\n return result\",\n \"def add_sales_per_customer(historical, test):\\n # load historical - use this in data.py\\n # historical = pd.read_csv('./data/raw/train.csv')\\n\\n data = historical.groupby('Store').mean()\\n data.loc[:, 'sales-per-customer'] = data.loc[:, 'Sales'] / data.loc[:, 'Customers']\\n data = data.loc[:, ['Customers', 'sales-per-customer']]\\n data.columns = ['mean-customers', 'sales-per-customer']\\n data.fillna({\\n 'mean-customers': np.mean(data.loc[:, 'mean-customers']),\\n 'sales-per-customer': np.mean(data.loc[:, 'sales-per-customer'])\\n }, inplace=True)\\n test = test.merge(data, on='Store')\\n return test\",\n \"def mid_market_price(orders: pandas.DataFrame):\\n return numpy.mean((best_bid_price(orders), best_ask_price(orders)))\",\n \"def __call__(self, clfs, dataset):\\n if len(clfs)==0:\\n return [] # to don't even bother\\n\\n all_predictions = []\\n for clf in clfs:\\n # Lets check first if necessary conditional attribute is enabled\\n if not clf.ca.is_enabled(\\\"predictions\\\"):\\n raise ValueError, \\\"MeanPrediction needs learners (such \\\" \\\\\\n \\\" as %s) with state 'predictions' enabled\\\" % clf\\n all_predictions.append(clf.ca.predictions)\\n\\n # compute mean\\n all_predictions = np.asarray(all_predictions)\\n predictions = np.mean(all_predictions, axis=0)\\n\\n ca = self.ca\\n ca.estimates = all_predictions\\n ca.predictions = predictions\\n return predictions\",\n \"def get_ephys_super_data(model, fit_data, ephys_raw):\\n # cl_labels = np.arange(1, model.n_components + 1)\\n # cl_labels = ['cluster_{}'.format(cl_idx + 1)\\n # for cl_idx in range(model.n_components)]\\n\\n # get cluster prediction counts\\n y_pred = model.predict(fit_data)\\n # y_cnts = pd.Series(0, index=range(model.n_components))\\n y_cnts = np.zeros(model.n_components, dtype=int)\\n for cl_idx, cnt in Counter(y_pred).items():\\n y_cnts[cl_idx] = cnt\\n y_cnts = pd.Series(y_cnts)\\n\\n resp = model.predict_proba(fit_data)\\n\\n cluster_super_means = {}\\n super_data_means = {}\\n super_data_stds = {}\\n for k in ephys_raw.keys():\\n\\n super_data = ephys_raw[k]\\n super_data_means[k] = super_data.mean(axis=0)\\n super_data_stds[k] = super_data.std(axis=0)\\n\\n cluster_super_means[k] = get_super_means(resp=resp,\\n super_data=super_data,\\n stand=False)\\n\\n return cluster_super_means, super_data_means, super_data_stds, y_cnts\",\n \"def calculate_mean_average_precision(class_name='', current_neuron_index=current_neuron_index, acts=acts, verbose=verbose, minx=0.000000001):\\n #\\n current_neuron = acts.get_activations_for_neuron(current_neuron_index) # get the neuron's data\\n x_data = current_neuron.vector # get the activations without classes\\n # grab your list of points\\n local_list, selected_activations = grab_points_for_a_cluster(current_neuron_index,\\n min_selected_x_data=minx,\\n max_selected_x_data=max(x_data),\\n acts=acts,\\n x_data=x_data,\\n verbose=verbose)\\n Q = len(local_list) # total length of list\\n # get the test class (this is the correct class or 'A')\\n if class_name == '':\\n test_class = local_list[-1][0]\\n else:\\n test_class = class_name\\n # set up counters\\n MAP = 0 # mean average precision\\n count_of_test_class = 0\\n # loop backwards through the list, abs j is the position in a 1-indexed list\\n for i in range(Q+1):\\n j = -(i + 1) # 1 indexed\\n current_class = local_list[j][0] # current class\\n if j == -Q:\\n # if the whole of local_list is the same class (this accounts for zero indexing)\\n if verbose:\\n print(current_class)\\n print('{}/{}'.format(count_of_test_class, abs(j)))\\n j = j -1 # really this is here so we can check j\\n break\\n if (current_class == test_class):\\n count_of_test_class = count_of_test_class + 1\\n MAP = MAP + count_of_test_class/(abs(j)) # N.b. this is the sum, we divide by j on the output\\n return MAP/Q\",\n \"def balance_classes(df):\\n df_class_0 = df[df[65]==0]\\n df_class_1 = df[df[65]==1]\\n df_count = df[65].value_counts()\\n count_0 = df_count[0]\\n count_1 = df_count[1]\\n\\n if count_0 > count_1:\\n df_class_1_over = df_class_1.sample(count_0, replace=True)\\n df_over = pd.concat([df_class_0, df_class_1_over], axis=0)\\n elif count_0 < count_1:\\n df_class_0_over = df_class_0.sample(count_1, replace=True)\\n df_over = pd.concat([df_class_1, df_class_0_over], axis=0)\\n else:\\n df_over = df\\n \\n return df_over\",\n \"def predictClusters(self, df, k):\\n self.models.fitModels(df)\\n return self.models.predict()\",\n \"def split_train_test(ratings):\\r\\n ratings = ratings.sample(frac=1).reset_index(drop=True)\\r\\n train_user_list = []\\r\\n train_item_list = []\\r\\n train_rating_list = []\\r\\n test_user_list = []\\r\\n test_item_list = []\\r\\n test_rating_list = []\\r\\n user_pool = set(ratings['userId'].unique())\\r\\n for idx in user_pool:\\r\\n flag = 0\\r\\n items = ratings[ratings['userId']==idx][['itemId','rating']]\\r\\n for i, row in items.iterrows():\\r\\n if flag == 0:\\r\\n test_user_list.append(int(idx))\\r\\n test_item_list.append(int(row['itemId']))\\r\\n test_rating_list.append(row['rating'])\\r\\n flag = 1\\r\\n else:\\r\\n train_user_list.append(int(idx))\\r\\n train_item_list.append(int(row['itemId']))\\r\\n train_rating_list.append(row['rating'])\\r\\n\\r\\n train = pd.DataFrame({'userId': train_user_list, 'itemId': train_item_list, 'rating': train_rating_list}, columns=['userId', 'itemId', 'rating'])\\r\\n test = pd.DataFrame({'userId': test_user_list, 'itemId': test_item_list, 'rating': test_rating_list}, columns=['userId', 'itemId', 'rating'])\\r\\n return [train, test]\\r\\n \\r\\n\\r\\n \\r\\n #train, test = train_test_split(ratings, test_size=0.1, shuffle=True)\\r\\n #return [train, test]\\r\",\n \"def _class_cov(X, y):\\n classes = np.unique(y)\\n covs = []\\n for group in classes:\\n Xg = X[y == group, :]\\n covs.append(np.atleast_2d(_cov(Xg)))\\n return np.average(covs, axis=0)\",\n \"def calc_earning(self, data=None):\\n result = Result()\\n if data is None:\\n data = self.security\\n self.calcDecision()\\n first_purchase_method = self.check_first_purchase_method()\\n for i in np.arange(len(data['Close'])):\\n if data['FinalDecision'].iloc[i] is None:\\n pass\\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\\n self.buys_made += 1\\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\\n self.shares_own = self.stock_quantity\\n self.buys_made += 1\\n else:\\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\\n self.final_capital = self.final_capital % data['Close'].iloc[i]\\n #print(self.shares_own)\\n\\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n pass\\n else:\\n self.final_capital += self.shares_own * data['Close'].iloc[i]\\n self.shares_own = 0\\n self.sells_made +=1\\n #Checar si es el momento mas alto o bajo de ganancias\\n if self.shares_own == 0:\\n if (self.highest_point is None\\n or self.highest_point < self.final_capital):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > self.final_capital\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n else:\\n if (self.highest_point is None\\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n self.calcRealFinalCapital()\\n self.calcDiferencePercentage()\",\n \"def cross_val(model, data, n, target):\\n scores = []\\n splits = partition(data, n)\\n for i in range(n):\\n train_list = splits[:i] + splits[i+1:]\\n train = pd.concat(train_list)\\n test = splits[i]\\n y_true = test[target]\\n test = test.drop(columns=[target], axis=1)\\n model.fit(train, estimator=BayesianEstimator, prior_type=\\\"BDeu\\\")\\n y_pred = model.predict(test)\\n acc = accuracy_score(y_pred[target], y_true)\\n scores.append(acc)\\n return scores\",\n \"def usefulness_score(model, test, train, k=20):\\n distances = []\\n test = test.tocsr()\\n train = train.tocsr()\\n (x, y, z) = sp.find(train.T)\\n counts = np.bincount(x)\\n counts += 1\\n sums = np.bincount(x, weights=z)\\n averages = sums / counts\\n\\n for user_id, row in enumerate(test):\\n\\n if not len(row.indices):\\n continue\\n\\n predictions = -model.predict(user_id)\\n\\n if train is not None:\\n rated = train[user_id].indices\\n predictions[rated] = FLOAT_MAX\\n\\n rec_list = predictions.argsort()[:k]\\n distances.append(np.mean(averages[rec_list]))\\n return np.array(distances)\",\n \"def evaluate(train: pd.DataFrame, test: pd.DataFrame, algorithm):\\n\\n model = algorithm(train)\\n\\n test_labels = test['Labels']\\n\\n predictions = predict_data(test, model)\\n\\n error = mean_square_error(predictions, test_labels)\\n\\n acc = accuracy(predictions, test_labels)\\n\\n return acc, error\",\n \"def main():\\n # Read in trainingSet and testSet as a DataFrame\\n trainingOriginal = pd.read_csv(\\n filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.train.5fold.csv\\\")\\n testOriginal = pd.read_csv(filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.test.csv\\\")\\n\\n # Select only the numeric data\\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\\n training = pd.concat([training.reset_index(drop=True),\\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Select only the numeric data\\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\\n test = pd.concat([test.reset_index(drop=True),\\n testOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Normalize the columns for training and test\\n # print training['age'].min()\\n # print training['age'].max()\\n # print training.head()\\n\\n # Run max-min normalization on numerical columns for testing and training data\\n for i in range(6):\\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\\n\\n # Convert the 'earns' column to boolean as follows\\n training['earns'] = training['earns'] == '>50K'\\n test['earns'] = test['earns'] == ' >50K'\\n\\n # Group the training set by the fold attribute as given by the dataset\\n trainingForFinal = training\\n training = training.groupby('fold')\\n\\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\\n kList = []\\n for i in range(40):\\n if i % 2 == 1:\\n kList.append(i)\\n\\n # Empty dictionary to hold performance of each k-values and its accuracy\\n performance = {}\\n\\n # Compute the performance for each k-value\\n for k in kList:\\n performance = crossValidation(training, k, performance)\\n\\n # Sort the performance dictionary by its accuracy (value)\\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\\n\\n # Open file to write results\\n file = open('grid.results.txt', 'w')\\n # Write the results to file\\n file.write(\\\"K | Accuracy\\\\n\\\")\\n for item in performance:\\n if item[0] < 10:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n else:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n # Close file\\n file.close()\\n\\n # The best K is the one at the top of the list after the sorting\\n bestK = performance[0][0]\\n\\n print 'Running Test Set with K = ' + str(bestK)\\n\\n applyModel(test,trainingForFinal,bestK)\",\n \"def __create_cluster_profiles(self,\\n clustered_dataframes,\\n shrunken_df,\\n numerical_features,\\n le_map,\\n output_path,\\n find_nearest_on_cols=False,\\n show=True):\\n\\n def find_nearest(numbers, target):\\n \\\"\\\"\\\"\\n Find the closest fitting number to the target number\\n \\\"\\\"\\\"\\n numbers = np.asarray(numbers)\\n idx = (np.abs(numbers - target)).argmin()\\n return numbers[idx]\\n\\n cluster_profiles_df = pd.DataFrame(columns=shrunken_df.columns).drop(\\n 'Cluster_Name', axis=1)\\n rows_count = 0\\n for cluster_identfier, cluster_dataframe in \\\\\\n clustered_dataframes.items():\\n df = pd.DataFrame(columns=cluster_dataframe.columns)\\n df = df.append(cluster_dataframe.mean(), ignore_index=True)\\n df.index = [cluster_identfier]\\n\\n if cluster_dataframe.shape[0] <= 1:\\n continue\\n\\n # Attempt to convert numbers found within the full set of data\\n for col in cluster_dataframe.columns:\\n if col not in numerical_features or find_nearest_on_cols:\\n df[col] = find_nearest(numbers=shrunken_df[\\n col].value_counts().index.tolist(),\\n target=df[col].values[0])\\n\\n # Evaluate cluster dataframe by dataframe\\n eval_df = pd.DataFrame(columns=cluster_dataframe.columns)\\n eval_df = eval_df.append(\\n cluster_dataframe.mean(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.min(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.median(),\\n ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.max(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.std(), ignore_index=True)\\n eval_df = eval_df.append(\\n cluster_dataframe.var(), ignore_index=True)\\n eval_df.index = [\\\"Mean\\\", \\\"Min\\\", \\\"Median\\\",\\n \\\"Max\\\", \\\"Standard Deviation\\\", \\\"Variance\\\"]\\n\\n if show:\\n print(\\\"Total found in {0} is {1}\\\".format(\\n cluster_identfier, cluster_dataframe.shape[0]))\\n self.__render_mpl_table(\\n df,\\n sub_dir=output_path,\\n filename=cluster_identfier +\\n \\\"_Means_Rounded_To_Nearest_Real_Numbers\\\",\\n header_columns=0,\\n col_width=4.0)\\n\\n self.__render_mpl_table(\\n eval_df,\\n sub_dir=output_path,\\n filename=cluster_identfier +\\n \\\"_Eval_Df\\\",\\n header_columns=0,\\n col_width=4.0)\\n display(df)\\n display(eval_df)\\n self.__vertical_spacing(7)\\n\\n cluster_profiles_df = cluster_profiles_df.append(\\n self.__decode_df(df, le_map))\\n\\n rows_count += cluster_dataframe.shape[0]\\n\\n return rows_count, cluster_profiles_df\",\n \"def decision_function(self, X):\\n\\n n, _ = X.shape\\n\\n # predict the cluster labels + distances to the clusters\\n labels = self.base_clusterer.predict(X)\\n # each dimension is the distance to the cluster centers (n_samples, n_clusters)\\n distances = self.base_clusterer.transform(X)\\n\\n # compute scores\\n scores = np.zeros(n, dtype=float)\\n for i, l in enumerate(labels):\\n if self.max_intra_cluster[l] < self.tol:\\n point_deviation = 1.0\\n else:\\n point_deviation = distances[i, l] / self.max_intra_cluster[l]\\n scores[i] = (\\n point_deviation * self.cluster_deviation[l]\\n ) / self.cluster_sizes[l]\\n\\n return scores\",\n \"def voting(y_pred_test, gnd_te):\\n df = pd.DataFrame({'y':y_pred_test, 'gnd':gnd_te})\\n df.sort_values(by=['y'], inplace=True, ascending=False)\\n out = df.groupby(['gnd']).mean()\\n return len(out[out['y'] > 0])/float(len(out))\",\n \"def groups_of_train_test_set(df, config, fbprophet=None):\\n \\n tvar = config.variables['tvar']\\n xvar = config.variables['xvar'] + config.variables['xvar_derived']\\n \\n begin_date = config.timestamps['begin_date']\\n end_date = config.timestamps['end_date']\\n deltat = config.timestamps['deltat']\\n\\n begin_date = datetime.datetime.strptime(begin_date, \\\"%Y-%m-%d %H:%M:%S\\\")\\n end_date = datetime.datetime.strptime(end_date, \\\"%Y-%m-%d %H:%M:%S\\\")\\n\\n \\n # Check if ustar threshold is provided for year of interest\\n if config.data['ustar']==True:\\n if not begin_date.year in config.data['ustar_map'].keys():\\n raise ValueError('{} is missing from config/data/ustar_map'.format(begin_date.year))\\n if not end_date.year in config.data['ustar_map'].keys():\\n raise ValueError('{} is missing from config/data/ustar_map'.format(end_date.year))\\n\\n\\n if (end_date - begin_date).days < deltat:\\n raise ValueError(\\\"Time difference in days between begin and end date\\\" + \\n \\\"must be greater than deltat.\\\")\\n\\n\\n df = df.loc[df[tvar] <= end_date]\\n\\n number_of_train_test_sets = int((end_date - begin_date).total_seconds()/\\\\\\n datetime.timedelta(deltat).total_seconds())\\n\\n begin_test_timestamp = begin_date\\n \\n\\n test_df = []\\n train_df = [] \\n for i in range(number_of_train_test_sets):\\n if i == number_of_train_test_sets-1:\\n end_test_timestamp = end_date\\n else:\\n end_test_timestamp = None\\n\\n\\n i_test_set, i_train_set, end_test_timestamp =\\\\\\n _train_test_split(df.copy(), config,\\n begin_test_timestamp,\\n deltat, end_test_timestamp,\\n fbprophet)\\n begin_test_timestamp = end_test_timestamp\\n \\n # Interpolating where x-var is nan.\\n i_test_set[xvar] = i_test_set[xvar].interpolate()\\n i_train_set[xvar] = i_train_set[xvar].interpolate()\\n \\n\\n i_test_set['Set_rank'] = i\\n i_train_set['Set_rank'] = i\\n \\n if i == 0:\\n test_df = i_test_set\\n train_df = i_train_set\\n else:\\n test_df = pd.concat((test_df, i_test_set))\\n train_df = pd.concat((train_df, i_train_set))\\n\\n\\n return test_df, train_df\",\n \"def evaluation_k_means(X_selected, n_clusters, y, n_jobs = 1):\\n k_means = KMeans(n_clusters=n_clusters, init='k-means++', n_init=10, max_iter=300,\\n tol=0.0001, precompute_distances=True, verbose=0,\\n random_state=None, copy_x=True, n_jobs=n_jobs)\\n \\n k_means.fit(X_selected)\\n y_predict = k_means.labels_\\n \\n # calculate NMI\\n nmi = normalized_mutual_info_score(y, y_predict)\\n \\n # calculate ACC\\n y_permuted_predict = best_map(y, y_predict)\\n acc = accuracy_score(y, y_permuted_predict)\\n \\n return nmi, acc\",\n \"def compute_clusters(addons_df, num_clusters, random_seed):\\n\\n # Build the stages of the pipeline. We need hashing to make the next\\n # steps work.\\n hashing_stage = HashingTF(inputCol=\\\"addon_ids\\\", outputCol=\\\"hashed_features\\\")\\n idf_stage = IDF(inputCol=\\\"hashed_features\\\", outputCol=\\\"features\\\", minDocFreq=1)\\n # As a future improvement, we may add a sane value for the minimum cluster size\\n # to BisectingKMeans (e.g. minDivisibleClusterSize). For now, just make sure\\n # to pass along the random seed if needed for tests.\\n kmeans_kwargs = {\\\"seed\\\": random_seed} if random_seed else {}\\n bkmeans_stage = BisectingKMeans(k=num_clusters, **kmeans_kwargs)\\n pipeline = Pipeline(stages=[hashing_stage, idf_stage, bkmeans_stage])\\n\\n # Run the pipeline and compute the results.\\n model = pipeline.fit(addons_df)\\n return model.transform(addons_df).select([\\\"client_id\\\", \\\"prediction\\\"])\",\n \"def kmeans_clustering(proj_df, k):\\r\\n k_means= k_means = KMeans(random_state=25, n_clusters=k)\\r\\n k_means.fit(proj_df)\\r\\n labels= k_means.predict(proj_df)\\r\\n \\r\\n return labels\",\n \"def train_val_test_split(df):\\n from sklearn.model_selction import train_test_split\\n train, test = train_test_split(df, train_size = 0.80, test_size=0.20,\\n random_state = 42)\\n train, val = train_test_split(train, train_size = 0.70, val_size=0.30)\\n print(train.shape, val.shape, test.shape)\\n\\n return train, val, test\",\n \"def k_means_model(df, numOfClusters):\\n # Perform scaling on the dataframe containing the selected features\\n data = scale(df)\\n\\n # Train a model\\n model = KMeans(init=\\\"k-means++\\\", n_clusters=numOfClusters, n_init=20).fit(data)\\n return model\",\n \"def calculate_profit(self):\",\n \"def apply_evaluation(x, label_true, params, names, database_name):\\n rows = []\\n\\n for i in range(0, len(names)):\\n act_name = names[i]\\n act_data = x[i]\\n\\n algorithm = KMeans(k=params['k'], seed=params['seed'], max_it=params['max_it'], tol=params['tol'])\\n labels = algorithm.fit_predict(act_data)\\n\\n unsupervised = evaluate_unsupervised_internal(act_data, labels)\\n supervised = evaluate_supervised_external(label_true, labels)\\n\\n row = {**dict(Names=act_name), **supervised, **unsupervised}\\n rows.append(row)\\n df_results = pd.DataFrame(rows)\\n set_output(df_results, 'pca_analysis_'+database_name)\",\n \"def get_cluster_assignments(self, data, n_clusters=10):\\n kmeans = KMeans(n_clusters=n_clusters)\\n kmeans.fit(data)\\n pred = kmeans.predict(data)\\n return pd.DataFrame(pred)\",\n \"def groupby_train_test_split(df, selected_features=None, test_ratio=0.2, seed=12345, groupby='user_id'):\\n\\n ############################################################\\n # Train Test Split\\n ############################################################\\n\\n grp = df[groupby]\\n n_splits = int(1 / test_ratio)\\n groupkfold = GroupKFold(n_splits=n_splits)\\n random.seed(seed)\\n folds = groupkfold.split(df, groups = grp)\\n train_idx, test_idx = next(folds)\\n df_train, df_test = df.iloc[train_idx], df.iloc[test_idx]\\n \\n return df_train, df_test\",\n \"def evaluate_on_test(self, train_set, test_set):\\n if train_set is not None and test_set is not None:\\n print(\\\"Evaluate RMSE on test data\\\")\\n self.LOG_HANDLE.info(\\\"Evaluate RMSE on test data\\\")\\n\\n similarity_options = {\\n 'name': 'msd',\\n 'user_based': False,\\n }\\n\\n # Use the KNN algorithm\\n algo = KNNWithMeans(sim_options = similarity_options)\\n\\n # Train the algorithm on the trainset, and predict ratings for the testset\\n algo.fit(train_set)\\n predictions = algo.test(test_set)\\n\\n # Then compute RMSE\\n return accuracy.rmse(predictions)\",\n \"def cluster(X=None, datalabels=None, nc=2):\\n from sklearn.cluster import KMeans\\n from sklearn.cluster import AffinityPropagation\\n\\n C = KMeans(n_clusters=nc,n_init=10,init='random')\\n C.fit(X[:,:1])\\n\\n #C = AffinityPropagation(preference=-80,damping=0.5).fit(X)\\n #cluster_centers_indices = C.cluster_centers_indices_\\n\\n clust = {}\\n for (i, label) in enumerate(C.labels_):\\n key = C.cluster_centers_[label][0]\\n #print label,key, datalabels[i],X[i][1]\\n if not clust.has_key(key):\\n clust[key]=[]\\n clust[key].append(datalabels[i])\\n #print clust\\n return C, clust\",\n \"def clusterability(features,data):\\n #Get together features describing clustering results\\n n_nuclei=len(features['label'])\\n n_ellongated_nuc=len(data['label'])\\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n n_uncoupled_nuclei = list(data['clusters']).count(-1) # noise\\n n_coupled_nuclei = len(data['clusters'])-n_uncoupled_nuclei\\n \\n if n_clusters>=2:\\n #calculate clustering robustness without noise\\n Silohhouette_score= sklm.silhouette_score(data.drop(['clusters','label'],axis=1)[data['clusters']> -1], data['clusters'][data['clusters']> -1])\\n else:\\n Silohhouette_score = 'NA'\\n basic_clustering_features = [Clusterability_Features([n_nuclei,n_ellongated_nuc,n_clusters, n_uncoupled_nuclei,n_coupled_nuclei,Silohhouette_score])]\\n basic_clustering_features = pd.DataFrame([o.__dict__ for o in basic_clustering_features])\\n\\n return basic_clustering_features\",\n \"def clusters(self,rng):\\n #clusts = subclust(normalize(self.training_data),0.4,0.5)\\n if self.extended:\\n dat = self.training_data / rng\\n else:\\n dat = self.training_data[:,0:-1] / rng[0:-1]\\n\\n clusts = subclust(normalize(dat))\\n\\n print len(clusts),\\\"initial clusters for class\\\",self.name\\n if self.extended:\\n return np.array([self.training_data[i] for i in clusts])\\n else:\\n return np.array([self.training_data[i,0:-1] for i in clusts])\",\n \"def cluster_kmeans(df, k):\\r\\n # Sample fron the original df\\r\\n sample_df=df.sample(n = k)\\r\\n obs, attr= df.shape\\r\\n # Make copies \\r\\n copy_df=df.copy()\\r\\n flag=0\\r\\n sse_old=0\\r\\n while (flag==0): \\r\\n sse=0\\r\\n Labels=[]\\r\\n for i in range(0, obs):\\r\\n dist= []\\r\\n for j in range(0,k):\\r\\n #Calculate Eucledian distance\\r\\n diff=list((df.iloc[i,:]-sample_df.iloc[j,:])**2)\\r\\n eu_dist=(sum(diff))**(1/attr)\\r\\n dist.append(eu_dist) \\r\\n #Add Labels to the observations based on the variable they are close to\\r\\n label=(dist.index(min(dist)))\\r\\n Labels.append(label)\\r\\n # Calculate SSE\\r\\n sse=sse+((min(dist) )**2)\\r\\n sse=sse**(1/2)\\r\\n copy_df['labels']=Labels\\r\\n # Stopping criteria is change in SSE should be 2 %\\r\\n if (sse_old !=0):\\r\\n if(abs(sse_old-sse)/sse_old<=0.05):\\r\\n flag=1 \\r\\n return_df=copy_df['labels'].to_frame()\\r\\n return (return_df, sse)\\r\\n else:\\r\\n sse_old=sse\\r\\n #Empty the sample df\\r\\n sample_df.drop(sample_df.index, inplace=True)\\r\\n # Now pick random values from each label and add it to the sample df\\r\\n for val in range(0,k):\\r\\n #Create new sample df\\r\\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\\r\\n else:\\r\\n sse_old=sse\\r\\n #Empty the sample df\\r\\n sample_df.drop(sample_df.index, inplace=True)\\r\\n for val in range(0,k):\\r\\n #Create new sample df \\r\\n sample_df = pd.concat([sample_df, copy_df[copy_df['labels']==val].iloc[:,0:attr].sample(n=1)])\",\n \"def kmeans(points,n_clusters):\\n # create kmeans object\\n kmeans = KMeans(n_clusters=n_clusters)\\n # fit kmeans object to data\\n kmeans.fit(points)\\n # print location of clusters learned by kmeans object\\n print(kmeans.cluster_centers_)\\n # save new clusters for chart\\n y_km = kmeans.fit_predict(points)\\n\\n print('Clusters partition: ', Counter(y_km))\\n \\n return y_km, kmeans\",\n \"def test_example(self): \\n num_clusters = 2\\n iterations = 5\\n ts1 = 2.5 * np.random.randn(100,) + 3\\n X_1 = pd.Series(ts1)\\n ts2 = 2 * np.random.randn(100,) + 5\\n X_2 = pd.Series(ts2)\\n ts3 = -2.5 * np.random.randn(100,) + 3\\n X_3 = pd.Series(ts3)\\n list_of_series = [X_1, X_2, X_3]\\n from pynuTS.clustering import DTWKmeans\\n clts = DTWKmeans(num_clust = num_clusters, num_iter = iterations)\\n clts.fit(list_of_series)\\n ts4 = 3.5 * np.random.randn(100,) + 2\\n ts5 = -3.5 * np.random.randn(100,) + 2\\n X_4 = pd.Series(ts4)\\n X_5 = pd.Series(ts5)\\n list_new = [X_4, X_5]\\n clustering_dict = clts.predict(list_new)\\n\\n assert type(clustering_dict) is dict\\n assert len(clustering_dict) == num_clusters\",\n \"def evaluate_clusters(self, cluster_formulas, value='weighted_sum'):\\n num_elems = len(self.labels)\\n total_val = {}\\n num_cl = len(cluster_formulas)\\n clustered_points_num = 0\\n print(\\\"\\\\n\\\\n\\\")\\n print(\\\"Sufficiently big clusters: {}\\\".format(num_cl))\\n for c, formula, val in cluster_formulas:\\n c_size = len([l for l in self.labels if l == c])\\n clustered_points_num += c_size\\n\\n if value == 'weighted_sum':\\n total_val[c] = val * c_size / num_elems\\n elif value == 'sum':\\n total_val[c] = val * 1\\n\\n clust_val = sum(total_val.values())\\n self.clustering_value = total_val\\n print(\\\"Value of clustering: {}\\\".format(clust_val))\\n return clust_val\",\n \"def get_train_test(df):\\n train = df[[\\\"Sex\\\", \\\"Race/Ethnicity\\\", \\\"AgeGroup\\\"]\\n ].to_numpy()\\n test = df[col_names].to_numpy()\\n return (train, test)\",\n \"def make_sklearn_prediction_classification(logger, run_id, df_train_X,\\n df_train_Y, df_test_X, kf,\\n features=None, params=None,\\n model_type=None, is_test=False,\\n seed=42, model=None):\\n yoof = np.zeros(len(df_train_X))\\n yhat = np.zeros(len(df_test_X))\\n cv_scores = []\\n result_dict = {}\\n\\n fold = 0\\n for in_index, oof_index in kf.split(df_train_X[features], df_train_Y):\\n # Start a counter describing number of folds\\n fold += 1\\n # Number of splits defined as a part of KFold/StratifiedKFold\\n n_splits = kf.get_n_splits()\\n logger.info(f'fold {fold} of {n_splits}')\\n X_in, X_oof = df_train_X.iloc[in_index].values, df_train_X.iloc[oof_index].values\\n y_in, y_oof = df_train_Y.iloc[in_index].values, df_train_Y.iloc[oof_index].values\\n\\n model = model\\n model.fit(X_in, y_in)\\n\\n yoof[oof_index] = model.predict_proba(X_oof)[:, 1]\\n if is_test is False:\\n yhat += model.predict_proba(df_test_X.values)[:, 1]\\n\\n cv_oof_score = roc_auc_score(y_oof, yoof[oof_index])\\n logger.info(f'CV OOF Score for fold {fold} is {cv_oof_score}')\\n cv_scores.append(cv_oof_score)\\n\\n del oof_index, X_oof, y_oof\\n gc.collect()\\n\\n util.update_tracking(run_id, \\\"metric_fold_{}\\\".format(fold), cv_oof_score, is_integer=False)\\n\\n yhat /= n_splits\\n\\n oof_score = round(roc_auc_score(df_train_Y, yoof), 5)\\n avg_cv_scores = round(sum(cv_scores)/len(cv_scores), 5)\\n std_cv_scores = round(np.array(cv_scores).std(), 5)\\n\\n logger.info(f'Combined OOF score : {oof_score}')\\n logger.info(f'Average of {fold} folds OOF score {avg_cv_scores}')\\n logger.info(f'std of {fold} folds OOF score {std_cv_scores}')\\n\\n result_dict['yoof'] = yoof\\n result_dict['prediction'] = yhat\\n result_dict['oof_score'] = oof_score\\n result_dict['cv_scores'] = cv_scores\\n result_dict['avg_cv_scores'] = avg_cv_scores\\n result_dict['std_cv_scores'] = std_cv_scores\\n\\n util.update_tracking(run_id, \\\"oof_score\\\", oof_score, is_integer=False)\\n util.update_tracking(run_id, \\\"cv_avg_score\\\", avg_cv_scores, is_integer=False)\\n util.update_tracking(run_id, \\\"cv_std_score\\\", std_cv_scores, is_integer=False)\\n\\n del yoof, yhat\\n gc.collect()\\n\\n logger.info('Training/Prediction completed!')\\n return result_dict\",\n \"def _cluster_hitprobability(self, x, y):\\n hm_count = np.zeros_like(y).astype(float)\\n hm = np.zeros_like(y).astype(float)\\n #skf = StratifiedShuffleSplit(n_splits=self.n_iter, test_size=self.shuffle_test_split, random_state=self.random_state)\\n\\n ind = self._cluster(x, 35)\\n\\n for cluster_id in np.unique(ind):\\n test = np.argwhere(ind == cluster_id)[:, 0]\\n train = np.argwhere(ind != cluster_id)[:, 0]\\n #print test\\n self.basemodel.fit(x[train, :], y[train], hyperparams_optim=False)\\n hm_count[test] += 1.\\n hm[test] += (self.basemodel.predict(x[test, :]) == y[test]).astype(float)\\n\\n proba = hm / hm_count\\n if self.verbose:\\n # print('H/M count:')\\n # print(hm_count)\\n print('Proba:')\\n print(proba)\\n self.basemodel.fit(x, y, hyperparams_optim=False)\\n return proba\",\n \"def mean_payoffs(dist,benefit_function,b,c,*params):\\n dist['A_pay'] = (b*benefit_function(dist.j+1,dist.k+1,*params)-c)*dist.A\\n dist['B_pay'] = (b*benefit_function(dist.j,dist.k+1,*params))*dist.B\\n return dist.groupby('n')[['A_pay','B_pay']].sum()\",\n \"def get_clusters(self,points):\\n self.points = points\\n self.__dabest = [self.__cmeans(points,i) for i in range(self.__start,self.__end)]\\n ##self.hull = \\n return self.__dabest\",\n \"def classfy(data, clu, k):\\n clulist = cal_dis(data, clu)\\n clusterRes = grouping(data, clulist)\\n clunew = new_Cen_Cal(data, clusterRes, k)\\n err = clunew - clu\\n\\n return err, clunew, k, clusterRes\",\n \"def sk_test_suit(X, y):\\r\\n\\r\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)\\r\\n\\r\\n classifierDict = {\\\"Random Forest\\\": RandomForestClassifier(),\\r\\n \\\"Logistic Regression\\\": LogisticRegression(),\\r\\n \\\"Linear Discriminant Analysis\\\": LinearDiscriminantAnalysis(),\\r\\n \\\"Gaussian Naive Bayes\\\": GaussianNB(),\\r\\n \\\"Neural Network\\\": MLPClassifier()}\\r\\n\\r\\n\\r\\n try:\\r\\n for k, v in classifierDict.items():\\r\\n clf = v.fit(X_train, y_train)\\r\\n training_score = cross_val_score(clf, X_train, y_train)\\r\\n testing_score = cross_val_score(clf, X_test, y_test)\\r\\n print(k)\\r\\n print('Sk-learn {0} training accuracy: {1}'.format(k, training_score.mean()))\\r\\n print('Sk-learn {0} testing accuracy: {1}'.format(k, testing_score.mean()))\\r\\n except:\\r\\n pass\\r\\n # winsound.PlaySound('sound.wav', winsound.SND_FILENAME)\\r\",\n \"def _class_means_and_neighbor_means(X, y, k1, k2):\\n means = []\\n neighbor_means = []\\n \\n classes = np.unique(y)\\n samples = np.size(y)\\n \\n for group in classes:\\n Xg = X[y == group, :]\\n Xg_count = Xg.shape[0]\\n Xg_mean = Xg.mean(0)\\n Xn = X[y != group, :]\\n Xg_similarity = _similarity_function(Xg_mean, Xg)\\n Xg_similarity_min = min(Xg_similarity)\\n Xn_similarity = _similarity_function(Xg_mean, Xn)\\n Xn_neighbor_count = len(Xn_similarity[Xn_similarity > Xg_similarity_min])\\n Xn_neighbor_count = int(max(k1 * Xg_count, k2 * Xn_neighbor_count))\\n Xn_neighbor_count = min(Xn_neighbor_count, samples - Xg_count)\\n Xn_label = np.argsort(Xn_similarity)\\n Xn_label = Xn_label[::-1]\\n Xg_neighbor = np.array([Xn[Xn_label[i]] for i in range(Xn_neighbor_count)])\\n Xg_neighbor_mean = Xg_neighbor.mean(0)\\n \\n means.append(Xg_mean)\\n neighbor_means.append(Xg_neighbor_mean)\\n \\n return np.array(means), np.array(neighbor_means)\",\n \"def getKSplitsStratified(df, n_splits, classColumn, seed = None):\\n df_class1 = df[df[classColumn] == True]\\n df_class2 = df[df[classColumn] == False]\\n\\n k_folds_class1 = getKSplits(df_class1, n_splits, seed)\\n k_folds_class2 = getKSplits(df_class2, n_splits, seed)\\n\\n # combine\\n k_folds_combined = []\\n for i in range(n_splits):\\n combined_fold = k_folds_class1[i].append(k_folds_class2[i])\\n combined_fold_shuffled = combined_fold.sample(len(combined_fold), random_state = seed)\\n k_folds_combined.append(combined_fold_shuffled)\\n\\n return k_folds_combined\",\n \"def score(self):\\n\\n\\t\\tsplits = 10\\n\\t\\tscore = 0\\n\\n\\t\\tkf = KFold(n_splits=splits, shuffle=True)\\n\\t\\tkf.get_n_splits(self.data)\\n\\n\\t\\tfor train_ind, test_ind in kf.split(self.data):\\n\\n\\t\\t\\ttrain = [self.data[ind] for ind in train_ind]\\n\\t\\t\\ttest = [self.data[ind] for ind in test_ind]\\n\\n\\t\\t\\tself.model = self._fit(train)\\n\\t\\t\\ttemp_score = self.score_one(test)\\n\\t\\t\\tscore += temp_score\\n\\n\\t\\treturn score/float(splits)\",\n \"def score(self):\\n\\n\\t\\tsplits = 10\\n\\t\\tscore = 0\\n\\n\\t\\tkf = KFold(n_splits=splits, shuffle=True)\\n\\t\\tkf.get_n_splits(self.data)\\n\\n\\t\\tfor train_ind, test_ind in kf.split(self.data):\\n\\n\\t\\t\\ttrain = [self.data[ind] for ind in train_ind]\\n\\t\\t\\ttest = [self.data[ind] for ind in test_ind]\\n\\n\\t\\t\\tself.model = self._fit(train)\\n\\t\\t\\ttemp_score = self.score_one(test)\\n\\t\\t\\tscore += temp_score\\n\\n\\t\\treturn score/float(splits)\",\n \"def OTU_table_ML(OTU_table,metadata,obj_col):\\n for ele in OTU_table.index:\\n #print(ele)\\n X.append(df.loc[ele])\\n Y.append(metadata[obj_col][ele])\\n precisions = []\\n for train_time in range(100): \\n X,Y = shuffle(X,Y)\\n sample_num = len(X)\\n sep_num = int(0.8*sample_num)\\n train_set = [X[:sep_num],Y[:sep_num]]\\n test_set = [X[sep_num:],Y[sep_num:]]\\n clf = svm.SVC(gamma='scale')\\n clf.fit(train_set[0], train_set[1]) \\n predict_result = clf.predict(test_set[0])\\n count = 0\\n for i in range(len(predict_result)):\\n if predict_result[i] == test_set[1][i]:\\n count += 1\\n else:\\n pass\\n precisions.append(1.0*count/len(predict_result))\\n print(np.mean(precisions))\",\n \"def mean_square_error(self, test_set, predicted_values):\\r\\n\\r\\n running_sum = 0\\r\\n for i in range(len(test_set)):\\r\\n running_sum += (test_set[i].classification - predicted_values[i])**2\\r\\n running_sum = running_sum / len(test_set)\\r\\n return running_sum\",\n \"def purity(clusters, classes):\\n\\n d = defaultdict(list)\\n\\n # Get a list of class numbers of all examples in a cluster.\\n for k, v in zip(clusters, classes):\\n d[k].append(v)\\n\\n mayority = 0\\n\\n # Count the mayority class number and add it up over all clusters.\\n for k in d:\\n mayority += Counter(d[k]).most_common(1)[0][1]\\n\\n return float(mayority) / len(clusters)\",\n \"def Client_K_Means_Orch(log,\\n\\t\\t\\t\\t train_data,\\n\\t\\t\\t\\t orig_data,\\n\\t\\t\\t\\t cluster_range,\\n\\t\\t\\t\\t silhouette_analysis = False,\\n\\t\\t\\t\\t silhouette_cluster_range = range(0,0),\\n\\t\\t\\t\\t train_col_names = None, \\n\\t\\t\\t\\t x_feature_index = 0,\\n\\t\\t\\t\\t y_feature_index = 1,\\n\\t\\t\\t\\t viz = False,\\n\\t\\t\\t\\t show = False,\\n\\t\\t\\t\\t viz_name = \\\"\\\",\\n\\t\\t\\t\\t test_name = \\\"\\\"):\\n\\n\\n\\t\\n\\tprint(\\\"\\\\nData\\\\n\\\")\\n\\t#Strip and replace off any spaces\\n\\ttest_name = test_name.strip().replace(\\\" \\\",\\\"_\\\")\\n\\n\\t#Initialize customer segmentation test\\n\\ttest = CustomerSegmentation(Method = KMeans(), \\n\\t\\t\\t\\t\\t\\t\\t\\tdata = train_data,\\n\\t\\t\\t\\t\\t\\t\\t\\torig_data = orig_data,\\n\\t\\t\\t\\t\\t\\t\\t\\tlog = log, \\n\\t\\t\\t\\t\\t\\t\\t\\ttest_name = test_name)\\n\\n\\t# Set train data and class labels\\n\\ttest.Preprocess.set_train_data(train_data)\\n\\n\\tprint(\\\"\\\\nPCA\\\\n\\\")\\n\\t# Conduct PCA, fit and transformation\\n\\ttest.Preprocess.PCA_fit(viz = viz, viz_name = viz_name, show = show)\\n\\ttest.Preprocess.PCA_transform()\\n\\n\\tprint(\\\"\\\\nElbow Chart Analysis\\\\n\\\")\\n\\t#Conduct elbow chart analysis\\n\\ttest.SegMethod.elbow_chart_test(cluster_range, viz = viz,show = show, viz_name = viz_name, profile = True)\\n\\n\\tif silhouette_analysis:\\n\\t\\tprint(\\\"\\\\nSilhouette Analysis\\\\n\\\")\\n\\t\\t#Conduct Silhouette analysis\\n\\t\\ttest.Preprocess.silhouette_analysis(silhouette_cluster_range, viz = viz, viz_name = viz_name, show = show)\\n\\n\\tprint(\\\"\\\\nLog Saving\\\\n\\\")\\n\\t#Save Preprocess and Method logs\\n\\ttest.Preprocess.PreprocessLog.savePreprocessLog()\\n\\ttest.SegMethod.MethodLog.saveMethodLog()\\n\\n\\t#Add final masterlog record\\n\\tlog.addMasterLogRecord(test)\",\n \"def mean_impute(self):\\n X_train, X_val, y_train, y_val = train_test_split(self.X_dev, self.y_dev, test_size=0.25, random_state=10)\\n imputer = SimpleImputer(strategy='mean')\\n imputer.fit(X_train)\\n X_train_mean_imputed = pd.DataFrame(imputer.transform(X_train), columns=X_train.columns)\\n X_val_mean_imputed = pd.DataFrame(imputer.transform(X_val), columns=X_val.columns)\\n rf = RandomForestClassifier\\n rf_mean_imputed, best_hyperparams_mean_imputed = holdout_grid_search(rf, X_train_mean_imputed, y_train,\\n X_val_mean_imputed, y_val,\\n hyperparams, {'random_state': 10})\\n\\n y_train_best = rf_mean_imputed.predict_proba(X_train_mean_imputed)[:, 1]\\n train_c_index = cindex(y_train, y_train_best)\\n \\n y_val_best = rf_mean_imputed.predict_proba(X_val_mean_imputed)[:, 1]\\n valid_c_index = cindex(y_val, y_val_best)\\n \\n y_test_imp = rf_mean_imputed.predict_proba(self.X_test)[:, 1]\\n test_c_index = cindex(self.y_test, y_test_imp)\\n \\n return train_c_index, valid_c_index, test_c_index\",\n \"def FE_kmeans_resampler(x_train, y_train, target, smote=\\\"\\\", verbose=0):\\r\\n x_train_c = copy.deepcopy(x_train)\\r\\n x_train_c[target] = y_train.values\\r\\n\\r\\n # Regression problem turned into Classification problem\\r\\n n_clusters = max(3, int(np.log10(len(y_train))) + 1)\\r\\n # Use KMeans to find natural clusters in your data\\r\\n km_model = KMeans(n_clusters=n_clusters,\\r\\n n_init=5,\\r\\n random_state=99)\\r\\n #### remember you must predict using only predictor variables!\\r\\n y_train_c = km_model.fit_predict(x_train)\\r\\n\\r\\n if verbose >= 1:\\r\\n print('Number of clusters created = %d' %n_clusters)\\r\\n\\r\\n #### Generate the over-sampled data\\r\\n #### ADASYN / SMOTE oversampling #####\\r\\n if isinstance(smote, str):\\r\\n x_train_ext, _ = oversample_SMOTE(x_train_c, y_train_c)\\r\\n else:\\r\\n x_train_ext, _ = smote.fit_resample(x_train_c, y_train_c)\\r\\n y_train_ext = x_train_ext[target].values\\r\\n x_train_ext.drop(target, axis=1, inplace=True)\\r\\n return (x_train_ext, y_train_ext)\",\n \"def compute_average_separability_score(self) -> Dict:\\n avg_sep_score = {}\\n for class_pair_key, class_pair_val in self.separability_scores.items():\\n avg_sep_score[class_pair_key] = np.mean(np.array([val for _, val in class_pair_val.items()]))\\n avg_sep_score['agg_with_risk'] = sum(\\n np.array([val for _, val in avg_sep_score.items()]) *\\n RISK\\n ) \\n avg_sep_score['agg'] = sum([val for key, val in avg_sep_score.items() if type(key)==int]) \\n return avg_sep_score\",\n \"def get_output(data, capital=100000, leverage=1, commission=0, slippage=0):\\n total_capital = capital * leverage\\n df = data\\n df['cnt'] = df.groupby('timestamp')['symbol'].transform(\\n lambda x: len(x))\\n df['qty'] = (total_capital/df['cnt']/df['price']).round()\\n df['profit'] = df.eval('(sell-buy)*qty')\\n df['commission'] = df.eval('(sell+buy)*qty') * commission * 0.01\\n df['slippage'] = df.eval('(sell+buy)*qty') * slippage * 0.01\\n df['net_profit'] = df.eval('profit - commission - slippage')\\n return df\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8185011","0.7136002","0.5966785","0.59034175","0.58183724","0.5765148","0.5717098","0.56850725","0.56474286","0.56181526","0.5601236","0.557191","0.55662805","0.5527561","0.55179936","0.55108774","0.54241854","0.5415164","0.5412711","0.5410539","0.5401505","0.53984374","0.53896075","0.5375711","0.53662443","0.5354585","0.5349638","0.53489065","0.5336449","0.5330914","0.532604","0.5311775","0.53024","0.52967787","0.5258595","0.52437234","0.5242932","0.52259934","0.52219266","0.5219407","0.52044165","0.5203621","0.51924163","0.51918197","0.51873785","0.5175033","0.51709324","0.5169465","0.5162098","0.516169","0.51537466","0.515191","0.51508033","0.51474154","0.5141458","0.51406","0.5139719","0.51317275","0.5131614","0.5130766","0.5126082","0.51248306","0.51238066","0.51046294","0.50969255","0.50953615","0.50847244","0.5084042","0.5073816","0.50733864","0.50715524","0.50618273","0.5058407","0.50575703","0.5050776","0.5043635","0.5034504","0.5032397","0.5028026","0.5026602","0.5023704","0.50181025","0.50178045","0.50175667","0.5016504","0.50152266","0.50138766","0.5013821","0.5007061","0.5006939","0.5001138","0.5001138","0.49996525","0.49983367","0.49964002","0.49923652","0.49922425","0.49909374","0.49870145","0.49869347"],"string":"[\n \"0.8185011\",\n \"0.7136002\",\n \"0.5966785\",\n \"0.59034175\",\n \"0.58183724\",\n \"0.5765148\",\n \"0.5717098\",\n \"0.56850725\",\n \"0.56474286\",\n \"0.56181526\",\n \"0.5601236\",\n \"0.557191\",\n \"0.55662805\",\n \"0.5527561\",\n \"0.55179936\",\n \"0.55108774\",\n \"0.54241854\",\n \"0.5415164\",\n \"0.5412711\",\n \"0.5410539\",\n \"0.5401505\",\n \"0.53984374\",\n \"0.53896075\",\n \"0.5375711\",\n \"0.53662443\",\n \"0.5354585\",\n \"0.5349638\",\n \"0.53489065\",\n \"0.5336449\",\n \"0.5330914\",\n \"0.532604\",\n \"0.5311775\",\n \"0.53024\",\n \"0.52967787\",\n \"0.5258595\",\n \"0.52437234\",\n \"0.5242932\",\n \"0.52259934\",\n \"0.52219266\",\n \"0.5219407\",\n \"0.52044165\",\n \"0.5203621\",\n \"0.51924163\",\n \"0.51918197\",\n \"0.51873785\",\n \"0.5175033\",\n \"0.51709324\",\n \"0.5169465\",\n \"0.5162098\",\n \"0.516169\",\n \"0.51537466\",\n \"0.515191\",\n \"0.51508033\",\n \"0.51474154\",\n \"0.5141458\",\n \"0.51406\",\n \"0.5139719\",\n \"0.51317275\",\n \"0.5131614\",\n \"0.5130766\",\n \"0.5126082\",\n \"0.51248306\",\n \"0.51238066\",\n \"0.51046294\",\n \"0.50969255\",\n \"0.50953615\",\n \"0.50847244\",\n \"0.5084042\",\n \"0.5073816\",\n \"0.50733864\",\n \"0.50715524\",\n \"0.50618273\",\n \"0.5058407\",\n \"0.50575703\",\n \"0.5050776\",\n \"0.5043635\",\n \"0.5034504\",\n \"0.5032397\",\n \"0.5028026\",\n \"0.5026602\",\n \"0.5023704\",\n \"0.50181025\",\n \"0.50178045\",\n \"0.50175667\",\n \"0.5016504\",\n \"0.50152266\",\n \"0.50138766\",\n \"0.5013821\",\n \"0.5007061\",\n \"0.5006939\",\n \"0.5001138\",\n \"0.5001138\",\n \"0.49996525\",\n \"0.49983367\",\n \"0.49964002\",\n \"0.49923652\",\n \"0.49922425\",\n \"0.49909374\",\n \"0.49870145\",\n \"0.49869347\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8361798"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19497,"cells":{"query":{"kind":"string","value":"Used for creating a final strategy (not for testing) reads preprocessed split into training and testing sets data train som model calculates mean profit per cluster in training dataset gets list of sell and buy clusters"},"document":{"kind":"string","value":"def create_final_strategy(filename: str, columns_list: List[str], som_width=Config.som_width,\n som_height=Config.som_height, n_iter=Config.n_iter, sigma=Config.sigma,\n learning_rate=Config.learning_rate) -> tuple:\n\n print(\n f'Creating final strategy for parameters: \\nmap_size: {som_height}\\nn_iter: {n_iter}\\nsigma:{sigma}\\nlr: {learning_rate}')\n # get prepared data\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\n\n # train som\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\n sigma=sigma, learning_rate=learning_rate)\n\n # get profit per cluster in train datasets\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\n\n assert len(df_profit_per_cluster_train) >= 3, \"Algorithm, returned less than 3 clusters.\"\n\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\n group_size = int(len(df_profit_per_cluster) / 3)\n\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\n\n return final_df_train, final_df_test, buy_clusters_list, sell_clusters_list"},"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 main_predefined_split():\n\n average_performance = []\n fold_num = 'predefined'\n output_file_folder = \"output/{}\".format(args.experiment_name)\n output_file_name = \"{}/lnnel_{}.csv\".format(output_file_folder, fold_num)\n Path(output_file_folder).mkdir(parents=True, exist_ok=True)\n args.output_file_name = output_file_name\n\n if args.use_blink:\n df_train = pd.read_csv(\"./data/lcquad/blink/lcquad_train_sorted.csv\")\n df_test = pd.read_csv(\"./data/lcquad/blink/lcquad_test_sorted.csv\")\n else:\n df_train = pd.read_csv(\"./data/lcquad/dbpedia/lcquad_train_sorted.csv\")\n df_test = pd.read_csv(\"./data/lcquad/dbpedia/lcquad_test_sorted.csv\")\n\n # filter out the questions with single positive or many negatives in trianing set\n filtered_question_mentions = []\n for qm in df_train.QuestionMention.unique():\n df_ = df_train[df_train.QuestionMention == qm]\n if df_.Label.sum() == 0:\n filtered_question_mentions.append(qm)\n if df_.Label.sum() == 1 and df_.shape[0] == 1:\n filtered_question_mentions.append(qm)\n # print(df_.Label.values)\n df_train_split_filtered = df_train[~df_train.QuestionMention.isin(filtered_question_mentions)]\n df_train_split_filtered = df_train_split_filtered.sort_values(by=['QuestionMention', 'Label'])\n df_train = df_train_split_filtered\n\n # train\n features_train = np.array(\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_train.Features.values])\n x_train = torch.from_numpy(features_train).float()\n y_train = torch.from_numpy(df_train.Label.values).float().reshape(-1, 1)\n m_labels_train = df_train.Mention_label.values\n ques_train = df_train.Question.values\n\n # test\n features_test = np.array(\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_test.Features.values])\n x_test = torch.from_numpy(features_test).float()\n y_test = torch.from_numpy(df_test.Label.values).float().reshape(-1, 1)\n m_labels_test = df_test.Mention_label.values\n ques_test = df_test.Question.values\n\n # train model and evaluate\n model = pick_model(args.model_name, args.alpha)\n model = model.to(device)\n\n # move to gpu\n x_train, y_train = x_train.to(device), y_train.to(device)\n x_test, y_test = x_test.to(device), y_test.to(device)\n\n print(model)\n\n print(\"model: \", args.model_name, args.alpha)\n print(model(x_train, m_labels_train))\n\n print(\"y_train sum\", sum(y_train), sum(y_train) / len(y_train))\n print(\"y_test sum\", sum(y_test), sum(y_test) / len(y_test))\n\n # aggregate the data into train, val, and test\n train_data = (x_train, y_train, m_labels_train, ques_train)\n print(\"train:\", x_train.shape, y_train.shape, m_labels_train.shape, ques_train.shape)\n test_data = (x_test, y_test, m_labels_test, ques_test)\n print(\"test:\", x_test.shape, y_test.shape, m_labels_test.shape, ques_test.shape)\n\n # check class distribution\n print(\"y_train sum\", sum(y_train), sum(y_train) / len(y_train))\n print(\"y_test sum\", sum(y_test), sum(y_test) / len(y_test))\n\n train(model, train_data, test_data, test_data, args.checkpoint_name, args.num_epoch, args.margin,\n args.learning_rate)\n test_pred, best_scores = test(x_test, m_labels_test, ques_test, args.alpha, args.checkpoint_name,\n args.model_name,\n args.output_file_name)\n with open(args.log_file_name, 'a') as f:\n f.write(\n \"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}; lr={}; margin={}\\n\".format(\n args.model_name,\n args.use_fixed_threshold,\n args.alpha,\n best_scores[\n 'precision'],\n best_scores[\n 'recall'],\n best_scores['f1'],\n args.learning_rate,\n args.margin))\n print(\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}\\n\".format(args.model_name,\n args.use_fixed_threshold,\n args.alpha,\n best_scores['precision'],\n best_scores['recall'],\n best_scores['f1']))\n average_performance.append([best_scores['precision'], best_scores['recall'], best_scores['f1']])\n\n average_performance = np.array(average_performance)\n print(\"Avg performance is prec - rec - f1: \", average_performance.mean(0))","def create_strategy(filename: str, columns_list: List[str], som_width: int, som_height: int, n_iter: int, sigma=0.3,\n learning_rate=0.01) -> tuple:\n # get prepared data\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\n\n # train som\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\n sigma=sigma, learning_rate=learning_rate)\n\n # get profit per cluster in train and test datasets\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\n df_profit_per_cluster_test = get_profit_per_cluster(final_df_test)\n\n # get mean profit for sell and buy class in training and testing datasets\n try:\n buy_clusters_mean_profit_train, buy_clusters_list, sell_clusters_mean_profit_train, sell_clusters_list = \\\n get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train)\n\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = \\\n get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test, buy_clusters_list, sell_clusters_list)\n # if the data was assigned to less than to 3 clusters\n except:\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = None, None, None, None\n\n return len(df_profit_per_cluster_train), len(df_profit_per_cluster_test), \\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test","def train_loop(train_per_list, cut_off_list, C_list,\n factors, non_factors, data_path, executable_path, \n trial_factors_list=None): \n if trial_factors_list is None:\n trial_factors_list=[factors]\n sql_table = 'aggregated_ctr' #Data table\n # remove cross terms\n sql_features = list(set(sum([fs.split('*') for fs in factors], [])))\n# factors+=['campaign_id','ad_account_id','pub_account_id', \n# 'campaign_id*site', 'ad*pub_account_id']\n con_dict_dse={'host':'db.lqm.io','db':'dse',\n 'user':'dse','passwd':'dSe@lQm'}\n con_dict_mad={'host':'db.lqm.io','db':'madvertise_production',\n 'user':'readonly','passwd':'z0q909TVZj'}\n \n rtb_flag=[0,1]\n model_type=0\n has_intercept = True # bias term in LR\n tol = 0.00000001\n # NB these filenames are HARDCODED in write_sparse routines\n weights_file = 'train_ais.txt'\n train_file = 'train_svm.txt'\n test_file = 'test_svm.txt'\n probability_file = 'preds_SummModel_py.txt'\n results = []\n for train_per in train_per_list:\n test_per = ( add_hour(train_per[1], 1), add_hour(train_per[1], 3))\n # DATA RANGE IS INCLUSIVE => 00:00-02:00 = 3 HOURS\n train_df=mysql_lqm.MySQL_getdata(con_dict_dse,\n sql_table, train_per, sql_features, rtb_flag)\n train_df=mysql_lqm.add_features( train_df)\n test_df= mysql_lqm.MySQL_getdata(con_dict_dse,\n sql_table, test_per, sql_features, rtb_flag)\n test_df = mysql_lqm.add_features(test_df)\n \n sc, click_no_click_df, weights, targets \\\n = libLinear_functions.create_sparse_cat(train_df, factors, non_factors)\n\n \n for cut_off in cut_off_list:\n sparse_train_all = libLinear_functions.create_sparse(sc, cut_off, click_no_click_df)\n sparse_test_all = sc.transform(test_df)\n for trial_factors in trial_factors_list:\n trial_factors=trial_factors[:] # copy\n trial_factors.sort(key=lambda x: sc.factors.index(x))\n # libsvm expects the indices in ascending order\n print (trial_factors) \n sparse_train=sc.select_factors(sparse_train_all, trial_factors)\n sparse_test=sc.select_factors(sparse_test_all, trial_factors)\n libLinear_functions.write_sparse(sc, sparse_train, weights, targets, data_path, len(trial_factors))\n libLinear_functions.write_sparse_test(sc, sparse_test, data_path, n_columns_used= len(trial_factors))\n\n\n for C in C_list:\n model_file = \\\n '{start}_{stop}_cut_{cut_off}_C_{C:0.3}.model'.format(\n start=date_name(train_per[0]),\n stop=date_name(train_per[1]),\n cut_off=cut_off, C=C)\n fit(executable_path, data_path, train_file,\n model_file, weights_file, model_type, reg_param=C, tol=tol,\n has_intercept=has_intercept)\n \n \n pCTR = libLinear_functions.predict(executable_path, data_path, test_file,\n model_file, probability_file)\n if type(pCTR) is pd.Series:\n amounts = pd.DataFrame({\n 'no_clicks':test_df['instances' ]-test_df['clicks'],\n 'clicks':test_df['clicks']})\n mean_log_loss, weighted_log_loss = log_loss_weighted(pCTR, amounts)\n results.append([train_per[:],trial_factors[:],\n cut_off,C,amounts.clicks.sum(),amounts.no_clicks.sum(), mean_log_loss])\n results_df=pd.DataFrame(results,columns=['date','features','cutoff','C','clicks','no_clicks','lloss'])\n results_df.to_csv(data_path+'resultsX.txt',index=False, sep='|')\n # what to do if ERROR?\n return results_df, weighted_log_loss","def pre_train(self, dataset):\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\n pe = principleextractor.PrincipleExtractor()\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\n # not in the .json; or with argument given TODO\n self.skm.add_syllogistic_data(data=pd_dataset)\n\n self.skm.generate_clusters(cutoff=self.cutoff)\n\n results = pe.extract_principles_from_k_clusters(self.skm.final_clusters_syll_list)\n\n participant_correspondence = principleextractor.compute_participant_correspondence(self.skm.subj_data_dict,\n self.skm.final_clusters_num)\n principleextractor.write_results(results[0], results[1], self.skm.final_clusters_syll_list,\n participant_correspondence)\n\n self.k_clusters = self.skm.final_clusters_syll_list\n\n gen_skm = syllogistickmeans.SyllogisticKMeans(1)\n gen_skm.add_syllogistic_data(data=pd_dataset)\n\n gen_skm.generate_clusters(cutoff=self.cutoff)\n\n self.current_k_cluster = gen_skm.final_clusters_syll_list[0]","def supervise_learning(self):\n if self._multi_leiden_clusters is None:\n raise ValueError(\n \"Run multi_leiden_clustering first to get a \" \"clustering assignment before run supervise_learning.\"\n )\n\n n_cluster = np.unique(self._multi_leiden_clusters[self._multi_leiden_clusters != -1]).size\n if n_cluster == 1:\n print(\"There is only one cluster except for outliers, can not train supervise model on that.\")\n self.label = np.zeros(self.n_obs, dtype=int)\n return\n print(\"\\n=== Start supervise model training and cluster merging ===\")\n\n x = self.X\n cur_y = self._multi_leiden_clusters.copy()\n score = None\n step = 0.1\n\n if self.supervise_model is None:\n # create default model if no model provided\n clf = self._create_model(n_estimators=500)\n else:\n clf = self.supervise_model\n for cur_iter in range(1, self.max_iter + 1):\n print(f\"\\n=== iteration {cur_iter} ===\")\n n_labels = np.unique(cur_y[cur_y != -1]).size\n print(f\"{n_labels} non-outlier labels\")\n if n_labels < 2:\n print(f\"Stop iteration because only {n_labels} cluster remain.\")\n break\n\n x_train, y_train, x_test, y_test = _split_train_test_per_group(\n x=x,\n y=cur_y,\n frac=self.train_frac,\n max_train=self.train_max_n,\n random_state=self.random_state + cur_iter,\n # every time train-test split got a different random state\n )\n (\n clf,\n score,\n cluster_map,\n cmat,\n r1_cmat,\n r2_cmat,\n ) = single_supervise_evaluation(\n clf,\n x_train,\n y_train,\n x_test,\n y_test,\n r1_norm_step=step,\n r2_norm_step=step,\n )\n step = min(0.2, max(0.05, 2 * (self.target_accuracy - score)))\n\n # save step data for plotting\n self.step_data[cur_iter] = [\n cur_y,\n cmat,\n r1_cmat,\n r2_cmat,\n cluster_map,\n score,\n step,\n ]\n\n if score > self.target_accuracy:\n print(\n f\"Stop iteration because current accuracy {score:.3f}\"\n f\" > target accuracy {self.target_accuracy:.3f}.\"\n )\n break\n\n # judge results\n if len(cluster_map) > 0:\n print(f\"Merging {len(cluster_map)} clusters.\")\n cur_y = pd.Series(cur_y).apply(lambda i: cluster_map[i] if i in cluster_map else i)\n # renumber labels from large to small\n ordered_map = {c: i for i, c in enumerate(cur_y[cur_y != -1].value_counts().index)}\n cur_y = pd.Series(cur_y).apply(lambda i: ordered_map[i] if i in ordered_map else i).values\n else:\n print(\"Stop iteration because there is no cluster to merge\")\n break\n else:\n print(\"Stop iteration because reaching maximum iteration.\")\n self._label_with_leiden_outliers = cur_y\n self.label = cur_y\n self.supervise_model = clf\n self.final_accuracy = score\n return","def data_split(self, split_index=0, thinning=None, apply_mask=False, mask=[], **kwargs):\n \n self.learn_sets = ['train','vali','test']\n self.ind_train = self.train_splitdict[split_index]\n self.ind_train.sort()\n self.ind_test = self.test_splitdict[split_index]\n self.ind_test.sort()\n if len(self.vali_splitdict) !=0:\n self.learn_sets = ['train','vali','test']\n self.ind_vali = self.vali_splitdict[split_index]\n self.ind_vali.sort()\n self.indices_learn_dict = dict(zip(self.learn_sets, [self.ind_train, self.ind_vali, self.ind_test]))\n else:\n self.learn_sets = ['train','test']\n self.indices_learn_dict = dict(zip(self.learn_sets, [self.ind_train, self.ind_test]))\n\n\n self.train_samples = self.fullspace[self.ind_train]\n self.train_size = len(self.train_samples)\n\n if len(self.vali_splitdict) !=0:\n self.vali_samples = self.fullspace[self.ind_vali]\n self.vali_samples.sort()\n self.vali_size = len(self.vali_samples)\n else:\n self.vali_size = 0\n self.test_samples = self.fullspace[self.ind_test]\n #self.test_samples.sort()\n self.test_size = len(self.test_samples)\n verbosity = kwargs.get('verbosity', 1)\n\n too.condprint(\"number of obtained training vectors\", self.train_size, level=1, verbosity=verbosity)\n too.condprint(\"number of obtained validation vectors\", self.vali_size, level=1, verbosity=verbosity)\n too.condprint(\"number of obtained test vectors\", self.test_size, level=2, verbosity=verbosity)\n\n\n self.matrix_datalearn_dict = dict()\n\n for dli in self.learn_sets:\n matrixdata = np.copy(self.matrix_z)\n self.matrixdata=matrixdata\n\n ## copy of mask to avoid modifying orginal mask after iterations\n if apply_mask==False:\n maskcopy=np.arange(0,len(matrixdata[0])) ##range over all axis length, does not mask anything\n else:\n maskcopy=np.copy(mask)\n \n ## apply thinning (if set to None, there is no thinning)\n self.mask_true=maskcopy[::thinning] \n\n ## apply mask also to feature grid and save as masked_+...\n setattr(self, 'masked_'+self.features_str, self.fgrid[self.mask_true]) \n\n matrixdata = matrixdata[:,self.mask_true] ## apply mask and thinning to feature space (k-grid)\n indices_l = self.indices_learn_dict[dli]\n matrixdata = matrixdata[indices_l,:] ##choose learning set\n self.matrix_datalearn_dict[dli] = matrixdata\n self.matrix_datalearn_dict = objdict(self.matrix_datalearn_dict)\n return self.matrix_datalearn_dict","def main():\n # Read in trainingSet and testSet as a DataFrame\n trainingOriginal = pd.read_csv(\n filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.train.5fold.csv\")\n testOriginal = pd.read_csv(filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.test.csv\")\n\n # Select only the numeric data\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\n training = pd.concat([training.reset_index(drop=True),\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Select only the numeric data\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\n test = pd.concat([test.reset_index(drop=True),\n testOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Normalize the columns for training and test\n # print training['age'].min()\n # print training['age'].max()\n # print training.head()\n\n # Run max-min normalization on numerical columns for testing and training data\n for i in range(6):\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\n\n # Convert the 'earns' column to boolean as follows\n training['earns'] = training['earns'] == '>50K'\n test['earns'] = test['earns'] == ' >50K'\n\n # Group the training set by the fold attribute as given by the dataset\n trainingForFinal = training\n training = training.groupby('fold')\n\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\n kList = []\n for i in range(40):\n if i % 2 == 1:\n kList.append(i)\n\n # Empty dictionary to hold performance of each k-values and its accuracy\n performance = {}\n\n # Compute the performance for each k-value\n for k in kList:\n performance = crossValidation(training, k, performance)\n\n # Sort the performance dictionary by its accuracy (value)\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\n\n # Open file to write results\n file = open('grid.results.txt', 'w')\n # Write the results to file\n file.write(\"K | Accuracy\\n\")\n for item in performance:\n if item[0] < 10:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n else:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n # Close file\n file.close()\n\n # The best K is the one at the top of the list after the sorting\n bestK = performance[0][0]\n\n print 'Running Test Set with K = ' + str(bestK)\n\n applyModel(test,trainingForFinal,bestK)","def train(self, data):\n\t\tepsilon = self.epsilon\n\t\ttempDist = 1.0\n\t\tk = self.k\n\t\tcenters = data.rdd.takeSample(False, k, 1)\n\t\ti = 0 \n\t\twhile tempDist > epsilon or self.maxNoOfIteration > i:\n\t\t\ti+=1\t\t\t\n\t\t\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\n \t\t\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\n \t\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\n \t\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\n \t\tfor (ind, p) in newPoints:\n\t\t\t\tcenters[ind] = p\n\t\tself.centers = centers\n\t\treturn self.centers","def main(source_dir, ksplit, out_dir, data_pattern, label_pattern, test_mode,\r\n numTopVars = [10, 50, 100, 500, 1000], compute_results=True):\r\n # Load input and labels.\r\n data, labels, data_file = load_data(source_dir, data_pattern)\r\n filename_base = path.splitext(path.basename(mname))[0]\r\n # Get classifiers and params.\r\n global NAMES\r\n if test_mode:\r\n NAMES = [\"Chance\", \"Nearest Neighbors\", \"Linear SVM\", \"Decision Tree\",\r\n \"Logistic Regression\", \"Naive Bayes\", \"LDA\"]\r\n ksplit = 3\r\n\r\n classifiers, params = make_classifiers(NAMES) # data.shape, ksplit)\r\n\r\n\r\n # Make the folds.\r\n logging.info(\"Making %d folds\" % ksplit)\r\n #kf = StratifiedKFold(labels, n_folds=ksplit)\r\n kf = KFold(labels.shape[0], n_folds=ksplit)\r\n\r\n # Extract the training and testing indices from the k-fold object,\r\n # which stores fold pairs of indices.\r\n fold_pairs = [(tr, ts) for (tr, ts) in kf]\r\n assert len(fold_pairs) == ksplit\r\n rank_per_fold = get_rank_per_fold(data, labels, fold_pairs,\r\n save_path=out_dir, parallel=True)\r\n #dhjelm: were we planning on using this dict?\r\n #score={}\r\n dscore=[]\r\n totalErrs = []\r\n if compute_results:\r\n for name in NAMES:\r\n mdl = classifiers[name]\r\n param = params[name]\r\n # get_score runs the classifier on each fold,\r\n # each subset of selected top variables and does a grid search for\r\n # classifier-specific parameters (selects the best)\r\n clf, allConfMats, allTotalErrs, allFittedClassifiers = \\\r\n get_score(data, labels, fold_pairs, name, mdl, param,\r\n numTopVars=numTopVars,\r\n rank_per_fold=rank_per_fold, parallel=True,\r\n rand_iter=-1)\r\n # save classifier object and results to file\r\n save_classifier_results(name, out_dir, allConfMats,\r\n allTotalErrs)\r\n save_classifier_object(clf, allFittedClassifiers, name, out_dir)\r\n # Append classifier results to list of all results\r\n dscore.append(allConfMats)\r\n totalErrs.append(allTotalErrs)\r\n '''\r\n First do some saving of total results\r\n '''\r\n save_combined_results(NAMES, dscore, totalErrs,\r\n numTopVars, out_dir, filename_base)\r\n\r\n plot_errors(NAMES, numTopVars, dscore, totalErrs,\r\n filename_base, out_dir,compute_results)\r\n\r\n logging.shutdown()","def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\n distribute_training=False):\n train_set = np.array(train_set)\n test_set = np.array(test_set)\n\n print(\"The shape of training set before dimension reduction is {0}\".format(train_set.shape))\n print(\"The shape of test set before dimension reduction is {0}\".format(test_set.shape))\n print('Use distribute training ? >> {0}'.format(distribute_training))\n reg = linear_model.BayesianRidge()\n\n if dimension_reduce:\n pca = PCA(n_components=128)\n train_set = pca.fit_transform(train_set)\n test_set = pca.fit_transform(test_set)\n\n print(\"The shape of training set after dimension reduction is {0}\".format(train_set.shape))\n print(\"The shape of test set after dimension reduction is {0}\".format(test_set.shape))\n\n if not distribute_training:\n reg.fit(train_set, train_label)\n else:\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\n train_label), da.array(test_label)\n reg.fit(train_set, train_label)\n\n predicted_label = reg.predict(test_set)\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\n\n mkdirs_if_not_exist('./model')\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\n print('The regression model has been persisted...')\n\n mkdirs_if_not_exist('./result')\n\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\n\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\n df.to_csv('./result/%s.csv' % data_name, index=False)\n print('The result csv file has been generated...')","def prepare_nfold_datasets(self): # i.e. split into different train/ground-truth(test) dataset\n for alpha in range(1, self.ALPHAs+1):\n if alpha != self.ALPHAs:\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI], separator='-')\n else:\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI+self.runoff_years], separator='-')\n new_cluster_dir = str(Path(self.tl_model.cluster_dir) / f'alpha_{alpha}_GT-{gt_years}')\n os.makedirs(new_cluster_dir, exist_ok=True)\n\n new_prepared_data_dir = str(Path(self.tl_model.prepared_data_dir) / f'alpha_{alpha}')\n os.makedirs(new_prepared_data_dir, exist_ok=True)\n \n if utils.find(f'*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir) and utils.find(f'*alpha_{alpha}_standardized_stacked_arr.pkl', new_prepared_data_dir):\n pass\n else:\n if not utils.find(f'*target*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\n print(f\"=> No input datasets pre-processed for alpha of {alpha}\")\n prepare.cut_target_dataset(self, alpha, new_prepared_data_dir)\n\n if not utils.find(f'*rf*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\n print(f\"=> No rainfall datasets pre-processed for alpha of {alpha}\")\n prepare.cut_rf_dataset(self, alpha, new_prepared_data_dir)\n \n print(f'Preprocessed pickles for alpha split {alpha} can be found @:\\n{new_prepared_data_dir}')","def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\n self.merge_clusters([[6,98,99]])\n self.merge_clusters([[35,80]])\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\n self.merge_clusters([[76,98]])\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\n self.merge_clusters([[39,42]])\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\n self.merge_clusters([[70,101]])\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\n self.merge_clusters()\n return","def calculate_data_split(self, n_train=2, n_vali=0, n_test=1, n_splits=1,\n num_percentiles=4, random_state=87, verbosity=1,\n manual_split=False,train_indices=None, test_indices=None,\n train_redshift_indices=[0], test_redshift_indices=[0],\n interpolate_over_redshift_only=False, **kwargs):\n \n n_extrema=kwargs.get('n_extrema', 2)\n ind_extrema=kwargs.get('ind_extrema', [0,-1])\n self.data_separation(n_extrema=n_extrema, ind_extrema=ind_extrema)\n\n too.condprint(\"number of wanted training vectors\", n_train, level=2, verbosity=verbosity)\n too.condprint(\"number of wanted test vectors\", n_test, level=1, verbosity=verbosity)\n if n_train+n_test > (self.size_fullspace):\n print(\"Warning n_train is larger than total full sample space\")\n\n self.random_state = random_state\n self.num_percentiles = num_percentiles\n self.n_splits = n_splits\n\n stratif_labels = self.stratify_array(self.midspace, num_percentiles=self.num_percentiles)\n self.test_splitdict = dict()\n self.train_splitdict = dict()\n self.vali_splitdict = dict()\n\n if manual_split == False:\n n_vali = self.size_midspace-n_test-n_train\n if n_vali !=0 and len(self.ind_midspace)> 1:\n kf = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=n_test, random_state=self.random_state)\n for ii, (trainvali, test) in enumerate(kf.split(self.midspace,stratif_labels)):\n #test = test[np.in1d(test, extspace_ind, invert=True)]\n\n test = self.ind_midspace[test]\n if n_train > 0:\n train, valitest = train_test_split(trainvali, test_size=n_vali, shuffle=True, random_state=self.random_state)\n train = self.ind_midspace[train]\n train = np.unique(np.concatenate([train,self.ind_extremaspace]))\n train = self.ind_fullspace[train]\n else:\n train = self.ind_extremaspace\n train = self.ind_fullspace[train]\n valitest=trainvali\n\n #valitest = valitest[np.in1d(valitest, extspace_ind, invert=True)]\n valitest = self.ind_midspace[valitest]\n #print(test, trr, \" s tr\", len(train)-2, \" tr: \", train, \" va: \", valitest)\n self.test_splitdict[ii] = test\n self.vali_splitdict[ii]= valitest\n self.train_splitdict[ii] = train\n elif len(self.ind_midspace)> 1 and n_vali == 0:\n kf = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=n_test, random_state=self.random_state)\n for ii, (train, test) in enumerate(kf.split(self.midspace,stratif_labels)):\n test = self.ind_midspace[test]\n train = self.ind_midspace[train]\n train = np.unique(np.concatenate([train,self.ind_extremaspace]))\n train = self.ind_fullspace[train]\n self.test_splitdict[ii] = test\n self.train_splitdict[ii] = train\n\n else:\n test = self.ind_midspace\n train = self.ind_extremaspace\n self.test_splitdict[0] = test\n self.train_splitdict[0] = train\n \n ###/!\\ Warning /!\\ For now we always use manual split (which not really manual now...)\n elif manual_split == True:\n ### Determine the number of samples avaible with different values of parameters. e.g nb_param = 101 for MassiveNus\n nb_param = int(len(self.fullspace)/len(self.z_requested)) \n if len(self.z_requested)==1:\n nb_param = int(len(self.fullspace))\n \n\n for ii in range (n_splits):\n ###Here the user has chosen to provide the test indices\n if test_indices is not None:\n test_indices = np.atleast_2d(test_indices)\n test = test_indices[ii]\n ###We make sure that the indice lies into a correct space. e.g if we have nb_param = 101, and a indices i = 103 it will become i =2\n test_origin = [tt%nb_param for tt in test]\n \n ###Do we want to construct a interpolation only over the redshift ? /!\\ Warning /!\\ this is case is not really used....\n if interpolate_over_redshift_only == False and train_indices is None:\n train_origin = [ii for ii in range(1,nb_param-1) if ii not in test_origin ]\n\n elif interpolate_over_redshift_only == False and train_indices is not None:\n train_origin = [tt%nb_param for tt in train ]\n else :\n train_origin = test_origin\n ###Here the user has chosen not to provide the test indices\n ## so we first randomly generate them\n else:\n if train_indices is None:\n test_origin = [ii for ii in range(1,nb_param-1)]\n test_origin = shuffle(test_origin)[:n_test]\n if interpolate_over_redshift_only == False:\n train_origin = [ii for ii in range(1,nb_param-1) if ii not in test_origin ]\n else:\n train_origin = test_origin\n ###The user has specified train indices so must be sure that train and test do not overlap !\n else:\n train_indices = np.atleast_2d(train_indices)\n train = train_indices[ii]\n train_origin = [tt%nb_param for tt in train ]\n test_origin = [ii for ii in range(1,nb_param-1) if ii not in train_origin ] ####!!!\n \n train_origin = shuffle(train_origin)\n \n train_origin = train_origin[:n_train]\n test_origin = shuffle(test_origin)[:n_test]\n if train_indices is None:\n if [0] not in test_origin:\n train_origin +=[0]\n if [nb_param-1]not in test_origin:\n \n train_origin += [nb_param-1]\n if [0] in test_origin or [nb_param-1] in test_origin :\n print(\"Warning : trying to interpolate a extramal value\")\n \n\n train_redshift = self.z_requested[train_redshift_indices]\n test_redshift = self.z_requested[test_redshift_indices]\n self.train_redshift = train_redshift \n self.test_redshift = test_redshift\n too.condprint(\"redshift used for training\", train_redshift,level=1,verbosity=verbosity)\n too.condprint(\"redshfit used for testing\", test_redshift,level=1,verbosity=verbosity)\n train = []\n test = []\n ### looping over the redshift \n for zz in train_redshift_indices:\n train+= [ii + zz*nb_param for ii in train_origin ]\n\n for zz in test_redshift_indices: \n test += [ii + zz*nb_param for ii in test_origin ]\n \n\n self.train_splitdict[ii] = train\n self.test_splitdict[ii] = test\n shuffled = shuffle(train)\n self.train_splitdict[ii] = shuffled\n self.vali_splitdict[ii] = shuffled\n\n return None","def __init__(self, conn, args, data, split_type, num_clusters):\n\n self.conn = conn\n self.args = args\n self.data = data\n self.split_type = split_type\n\n self.pca_model = None\n self.cluster_model = None\n self.algorithm = args['cluster_algorithm']\n\n # http://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html\n hdbsc = hdbscan.HDBSCAN(min_cluster_size=10)\n affinity_propagation = cluster.AffinityPropagation()\n ms = cluster.MeanShift(bin_seeding=True)\n spectral = cluster.SpectralClustering(n_clusters=num_clusters, \n eigen_solver='arpack',\n affinity=\"nearest_neighbors\", \n random_state=self.args['seed'])\n ward = cluster.AgglomerativeClustering(n_clusters=num_clusters, \n linkage='ward')\n birch = cluster.Birch(n_clusters=num_clusters)\n two_means = cluster.MiniBatchKMeans(n_clusters=num_clusters,\n random_state=self.args['seed'])\n average_linkage = cluster.AgglomerativeClustering(linkage=\"average\", \n n_clusters=num_clusters)\n hdbsc = hdbscan.HDBSCAN(min_cluster_size=10)\n kmeans = cluster.KMeans(n_clusters=num_clusters, random_state=self.args['seed'])\n dbscan = cluster.DBSCAN()\n \n self.clustering_algorithms = {\n 'MiniBatchKMeans': two_means,\n 'AffinityPropagation': affinity_propagation,\n 'MeanShift': ms,\n 'SpectralClustering': spectral,\n 'Ward': ward,\n 'AgglomerativeClustering': average_linkage,\n 'DBSCAN': dbscan,\n 'Birch': birch,\n 'HDBSCAN': hdbsc,\n 'KMeans': kmeans\n }","def kmeans_001(fit_centroids=False):\n trainX = np.memmap('data/train_cropped_150.memmap', mode='r', shape=(N_TRAIN, 150, 150, 3))\n # Not used yet\n testX = np.memmap('data/test_cropped_150.memmap', mode='r', shape=(N_TEST, 150, 150, 3))\n\n if fit_centroids:\n km = models.KMeansFeatures.KMeansFeatures(rf_size=6, num_centroids=1600, num_patches=400000)\n km.fit(trainX)\n\n km.save_to_file('mdl_kmeans_ridge_rf_001')\n # t0 = time.time()\n # pickle.dump(km, open('data/kmeans_centroids.pkl', mode='wb'))\n # print 'Pickling the KMeansFeatures object took {0} seconds'.format(time.time() - t0)\n else:\n km = models.KMeansFeatures.KMeansFeatures.load_from_file('mdl_kmeans_ridge_rf_001')\n # km = pickle.load(open('data/kmeans_centroids.pkl'))\n\n n = 10000\n\n train_x = km.transform(trainX[0:n, :])\n train_y = classes.train_solutions.data[0:n, :]\n # train_x = km.transform(trainX)\n # train_y = classes.train_solutions.data\n\n logger.info(\"Train x shape: {}\".format(train_x.shape))\n logger.info(\"Train y shape: {}\".format(train_y.shape))\n\n kf = KFold(n, n_folds=2, shuffle=True)\n\n for train, test in kf:\n # clf = models.Ridge.RidgeRFEstimator()\n # clf.rf_rgn = RandomForestRegressor(n_estimators=250, n_jobs=4, verbose=3)\n clf = RandomForestRegressor(n_estimators=20, n_jobs=4, verbose=3, random_state=0, oob_score=True)\n clf.fit(train_x[train], train_y[train])\n res = clf.predict(train_x[test])\n classes.rmse(train_y[test], res)","def prepareSplitClassifier(df, models, choice):\n\n\n def classificationOutput(clf, X, Y):\n \"\"\"\n Fit the model and print the classification results\n - confusion_matrix\n - avg scores etc\n \"\"\"\n n_samples = 36\n\n print \"\\n\\nClassifier: \\n %s\" % (clf)\n print \"#\" * 79\n # classifier_gnb = naive_bayes.GaussianNB() # initiating the classifier\n\n clf.fit(X[:n_samples], Y[:n_samples]) # train on first n_samples and test on last 10\n\n expected = Y[n_samples:]\n predicted = clf.predict(X[n_samples:])\n print(\"Classification report:\\n%s\\n\" % (metrics.classification_report(expected, predicted)))\n print(\"\\nConfusion matrix:\\n%s\" % metrics.confusion_matrix(expected, predicted))\n\n\n\n\n def splitclassify(cDf):\n \"\"\"\n Given the dataframe combined with equal fair and unfair apps,\n classify them\n \"\"\"\n cDf = cDf.reindex(np.random.permutation(cDf.index)) # shuffle the dataframe\n featCols = set(cDf.columns)\n featCols.remove('appLabel')\n\n features = cDf[list(featCols)].astype('float')\n\n ## Scale the features to a common range\n min_max_scaler = preprocessing.MinMaxScaler()\n X = min_max_scaler.fit_transform(features.values)\n\n Y = cDf['appLabel'].values\n\n\n if choice == 'all':\n for key in models:\n classifier = models[key]\n classificationOutput(classifier, X, Y)\n else:\n if choice in models:\n classifier = models[choice]\n classificationOutput(classifier, X, Y)\n else:\n print \"Incorrect Choice\"\n\n\n\n fairDf = df[df['appLabel'] == False]\n unfairDf = df[df['appLabel'] == True]\n\n\n # calculate total possible splits of fair data frame relatie to\n # size of unfair dataframe\n splits = len(fairDf) // len(unfairDf)\n\n for i in range(splits):\n clDf = fairDf[i : i+len(unfairDf)].append(unfairDf)\n\n # print fairDf.values, unfairDf.values\n print \"Classifying %d th split of fair apps with unfair app\" % (i)\n print \"-\" * 79\n splitclassify(clDf)\n print \"\\n\\n\"","def train_k():\n\n for i in range(n_families):\n print('[training-k] family:', i, '...')\n f1_fam_name = 'f1_fam_' + str(i) + '_features'\n feature_mat_fam1 = mask_features(f1_fam_name)\n n_samples = len(feature_mat_fam1)\n # use 80% of samples as training set\n feature_mat_fam1 = feature_mat_fam1[int(n_samples / 5):, :]\n my_k, my_result = train_with_inner_outer(feature_mat_fam1, 0)\n\n save_name = '/f1_fam_' + str(i) + '_validation'\n with open(saved_cluster_path + save_name, 'wb') as fp:\n pickle.dump(my_result, fp)","def stepwise_regression(train_per_list, cut_off_list, C_list,\n factors,non_factors, data_path, executable_path):\n sql_table = 'aggregated_ctr' #Data table\n sql_features = list(set(sum([fs.split('*') for fs in factors], [])))\n # remove cross terms\n\n factors+=['campaign_id','ad_account_id','pub_account_id', \n 'campaign_id*site', 'ad*pub_account_id']\n con_dict_mad={'host':'db.lqm.io','db':'madvertise_production',\n 'user':'readonly','passwd':'z0q909TVZj'}\n con_dict_dse={'host':'db.lqm.io','db':'dse','user':'dse','passwd':'dSe@lQm'}\n rtb_flag=[0,1]\n \n test_per_list= map(lambda x: ( add_hour(x[1], 1), add_hour(x[1], 3)), train_per_list)\n \n # test period is next 3 hours after end of training period\n # DATA RANGE IS INCLUSIVE => 00:00-02:00 = 3 HOURS\n MySQL_save_data_loop(con_dict_dse, sql_table,\n train_per_list, sql_features, rtb_flag, data_path)\n MySQL_save_data_loop(con_dict_dse, sql_table,\n test_per_list, sql_features, rtb_flag, data_path)\n \n model_type=0\n has_intercept = True # bias term in LR\n tol = 0.00000001\n\n # NB these filenames are HARDCODED in write_sparse routines\n weights_file = 'train_ais.txt'\n train_file = 'train_svm.txt'\n test_file = 'test_svm.txt'\n probability_file = 'preds_SummModel_py.txt'\n\n \n res_df_list=[]\n trial_factors=[]\n remaining_factors=factors[:]\n while len(remaining_factors):\n results = [] \n # we assume we cannot load all the data in memory\n # so we have to reload for every step of stepwise selection\n for train_per, test_per in zip(train_per_list, test_per_list):\n \n train_df=load_data(data_path,train_per)\n test_df=load_data(data_path,test_per)\n \n sc, click_no_click_df, weights, targets \\\n = libLinear_functions.create_sparse_cat(train_df, factors, non_factors)\n \n for cut_off in cut_off_list:\n sparse_train_all = libLinear_functions.create_sparse(sc, cut_off, click_no_click_df)\n sparse_test_all = sc.transform(test_df)\n for fac in remaining_factors:\n trial_factors.append(fac)\n trial_factors.sort(key=lambda x: sc.factors.index(x))\n # libsvm expects the indices in ascending order\n print (trial_factors) \n sparse_train=sc.select_factors(sparse_train_all, trial_factors)\n sparse_test=sc.select_factors(sparse_test_all, trial_factors)\n libLinear_functions.write_sparse(sc, sparse_train, weights, targets, data_path, len(trial_factors))\n libLinear_functions.write_sparse_test(sc, sparse_test, data_path, n_columns_used= len(trial_factors))\n\n for C in C_list:\n model_file = \\\n '{start}_{stop}_cut_{cut_off}_C_{C:0.3}.model'.format(\n start=date_name(train_per[0]),\n stop=date_name(train_per[1]),\n cut_off=cut_off, C=C)\n fit(executable_path, data_path, train_file,\n model_file, weights_file, model_type, reg_param=C, tol=tol,\n has_intercept=has_intercept)\n \n pCTR = libLinear_functions.predict(\n executable_path, data_path, test_file,\n model_file, probability_file)\n if type(pCTR) is pd.Series:\n amounts = pd.DataFrame({\n 'no_clicks':test_df['instances' ]-test_df['clicks'],\n 'clicks':test_df['clicks']})\n mean_log_loss, weighted_log_loss =\\\n libLinear_functions.log_loss_weighted(pCTR, amounts)\n results.append([train_per[:], tuple(trial_factors),fac, cut_off, C, mean_log_loss])\n # what to do if ERROR?\n trial_factors.remove(fac)\n res_df=pd.DataFrame(results,columns=['train_per','factors','add_factor','cut_off','C','mean_log_loss'])\n res_avg=res_df.groupby(['factors','add_factor','cut_off','C']).agg([np.mean,np.std])\n best_params=res_avg['mean_log_loss','mean'].argmin()\n best_fac=best_params[1]\n remaining_factors.remove(best_fac)\n trial_factors.append(best_fac)\n res_df_list.append(res_df)\n results_df=pd.concat(res_df_list)\n return results_df","def partition_data(dataset, datadir, logdir, partition, n_parties, beta=0.4):\n if dataset == 'mnist':\n X_train, y_train, X_test, y_test = load_mnist_data(datadir)\n elif dataset == 'fmnist':\n X_train, y_train, X_test, y_test = load_fmnist_data(datadir)\n elif dataset == 'cifar10':\n X_train, y_train, X_test, y_test = load_cifar10_data(datadir)\n elif dataset == 'svhn':\n X_train, y_train, X_test, y_test = load_svhn_data(datadir)\n elif dataset == 'celeba':\n X_train, y_train, X_test, y_test = load_celeba_data(datadir)\n elif dataset == 'femnist':\n X_train, y_train, u_train, X_test, y_test, u_test = load_femnist_data(datadir)\n elif dataset == 'cifar100':\n X_train, y_train, X_test, y_test = load_cifar100_data(datadir)\n elif dataset == 'tinyimagenet':\n X_train, y_train, X_test, y_test = load_tinyimagenet_data(datadir)\n print(\"y_train\",y_train.shape)\n print(\"y_test\",y_test.shape)\n\n elif dataset == 'generated':\n X_train, y_train = [], []\n for loc in range(4):\n for i in range(1000):\n p1 = random.random()\n p2 = random.random()\n p3 = random.random()\n if loc > 1:\n p2 = -p2\n if loc % 2 ==1:\n p3 = -p3\n if i % 2 == 0:\n X_train.append([p1, p2, p3])\n y_train.append(0)\n else:\n X_train.append([-p1, -p2, -p3])\n y_train.append(1)\n X_test, y_test = [], []\n for i in range(1000):\n p1 = random.random() * 2 - 1\n p2 = random.random() * 2 - 1\n p3 = random.random() * 2 - 1\n X_test.append([p1, p2, p3])\n if p1>0:\n y_test.append(0)\n else:\n y_test.append(1)\n X_train = np.array(X_train, dtype=np.float32)\n X_test = np.array(X_test, dtype=np.float32)\n y_train = np.array(y_train, dtype=np.int32)\n y_test = np.array(y_test, dtype=np.int64)\n idxs = np.linspace(0,3999,4000,dtype=np.int64)\n batch_idxs = np.array_split(idxs, n_parties)\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\n mkdirs(\"data/generated/\")\n np.save(\"data/generated/X_train.npy\",X_train)\n np.save(\"data/generated/X_test.npy\",X_test)\n np.save(\"data/generated/y_train.npy\",y_train)\n np.save(\"data/generated/y_test.npy\",y_test)\n \n #elif dataset == 'covtype':\n # cov_type = sk.fetch_covtype('./data')\n # num_train = int(581012 * 0.75)\n # idxs = np.random.permutation(581012)\n # X_train = np.array(cov_type['data'][idxs[:num_train]], dtype=np.float32)\n # y_train = np.array(cov_type['target'][idxs[:num_train]], dtype=np.int32) - 1\n # X_test = np.array(cov_type['data'][idxs[num_train:]], dtype=np.float32)\n # y_test = np.array(cov_type['target'][idxs[num_train:]], dtype=np.int32) - 1\n # mkdirs(\"data/generated/\")\n # np.save(\"data/generated/X_train.npy\",X_train)\n # np.save(\"data/generated/X_test.npy\",X_test)\n # np.save(\"data/generated/y_train.npy\",y_train)\n # np.save(\"data/generated/y_test.npy\",y_test)\n\n elif dataset in ('rcv1', 'SUSY', 'covtype'):\n X_train, y_train = load_svmlight_file(\"../../../data/{}\".format(dataset))\n X_train = X_train.todense()\n num_train = int(X_train.shape[0] * 0.75)\n if dataset == 'covtype':\n y_train = y_train-1\n else:\n y_train = (y_train+1)/2\n idxs = np.random.permutation(X_train.shape[0])\n\n X_test = np.array(X_train[idxs[num_train:]], dtype=np.float32)\n y_test = np.array(y_train[idxs[num_train:]], dtype=np.int32)\n X_train = np.array(X_train[idxs[:num_train]], dtype=np.float32)\n y_train = np.array(y_train[idxs[:num_train]], dtype=np.int32)\n\n mkdirs(\"data/generated/\")\n np.save(\"data/generated/X_train.npy\",X_train)\n np.save(\"data/generated/X_test.npy\",X_test)\n np.save(\"data/generated/y_train.npy\",y_train)\n np.save(\"data/generated/y_test.npy\",y_test)\n\n elif dataset in ('a9a'):\n X_train, y_train = load_svmlight_file(\"../../../data/{}\".format(dataset))\n X_test, y_test = load_svmlight_file(\"../../../data/{}.t\".format(dataset))\n X_train = X_train.todense()\n X_test = X_test.todense()\n X_test = np.c_[X_test, np.zeros((len(y_test), X_train.shape[1] - np.size(X_test[0, :])))]\n\n X_train = np.array(X_train, dtype=np.float32)\n X_test = np.array(X_test, dtype=np.float32)\n y_train = (y_train+1)/2\n y_test = (y_test+1)/2\n y_train = np.array(y_train, dtype=np.int32)\n y_test = np.array(y_test, dtype=np.int32)\n\n mkdirs(\"data/generated/\")\n np.save(\"data/generated/X_train.npy\",X_train)\n np.save(\"data/generated/X_test.npy\",X_test)\n np.save(\"data/generated/y_train.npy\",y_train)\n np.save(\"data/generated/y_test.npy\",y_test)\n\n\n n_train = y_train.shape[0]\n \n if partition == \"manual\":\n label_idxs = {i:[] for i in np.unique(y_train)}\n label_node_map = {i:[] for i in label_idxs.keys()} \n label_node_map[0] = [0,5,10,15,20]\n label_node_map[1] = [0,5,10,15,20]\n label_node_map[2] = [1,6,11,16,21]\n label_node_map[3] = [1,6,11,16,21]\n label_node_map[4] = [2,7,12,17,22]\n label_node_map[5] = [2,7,12,17,22]\n label_node_map[6] = [3,8,13,18,23]\n label_node_map[7] = [3,8,13,18,23]\n label_node_map[8] = [4,9,14,19]\n label_node_map[9] = [4,9,14,19]\n\n \n for i,label in enumerate(y_train):\n label_idxs[label].append(i)\n \n net_dataidx_map = {i:[] for i in range(n_parties)}\n for label, idxs in label_idxs.items():\n batch_idxs = np.array_split(idxs, len(label_node_map[label]))\n for i, net_id in enumerate(label_node_map[label]):\n net_dataidx_map[net_id] += list(batch_idxs[i])\n \n\n if partition == \"homo\":\n idxs = np.random.permutation(n_train)\n batch_idxs = np.array_split(idxs, n_parties)\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\n \n\n\n elif partition == \"noniid-labeldir\":\n min_size = 0\n min_require_size = 10\n K = 10\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\n K = 2\n elif dataset in ('tinyimagenet'):\n K = 200\n # min_require_size = 100\n elif dataset in ('cifar100'):\n K = 100\n\n N = y_train.shape[0]\n #np.random.seed(2020)\n net_dataidx_map = {}\n\n while min_size < min_require_size:\n idx_batch = [[] for _ in range(n_parties)]\n for k in range(K):\n idx_k = np.where(y_train == k)[0]\n np.random.shuffle(idx_k)\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\n # logger.info(\"proportions1: \", proportions)\n # logger.info(\"sum pro1:\", np.sum(proportions))\n ## Balance\n proportions = np.array([p * (len(idx_j) < N / n_parties) for p, idx_j in zip(proportions, idx_batch)])\n # logger.info(\"proportions2: \", proportions)\n proportions = proportions / proportions.sum()\n # logger.info(\"proportions3: \", proportions)\n proportions = (np.cumsum(proportions) * len(idx_k)).astype(int)[:-1]\n # logger.info(\"proportions4: \", proportions)\n idx_batch = [idx_j + idx.tolist() for idx_j, idx in zip(idx_batch, np.split(idx_k, proportions))]\n min_size = min([len(idx_j) for idx_j in idx_batch])\n # if K == 2 and n_parties <= 10:\n # if np.min(proportions) < 200:\n # min_size = 0\n # break\n\n\n for j in range(n_parties):\n np.random.shuffle(idx_batch[j])\n net_dataidx_map[j] = idx_batch[j]\n\n elif partition > \"noniid-#label0\" and partition <= \"noniid-#label9\":\n num = eval(partition[13:])\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\n num = 1\n K = 2\n else:\n K = 10\n if dataset == \"cifar100\":\n K = 100\n elif dataset == \"tinyimagenet\":\n K = 200\n if num == 10:\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\n for i in range(10):\n idx_k = np.where(y_train==i)[0]\n np.random.shuffle(idx_k)\n split = np.array_split(idx_k,n_parties)\n for j in range(n_parties):\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[j])\n else:\n times=[0 for i in range(K)]\n contain=[]\n for i in range(n_parties):\n current=[i%K]\n times[i%K]+=1\n j=1\n while (j<num):\n ind=random.randint(0,K-1)\n if (ind not in current):\n j=j+1\n current.append(ind)\n times[ind]+=1\n contain.append(current)\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\n for i in range(K):\n idx_k = np.where(y_train==i)[0]\n np.random.shuffle(idx_k)\n split = np.array_split(idx_k,times[i])\n ids=0\n for j in range(n_parties):\n if i in contain[j]:\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[ids])\n ids+=1\n\n\n elif partition == \"iid-diff-quantity\":\n idxs = np.random.permutation(n_train)\n min_size = 0\n while min_size < 10:\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\n proportions = proportions/proportions.sum()\n min_size = np.min(proportions*len(idxs))\n proportions = (np.cumsum(proportions)*len(idxs)).astype(int)[:-1]\n batch_idxs = np.split(idxs,proportions)\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\n \n elif partition == \"mixed\":\n min_size = 0\n min_require_size = 10\n K = 10\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\n K = 2\n # min_require_size = 100\n\n N = y_train.shape[0]\n net_dataidx_map = {}\n\n times=[1 for i in range(10)]\n contain=[]\n for i in range(n_parties):\n current=[i%K]\n j=1\n while (j<2):\n ind=random.randint(0,K-1)\n if (ind not in current and times[ind]<2):\n j=j+1\n current.append(ind)\n times[ind]+=1\n contain.append(current)\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\n \n\n min_size = 0\n while min_size < 10:\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\n proportions = proportions/proportions.sum()\n min_size = np.min(proportions*n_train)\n\n for i in range(K):\n idx_k = np.where(y_train==i)[0]\n np.random.shuffle(idx_k)\n\n proportions_k = np.random.dirichlet(np.repeat(beta, 2))\n #proportions_k = np.ndarray(0,dtype=np.float64)\n #for j in range(n_parties):\n # if i in contain[j]:\n # proportions_k=np.append(proportions_k ,proportions[j])\n\n proportions_k = (np.cumsum(proportions_k)*len(idx_k)).astype(int)[:-1]\n\n split = np.split(idx_k, proportions_k)\n ids=0\n for j in range(n_parties):\n if i in contain[j]:\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[ids])\n ids+=1\n\n elif partition == \"real\" and dataset == \"femnist\":\n num_user = u_train.shape[0]\n user = np.zeros(num_user+1,dtype=np.int32)\n for i in range(1,num_user+1):\n user[i] = user[i-1] + u_train[i-1]\n no = np.random.permutation(num_user)\n batch_idxs = np.array_split(no, n_parties)\n net_dataidx_map = {i:np.zeros(0,dtype=np.int32) for i in range(n_parties)}\n for i in range(n_parties):\n for j in batch_idxs[i]:\n net_dataidx_map[i]=np.append(net_dataidx_map[i], np.arange(user[j], user[j+1]))\n\n traindata_cls_counts = record_net_data_stats(y_train, net_dataidx_map, logdir)\n return (X_train, y_train, X_test, y_test, net_dataidx_map, traindata_cls_counts)","def learn(self):\n metrics_hist = dict()\n max_runs = 3\n for run in range(max_runs):\n all_indices, initial_indices = self._init_al_dataset()\n\n metrics_hist[str(run)] = dict()\n\n current_indices = list(initial_indices)\n \n for split in self.data_splits_frac:\n print(f'\\nRUN {run} - SPLIT - {split*100:0.0f}%')\n\n # Initialise models\n self._init_models(mode='svaal')\n\n # Do some label stuff\n unlabelled_indices = np.setdiff1d(list(all_indices), current_indices)\n unlabelled_sampler = data.sampler.SubsetRandomSampler(unlabelled_indices)\n unlabelled_dataloader = data.DataLoader(self.datasets['train'],\n sampler=unlabelled_sampler,\n batch_size=64,\n drop_last=False)\n\n print(f'Labelled: {len(current_indices)} Unlabelled: {len(unlabelled_indices)} Total: {len(all_indices)}')\n\n # TODO: Make the SVAAL allow 100% labelled and 0% unlabelled to pass through it. Breaking out of loop for now when data hits 100% labelled.\n if len(unlabelled_indices) == 0:\n break\n\n metrics, svae, discriminator = self.train(dataloader_l=self.labelled_dataloader,\n dataloader_u=unlabelled_dataloader,\n dataloader_v=self.val_dataloader,\n dataloader_t=self.test_dataloader,\n mode='svaal') \n print(f'Test Eval.: F1 Scores - Macro {metrics[0]*100:0.2f}% Micro {metrics[1]*100:0.2f}%') \n \n # Record performance at each split\n metrics_hist[str(run)][str(split)] = metrics\n\n \n sampled_indices = self.sample_adversarial(svae, discriminator, unlabelled_dataloader, indices=unlabelled_indices, cuda=True) # TODO: review usage of indices arg\n current_indices = list(current_indices) + list(sampled_indices)\n sampler = data.sampler.SubsetRandomSampler(current_indices)\n self.labelled_dataloader = data.DataLoader(self.datasets['train'], sampler=sampler, batch_size=self.batch_size, drop_last=True)\n \n # write results to disk\n with open('results.json', 'w') as fj:\n json.dump(metrics_hist, fj, indent=4)","def run_evaluation(self, n_runs=1, n_points=1000, n_iterations=1, min_n_components=2, max_n_components=25,\n\t\t\t\t\t n_splits=3, save_data=False, file_label='',n_microstates=None, all_methods=True,\n\t\t\t\t\t assign_transition_points=True):\n\n\t\tif self.presampled_data is not None:\n\t\t\tsampled_data = self.presampled_data[0]\n\t\t\ttrue_clustering = self.presampled_data[1]\n\t\t\tn_runs = sampled_data.shape[0]\n\n\t\tself.cluster_score_ami_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tself.cluster_score_fm_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tself.cluster_score_vm_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tdata = self.toy_model_.sample(3)\n\n\t\t# Create free energy estimators\n\t\tgmm_FE = GMM_FE.FreeEnergyClustering(data, min_n_components=min_n_components, max_n_components=max_n_components,\n\t\t\t\t\t\t\t\t\t x_lims=self.x_lims_, n_grids=self.n_grids_, stack_landscapes=False,\n\t\t\t\t\t\t\t\t\t n_splits=n_splits, n_iterations=n_iterations,convergence_tol=self.convergence_tol_,\n\t\t\t\t\t\t\t\t\t verbose=self.verbose_)\n\n\t\tkm = kmc.KMeansCluster(min_n_components, max_n_components)\n\t\taw = awc.AWCluster(min_n_components, max_n_components)\n\t\tspectral = sc.SpectralCluster(min_n_components, max_n_components)\n\n\t\tall_data = []\n\t\tfor i_run in range(n_runs):\n\t\t\tprint(\"Run: \"+str(i_run+1)+'/'+str(n_runs))\n\n\t\t\tif self.presampled_data is None:\n\t\t\t\t# Sample data\n\t\t\t\tdata = self.toy_model_.sample(n_points)\n\t\t\telse:\n\t\t\t\tdata = sampled_data[i_run]\n\t\t\t\n\t\t\tall_data.append(data)\n\n\t\t\tprint('Shape data: ' + str(data.shape))\n\n\t\t\t# Set data in model and estimate GMM density\n\t\t\tgmm_FE.data_ = data\n\t\t\tcoords, est_FE_landsc, FE_points = gmm_FE.landscape()\n\n\t\t\t# Get true cluster labels\n\t\t\tif self.presampled_data is None:\n\t\t\t\tif hasattr(self.toy_model_, \"assign_cluster_labels\"):\n\t\t\t\t\tself.true_labels_ = self.toy_model_.assign_cluster_labels(data)\n\t\t\t\telse:\n\t\t\t\t\tprint('Setting true labels.')\n\t\t\t\t\tself.true_labels_, _ = self.true_FE_.cluster(data, np.zeros(data.shape[0]))\n\t\t\telse:\n\t\t\t\tself.true_labels_ = true_clustering[i_run]\n\t\t\t\n\t\t\t# Cluster data with different methods\n\t\t\tif n_microstates is None:\n\t\t\t\tself.FE_min_labels, _ = gmm_FE.cluster(data, FE_points, assign_transition_points=assign_transition_points)\n\t\t\telse:\n\t\t\t\tkmea = KMeans(n_clusters=n_microstates).fit(data[::2])\n\t\t\t\tmicrostate_centers = kmea.cluster_centers_\n\t\t\t\tself.FE_min_labels, _ = gmm_FE.cluster(microstate_centers, FE_points, data, assign_transition_points=assign_transition_points, unravel_grid=False)\n\n\t\t\tif all_methods:\n\t\t\t\tself.km_labels = km.cluster(data)\n\t\t\t\tself.aw_labels = aw.cluster(data)\n\t\t\t\tself.spectral_labels = spectral.cluster(data)\n\n\t\t\t# Score clustering using different scoring metrics\n\t\t\t# V-measure score\n\t\t\tself.cluster_score_vm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'vm')\n\t\t\tprint(self.cluster_score_vm_GMM_FE_min_[i_run])\n\t\t\tif all_methods:\n\t\t\t\tself.cluster_score_vm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'vm')\n\t\t\t\tself.cluster_score_vm_kmeans_[i_run] = self._score_clustering(self.km_labels,'vm')\n\t\t\t\tself.cluster_score_vm_AW_[i_run] = self._score_clustering(self.aw_labels,'vm')\n\t\t\t\tself.cluster_score_vm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'vm')\n\n\t\t\t\t# Adjusted MI\n\t\t\t\tself.cluster_score_ami_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'ami')\n\t\t\t\tself.cluster_score_ami_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'ami')\n\t\t\t\tself.cluster_score_ami_kmeans_[i_run] = self._score_clustering(self.km_labels,'ami')\n\t\t\t\tself.cluster_score_ami_AW_[i_run] = self._score_clustering(self.aw_labels,'ami')\n\t\t\t\tself.cluster_score_ami_spectral_[i_run] = self._score_clustering(self.spectral_labels,'ami')\n\n\t\t\t\t# Fowlkes Mallows\n\t\t\t\tself.cluster_score_fm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'fm')\n\t\t\t\tself.cluster_score_fm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'fm')\n\t\t\t\tself.cluster_score_fm_kmeans_[i_run] = self._score_clustering(self.km_labels,'fm')\n\t\t\t\tself.cluster_score_fm_AW_[i_run] = self._score_clustering(self.aw_labels,'fm')\n\t\t\t\tself.cluster_score_fm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'fm')\n\t\t\n\t\tif save_data:\n\t\t\tif self.presampled_data is None:\n\t\t\t\tnp.save('data_out/sampled_data_'+self.toy_model_.name+file_label+'.npy',all_data)\n\n\t\t\tif False:\n\t\t\t\tnp.save('data_out/cluster_score_fm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_fm_GMM_FE_min_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_kmeans_' + self.toy_model_.name +file_label +'.npy', self.cluster_score_fm_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_spectral_)\n\n\t\t\t\tnp.save('data_out/cluster_score_ami_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_ami_GMM_FE_min_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_spectral_)\n\n\t\t\tnp.save('data_out/cluster_score_vm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_vm_GMM_FE_min_)\n\t\t\tif all_methods:\n\t\t\t\tnp.save('data_out/cluster_score_vm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_spectral_)\n\t\treturn","def ensemble_001():\n n_centroids = 3000\n s = 15\n crop = 150\n n_patches = 400000\n rf_size = 5\n\n train_x_crop_scale = CropScaleImageTransformer(training=True,\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\n rf_size=rf_size,\n result_path='data/mdl_ensemble_001',\n n_iterations=20,\n n_jobs=-1,)\n\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\n patch_size=rf_size,\n n_jobs=-1)\n images = train_x_crop_scale.transform()\n patches = patch_extractor.transform(images)\n\n kmeans_generator.fit(patches)\n\n del patches\n gc.collect()\n\n X = kmeans_generator.transform(images, save_to_file='data/data_ensemble_001.npy', memmap=True)\n Y = classes.train_solutions.data\n\n # Unload some objects\n del images\n gc.collect()\n\n # Get the input for the RF so that we can split together\n sampler = SampleTransformer(training=True, steps=2, step_size=20, n_jobs=-1)\n pX = sampler.transform()\n\n # manual split of train and test\n train_x, test_x, ptrain_x, ptest_x, train_y, test_y = train_test_split(X, pX, Y, test_size=0.5)\n\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 500}, n_jobs=-1)\n wrapper.fit(train_x, train_y)\n kmeans_preds = wrapper.predict(test_x)\n\n pWrapper = ModelWrapper(RandomForestRegressor, {'n_estimators': 500, 'verbose': 3}, n_jobs=-1)\n pWrapper.fit(ptrain_x, train_y)\n pixel_preds = pWrapper.predict(ptest_x)\n\n logger.info('Kmeans')\n classes.colwise_rmse(kmeans_preds, test_y)\n classes.rmse(kmeans_preds, test_y)\n logger.info('Pixel RF')\n classes.colwise_rmse(pixel_preds, test_y)\n classes.rmse(pixel_preds, test_y)\n\n logger.info(\"Ensembling predictions\")\n etrain_x = np.hstack((wrapper.predict(train_x), pWrapper.predict(ptrain_x)))\n etest_x = np.hstack((kmeans_preds, pixel_preds))\n eWrapper = ModelWrapper(RandomForestRegressor, {'n_estimators': 500, 'verbose': 3}, n_jobs=-1)\n eWrapper.fit(etrain_x, train_y)\n ensemble_preds = eWrapper.predict(etest_x)\n classes.colwise_rmse(ensemble_preds, test_y)\n classes.rmse(ensemble_preds, test_y)","def read_data_split_and_search():\n\n\n\n dataReader = Movielens10MReader()\n dataset = dataReader.load_data()\n\n URM_train, URM_test = split_train_in_two_percentage_global_sample(dataset.get_URM_all(), train_percentage = 0.80)\n URM_train, URM_validation = split_train_in_two_percentage_global_sample(URM_train, train_percentage = 0.80)\n\n output_folder_path = \"result_experiments/\"\n\n\n # If directory does not exist, create\n if not os.path.exists(output_folder_path):\n os.makedirs(output_folder_path)\n\n\n\n\n\n\n\n collaborative_algorithm_list = [\n Random,\n TopPop,\n P3alphaRecommender,\n RP3betaRecommender,\n ItemKNNCFRecommender,\n UserKNNCFRecommender,\n MatrixFactorization_BPR_Cython,\n MatrixFactorization_FunkSVD_Cython,\n PureSVDRecommender,\n SLIM_BPR_Cython,\n SLIMElasticNetRecommender\n ]\n\n\n\n\n from Base.Evaluation.Evaluator import EvaluatorHoldout\n\n evaluator_validation = EvaluatorHoldout(URM_validation, cutoff_list=[5])\n evaluator_test = EvaluatorHoldout(URM_test, cutoff_list=[5, 10])\n\n\n runParameterSearch_Collaborative_partial = partial(runParameterSearch_Collaborative,\n URM_train = URM_train,\n metric_to_optimize = \"MAP\",\n n_cases = 10,\n evaluator_validation_earlystopping = evaluator_validation,\n evaluator_validation = evaluator_validation,\n evaluator_test = evaluator_test,\n output_folder_path = output_folder_path,\n similarity_type_list = [\"cosine\"],\n parallelizeKNN = False)\n\n\n\n\n\n pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)\n pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)\n\n #\n #\n # for recommender_class in collaborative_algorithm_list:\n #\n # try:\n #\n # runParameterSearch_Collaborative_partial(recommender_class)\n #\n # except Exception as e:\n #\n # print(\"On recommender {} Exception {}\".format(recommender_class, str(e)))\n # traceback.print_exc()\n #","def _fit_split_(self, dataset, targets, val_set, val_targets, checkpoints):\n dir = ''.join(random.choices(string.ascii_lowercase + string.digits, k=16))\n dir = '.tmp' + dir + '/'\n os.mkdir(dir)\n grid = self.grid\n if self.folds is not None or self.folds != 0:\n if self.task == 'Classification':\n if self.folds > 1:\n sf = StratifiedKFold(n_splits=self.folds, shuffle=True, random_state=0)\n elif 0 <= self.folds < 1:\n sf = StratifiedShuffleSplit(n_splits=1, test_size=self.folds, random_state=0)\n elif self.task == 'Regression':\n folds, dataset, targets = self.split_regression(dataset, targets)\n results = []\n for params in grid:\n try:\n nn = NeuralNetwork()\n for i in range(len(params['layers'])):\n if i == 0:\n nn.add_layer('dense', params['layers'][i], params['activation'], dataset.shape[1])\n else:\n if i == len(params['layers']) - 1 and self.task == 'Regression':\n nn.add_layer('dense', params['layers'][i], 'linear')\n else:\n nn.add_layer('dense', params['layers'][i], params['activation'])\n curr_res = {'params': params,\n 'metric_stats': [],\n 'test_stats': [],\n 'vl_stats': [],\n 'tr_stats': []}\n\n if self.task == 'Classification':\n folds = sf.split(dataset, targets)\n for train_index, test_index in folds:\n X_train, X_test = dataset[train_index], dataset[test_index]\n Y_train, Y_test = targets[train_index], targets[test_index]\n nested_best = None\n nested_best_metric = None\n nested_tr_pred = None\n nested_vl_pred = None\n for i in range(self.restarts):\n nn.compile(task=self.task,\n loss=self.loss_name,\n l2_lambda=params['l2_lambda'],\n dropout=params['dropout'],\n optimizer=SGD(lr_init=params['lr'],\n momentum=params['momentum'],\n nesterov=params['nesterov'],\n lr_sched=StepDecayScheduler(drop=params['lr_sched'][0],\n epochs_drop=params['lr_sched'][1])))\n\n curr_model, curr_metric, best_epoch = nn.fit(X_train, Y_train,\n val_set=val_set, val_targets=val_targets,\n batch_size=params['batch_size'],\n test_size=params['test_size'],\n epochs=params['epoch'],\n patience=params['patience'],\n save_pred=dir + 'tmp_gs',\n save_model=None)\n\n nested_best_metric = metrics.metric_improve(self.metric, nested_best_metric, curr_metric)\n if nested_best_metric[1]:\n nested_tr_pred = np.load(dir + 'tmp_gs_tr_predictions.npy')[best_epoch]\n nested_vl_pred = np.load(dir + 'tmp_gs_vl_predictions.npy')[best_epoch]\n nested_best = copy.deepcopy(curr_model)\n if nested_best_metric[2]:\n break\n\n Y_pred = nested_best.predict(X_test)\n if self.metric == 'loss':\n curr_metric = np.sum(self.loss(Y_test, Y_pred), axis=0) / len(Y_test)\n else:\n curr_metric = metrics.metric_computation(self.metric, Y_test, Y_pred)\n\n curr_res['metric_stats'].append(curr_metric)\n tr_stats = []\n vl_stats = []\n test_stats = []\n for stat in self.statistics:\n if stat == 'loss':\n\n tr_stats.append(np.mean(self.loss(nested_tr_pred[:, :targets.shape[1]],\n nested_tr_pred[:, targets.shape[1]:])))\n vl_stats.append(np.mean(self.loss(nested_vl_pred[:, :targets.shape[1]],\n nested_vl_pred[:, targets.shape[1]:])))\n test_stats.append(np.mean(self.loss(Y_test, Y_pred)))\n else:\n tr_stats.append(metrics.metric_computation(stat,\n nested_tr_pred[:, :targets.shape[1]],\n nested_tr_pred[:, targets.shape[1]:]))\n vl_stats.append(metrics.metric_computation(stat,\n nested_vl_pred[:, :targets.shape[1]],\n nested_vl_pred[:, targets.shape[1]:]))\n test_stats.append(metrics.metric_computation(stat, Y_test, Y_pred))\n curr_res['tr_stats'].append(tr_stats)\n curr_res['vl_stats'].append(vl_stats)\n curr_res['test_stats'].append(test_stats)\n\n results.append(curr_res)\n if checkpoints is not None:\n with open(checkpoints + '.pkl', 'wb') as output:\n pickle.dump(results, output, pickle.HIGHEST_PROTOCOL)\n\n except NesterovError:\n continue\n shutil.rmtree(dir)\n return results","def __train__(self):\n if (self.type_camf == 'CAMF_CI'):\n #users, items, context, ratings\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = ci.fit()\n elif (self.type_camf == 'CAMF_CU'):\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = cu.fit()\n elif (self.type_camf == 'CAMF_C'):\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\n predictions, losses = c.fit()\n\n dummy_pred = np.zeros((predictions.shape))\n for r, pred_array in enumerate(predictions):\n for c, pred in enumerate(pred_array):\n dummy_pred[r][c] = self.__check_ratings__(pred)\n predictions = dummy_pred\n #save a plot with a loss function\n plots = prs.PlotRSData()\n #print(losses)\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\"_loop\"+str(self.loop))\n pd.DataFrame(losses).to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ +\"losses_loop\"+str(self.loop)+\".csv\")\n print('Saving the feature matrix...')\n # set predictions back to the pivot table\n self.__utility_saved_training__(predictions) \n # save results\n self.utility_predictions.to_csv(\"./RecSys/out/CAMF/train/\"+self.type_camf+\"/\" + self.__save_prefix__ + \"_SGD_predictions_loop\"+str(self.loop)+\".csv\")","def split_train_test_classifier(self, split_method, method):\n \n # split data balance based on user and act (if provided)\n if method == 'window_based':\n data_train, data_val, label_user_train, label_user_val, id_window_train, id_window_val = self.split_train_val_classifier(\n self.classifier['data'], self.classifier['user_label'], self.classifier['act_label'], self.classifier['id'], 'standard', train_size=0.9) \n\n print(f'Train window before delete overlap sequence: {data_train.shape[0]}')\n\n # delete overlap sequence\n if self.overlap != 0:\n if self.overlap == 0.5:\n distance_to_delete = [1]\n elif self.overlap == 0.75:\n distance_to_delete = [1,2,3]\n invalid_idx = delete_overlap(id_window_train, id_window_val, distance_to_delete)\n data_train = np.delete(data_train, invalid_idx, axis=0)\n label_user_train = np.delete(label_user_train, invalid_idx, axis=0)\n\n print(f'Train window after delete overlap sequence: {data_train.shape[0]}')\n print(f'Validation set: {data_val.shape[0]}')\n \n elif method == 'cycle_based':\n data_train, data_val, label_user_train, label_user_val = self.split_train_val_classifier(\n self.classifier['data'], self.classifier['user_label'], self.classifier['act_label'], None, split_method, train_size=0.9) \n\n self.train = data_train\n self.train_user = label_user_train\n self.val = data_val\n self.val_user = label_user_val","def train(self):\n for data_tier in self.data_tiers:\n fd = open(self.data_path + '/training_data_' + data_tier + '.json', 'r')\n self.preprocessed_data[data_tier] = json.load(fd)\n fd.close()\n tot = len(self.preprocessed_data[data_tier]['features'])\n p = int(math.ceil(tot*0.8))\n training_features = np.array(self.preprocessed_data[data_tier]['features'][:p])\n trend_training_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][:p])\n avg_training_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][:p])\n t1 = datetime.datetime.utcnow()\n self.clf_trend[data_tier].fit(training_features, trend_training_classifications)\n self.clf_avg[data_tier].fit(training_features, avg_training_classifications)\n t2 = datetime.datetime.utcnow()\n td = t2 - t1\n self.logger.info('Training %s for data tier %s took %s', self.name, data_tier, str(td))\n joblib.dump(self.clf_trend[data_tier], self.data_path + '/' + self.name + '_trend_' + data_tier + '.pkl')\n joblib.dump(self.clf_avg[data_tier], self.data_path + '/' + self.name + '_avg_' + data_tier + '.pkl')","def create_train_test(option, transform, params, split=0.2):\r\n clip_im_dir = option.clip_im_dir\r\n matting_dir = option.matting_dir\r\n csv_path = option.csv_path\r\n \r\n print(\"create datasets\")\r\n \r\n \r\n data_df = pd.read_csv(csv_path)\r\n # data_df = MergeDataframe(clip_im_dir, matting_dir)\r\n \r\n #separate data in training and test data (20/80)\r\n train_df, test_df = train_test_split(data_df, test_size=split)\r\n \r\n #search right Dataset class\r\n package_dir = Path(src.dataset.__file__).resolve().parent\r\n\r\n for (_, module_name, _) in iter_modules([package_dir]):\r\n # print(module_name, self.ComType)\r\n if option.dataset.lower() == module_name.lower() :\r\n modelModule = importlib.import_module(\".\"+module_name)\r\n break\r\n \r\n # train data\r\n training_set = modelModule(train_df, clip_im_dir, matting_dir, transform, transform)\r\n train_loader = DataLoader(training_set, **params)\r\n \r\n \r\n #test data\r\n testing_set = modelModule(test_df, clip_im_dir, matting_dir, transform, transform)\r\n test_loader = DataLoader(testing_set, **params)\r\n \r\n return train_loader, test_loader","def main():\n df = prepro_last()\n X, y = train_build(df)\n fit_store(X, y)","def split_data_metrics_learning(cfg):\n actual_pose = cfg['actual_pose']\n target = cfg['target']\n person_ids = cfg['person_ids']\n \n # Split train and val data based on the person ids.\n all_ids = np.arange(1, 21)\n val_ids = cfg['val_ids']\n train_ids = set(all_ids).symmetric_difference(val_ids)\n \n anchor_gallery_split_size = cfg['anchor_gallery_split_size']\n window_width = cfg['window_width']\n overlap = cfg['overlap']\n random_state = cfg['random_state']\n \n # Get only the training set data and the label.\n X_train, y_train = get_req_ids(actual_pose, target, train_ids, person_ids)\n \n # Select the evaluation data that measures the performance of the model on the training set.\n train_accuracy_ids = random.sample(train_ids, len(val_ids))\n X_train_acc, y_train_acc = get_req_ids(actual_pose, target, train_accuracy_ids, person_ids)\n \n # Anchor/Gallery set split for the training set.\n X_train_gal, X_train_anchor, y_train_gal, y_train_anchor = train_test(X_train = X_train_acc, y_train = y_train_acc, \n test_size=anchor_gallery_split_size, \n random_state=random_state, stratify=y_train_acc)\n \n # Subsample the gait sequences of the anchor/gallery set of the training set based on the window width and the overlap.\n X_train_gal, y_train_gal = subsample(cfg, X_train_gal, y_train_gal, window_width=window_width, overlap=overlap)\n X_train_anchor, y_train_anchor = subsample(cfg, X_train_anchor, y_train_anchor, window_width=window_width, overlap=overlap)\n \n # Get only the validation set data and the label.\n X_val, y_val = get_req_ids(actual_pose, target, val_ids, person_ids)\n \n # Anchor/Gallery set split for the validation set.\n X_val_gal, X_val_anchor, y_val_gal, y_val_anchor = train_test(X_train = X_val, \n y_train = y_val, \n test_size=anchor_gallery_split_size, \n random_state=random_state, \n stratify=y_val)\n \n \n # If data augmentation parameter is set to True in the configuration dictionary, data augmentation is done for the training set.\n if cfg['augment_data']:\n X_train, y_train = augment_data(X_train, y_train)\n \n # Subsample the gait sequences of the whole training set based on the window width and the overlap.\n X_train, y_train = subsample(cfg, X_train, y_train, window_width=window_width, overlap=overlap)\n \n # Subsample the gait sequences of the anchor/gallery set of the validation set based on the window width and the overlap.\n X_val_gal, y_val_gal = subsample(cfg, X_val_gal, y_val_gal, window_width=window_width, overlap=overlap)\n X_val_anchor, y_val_anchor = subsample(cfg, X_val_anchor, y_val_anchor, window_width=window_width, overlap=overlap)\n \n # Concatenate the gallery and anchor set of the validation data and label as a whole. This is just to maintain the train-val uniformity and \n # is not used anywhere in the project.\n X_val, y_val = np.concatenate((X_val_gal, X_val_anchor)), np.concatenate((y_val_gal, y_val_anchor))\n \n return X_train, X_val, X_train_gal, X_train_anchor, X_val_gal, X_val_anchor, y_train, y_val, y_train_gal, y_train_anchor, y_val_gal, y_val_anchor","def split(self,\n dataset,\n seed=None,\n frac_train=None,\n frac_valid=None,\n frac_test=None,\n log_every_n=1000,\n cutoff=0.18,\n regression_task=True):\n print(\"Performing butina clustering with cutoff of\", cutoff)\n scaffold_sets = self.generate_scaffolds(dataset, cutoff)\n ys = dataset.y\n valid_inds = []\n\n for c_idx, cluster in enumerate(scaffold_sets):\n # for m_idx in cluster:\n valid_inds.extend(cluster)\n # continue until we find an active in all the tasks, otherwise we can't\n # compute a meaningful AUC\n # TODO (ytz): really, we want at least one active and inactive in both scenarios.\n # TODO (Ytz): for regression tasks we'd stop after only one cluster.\n active_populations = np.sum(ys[valid_inds], axis=0)\n if np.all(active_populations):\n print(\"# of actives per task in valid:\", active_populations)\n print(\"Total # of validation points:\", len(valid_inds))\n break\n\n train_inds = list(itertools.chain.from_iterable(scaffold_sets[c_idx + 1:]))\n test_inds = []\n\n return train_inds, valid_inds, []","def train(x_train, y_train, x_test, y_test):\n\n print(\" Nearest centroid : \", end='')\n run(x_train, y_train, x_test, y_test, NearestCentroid())\n print(\" k-NN classifier (k=3) : \", end='')\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=3))\n print(\" k-NN classifier (k=7) : \", end='')\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=7))\n print(\" Naive Bayes (Gaussian) : \", end='')\n run(x_train, y_train, x_test, y_test, GaussianNB())\n print(\" Random Forest (trees= 5) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=5))\n print(\" Random Forest (trees= 50) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=50))\n print(\" Random Forest (trees=500) : \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=500))\n print(\" Random Forest (trees=1000): \", end='')\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=1000))\n print(\" LinearSVM (C=0.01) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.01))\n print(\" LinearSVM (C=0.1) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.1))\n print(\" LinearSVM (C=1.0) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=1.0))\n print(\" LinearSVM (C=10.0) : \", end='')\n run(x_train, y_train, x_test, y_test, LinearSVC(C=10.0))","def main():\n datasets = {}\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\"Processing datasets and fitting base models\"):\n logger.info(f\"processing dataset {dataset_name}\")\n clusters_path: Optional[str] = None\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \"_clusters.json\")\n train_pairs_path = None\n val_pairs_path = None\n test_pairs_path = None\n else:\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \"train_pairs.csv\")\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \"val_pairs.csv\")\n if not os.path.exists(val_pairs_path):\n val_pairs_path = None\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \"test_pairs.csv\")\n\n logger.info(f\"loading dataset {dataset_name}\")\n anddata = ANDData(\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_signatures.json\"),\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_papers.json\"),\n name=dataset_name,\n mode=\"train\",\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_specter.pickle\"),\n clusters=clusters_path,\n block_type=BLOCK_TYPE,\n train_pairs=train_pairs_path,\n val_pairs=val_pairs_path,\n test_pairs=test_pairs_path,\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\n val_pairs_size=N_VAL_TEST_SIZE,\n test_pairs_size=N_VAL_TEST_SIZE,\n preprocess=True,\n )\n\n logger.info(f\"featurizing {dataset_name}\")\n train, val, test = featurize(\n anddata,\n FEATURIZER_INFO,\n n_jobs=N_JOBS,\n use_cache=True,\n chunk_size=100,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\n nan_value=NAN_VALUE,\n )\n X_train, y_train, nameless_X_train = train\n X_val, y_val, nameless_X_val = val\n X_test, y_test, nameless_X_test = test\n\n dataset = {}\n dataset[\"anddata\"] = anddata\n dataset[\"X_train\"] = X_train\n dataset[\"y_train\"] = y_train\n dataset[\"X_val\"] = X_val\n dataset[\"y_val\"] = y_val\n dataset[\"X_test\"] = X_test\n dataset[\"y_test\"] = y_test\n dataset[\"nameless_X_train\"] = nameless_X_train\n dataset[\"nameless_X_val\"] = nameless_X_val\n dataset[\"nameless_X_test\"] = nameless_X_test\n dataset[\"name\"] = anddata.name\n datasets[dataset_name] = dataset\n\n anddatas = [\n datasets[dataset_name][\"anddata\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in PAIRWISE_ONLY_DATASETS\n ]\n\n X_train = np.vstack([datasets[dataset_name][\"X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n y_train = np.hstack([datasets[dataset_name][\"y_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n X_val = np.vstack(\n [datasets[dataset_name][\"X_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n y_val = np.hstack(\n [datasets[dataset_name][\"y_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n\n nameless_X_train = np.vstack([datasets[dataset_name][\"nameless_X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n nameless_X_val = np.vstack(\n [\n datasets[dataset_name][\"nameless_X_val\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in {\"augmented\"}\n ]\n )\n\n logger.info(\"fitting pairwise\")\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\n union_classifier.fit(X_train, y_train, X_val, y_val)\n\n nameless_union_classifier = None\n if USE_NAMELESS_MODEL:\n logger.info(\"nameless fitting pairwise for \" + str(SOURCE_DATASET_NAMES))\n nameless_union_classifier = PairwiseModeler(\n n_iter=N_ITER,\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\n )\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\n logger.info(\"nameless pairwise fit for \" + str(SOURCE_DATASET_NAMES))\n\n logger.info(\"fitting clusterer for\")\n union_clusterer = Clusterer(\n FEATURIZER_INFO,\n union_classifier.classifier,\n cluster_model=FastCluster(),\n search_space=search_space,\n n_jobs=N_JOBS,\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\n )\n union_clusterer.fit(anddatas)\n print(\n \"best clustering parameters:\",\n union_clusterer.best_params,\n )\n\n models = {}\n models[\"clusterer\"] = union_clusterer\n\n with open(\n f\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\",\n \"wb\",\n ) as _pickle_file:\n pickle.dump(models, _pickle_file)\n logger.info(\"Done.\")","def main():\n housing = pd.read_csv(\"Data/train_original.csv\")\n housing[\"TotalSF\"] = (\n housing[\"TotalBsmtSF\"] + housing[\"1stFlrSF\"] + housing[\"2ndFlrSF\"]\n )\n training_features, testing_features, training_target, testing_target = impute_dummify_and_split(\n housing, drop_target=False\n )\n\n p_values = [\n (c, pearsonr(training_features[\"SalePrice\"], training_features[c])[1])\n for c in training_features.columns\n ]\n\n p_value_limits = [0.05]\n\n result = []\n ps_and_cols = {}\n\n for p_value_limit in p_value_limits:\n\n high_ps = list(\n map(lambda t: t[0], sorted(p_values, key=lambda t1: t1[1])[:15])\n )\n\n print(training_features[high_ps].corr())\n\n columns = [p[0] for p in p_values if p[1] < p_value_limit]\n\n training_features_restricted = training_features[columns].drop(\n \"SalePrice\", axis=\"columns\"\n )\n\n testing_features_restricted = testing_features[columns].drop(\n \"SalePrice\", axis=\"columns\"\n )\n\n for model in (\n linear_model.Lasso(alpha=2.1),\n linear_model.Ridge(alpha=2.1),\n ):\n\n model.fit(training_features_restricted, training_target)\n\n train_score = model.score(\n training_features_restricted, training_target\n )\n\n test_score = model.score(\n testing_features_restricted, testing_target\n )\n\n name = str(model).split(\"(\")[0]\n\n result = result + [\n (\n \"_2_restrict_features\",\n name,\n \"p value limit: {:.3f}, alpha: 2.1\".format(p_value_limit),\n train_score,\n test_score,\n )\n ]\n\n print(ps_and_cols)\n return training_features[high_ps].corr()","def split_data(self,test=False):\n shuffle_index = torch.randperm(self.train_target.shape[0])\n load = shuffle_index.shape[0]\n train_input_shuffle = self.train_input[shuffle_index]\n train_target_shuffle = self.train_target[shuffle_index]\n train_classes_shuffle = self.train_classes[shuffle_index]\n index_train = self.index_for_equal_class(train_target_shuffle[:load//2])\n train_input = train_input_shuffle[index_train]\n train_target = train_target_shuffle[index_train]\n train_classes = train_classes_shuffle[index_train]\n if not test:\n index_test = self.index_for_equal_class( train_target_shuffle[load//2:]) + load//2\n test_input = train_input_shuffle[index_test]\n test_target = train_target_shuffle[index_test]\n test_classes = train_classes_shuffle[index_test]\n else:\n index_test = self.index_for_equal_class(self.test_target)\n test_input = self.test_input[index_test]\n test_target = self.test_target[index_test]\n test_classes = self.test_classes[index_test]\n train_input, mean, std = normalize(train_input)\n test_input, _, _ = normalize(test_input,mean,std)\n return train_input, train_target, train_classes ,test_input ,test_target ,test_classes","def main():\n \n # The following 5 command lines can be outcommented if the features are already created.\n # There is no need to process the data every single time.\n # Fine tuning the learning algorythm is much faster without that extra step.\n \n # by reading the train dataset the feature index is created.\n # First calling of the processdata function\n # Data limited to 300000\n featureIndexes = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000)\n print \"featureIndex generated!\"\n print len(featureIndexes)\n\n # Trainfeature is created using the indexfeatures...\n # Second calling of the processdata function\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000) # Original itemsLimit=300000\n\n # Building the test dataset... just like the training...\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\"avito_test.tsv\"), featureIndexes)\n\n # Dumping data into file...\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\"train_data.pkl\"))\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\"SeparatedByCategory.pkl\"))\n\n\n # loading data pack...\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\"train_data.pkl\"))\n\n #logging.info(\"Feature preparation done, fitting model...\")\n\n # Stochastic gradient model","def train(data, N, accuracy, Lout, Washout, Vin, Wres):\n print 'Training'\n args = [\n [data[i], N, accuracy, Washout, Vin, Wres] for i in xrange(Lout)\n ]\n pool = Pool(processes=Lout)\n clusters = pool.map(training, args)\n # TODO delete\n for i, cluster in enumerate(clusters):\n np.savetxt('dump_{0}'.format(i), cluster[1])\n return clusters","def kmeans_006():\n n_centroids_vals = [1000, 2000, 2500, 3000]\n scores = []\n\n for n_centroids in n_centroids_vals:\n s = 15\n crop = 150\n n_patches = 400000\n rf_size = 5\n logger.info(\"Training with n_centroids {}\".format(n_centroids))\n\n train_x_crop_scale = CropScaleImageTransformer(training=True,\n result_path='data/data_train_crop_{}_scale_{}.npy'.format(crop, s),\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n test_x_crop_scale = CropScaleImageTransformer(training=False,\n result_path='data/data_test_crop_{}_scale_{}.npy'.format(crop, s),\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\n rf_size=rf_size,\n result_path='data/mdl_kmeans_006_centroids_{}'.format(n_centroids),\n n_iterations=20,\n n_jobs=-1,)\n\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\n patch_size=rf_size,\n n_jobs=-1)\n images = train_x_crop_scale.transform()\n\n patches = patch_extractor.transform(images)\n\n kmeans_generator.fit(patches)\n\n del patches\n gc.collect()\n\n train_x = kmeans_generator.transform(images, save_to_file='data/data_kmeans_features_006_centroids_{}.npy'.format(n_centroids), memmap=True)\n train_y = classes.train_solutions.data\n # Unload some objects\n del images\n gc.collect()\n\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 250}, n_jobs=-1)\n wrapper.cross_validation(train_x, train_y, n_folds=2, parallel_estimator=True)\n\n score = (n_centroids, wrapper.cv_scores)\n logger.info(\"Scores: {}\".format(score))\n scores.append(score)\n\n del wrapper\n gc.collect()","def run_train_test_split():\n # Load all documents\n conn = sq.connect(config.DB_FILE)\n documents = pd.read_sql_query('select pubmed_id, review_id, included, title, abstract from article ', conn)\n\n # Identify unique review IDs\n review_ids = documents['review_id'].unique()\n\n # Set seed for random sampling\n np.random.seed(2)\n\n # List of Reviews in the partial data set and full data set\n partial_set = list(np.random.choice(review_ids, 10, replace=False))\n full_set = list(review_ids.copy())\n\n # Load array (X) and labels (Y) of all documents\n with (open(config.DOC_TERM_MATRIX, \"rb\")) as openfile:\n X = pickle.load(openfile)\n\n y = documents['included']\n\n # Train-test split of the partial dataset\n train_test_split(X, y, partial_set, 'min_max', 'partial', review_ids)\n train_test_split(X, y, partial_set, 'tf_idf', 'partial', review_ids)\n\n # Train-test split of the full dataset\n train_test_split(X, y, full_set, 'min_max', 'full', review_ids)\n train_test_split(X, y, full_set, 'tf_idf', 'full', review_ids)","def split_dataset(self, split):\n trunk_pos_size = math.ceil((1 - split) * len(self.Pos))\n trunk_neg_size = math.ceil((1 - split) * len(self.Neg))\n trunk_num = int(1 / (1 - split))\n pos_temp = list()\n neg_temp = list()\n for index in range(trunk_num):\n pos_temp.append(self.Pos[index * trunk_pos_size:(index + 1) *\n trunk_pos_size])\n neg_temp.append(self.Neg[index * trunk_neg_size:(index + 1) *\n trunk_neg_size])\n self.test = pos_temp.pop(2) + neg_temp.pop(2)\n # self.train = [i for item in pos_temp + neg_temp for i in item]\n self.train = []\n for item in pos_temp + neg_temp:\n for i in item:\n self.train.append(i)\n\n random.shuffle(self.train)\n random.shuffle(self.test)","def train( self, trainingData, trainingLabels, validationData, validationLabels ):\n\n self.features = trainingData[0].keys() # could be useful later\n # DO NOT ZERO OUT YOUR WEIGHTS BEFORE STARTING TRAINING, OR\n # THE AUTOGRADER WILL LIKELY DEDUCT POINTS.\n for iteration in range(self.max_iterations):\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\n print (\"Starting iteration \", iteration, \"...\")\n for i in range(len(trainingData)):#training data\n max = -10000000\n for j in range(len(self.weights)):\n prod = np.dot(self.weights[j], trainingData[i]) #este sería x0 (en la primera vuelta) (xj)\n if (prod > max):\n max=prod #en max guardamos la distancia a la instancia que más cerca está de la que estamos recorriendo\n indclase=j #guardas el índice de la clase a la que predices que pertenece\n\n if(indclase != trainingLabels[i]):\n # recalcular pesos\n self.weights[trainingLabels[i]].__radd__(trainingData[i]) #honek jarraian egiten du gehiketa pisu guztientzat\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\n self.weights[indclase].__sub__(trainingData[i]) #honek jarraian egiten du kenketa pisu guztientzat\n\n\n\n\n\n ########################################################################################\n # 1. i es el indice de un ejemplo (un item, f(x) de un ejemplo) del conjunto de entrenamiento.\n # 2. Asi pues, en cada vuelta de este loop se trata un solo ejemplo\n # por cada ejemplo calculareis el producto punto (dotProduct) w*item\n # NOTAS: Recordad que cada ejemplo viene representado por varios rasgos (o features), es decir, es un vector de rasgos, tantos como nos marca el atributo self.features.\n # Asi cada ejemplo es de dimension 1 filas y self.features).\n # La dimension del vector w tambien es self.features, es decir, habra tantos pesos en w_rasgo dentro de w como rasgos haya en cada item de ejemplo\n # Recordad tambien que es una clasificacion multiclase en este caso. Hay tantas clases como nos marca el atributo self.legalLabels\n #########################################################################################","def process_dataset(self):\n\n logger.info('\\n')\n logger.info('=' * 40)\n logger.info('=\\t DeepRank Data Set')\n logger.info('=')\n logger.info('=\\t Training data')\n for f in self.train_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n if self.valid_database:\n logger.info('=\\t Validation data')\n for f in self.valid_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n if self.test_database:\n logger.info('=\\t Test data')\n for f in self.test_database:\n logger.info(f'=\\t -> {f}')\n logger.info('=')\n logger.info('=' * 40 + '\\n')\n sys.stdout.flush()\n\n # check if the files are ok\n self.check_hdf5_files(self.train_database)\n\n if self.valid_database:\n self.valid_database = self.check_hdf5_files(\n self.valid_database)\n\n if self.test_database:\n self.test_database = self.check_hdf5_files(\n self.test_database)\n\n # create the indexing system\n # alows to associate each mol to an index\n # and get fname and mol name from the index\n self.create_index_molecules()\n\n # get the actual feature name\n if self.mapfly:\n self.get_raw_feature_name()\n else:\n self.get_mapped_feature_name()\n\n # get the pairing\n self.get_pairing_feature()\n\n # get grid shape\n self.get_grid_shape()\n\n # get the input shape\n self.get_input_shape()\n\n # get renormalization factor\n if self.normalize_features or self.normalize_targets or self.clip_features:\n if self.mapfly:\n self.compute_norm()\n else:\n self.get_norm()\n\n logger.info('\\n')\n logger.info(\" Data Set Info:\")\n logger.info(\n f' Augmentation : {self.use_rotation} rotations')\n logger.info(\n f' Training set : {self.ntrain} conformations')\n logger.info(\n f' Validation set : {self.nvalid} conformations')\n logger.info(\n f' Test set : {self.ntest} conformations')\n logger.info(f' Number of channels : {self.input_shape[0]}')\n logger.info(f' Grid Size : {self.data_shape[1]}, '\n f'{self.data_shape[2]}, {self.data_shape[3]}')\n sys.stdout.flush()","def prediction_data(median_split,mean_split,std_split,degrees_split,weight_split,export_file):\n DATA_TEST_PATH = '../data/test.csv' # Download train data and supply path here \n print('\\nIMPORTING TESTING DATA :',end=\" \")\n y_test, tX_test, ids_test = load_csv_data(DATA_TEST_PATH)\n print('DONE')\n \n #5.a. Splitting the testing data\n print('SPLITTING TESTING DATA :',end=\" \")\n y_test_split,tx_test_split,id_test_split = split_dataset(y_test,tX_test,ids_test) \n print('DONE') \n #5.b. prediction on each model\n y_pred = list()\n \n for split,(y_test_s,tx_test_s,id_test_s) in enumerate(zip(y_test_split,tx_test_split,id_test_split)): \n print('PREDICTION FOR TESTING DATA SPLIT NUMBER',split)\n \n #Formatting to the correct datatype\n y_test_s = np.squeeze(y_test_s)\n tx_test_s = np.squeeze(tx_test_s)\n id_test_s = np.squeeze(id_test_s)\n print('Size of the vectors',y_test_s.shape,tx_test_s.shape) \n #Formatting the data themselves\n print('Counting NaN',end='. ')\n tx_test_s = count_NaN(tx_test_s)\n print('Sanitizing',end = ' . ')\n tx_test_s,median_vec = sanitize_NaN(tx_test_s,median_split[split])\n print('Standardizing',end = ' .')\n tx_test_s,mean_te,std_te = standardize(tx_test_s,mean_split[split],std_split[split])\n print('Building polynomial basis') \n tx_test_s = build_poly(tx_test_s, degrees_split[split])\n \n #Prediction\n y_pred.append(predict_labels(np.array(weight_split[split]), np.array(tx_test_s))) \n \n print('MERGING TESTING DATA',end=\"\")\n y_pred_merged, ids_merged = merge_dataset(y_pred,id_test_split)\n print('DONE')\n \n OUTPUT_PATH = 'results/output_sanitized_normalization_'+export_file+'.csv' \n print('EXPORTING TESTING DATA WITH PREDICTIONS :',end=\" \")\n \n create_csv_submission(ids_merged, y_pred_merged, OUTPUT_PATH)\n print('DONE')","def get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(df_profit_per_cluster_train) >= 3, \"Algorithm, returned less than 3 clusters.\"\n\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\n group_size = int(len(df_profit_per_cluster) / 3)\n\n buy_clusters_mean_profit = df_profit_per_cluster.iloc[:group_size]['profit'].mean()\n sell_clusters_mean_profit = df_profit_per_cluster.iloc[-group_size:]['profit'].mean()\n\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\n\n return buy_clusters_mean_profit, buy_clusters_list, sell_clusters_mean_profit, sell_clusters_list","def compute(self):\n # some possible parameters:\n # minimum size: min node count for a cluster\n # (should be small, or some fraction of total graph size)\n # num splits: desired number of resultant partitions. Partitioning will continue until there are no more \"parallelizing splits\", or the total partition count is >= num splits\n minSplits = 3\n clustermetalist = []\n (roots, inters) = self.rootSplit(self.cluster)\n clustermetalist.append(roots)\n if (len(roots) + len(inters)) < minSplits:\n # split intersects.\n inters = map(self.rootSplit, inters)\n clustermetalist.append(inters[0])\n clustermetalist.append(inters[1])\n else:\n clustermetalist.append(inters)\n \n print \"nodes\", len(self.cluster)\n print \"roots\", len(roots)\n self.ready = clustermetalist\n # The metalist is a list of lists of clusters.\n # list[0] is a list of clusters that are ready for execution.\n # list[1] is a list of clusters that are ready after all clusters\n # in list[0] are complete. Some or all clusters may be ready\n # earlier, but each cluster requires some finite progress in one\n # or more clusters in list[0], otherwise the cluster could be\n # placed in list[0].\n # list[i+1] is related to list[i] similarly as list[1] is related\n # to list[0]\n open(\"pass1.dot\",\"w\").write(self.makeStateGraph(\"pass1\",roots))\n pass","def partition_data(self):\n\n _header_ = self._header_ + 'partition_data(): '\n\n if self.verbose:\n print(_header_ + 'Partitioning data ...')\n\n network = self._useful_network()\n\n if self.nidx_train:\n # The only reason that allows .nidx to not be empty would be that a training Data was copied over\n # hence, the training node indices are retained and need to be excluded\n print(_header_ + 'Excluding %d training nodes transfered from training dataset ...' % len(self.nidx_train))\n nidx = set(self.nidx2lidx.keys()) - set(self.nidx_train)\n self.nidx_exclude += self.nidx_train\n self.nidx_train = []\n else:\n nidx = set(self.nidx2lidx.keys())\n\n for l in nidx:\n if l in network:\n if self.node_labels[l]:\n self.nidx_train.append(l)\n else:\n self.nidx_exclude.append(l)\n\n if self.verbose:\n print(_header_ + 'Found %d nodes' % len(self.nidx2lidx))\n print(' %d nodes with labels of interest' % len(self.nidx_train))\n print(' %d nodes can be used to predict' % len(self.nidx_pred))\n print(' %d nodes cannot be mapped due to lack of mappable links' % len(self.nidx_exclude))\n\n return self","def buildAndTrain(trainingData):\n\tname = trainingData.drop(['count', 'casual', 'registered'], axis=1).columns\n\ttarget = trainingData['count'].values\n\tfeature = trainingData.drop(['count', 'casual', 'registered'], axis=1).values\n\t# feature scaling\n\tfeature_scaled = preprocessing.scale(feature)\n\t# 0.5 cross validate\n\tcv = cross_validation.ShuffleSplit(len(feature_scaled), n_iter=5, test_size=0.2, random_state=0)\n\t# build model, then training and get accuracy of it\n\tprint('\\n---------岭回归结果--------\\n')\n\tfor train, test in cv:\n\t\tregLR = linear_model.Ridge().fit(feature_scaled[train], target[train])\n\t\tprint('train score:{0:.3f}, test score:{1:.3f}\\n'.format(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tregLR.score(feature_scaled[train], target[train]),\n\t\t regLR.score(feature_scaled[test], target[test])))\n\tprint('\\n---------svm结果--------\\n')\n\tfor train, test in cv:\n\t\tregSvm = svm.SVR().fit(feature_scaled[train], target[train])\n\t\tprint('train score:{0:.3f}, test score:{1:.3f}\\n'.format(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tregSvm.score(feature_scaled[train], target[train]),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tregSvm.score(feature_scaled[test], target[test])))\n\tprint('\\n---------随机森林结果--------\\n')\n\tfor train, test in cv:\n\t\tregRF = RandomForestRegressor(n_estimators=100).fit(feature_scaled[train], target[train])\n\t\tprint('train score:{0:.3f}, test score:{1:.3f}\\n'.format(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tregRF.score(feature_scaled[train], target[train]),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tregRF.score(feature_scaled[test], target[test])))\n\t# reduce some low correction feature\n\tfeatureReduced = trainingData.drop(['count', 'casual', 'registered', 'holiday', 'workingday', 'day'], axis=1).values\n\tfeatureReduced_scaled = preprocessing.scale(featureReduced)\n\tprint('\\n---------减少特征维度以避免过拟合后的随机森林结果--------\\n')\n\tfor train, test in cv:\n\t\tregRFImpr = RandomForestRegressor(n_estimators=100).fit(featureReduced_scaled[train], target[train])\n\t\tprint('train score:{0:.3f}, test score:{1:.3f}\\n'.format(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tregRFImpr.score(featureReduced_scaled[train], target[train]),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tregRFImpr.score(featureReduced_scaled[test], target[test])))\n\t# use grid search algorithm to improve random forest regression\n\tX_train, X_test, y_train, y_test = cross_validation.train_test_split(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tfeature_scaled, target, test_size=0.2, random_state=0)\n\ttuned_parameters = [{'n_estimators': [10,100,500], 'max_depth': [2,3,4,5,6,7,8,9,10]}]\n\tscores = ['r2']\n\n\tfor score in scores:\n\t\tprint(score)\n\t\tclf = GridSearchCV(RandomForestRegressor(), tuned_parameters, cv=5, scoring=score)\n\t\tclf.fit(X_train, y_train)\n\t\tprint(clf.best_estimator_)\n\t\tprint('each parameter combination is ')\n\t\tfor params, mean_score, scores in clf.grid_scores_:\n\t\t\tprint('{0:.3f} (+/-{1:.03f}) for {2}'.format(mean_score, scores.std()/2, params))\n\n\tprint('--------最优参数下的随机森林结果--------')\n\tfor train, test in cv:\n\t\tregRFBest = RandomForestRegressor(n_estimators=100, max_depth=10).fit(feature_scaled[train], target[train])\n\t\tprint('train score:{0:.3f}, test score:{1:.3f}\\n'.format(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tregRFBest.score(feature_scaled[train], target[train]),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tregRFBest.score(feature_scaled[test], target[test])))\n\treturn regRFBest, feature_scaled, target","def train_clustermodel_nonsparse(self):\n \n segtimes_df, nonsparse_matrix = self.create_nonsparse_matrix(self.data)\n segtimes_df['index']=segtimes_df.index\n nonsparse_matrix['index']=nonsparse_matrix.index\n data_to_scale = pd.merge(segtimes_df, nonsparse_matrix, on=['index'])\n data_scaled = self.scale_matrix(data_to_scale)\n data_to_cluster = data_scaled.drop(columns = ['segment_id','level_0','date','time'])\n \n print('Clustering using nonsparse segment/time matrix and: ' + self.algorithm)\n clusterer = self.clustering_algorithms[self.algorithm]\n self.clustering_model = clusterer.fit(data_to_cluster)\n \n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_nonsparse'])\n clusters_df['segtimekey'] = clusters_df.index\n segtimes_df['segtimekey'] = segtimes_df.index\n clusters_df = clusters_df.reset_index(drop=True)\n self.clusters_df_final = pd.merge(segtimes_df, clusters_df, on=['segtimekey'])\n self.clusters_df_final['cluster_nonsparse'].value_counts()\n \n today = datetime.date.today()\n filename = self.algorithm + '_nonsparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\n joblib.dump(self.clustering_model, filename)\n \n print('Stored ' + filename)\n \n return self.clustering_model, self.clusters_df_final[['segment_id','date','time','cluster_nonsparse']]","def kmeans_002():\n train_mmap_path = 'data/train_cropped_150_scale_15.memmap'\n test_mmap_path = 'data/test_cropped_150_scale_15.memmap'\n\n if not os.path.exists('data/train_cropped_150.memmap'):\n classes.crop_to_memmap(150, training=True)\n if not os.path.exists('data/test_cropped_150.memmap'):\n classes.crop_to_memmap(150, training=False)\n\n if not os.path.exists(train_mmap_path):\n logger.info(\"Prepping training images\")\n pre_scale = np.memmap('data/train_cropped_150.memmap', mode='r', shape=(N_TRAIN, 150, 150, 3))\n trainX = classes.rescale_memmap(15, pre_scale, train_mmap_path)\n del pre_scale\n else:\n trainX = np.memmap(train_mmap_path, mode='r', shape=(N_TRAIN, 15, 15, 3))\n\n if not os.path.exists(test_mmap_path):\n logger.info(\"Prepping testing images\")\n pre_scale = np.memmap('data/test_cropped_150.memmap', mode='r', shape=(N_TEST, 150, 150, 3))\n testX = classes.rescale_memmap(15, pre_scale, test_mmap_path)\n del pre_scale\n else:\n testX = np.memmap(test_mmap_path, mode='r', shape=(N_TEST, 15, 15, 3))\n\n\n n_jobs = multiprocessing.cpu_count()\n\n if not os.path.exists('data/mdl_kmeans_002_centroids.npy'):\n logger.info(\"Pretraining KMeans feature encoder\")\n km = models.KMeansFeatures.KMeansFeatures(rf_size=5, num_centroids=1600, num_patches=400000)\n km.fit(trainX)\n km.save_to_file('mdl_kmeans_002')\n else:\n logger.info(\"Loading KMeans feature encoder from file\")\n km = models.KMeansFeatures.KMeansFeatures.load_from_file('mdl_kmeans_002', rf_size=5)\n\n # Takes waaaay too long to finish. At least an hour per tree. Clearly too\n # many dimensions\n\n # Instead ran with ridge rf manually\n mdl = models.RandomForest.KMeansRandomForest(km, trainX, testX, n_jobs=n_jobs, cv_sample=0.5)\n # mdl.run('cv')\n mdl.run('train')\n res = mdl.run('predict')\n np.save('submissions/sub_kmeans_rf_002.npy', res)\n output = classes.Submission(res)\n output.to_file('sub_kmeans_rf_002.csv')","def train_clustermodel_sparse(self):\n\n print('Clustering using: ' + self.algorithm)\n uniquesegments_df, sparse_matrix = self.create_sparse_matrix(self.data)\n\n clusterer = self.clustering_algorithms[self.algorithm]\n self.clustering_model = clusterer.fit(sparse_matrix)\n \n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_sparse'])\n clusters_df['segmentskey'] = clusters_df.index\n clusters_df = clusters_df.reset_index(drop=True)\n self.clusters_df_final = pd.merge(uniquesegments_df, clusters_df, on=['segmentskey'])\n self.clusters_df_final['cluster_sparse'].value_counts()\n \n today = datetime.date.today()\n filename = self.algorithm + '_sparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\n joblib.dump(self.clustering_model, filename)\n \n print('Stored ' + filename)\n \n return self.clustering_model, self.clusters_df_final[['segment_id','cluster_sparse']]","def final_evaluation(self):\n print(\"\\n=== Assign final labels ===\")\n\n # skip if there is only one cluster\n n_cluster = len(set(self.label[self.label != -1]))\n if n_cluster < 2:\n print(f\"Skip final evaluation because only {n_cluster} cluster label exist.\")\n # name all cluster as c0\n self.label = np.zeros(self.label.size, dtype=int)\n self.cv_predicted_label = [f\"c{label}\" for label in self.label]\n self.label_proba = np.ones(self.label.size, dtype=int)\n self.final_accuracy = 1\n else:\n # predict outliers\n outlier_x = self.X[self.label == -1]\n outlier_idx = np.where(self.label == -1)[0]\n if len(outlier_idx) != 0:\n outlier_predict = pd.Series(self.supervise_model.predict(outlier_x), index=outlier_idx)\n for cell, pred_label in outlier_predict.items():\n self.label[cell] = pred_label\n print(\n \"Assigned all the multi-leiden clustering outliers into clusters \"\n \"using the prediction model from final clustering version.\"\n )\n\n # final evaluation of non-outliers using cross val predict\n final_predict_proba = cross_val_predict(\n self.supervise_model,\n self.X,\n y=self.label,\n method=\"predict_proba\",\n n_jobs=self.n_jobs,\n verbose=0,\n cv=10,\n )\n final_predict = pd.Series(np.argmax(final_predict_proba, axis=1))\n final_cell_proba = pd.Series(np.max(final_predict_proba, axis=1))\n final_acc = balanced_accuracy_score(self.label, final_predict.values)\n print(f\"Final ten-fold CV Accuracy on all the cells: {final_acc:.3f}\")\n self.cv_predicted_label = [f\"c{label}\" for label in final_predict]\n self.label_proba = final_cell_proba.values\n self.final_accuracy = final_acc\n\n self.label = [f\"c{label}\" for label in self.label]\n return","def ensemble(final_X_test, final_X_train, Y_train, Yl, index_train):\n ensemble_models = [DecisionTreeClassifier(),\n LinearSVC(),\n GaussianNB(),\n LogisticRegression(solver='lbfgs', multi_class='auto'),\n SVC(kernel=\"linear\", C=0.025)]\n n_folds = len(ensemble_models)\n kf = KFold(n_folds, shuffle=True)\n X_lv2 = np.zeros((final_X_train.shape[0], n_folds))\n y_lv2 = np.zeros(Y_train.shape)\n for itrain, itest in kf.split(final_X_train):\n y_lv2[itest] = Y_train[itest]\n # Train\n for n in range(n_folds):\n ensemble_models[n].fit(final_X_train[itrain, :], Y_train[itrain])\n X_lv2[itest, n] = ensemble_models[\n n].predict(final_X_train[itest, :])\n # Nivel 2\n Clas_lv2_m2 = SVC(kernel=\"linear\")\n Clas_lv2_m2.fit(X_lv2, y_lv2)\n # Train\n for n in range(n_folds):\n ensemble_models[n].fit(final_X_train, Y_train)\n # Predicción\n Ypred_test = np.zeros((Y_test.shape[0], n_folds))\n Ypred_excl = np.zeros((final_X_train.shape[0], n_folds))\n for n in range(n_folds):\n Ypred_test[:, n] = ensemble_models[n].predict(final_X_test)\n Ypred_excl[:, n] = ensemble_models[n].predict(final_X_train)\n yc2 = Clas_lv2_m2.predict(Ypred_excl)\n Yl_prediccion = np.zeros(Yl.shape[0])\n Yl_prediccion[index_train] = yc2\n plt.imshow(np.reshape(Yl_prediccion, (145, 145), order=\"F\")),\n plt.axis('off'),\n plt.title('Ensemble')\n plt.show()","def train(self):\n\n print \"==> Running Kmeans on data set of shape: {}\".format(self.data.shape)\n km = KMeans(n_clusters = self.n_clusters)\n km.fit(self.data.values)\n self.labels = km.labels_\n self.inertia = km.inertia_","def interpret_clusters(self, split=0.7, all_demos=None, num_clusters=None, \n max_depth=CLUSTER_DEPTH, data=None, labels=None, verbose=True):\n all_demos = self.all_data if all_demos is None else all_demos\n clusters = self.get_ordered_clusters(labels, num_clusters)\n data = self.demos if data is None else data\n labels = self.labels if labels is None else labels\n\n cluster_formulas = []\n counter = 0\n sep = \"\\n \"\n for c in clusters:\n counter += 1\n res = self.sample_from_clusters(num_samples=split,\n all_data=all_demos,\n pos_validation=True, \n neg_validation=True,\n which_cluster=counter)\n positive_samples, val_positive_samples = res[0], res[1]\n negative_samples, val_negative_samples = res[2], res[3]\n z = 0\n for d in positive_samples:\n if d[1] == 0: z += 1\n\n cluster_data = {'pos': positive_samples,\n 'neg': negative_samples}\n val_cluster_data = {'pos': val_positive_samples,\n 'neg': val_negative_samples}\n\n if verbose: print(sep +\"Checking formulas \" + \\\n \"with max depth {}\\n\".format(max_depth))\n\n cluster_formula, value_formula = wrapper_train(max_depth,\n cluster_data, \n val_cluster_data,\n verbose=verbose,\n pred_data=[self.pipeline_X,\n self.pipeline_y])\n if cluster_formula is not None:\n print(cluster_formula)\n\n cluster_formulas.append((c, cluster_formula, value_formula))\n self.reset_pipeline()\n\n return cluster_formulas","def preprocess(self,\n balance=True,\n partition=\"iid\",\n unbalance_sgm=0,\n num_shards=None,\n dir_alpha=None,\n verbose=True,\n seed=None,\n download=True):\n self.download = download\n\n if os.path.exists(self.path) is not True:\n os.mkdir(self.path)\n os.mkdir(os.path.join(self.path, \"train\"))\n os.mkdir(os.path.join(self.path, \"var\"))\n os.mkdir(os.path.join(self.path, \"test\"))\n # train dataset partitioning\n if self.dataname == 'cifar10':\n trainset = torchvision.datasets.CIFAR10(root=self.root,\n train=True,\n download=self.download)\n partitioner = CIFAR10Partitioner(trainset.targets,\n self.num_clients,\n balance=balance,\n partition=partition,\n unbalance_sgm=unbalance_sgm,\n num_shards=num_shards,\n dir_alpha=dir_alpha,\n verbose=verbose,\n seed=seed)\n elif self.dataname == 'cifar100':\n trainset = torchvision.datasets.CIFAR100(root=self.root,\n train=True,\n download=self.download)\n partitioner = CIFAR100Partitioner(trainset.targets,\n self.num_clients,\n balance=balance,\n partition=partition,\n unbalance_sgm=unbalance_sgm,\n num_shards=num_shards,\n dir_alpha=dir_alpha,\n verbose=verbose,\n seed=seed)\n else:\n raise ValueError(\n f\"'dataname'={self.dataname} currently is not supported. Only 'cifar10', and 'cifar100' are supported.\"\n )\n\n subsets = {\n cid: CIFARSubset(trainset,\n partitioner.client_dict[cid],\n transform=self.transform,\n target_transform=self.targt_transform)\n for cid in range(self.num_clients)\n }\n for cid in subsets:\n torch.save(\n subsets[cid],\n os.path.join(self.path, \"train\", \"data{}.pkl\".format(cid)))","def initSets(self):\n data_frame = pd.read_csv(self.train_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n if self.test_file is None:\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n else:\n data_frame = pd.read_csv(self.test_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n # kfold = KFold(n_splits=3)\n # self.train_index, self.test_index = kfold.split(features,labels)","def get_dataset(FOLD, AR_PERCENTAGE, d_type='yelp', AUTHOR='inf', POST='inf'):\n global AR_TYPE\n\n # dataset = loader.load(d_type, AUTHOR, POST)\n first_dataset = loader.unimportant_load(AUTHOR, POST * FOLD, AR_TYPE)\n datasets = first_dataset.fold_to(FOLD)\n \n for i in range(0, len(datasets)):\n dataset = datasets[i]\n dataset.divide_ar_ir(AR_PERCENTAGE)\n texts = []\n\n # check if we have this dataset already calculated.\n \n ir_filename = 'processed/' + get_ir_identifier(d_type, i, AUTHOR, POST)\n ar_filename = 'processed/' + get_ar_identifier(d_type, i, AUTHOR, POST)\n\n ir_features = None\n if os.path.isfile(ir_filename):\n print '@get: we have the file', ir_filename, 'and going to load it.'\n with open(ir_filename, 'rb') as fp:\n ir_features = pickle.load(fp)\n \n ar_features = None\n if os.path.isfile(ar_filename):\n print '@get: we have the file', ar_filename, 'and going to load it.'\n with open(ar_filename, 'rb') as fp:\n ar_features = pickle.load(fp)\n\n\n if ir_features is not None:\n for author in dataset.authors:\n dataset.features[author][-1] = ir_features[author]\n\n if ar_features is not None:\n for author in dataset.authors:\n dataset.features[author][:-1] = ar_features[author]\n\n for author in dataset.authors:\n if ar_features is None:\n texts.extend(dataset.get_ars(author))\n if ir_features is None: \n texts.append(dataset.get_ir(author))\n\n print '@getting_features, #dataset'#, index_fold\n pool = Pool(processes=NUMBER_OF_CORES)\n it = pool.imap(get_dataset_features, texts)\n pool.close()\n pool.join()\n\n print '@getting_features FINISHED, adding features to dictionary'\n for author in dataset.authors:\n # for each ar + ir, get back the features\n if ar_features is None:\n for i in range(0, dataset.get_ar_size(author)):\n dataset.put_feature(author, i, it.next())\n if ir_features is None:\n dataset.put_feature(author, dataset.get_ar_size(author), it.next())\n\n if ir_features is None:\n print '@get: we DONOT have the file', ir_filename, 'is going to be created and saved.'\n with open(ir_filename, 'wb') as fp:\n tmp = dict()\n for key, value in dataset.features.iteritems():\n tmp[key] = value[-1]\n pickle.dump(tmp, fp)\n\n if ar_features is None:\n print '@get: we DONOT have the file', ar_filename, 'is going to be created and saved.'\n with open(ar_filename, 'wb') as fp:\n tmp = defaultdict(list)\n for key, value in dataset.features.iteritems():\n tmp[key] = value[:-1]\n pickle.dump(tmp, fp)\n\n return datasets","def train(self, algorithm):\n\n kfold = StratifiedKFold(10, True, 1)\n f1_score = []\n precision_score = []\n recall_score = []\n for train, test in kfold.split(self.data_training, self.data_target):\n model = algorithm.fit(self.data_training.iloc[train], self.data_target.iloc[train])\n scores = self.score_model(model, self.data_training.iloc[test], self.data_target.iloc[test])\n f1_score.append(scores[0])\n precision_score.append(scores[1])\n recall_score.append(scores[2])\n\n self.print_results(f1_score, precision_score, recall_score)","def generate_data(project_data, config, split_method = RAW) :\n training_data = []\n testing_data = []\n \n # Flatten the data (collapse the project and session hierarchy into a list of session_data)\n for v in config.train_project_names:\n # Data in all sessions of one project\n project_session_data = random.sample(project_data[v], len(project_data[v]))\n\n training_data += project_session_data[int(config.session_training_percentage[0] * len(project_session_data)):\n int(config.session_training_percentage[1] * len(project_session_data))]\n\n if config.double_training:\n for i in xrange(int(config.session_training_percentage[0] * len(project_session_data)),\n int(config.session_training_percentage[1] * len(project_session_data))):\n session_data = project_session_data[i]\n\n reversed_session_data = {}\n reversed_session_data[SESSION_NAME] = session_data[SESSION_NAME] + \"_reversed\"\n reversed_session_data[SESSION_EVENTS] = []\n\n def reverse_point_data_qsr(point_data):\n reversed_point_data = point_data[:4]\n # Hands to objects feature swap\n reversed_point_data += point_data[8:12] \n reversed_point_data += point_data[4:8]\n\n # Centroid direction and distance difference is symmetric\n reversed_point_data += point_data[12:14]\n\n # Object corners swap\n reversed_point_data += point_data[16:18] \n reversed_point_data += point_data[14:16]\n\n reversed_point_data += point_data[18:19]\n reversed_point_data += point_data[20:21] \n reversed_point_data += point_data[19:20]\n\n # For QTCCS\n reversed_point_data += point_data[22:23]\n reversed_point_data += point_data[21:22]\n reversed_point_data += point_data[24:25]\n reversed_point_data += point_data[23:24]\n\n # # For difference of features\n # fl = 21\n # reversed_point_data += point_data[fl:fl + 4]\n # # Hands to objects feature swap\n # reversed_point_data += point_data[fl + 8:fl + 12] \n # reversed_point_data += point_data[fl + 4:fl + 8]\n\n # # Centroid direction and distance difference is symmetric\n # reversed_point_data += point_data[fl + 12:fl + 14]\n\n # # Object corners swap\n # reversed_point_data += point_data[fl + 16:fl + 18] \n # reversed_point_data += point_data[fl + 14:fl + 16]\n\n # reversed_point_data += point_data[fl + 18:fl + 19]\n # reversed_point_data += point_data[fl + 20:fl + 21] \n # reversed_point_data += point_data[fl + 19:fl + 20]\n\n return reversed_point_data\n\n def reverse_point_data_sparse_qsr(point_data):\n reversed_point_data = point_data[:2 * 56]\n # Hands to objects feature swap\n reversed_point_data += point_data[4 * 56:6 * 56] \n reversed_point_data += point_data[2 * 56:4 * 56]\n\n # Centroid direction and distance difference is symmetric\n reversed_point_data += point_data[6 * 56:7 * 56]\n\n # Object corners swap\n reversed_point_data += point_data[8 * 56:9 * 56] \n reversed_point_data += point_data[7 * 56:8 * 56]\n\n anchor = 9 * 56\n reversed_point_data += point_data[anchor:anchor + 2]\n reversed_point_data += point_data[anchor + 2 * 2:anchor + 3 * 2] \n reversed_point_data += point_data[anchor + 2:anchor + 2 * 2]\n\n anchor = 9 * 56 + 3 * 2\n # For QTCCS\n reversed_point_data += point_data[anchor + 3:anchor + 2 * 3]\n reversed_point_data += point_data[anchor:anchor + 3]\n reversed_point_data += point_data[anchor + 3 * 3:anchor + 4 * 3]\n reversed_point_data += point_data[anchor + 2 * 3:anchor + 3 * 3]\n\n return reversed_point_data\n\n reversed_session_data[SESSION_DATA] = []\n for point_data in session_data[SESSION_DATA]:\n if split_method == RAW:\n reversed_point_data = point_data[:39]\n reversed_point_data += point_data[51:63]\n reversed_point_data += point_data[39:51]\n elif split_method == PCAS:\n reversed_point_data = point_data[:6]\n # Object centroid swap\n reversed_point_data += point_data[8:10] \n reversed_point_data += point_data[6:8]\n # Object corners swap\n reversed_point_data += point_data[14:18] \n reversed_point_data += point_data[10:14]\n elif split_method == QSR or split_method == EVENT:\n reversed_point_data = reverse_point_data_qsr(point_data)\n elif split_method == SPARSE_QSR:\n reversed_point_data = reverse_point_data_sparse_qsr(point_data)\n\n reversed_session_data[SESSION_DATA].append(reversed_point_data)\n\n for event_str in session_data[SESSION_EVENTS]:\n reversed_event_str = {}\n for key in event_str:\n reversed_event_str[key] = event_str[key]\n\n subj, obj, theme, event, prep = event_str['label']\n def swap_objects(value):\n if value == 2:\n return 3\n if value == 3:\n return 2\n return value\n\n reversed_event_str['label'] = (swap_objects(subj), swap_objects(obj), swap_objects(theme), event, prep)\n\n reversed_session_data[SESSION_EVENTS].append(reversed_event_str)\n\n training_data.append(reversed_session_data)\n\n\n testing_data += project_session_data[int(config.session_testing_percentage[0] * len(project_session_data)):\n int(config.session_testing_percentage[1] * len(project_session_data))]\n \n return (training_data, testing_data)","def training(df, type=None):\r\n df=dataCleaner(df[DISC_FEATURES_COL_TO_USE+CONT_FEATURES_COL_TO_USE+[DISC_TARGET_COL_TO_USE]])\r\n print(\"Using %d numbers of features\"%len(DISC_FEATURES_COL_TO_USE + CONT_FEATURES_COL_TO_USE))\r\n df_coded = trainEncode(df)\r\n df_coded = scalarNormalizer(df_coded)\r\n visualizeHistogram(df_coded)\r\n # visualizePCA(df_coded)\r\n df_shuffled = df_coded.sample(frac=1, random_state=100).reset_index(drop=True)\r\n X, y = df_shuffled[DISC_FEATURES_COL_TO_USE + CONT_FEATURES_COL_TO_USE], df_shuffled[DISC_TARGET_COL_TO_USE]\r\n X, y = resampling(X, y)\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = TEST_FR, random_state = 42)\r\n\r\n print(\"Training the classifier!\")\r\n if type=='LR':\r\n print(\"Using Logistic Regression Classifier\")\r\n cls=LogisticRegression(n_jobs=2, class_weight='balanced', tol=1e-4, C=1,random_state=111)\r\n elif type=='SVM':\r\n print(\"Using Support Vector Machine Classifier\")\r\n cls=SVC(class_weight='balanced', probability=True)\r\n elif type=='RF':\r\n print(\"Using Random Forst Classifier\")\r\n cls=RandomForestClassifier( n_jobs=3, n_estimators=8192, class_weight='balanced', max_depth=8,\r\n min_samples_leaf=1, random_state=24)\r\n elif type=='GBC':\r\n print(\"Using Gradient Boosting Classifier\")\r\n cls = GradientBoostingClassifier(n_estimators=2048, max_depth=4,\r\n subsample=0.8, learning_rate=0.004,\r\n random_state=34, min_samples_split=4,\r\n max_features=\r\n int(0.4*len(DISC_FEATURES_COL_TO_USE+\r\n CONT_FEATURES_COL_TO_USE)))\r\n else:\r\n print(\"Using Naive Bayes Classifier\")\r\n cls = GaussianNB()\r\n model = cls.fit(X_train, y_train)\r\n print (\"Cross-validated scores:\", cross_val_score(model, X_train, y_train, cv=10))\r\n print (\"Score:\", model.score(X_test, y_test))\r\n predict_test = model.predict(X_test)\r\n\r\n print('precision_score=%f\\nrecall_score=%f'%(precision_score(y_test, predict_test),recall_score(y_test, predict_test)))\r\n\r\n print(metrics.roc_auc_score(y_test, predict_test))\r\n\r\n cm=confusion_matrix(y_test, predict_test)\r\n print(\"Confusion matrix:\\n\" + str(cm))\r\n # showConfusionMatrix(cm)\r\n\r\n pickle.dump(model, open(MODEL_FILENAME, 'wb'))\r\n print(\"Model Created!\")","def main(feats_name, targets_name, model_name, n_boot, seed_start, output_filename, train_test_flag):\n\n #load feats and targets\n input_dict = {}\n input_dict['feats'] = 'data/%s' % (feats_name)\n input_dict['targets'] = 'data/%s' % (targets_name)\n #load the feats and targets\n df = pd.read_csv(\"%s\" % (input_dict['feats']))\n targets = pd.read_csv(\"%s\" % (input_dict['targets']))\n #drop columns not used for prediction\n drop_cols = [\"Unnamed: 0\",\"index\"]\n for dc in drop_cols:\n if dc in targets.columns:\n targets = targets.drop(dc,axis=1)\n if dc in df.columns:\n df = df.drop(dc,axis=1)\n #reduce to training or test set only if requested\n if (train_test_flag == 'train') and ('test_set' in df.columns):\n targets = targets[df['test_set'] == 0]\n df = df[df['test_set'] == 0]\n elif (train_test_flag == 'test') and ('test_set' in df.columns):\n targets = targets[df['test_set'] == 1]\n df = df[df['test_set'] == 1]\n df = df.drop('test_set', axis = 1)\n \n #broadcast the feats and targets\n df_b = sc.broadcast(df)\n targets_b = sc.broadcast(targets)\n\n #Set up the classifier. 3fold CV for selection of regularization term.\n if model_name == 'linear':\n model = LinearRegression(fit_intercept=True,\n normalize=False,\n copy_X=True,\n n_jobs=1) \n elif model_name == 'lasso':\n model = LassoCV(alphas = [.05,.1,.2],\n normalize = False,\n fit_intercept = True,\n verbose = False,\n copy_X = False,\n n_jobs = 3)\n elif model_name == 'ridge':\n model = RidgeCV(alphas = [.00001,.0001,.001,.01,.1,1,10,100,1000,10000],\n normalize = False,\n fit_intercept = True,\n verbose = 1,\n cv = 3)\n else:\n raise ValueError('model_name not recognized.')\n \n #Create an RDD that specifies prng seed to use\n samp_list = [(n,) for n in np.arange(seed_start, seed_start+n_boot)]\n samp_rdd = sc.parallelize(samp_list,n_boot) #create RDD with one partition for each row (second arg is number of partitions)\n #Create a function that takes a tuple as input and returns \n def func(tup):\n \"\"\"\n Takes as input a tuple containing an integer. The integer specifies the random seed that will be used to \n randomly sample, with replacement, observations from the feats set provided. The model is fitted to the \n sampled feats. Resulting best fit parameters, along with some other summary statistics and information are\n provided as input in a JSON string that will be written to the output file when all jobs are completed.\n \n Parameters\n ----------\n tup, rdd\n - series of tuples with different integer values defining the RNG seed to be used to sample observations\n \n Returns\n ----------\n tup[0], int\n - the seed that was used\n json.dumps(results_dict), str\n - dict in json format with the following keys:\n - alpha, the regularization term providing the best fit according to 3 fold cross-validation\n - random_state, the initial state used for fitting\n - training_feats, the name of the training_feats csv file\n - training_targets, the name of the target variable csv file\n - cv, the type of cross-validation used\n - sklearn_version, which version of sklearn was used\n - mse_min, the mean squared error for the test set on each fold\n - r2, the r-squared value (% var explained)\n - coef, parameter vector\n - intercept, intercept parameter\n - column_names, feature name corresponding to each parameter in the parameter vector\n \"\"\"\n #take a random sample with replacement\n np.random.seed(seed=tup[0]) #set the seed\n n_obs = np.shape(df_b.value)[0] #number of observations determines sample size\n samp = list(np.random.randint(0,high=n_obs,size=n_obs)) #draw the random sample with replacement\n #fit the model\n tic = time.time()\n results = model.fit(df_b.value.iloc[samp,:],np.ravel(targets_b.value.iloc[samp]))\n toc = tic - time.time()\n #save the results in a dict\n results_dict = {}\n results_dict['alpha'] = results.alpha_\n results_dict['random_state'] = results.random_state\n results_dict['training_feats'] = input_dict['feats']\n results_dict['training_targets'] = input_dict['targets']\n results_dict['cv'] = results.cv\n results_dict['sklearn_version'] = sklearn.__version__\n results_dict['mse_min'] = results.mse_path_.min()\n results_dict['r2'] = results.score(df_b.value.iloc[samp,:],np.ravel(targets_b.value.iloc[samp]))\n results_dict['coef'] = list(results.coef_)\n results_dict['intercept'] = results.intercept_\n results_dict['column_names'] = [i for i in df_b.value.columns]\n results_dict['fit_time'] = toc\n #convert results dict to json and save in tuple\n return(json.dumps(results_dict))\n\n #fit model in parallel\n results = samp_rdd.map(lambda p: func(p))\n #save to text file\n results.saveAsTextFile(output_filename)\n #stop the SparkContext.\n if not local_mode:\n sc.stop()","def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\n learning_rate=0.01):\n\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\n random_seed=0)\n som.train(df_train, n_iter)\n\n # converting numpy arrays to dataframes\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\n\n # creating column with cluster basing on model prediction\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\n\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\n # the script\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\n lsuffix='_org')\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\n lsuffix='_org')\n\n return final_df_train, final_df_test","def train():\n\t# 1、make dataloader\n\ttrain_loader, val_loader, num_query, num_class = make_data_loader(cfg)\n\t#print(\"num_query:{},num_class:{}\".format(num_query,num_class))\n\n\t# 2、make model\n\tmodel = build_model(cfg, num_class)\n\n\t# model.eval()\n\t# x = model(img_tensor)\n\t# print(x.shape)\n\t# 3、 make optimizer\n\toptimizer = make_optimizer(cfg, model)\n\n\t# 4、 make lr_scheduler\n\tscheduler = make_lr_scheduler(cfg, optimizer)\n\n\t# 5、 make loss_func\n\tif cfg.MODEL.PCB_NECK:\n\t\t# make loss specificially for pcb \n\t\tloss_func = get_softmax_triplet_loss_fn(cfg, num_class)\n\telse:\n\t\tloss_func = make_loss(cfg, num_class)\n\n\t# get paramters\n\tlog_period = cfg.OUTPUT.LOG_PERIOD \n\tckpt_period =cfg.OUTPUT.CHECKPOINT_PERIOD\n\teval_period = cfg.OUTPUT.EVAL_PERIOD\n\toutput_dir = cfg.OUTPUT.ROOT_DIR\n\tdevice = cfg.MODEL.DEVICE\n\tepochs = cfg.SOLVER.MAX_EPOCHS\n\tuse_gpu = device == \"cuda\"\n\tuse_neck = cfg.MODEL.NECK or cfg.MODEL.LEARN_REGION \n\t# how many batch for each log\n\tbatch_size = cfg.SOLVER.IMGS_PER_BATCH\n\tbatch_num = len(train_loader) \n\t\n\tlog_iters = batch_num // log_period\n\tpretrained = cfg.MODEL.PRETRAIN_PATH != ''\n\tparallel = cfg.MODEL.PARALLEL \t\n\tgrad_clip = cfg.DARTS.GRAD_CLIP \n\n\tfeat_norm = cfg.TEST.FEAT_NORM \n\tckpt_save_path = cfg.OUTPUT.ROOT_DIR + cfg.OUTPUT.CKPT_DIR\n\tif not os.path.exists(ckpt_save_path):\n\t\tos.makedirs(ckpt_save_path)\n\n\n\t# create *_result.xlsx\n\t# save the result for analyze\n\tname = (cfg.OUTPUT.LOG_NAME).split(\".\")[0] + \".xlsx\"\n\tresult_path = cfg.OUTPUT.ROOT_DIR + name\n\n\twb = xl.Workbook()\n\tsheet = wb.worksheets[0]\n\ttitles = ['size/M','speed/ms','final_planes', 'acc', 'mAP', 'r1', 'r5', 'r10', 'loss',\n\t\t\t 'acc', 'mAP', 'r1', 'r5', 'r10', 'loss','acc', 'mAP', 'r1', 'r5', 'r10', 'loss']\n\tsheet.append(titles)\n\tcheck_epochs = [40, 80, 120, 160, 200, 240, 280, 320, 360, epochs]\n\tvalues = []\n\n\tlogger = logging.getLogger('MobileNetReID.train')\n\t\n\t# count parameter\n\tsize = count_parameters(model)\n\tlogger.info(\"the param number of the model is {:.2f} M\".format(size))\n\t\n\tvalues.append(format(size, '.2f'))\n\tvalues.append(model.final_planes)\n\n\tlogger.info(\"Start training\")\n\t\n\t#count = 183, x, y = batch -> 11712 for train\n\tif pretrained:\n\t\tstart_epoch = model.start_epoch\n\n\tif parallel:\n\t\tmodel = nn.DataParallel(model)\n\n\tif use_gpu:\n\t\t# model = nn.DataParallel(model)\n\t\tmodel.to(device)\n\t\n\t# save the best model\n\tbest_mAP, best_r1 = 0., 0.\n\tis_best = False\n\t# batch : img, pid, camid, img_path\n\tavg_loss, avg_acc = RunningAverageMeter(), RunningAverageMeter()\n\tavg_time, global_avg_time = AverageMeter(), AverageMeter()\n\tglobal_avg_time.reset()\n\tfor epoch in range(epochs):\n\t\tscheduler.step()\n\n\t\tif pretrained and epoch < start_epoch - 1:\n\t\t\tcontinue\n\t\n\t\tmodel.train()\n\t\t# sum_loss, sum_acc = 0., 0.\n\t\tavg_loss.reset()\n\t\tavg_acc.reset()\n\t\tavg_time.reset()\n\t\tfor i, batch in enumerate(train_loader):\n\n\t\t\tt0 = time.time()\n\t\t\timgs,labels = batch\n\n\t\t\tif use_gpu:\n\t\t\t\timgs = imgs.to(device)\n\t\t\t\tlabels = labels.to(device)\n\n\t\t\tres = model(imgs)\n\t\t\t# score, feat = model(imgs)\n\t\t\t# loss = loss_func(score, feat, labels)\n\t\t\tloss, acc = compute_loss_acc(use_neck, res, labels, loss_func)\n\t\t\t\n\t\t\tloss.backward()\n\t\t\tif grad_clip != 0:\n\t\t\t\tnn.utils.clip_grad_norm(model.parameters(), grad_clip)\n\n\t\t\toptimizer.step()\n\n\t\t\toptimizer.zero_grad()\n\n\t\t\t# acc = (score.max(1)[1] == labels).float().mean()\n\n\t\t\t# sum_loss += loss\n\t\t\t# sum_acc += acc \n\t\t\tt1 = time.time()\n\t\t\tavg_time.update((t1 - t0) / batch_size)\n\t\t\tavg_loss.update(loss)\n\t\t\tavg_acc.update(acc)\n\n\t\t\t#log the info \n\t\t\tif (i+1) % log_iters == 0:\n\n\t\t\t\tlogger.info(\"epoch {}: {}/{} with loss is {:.5f} and acc is {:.3f}\".format(\n\t\t\t\t\t epoch+1, i+1, batch_num, avg_loss.avg, avg_acc.avg))\n\n\t\tlr = optimizer.state_dict()['param_groups'][0]['lr']\n\t\tlogger.info(\"end epochs {}/{} with lr: {:.5f} and avg_time is {:.3f} ms\".format(epoch+1, epochs, lr, avg_time.avg * 1000))\n\t\tglobal_avg_time.update(avg_time.avg)\n\t\t# change the lr \n\n\t\t# eval the model \n\t\tif (epoch+1) % eval_period == 0 or (epoch + 1) == epochs :\n\t\t\t\n\t\t\tmodel.eval()\n\t\t\tmetrics = R1_mAP(num_query, use_gpu = use_gpu, feat_norm = feat_norm)\n\n\t\t\twith torch.no_grad():\n\n\t\t\t\tfor vi, batch in enumerate(val_loader):\n\t\t\t\t\t\n\t\t\t\t\timgs, labels, camids = batch\n\n\t\t\t\t\tif use_gpu:\n\t\t\t\t\t\timgs = imgs.to(device)\n\n\t\t\t\t\tfeats = model(imgs)\n\t\t\t\t\tmetrics.update((feats,labels, camids))\n\n\t\t\t\t#compute cmc and mAP\n\t\t\t\tcmc, mAP = metrics.compute()\n\t\t\t\tlogger.info(\"validation results at epoch:{}\".format(epoch + 1))\n\t\t\t\tlogger.info(\"mAP:{:.2%}\".format(mAP))\n\t\t\t\tfor r in [1,5,10]:\n\t\t\t\t\tlogger.info(\"CMC curve, Rank-{:<3}:{:.2%}\".format(r,cmc[r-1]))\t\n\n\t\t\t\t# determine whether cur model is the best \n\t\t\t\tif mAP > best_mAP:\n\t\t\t\t\tis_best = True\n\t\t\t\t\tbest_mAP = mAP\n\t\t\t\t\tlogger.info(\"Get a new best mAP\")\n\t\t\t\tif cmc[0] > best_r1:\n\t\t\t\t\tis_best = True\n\t\t\t\t\tbest_r1 = cmc[0]\n\t\t\t\t\tlogger.info(\"Get a new best r1\")\n\n\t\t\t\t# add the result to sheet\n\t\t\t\tif (epoch + 1) in check_epochs:\n\t\t\t\t\tval = [avg_acc.avg, mAP, cmc[0], cmc[4], cmc[9]]\n\t\t\t\t\tchange = [format(v * 100, '.2f') for v in val]\n\t\t\t\t\tchange.append(format(avg_loss.avg, '.3f'))\n\t\t\t\t\tvalues.extend(change)\n\n\n\t\t# we hope that eval_period == ckpt_period or eval_period == k* ckpt_period where k is int\t\t\t\n\t\t# whether to save the model\n\t\tif (epoch+1) % ckpt_period == 0 or is_best:\n\n\t\t\tif parallel:\n\t\t\t\ttorch.save(model.module.state_dict(), ckpt_save_path + \"checkpoint_{}.pth\".format(epoch + 1 ))\n\t\t\telse:\n\t\t\t\ttorch.save(model.state_dict(), ckpt_save_path + \"checkpoint_{}.pth\".format(epoch + 1 ))\n\n\t\t\tlogger.info(\"checkpoint {} saved !\".format(epoch + 1))\n\n\t\t\tif is_best:\n\t\t\t\tif parallel:\n\t\t\t\t\ttorch.save(model.module.state_dict(), ckpt_save_path + \"best_ckpt.pth\")\n\t\t\t\telse:\n\t\t\t\t\ttorch.save(model.state_dict(), ckpt_save_path + \"best_ckpt.pth\")\n\t\t\t\tlogger.info(\"best checkpoint was saved\")\n\t\t\t\tis_best = False\n\t\n\tvalues.insert(1, format(global_avg_time.avg * 1000, '.2f'))\n\tsheet.append(values)\n\twb.save(result_path)\n\n\tlogger.info(\"training is end, time for per imgs is {} ms\".format(global_avg_time.avg *1000))","def train(self):\n\t\traise NotImplementedError","def predict_progression(final):\n #Import the dataset for prediction\n dataset = read_excel('SampleProgressionData.xlsx', sheet_name=0)\n \"\"\"\n Split the data into a training and a testing set\n \"\"\"\n train_features = dataset.iloc[0:197,:-1]\n train_targets = dataset.iloc[0:197,-1]\n i=0\n df_cluster_data_col = {}\n Dict_progression = {} \n Dict_rec_progression = {} \n while i < 5:\n # Number of employees in this cluster\n array_n = final[final.cluster == i][\"EmployeeID\"].unique()\n len(array_n)\n print(\"cluster \", i )\n print(\"Employees: \", array_n)\n # List of employees\n final[final.cluster == i]\n cluster_data_n=final[final.cluster == i]\n cluster_data_n=cluster_data_n[0:len(array_n)]\n # cluster_data_n\n df_cluster_data_n=pd.DataFrame(cluster_data_n, columns = ['EmployeeID', 'MajorityBand','CurrentBand','NumberYears','Progression']) \n df_cluster_data_n['MajorityBand']=df_cluster_data_n['CurrentBand'].max()\n df_cluster_data_n.fillna(0, inplace=True)\n dataset_cluster_n = pd.DataFrame(df_cluster_data_n,columns = ['EmployeeID','MajorityBand', 'CurrentBand','NumberYears','Progression'])\n test_features = dataset_cluster_n.iloc[:,1:4]\n test_targets = dataset_cluster_n.iloc[:,-1]\n \"\"\"\n Train the model\n \"\"\"\n tree = DecisionTreeClassifier(criterion = 'entropy').fit(train_features,train_targets)\n \"\"\"\n Predict the classes of new, unseen data\n \"\"\"\n prediction = tree.predict(test_features)\n \"\"\"\n Check the accuracy\n \"\"\"\n print(\"The prediction accuracy is: \",tree.score(test_features,test_targets)*100,\"%\")\n df_cluster_data_n['Progression']=list(prediction)\n strmax = df_cluster_data_n['CurrentBand'].max()\n print(\"strmax \", strmax)\n print(\"prediction \", prediction)\n print('---------------------------------------------------------------------')\n print(\"PREDICTION FOR BAND \", strmax)\n print('---------------------------------------------------------------------')\n df_cluster_data_n = df_cluster_data_n.loc[df_cluster_data_n[\"Progression\"]==1]\n df_cluster_data_empid=pd.DataFrame(df_cluster_data_n, columns = ['EmployeeID'])\n df_cluster_data_col[i]=df_cluster_data_empid\n Dict_progression[strmax]=list(df_cluster_data_empid['EmployeeID'].unique())\n print(\"Dict_progression \", Dict_progression)\n i=i+1\n # Show the next promotion band and not the cluster highest band for recommendation to employees\n list_promotion = Dict_progression[strmax]\n for emp_band_promo in list_promotion:\n array = df_cluster_data_n.loc[df_cluster_data_n['EmployeeID'] == emp_band_promo]['CurrentBand'].unique()\n promotion_band = array[0]+1 \n list_emp_band = []\n if promotion_band in Dict_rec_progression:\n list_emp_band = Dict_rec_progression[promotion_band]\n list_emp_band.append(emp_band_promo) \n list_emp_band.sort()\n Dict_rec_progression[promotion_band] = list_emp_band\n print(\"Dict_progression\", Dict_progression)\n print(\"Dict_rec_progression\", Dict_rec_progression) \n return Dict_rec_progression","def kmeans_004():\n crops = [200] # Should probably also add 250\n scales = [30, 50] # Scaling is probably the most important part here\n\n scores = []\n for s in scales:\n crop = 200\n n_centroids = 1600\n n_patches = 400000\n # rf_size = int(round(s * .2))\n rf_size = 10\n logger.info(\"Training with crop {}, scale {}, patch size {}, patches {}, centroids {}\".format(crop, s, rf_size, n_patches, n_centroids))\n\n train_x_crop_scale = CropScaleImageTransformer(training=True,\n result_path='data/data_train_crop_{}_scale_{}.npy'.format(crop, s),\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n\n # spherical generator\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\n rf_size=rf_size,\n result_path='data/mdl_kmeans_004_scale_{}_rf_{}'.format(s, rf_size),\n n_iterations=20,\n n_jobs=-1,)\n\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\n patch_size=rf_size,\n n_jobs=-1)\n images = train_x_crop_scale.transform()\n logger.info(\"Images ndarray shape: {}\".format(images.shape))\n patches = patch_extractor.transform(images)\n logger.info(\"Patches ndarray shape: {}\".format(patches.shape))\n\n kmeans_generator.fit(patches)\n\n del patches\n gc.collect()\n\n train_x = kmeans_generator.transform(images, save_to_file='data/data_kmeans_features_004_scale_{}_rf_{}.npy'.format(s, rf_size), memmap=True)\n train_y = classes.train_solutions.data\n # Unload some objects\n del images\n gc.collect()\n logger.info(\"Train X ndarray shape: {}\".format(train_x.shape))\n\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 250}, n_jobs=-1)\n wrapper.cross_validation(train_x, train_y, n_folds=2, parallel_estimator=True)\n scores.append((s, wrapper.cv_scores))\n del wrapper\n gc.collect()","def trainSOM_getK(model):\n model.detect_serialized_datasets()\n model.detect_prepared_datasets()\n model.train_SOM()\n model.detect_som_products()\n model.generate_k()\n cluster_num = model.get_k()\n return cluster_num","def classify():\n yes_dataset = df[df[\"_class\"] == 1] # 470588\n no_dataset = df[df[\"_class\"] == 0] # 1971\n\n parameter_analysis = list()\n for criterion in np.arange(0.05, 0.91, 0.05):\n print(\"doing experiment at criterion = %s ...\" % criterion)\n rate_list = list()\n for i in range(10):\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\n yes_index = yes_dataset.index.tolist()\n random.shuffle(yes_index)\n no_index = no_dataset.index.tolist()\n random.shuffle(no_index)\n \n # concatenate 90%yes + 90%no, 10%yes + 10%no\n train = pd.concat([\n yes_dataset.loc[yes_index[:1774], :],\n no_dataset.loc[no_index[:423530], :]\n ])\n test = pd.concat([\n yes_dataset.loc[yes_index[1774:], :],\n no_dataset.loc[no_index[423530:], :]\n ]) \n \n # split data and label\n train_data, train_label = (train[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n train[\"_class\"])\n test_data, test_label = (test[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n test[\"_class\"])\n \n # apply classifier\n clf = GaussianNB()\n clf.fit(train_data, train_label)\n probability = clf.predict_proba(test_data).T[1]\n \n result = pd.DataFrame()\n result[\"_class\"] = test_label\n result[\"_predict\"] = probability >= criterion\n \n result_yes = result[result[\"_class\"] == 1]\n yes_yes_rate = sum(result_yes[\"_class\"] == result_yes[\"_predict\"])/len(result_yes[\"_predict\"])\n \n result_no = result[result[\"_class\"] == 0]\n no_no_rate = sum(result_no[\"_class\"] == result_no[\"_predict\"])/len(result_no[\"_predict\"])\n \n rate_list.append((yes_yes_rate, no_no_rate))\n\n rate_list = pd.DataFrame(rate_list)\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\n \n # save data to excel spreadsheet\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\"criterion\", \"yes_yes_rate\", \"no_no_rate\"])\n writer = pd.ExcelWriter(\"parameter_analysis.xlsx\")\n parameter_analysis.to_excel(writer, \"parameter_analysis\", index=False)\n writer.save()","def final_clf_training(Xs, ys, X_holdout, y_holdout, scorer_type, sanity_check=False, oversampling=False):\n\n # stack all the feature vectors of all the folds\n X_train = np.vstack(tuple([Xs[i] for i in range(10)]))\n y_train = np.hstack(tuple([ys[i] for i in range(10)]))\n\n # stack the holdout feature vectors on the feature vectors of all folds\n X_all = np.concatenate([X_train, X_holdout], axis=0)\n y_all = np.concatenate([y_train, y_holdout], axis=0)\n\n # define and create parent folder to save all trained classifiers into\n parent_folder = \"%s/data/fnc-1/mlp_models/\" % (path.dirname(path.dirname(path.abspath(__file__))))\n\n # create the new save folder for the specific classifer\n scorer_folder_name = scorer_type+\"_final\"\n save_folder = get_save_folder(parent_folder, scorer_folder_name+\"_new\")\n\n # get classifier and only pass a save folder if the classifier should be saved\n clf = esitmator_definitions.get_estimator(scorer_type, save_folder=save_folder)\n\n #perform oversampling if selected\n if oversampling == True:\n if 'f_ext' in scorer_type:\n print(\"Oversampling not defined for LSTM\")\n exit()\n\n import datetime\n start = datetime.datetime.now().time()\n print(\"Started oversampling/undersampling at: \" + str(start))\n # uncomment following lines for the different sampling methods #####\n # Oversampling\n from imblearn.over_sampling import SMOTE, ADASYN, RandomOverSampler\n print(\"Oversampling data\")\n #kind = ['regular', 'borderline1', 'borderline2', 'svm']\n #sm = SMOTE(kind='regular',)\n #X_res, y_res = sm.fit_sample(X_all, y_all)\n\n #ros = RandomOverSampler()\n #X_res, y_res = ros.fit_sample(X_all, y_all)\n\n #ada = ADASYN()\n #X_res, y_res = ada.fit_sample(X_all, y_all)\n\n ######################################################\n # Undersampling\n from imblearn.under_sampling import TomekLinks, EditedNearestNeighbours, CondensedNearestNeighbour, \\\n NeighbourhoodCleaningRule, InstanceHardnessThreshold\n # remove Tomek links\n tl = TomekLinks(return_indices=True)\n X_res, y_res, idx_resampled = tl.fit_sample(X_all, y_all)\n\n #enn = EditedNearestNeighbours(random_state=0)\n #X_res, y_res = enn.fit_sample(X_all, y_all)\n\n #cnn = CondensedNearestNeighbour(random_state=0)\n #X_res, y_res = cnn.fit_sample(X_all, y_all)\n\n #ncr = NeighbourhoodCleaningRule(random_state=0)\n #X_res, y_res = ncr.fit_sample(X_all, y_all)\n\n #iht = InstanceHardnessThreshold(random_state=0, estimator=clf)\n #X_res, y_res = iht.fit_sample(X_all, y_all)\n\n\n ##################\n # Combination of Undersampling and oversampling\n\n from imblearn.combine import SMOTEENN, SMOTETomek\n #smote_enn = SMOTEENN(random_state=0)\n #X_res, y_res = smote_enn.fit_sample(X_all, y_all)\n\n #smote_tomek = SMOTETomek(random_state=0)\n #X_res, y_res = smote_tomek.fit_sample(X_all, y_all)\n\n end = datetime.datetime.now().time()\n print(\"Ended oversampling/undersampling at: \" + str(end))\n\n clf.fit(X_res, y_res)\n else: # if oversampling is false\n import datetime\n # fit the final classifier\n loss_monitor_file_dir = \"%s/data/fnc-1/model_results/loss_results/\" % (\n path.dirname(path.dirname(path.abspath(__file__))))\n loss_filename = loss_monitor_file_dir + str(datetime.datetime.now().strftime(\"%Y-%m-%d_%H-%M\")) + \".txt\"\n # fit the classifier\n if 'f_ext' in scorer_type:\n append_to_loss_monitor_file(\"\\n\\nFOLD holdout and classifier: \" + scorer_type + \"\\n\", loss_filename)\n append_to_loss_monitor_file(str(datetime.datetime.now()).split('.')[0], loss_filename)\n clf.fit(X_train, y_train, X_holdout, np.array(y_holdout), 'holdout', loss_filename)\n else:\n clf.fit(X_all, y_all)\n\n # save the model\n filename = scorer_folder_name + \".sav\"\n save_model(clf, save_folder, filename) # save model with filename to specific folder\n\n # predict on the data the classifier was trained on => should give near perfect score\n if sanity_check == True:\n # get predicted and actual labels\n y_predicted = clf.predict(X_all)\n predicted = [LABELS[int(a)] for a in y_predicted]\n actual = [LABELS[int(a)] for a in y_all]\n\n # calc FNC score\n fold_score, _ = score_submission(actual, predicted)\n max_fold_score, _ = score_submission(actual, actual)\n score = fold_score / max_fold_score\n\n # calc accuracy, f1 macro\n accuracy_stance = score_calculation.get_accuracy(y_predicted, y_all, stance=True)\n accuracy_related = score_calculation.get_accuracy(y_predicted, y_all, stance=False)\n f1_stance = score_calculation.get_f1score(y_predicted, y_all, stance=True)\n f1_related = score_calculation.get_f1score(y_predicted, y_all, stance=False)\n\n # printout results\n printout = printout_manager.get_holdout_printout(save_folder, accuracy_related, accuracy_stance, f1_related,\n f1_stance, score)\n print(\"SANITY CHECK (predict on train data):\")\n print(printout)\n return clf","def separate(self):\n print(\"start dataset separating\")\n sum = 0\n for i in tqdm(range(len(self.itemlen))):\n il = self.itemlen[i]\n if il < 3:\n sum += il\n continue\n rarr = list(range(sum, sum+il))\n random.shuffle(rarr)\n self.train.append({\n 'input': self.input[rarr[0]],\n 'label': self.label[i]\n })\n self.val.append({\n 'input': self.input[rarr[1]],\n 'label': self.label[i]\n })\n for j in range(2, len(rarr)):\n self.test.append({\n 'input': self.input[rarr[j]],\n 'label': self.label[i]\n })\n sum += il","def train_test_split(self):\n random.seed(self.args.seed)\n nodes = [node for node in range(self.ncount)]\n random.shuffle(nodes)\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.args.training_size+self.args.validation_size])\n self.test_nodes = torch.LongTensor(nodes[self.args.training_size+self.args.validation_size:])","def train_batches(feature_matrix,y):\r\n X_org,y_org = shuffle(feature_matrix, y, random_state=13)\r\n \r\n # Splitting 20% of dataset to be test later\r\n X_train_org, X_test_org, y_train_org, y_test_org = train_test_split(X_org, y_org,test_size=0.20)\r\n X = X_train_org\r\n y = y_train_org\r\n \r\n \r\n for name, clf in classifiers:\r\n inc = Incremental(clf, scoring='accuracy')\r\n batch_size=5000\r\n counter=0\r\n train_acc = [] \r\n test_acc = []\r\n \r\n # Initializing Standard Scaler and IPCA for each classifier\r\n \r\n SS = StandardScaler()\r\n # IPCA = IncrementalPCA(n_components = 500)\r\n n=1\r\n print(\"Training \", name,\".......\\n\")\r\n for j in range(80):\r\n if counter >= len(X):\r\n break\r\n \r\n # Splitting each batch into training and validation datset\r\n X_train, X_test, y_train, y_test = train_test_split(X[counter:counter+batch_size], y[counter:counter+batch_size],test_size=0.25)\r\n print(\"Iteration:\",n)\r\n \r\n classes = da.unique(y_train).compute()\r\n \r\n # Feature Scaling\r\n SS.partial_fit(np.asarray(X_train))\r\n SS.transform(np.asarray(X_test))\r\n \r\n # Feature Decomposition\r\n # IPCA.partial_fit(X_train)\r\n # IPCA.transform(X_test)\r\n \r\n # Partial fitting - Stochastic Gradient Descent\r\n inc.partial_fit(X_train, y_train, classes=classes)\r\n print('Training Score:', inc.score(X_train, y_train))\r\n print('Validation Score:', inc.score(X_test, y_test))\r\n print(\"\\n\")\r\n \r\n # Concatenating batch scores\r\n train_acc.append(inc.score(X_train, y_train)) \r\n test_acc.append(inc.score(X_test, y_test)) \r\n \r\n if(len(X)-counter < batch_size):\r\n batch_size = len(X)-counter\r\n counter += batch_size\r\n n += 1\r\n \r\n \r\n # Savings the model\r\n filename = r'C:\\PythonCodes\\MM803\\code\\Outputs\\New\\f_canny_'+name+'.sav'\r\n pickle.dump(inc, open(filename, 'wb'))\r\n \r\n # Printing Model Accuracy\r\n print(name,\" MODEL ACCURACY\")\r\n print(\"_______________________\")\r\n print(\"Avg Training Accuracy of \", name,\":\", statistics.mean(train_acc)) \r\n print(\"Avg Test Accuracy \", name,\":\",statistics.mean(test_acc))\r\n \r\n \r\n # Testing on Unseen Data\r\n SS.transform(np.asarray(X_test_org[:5000]))\r\n # IPCA.transform(X_test_org[:5000])\r\n print('\\nFinal Testing Score on Unseen data 1 by ', name,':', inc.score(X_test_org[:10], y_test_org[:10]))\r\n print('Final Testing Score on Unseen data 2 by ', name,':', inc.score(X_test_org[10:100], y_test_org[10:100]))\r\n print('Final Testing Score on Unseen data 3 by ', name,':', inc.score(X_test_org[500:1000], y_test_org[500:1000]))\r\n \r\n print('\\n\\nClassification Report of', name)\r\n print('------------------------------------')\r\n print(classification_report(y_test_org[:5000],inc.predict(X_test_org[:5000]), digits = 4))\r\n print('====================================')\r\n print('\\n')\r\n \r\n # Saving the trained StandardScaler to be used for testing\r\n filename_ss = r'C:\\PythonCodes\\MM803\\code\\Outputs\\New\\f_canny_SS.sav'\r\n pickle.dump(SS, open(filename_ss, 'wb'))\r\n \r\n # Saving the trained Incremental PCA to be used for testing\r\n #filename_ipca = r'C:\\PythonCodes\\MM803\\code\\Outputs\\New\\f_hed_IPCA.sav'\r\n #pickle.dump(IPCA, open(filename_ipca, 'wb')) \r","def _train_model(\n self,\n dataset: DatasetEntity,\n ):\n logger.info(\"init data cfg.\")\n self._data_cfg = ConfigDict(data=ConfigDict())\n\n for cfg_key, subset in zip(\n [\"train\", \"val\", \"unlabeled\"],\n [Subset.TRAINING, Subset.VALIDATION, Subset.UNLABELED],\n ):\n subset = get_dataset(dataset, subset)\n if subset and self._data_cfg is not None:\n self._data_cfg.data[cfg_key] = ConfigDict(\n otx_dataset=subset,\n labels=self._labels,\n )\n\n self._is_training = True\n\n self._init_task()\n\n cfg = self.configure(True, None)\n logger.info(\"train!\")\n\n timestamp = time.strftime(\"%Y%m%d_%H%M%S\", time.localtime())\n\n # Environment\n logger.info(f\"cfg.gpu_ids = {cfg.gpu_ids}, distributed = {cfg.distributed}\")\n env_info_dict = collect_env()\n env_info = \"\\n\".join([(f\"{k}: {v}\") for k, v in env_info_dict.items()])\n dash_line = \"-\" * 60 + \"\\n\"\n logger.info(f\"Environment info:\\n{dash_line}{env_info}\\n{dash_line}\")\n\n # Data\n datasets = [build_dataset(cfg.data.train)]\n\n if self._train_type == TrainType.Semisupervised:\n # forward the knowledge of num iters per epoch to model for filter loss\n bs_per_gpu = cfg.data.train_dataloader[\"samples_per_gpu\"]\n actual_bs = bs_per_gpu * torch.distributed.get_world_size() if cfg.distributed else bs_per_gpu\n cfg.model.num_iters_per_epoch = math.ceil(len(datasets[0]) / actual_bs)\n\n # FIXME: Currently segmentor does not support multi batch evaluation.\n # For the Self-SL case, there is no val data. So, need to check the\n\n if \"val\" in cfg.data and \"val_dataloader\" in cfg.data:\n cfg.data.val_dataloader[\"samples_per_gpu\"] = 1\n\n # Target classes\n if \"task_adapt\" in cfg:\n target_classes = cfg.task_adapt.final\n else:\n target_classes = datasets[0].CLASSES\n\n # Metadata\n meta = dict()\n meta[\"env_info\"] = env_info\n meta[\"seed\"] = cfg.seed\n meta[\"exp_name\"] = cfg.work_dir\n if cfg.checkpoint_config is not None:\n cfg.checkpoint_config.meta = dict(\n mmseg_version=__version__ + get_git_hash()[:7],\n CLASSES=target_classes,\n )\n\n # Model\n model = self.build_model(cfg, fp16=cfg.get(\"fp16\", False), is_training=self._is_training)\n model.train()\n model.CLASSES = target_classes\n\n if cfg.distributed:\n convert_sync_batchnorm(model)\n\n validate = bool(cfg.data.get(\"val\", None))\n\n if self._hyperparams.learning_parameters.auto_adapt_batch_size != BatchSizeAdaptType.NONE:\n train_func = partial(train_segmentor, meta=deepcopy(meta), model=deepcopy(model), distributed=False)\n adapt_batch_size(\n train_func,\n cfg,\n datasets,\n isinstance(self, NNCFBaseTask), # nncf needs eval hooks\n not_increase=(self._hyperparams.learning_parameters.auto_adapt_batch_size == BatchSizeAdaptType.SAFE),\n )\n\n train_segmentor(\n model,\n datasets,\n cfg,\n distributed=cfg.distributed,\n validate=validate,\n timestamp=timestamp,\n meta=meta,\n )\n\n # Save outputs\n output_ckpt_path = os.path.join(cfg.work_dir, \"latest.pth\")\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \"best_mDice_*.pth\"))\n if len(best_ckpt_path) > 0:\n output_ckpt_path = best_ckpt_path[0]\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \"best_mIoU_*.pth\"))\n if len(best_ckpt_path) > 0:\n output_ckpt_path = best_ckpt_path[0]\n return dict(\n final_ckpt=output_ckpt_path,\n )","def worker(selection_idx, results_table):\n randgen = np.random.RandomState()\n \n # Data-specific positive set partition (the real-world dataset consists of multiple motif classes, always exactly 3 instances of each class stored consequently).\n # The partition assures that the training and test sets do not share instances of the same motif class\n positive_n_train = round(0.8 * len(positive_set_) / 3) * 3\n block_start_idx = randgen.randint(positive_n_train / 3 + 1) * 3 \n block_end_idx = block_start_idx + len(positive_set_) - positive_n_train\n positive_set_part_train, positive_set_part_test = (np.concatenate((positive_set_[: block_start_idx], positive_set_[block_end_idx: ])), positive_set_[block_start_idx: block_end_idx])\n \n # Negative set partition with random selection of elements to match the size of the positive set\n negative_set = negative_set_[randgen.choice(len(negative_set_), size = positive_set_.shape[0], replace = False)]\n negative_n = len(negative_set)\n negative_n_train = round(negative_n * 0.8)\n negative_set_part_train, negative_set_part_test = (negative_set[: negative_n_train], negative_set[negative_n_train: ])\n \n data_part_train = np.float64(np.concatenate((positive_set_part_train, negative_set_part_train)))\n labels_part_train = np.concatenate((np.ones(len(positive_set_part_train), dtype = 'i1'), np.zeros(len(negative_set_part_train), dtype = 'i1')))\n data_part_test = np.float64(np.concatenate((positive_set_part_test, negative_set_part_test)))\n labels_part_test = np.concatenate((np.ones(len(positive_set_part_test), dtype = 'i1'), np.zeros(len(negative_set_part_test), dtype = 'i1')))\n \n # Specifying the pipeline and the CV structure\n pruner = feature_selection.VarianceThreshold()\n scaler = preprocessing.StandardScaler()\n feature_selector = feature_selection.SelectKBest(feature_selection.f_classif)\n classifier = svm.SVC(kernel = 'rbf', gamma = 0.01, class_weight = 'balanced')\n pipeline0 = pipeline.Pipeline([\n ('pruning', pruner),\n ('scaling', scaler),\n ('selection', feature_selector),\n ('classification', classifier)\n ])\n cv_structure = model_selection.StratifiedShuffleSplit(n_splits = 10, test_size = 0.2)\n scoring = 'recall_macro' #same as balanced accuracy\n grid = model_selection.GridSearchCV(pipeline0, scoring = scoring, param_grid = param_grid, cv = cv_structure, n_jobs = 1)\n \n # Training the pipeline, saving the data\n grid.fit(data_part_train, labels_part_train)\n results_table[selection_idx][0] = np.log10(grid.best_params_['classification__C'])\n results_table[selection_idx][1] = grid.best_params_['selection__k']\n results_table[selection_idx][2] = grid.best_score_\n \n # Testing the pipeline, saving the data\n results_table[selection_idx][3] = grid.score(data_part_test, labels_part_test)","def finetuned():\n launch_training_on_all_splits(experiment='full', splits=NAME_SPLIT, base_model='ft', dropout=0.7304, learning_rate=0.0000976)","def train(self, train_dataset, val_dataset):\n\n # check fine_tuning option\n model_path = os.path.join(self.check_point, 'model.pt')\n if self.fine_tune and not os.path.exists(model_path):\n raise Exception('Cannot find %s.' % model_path)\n elif self.fine_tune and os.path.exists(model_path):\n if self.verbose:\n print('Loading %s for finetuning.' % model_path)\n self.model = torch.load(model_path)\n '''\n if isinstance(net, torch.nn.DataParallel):\n net = net.module\n model_dict = self.model.state_dict()\n net_dict = net.state_dict()\n # 1. filter out unnecessary keys\n pretrained_dict = {k: v for k, v in net_dict.items() if k in model_dict}\n # 2. overwrite entries in the existing state dict\n model_dict.update(pretrained_dict)\n # 3. load the new state dict\n self.model.load_state_dict(model_dict)\n '''\n self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)\n\n # capture best model\n best_val_psnr = -1\n best_psnr = -1\n best_model_state = self.model.state_dict()\n\n with open(os.path.join(self.check_point, 'PSNR' + '.txt'), 'w') as f:\n # Train the model\n for epoch in range(self.num_epochs):\n self._epoch_step(train_dataset, epoch)\n self.scheduler.step()\n\n if epoch % 10 == 0:\n if self.verbose:\n print('Computing PSNR...')\n\n # capture running PSNR on train and val dataset\n train_psnr, train_ssim, _, _, _ = self._check_PSNR(val_dataset)\n self.hist_train_psnr.append(train_psnr)\n\n f.write('epoch%d:\\t%.3f\\n' % (epoch, train_psnr))\n\n if self.verbose:\n print('Average train PSNR:%.3fdB average ssim: %.3f' % (train_psnr, train_ssim))\n print('')\n if best_psnr < train_psnr:\n best_psnr = train_psnr\n # write the model to hard-disk for testing\n if not os.path.exists(self.check_point):\n os.makedirs(self.check_point)\n model_path = os.path.join(self.check_point, 'model.pt')\n torch.save(self.model, model_path)\n print(' Best average psnr: %.3f' % (best_psnr))\n print('')","def main(args):\n \n ## Load & Preprocess data \n if args.data_name == 'amsterdam': \n file_name = '../data/amsterdam/test_longitudinal_data.csv'\n ori_data = data_preprocess(file_name, args.max_seq_len)\n \n # Divide the data into training and testing\n divided_data, _ = data_division(ori_data, seed = args.seed, divide_rates = [args.train_rate, 1-args.train_rate])\n \n train_data = np.asarray(divided_data[0])\n test_data = np.asarray(divided_data[1])\n\n print('Finish data loading: ' + str(args.data_name)) \n \n ## Run hider algorithm\n if args.hider_model == 'timegan':\n generated_data = timegan.timegan(train_data)\n elif args.hider_model == 'add_noise':\n generated_data = add_noise.add_noise(train_data, args.noise_size) \n print('Finish hider algorithm training') \n \n ## Define enlarge data and its labels\n enlarge_data = np.concatenate((train_data, test_data), axis = 0)\n enlarge_data_label = np.concatenate((np.ones([train_data.shape[0],]), np.zeros([test_data.shape[0],])), axis = 0)\n \n # Mix the order\n idx = np.random.permutation(enlarge_data.shape[0])\n enlarge_data = enlarge_data[idx]\n enlarge_data_label = enlarge_data_label[idx]\n \n ## Run seeker algorithm\n reidentified_data = knn_seeker(generated_data, enlarge_data)\n \n print('Finish seeker algorithm training') \n \n ## Evaluate the performance\n # 1. Feature prediction\n feat_idx = np.random.permutation(train_data.shape[2])[:args.feature_prediction_no]\n ori_feat_pred_perf = feature_prediction(train_data, test_data, feat_idx)\n new_feat_pred_perf = feature_prediction(generated_data, test_data, feat_idx)\n \n feat_pred = [ori_feat_pred_perf, new_feat_pred_perf]\n \n print('Feature prediction results: ' + \n '(1) Ori: ' + str(np.round(ori_feat_pred_perf, 4)) + \n '(2) New: ' + str(np.round(new_feat_pred_perf, 4)))\n \n # 2. One step ahead prediction\n ori_step_ahead_pred_perf = one_step_ahead_prediction(train_data, test_data)\n new_step_ahead_pred_perf = one_step_ahead_prediction(generated_data, test_data)\n \n step_ahead_pred = [ori_step_ahead_pred_perf, new_step_ahead_pred_perf]\n \n print('One step ahead prediction results: ' + \n '(1) Ori: ' + str(np.round(ori_step_ahead_pred_perf, 4)) + \n '(2) New: ' + str(np.round(new_step_ahead_pred_perf, 4)))\n \n # 3. Reidentification score\n reidentification_score = reidentify_score(enlarge_data_label, reidentified_data)\n \n print('Reidentification score: ' + str(np.round(reidentification_score, 4)))\n \n shutil.rmtree('tmp')\n \n return feat_pred, step_ahead_pred, reidentification_score","def train(self, training_data):\n pass","def run_training(self, schema_params, export_model=False, output_model_dir=None):\n # Log distributed execution context, which includes cluster configuration\n logger.info(f\"Commencing {self.effect_name} training\")\n logger.info(f\"Execution context : {self.execution_context}\")\n\n # Create partition_index_list\n partition_index_list = self._get_partition_list()\n logger.info(f\"This worker on work on the following list of partitions : {partition_index_list}\")\n\n # Sequentially train model on partitions\n for partition_index in partition_index_list:\n logger.info(f\"Commencing {self.effect_name} training for partition index : {partition_index}\")\n\n # Resolve partitioned data directory from raw path params from user\n checkpoint_path = self._anchor_directory(\n self.model.checkpoint_path,\n partition_index)\n training_data_dir = self._anchor_directory(self.model.training_data_dir,\n partition_index)\n validation_data_dir = self._anchor_directory(self.model.validation_data_dir,\n partition_index) if self.model.validation_data_dir else None\n\n if is_empty_directory(training_data_dir):\n logger.info(f\"{training_data_dir} is empty, no dataset to train on.\")\n continue\n # Train model\n self.execution_context[constants.PARTITION_INDEX] = partition_index\n self.model.train(training_data_dir=training_data_dir,\n validation_data_dir=validation_data_dir,\n metadata_file=self.model.metadata_file,\n checkpoint_path=checkpoint_path,\n execution_context=self._prepare_training_context(partition_index),\n schema_params=schema_params)\n\n # Chief should export model\n is_chief = self.execution_context[constants.IS_CHIEF]\n if export_model and is_chief:\n logger.info(f\"Exporting model to directory : {output_model_dir}\")\n self.model.export(output_model_dir=output_model_dir)","def train(self, args_hpo, index):\n\n PrintColors.prYellow(f'\\n===== training with: {args_hpo} index={index}')\n PrintColors.prGreen(f'---- in mode: {self.configurations.execution_mode}, tag: {self.configurations.tag} ----')\n ''' ============ LOAD DATA ================================================================================ '''\n starting_time = time.time()\n dataset_reader = self.dataset_reader(\n candidate_types=self.configurations.clustering_mode,\n word_indexer={'words': PretrainedTransformerIndexer(self.configurations.pretrained_model_name)},\n mode=self.configurations.loading_mode)\n ''' .read returns list of instances '''\n train_data, val_data, test_data = (dataset_reader.read(folder) for folder in\n [self.configurations.train_data_dir,\n self.configurations.val_data_dir,\n self.configurations.test_data_dir])\n\n # count state pairs\n preceeds = dict()\n\n for instance in train_data:\n for ind in range(len(instance.fields['squeezed_labels'].tokens) - 1):\n [event_1, event_2] = [instance.fields['squeezed_labels'].tokens[i].text for i in [ind, ind + 1]]\n scenario = self.dataset_reader.scenario_of_label(event_1)\n if scenario not in preceeds:\n preceeds[scenario] = dict()\n if (event_1, event_2) not in preceeds[scenario]:\n preceeds[scenario][(event_1, event_2)] = 0\n preceeds[scenario][(event_1, event_2)] += 1\n\n pretrained_tokenizer = PretrainedTransformerTokenizer(self.configurations.pretrained_model_name)\n supply_token_indices(train_data + val_data, 'story', pretrained_tokenizer)\n\n ''' build vocabulary and associate it with datasets '''\n vocabulary = Vocabulary.from_instances(train_data + val_data)\n train_data.index_with(vocabulary), val_data.index_with(vocabulary)\n\n train_data_loader = DataLoader(dataset=train_data, batch_size=args_hpo.batch_size)\n val_data_loader = DataLoader(dataset=val_data, batch_size=args_hpo.batch_size)\n\n ''' ============ DEFINE MODEL ============================================================================= '''\n ''' i keep .to() here instead of in model.__init__() to accomadate better abstraction '''\n event_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\n if '#' in vocabulary.get_token_from_index(i, 'scr_labels')]\n participant_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\n if '@' in vocabulary.get_token_from_index(i, 'scr_labels')]\n model = self.model(args_hpo, vocabulary, configurations=self.configurations,\n preceeds=preceeds,\n event_indices=event_labels,\n participant_indices=participant_labels).to(self.configurations.device)\n\n ''' ============ DEFINE TRAINER =========================================================================== '''\n ''' -- serialization --------------------------------------------------- '''\n if not os.path.exists(os.path.join(*['.', 'models'])):\n os.mkdir(os.path.join(*['.', 'models']))\n if index == 0:\n for file in os.listdir(os.path.join(*['.', 'models'])):\n path = os.path.join(*['.', 'models', file])\n if os.path.isfile(path):\n os.remove(path)\n else:\n shutil.rmtree(path)\n serialization_path = 'models_{}_{}'.format(self.configurations.tag, index)\n serialization_path_longer = os.path.join(*['.', 'models', serialization_path])\n vocab_path = 'vocab_{}_{}'.format(self.configurations.tag, index)\n vocab_dir_longer = os.path.join(*['.', 'models', vocab_path])\n if not os.path.exists(serialization_path_longer):\n os.mkdir(serialization_path_longer)\n model_checkpointer = Checkpointer(serialization_dir=serialization_path_longer, num_serialized_models_to_keep=1)\n ''' -- logging ---------------------------------------------------------- '''\n tensorboard_writer = TensorboardWriter(serialization_dir='tensorboard', summary_interval=1)\n if index == 0:\n shutil.rmtree(os.path.join(*['.', 'tensorboard', 'log']))\n\n optimizer = torch.optim.Adam(model.parameters(), lr=args_hpo.lr, weight_decay=args_hpo.l2)\n trainer = GradientDescentTrainer(\n model=model,\n optimizer=optimizer,\n data_loader=train_data_loader,\n validation_data_loader=val_data_loader,\n # note: this is the metric for early stopping\n validation_metric='-loss',\n patience=self.configurations.patience,\n num_epochs=self.configurations.max_epochs,\n serialization_dir=serialization_path_longer,\n checkpointer=model_checkpointer,\n cuda_device=self.configurations.device,\n grad_norm=args_hpo.clip,\n tensorboard_writer=tensorboard_writer,\n learning_rate_scheduler=ReduceOnPlateauLearningRateScheduler(optimizer=optimizer)\n )\n\n ''' trainer saves the model, but the vocabulary needs to be saved, too '''\n vocabulary.save_to_files(vocab_dir_longer)\n\n ''' check the metric names to synchronize with the class '''\n metrics = trainer.train()\n test_metrics = model.test(test_data=test_data, dataset_reader=dataset_reader)\n metrics.update(test_metrics)\n metrics['time_consumed(hrs)'] = round((time.time() - starting_time) / 3600, 4)\n\n return metrics","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train_data_split(self, selected_sr, selected_ss):\n \"\"\"\n Arguments:\n selected_sr: ordinal number of the selected split ratio\n selected_ss: ordinal number of split shift\n \"\"\"\n assert selected_sr < len(self.split_ratios),\\\n \"The total number of possible split ratios is: %d\"\\\n % len(self.split_ratios)\n\n max_shifts = 100 / self.split_ratios[selected_sr][-1]\n\n assert selected_ss < max_shifts,\\\n \"The total number of split shifts is: %d\" % max_shifts\n\n self.empty_split()\n\n n = float(self.n_train) / max_shifts\n self.n_develop = int(self.split_ratios[selected_sr][0] /\n (100 / max_shifts) * n)\n\n self.n_valid = int(self.split_ratios[selected_sr][1] /\n (100 / max_shifts) * n)\n\n self.n_eval = self.n_train - self.n_develop - self.n_valid\n\n for i in range(self.n_develop):\n self.development_subjects.\\\n append(self.training_subjects[(selected_ss * self.n_eval + i) %\n self.n_train])\n\n for i in range(self.n_valid):\n self.validation_subjects.\\\n append(self.training_subjects[(selected_ss * self.n_eval +\n self.n_develop + i) %\n self.n_train])\n\n for i in range(self.n_eval):\n self.evaluation_subjects.\\\n append(self.training_subjects[(selected_ss * self.n_eval +\n self.n_develop +\n self.n_valid + i) %\n self.n_train])","def create_cub200_task_distribution(path_to_pkl,\n num_training_samples_per_class=10,\n num_test_samples_per_class=15,\n num_training_classes=20,\n meta_batch_size=5):\n\n global cub200_trainX\n global cub200_trainY\n\n global cub200_valX\n global cub200_valY\n\n global cub200_testX\n global cub200_testY\n\n\n with open(path_to_pkl, 'rb') as f:\n d = pickle.load(f)\n cub200_X, cub200_Y = d['dataset']\n\n cub200_X = cub200_X.astype(np.float32) / 255.0\n cub200_X = (cub200_X - np.asarray((0.4914, 0.4822, 0.4465))) / np.asarray((0.2023, 0.1994, 0.2010))\n\n #\n # TODO\n # random horiz flip + normalize by: \n # transforms.Normalize((0.4914, 0.4822, 0.4465),\n # (0.2023, 0.1994, 0.2010)) (mean, std)\n\n\n\n #np.random.seed(0)\n # TODO: shuffle allocation of class indices to train/val/test\n num_train = 100\n num_val = 50\n num_test = 50\n\n classes = list(set(cub200_Y))\n train_classes = classes[:num_train]\n val_classes = classes[num_train:(num_train+num_val)]\n test_classes = classes[(num_train+num_val):]\n\n train_indices = []\n val_indices = []\n test_indices = []\n\n for i in range(len(cub200_Y)):\n if cub200_Y[i] in train_classes:\n train_indices.append(i)\n elif cub200_Y[i] in val_classes:\n val_indices.append(i)\n elif cub200_Y[i] in test_classes:\n test_indices.append(i)\n\n cub200_trainX = cub200_X[train_indices]\n cub200_trainY = cub200_Y[train_indices]\n\n cub200_valX = cub200_X[val_indices]\n cub200_valY = cub200_Y[val_indices]\n\n cub200_testX = cub200_X[test_indices]\n cub200_testY = cub200_Y[test_indices]\n\n\n train_tasks_list = [ClassificationTask(cub200_trainX,\n cub200_trainY,\n num_training_samples_per_class,\n num_test_samples_per_class,\n num_training_classes,\n split_train_test=0.5)]\n\n # TODO: NOTE: HACK -- validation and test tasks use a fixed number of test-set samples, instead of the supplied\n # ones. This is because in MAML/FOMAML the test set is used to compute the meta-gradient, and a small number of\n # samples is used (in the philosophy of few-shot learning, where only few samples are available).\n # However, in this case we wish to use a few more test-samples to better estimate the accuracy of the model on the validation\n # and test tasks!\n num_test_samples_per_class = 20\n validation_tasks_list = [ClassificationTask(cub200_valX,\n cub200_valY,\n num_training_samples_per_class,\n num_test_samples_per_class,\n num_training_classes,\n split_train_test=0.5)]\n\n test_tasks_list = [ClassificationTask(cub200_valX,\n cub200_valY,\n num_training_samples_per_class,\n num_test_samples_per_class,\n num_training_classes,\n split_train_test=0.5)]\n\n metatrain_task_distribution = TaskDistribution(tasks=train_tasks_list,\n task_probabilities=[1.0],\n batch_size=meta_batch_size,\n sample_with_replacement=True,\n use_classes_only_once=True)\n\n metaval_task_distribution = TaskDistribution(tasks=validation_tasks_list,\n task_probabilities=[1.0],\n batch_size=meta_batch_size,\n sample_with_replacement=True,\n use_classes_only_once=True)\n\n metatest_task_distribution = TaskDistribution(tasks=test_tasks_list,\n task_probabilities=[1.0],\n batch_size=meta_batch_size,\n sample_with_replacement=True,\n use_classes_only_once=True)\n\n return metatrain_task_distribution, metaval_task_distribution, metatest_task_distribution","def process_data(train_file, test_file):\n y_train, tx_train, ids_train, y_test, tx_test, ids_test = load(train_file, test_file)\n header_train = get_header(train_file)\n header_test = get_header(test_file)\n print('\\nData set will be split into four, each representing data with different jet numbers.')\n for jet_num in range(4):\n print('\\nProcess training set with jet number = ' + str(jet_num) + '...')\n y_train_jet, tx_train_jet, ids_train_jet = split_data(y_train, tx_train, ids_train, jet_num)\n columns_to_remove = analyze(tx_train_jet)\n tx_train_jet, header_train_jet = remove_columns(tx_train_jet, header_train, columns_to_remove)\n create_csv('train_jet_' + str(jet_num) + '.csv', y_train_jet, tx_train_jet, ids_train_jet, header_train_jet, False)\n print('\\n... created train_jet_' + str(jet_num) + '.csv file.')\n print('\\nProcess test set with jet number = ' + str(jet_num) + '...')\n y_test_jet, tx_test_jet, ids_test_jet = split_data(y_test, tx_test, ids_test, jet_num)\n columns_to_remove = analyze(tx_test_jet)\n tx_test_jet, header_test_jet = remove_columns(tx_test_jet, header_test, columns_to_remove)\n create_csv('test_jet_' + str(jet_num) + '.csv', y_test_jet, tx_test_jet, ids_test_jet, header_test_jet, True)\n print('\\n... created test_jet_' + str(jet_num) + '.csv file.')","def prediction(prediction_file_name, clusters_list, svd_use_flag):\n \n coords = misc_functions.getWindowCoords()\n \n test_users = range(coords[0], coords[2] + 1) \n test_items = range(coords[1], coords[3] + 1)\n \n #print \"len(test_users) = \", len(test_users)\n #print \"len(test_items) = \", len(test_items)\n #print \"test_items = \", test_items\n \n # this matrix to be written as result finally\n #misc_functions.step()\n prediction_matrix = zeros((len(test_users), len(test_items)), dtype = float)\n \n training_matrix = scipy.io.mmio.mmread(\"history.mtx\").tocsr()\n \n item_X_meta_matrix = scipy.io.mmio.mmread(\"../../../well_done/items-metas_global.mtx\").toarray()\n \n # getting meta matrices for corresponding using metas\n meta_ctr = 0\n meta_matrices = []\n for meta in METAS_TO_USE:\n if svd_use_flag:\n meta_matrice_file_name = \"users-\" + METAS_TO_USE[meta] + \".svd.mtx\"\n else:\n meta_matrice_file_name = \"users-\" + METAS_TO_USE[meta] + \".mtx\"\n exec(\"meta_matrices.append(scipy.io.mmio.mmread(\\\"\" + meta_matrice_file_name + \"\\\").toarray())\")\n\n #user_counter = 0\n #for user in test_users:\n for cur_cluster in clusters_list:\n \n #print \"cur_cluster[0] = \", cur_cluster[0]\n user = int (cur_cluster[0].split(\"\\t\")[1])\n #print \"user #\", user\n \n #user_metas = {} - changed to list because of problem with dimension\n user_metas = []\n \n values = zeros((len(METAS_TO_USE), len(test_items)), dtype = float)\n meta_ctr = 0\n for meta in METAS_TO_USE:\n \n #print \" meta_matrices = \", meta_matrices\n #print \" meta_matrices[meta_ctr] = \", meta_matrices[meta_ctr]\n user_vector = meta_matrices[meta_ctr][user]\n #print \" user_vector = \", user_vector\n #print \" len(user_metas) = \", len(user_metas)\n #print \" meta_ctr = \", meta_ctr\n #print \"meta = \", meta\n #misc_functions.step()\n \n # normalizing counts of visited metas to use them as weights later\n if max(user_vector) != 0:\n user_metas.append(1.0 * user_vector / max(user_vector))\n else:\n user_metas.append(zeros((len(user_vector), ), dtype = float))\n #print \" user_metas[meta_ctr] = \", user_metas[meta_ctr]\n #print \" user_metas[meta_ctr].shape = \", user_metas[meta_ctr].shape\n \n #for item in test_items:\n for cluster in cur_cluster[1 : ]:\n start_cluster_item = int(cluster.split(\"\\t\")[0])\n stop_cluster_item = int(cluster.split(\"\\t\")[2])\n \n cluster_items = range(start_cluster_item, stop_cluster_item + 1)\n \n for item in cluster_items:\n meta_value = item_X_meta_matrix[item, meta]\n \n # PRICE\n if meta == 8:\n meta_value = priceToPriceCat(meta_value)\n \n # CITY HEURISTIC\n if meta == 11:\n if user_metas[meta_ctr][meta_value - 1] < CITY_TRESHOLD:\n values[:, item - coords[1]] *= CITY_COEF\n \"\"\"\n # DAYTIME\n if meta == 17:\n meta_value = dayTime(meta_value)\n \"\"\"\n \n #print \" meta_value = \", meta_value\n #print \" item = \", item\n #step()\n values[meta_ctr][item - coords[1]] = (user_metas[meta_ctr])[meta_value - 1]\n \n \"\"\"HEURISTICS \"\"\"\n \n \n \n \n \n \"\"\"\\\\ HEURISTICS \"\"\"\n\n meta_ctr += 1\n #print \"values[:, 0:10] = \", values[:, 0:10]\n prediction_vector = numpy.sum(META_WEIGHTS * values, axis = 0)\n #print \"prediction_vector[0:10] = \", prediction_vector[0:10]\n #print \"sum(prediction_vector) = \", sum(prediction_vector)\n prediction_matrix[user - coords[0]] = prediction_vector\n \n #step()\n \n# ===== END OF MAIN CYCLE ===== \n\n result_matrix = scipy.sparse.csr_matrix(prediction_matrix)\n scipy.io.mmio.mmwrite(prediction_file_name, result_matrix, field = 'real', precision = 5)","def __init__(self, sc, dataset_path):\n\n logger.info(\"Starting up the Recommendation Engine: \")\n\n self.sc = sc\n\n\t#Load cusomer data for later use\n\t\n logger.info(\"Loading Customer data...\")\n customer_file_path = os.path.join(dataset_path, 'tpo_customer.csv')\n customer_raw_RDD = self.sc.textFile(customer_file_path)\n customer_raw_data_header = customer_raw_RDD.take(1)[0]\n self.customer_RDD = customer_raw_RDD.filter(lambda line: line!=customer_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[4]),(tokens[5]),(tokens[6]),(tokens[7]))).cache()\n\tlogger.info(\"Loading Customer data success...\")\n\t#CUSTOMCUSTOMER_NAME,CUSTOMER_ADDRESS1,CUSTOMER_ADDRESS2,CUSTOMER_CITY,CUSTOMER_STATE,CUSTOMER_COUNTRY,CUSTOMER_ZIPCODE,CREATED_BY,CREATION_DATE,LAST_UPDATED_BY,LAST_UPDATE_DATE\n \n\n\n\t\n\t#Load turbine data for later use\t\n logger.info(\"Loading Turbine data...\")\n turbine_file_path = os.path.join(dataset_path, 'test_tpo_unit_config.csv')\n turbine_raw_RDD = self.sc.textFile(turbine_file_path)\n turbine_raw_data_header = turbine_raw_RDD.take(1)[0]\n self.turbine_RDD = turbine_raw_RDD.filter(lambda line: line!=turbine_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[5]),(tokens[34]),(tokens[51]),(tokens[35]))).cache()\n\tlogger.info(\"Loading Turbine data success...\")\n \n\t\n\t\n\t\n\t#Load site data for later use\t\n logger.info(\"Loading Site data...\")\n site_file_path = os.path.join(dataset_path, 'tpo_site.csv')\n site_raw_RDD = self.sc.textFile(site_file_path)\n site_raw_data_header = site_raw_RDD.take(1)[0]\n self.site_RDD = site_raw_RDD.filter(lambda line: line!=site_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[4]),(tokens[5]),(tokens[6]),(tokens[7]),(tokens[16]))).cache()\n\tlogger.info(\"Loading Site data success...\")\n\t\n\n\n\n\t# Load ratings data for later use\n logger.info(\"Loading Ratings data...\")\n ratings_file_path = os.path.join(dataset_path, 'ratings.csv')\n ratings_raw_RDD = self.sc.textFile(ratings_file_path)\n ratings_raw_data_header = ratings_raw_RDD.take(1)[0]\n self.ratings_RDD = ratings_raw_RDD.filter(lambda line: line!=ratings_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: (int(tokens[0]),int(tokens[1]),float(tokens[2]))).cache()\n # Load movies data for later use\n logger.info(\"Loading Movies data...\")\n movies_file_path = os.path.join(dataset_path, 'movies.csv')\n movies_raw_RDD = self.sc.textFile(movies_file_path)\n movies_raw_data_header = movies_raw_RDD.take(1)[0]\n self.movies_RDD = movies_raw_RDD.filter(lambda line: line!=movies_raw_data_header)\\\n .map(lambda line: line.split(\",\")).map(lambda tokens: (int(tokens[0]),tokens[1],tokens[2])).cache()\n self.movies_titles_RDD = self.movies_RDD.map(lambda x: (int(x[0]),x[1])).cache()\n # Pre-calculate movies ratings counts\n self.__count_and_average_ratings()\n\n # Train the model\n self.rank = 8\n self.seed = 5L\n self.iterations = 10\n self.regularization_parameter = 0.1\n self.__train_model()","def train(self, clfs, dataset):\n # TODO: implement stacking to help with resolving ties\n pass","def trainAndCalculate(self):\n f = open(\"congressional_voting_dataset.csv\")\n data = np.genfromtxt(fname = f, delimiter=',', dtype=str, encoding=None)\n X = data[:, :-1]\n y = data[:, -1]\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)\n self.svclassifier.fit(X_train, y_train)","def train_test_model_batch():\n train=learning.Train_kmer_clf()\n train.run()","def train(self):\n raise NotImplementedError","def prepare_train_data(self):\r\n ## Impute rlkpis\r\n print(\"Imputing rlKPI df\")\r\n self.rlkpi.add_target_labels(1)\r\n self.rlkpi.impute_rl_kpis()\r\n\r\n print(\"Add 'met-real-station_no' & met-forecast-station_no to rl_kpis_df\")\r\n self.add_met_real_forecast_station_col_to_rlkpis()\r\n print(\"Merge 'met-real-sampled df to rl kps \")\r\n self.merge_met_real_sampled_df_to_rlkpis()\r\n\r\n ## Imputations for met-forecast\r\n print(\"Impute met-forecast\")\r\n met_forecast_obj = self.metfcast\r\n met_forecast_obj.impute_met_forecast()\r\n\r\n #Merge met forecast data to earlier merged data\r\n print(\"Merge Train data with imputed forecast df\")\r\n self.train_data = pd.merge(self.train_data,\r\n met_forecast_obj.imputed_forecast_df,\r\n on=['datetime-station_no'], indicator=True, how='inner')\r\n print(\"Check any imputation needed\", self.train_data.isna().sum().sum())\r\n self.train_data.drop(['_merge'], axis=1, inplace=True)\r\n self.perform_data_under_sampling(self.train_data)","def computeSoftwareMLModels(df,data_label,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,group_col,model_type,ml_model,rank_features=False,compute_null=False,n_splits=10,n_repeats=10,n_jobs=1):\n software_list = df[data_label].unique()\n print('Running ML classifer on {} {}'.format(len(software_list),data_label))\n scores_concat_df = pd.DataFrame()\n feature_rank_concat_df = pd.DataFrame()\n external_scores_concat_df = pd.DataFrame()\n\n perf_pval_dict = {}\n for pipe in software_list:\n ml_df = df[df[data_label]==pipe]\n print('{} {}'.format(data_label, pipe))\n\n #cross_val_score\n scores_df, null_df, pvalue, feature_rank_df = getMLModelPerf(ml_df,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,model_type,ml_model,rank_features,compute_null,n_splits,n_repeats,n_jobs) \n scores_df[data_label] = np.tile(pipe,len(scores_df))\n scores_concat_df = scores_concat_df.append(scores_df)\n \n if compute_null:\n null_df[data_label] = np.tile('null',len(null_df))\n scores_concat_df = scores_concat_df.append(null_df)\n perf_pval_dict[pipe] = pvalue\n\n # RFECV\n if rank_features:\n feature_rank_df[data_label] = np.tile(pipe,len(feature_rank_df))\n feature_rank_concat_df = feature_rank_concat_df.append(feature_rank_df)\n\n # explicit CV for internal vs external perfomance\n if group_col:\n external_scores_df = getIndependentTestSetPerf(ml_df,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,group_col,model_type,ml_model)\n external_scores_df[data_label] = np.tile(pipe,len(external_scores_df))\n external_scores_concat_df = external_scores_concat_df.append(external_scores_df) \n\n return scores_concat_df, perf_pval_dict, feature_rank_concat_df, external_scores_concat_df","def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n\n # Scale the data so that Euclidian distance makes sense\n means = np.mean(data, axis = 0)\n stddevs = np.std(data, axis = 0, ddof = 1)\n\n #print(means)\n #print(stddevs)\n\n data_scaled = np.zeros((n_examples, n_features))\n\n for i in range(n_features):\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\n\n study_correlation(data_scaled)\n\n # Initialize the centroids\n idx = np.random.randint(n_examples, size = n_clusters)\n centroids = data_scaled[idx, :]\n\n counter = 0\n\n while True:\n\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\n centroid_idx = np.argmin(distances, axis = 1)\n old_centroids = centroids\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\n #displacement = get_displacement(old_centroids, centroids)\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\n\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\n\n if counter == 0:\n# print(\"Initial displacement = {}\".format(displacement))\n initial_displacement = displacement\n\n counter += 1\n\n if displacement < (initial_displacement / 10000): break\n\n #print(\"Total number of loops before ending : {}\".format(counter))\n converted_predictions = convert_predictions(centroid_idx)\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def train_and_test(self, data):\n\n np.random.shuffle(data)\n datalist = self.unpack_data(data)\n\n logger.info('[*] 75-25 partition of datasets ...')\n\n markline1 = math.floor(0.75*(len(datalist['features'])))\n markline2 = math.floor(0.75*len(datalist['labels']))\n\n train_features = datalist['features'][:(markline1)]\n test_features = datalist['features'][(markline1):]\n \n train_labels = datalist['labels'][:(markline2)]\n test_labels = datalist['labels'][(markline2):]\n\n logger.info('[*] Training started with 75% Dataset ...')\n\n self.knn_model.fit(train_features, train_labels)\n\n logger.info('[*] Testing started with 25% Dataset ...')\n print('\\n/---------------Accuracy----------------/') \n \n accuracy = self.knn_model.score(train_features, train_labels)\n print('Test set accuracy {:.2f} %'.format(accuracy*100))\n\n if accuracy < 0.40:\n logger.warning('[-.-!] Thanks for tryin\\' but this machine ain\\'t learning.')\n\n return True","def train_model_pipeline(conform_shape=True, indi_proportion=0.50, incl_group_imgs=True,\r\n feature_extractor=flatten_array, model=train_logistic_regression): \r\n # Create dataframe subject to feature extractor requirements\r\n X_train, y_train, X_test_indi, y_test_indi, X_test_group, y_test_group = \\\r\n create_train_test_sets(conform_shape=conform_shape, indi_proportion=indi_proportion, \r\n incl_group_imgs=incl_group_imgs)\r\n \r\n # Extract features\r\n if feature_extractor == extract_ORB_features:\r\n if os.path.isfile('Trained_Models/Kmeans_model.sav'):\r\n kmeans_model = load_model('Trained_Models/Kmeans_model.sav')\r\n else:\r\n kmeans_model = kmeans_cluster(X_train, 500)\r\n X_train = feature_extractor(X_train, kmeans_model, normalize = False)\r\n X_test_indi = feature_extractor(X_test_indi, kmeans_model, normalize = False)\r\n X_test_group = feature_extractor(X_test_group, kmeans_model, normalize = False)\r\n\r\n else:\r\n X_train = feature_extractor(X_train)\r\n X_test_indi = feature_extractor(X_test_indi)\r\n X_test_group = feature_extractor(X_test_group)\r\n \r\n # Train model on flattened array (no feature extraction)\r\n trained_model = model(X_train, y_train)\r\n \r\n indi_pred_class, indi_accuracy = evaluate_model(trained_model, X_test_indi, y_test_indi)\r\n group_pred_class, group_accuracy = evaluate_model(trained_model, X_test_group, y_test_group)\r\n \r\n return trained_model, indi_pred_class, indi_accuracy, group_pred_class, group_accuracy","def trainOnFold(data, labels, outDir, numModels, partition, params):\n\ttrainPart, devPart = partition\n\n\t#partition the data and labels\n\ttrainX, trainY = partitionData(data, labels, trainPart)\n\tdevX, devY = partitionData(data, labels, devPart)\n\n\tmodels = []\n\n\t#train multiple models\n\tfor i in range(numModels):\n\n\t\tmodelDir = join(outDir, str(i))\n\n\t\tmkdir(modelDir)\n\n\t\t#setup logger\n\t\tlogger = makeLogger(modelDir, params.eventMap)\n\n\t\t#train model\n\t\tmodel, index = trainModel(trainX, trainY, devX, devY, logger, params)\n\n\t\t#make predictions\n\t\tpred = predictClasses(model, devX, params.batchSize)\n\n\t\t#evaluate using F1\n\t\tscore = evaluatePredictions(pred, params.eventMap.matrixToNames(devY), params.eventMap, False)\n\n\t\tmodels.append((score, i, index, model))\n\n\t\t#need to clean up after building a model\n\t\tb.clear_session()\n\n\t#return best model\n\treturn max(models)"],"string":"[\n \"def main_predefined_split():\\n\\n average_performance = []\\n fold_num = 'predefined'\\n output_file_folder = \\\"output/{}\\\".format(args.experiment_name)\\n output_file_name = \\\"{}/lnnel_{}.csv\\\".format(output_file_folder, fold_num)\\n Path(output_file_folder).mkdir(parents=True, exist_ok=True)\\n args.output_file_name = output_file_name\\n\\n if args.use_blink:\\n df_train = pd.read_csv(\\\"./data/lcquad/blink/lcquad_train_sorted.csv\\\")\\n df_test = pd.read_csv(\\\"./data/lcquad/blink/lcquad_test_sorted.csv\\\")\\n else:\\n df_train = pd.read_csv(\\\"./data/lcquad/dbpedia/lcquad_train_sorted.csv\\\")\\n df_test = pd.read_csv(\\\"./data/lcquad/dbpedia/lcquad_test_sorted.csv\\\")\\n\\n # filter out the questions with single positive or many negatives in trianing set\\n filtered_question_mentions = []\\n for qm in df_train.QuestionMention.unique():\\n df_ = df_train[df_train.QuestionMention == qm]\\n if df_.Label.sum() == 0:\\n filtered_question_mentions.append(qm)\\n if df_.Label.sum() == 1 and df_.shape[0] == 1:\\n filtered_question_mentions.append(qm)\\n # print(df_.Label.values)\\n df_train_split_filtered = df_train[~df_train.QuestionMention.isin(filtered_question_mentions)]\\n df_train_split_filtered = df_train_split_filtered.sort_values(by=['QuestionMention', 'Label'])\\n df_train = df_train_split_filtered\\n\\n # train\\n features_train = np.array(\\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_train.Features.values])\\n x_train = torch.from_numpy(features_train).float()\\n y_train = torch.from_numpy(df_train.Label.values).float().reshape(-1, 1)\\n m_labels_train = df_train.Mention_label.values\\n ques_train = df_train.Question.values\\n\\n # test\\n features_test = np.array(\\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_test.Features.values])\\n x_test = torch.from_numpy(features_test).float()\\n y_test = torch.from_numpy(df_test.Label.values).float().reshape(-1, 1)\\n m_labels_test = df_test.Mention_label.values\\n ques_test = df_test.Question.values\\n\\n # train model and evaluate\\n model = pick_model(args.model_name, args.alpha)\\n model = model.to(device)\\n\\n # move to gpu\\n x_train, y_train = x_train.to(device), y_train.to(device)\\n x_test, y_test = x_test.to(device), y_test.to(device)\\n\\n print(model)\\n\\n print(\\\"model: \\\", args.model_name, args.alpha)\\n print(model(x_train, m_labels_train))\\n\\n print(\\\"y_train sum\\\", sum(y_train), sum(y_train) / len(y_train))\\n print(\\\"y_test sum\\\", sum(y_test), sum(y_test) / len(y_test))\\n\\n # aggregate the data into train, val, and test\\n train_data = (x_train, y_train, m_labels_train, ques_train)\\n print(\\\"train:\\\", x_train.shape, y_train.shape, m_labels_train.shape, ques_train.shape)\\n test_data = (x_test, y_test, m_labels_test, ques_test)\\n print(\\\"test:\\\", x_test.shape, y_test.shape, m_labels_test.shape, ques_test.shape)\\n\\n # check class distribution\\n print(\\\"y_train sum\\\", sum(y_train), sum(y_train) / len(y_train))\\n print(\\\"y_test sum\\\", sum(y_test), sum(y_test) / len(y_test))\\n\\n train(model, train_data, test_data, test_data, args.checkpoint_name, args.num_epoch, args.margin,\\n args.learning_rate)\\n test_pred, best_scores = test(x_test, m_labels_test, ques_test, args.alpha, args.checkpoint_name,\\n args.model_name,\\n args.output_file_name)\\n with open(args.log_file_name, 'a') as f:\\n f.write(\\n \\\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}; lr={}; margin={}\\\\n\\\".format(\\n args.model_name,\\n args.use_fixed_threshold,\\n args.alpha,\\n best_scores[\\n 'precision'],\\n best_scores[\\n 'recall'],\\n best_scores['f1'],\\n args.learning_rate,\\n args.margin))\\n print(\\\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}\\\\n\\\".format(args.model_name,\\n args.use_fixed_threshold,\\n args.alpha,\\n best_scores['precision'],\\n best_scores['recall'],\\n best_scores['f1']))\\n average_performance.append([best_scores['precision'], best_scores['recall'], best_scores['f1']])\\n\\n average_performance = np.array(average_performance)\\n print(\\\"Avg performance is prec - rec - f1: \\\", average_performance.mean(0))\",\n \"def create_strategy(filename: str, columns_list: List[str], som_width: int, som_height: int, n_iter: int, sigma=0.3,\\n learning_rate=0.01) -> tuple:\\n # get prepared data\\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\\n\\n # train som\\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\\n sigma=sigma, learning_rate=learning_rate)\\n\\n # get profit per cluster in train and test datasets\\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\\n df_profit_per_cluster_test = get_profit_per_cluster(final_df_test)\\n\\n # get mean profit for sell and buy class in training and testing datasets\\n try:\\n buy_clusters_mean_profit_train, buy_clusters_list, sell_clusters_mean_profit_train, sell_clusters_list = \\\\\\n get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train)\\n\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = \\\\\\n get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test, buy_clusters_list, sell_clusters_list)\\n # if the data was assigned to less than to 3 clusters\\n except:\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\\\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = None, None, None, None\\n\\n return len(df_profit_per_cluster_train), len(df_profit_per_cluster_test), \\\\\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\\\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test\",\n \"def train_loop(train_per_list, cut_off_list, C_list,\\n factors, non_factors, data_path, executable_path, \\n trial_factors_list=None): \\n if trial_factors_list is None:\\n trial_factors_list=[factors]\\n sql_table = 'aggregated_ctr' #Data table\\n # remove cross terms\\n sql_features = list(set(sum([fs.split('*') for fs in factors], [])))\\n# factors+=['campaign_id','ad_account_id','pub_account_id', \\n# 'campaign_id*site', 'ad*pub_account_id']\\n con_dict_dse={'host':'db.lqm.io','db':'dse',\\n 'user':'dse','passwd':'dSe@lQm'}\\n con_dict_mad={'host':'db.lqm.io','db':'madvertise_production',\\n 'user':'readonly','passwd':'z0q909TVZj'}\\n \\n rtb_flag=[0,1]\\n model_type=0\\n has_intercept = True # bias term in LR\\n tol = 0.00000001\\n # NB these filenames are HARDCODED in write_sparse routines\\n weights_file = 'train_ais.txt'\\n train_file = 'train_svm.txt'\\n test_file = 'test_svm.txt'\\n probability_file = 'preds_SummModel_py.txt'\\n results = []\\n for train_per in train_per_list:\\n test_per = ( add_hour(train_per[1], 1), add_hour(train_per[1], 3))\\n # DATA RANGE IS INCLUSIVE => 00:00-02:00 = 3 HOURS\\n train_df=mysql_lqm.MySQL_getdata(con_dict_dse,\\n sql_table, train_per, sql_features, rtb_flag)\\n train_df=mysql_lqm.add_features( train_df)\\n test_df= mysql_lqm.MySQL_getdata(con_dict_dse,\\n sql_table, test_per, sql_features, rtb_flag)\\n test_df = mysql_lqm.add_features(test_df)\\n \\n sc, click_no_click_df, weights, targets \\\\\\n = libLinear_functions.create_sparse_cat(train_df, factors, non_factors)\\n\\n \\n for cut_off in cut_off_list:\\n sparse_train_all = libLinear_functions.create_sparse(sc, cut_off, click_no_click_df)\\n sparse_test_all = sc.transform(test_df)\\n for trial_factors in trial_factors_list:\\n trial_factors=trial_factors[:] # copy\\n trial_factors.sort(key=lambda x: sc.factors.index(x))\\n # libsvm expects the indices in ascending order\\n print (trial_factors) \\n sparse_train=sc.select_factors(sparse_train_all, trial_factors)\\n sparse_test=sc.select_factors(sparse_test_all, trial_factors)\\n libLinear_functions.write_sparse(sc, sparse_train, weights, targets, data_path, len(trial_factors))\\n libLinear_functions.write_sparse_test(sc, sparse_test, data_path, n_columns_used= len(trial_factors))\\n\\n\\n for C in C_list:\\n model_file = \\\\\\n '{start}_{stop}_cut_{cut_off}_C_{C:0.3}.model'.format(\\n start=date_name(train_per[0]),\\n stop=date_name(train_per[1]),\\n cut_off=cut_off, C=C)\\n fit(executable_path, data_path, train_file,\\n model_file, weights_file, model_type, reg_param=C, tol=tol,\\n has_intercept=has_intercept)\\n \\n \\n pCTR = libLinear_functions.predict(executable_path, data_path, test_file,\\n model_file, probability_file)\\n if type(pCTR) is pd.Series:\\n amounts = pd.DataFrame({\\n 'no_clicks':test_df['instances' ]-test_df['clicks'],\\n 'clicks':test_df['clicks']})\\n mean_log_loss, weighted_log_loss = log_loss_weighted(pCTR, amounts)\\n results.append([train_per[:],trial_factors[:],\\n cut_off,C,amounts.clicks.sum(),amounts.no_clicks.sum(), mean_log_loss])\\n results_df=pd.DataFrame(results,columns=['date','features','cutoff','C','clicks','no_clicks','lloss'])\\n results_df.to_csv(data_path+'resultsX.txt',index=False, sep='|')\\n # what to do if ERROR?\\n return results_df, weighted_log_loss\",\n \"def pre_train(self, dataset):\\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\\n pe = principleextractor.PrincipleExtractor()\\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\\n # not in the .json; or with argument given TODO\\n self.skm.add_syllogistic_data(data=pd_dataset)\\n\\n self.skm.generate_clusters(cutoff=self.cutoff)\\n\\n results = pe.extract_principles_from_k_clusters(self.skm.final_clusters_syll_list)\\n\\n participant_correspondence = principleextractor.compute_participant_correspondence(self.skm.subj_data_dict,\\n self.skm.final_clusters_num)\\n principleextractor.write_results(results[0], results[1], self.skm.final_clusters_syll_list,\\n participant_correspondence)\\n\\n self.k_clusters = self.skm.final_clusters_syll_list\\n\\n gen_skm = syllogistickmeans.SyllogisticKMeans(1)\\n gen_skm.add_syllogistic_data(data=pd_dataset)\\n\\n gen_skm.generate_clusters(cutoff=self.cutoff)\\n\\n self.current_k_cluster = gen_skm.final_clusters_syll_list[0]\",\n \"def supervise_learning(self):\\n if self._multi_leiden_clusters is None:\\n raise ValueError(\\n \\\"Run multi_leiden_clustering first to get a \\\" \\\"clustering assignment before run supervise_learning.\\\"\\n )\\n\\n n_cluster = np.unique(self._multi_leiden_clusters[self._multi_leiden_clusters != -1]).size\\n if n_cluster == 1:\\n print(\\\"There is only one cluster except for outliers, can not train supervise model on that.\\\")\\n self.label = np.zeros(self.n_obs, dtype=int)\\n return\\n print(\\\"\\\\n=== Start supervise model training and cluster merging ===\\\")\\n\\n x = self.X\\n cur_y = self._multi_leiden_clusters.copy()\\n score = None\\n step = 0.1\\n\\n if self.supervise_model is None:\\n # create default model if no model provided\\n clf = self._create_model(n_estimators=500)\\n else:\\n clf = self.supervise_model\\n for cur_iter in range(1, self.max_iter + 1):\\n print(f\\\"\\\\n=== iteration {cur_iter} ===\\\")\\n n_labels = np.unique(cur_y[cur_y != -1]).size\\n print(f\\\"{n_labels} non-outlier labels\\\")\\n if n_labels < 2:\\n print(f\\\"Stop iteration because only {n_labels} cluster remain.\\\")\\n break\\n\\n x_train, y_train, x_test, y_test = _split_train_test_per_group(\\n x=x,\\n y=cur_y,\\n frac=self.train_frac,\\n max_train=self.train_max_n,\\n random_state=self.random_state + cur_iter,\\n # every time train-test split got a different random state\\n )\\n (\\n clf,\\n score,\\n cluster_map,\\n cmat,\\n r1_cmat,\\n r2_cmat,\\n ) = single_supervise_evaluation(\\n clf,\\n x_train,\\n y_train,\\n x_test,\\n y_test,\\n r1_norm_step=step,\\n r2_norm_step=step,\\n )\\n step = min(0.2, max(0.05, 2 * (self.target_accuracy - score)))\\n\\n # save step data for plotting\\n self.step_data[cur_iter] = [\\n cur_y,\\n cmat,\\n r1_cmat,\\n r2_cmat,\\n cluster_map,\\n score,\\n step,\\n ]\\n\\n if score > self.target_accuracy:\\n print(\\n f\\\"Stop iteration because current accuracy {score:.3f}\\\"\\n f\\\" > target accuracy {self.target_accuracy:.3f}.\\\"\\n )\\n break\\n\\n # judge results\\n if len(cluster_map) > 0:\\n print(f\\\"Merging {len(cluster_map)} clusters.\\\")\\n cur_y = pd.Series(cur_y).apply(lambda i: cluster_map[i] if i in cluster_map else i)\\n # renumber labels from large to small\\n ordered_map = {c: i for i, c in enumerate(cur_y[cur_y != -1].value_counts().index)}\\n cur_y = pd.Series(cur_y).apply(lambda i: ordered_map[i] if i in ordered_map else i).values\\n else:\\n print(\\\"Stop iteration because there is no cluster to merge\\\")\\n break\\n else:\\n print(\\\"Stop iteration because reaching maximum iteration.\\\")\\n self._label_with_leiden_outliers = cur_y\\n self.label = cur_y\\n self.supervise_model = clf\\n self.final_accuracy = score\\n return\",\n \"def data_split(self, split_index=0, thinning=None, apply_mask=False, mask=[], **kwargs):\\n \\n self.learn_sets = ['train','vali','test']\\n self.ind_train = self.train_splitdict[split_index]\\n self.ind_train.sort()\\n self.ind_test = self.test_splitdict[split_index]\\n self.ind_test.sort()\\n if len(self.vali_splitdict) !=0:\\n self.learn_sets = ['train','vali','test']\\n self.ind_vali = self.vali_splitdict[split_index]\\n self.ind_vali.sort()\\n self.indices_learn_dict = dict(zip(self.learn_sets, [self.ind_train, self.ind_vali, self.ind_test]))\\n else:\\n self.learn_sets = ['train','test']\\n self.indices_learn_dict = dict(zip(self.learn_sets, [self.ind_train, self.ind_test]))\\n\\n\\n self.train_samples = self.fullspace[self.ind_train]\\n self.train_size = len(self.train_samples)\\n\\n if len(self.vali_splitdict) !=0:\\n self.vali_samples = self.fullspace[self.ind_vali]\\n self.vali_samples.sort()\\n self.vali_size = len(self.vali_samples)\\n else:\\n self.vali_size = 0\\n self.test_samples = self.fullspace[self.ind_test]\\n #self.test_samples.sort()\\n self.test_size = len(self.test_samples)\\n verbosity = kwargs.get('verbosity', 1)\\n\\n too.condprint(\\\"number of obtained training vectors\\\", self.train_size, level=1, verbosity=verbosity)\\n too.condprint(\\\"number of obtained validation vectors\\\", self.vali_size, level=1, verbosity=verbosity)\\n too.condprint(\\\"number of obtained test vectors\\\", self.test_size, level=2, verbosity=verbosity)\\n\\n\\n self.matrix_datalearn_dict = dict()\\n\\n for dli in self.learn_sets:\\n matrixdata = np.copy(self.matrix_z)\\n self.matrixdata=matrixdata\\n\\n ## copy of mask to avoid modifying orginal mask after iterations\\n if apply_mask==False:\\n maskcopy=np.arange(0,len(matrixdata[0])) ##range over all axis length, does not mask anything\\n else:\\n maskcopy=np.copy(mask)\\n \\n ## apply thinning (if set to None, there is no thinning)\\n self.mask_true=maskcopy[::thinning] \\n\\n ## apply mask also to feature grid and save as masked_+...\\n setattr(self, 'masked_'+self.features_str, self.fgrid[self.mask_true]) \\n\\n matrixdata = matrixdata[:,self.mask_true] ## apply mask and thinning to feature space (k-grid)\\n indices_l = self.indices_learn_dict[dli]\\n matrixdata = matrixdata[indices_l,:] ##choose learning set\\n self.matrix_datalearn_dict[dli] = matrixdata\\n self.matrix_datalearn_dict = objdict(self.matrix_datalearn_dict)\\n return self.matrix_datalearn_dict\",\n \"def main():\\n # Read in trainingSet and testSet as a DataFrame\\n trainingOriginal = pd.read_csv(\\n filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.train.5fold.csv\\\")\\n testOriginal = pd.read_csv(filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.test.csv\\\")\\n\\n # Select only the numeric data\\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\\n training = pd.concat([training.reset_index(drop=True),\\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Select only the numeric data\\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\\n test = pd.concat([test.reset_index(drop=True),\\n testOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Normalize the columns for training and test\\n # print training['age'].min()\\n # print training['age'].max()\\n # print training.head()\\n\\n # Run max-min normalization on numerical columns for testing and training data\\n for i in range(6):\\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\\n\\n # Convert the 'earns' column to boolean as follows\\n training['earns'] = training['earns'] == '>50K'\\n test['earns'] = test['earns'] == ' >50K'\\n\\n # Group the training set by the fold attribute as given by the dataset\\n trainingForFinal = training\\n training = training.groupby('fold')\\n\\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\\n kList = []\\n for i in range(40):\\n if i % 2 == 1:\\n kList.append(i)\\n\\n # Empty dictionary to hold performance of each k-values and its accuracy\\n performance = {}\\n\\n # Compute the performance for each k-value\\n for k in kList:\\n performance = crossValidation(training, k, performance)\\n\\n # Sort the performance dictionary by its accuracy (value)\\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\\n\\n # Open file to write results\\n file = open('grid.results.txt', 'w')\\n # Write the results to file\\n file.write(\\\"K | Accuracy\\\\n\\\")\\n for item in performance:\\n if item[0] < 10:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n else:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n # Close file\\n file.close()\\n\\n # The best K is the one at the top of the list after the sorting\\n bestK = performance[0][0]\\n\\n print 'Running Test Set with K = ' + str(bestK)\\n\\n applyModel(test,trainingForFinal,bestK)\",\n \"def train(self, data):\\n\\t\\tepsilon = self.epsilon\\n\\t\\ttempDist = 1.0\\n\\t\\tk = self.k\\n\\t\\tcenters = data.rdd.takeSample(False, k, 1)\\n\\t\\ti = 0 \\n\\t\\twhile tempDist > epsilon or self.maxNoOfIteration > i:\\n\\t\\t\\ti+=1\\t\\t\\t\\n\\t\\t\\tclosest = data.map(lambda p: (closestCluster(p, centers), (np.array(p), 1)))\\n \\t\\t\\tpointStats = closest.reduceByKey(lambda x, y: (x[0] + y[0], x[1] + y[1]))\\n \\t\\tnewPoints = pointStats.map(lambda x: (x[0], x[1][0] / float(x[1][1]))).collect()\\n \\t\\ttempDist = sum(np.sum((centers[index] - p) ** 2) for (index, p) in newPoints)\\n \\t\\tfor (ind, p) in newPoints:\\n\\t\\t\\t\\tcenters[ind] = p\\n\\t\\tself.centers = centers\\n\\t\\treturn self.centers\",\n \"def main(source_dir, ksplit, out_dir, data_pattern, label_pattern, test_mode,\\r\\n numTopVars = [10, 50, 100, 500, 1000], compute_results=True):\\r\\n # Load input and labels.\\r\\n data, labels, data_file = load_data(source_dir, data_pattern)\\r\\n filename_base = path.splitext(path.basename(mname))[0]\\r\\n # Get classifiers and params.\\r\\n global NAMES\\r\\n if test_mode:\\r\\n NAMES = [\\\"Chance\\\", \\\"Nearest Neighbors\\\", \\\"Linear SVM\\\", \\\"Decision Tree\\\",\\r\\n \\\"Logistic Regression\\\", \\\"Naive Bayes\\\", \\\"LDA\\\"]\\r\\n ksplit = 3\\r\\n\\r\\n classifiers, params = make_classifiers(NAMES) # data.shape, ksplit)\\r\\n\\r\\n\\r\\n # Make the folds.\\r\\n logging.info(\\\"Making %d folds\\\" % ksplit)\\r\\n #kf = StratifiedKFold(labels, n_folds=ksplit)\\r\\n kf = KFold(labels.shape[0], n_folds=ksplit)\\r\\n\\r\\n # Extract the training and testing indices from the k-fold object,\\r\\n # which stores fold pairs of indices.\\r\\n fold_pairs = [(tr, ts) for (tr, ts) in kf]\\r\\n assert len(fold_pairs) == ksplit\\r\\n rank_per_fold = get_rank_per_fold(data, labels, fold_pairs,\\r\\n save_path=out_dir, parallel=True)\\r\\n #dhjelm: were we planning on using this dict?\\r\\n #score={}\\r\\n dscore=[]\\r\\n totalErrs = []\\r\\n if compute_results:\\r\\n for name in NAMES:\\r\\n mdl = classifiers[name]\\r\\n param = params[name]\\r\\n # get_score runs the classifier on each fold,\\r\\n # each subset of selected top variables and does a grid search for\\r\\n # classifier-specific parameters (selects the best)\\r\\n clf, allConfMats, allTotalErrs, allFittedClassifiers = \\\\\\r\\n get_score(data, labels, fold_pairs, name, mdl, param,\\r\\n numTopVars=numTopVars,\\r\\n rank_per_fold=rank_per_fold, parallel=True,\\r\\n rand_iter=-1)\\r\\n # save classifier object and results to file\\r\\n save_classifier_results(name, out_dir, allConfMats,\\r\\n allTotalErrs)\\r\\n save_classifier_object(clf, allFittedClassifiers, name, out_dir)\\r\\n # Append classifier results to list of all results\\r\\n dscore.append(allConfMats)\\r\\n totalErrs.append(allTotalErrs)\\r\\n '''\\r\\n First do some saving of total results\\r\\n '''\\r\\n save_combined_results(NAMES, dscore, totalErrs,\\r\\n numTopVars, out_dir, filename_base)\\r\\n\\r\\n plot_errors(NAMES, numTopVars, dscore, totalErrs,\\r\\n filename_base, out_dir,compute_results)\\r\\n\\r\\n logging.shutdown()\",\n \"def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\\n distribute_training=False):\\n train_set = np.array(train_set)\\n test_set = np.array(test_set)\\n\\n print(\\\"The shape of training set before dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set before dimension reduction is {0}\\\".format(test_set.shape))\\n print('Use distribute training ? >> {0}'.format(distribute_training))\\n reg = linear_model.BayesianRidge()\\n\\n if dimension_reduce:\\n pca = PCA(n_components=128)\\n train_set = pca.fit_transform(train_set)\\n test_set = pca.fit_transform(test_set)\\n\\n print(\\\"The shape of training set after dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set after dimension reduction is {0}\\\".format(test_set.shape))\\n\\n if not distribute_training:\\n reg.fit(train_set, train_label)\\n else:\\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\\n train_label), da.array(test_label)\\n reg.fit(train_set, train_label)\\n\\n predicted_label = reg.predict(test_set)\\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\\n\\n mkdirs_if_not_exist('./model')\\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\\n print('The regression model has been persisted...')\\n\\n mkdirs_if_not_exist('./result')\\n\\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\\n\\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\\n df.to_csv('./result/%s.csv' % data_name, index=False)\\n print('The result csv file has been generated...')\",\n \"def prepare_nfold_datasets(self): # i.e. split into different train/ground-truth(test) dataset\\n for alpha in range(1, self.ALPHAs+1):\\n if alpha != self.ALPHAs:\\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI], separator='-')\\n else:\\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI+self.runoff_years], separator='-')\\n new_cluster_dir = str(Path(self.tl_model.cluster_dir) / f'alpha_{alpha}_GT-{gt_years}')\\n os.makedirs(new_cluster_dir, exist_ok=True)\\n\\n new_prepared_data_dir = str(Path(self.tl_model.prepared_data_dir) / f'alpha_{alpha}')\\n os.makedirs(new_prepared_data_dir, exist_ok=True)\\n \\n if utils.find(f'*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir) and utils.find(f'*alpha_{alpha}_standardized_stacked_arr.pkl', new_prepared_data_dir):\\n pass\\n else:\\n if not utils.find(f'*target*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\\n print(f\\\"=> No input datasets pre-processed for alpha of {alpha}\\\")\\n prepare.cut_target_dataset(self, alpha, new_prepared_data_dir)\\n\\n if not utils.find(f'*rf*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\\n print(f\\\"=> No rainfall datasets pre-processed for alpha of {alpha}\\\")\\n prepare.cut_rf_dataset(self, alpha, new_prepared_data_dir)\\n \\n print(f'Preprocessed pickles for alpha split {alpha} can be found @:\\\\n{new_prepared_data_dir}')\",\n \"def fit(self):\\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\\n self.merge_clusters([[6,33,52],[17,14]])\\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\\n self.merge_clusters([[6,98,99]])\\n self.merge_clusters([[35,80]])\\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[76,98]])\\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[39,42]])\\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\\n self.merge_clusters([[70,101]])\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\\n self.merge_clusters()\\n return\",\n \"def calculate_data_split(self, n_train=2, n_vali=0, n_test=1, n_splits=1,\\n num_percentiles=4, random_state=87, verbosity=1,\\n manual_split=False,train_indices=None, test_indices=None,\\n train_redshift_indices=[0], test_redshift_indices=[0],\\n interpolate_over_redshift_only=False, **kwargs):\\n \\n n_extrema=kwargs.get('n_extrema', 2)\\n ind_extrema=kwargs.get('ind_extrema', [0,-1])\\n self.data_separation(n_extrema=n_extrema, ind_extrema=ind_extrema)\\n\\n too.condprint(\\\"number of wanted training vectors\\\", n_train, level=2, verbosity=verbosity)\\n too.condprint(\\\"number of wanted test vectors\\\", n_test, level=1, verbosity=verbosity)\\n if n_train+n_test > (self.size_fullspace):\\n print(\\\"Warning n_train is larger than total full sample space\\\")\\n\\n self.random_state = random_state\\n self.num_percentiles = num_percentiles\\n self.n_splits = n_splits\\n\\n stratif_labels = self.stratify_array(self.midspace, num_percentiles=self.num_percentiles)\\n self.test_splitdict = dict()\\n self.train_splitdict = dict()\\n self.vali_splitdict = dict()\\n\\n if manual_split == False:\\n n_vali = self.size_midspace-n_test-n_train\\n if n_vali !=0 and len(self.ind_midspace)> 1:\\n kf = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=n_test, random_state=self.random_state)\\n for ii, (trainvali, test) in enumerate(kf.split(self.midspace,stratif_labels)):\\n #test = test[np.in1d(test, extspace_ind, invert=True)]\\n\\n test = self.ind_midspace[test]\\n if n_train > 0:\\n train, valitest = train_test_split(trainvali, test_size=n_vali, shuffle=True, random_state=self.random_state)\\n train = self.ind_midspace[train]\\n train = np.unique(np.concatenate([train,self.ind_extremaspace]))\\n train = self.ind_fullspace[train]\\n else:\\n train = self.ind_extremaspace\\n train = self.ind_fullspace[train]\\n valitest=trainvali\\n\\n #valitest = valitest[np.in1d(valitest, extspace_ind, invert=True)]\\n valitest = self.ind_midspace[valitest]\\n #print(test, trr, \\\" s tr\\\", len(train)-2, \\\" tr: \\\", train, \\\" va: \\\", valitest)\\n self.test_splitdict[ii] = test\\n self.vali_splitdict[ii]= valitest\\n self.train_splitdict[ii] = train\\n elif len(self.ind_midspace)> 1 and n_vali == 0:\\n kf = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=n_test, random_state=self.random_state)\\n for ii, (train, test) in enumerate(kf.split(self.midspace,stratif_labels)):\\n test = self.ind_midspace[test]\\n train = self.ind_midspace[train]\\n train = np.unique(np.concatenate([train,self.ind_extremaspace]))\\n train = self.ind_fullspace[train]\\n self.test_splitdict[ii] = test\\n self.train_splitdict[ii] = train\\n\\n else:\\n test = self.ind_midspace\\n train = self.ind_extremaspace\\n self.test_splitdict[0] = test\\n self.train_splitdict[0] = train\\n \\n ###/!\\\\ Warning /!\\\\ For now we always use manual split (which not really manual now...)\\n elif manual_split == True:\\n ### Determine the number of samples avaible with different values of parameters. e.g nb_param = 101 for MassiveNus\\n nb_param = int(len(self.fullspace)/len(self.z_requested)) \\n if len(self.z_requested)==1:\\n nb_param = int(len(self.fullspace))\\n \\n\\n for ii in range (n_splits):\\n ###Here the user has chosen to provide the test indices\\n if test_indices is not None:\\n test_indices = np.atleast_2d(test_indices)\\n test = test_indices[ii]\\n ###We make sure that the indice lies into a correct space. e.g if we have nb_param = 101, and a indices i = 103 it will become i =2\\n test_origin = [tt%nb_param for tt in test]\\n \\n ###Do we want to construct a interpolation only over the redshift ? /!\\\\ Warning /!\\\\ this is case is not really used....\\n if interpolate_over_redshift_only == False and train_indices is None:\\n train_origin = [ii for ii in range(1,nb_param-1) if ii not in test_origin ]\\n\\n elif interpolate_over_redshift_only == False and train_indices is not None:\\n train_origin = [tt%nb_param for tt in train ]\\n else :\\n train_origin = test_origin\\n ###Here the user has chosen not to provide the test indices\\n ## so we first randomly generate them\\n else:\\n if train_indices is None:\\n test_origin = [ii for ii in range(1,nb_param-1)]\\n test_origin = shuffle(test_origin)[:n_test]\\n if interpolate_over_redshift_only == False:\\n train_origin = [ii for ii in range(1,nb_param-1) if ii not in test_origin ]\\n else:\\n train_origin = test_origin\\n ###The user has specified train indices so must be sure that train and test do not overlap !\\n else:\\n train_indices = np.atleast_2d(train_indices)\\n train = train_indices[ii]\\n train_origin = [tt%nb_param for tt in train ]\\n test_origin = [ii for ii in range(1,nb_param-1) if ii not in train_origin ] ####!!!\\n \\n train_origin = shuffle(train_origin)\\n \\n train_origin = train_origin[:n_train]\\n test_origin = shuffle(test_origin)[:n_test]\\n if train_indices is None:\\n if [0] not in test_origin:\\n train_origin +=[0]\\n if [nb_param-1]not in test_origin:\\n \\n train_origin += [nb_param-1]\\n if [0] in test_origin or [nb_param-1] in test_origin :\\n print(\\\"Warning : trying to interpolate a extramal value\\\")\\n \\n\\n train_redshift = self.z_requested[train_redshift_indices]\\n test_redshift = self.z_requested[test_redshift_indices]\\n self.train_redshift = train_redshift \\n self.test_redshift = test_redshift\\n too.condprint(\\\"redshift used for training\\\", train_redshift,level=1,verbosity=verbosity)\\n too.condprint(\\\"redshfit used for testing\\\", test_redshift,level=1,verbosity=verbosity)\\n train = []\\n test = []\\n ### looping over the redshift \\n for zz in train_redshift_indices:\\n train+= [ii + zz*nb_param for ii in train_origin ]\\n\\n for zz in test_redshift_indices: \\n test += [ii + zz*nb_param for ii in test_origin ]\\n \\n\\n self.train_splitdict[ii] = train\\n self.test_splitdict[ii] = test\\n shuffled = shuffle(train)\\n self.train_splitdict[ii] = shuffled\\n self.vali_splitdict[ii] = shuffled\\n\\n return None\",\n \"def __init__(self, conn, args, data, split_type, num_clusters):\\n\\n self.conn = conn\\n self.args = args\\n self.data = data\\n self.split_type = split_type\\n\\n self.pca_model = None\\n self.cluster_model = None\\n self.algorithm = args['cluster_algorithm']\\n\\n # http://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html\\n hdbsc = hdbscan.HDBSCAN(min_cluster_size=10)\\n affinity_propagation = cluster.AffinityPropagation()\\n ms = cluster.MeanShift(bin_seeding=True)\\n spectral = cluster.SpectralClustering(n_clusters=num_clusters, \\n eigen_solver='arpack',\\n affinity=\\\"nearest_neighbors\\\", \\n random_state=self.args['seed'])\\n ward = cluster.AgglomerativeClustering(n_clusters=num_clusters, \\n linkage='ward')\\n birch = cluster.Birch(n_clusters=num_clusters)\\n two_means = cluster.MiniBatchKMeans(n_clusters=num_clusters,\\n random_state=self.args['seed'])\\n average_linkage = cluster.AgglomerativeClustering(linkage=\\\"average\\\", \\n n_clusters=num_clusters)\\n hdbsc = hdbscan.HDBSCAN(min_cluster_size=10)\\n kmeans = cluster.KMeans(n_clusters=num_clusters, random_state=self.args['seed'])\\n dbscan = cluster.DBSCAN()\\n \\n self.clustering_algorithms = {\\n 'MiniBatchKMeans': two_means,\\n 'AffinityPropagation': affinity_propagation,\\n 'MeanShift': ms,\\n 'SpectralClustering': spectral,\\n 'Ward': ward,\\n 'AgglomerativeClustering': average_linkage,\\n 'DBSCAN': dbscan,\\n 'Birch': birch,\\n 'HDBSCAN': hdbsc,\\n 'KMeans': kmeans\\n }\",\n \"def kmeans_001(fit_centroids=False):\\n trainX = np.memmap('data/train_cropped_150.memmap', mode='r', shape=(N_TRAIN, 150, 150, 3))\\n # Not used yet\\n testX = np.memmap('data/test_cropped_150.memmap', mode='r', shape=(N_TEST, 150, 150, 3))\\n\\n if fit_centroids:\\n km = models.KMeansFeatures.KMeansFeatures(rf_size=6, num_centroids=1600, num_patches=400000)\\n km.fit(trainX)\\n\\n km.save_to_file('mdl_kmeans_ridge_rf_001')\\n # t0 = time.time()\\n # pickle.dump(km, open('data/kmeans_centroids.pkl', mode='wb'))\\n # print 'Pickling the KMeansFeatures object took {0} seconds'.format(time.time() - t0)\\n else:\\n km = models.KMeansFeatures.KMeansFeatures.load_from_file('mdl_kmeans_ridge_rf_001')\\n # km = pickle.load(open('data/kmeans_centroids.pkl'))\\n\\n n = 10000\\n\\n train_x = km.transform(trainX[0:n, :])\\n train_y = classes.train_solutions.data[0:n, :]\\n # train_x = km.transform(trainX)\\n # train_y = classes.train_solutions.data\\n\\n logger.info(\\\"Train x shape: {}\\\".format(train_x.shape))\\n logger.info(\\\"Train y shape: {}\\\".format(train_y.shape))\\n\\n kf = KFold(n, n_folds=2, shuffle=True)\\n\\n for train, test in kf:\\n # clf = models.Ridge.RidgeRFEstimator()\\n # clf.rf_rgn = RandomForestRegressor(n_estimators=250, n_jobs=4, verbose=3)\\n clf = RandomForestRegressor(n_estimators=20, n_jobs=4, verbose=3, random_state=0, oob_score=True)\\n clf.fit(train_x[train], train_y[train])\\n res = clf.predict(train_x[test])\\n classes.rmse(train_y[test], res)\",\n \"def prepareSplitClassifier(df, models, choice):\\n\\n\\n def classificationOutput(clf, X, Y):\\n \\\"\\\"\\\"\\n Fit the model and print the classification results\\n - confusion_matrix\\n - avg scores etc\\n \\\"\\\"\\\"\\n n_samples = 36\\n\\n print \\\"\\\\n\\\\nClassifier: \\\\n %s\\\" % (clf)\\n print \\\"#\\\" * 79\\n # classifier_gnb = naive_bayes.GaussianNB() # initiating the classifier\\n\\n clf.fit(X[:n_samples], Y[:n_samples]) # train on first n_samples and test on last 10\\n\\n expected = Y[n_samples:]\\n predicted = clf.predict(X[n_samples:])\\n print(\\\"Classification report:\\\\n%s\\\\n\\\" % (metrics.classification_report(expected, predicted)))\\n print(\\\"\\\\nConfusion matrix:\\\\n%s\\\" % metrics.confusion_matrix(expected, predicted))\\n\\n\\n\\n\\n def splitclassify(cDf):\\n \\\"\\\"\\\"\\n Given the dataframe combined with equal fair and unfair apps,\\n classify them\\n \\\"\\\"\\\"\\n cDf = cDf.reindex(np.random.permutation(cDf.index)) # shuffle the dataframe\\n featCols = set(cDf.columns)\\n featCols.remove('appLabel')\\n\\n features = cDf[list(featCols)].astype('float')\\n\\n ## Scale the features to a common range\\n min_max_scaler = preprocessing.MinMaxScaler()\\n X = min_max_scaler.fit_transform(features.values)\\n\\n Y = cDf['appLabel'].values\\n\\n\\n if choice == 'all':\\n for key in models:\\n classifier = models[key]\\n classificationOutput(classifier, X, Y)\\n else:\\n if choice in models:\\n classifier = models[choice]\\n classificationOutput(classifier, X, Y)\\n else:\\n print \\\"Incorrect Choice\\\"\\n\\n\\n\\n fairDf = df[df['appLabel'] == False]\\n unfairDf = df[df['appLabel'] == True]\\n\\n\\n # calculate total possible splits of fair data frame relatie to\\n # size of unfair dataframe\\n splits = len(fairDf) // len(unfairDf)\\n\\n for i in range(splits):\\n clDf = fairDf[i : i+len(unfairDf)].append(unfairDf)\\n\\n # print fairDf.values, unfairDf.values\\n print \\\"Classifying %d th split of fair apps with unfair app\\\" % (i)\\n print \\\"-\\\" * 79\\n splitclassify(clDf)\\n print \\\"\\\\n\\\\n\\\"\",\n \"def train_k():\\n\\n for i in range(n_families):\\n print('[training-k] family:', i, '...')\\n f1_fam_name = 'f1_fam_' + str(i) + '_features'\\n feature_mat_fam1 = mask_features(f1_fam_name)\\n n_samples = len(feature_mat_fam1)\\n # use 80% of samples as training set\\n feature_mat_fam1 = feature_mat_fam1[int(n_samples / 5):, :]\\n my_k, my_result = train_with_inner_outer(feature_mat_fam1, 0)\\n\\n save_name = '/f1_fam_' + str(i) + '_validation'\\n with open(saved_cluster_path + save_name, 'wb') as fp:\\n pickle.dump(my_result, fp)\",\n \"def stepwise_regression(train_per_list, cut_off_list, C_list,\\n factors,non_factors, data_path, executable_path):\\n sql_table = 'aggregated_ctr' #Data table\\n sql_features = list(set(sum([fs.split('*') for fs in factors], [])))\\n # remove cross terms\\n\\n factors+=['campaign_id','ad_account_id','pub_account_id', \\n 'campaign_id*site', 'ad*pub_account_id']\\n con_dict_mad={'host':'db.lqm.io','db':'madvertise_production',\\n 'user':'readonly','passwd':'z0q909TVZj'}\\n con_dict_dse={'host':'db.lqm.io','db':'dse','user':'dse','passwd':'dSe@lQm'}\\n rtb_flag=[0,1]\\n \\n test_per_list= map(lambda x: ( add_hour(x[1], 1), add_hour(x[1], 3)), train_per_list)\\n \\n # test period is next 3 hours after end of training period\\n # DATA RANGE IS INCLUSIVE => 00:00-02:00 = 3 HOURS\\n MySQL_save_data_loop(con_dict_dse, sql_table,\\n train_per_list, sql_features, rtb_flag, data_path)\\n MySQL_save_data_loop(con_dict_dse, sql_table,\\n test_per_list, sql_features, rtb_flag, data_path)\\n \\n model_type=0\\n has_intercept = True # bias term in LR\\n tol = 0.00000001\\n\\n # NB these filenames are HARDCODED in write_sparse routines\\n weights_file = 'train_ais.txt'\\n train_file = 'train_svm.txt'\\n test_file = 'test_svm.txt'\\n probability_file = 'preds_SummModel_py.txt'\\n\\n \\n res_df_list=[]\\n trial_factors=[]\\n remaining_factors=factors[:]\\n while len(remaining_factors):\\n results = [] \\n # we assume we cannot load all the data in memory\\n # so we have to reload for every step of stepwise selection\\n for train_per, test_per in zip(train_per_list, test_per_list):\\n \\n train_df=load_data(data_path,train_per)\\n test_df=load_data(data_path,test_per)\\n \\n sc, click_no_click_df, weights, targets \\\\\\n = libLinear_functions.create_sparse_cat(train_df, factors, non_factors)\\n \\n for cut_off in cut_off_list:\\n sparse_train_all = libLinear_functions.create_sparse(sc, cut_off, click_no_click_df)\\n sparse_test_all = sc.transform(test_df)\\n for fac in remaining_factors:\\n trial_factors.append(fac)\\n trial_factors.sort(key=lambda x: sc.factors.index(x))\\n # libsvm expects the indices in ascending order\\n print (trial_factors) \\n sparse_train=sc.select_factors(sparse_train_all, trial_factors)\\n sparse_test=sc.select_factors(sparse_test_all, trial_factors)\\n libLinear_functions.write_sparse(sc, sparse_train, weights, targets, data_path, len(trial_factors))\\n libLinear_functions.write_sparse_test(sc, sparse_test, data_path, n_columns_used= len(trial_factors))\\n\\n for C in C_list:\\n model_file = \\\\\\n '{start}_{stop}_cut_{cut_off}_C_{C:0.3}.model'.format(\\n start=date_name(train_per[0]),\\n stop=date_name(train_per[1]),\\n cut_off=cut_off, C=C)\\n fit(executable_path, data_path, train_file,\\n model_file, weights_file, model_type, reg_param=C, tol=tol,\\n has_intercept=has_intercept)\\n \\n pCTR = libLinear_functions.predict(\\n executable_path, data_path, test_file,\\n model_file, probability_file)\\n if type(pCTR) is pd.Series:\\n amounts = pd.DataFrame({\\n 'no_clicks':test_df['instances' ]-test_df['clicks'],\\n 'clicks':test_df['clicks']})\\n mean_log_loss, weighted_log_loss =\\\\\\n libLinear_functions.log_loss_weighted(pCTR, amounts)\\n results.append([train_per[:], tuple(trial_factors),fac, cut_off, C, mean_log_loss])\\n # what to do if ERROR?\\n trial_factors.remove(fac)\\n res_df=pd.DataFrame(results,columns=['train_per','factors','add_factor','cut_off','C','mean_log_loss'])\\n res_avg=res_df.groupby(['factors','add_factor','cut_off','C']).agg([np.mean,np.std])\\n best_params=res_avg['mean_log_loss','mean'].argmin()\\n best_fac=best_params[1]\\n remaining_factors.remove(best_fac)\\n trial_factors.append(best_fac)\\n res_df_list.append(res_df)\\n results_df=pd.concat(res_df_list)\\n return results_df\",\n \"def partition_data(dataset, datadir, logdir, partition, n_parties, beta=0.4):\\n if dataset == 'mnist':\\n X_train, y_train, X_test, y_test = load_mnist_data(datadir)\\n elif dataset == 'fmnist':\\n X_train, y_train, X_test, y_test = load_fmnist_data(datadir)\\n elif dataset == 'cifar10':\\n X_train, y_train, X_test, y_test = load_cifar10_data(datadir)\\n elif dataset == 'svhn':\\n X_train, y_train, X_test, y_test = load_svhn_data(datadir)\\n elif dataset == 'celeba':\\n X_train, y_train, X_test, y_test = load_celeba_data(datadir)\\n elif dataset == 'femnist':\\n X_train, y_train, u_train, X_test, y_test, u_test = load_femnist_data(datadir)\\n elif dataset == 'cifar100':\\n X_train, y_train, X_test, y_test = load_cifar100_data(datadir)\\n elif dataset == 'tinyimagenet':\\n X_train, y_train, X_test, y_test = load_tinyimagenet_data(datadir)\\n print(\\\"y_train\\\",y_train.shape)\\n print(\\\"y_test\\\",y_test.shape)\\n\\n elif dataset == 'generated':\\n X_train, y_train = [], []\\n for loc in range(4):\\n for i in range(1000):\\n p1 = random.random()\\n p2 = random.random()\\n p3 = random.random()\\n if loc > 1:\\n p2 = -p2\\n if loc % 2 ==1:\\n p3 = -p3\\n if i % 2 == 0:\\n X_train.append([p1, p2, p3])\\n y_train.append(0)\\n else:\\n X_train.append([-p1, -p2, -p3])\\n y_train.append(1)\\n X_test, y_test = [], []\\n for i in range(1000):\\n p1 = random.random() * 2 - 1\\n p2 = random.random() * 2 - 1\\n p3 = random.random() * 2 - 1\\n X_test.append([p1, p2, p3])\\n if p1>0:\\n y_test.append(0)\\n else:\\n y_test.append(1)\\n X_train = np.array(X_train, dtype=np.float32)\\n X_test = np.array(X_test, dtype=np.float32)\\n y_train = np.array(y_train, dtype=np.int32)\\n y_test = np.array(y_test, dtype=np.int64)\\n idxs = np.linspace(0,3999,4000,dtype=np.int64)\\n batch_idxs = np.array_split(idxs, n_parties)\\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\\n mkdirs(\\\"data/generated/\\\")\\n np.save(\\\"data/generated/X_train.npy\\\",X_train)\\n np.save(\\\"data/generated/X_test.npy\\\",X_test)\\n np.save(\\\"data/generated/y_train.npy\\\",y_train)\\n np.save(\\\"data/generated/y_test.npy\\\",y_test)\\n \\n #elif dataset == 'covtype':\\n # cov_type = sk.fetch_covtype('./data')\\n # num_train = int(581012 * 0.75)\\n # idxs = np.random.permutation(581012)\\n # X_train = np.array(cov_type['data'][idxs[:num_train]], dtype=np.float32)\\n # y_train = np.array(cov_type['target'][idxs[:num_train]], dtype=np.int32) - 1\\n # X_test = np.array(cov_type['data'][idxs[num_train:]], dtype=np.float32)\\n # y_test = np.array(cov_type['target'][idxs[num_train:]], dtype=np.int32) - 1\\n # mkdirs(\\\"data/generated/\\\")\\n # np.save(\\\"data/generated/X_train.npy\\\",X_train)\\n # np.save(\\\"data/generated/X_test.npy\\\",X_test)\\n # np.save(\\\"data/generated/y_train.npy\\\",y_train)\\n # np.save(\\\"data/generated/y_test.npy\\\",y_test)\\n\\n elif dataset in ('rcv1', 'SUSY', 'covtype'):\\n X_train, y_train = load_svmlight_file(\\\"../../../data/{}\\\".format(dataset))\\n X_train = X_train.todense()\\n num_train = int(X_train.shape[0] * 0.75)\\n if dataset == 'covtype':\\n y_train = y_train-1\\n else:\\n y_train = (y_train+1)/2\\n idxs = np.random.permutation(X_train.shape[0])\\n\\n X_test = np.array(X_train[idxs[num_train:]], dtype=np.float32)\\n y_test = np.array(y_train[idxs[num_train:]], dtype=np.int32)\\n X_train = np.array(X_train[idxs[:num_train]], dtype=np.float32)\\n y_train = np.array(y_train[idxs[:num_train]], dtype=np.int32)\\n\\n mkdirs(\\\"data/generated/\\\")\\n np.save(\\\"data/generated/X_train.npy\\\",X_train)\\n np.save(\\\"data/generated/X_test.npy\\\",X_test)\\n np.save(\\\"data/generated/y_train.npy\\\",y_train)\\n np.save(\\\"data/generated/y_test.npy\\\",y_test)\\n\\n elif dataset in ('a9a'):\\n X_train, y_train = load_svmlight_file(\\\"../../../data/{}\\\".format(dataset))\\n X_test, y_test = load_svmlight_file(\\\"../../../data/{}.t\\\".format(dataset))\\n X_train = X_train.todense()\\n X_test = X_test.todense()\\n X_test = np.c_[X_test, np.zeros((len(y_test), X_train.shape[1] - np.size(X_test[0, :])))]\\n\\n X_train = np.array(X_train, dtype=np.float32)\\n X_test = np.array(X_test, dtype=np.float32)\\n y_train = (y_train+1)/2\\n y_test = (y_test+1)/2\\n y_train = np.array(y_train, dtype=np.int32)\\n y_test = np.array(y_test, dtype=np.int32)\\n\\n mkdirs(\\\"data/generated/\\\")\\n np.save(\\\"data/generated/X_train.npy\\\",X_train)\\n np.save(\\\"data/generated/X_test.npy\\\",X_test)\\n np.save(\\\"data/generated/y_train.npy\\\",y_train)\\n np.save(\\\"data/generated/y_test.npy\\\",y_test)\\n\\n\\n n_train = y_train.shape[0]\\n \\n if partition == \\\"manual\\\":\\n label_idxs = {i:[] for i in np.unique(y_train)}\\n label_node_map = {i:[] for i in label_idxs.keys()} \\n label_node_map[0] = [0,5,10,15,20]\\n label_node_map[1] = [0,5,10,15,20]\\n label_node_map[2] = [1,6,11,16,21]\\n label_node_map[3] = [1,6,11,16,21]\\n label_node_map[4] = [2,7,12,17,22]\\n label_node_map[5] = [2,7,12,17,22]\\n label_node_map[6] = [3,8,13,18,23]\\n label_node_map[7] = [3,8,13,18,23]\\n label_node_map[8] = [4,9,14,19]\\n label_node_map[9] = [4,9,14,19]\\n\\n \\n for i,label in enumerate(y_train):\\n label_idxs[label].append(i)\\n \\n net_dataidx_map = {i:[] for i in range(n_parties)}\\n for label, idxs in label_idxs.items():\\n batch_idxs = np.array_split(idxs, len(label_node_map[label]))\\n for i, net_id in enumerate(label_node_map[label]):\\n net_dataidx_map[net_id] += list(batch_idxs[i])\\n \\n\\n if partition == \\\"homo\\\":\\n idxs = np.random.permutation(n_train)\\n batch_idxs = np.array_split(idxs, n_parties)\\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\\n \\n\\n\\n elif partition == \\\"noniid-labeldir\\\":\\n min_size = 0\\n min_require_size = 10\\n K = 10\\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\\n K = 2\\n elif dataset in ('tinyimagenet'):\\n K = 200\\n # min_require_size = 100\\n elif dataset in ('cifar100'):\\n K = 100\\n\\n N = y_train.shape[0]\\n #np.random.seed(2020)\\n net_dataidx_map = {}\\n\\n while min_size < min_require_size:\\n idx_batch = [[] for _ in range(n_parties)]\\n for k in range(K):\\n idx_k = np.where(y_train == k)[0]\\n np.random.shuffle(idx_k)\\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\\n # logger.info(\\\"proportions1: \\\", proportions)\\n # logger.info(\\\"sum pro1:\\\", np.sum(proportions))\\n ## Balance\\n proportions = np.array([p * (len(idx_j) < N / n_parties) for p, idx_j in zip(proportions, idx_batch)])\\n # logger.info(\\\"proportions2: \\\", proportions)\\n proportions = proportions / proportions.sum()\\n # logger.info(\\\"proportions3: \\\", proportions)\\n proportions = (np.cumsum(proportions) * len(idx_k)).astype(int)[:-1]\\n # logger.info(\\\"proportions4: \\\", proportions)\\n idx_batch = [idx_j + idx.tolist() for idx_j, idx in zip(idx_batch, np.split(idx_k, proportions))]\\n min_size = min([len(idx_j) for idx_j in idx_batch])\\n # if K == 2 and n_parties <= 10:\\n # if np.min(proportions) < 200:\\n # min_size = 0\\n # break\\n\\n\\n for j in range(n_parties):\\n np.random.shuffle(idx_batch[j])\\n net_dataidx_map[j] = idx_batch[j]\\n\\n elif partition > \\\"noniid-#label0\\\" and partition <= \\\"noniid-#label9\\\":\\n num = eval(partition[13:])\\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\\n num = 1\\n K = 2\\n else:\\n K = 10\\n if dataset == \\\"cifar100\\\":\\n K = 100\\n elif dataset == \\\"tinyimagenet\\\":\\n K = 200\\n if num == 10:\\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\\n for i in range(10):\\n idx_k = np.where(y_train==i)[0]\\n np.random.shuffle(idx_k)\\n split = np.array_split(idx_k,n_parties)\\n for j in range(n_parties):\\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[j])\\n else:\\n times=[0 for i in range(K)]\\n contain=[]\\n for i in range(n_parties):\\n current=[i%K]\\n times[i%K]+=1\\n j=1\\n while (j<num):\\n ind=random.randint(0,K-1)\\n if (ind not in current):\\n j=j+1\\n current.append(ind)\\n times[ind]+=1\\n contain.append(current)\\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\\n for i in range(K):\\n idx_k = np.where(y_train==i)[0]\\n np.random.shuffle(idx_k)\\n split = np.array_split(idx_k,times[i])\\n ids=0\\n for j in range(n_parties):\\n if i in contain[j]:\\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[ids])\\n ids+=1\\n\\n\\n elif partition == \\\"iid-diff-quantity\\\":\\n idxs = np.random.permutation(n_train)\\n min_size = 0\\n while min_size < 10:\\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\\n proportions = proportions/proportions.sum()\\n min_size = np.min(proportions*len(idxs))\\n proportions = (np.cumsum(proportions)*len(idxs)).astype(int)[:-1]\\n batch_idxs = np.split(idxs,proportions)\\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\\n \\n elif partition == \\\"mixed\\\":\\n min_size = 0\\n min_require_size = 10\\n K = 10\\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\\n K = 2\\n # min_require_size = 100\\n\\n N = y_train.shape[0]\\n net_dataidx_map = {}\\n\\n times=[1 for i in range(10)]\\n contain=[]\\n for i in range(n_parties):\\n current=[i%K]\\n j=1\\n while (j<2):\\n ind=random.randint(0,K-1)\\n if (ind not in current and times[ind]<2):\\n j=j+1\\n current.append(ind)\\n times[ind]+=1\\n contain.append(current)\\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\\n \\n\\n min_size = 0\\n while min_size < 10:\\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\\n proportions = proportions/proportions.sum()\\n min_size = np.min(proportions*n_train)\\n\\n for i in range(K):\\n idx_k = np.where(y_train==i)[0]\\n np.random.shuffle(idx_k)\\n\\n proportions_k = np.random.dirichlet(np.repeat(beta, 2))\\n #proportions_k = np.ndarray(0,dtype=np.float64)\\n #for j in range(n_parties):\\n # if i in contain[j]:\\n # proportions_k=np.append(proportions_k ,proportions[j])\\n\\n proportions_k = (np.cumsum(proportions_k)*len(idx_k)).astype(int)[:-1]\\n\\n split = np.split(idx_k, proportions_k)\\n ids=0\\n for j in range(n_parties):\\n if i in contain[j]:\\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[ids])\\n ids+=1\\n\\n elif partition == \\\"real\\\" and dataset == \\\"femnist\\\":\\n num_user = u_train.shape[0]\\n user = np.zeros(num_user+1,dtype=np.int32)\\n for i in range(1,num_user+1):\\n user[i] = user[i-1] + u_train[i-1]\\n no = np.random.permutation(num_user)\\n batch_idxs = np.array_split(no, n_parties)\\n net_dataidx_map = {i:np.zeros(0,dtype=np.int32) for i in range(n_parties)}\\n for i in range(n_parties):\\n for j in batch_idxs[i]:\\n net_dataidx_map[i]=np.append(net_dataidx_map[i], np.arange(user[j], user[j+1]))\\n\\n traindata_cls_counts = record_net_data_stats(y_train, net_dataidx_map, logdir)\\n return (X_train, y_train, X_test, y_test, net_dataidx_map, traindata_cls_counts)\",\n \"def learn(self):\\n metrics_hist = dict()\\n max_runs = 3\\n for run in range(max_runs):\\n all_indices, initial_indices = self._init_al_dataset()\\n\\n metrics_hist[str(run)] = dict()\\n\\n current_indices = list(initial_indices)\\n \\n for split in self.data_splits_frac:\\n print(f'\\\\nRUN {run} - SPLIT - {split*100:0.0f}%')\\n\\n # Initialise models\\n self._init_models(mode='svaal')\\n\\n # Do some label stuff\\n unlabelled_indices = np.setdiff1d(list(all_indices), current_indices)\\n unlabelled_sampler = data.sampler.SubsetRandomSampler(unlabelled_indices)\\n unlabelled_dataloader = data.DataLoader(self.datasets['train'],\\n sampler=unlabelled_sampler,\\n batch_size=64,\\n drop_last=False)\\n\\n print(f'Labelled: {len(current_indices)} Unlabelled: {len(unlabelled_indices)} Total: {len(all_indices)}')\\n\\n # TODO: Make the SVAAL allow 100% labelled and 0% unlabelled to pass through it. Breaking out of loop for now when data hits 100% labelled.\\n if len(unlabelled_indices) == 0:\\n break\\n\\n metrics, svae, discriminator = self.train(dataloader_l=self.labelled_dataloader,\\n dataloader_u=unlabelled_dataloader,\\n dataloader_v=self.val_dataloader,\\n dataloader_t=self.test_dataloader,\\n mode='svaal') \\n print(f'Test Eval.: F1 Scores - Macro {metrics[0]*100:0.2f}% Micro {metrics[1]*100:0.2f}%') \\n \\n # Record performance at each split\\n metrics_hist[str(run)][str(split)] = metrics\\n\\n \\n sampled_indices = self.sample_adversarial(svae, discriminator, unlabelled_dataloader, indices=unlabelled_indices, cuda=True) # TODO: review usage of indices arg\\n current_indices = list(current_indices) + list(sampled_indices)\\n sampler = data.sampler.SubsetRandomSampler(current_indices)\\n self.labelled_dataloader = data.DataLoader(self.datasets['train'], sampler=sampler, batch_size=self.batch_size, drop_last=True)\\n \\n # write results to disk\\n with open('results.json', 'w') as fj:\\n json.dump(metrics_hist, fj, indent=4)\",\n \"def run_evaluation(self, n_runs=1, n_points=1000, n_iterations=1, min_n_components=2, max_n_components=25,\\n\\t\\t\\t\\t\\t n_splits=3, save_data=False, file_label='',n_microstates=None, all_methods=True,\\n\\t\\t\\t\\t\\t assign_transition_points=True):\\n\\n\\t\\tif self.presampled_data is not None:\\n\\t\\t\\tsampled_data = self.presampled_data[0]\\n\\t\\t\\ttrue_clustering = self.presampled_data[1]\\n\\t\\t\\tn_runs = sampled_data.shape[0]\\n\\n\\t\\tself.cluster_score_ami_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tself.cluster_score_fm_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tself.cluster_score_vm_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tdata = self.toy_model_.sample(3)\\n\\n\\t\\t# Create free energy estimators\\n\\t\\tgmm_FE = GMM_FE.FreeEnergyClustering(data, min_n_components=min_n_components, max_n_components=max_n_components,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t x_lims=self.x_lims_, n_grids=self.n_grids_, stack_landscapes=False,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t n_splits=n_splits, n_iterations=n_iterations,convergence_tol=self.convergence_tol_,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t verbose=self.verbose_)\\n\\n\\t\\tkm = kmc.KMeansCluster(min_n_components, max_n_components)\\n\\t\\taw = awc.AWCluster(min_n_components, max_n_components)\\n\\t\\tspectral = sc.SpectralCluster(min_n_components, max_n_components)\\n\\n\\t\\tall_data = []\\n\\t\\tfor i_run in range(n_runs):\\n\\t\\t\\tprint(\\\"Run: \\\"+str(i_run+1)+'/'+str(n_runs))\\n\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\t# Sample data\\n\\t\\t\\t\\tdata = self.toy_model_.sample(n_points)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdata = sampled_data[i_run]\\n\\t\\t\\t\\n\\t\\t\\tall_data.append(data)\\n\\n\\t\\t\\tprint('Shape data: ' + str(data.shape))\\n\\n\\t\\t\\t# Set data in model and estimate GMM density\\n\\t\\t\\tgmm_FE.data_ = data\\n\\t\\t\\tcoords, est_FE_landsc, FE_points = gmm_FE.landscape()\\n\\n\\t\\t\\t# Get true cluster labels\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\tif hasattr(self.toy_model_, \\\"assign_cluster_labels\\\"):\\n\\t\\t\\t\\t\\tself.true_labels_ = self.toy_model_.assign_cluster_labels(data)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tprint('Setting true labels.')\\n\\t\\t\\t\\t\\tself.true_labels_, _ = self.true_FE_.cluster(data, np.zeros(data.shape[0]))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.true_labels_ = true_clustering[i_run]\\n\\t\\t\\t\\n\\t\\t\\t# Cluster data with different methods\\n\\t\\t\\tif n_microstates is None:\\n\\t\\t\\t\\tself.FE_min_labels, _ = gmm_FE.cluster(data, FE_points, assign_transition_points=assign_transition_points)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tkmea = KMeans(n_clusters=n_microstates).fit(data[::2])\\n\\t\\t\\t\\tmicrostate_centers = kmea.cluster_centers_\\n\\t\\t\\t\\tself.FE_min_labels, _ = gmm_FE.cluster(microstate_centers, FE_points, data, assign_transition_points=assign_transition_points, unravel_grid=False)\\n\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tself.km_labels = km.cluster(data)\\n\\t\\t\\t\\tself.aw_labels = aw.cluster(data)\\n\\t\\t\\t\\tself.spectral_labels = spectral.cluster(data)\\n\\n\\t\\t\\t# Score clustering using different scoring metrics\\n\\t\\t\\t# V-measure score\\n\\t\\t\\tself.cluster_score_vm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'vm')\\n\\t\\t\\tprint(self.cluster_score_vm_GMM_FE_min_[i_run])\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tself.cluster_score_vm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_kmeans_[i_run] = self._score_clustering(self.km_labels,'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_AW_[i_run] = self._score_clustering(self.aw_labels,'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'vm')\\n\\n\\t\\t\\t\\t# Adjusted MI\\n\\t\\t\\t\\tself.cluster_score_ami_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_kmeans_[i_run] = self._score_clustering(self.km_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_AW_[i_run] = self._score_clustering(self.aw_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_spectral_[i_run] = self._score_clustering(self.spectral_labels,'ami')\\n\\n\\t\\t\\t\\t# Fowlkes Mallows\\n\\t\\t\\t\\tself.cluster_score_fm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_kmeans_[i_run] = self._score_clustering(self.km_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_AW_[i_run] = self._score_clustering(self.aw_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'fm')\\n\\t\\t\\n\\t\\tif save_data:\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\tnp.save('data_out/sampled_data_'+self.toy_model_.name+file_label+'.npy',all_data)\\n\\n\\t\\t\\tif False:\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_fm_GMM_FE_min_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_kmeans_' + self.toy_model_.name +file_label +'.npy', self.cluster_score_fm_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_spectral_)\\n\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_ami_GMM_FE_min_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_spectral_)\\n\\n\\t\\t\\tnp.save('data_out/cluster_score_vm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_vm_GMM_FE_min_)\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_spectral_)\\n\\t\\treturn\",\n \"def ensemble_001():\\n n_centroids = 3000\\n s = 15\\n crop = 150\\n n_patches = 400000\\n rf_size = 5\\n\\n train_x_crop_scale = CropScaleImageTransformer(training=True,\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n\\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\\n rf_size=rf_size,\\n result_path='data/mdl_ensemble_001',\\n n_iterations=20,\\n n_jobs=-1,)\\n\\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\\n patch_size=rf_size,\\n n_jobs=-1)\\n images = train_x_crop_scale.transform()\\n patches = patch_extractor.transform(images)\\n\\n kmeans_generator.fit(patches)\\n\\n del patches\\n gc.collect()\\n\\n X = kmeans_generator.transform(images, save_to_file='data/data_ensemble_001.npy', memmap=True)\\n Y = classes.train_solutions.data\\n\\n # Unload some objects\\n del images\\n gc.collect()\\n\\n # Get the input for the RF so that we can split together\\n sampler = SampleTransformer(training=True, steps=2, step_size=20, n_jobs=-1)\\n pX = sampler.transform()\\n\\n # manual split of train and test\\n train_x, test_x, ptrain_x, ptest_x, train_y, test_y = train_test_split(X, pX, Y, test_size=0.5)\\n\\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 500}, n_jobs=-1)\\n wrapper.fit(train_x, train_y)\\n kmeans_preds = wrapper.predict(test_x)\\n\\n pWrapper = ModelWrapper(RandomForestRegressor, {'n_estimators': 500, 'verbose': 3}, n_jobs=-1)\\n pWrapper.fit(ptrain_x, train_y)\\n pixel_preds = pWrapper.predict(ptest_x)\\n\\n logger.info('Kmeans')\\n classes.colwise_rmse(kmeans_preds, test_y)\\n classes.rmse(kmeans_preds, test_y)\\n logger.info('Pixel RF')\\n classes.colwise_rmse(pixel_preds, test_y)\\n classes.rmse(pixel_preds, test_y)\\n\\n logger.info(\\\"Ensembling predictions\\\")\\n etrain_x = np.hstack((wrapper.predict(train_x), pWrapper.predict(ptrain_x)))\\n etest_x = np.hstack((kmeans_preds, pixel_preds))\\n eWrapper = ModelWrapper(RandomForestRegressor, {'n_estimators': 500, 'verbose': 3}, n_jobs=-1)\\n eWrapper.fit(etrain_x, train_y)\\n ensemble_preds = eWrapper.predict(etest_x)\\n classes.colwise_rmse(ensemble_preds, test_y)\\n classes.rmse(ensemble_preds, test_y)\",\n \"def read_data_split_and_search():\\n\\n\\n\\n dataReader = Movielens10MReader()\\n dataset = dataReader.load_data()\\n\\n URM_train, URM_test = split_train_in_two_percentage_global_sample(dataset.get_URM_all(), train_percentage = 0.80)\\n URM_train, URM_validation = split_train_in_two_percentage_global_sample(URM_train, train_percentage = 0.80)\\n\\n output_folder_path = \\\"result_experiments/\\\"\\n\\n\\n # If directory does not exist, create\\n if not os.path.exists(output_folder_path):\\n os.makedirs(output_folder_path)\\n\\n\\n\\n\\n\\n\\n\\n collaborative_algorithm_list = [\\n Random,\\n TopPop,\\n P3alphaRecommender,\\n RP3betaRecommender,\\n ItemKNNCFRecommender,\\n UserKNNCFRecommender,\\n MatrixFactorization_BPR_Cython,\\n MatrixFactorization_FunkSVD_Cython,\\n PureSVDRecommender,\\n SLIM_BPR_Cython,\\n SLIMElasticNetRecommender\\n ]\\n\\n\\n\\n\\n from Base.Evaluation.Evaluator import EvaluatorHoldout\\n\\n evaluator_validation = EvaluatorHoldout(URM_validation, cutoff_list=[5])\\n evaluator_test = EvaluatorHoldout(URM_test, cutoff_list=[5, 10])\\n\\n\\n runParameterSearch_Collaborative_partial = partial(runParameterSearch_Collaborative,\\n URM_train = URM_train,\\n metric_to_optimize = \\\"MAP\\\",\\n n_cases = 10,\\n evaluator_validation_earlystopping = evaluator_validation,\\n evaluator_validation = evaluator_validation,\\n evaluator_test = evaluator_test,\\n output_folder_path = output_folder_path,\\n similarity_type_list = [\\\"cosine\\\"],\\n parallelizeKNN = False)\\n\\n\\n\\n\\n\\n pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)\\n pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)\\n\\n #\\n #\\n # for recommender_class in collaborative_algorithm_list:\\n #\\n # try:\\n #\\n # runParameterSearch_Collaborative_partial(recommender_class)\\n #\\n # except Exception as e:\\n #\\n # print(\\\"On recommender {} Exception {}\\\".format(recommender_class, str(e)))\\n # traceback.print_exc()\\n #\",\n \"def _fit_split_(self, dataset, targets, val_set, val_targets, checkpoints):\\n dir = ''.join(random.choices(string.ascii_lowercase + string.digits, k=16))\\n dir = '.tmp' + dir + '/'\\n os.mkdir(dir)\\n grid = self.grid\\n if self.folds is not None or self.folds != 0:\\n if self.task == 'Classification':\\n if self.folds > 1:\\n sf = StratifiedKFold(n_splits=self.folds, shuffle=True, random_state=0)\\n elif 0 <= self.folds < 1:\\n sf = StratifiedShuffleSplit(n_splits=1, test_size=self.folds, random_state=0)\\n elif self.task == 'Regression':\\n folds, dataset, targets = self.split_regression(dataset, targets)\\n results = []\\n for params in grid:\\n try:\\n nn = NeuralNetwork()\\n for i in range(len(params['layers'])):\\n if i == 0:\\n nn.add_layer('dense', params['layers'][i], params['activation'], dataset.shape[1])\\n else:\\n if i == len(params['layers']) - 1 and self.task == 'Regression':\\n nn.add_layer('dense', params['layers'][i], 'linear')\\n else:\\n nn.add_layer('dense', params['layers'][i], params['activation'])\\n curr_res = {'params': params,\\n 'metric_stats': [],\\n 'test_stats': [],\\n 'vl_stats': [],\\n 'tr_stats': []}\\n\\n if self.task == 'Classification':\\n folds = sf.split(dataset, targets)\\n for train_index, test_index in folds:\\n X_train, X_test = dataset[train_index], dataset[test_index]\\n Y_train, Y_test = targets[train_index], targets[test_index]\\n nested_best = None\\n nested_best_metric = None\\n nested_tr_pred = None\\n nested_vl_pred = None\\n for i in range(self.restarts):\\n nn.compile(task=self.task,\\n loss=self.loss_name,\\n l2_lambda=params['l2_lambda'],\\n dropout=params['dropout'],\\n optimizer=SGD(lr_init=params['lr'],\\n momentum=params['momentum'],\\n nesterov=params['nesterov'],\\n lr_sched=StepDecayScheduler(drop=params['lr_sched'][0],\\n epochs_drop=params['lr_sched'][1])))\\n\\n curr_model, curr_metric, best_epoch = nn.fit(X_train, Y_train,\\n val_set=val_set, val_targets=val_targets,\\n batch_size=params['batch_size'],\\n test_size=params['test_size'],\\n epochs=params['epoch'],\\n patience=params['patience'],\\n save_pred=dir + 'tmp_gs',\\n save_model=None)\\n\\n nested_best_metric = metrics.metric_improve(self.metric, nested_best_metric, curr_metric)\\n if nested_best_metric[1]:\\n nested_tr_pred = np.load(dir + 'tmp_gs_tr_predictions.npy')[best_epoch]\\n nested_vl_pred = np.load(dir + 'tmp_gs_vl_predictions.npy')[best_epoch]\\n nested_best = copy.deepcopy(curr_model)\\n if nested_best_metric[2]:\\n break\\n\\n Y_pred = nested_best.predict(X_test)\\n if self.metric == 'loss':\\n curr_metric = np.sum(self.loss(Y_test, Y_pred), axis=0) / len(Y_test)\\n else:\\n curr_metric = metrics.metric_computation(self.metric, Y_test, Y_pred)\\n\\n curr_res['metric_stats'].append(curr_metric)\\n tr_stats = []\\n vl_stats = []\\n test_stats = []\\n for stat in self.statistics:\\n if stat == 'loss':\\n\\n tr_stats.append(np.mean(self.loss(nested_tr_pred[:, :targets.shape[1]],\\n nested_tr_pred[:, targets.shape[1]:])))\\n vl_stats.append(np.mean(self.loss(nested_vl_pred[:, :targets.shape[1]],\\n nested_vl_pred[:, targets.shape[1]:])))\\n test_stats.append(np.mean(self.loss(Y_test, Y_pred)))\\n else:\\n tr_stats.append(metrics.metric_computation(stat,\\n nested_tr_pred[:, :targets.shape[1]],\\n nested_tr_pred[:, targets.shape[1]:]))\\n vl_stats.append(metrics.metric_computation(stat,\\n nested_vl_pred[:, :targets.shape[1]],\\n nested_vl_pred[:, targets.shape[1]:]))\\n test_stats.append(metrics.metric_computation(stat, Y_test, Y_pred))\\n curr_res['tr_stats'].append(tr_stats)\\n curr_res['vl_stats'].append(vl_stats)\\n curr_res['test_stats'].append(test_stats)\\n\\n results.append(curr_res)\\n if checkpoints is not None:\\n with open(checkpoints + '.pkl', 'wb') as output:\\n pickle.dump(results, output, pickle.HIGHEST_PROTOCOL)\\n\\n except NesterovError:\\n continue\\n shutil.rmtree(dir)\\n return results\",\n \"def __train__(self):\\n if (self.type_camf == 'CAMF_CI'):\\n #users, items, context, ratings\\n ci = camf_ci.CI_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = ci.fit()\\n elif (self.type_camf == 'CAMF_CU'):\\n cu = camf_cu.CU_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = cu.fit()\\n elif (self.type_camf == 'CAMF_C'):\\n c = camf_c.C_class(self.__users_array__, self.__items_array__, self.__context_array__, self.__ratings__, self.fold, self.lr, self.factors)\\n predictions, losses = c.fit()\\n\\n dummy_pred = np.zeros((predictions.shape))\\n for r, pred_array in enumerate(predictions):\\n for c, pred in enumerate(pred_array):\\n dummy_pred[r][c] = self.__check_ratings__(pred)\\n predictions = dummy_pred\\n #save a plot with a loss function\\n plots = prs.PlotRSData()\\n #print(losses)\\n plots.plot_loss_cars(losses, self.type_camf, self.__save_prefix__+\\\"_loop\\\"+str(self.loop))\\n pd.DataFrame(losses).to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ +\\\"losses_loop\\\"+str(self.loop)+\\\".csv\\\")\\n print('Saving the feature matrix...')\\n # set predictions back to the pivot table\\n self.__utility_saved_training__(predictions) \\n # save results\\n self.utility_predictions.to_csv(\\\"./RecSys/out/CAMF/train/\\\"+self.type_camf+\\\"/\\\" + self.__save_prefix__ + \\\"_SGD_predictions_loop\\\"+str(self.loop)+\\\".csv\\\")\",\n \"def split_train_test_classifier(self, split_method, method):\\n \\n # split data balance based on user and act (if provided)\\n if method == 'window_based':\\n data_train, data_val, label_user_train, label_user_val, id_window_train, id_window_val = self.split_train_val_classifier(\\n self.classifier['data'], self.classifier['user_label'], self.classifier['act_label'], self.classifier['id'], 'standard', train_size=0.9) \\n\\n print(f'Train window before delete overlap sequence: {data_train.shape[0]}')\\n\\n # delete overlap sequence\\n if self.overlap != 0:\\n if self.overlap == 0.5:\\n distance_to_delete = [1]\\n elif self.overlap == 0.75:\\n distance_to_delete = [1,2,3]\\n invalid_idx = delete_overlap(id_window_train, id_window_val, distance_to_delete)\\n data_train = np.delete(data_train, invalid_idx, axis=0)\\n label_user_train = np.delete(label_user_train, invalid_idx, axis=0)\\n\\n print(f'Train window after delete overlap sequence: {data_train.shape[0]}')\\n print(f'Validation set: {data_val.shape[0]}')\\n \\n elif method == 'cycle_based':\\n data_train, data_val, label_user_train, label_user_val = self.split_train_val_classifier(\\n self.classifier['data'], self.classifier['user_label'], self.classifier['act_label'], None, split_method, train_size=0.9) \\n\\n self.train = data_train\\n self.train_user = label_user_train\\n self.val = data_val\\n self.val_user = label_user_val\",\n \"def train(self):\\n for data_tier in self.data_tiers:\\n fd = open(self.data_path + '/training_data_' + data_tier + '.json', 'r')\\n self.preprocessed_data[data_tier] = json.load(fd)\\n fd.close()\\n tot = len(self.preprocessed_data[data_tier]['features'])\\n p = int(math.ceil(tot*0.8))\\n training_features = np.array(self.preprocessed_data[data_tier]['features'][:p])\\n trend_training_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][:p])\\n avg_training_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][:p])\\n t1 = datetime.datetime.utcnow()\\n self.clf_trend[data_tier].fit(training_features, trend_training_classifications)\\n self.clf_avg[data_tier].fit(training_features, avg_training_classifications)\\n t2 = datetime.datetime.utcnow()\\n td = t2 - t1\\n self.logger.info('Training %s for data tier %s took %s', self.name, data_tier, str(td))\\n joblib.dump(self.clf_trend[data_tier], self.data_path + '/' + self.name + '_trend_' + data_tier + '.pkl')\\n joblib.dump(self.clf_avg[data_tier], self.data_path + '/' + self.name + '_avg_' + data_tier + '.pkl')\",\n \"def create_train_test(option, transform, params, split=0.2):\\r\\n clip_im_dir = option.clip_im_dir\\r\\n matting_dir = option.matting_dir\\r\\n csv_path = option.csv_path\\r\\n \\r\\n print(\\\"create datasets\\\")\\r\\n \\r\\n \\r\\n data_df = pd.read_csv(csv_path)\\r\\n # data_df = MergeDataframe(clip_im_dir, matting_dir)\\r\\n \\r\\n #separate data in training and test data (20/80)\\r\\n train_df, test_df = train_test_split(data_df, test_size=split)\\r\\n \\r\\n #search right Dataset class\\r\\n package_dir = Path(src.dataset.__file__).resolve().parent\\r\\n\\r\\n for (_, module_name, _) in iter_modules([package_dir]):\\r\\n # print(module_name, self.ComType)\\r\\n if option.dataset.lower() == module_name.lower() :\\r\\n modelModule = importlib.import_module(\\\".\\\"+module_name)\\r\\n break\\r\\n \\r\\n # train data\\r\\n training_set = modelModule(train_df, clip_im_dir, matting_dir, transform, transform)\\r\\n train_loader = DataLoader(training_set, **params)\\r\\n \\r\\n \\r\\n #test data\\r\\n testing_set = modelModule(test_df, clip_im_dir, matting_dir, transform, transform)\\r\\n test_loader = DataLoader(testing_set, **params)\\r\\n \\r\\n return train_loader, test_loader\",\n \"def main():\\n df = prepro_last()\\n X, y = train_build(df)\\n fit_store(X, y)\",\n \"def split_data_metrics_learning(cfg):\\n actual_pose = cfg['actual_pose']\\n target = cfg['target']\\n person_ids = cfg['person_ids']\\n \\n # Split train and val data based on the person ids.\\n all_ids = np.arange(1, 21)\\n val_ids = cfg['val_ids']\\n train_ids = set(all_ids).symmetric_difference(val_ids)\\n \\n anchor_gallery_split_size = cfg['anchor_gallery_split_size']\\n window_width = cfg['window_width']\\n overlap = cfg['overlap']\\n random_state = cfg['random_state']\\n \\n # Get only the training set data and the label.\\n X_train, y_train = get_req_ids(actual_pose, target, train_ids, person_ids)\\n \\n # Select the evaluation data that measures the performance of the model on the training set.\\n train_accuracy_ids = random.sample(train_ids, len(val_ids))\\n X_train_acc, y_train_acc = get_req_ids(actual_pose, target, train_accuracy_ids, person_ids)\\n \\n # Anchor/Gallery set split for the training set.\\n X_train_gal, X_train_anchor, y_train_gal, y_train_anchor = train_test(X_train = X_train_acc, y_train = y_train_acc, \\n test_size=anchor_gallery_split_size, \\n random_state=random_state, stratify=y_train_acc)\\n \\n # Subsample the gait sequences of the anchor/gallery set of the training set based on the window width and the overlap.\\n X_train_gal, y_train_gal = subsample(cfg, X_train_gal, y_train_gal, window_width=window_width, overlap=overlap)\\n X_train_anchor, y_train_anchor = subsample(cfg, X_train_anchor, y_train_anchor, window_width=window_width, overlap=overlap)\\n \\n # Get only the validation set data and the label.\\n X_val, y_val = get_req_ids(actual_pose, target, val_ids, person_ids)\\n \\n # Anchor/Gallery set split for the validation set.\\n X_val_gal, X_val_anchor, y_val_gal, y_val_anchor = train_test(X_train = X_val, \\n y_train = y_val, \\n test_size=anchor_gallery_split_size, \\n random_state=random_state, \\n stratify=y_val)\\n \\n \\n # If data augmentation parameter is set to True in the configuration dictionary, data augmentation is done for the training set.\\n if cfg['augment_data']:\\n X_train, y_train = augment_data(X_train, y_train)\\n \\n # Subsample the gait sequences of the whole training set based on the window width and the overlap.\\n X_train, y_train = subsample(cfg, X_train, y_train, window_width=window_width, overlap=overlap)\\n \\n # Subsample the gait sequences of the anchor/gallery set of the validation set based on the window width and the overlap.\\n X_val_gal, y_val_gal = subsample(cfg, X_val_gal, y_val_gal, window_width=window_width, overlap=overlap)\\n X_val_anchor, y_val_anchor = subsample(cfg, X_val_anchor, y_val_anchor, window_width=window_width, overlap=overlap)\\n \\n # Concatenate the gallery and anchor set of the validation data and label as a whole. This is just to maintain the train-val uniformity and \\n # is not used anywhere in the project.\\n X_val, y_val = np.concatenate((X_val_gal, X_val_anchor)), np.concatenate((y_val_gal, y_val_anchor))\\n \\n return X_train, X_val, X_train_gal, X_train_anchor, X_val_gal, X_val_anchor, y_train, y_val, y_train_gal, y_train_anchor, y_val_gal, y_val_anchor\",\n \"def split(self,\\n dataset,\\n seed=None,\\n frac_train=None,\\n frac_valid=None,\\n frac_test=None,\\n log_every_n=1000,\\n cutoff=0.18,\\n regression_task=True):\\n print(\\\"Performing butina clustering with cutoff of\\\", cutoff)\\n scaffold_sets = self.generate_scaffolds(dataset, cutoff)\\n ys = dataset.y\\n valid_inds = []\\n\\n for c_idx, cluster in enumerate(scaffold_sets):\\n # for m_idx in cluster:\\n valid_inds.extend(cluster)\\n # continue until we find an active in all the tasks, otherwise we can't\\n # compute a meaningful AUC\\n # TODO (ytz): really, we want at least one active and inactive in both scenarios.\\n # TODO (Ytz): for regression tasks we'd stop after only one cluster.\\n active_populations = np.sum(ys[valid_inds], axis=0)\\n if np.all(active_populations):\\n print(\\\"# of actives per task in valid:\\\", active_populations)\\n print(\\\"Total # of validation points:\\\", len(valid_inds))\\n break\\n\\n train_inds = list(itertools.chain.from_iterable(scaffold_sets[c_idx + 1:]))\\n test_inds = []\\n\\n return train_inds, valid_inds, []\",\n \"def train(x_train, y_train, x_test, y_test):\\n\\n print(\\\" Nearest centroid : \\\", end='')\\n run(x_train, y_train, x_test, y_test, NearestCentroid())\\n print(\\\" k-NN classifier (k=3) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=3))\\n print(\\\" k-NN classifier (k=7) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, KNeighborsClassifier(n_neighbors=7))\\n print(\\\" Naive Bayes (Gaussian) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, GaussianNB())\\n print(\\\" Random Forest (trees= 5) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=5))\\n print(\\\" Random Forest (trees= 50) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=50))\\n print(\\\" Random Forest (trees=500) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=500))\\n print(\\\" Random Forest (trees=1000): \\\", end='')\\n run(x_train, y_train, x_test, y_test, RandomForestClassifier(n_estimators=1000))\\n print(\\\" LinearSVM (C=0.01) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.01))\\n print(\\\" LinearSVM (C=0.1) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=0.1))\\n print(\\\" LinearSVM (C=1.0) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=1.0))\\n print(\\\" LinearSVM (C=10.0) : \\\", end='')\\n run(x_train, y_train, x_test, y_test, LinearSVC(C=10.0))\",\n \"def main():\\n datasets = {}\\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\\\"Processing datasets and fitting base models\\\"):\\n logger.info(f\\\"processing dataset {dataset_name}\\\")\\n clusters_path: Optional[str] = None\\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_clusters.json\\\")\\n train_pairs_path = None\\n val_pairs_path = None\\n test_pairs_path = None\\n else:\\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"train_pairs.csv\\\")\\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"val_pairs.csv\\\")\\n if not os.path.exists(val_pairs_path):\\n val_pairs_path = None\\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"test_pairs.csv\\\")\\n\\n logger.info(f\\\"loading dataset {dataset_name}\\\")\\n anddata = ANDData(\\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_signatures.json\\\"),\\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_papers.json\\\"),\\n name=dataset_name,\\n mode=\\\"train\\\",\\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_specter.pickle\\\"),\\n clusters=clusters_path,\\n block_type=BLOCK_TYPE,\\n train_pairs=train_pairs_path,\\n val_pairs=val_pairs_path,\\n test_pairs=test_pairs_path,\\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\\n val_pairs_size=N_VAL_TEST_SIZE,\\n test_pairs_size=N_VAL_TEST_SIZE,\\n preprocess=True,\\n )\\n\\n logger.info(f\\\"featurizing {dataset_name}\\\")\\n train, val, test = featurize(\\n anddata,\\n FEATURIZER_INFO,\\n n_jobs=N_JOBS,\\n use_cache=True,\\n chunk_size=100,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\\n nan_value=NAN_VALUE,\\n )\\n X_train, y_train, nameless_X_train = train\\n X_val, y_val, nameless_X_val = val\\n X_test, y_test, nameless_X_test = test\\n\\n dataset = {}\\n dataset[\\\"anddata\\\"] = anddata\\n dataset[\\\"X_train\\\"] = X_train\\n dataset[\\\"y_train\\\"] = y_train\\n dataset[\\\"X_val\\\"] = X_val\\n dataset[\\\"y_val\\\"] = y_val\\n dataset[\\\"X_test\\\"] = X_test\\n dataset[\\\"y_test\\\"] = y_test\\n dataset[\\\"nameless_X_train\\\"] = nameless_X_train\\n dataset[\\\"nameless_X_val\\\"] = nameless_X_val\\n dataset[\\\"nameless_X_test\\\"] = nameless_X_test\\n dataset[\\\"name\\\"] = anddata.name\\n datasets[dataset_name] = dataset\\n\\n anddatas = [\\n datasets[dataset_name][\\\"anddata\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in PAIRWISE_ONLY_DATASETS\\n ]\\n\\n X_train = np.vstack([datasets[dataset_name][\\\"X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n y_train = np.hstack([datasets[dataset_name][\\\"y_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n X_val = np.vstack(\\n [datasets[dataset_name][\\\"X_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n y_val = np.hstack(\\n [datasets[dataset_name][\\\"y_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n\\n nameless_X_train = np.vstack([datasets[dataset_name][\\\"nameless_X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n nameless_X_val = np.vstack(\\n [\\n datasets[dataset_name][\\\"nameless_X_val\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in {\\\"augmented\\\"}\\n ]\\n )\\n\\n logger.info(\\\"fitting pairwise\\\")\\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\\n union_classifier.fit(X_train, y_train, X_val, y_val)\\n\\n nameless_union_classifier = None\\n if USE_NAMELESS_MODEL:\\n logger.info(\\\"nameless fitting pairwise for \\\" + str(SOURCE_DATASET_NAMES))\\n nameless_union_classifier = PairwiseModeler(\\n n_iter=N_ITER,\\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\\n )\\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\\n logger.info(\\\"nameless pairwise fit for \\\" + str(SOURCE_DATASET_NAMES))\\n\\n logger.info(\\\"fitting clusterer for\\\")\\n union_clusterer = Clusterer(\\n FEATURIZER_INFO,\\n union_classifier.classifier,\\n cluster_model=FastCluster(),\\n search_space=search_space,\\n n_jobs=N_JOBS,\\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\\n )\\n union_clusterer.fit(anddatas)\\n print(\\n \\\"best clustering parameters:\\\",\\n union_clusterer.best_params,\\n )\\n\\n models = {}\\n models[\\\"clusterer\\\"] = union_clusterer\\n\\n with open(\\n f\\\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\\\",\\n \\\"wb\\\",\\n ) as _pickle_file:\\n pickle.dump(models, _pickle_file)\\n logger.info(\\\"Done.\\\")\",\n \"def main():\\n housing = pd.read_csv(\\\"Data/train_original.csv\\\")\\n housing[\\\"TotalSF\\\"] = (\\n housing[\\\"TotalBsmtSF\\\"] + housing[\\\"1stFlrSF\\\"] + housing[\\\"2ndFlrSF\\\"]\\n )\\n training_features, testing_features, training_target, testing_target = impute_dummify_and_split(\\n housing, drop_target=False\\n )\\n\\n p_values = [\\n (c, pearsonr(training_features[\\\"SalePrice\\\"], training_features[c])[1])\\n for c in training_features.columns\\n ]\\n\\n p_value_limits = [0.05]\\n\\n result = []\\n ps_and_cols = {}\\n\\n for p_value_limit in p_value_limits:\\n\\n high_ps = list(\\n map(lambda t: t[0], sorted(p_values, key=lambda t1: t1[1])[:15])\\n )\\n\\n print(training_features[high_ps].corr())\\n\\n columns = [p[0] for p in p_values if p[1] < p_value_limit]\\n\\n training_features_restricted = training_features[columns].drop(\\n \\\"SalePrice\\\", axis=\\\"columns\\\"\\n )\\n\\n testing_features_restricted = testing_features[columns].drop(\\n \\\"SalePrice\\\", axis=\\\"columns\\\"\\n )\\n\\n for model in (\\n linear_model.Lasso(alpha=2.1),\\n linear_model.Ridge(alpha=2.1),\\n ):\\n\\n model.fit(training_features_restricted, training_target)\\n\\n train_score = model.score(\\n training_features_restricted, training_target\\n )\\n\\n test_score = model.score(\\n testing_features_restricted, testing_target\\n )\\n\\n name = str(model).split(\\\"(\\\")[0]\\n\\n result = result + [\\n (\\n \\\"_2_restrict_features\\\",\\n name,\\n \\\"p value limit: {:.3f}, alpha: 2.1\\\".format(p_value_limit),\\n train_score,\\n test_score,\\n )\\n ]\\n\\n print(ps_and_cols)\\n return training_features[high_ps].corr()\",\n \"def split_data(self,test=False):\\n shuffle_index = torch.randperm(self.train_target.shape[0])\\n load = shuffle_index.shape[0]\\n train_input_shuffle = self.train_input[shuffle_index]\\n train_target_shuffle = self.train_target[shuffle_index]\\n train_classes_shuffle = self.train_classes[shuffle_index]\\n index_train = self.index_for_equal_class(train_target_shuffle[:load//2])\\n train_input = train_input_shuffle[index_train]\\n train_target = train_target_shuffle[index_train]\\n train_classes = train_classes_shuffle[index_train]\\n if not test:\\n index_test = self.index_for_equal_class( train_target_shuffle[load//2:]) + load//2\\n test_input = train_input_shuffle[index_test]\\n test_target = train_target_shuffle[index_test]\\n test_classes = train_classes_shuffle[index_test]\\n else:\\n index_test = self.index_for_equal_class(self.test_target)\\n test_input = self.test_input[index_test]\\n test_target = self.test_target[index_test]\\n test_classes = self.test_classes[index_test]\\n train_input, mean, std = normalize(train_input)\\n test_input, _, _ = normalize(test_input,mean,std)\\n return train_input, train_target, train_classes ,test_input ,test_target ,test_classes\",\n \"def main():\\n \\n # The following 5 command lines can be outcommented if the features are already created.\\n # There is no need to process the data every single time.\\n # Fine tuning the learning algorythm is much faster without that extra step.\\n \\n # by reading the train dataset the feature index is created.\\n # First calling of the processdata function\\n # Data limited to 300000\\n featureIndexes = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000)\\n print \\\"featureIndex generated!\\\"\\n print len(featureIndexes)\\n\\n # Trainfeature is created using the indexfeatures...\\n # Second calling of the processdata function\\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000) # Original itemsLimit=300000\\n\\n # Building the test dataset... just like the training...\\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\\\"avito_test.tsv\\\"), featureIndexes)\\n\\n # Dumping data into file...\\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\\\"SeparatedByCategory.pkl\\\"))\\n\\n\\n # loading data pack...\\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n\\n #logging.info(\\\"Feature preparation done, fitting model...\\\")\\n\\n # Stochastic gradient model\",\n \"def train(data, N, accuracy, Lout, Washout, Vin, Wres):\\n print 'Training'\\n args = [\\n [data[i], N, accuracy, Washout, Vin, Wres] for i in xrange(Lout)\\n ]\\n pool = Pool(processes=Lout)\\n clusters = pool.map(training, args)\\n # TODO delete\\n for i, cluster in enumerate(clusters):\\n np.savetxt('dump_{0}'.format(i), cluster[1])\\n return clusters\",\n \"def kmeans_006():\\n n_centroids_vals = [1000, 2000, 2500, 3000]\\n scores = []\\n\\n for n_centroids in n_centroids_vals:\\n s = 15\\n crop = 150\\n n_patches = 400000\\n rf_size = 5\\n logger.info(\\\"Training with n_centroids {}\\\".format(n_centroids))\\n\\n train_x_crop_scale = CropScaleImageTransformer(training=True,\\n result_path='data/data_train_crop_{}_scale_{}.npy'.format(crop, s),\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n test_x_crop_scale = CropScaleImageTransformer(training=False,\\n result_path='data/data_test_crop_{}_scale_{}.npy'.format(crop, s),\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n\\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\\n rf_size=rf_size,\\n result_path='data/mdl_kmeans_006_centroids_{}'.format(n_centroids),\\n n_iterations=20,\\n n_jobs=-1,)\\n\\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\\n patch_size=rf_size,\\n n_jobs=-1)\\n images = train_x_crop_scale.transform()\\n\\n patches = patch_extractor.transform(images)\\n\\n kmeans_generator.fit(patches)\\n\\n del patches\\n gc.collect()\\n\\n train_x = kmeans_generator.transform(images, save_to_file='data/data_kmeans_features_006_centroids_{}.npy'.format(n_centroids), memmap=True)\\n train_y = classes.train_solutions.data\\n # Unload some objects\\n del images\\n gc.collect()\\n\\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 250}, n_jobs=-1)\\n wrapper.cross_validation(train_x, train_y, n_folds=2, parallel_estimator=True)\\n\\n score = (n_centroids, wrapper.cv_scores)\\n logger.info(\\\"Scores: {}\\\".format(score))\\n scores.append(score)\\n\\n del wrapper\\n gc.collect()\",\n \"def run_train_test_split():\\n # Load all documents\\n conn = sq.connect(config.DB_FILE)\\n documents = pd.read_sql_query('select pubmed_id, review_id, included, title, abstract from article ', conn)\\n\\n # Identify unique review IDs\\n review_ids = documents['review_id'].unique()\\n\\n # Set seed for random sampling\\n np.random.seed(2)\\n\\n # List of Reviews in the partial data set and full data set\\n partial_set = list(np.random.choice(review_ids, 10, replace=False))\\n full_set = list(review_ids.copy())\\n\\n # Load array (X) and labels (Y) of all documents\\n with (open(config.DOC_TERM_MATRIX, \\\"rb\\\")) as openfile:\\n X = pickle.load(openfile)\\n\\n y = documents['included']\\n\\n # Train-test split of the partial dataset\\n train_test_split(X, y, partial_set, 'min_max', 'partial', review_ids)\\n train_test_split(X, y, partial_set, 'tf_idf', 'partial', review_ids)\\n\\n # Train-test split of the full dataset\\n train_test_split(X, y, full_set, 'min_max', 'full', review_ids)\\n train_test_split(X, y, full_set, 'tf_idf', 'full', review_ids)\",\n \"def split_dataset(self, split):\\n trunk_pos_size = math.ceil((1 - split) * len(self.Pos))\\n trunk_neg_size = math.ceil((1 - split) * len(self.Neg))\\n trunk_num = int(1 / (1 - split))\\n pos_temp = list()\\n neg_temp = list()\\n for index in range(trunk_num):\\n pos_temp.append(self.Pos[index * trunk_pos_size:(index + 1) *\\n trunk_pos_size])\\n neg_temp.append(self.Neg[index * trunk_neg_size:(index + 1) *\\n trunk_neg_size])\\n self.test = pos_temp.pop(2) + neg_temp.pop(2)\\n # self.train = [i for item in pos_temp + neg_temp for i in item]\\n self.train = []\\n for item in pos_temp + neg_temp:\\n for i in item:\\n self.train.append(i)\\n\\n random.shuffle(self.train)\\n random.shuffle(self.test)\",\n \"def train( self, trainingData, trainingLabels, validationData, validationLabels ):\\n\\n self.features = trainingData[0].keys() # could be useful later\\n # DO NOT ZERO OUT YOUR WEIGHTS BEFORE STARTING TRAINING, OR\\n # THE AUTOGRADER WILL LIKELY DEDUCT POINTS.\\n for iteration in range(self.max_iterations):\\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\\n print (\\\"Starting iteration \\\", iteration, \\\"...\\\")\\n for i in range(len(trainingData)):#training data\\n max = -10000000\\n for j in range(len(self.weights)):\\n prod = np.dot(self.weights[j], trainingData[i]) #este sería x0 (en la primera vuelta) (xj)\\n if (prod > max):\\n max=prod #en max guardamos la distancia a la instancia que más cerca está de la que estamos recorriendo\\n indclase=j #guardas el índice de la clase a la que predices que pertenece\\n\\n if(indclase != trainingLabels[i]):\\n # recalcular pesos\\n self.weights[trainingLabels[i]].__radd__(trainingData[i]) #honek jarraian egiten du gehiketa pisu guztientzat\\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\\n self.weights[indclase].__sub__(trainingData[i]) #honek jarraian egiten du kenketa pisu guztientzat\\n\\n\\n\\n\\n\\n ########################################################################################\\n # 1. i es el indice de un ejemplo (un item, f(x) de un ejemplo) del conjunto de entrenamiento.\\n # 2. Asi pues, en cada vuelta de este loop se trata un solo ejemplo\\n # por cada ejemplo calculareis el producto punto (dotProduct) w*item\\n # NOTAS: Recordad que cada ejemplo viene representado por varios rasgos (o features), es decir, es un vector de rasgos, tantos como nos marca el atributo self.features.\\n # Asi cada ejemplo es de dimension 1 filas y self.features).\\n # La dimension del vector w tambien es self.features, es decir, habra tantos pesos en w_rasgo dentro de w como rasgos haya en cada item de ejemplo\\n # Recordad tambien que es una clasificacion multiclase en este caso. Hay tantas clases como nos marca el atributo self.legalLabels\\n #########################################################################################\",\n \"def process_dataset(self):\\n\\n logger.info('\\\\n')\\n logger.info('=' * 40)\\n logger.info('=\\\\t DeepRank Data Set')\\n logger.info('=')\\n logger.info('=\\\\t Training data')\\n for f in self.train_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n if self.valid_database:\\n logger.info('=\\\\t Validation data')\\n for f in self.valid_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n if self.test_database:\\n logger.info('=\\\\t Test data')\\n for f in self.test_database:\\n logger.info(f'=\\\\t -> {f}')\\n logger.info('=')\\n logger.info('=' * 40 + '\\\\n')\\n sys.stdout.flush()\\n\\n # check if the files are ok\\n self.check_hdf5_files(self.train_database)\\n\\n if self.valid_database:\\n self.valid_database = self.check_hdf5_files(\\n self.valid_database)\\n\\n if self.test_database:\\n self.test_database = self.check_hdf5_files(\\n self.test_database)\\n\\n # create the indexing system\\n # alows to associate each mol to an index\\n # and get fname and mol name from the index\\n self.create_index_molecules()\\n\\n # get the actual feature name\\n if self.mapfly:\\n self.get_raw_feature_name()\\n else:\\n self.get_mapped_feature_name()\\n\\n # get the pairing\\n self.get_pairing_feature()\\n\\n # get grid shape\\n self.get_grid_shape()\\n\\n # get the input shape\\n self.get_input_shape()\\n\\n # get renormalization factor\\n if self.normalize_features or self.normalize_targets or self.clip_features:\\n if self.mapfly:\\n self.compute_norm()\\n else:\\n self.get_norm()\\n\\n logger.info('\\\\n')\\n logger.info(\\\" Data Set Info:\\\")\\n logger.info(\\n f' Augmentation : {self.use_rotation} rotations')\\n logger.info(\\n f' Training set : {self.ntrain} conformations')\\n logger.info(\\n f' Validation set : {self.nvalid} conformations')\\n logger.info(\\n f' Test set : {self.ntest} conformations')\\n logger.info(f' Number of channels : {self.input_shape[0]}')\\n logger.info(f' Grid Size : {self.data_shape[1]}, '\\n f'{self.data_shape[2]}, {self.data_shape[3]}')\\n sys.stdout.flush()\",\n \"def prediction_data(median_split,mean_split,std_split,degrees_split,weight_split,export_file):\\n DATA_TEST_PATH = '../data/test.csv' # Download train data and supply path here \\n print('\\\\nIMPORTING TESTING DATA :',end=\\\" \\\")\\n y_test, tX_test, ids_test = load_csv_data(DATA_TEST_PATH)\\n print('DONE')\\n \\n #5.a. Splitting the testing data\\n print('SPLITTING TESTING DATA :',end=\\\" \\\")\\n y_test_split,tx_test_split,id_test_split = split_dataset(y_test,tX_test,ids_test) \\n print('DONE') \\n #5.b. prediction on each model\\n y_pred = list()\\n \\n for split,(y_test_s,tx_test_s,id_test_s) in enumerate(zip(y_test_split,tx_test_split,id_test_split)): \\n print('PREDICTION FOR TESTING DATA SPLIT NUMBER',split)\\n \\n #Formatting to the correct datatype\\n y_test_s = np.squeeze(y_test_s)\\n tx_test_s = np.squeeze(tx_test_s)\\n id_test_s = np.squeeze(id_test_s)\\n print('Size of the vectors',y_test_s.shape,tx_test_s.shape) \\n #Formatting the data themselves\\n print('Counting NaN',end='. ')\\n tx_test_s = count_NaN(tx_test_s)\\n print('Sanitizing',end = ' . ')\\n tx_test_s,median_vec = sanitize_NaN(tx_test_s,median_split[split])\\n print('Standardizing',end = ' .')\\n tx_test_s,mean_te,std_te = standardize(tx_test_s,mean_split[split],std_split[split])\\n print('Building polynomial basis') \\n tx_test_s = build_poly(tx_test_s, degrees_split[split])\\n \\n #Prediction\\n y_pred.append(predict_labels(np.array(weight_split[split]), np.array(tx_test_s))) \\n \\n print('MERGING TESTING DATA',end=\\\"\\\")\\n y_pred_merged, ids_merged = merge_dataset(y_pred,id_test_split)\\n print('DONE')\\n \\n OUTPUT_PATH = 'results/output_sanitized_normalization_'+export_file+'.csv' \\n print('EXPORTING TESTING DATA WITH PREDICTIONS :',end=\\\" \\\")\\n \\n create_csv_submission(ids_merged, y_pred_merged, OUTPUT_PATH)\\n print('DONE')\",\n \"def get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\\n # if condition returns False, AssertionError is raised:\\n assert len(df_profit_per_cluster_train) >= 3, \\\"Algorithm, returned less than 3 clusters.\\\"\\n\\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\\n group_size = int(len(df_profit_per_cluster) / 3)\\n\\n buy_clusters_mean_profit = df_profit_per_cluster.iloc[:group_size]['profit'].mean()\\n sell_clusters_mean_profit = df_profit_per_cluster.iloc[-group_size:]['profit'].mean()\\n\\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\\n\\n return buy_clusters_mean_profit, buy_clusters_list, sell_clusters_mean_profit, sell_clusters_list\",\n \"def compute(self):\\n # some possible parameters:\\n # minimum size: min node count for a cluster\\n # (should be small, or some fraction of total graph size)\\n # num splits: desired number of resultant partitions. Partitioning will continue until there are no more \\\"parallelizing splits\\\", or the total partition count is >= num splits\\n minSplits = 3\\n clustermetalist = []\\n (roots, inters) = self.rootSplit(self.cluster)\\n clustermetalist.append(roots)\\n if (len(roots) + len(inters)) < minSplits:\\n # split intersects.\\n inters = map(self.rootSplit, inters)\\n clustermetalist.append(inters[0])\\n clustermetalist.append(inters[1])\\n else:\\n clustermetalist.append(inters)\\n \\n print \\\"nodes\\\", len(self.cluster)\\n print \\\"roots\\\", len(roots)\\n self.ready = clustermetalist\\n # The metalist is a list of lists of clusters.\\n # list[0] is a list of clusters that are ready for execution.\\n # list[1] is a list of clusters that are ready after all clusters\\n # in list[0] are complete. Some or all clusters may be ready\\n # earlier, but each cluster requires some finite progress in one\\n # or more clusters in list[0], otherwise the cluster could be\\n # placed in list[0].\\n # list[i+1] is related to list[i] similarly as list[1] is related\\n # to list[0]\\n open(\\\"pass1.dot\\\",\\\"w\\\").write(self.makeStateGraph(\\\"pass1\\\",roots))\\n pass\",\n \"def partition_data(self):\\n\\n _header_ = self._header_ + 'partition_data(): '\\n\\n if self.verbose:\\n print(_header_ + 'Partitioning data ...')\\n\\n network = self._useful_network()\\n\\n if self.nidx_train:\\n # The only reason that allows .nidx to not be empty would be that a training Data was copied over\\n # hence, the training node indices are retained and need to be excluded\\n print(_header_ + 'Excluding %d training nodes transfered from training dataset ...' % len(self.nidx_train))\\n nidx = set(self.nidx2lidx.keys()) - set(self.nidx_train)\\n self.nidx_exclude += self.nidx_train\\n self.nidx_train = []\\n else:\\n nidx = set(self.nidx2lidx.keys())\\n\\n for l in nidx:\\n if l in network:\\n if self.node_labels[l]:\\n self.nidx_train.append(l)\\n else:\\n self.nidx_exclude.append(l)\\n\\n if self.verbose:\\n print(_header_ + 'Found %d nodes' % len(self.nidx2lidx))\\n print(' %d nodes with labels of interest' % len(self.nidx_train))\\n print(' %d nodes can be used to predict' % len(self.nidx_pred))\\n print(' %d nodes cannot be mapped due to lack of mappable links' % len(self.nidx_exclude))\\n\\n return self\",\n \"def buildAndTrain(trainingData):\\n\\tname = trainingData.drop(['count', 'casual', 'registered'], axis=1).columns\\n\\ttarget = trainingData['count'].values\\n\\tfeature = trainingData.drop(['count', 'casual', 'registered'], axis=1).values\\n\\t# feature scaling\\n\\tfeature_scaled = preprocessing.scale(feature)\\n\\t# 0.5 cross validate\\n\\tcv = cross_validation.ShuffleSplit(len(feature_scaled), n_iter=5, test_size=0.2, random_state=0)\\n\\t# build model, then training and get accuracy of it\\n\\tprint('\\\\n---------岭回归结果--------\\\\n')\\n\\tfor train, test in cv:\\n\\t\\tregLR = linear_model.Ridge().fit(feature_scaled[train], target[train])\\n\\t\\tprint('train score:{0:.3f}, test score:{1:.3f}\\\\n'.format(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregLR.score(feature_scaled[train], target[train]),\\n\\t\\t regLR.score(feature_scaled[test], target[test])))\\n\\tprint('\\\\n---------svm结果--------\\\\n')\\n\\tfor train, test in cv:\\n\\t\\tregSvm = svm.SVR().fit(feature_scaled[train], target[train])\\n\\t\\tprint('train score:{0:.3f}, test score:{1:.3f}\\\\n'.format(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregSvm.score(feature_scaled[train], target[train]),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregSvm.score(feature_scaled[test], target[test])))\\n\\tprint('\\\\n---------随机森林结果--------\\\\n')\\n\\tfor train, test in cv:\\n\\t\\tregRF = RandomForestRegressor(n_estimators=100).fit(feature_scaled[train], target[train])\\n\\t\\tprint('train score:{0:.3f}, test score:{1:.3f}\\\\n'.format(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregRF.score(feature_scaled[train], target[train]),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregRF.score(feature_scaled[test], target[test])))\\n\\t# reduce some low correction feature\\n\\tfeatureReduced = trainingData.drop(['count', 'casual', 'registered', 'holiday', 'workingday', 'day'], axis=1).values\\n\\tfeatureReduced_scaled = preprocessing.scale(featureReduced)\\n\\tprint('\\\\n---------减少特征维度以避免过拟合后的随机森林结果--------\\\\n')\\n\\tfor train, test in cv:\\n\\t\\tregRFImpr = RandomForestRegressor(n_estimators=100).fit(featureReduced_scaled[train], target[train])\\n\\t\\tprint('train score:{0:.3f}, test score:{1:.3f}\\\\n'.format(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregRFImpr.score(featureReduced_scaled[train], target[train]),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregRFImpr.score(featureReduced_scaled[test], target[test])))\\n\\t# use grid search algorithm to improve random forest regression\\n\\tX_train, X_test, y_train, y_test = cross_validation.train_test_split(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfeature_scaled, target, test_size=0.2, random_state=0)\\n\\ttuned_parameters = [{'n_estimators': [10,100,500], 'max_depth': [2,3,4,5,6,7,8,9,10]}]\\n\\tscores = ['r2']\\n\\n\\tfor score in scores:\\n\\t\\tprint(score)\\n\\t\\tclf = GridSearchCV(RandomForestRegressor(), tuned_parameters, cv=5, scoring=score)\\n\\t\\tclf.fit(X_train, y_train)\\n\\t\\tprint(clf.best_estimator_)\\n\\t\\tprint('each parameter combination is ')\\n\\t\\tfor params, mean_score, scores in clf.grid_scores_:\\n\\t\\t\\tprint('{0:.3f} (+/-{1:.03f}) for {2}'.format(mean_score, scores.std()/2, params))\\n\\n\\tprint('--------最优参数下的随机森林结果--------')\\n\\tfor train, test in cv:\\n\\t\\tregRFBest = RandomForestRegressor(n_estimators=100, max_depth=10).fit(feature_scaled[train], target[train])\\n\\t\\tprint('train score:{0:.3f}, test score:{1:.3f}\\\\n'.format(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregRFBest.score(feature_scaled[train], target[train]),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tregRFBest.score(feature_scaled[test], target[test])))\\n\\treturn regRFBest, feature_scaled, target\",\n \"def train_clustermodel_nonsparse(self):\\n \\n segtimes_df, nonsparse_matrix = self.create_nonsparse_matrix(self.data)\\n segtimes_df['index']=segtimes_df.index\\n nonsparse_matrix['index']=nonsparse_matrix.index\\n data_to_scale = pd.merge(segtimes_df, nonsparse_matrix, on=['index'])\\n data_scaled = self.scale_matrix(data_to_scale)\\n data_to_cluster = data_scaled.drop(columns = ['segment_id','level_0','date','time'])\\n \\n print('Clustering using nonsparse segment/time matrix and: ' + self.algorithm)\\n clusterer = self.clustering_algorithms[self.algorithm]\\n self.clustering_model = clusterer.fit(data_to_cluster)\\n \\n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_nonsparse'])\\n clusters_df['segtimekey'] = clusters_df.index\\n segtimes_df['segtimekey'] = segtimes_df.index\\n clusters_df = clusters_df.reset_index(drop=True)\\n self.clusters_df_final = pd.merge(segtimes_df, clusters_df, on=['segtimekey'])\\n self.clusters_df_final['cluster_nonsparse'].value_counts()\\n \\n today = datetime.date.today()\\n filename = self.algorithm + '_nonsparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\\n joblib.dump(self.clustering_model, filename)\\n \\n print('Stored ' + filename)\\n \\n return self.clustering_model, self.clusters_df_final[['segment_id','date','time','cluster_nonsparse']]\",\n \"def kmeans_002():\\n train_mmap_path = 'data/train_cropped_150_scale_15.memmap'\\n test_mmap_path = 'data/test_cropped_150_scale_15.memmap'\\n\\n if not os.path.exists('data/train_cropped_150.memmap'):\\n classes.crop_to_memmap(150, training=True)\\n if not os.path.exists('data/test_cropped_150.memmap'):\\n classes.crop_to_memmap(150, training=False)\\n\\n if not os.path.exists(train_mmap_path):\\n logger.info(\\\"Prepping training images\\\")\\n pre_scale = np.memmap('data/train_cropped_150.memmap', mode='r', shape=(N_TRAIN, 150, 150, 3))\\n trainX = classes.rescale_memmap(15, pre_scale, train_mmap_path)\\n del pre_scale\\n else:\\n trainX = np.memmap(train_mmap_path, mode='r', shape=(N_TRAIN, 15, 15, 3))\\n\\n if not os.path.exists(test_mmap_path):\\n logger.info(\\\"Prepping testing images\\\")\\n pre_scale = np.memmap('data/test_cropped_150.memmap', mode='r', shape=(N_TEST, 150, 150, 3))\\n testX = classes.rescale_memmap(15, pre_scale, test_mmap_path)\\n del pre_scale\\n else:\\n testX = np.memmap(test_mmap_path, mode='r', shape=(N_TEST, 15, 15, 3))\\n\\n\\n n_jobs = multiprocessing.cpu_count()\\n\\n if not os.path.exists('data/mdl_kmeans_002_centroids.npy'):\\n logger.info(\\\"Pretraining KMeans feature encoder\\\")\\n km = models.KMeansFeatures.KMeansFeatures(rf_size=5, num_centroids=1600, num_patches=400000)\\n km.fit(trainX)\\n km.save_to_file('mdl_kmeans_002')\\n else:\\n logger.info(\\\"Loading KMeans feature encoder from file\\\")\\n km = models.KMeansFeatures.KMeansFeatures.load_from_file('mdl_kmeans_002', rf_size=5)\\n\\n # Takes waaaay too long to finish. At least an hour per tree. Clearly too\\n # many dimensions\\n\\n # Instead ran with ridge rf manually\\n mdl = models.RandomForest.KMeansRandomForest(km, trainX, testX, n_jobs=n_jobs, cv_sample=0.5)\\n # mdl.run('cv')\\n mdl.run('train')\\n res = mdl.run('predict')\\n np.save('submissions/sub_kmeans_rf_002.npy', res)\\n output = classes.Submission(res)\\n output.to_file('sub_kmeans_rf_002.csv')\",\n \"def train_clustermodel_sparse(self):\\n\\n print('Clustering using: ' + self.algorithm)\\n uniquesegments_df, sparse_matrix = self.create_sparse_matrix(self.data)\\n\\n clusterer = self.clustering_algorithms[self.algorithm]\\n self.clustering_model = clusterer.fit(sparse_matrix)\\n \\n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_sparse'])\\n clusters_df['segmentskey'] = clusters_df.index\\n clusters_df = clusters_df.reset_index(drop=True)\\n self.clusters_df_final = pd.merge(uniquesegments_df, clusters_df, on=['segmentskey'])\\n self.clusters_df_final['cluster_sparse'].value_counts()\\n \\n today = datetime.date.today()\\n filename = self.algorithm + '_sparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\\n joblib.dump(self.clustering_model, filename)\\n \\n print('Stored ' + filename)\\n \\n return self.clustering_model, self.clusters_df_final[['segment_id','cluster_sparse']]\",\n \"def final_evaluation(self):\\n print(\\\"\\\\n=== Assign final labels ===\\\")\\n\\n # skip if there is only one cluster\\n n_cluster = len(set(self.label[self.label != -1]))\\n if n_cluster < 2:\\n print(f\\\"Skip final evaluation because only {n_cluster} cluster label exist.\\\")\\n # name all cluster as c0\\n self.label = np.zeros(self.label.size, dtype=int)\\n self.cv_predicted_label = [f\\\"c{label}\\\" for label in self.label]\\n self.label_proba = np.ones(self.label.size, dtype=int)\\n self.final_accuracy = 1\\n else:\\n # predict outliers\\n outlier_x = self.X[self.label == -1]\\n outlier_idx = np.where(self.label == -1)[0]\\n if len(outlier_idx) != 0:\\n outlier_predict = pd.Series(self.supervise_model.predict(outlier_x), index=outlier_idx)\\n for cell, pred_label in outlier_predict.items():\\n self.label[cell] = pred_label\\n print(\\n \\\"Assigned all the multi-leiden clustering outliers into clusters \\\"\\n \\\"using the prediction model from final clustering version.\\\"\\n )\\n\\n # final evaluation of non-outliers using cross val predict\\n final_predict_proba = cross_val_predict(\\n self.supervise_model,\\n self.X,\\n y=self.label,\\n method=\\\"predict_proba\\\",\\n n_jobs=self.n_jobs,\\n verbose=0,\\n cv=10,\\n )\\n final_predict = pd.Series(np.argmax(final_predict_proba, axis=1))\\n final_cell_proba = pd.Series(np.max(final_predict_proba, axis=1))\\n final_acc = balanced_accuracy_score(self.label, final_predict.values)\\n print(f\\\"Final ten-fold CV Accuracy on all the cells: {final_acc:.3f}\\\")\\n self.cv_predicted_label = [f\\\"c{label}\\\" for label in final_predict]\\n self.label_proba = final_cell_proba.values\\n self.final_accuracy = final_acc\\n\\n self.label = [f\\\"c{label}\\\" for label in self.label]\\n return\",\n \"def ensemble(final_X_test, final_X_train, Y_train, Yl, index_train):\\n ensemble_models = [DecisionTreeClassifier(),\\n LinearSVC(),\\n GaussianNB(),\\n LogisticRegression(solver='lbfgs', multi_class='auto'),\\n SVC(kernel=\\\"linear\\\", C=0.025)]\\n n_folds = len(ensemble_models)\\n kf = KFold(n_folds, shuffle=True)\\n X_lv2 = np.zeros((final_X_train.shape[0], n_folds))\\n y_lv2 = np.zeros(Y_train.shape)\\n for itrain, itest in kf.split(final_X_train):\\n y_lv2[itest] = Y_train[itest]\\n # Train\\n for n in range(n_folds):\\n ensemble_models[n].fit(final_X_train[itrain, :], Y_train[itrain])\\n X_lv2[itest, n] = ensemble_models[\\n n].predict(final_X_train[itest, :])\\n # Nivel 2\\n Clas_lv2_m2 = SVC(kernel=\\\"linear\\\")\\n Clas_lv2_m2.fit(X_lv2, y_lv2)\\n # Train\\n for n in range(n_folds):\\n ensemble_models[n].fit(final_X_train, Y_train)\\n # Predicción\\n Ypred_test = np.zeros((Y_test.shape[0], n_folds))\\n Ypred_excl = np.zeros((final_X_train.shape[0], n_folds))\\n for n in range(n_folds):\\n Ypred_test[:, n] = ensemble_models[n].predict(final_X_test)\\n Ypred_excl[:, n] = ensemble_models[n].predict(final_X_train)\\n yc2 = Clas_lv2_m2.predict(Ypred_excl)\\n Yl_prediccion = np.zeros(Yl.shape[0])\\n Yl_prediccion[index_train] = yc2\\n plt.imshow(np.reshape(Yl_prediccion, (145, 145), order=\\\"F\\\")),\\n plt.axis('off'),\\n plt.title('Ensemble')\\n plt.show()\",\n \"def train(self):\\n\\n print \\\"==> Running Kmeans on data set of shape: {}\\\".format(self.data.shape)\\n km = KMeans(n_clusters = self.n_clusters)\\n km.fit(self.data.values)\\n self.labels = km.labels_\\n self.inertia = km.inertia_\",\n \"def interpret_clusters(self, split=0.7, all_demos=None, num_clusters=None, \\n max_depth=CLUSTER_DEPTH, data=None, labels=None, verbose=True):\\n all_demos = self.all_data if all_demos is None else all_demos\\n clusters = self.get_ordered_clusters(labels, num_clusters)\\n data = self.demos if data is None else data\\n labels = self.labels if labels is None else labels\\n\\n cluster_formulas = []\\n counter = 0\\n sep = \\\"\\\\n \\\"\\n for c in clusters:\\n counter += 1\\n res = self.sample_from_clusters(num_samples=split,\\n all_data=all_demos,\\n pos_validation=True, \\n neg_validation=True,\\n which_cluster=counter)\\n positive_samples, val_positive_samples = res[0], res[1]\\n negative_samples, val_negative_samples = res[2], res[3]\\n z = 0\\n for d in positive_samples:\\n if d[1] == 0: z += 1\\n\\n cluster_data = {'pos': positive_samples,\\n 'neg': negative_samples}\\n val_cluster_data = {'pos': val_positive_samples,\\n 'neg': val_negative_samples}\\n\\n if verbose: print(sep +\\\"Checking formulas \\\" + \\\\\\n \\\"with max depth {}\\\\n\\\".format(max_depth))\\n\\n cluster_formula, value_formula = wrapper_train(max_depth,\\n cluster_data, \\n val_cluster_data,\\n verbose=verbose,\\n pred_data=[self.pipeline_X,\\n self.pipeline_y])\\n if cluster_formula is not None:\\n print(cluster_formula)\\n\\n cluster_formulas.append((c, cluster_formula, value_formula))\\n self.reset_pipeline()\\n\\n return cluster_formulas\",\n \"def preprocess(self,\\n balance=True,\\n partition=\\\"iid\\\",\\n unbalance_sgm=0,\\n num_shards=None,\\n dir_alpha=None,\\n verbose=True,\\n seed=None,\\n download=True):\\n self.download = download\\n\\n if os.path.exists(self.path) is not True:\\n os.mkdir(self.path)\\n os.mkdir(os.path.join(self.path, \\\"train\\\"))\\n os.mkdir(os.path.join(self.path, \\\"var\\\"))\\n os.mkdir(os.path.join(self.path, \\\"test\\\"))\\n # train dataset partitioning\\n if self.dataname == 'cifar10':\\n trainset = torchvision.datasets.CIFAR10(root=self.root,\\n train=True,\\n download=self.download)\\n partitioner = CIFAR10Partitioner(trainset.targets,\\n self.num_clients,\\n balance=balance,\\n partition=partition,\\n unbalance_sgm=unbalance_sgm,\\n num_shards=num_shards,\\n dir_alpha=dir_alpha,\\n verbose=verbose,\\n seed=seed)\\n elif self.dataname == 'cifar100':\\n trainset = torchvision.datasets.CIFAR100(root=self.root,\\n train=True,\\n download=self.download)\\n partitioner = CIFAR100Partitioner(trainset.targets,\\n self.num_clients,\\n balance=balance,\\n partition=partition,\\n unbalance_sgm=unbalance_sgm,\\n num_shards=num_shards,\\n dir_alpha=dir_alpha,\\n verbose=verbose,\\n seed=seed)\\n else:\\n raise ValueError(\\n f\\\"'dataname'={self.dataname} currently is not supported. Only 'cifar10', and 'cifar100' are supported.\\\"\\n )\\n\\n subsets = {\\n cid: CIFARSubset(trainset,\\n partitioner.client_dict[cid],\\n transform=self.transform,\\n target_transform=self.targt_transform)\\n for cid in range(self.num_clients)\\n }\\n for cid in subsets:\\n torch.save(\\n subsets[cid],\\n os.path.join(self.path, \\\"train\\\", \\\"data{}.pkl\\\".format(cid)))\",\n \"def initSets(self):\\n data_frame = pd.read_csv(self.train_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n if self.test_file is None:\\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n else:\\n data_frame = pd.read_csv(self.test_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n # kfold = KFold(n_splits=3)\\n # self.train_index, self.test_index = kfold.split(features,labels)\",\n \"def get_dataset(FOLD, AR_PERCENTAGE, d_type='yelp', AUTHOR='inf', POST='inf'):\\n global AR_TYPE\\n\\n # dataset = loader.load(d_type, AUTHOR, POST)\\n first_dataset = loader.unimportant_load(AUTHOR, POST * FOLD, AR_TYPE)\\n datasets = first_dataset.fold_to(FOLD)\\n \\n for i in range(0, len(datasets)):\\n dataset = datasets[i]\\n dataset.divide_ar_ir(AR_PERCENTAGE)\\n texts = []\\n\\n # check if we have this dataset already calculated.\\n \\n ir_filename = 'processed/' + get_ir_identifier(d_type, i, AUTHOR, POST)\\n ar_filename = 'processed/' + get_ar_identifier(d_type, i, AUTHOR, POST)\\n\\n ir_features = None\\n if os.path.isfile(ir_filename):\\n print '@get: we have the file', ir_filename, 'and going to load it.'\\n with open(ir_filename, 'rb') as fp:\\n ir_features = pickle.load(fp)\\n \\n ar_features = None\\n if os.path.isfile(ar_filename):\\n print '@get: we have the file', ar_filename, 'and going to load it.'\\n with open(ar_filename, 'rb') as fp:\\n ar_features = pickle.load(fp)\\n\\n\\n if ir_features is not None:\\n for author in dataset.authors:\\n dataset.features[author][-1] = ir_features[author]\\n\\n if ar_features is not None:\\n for author in dataset.authors:\\n dataset.features[author][:-1] = ar_features[author]\\n\\n for author in dataset.authors:\\n if ar_features is None:\\n texts.extend(dataset.get_ars(author))\\n if ir_features is None: \\n texts.append(dataset.get_ir(author))\\n\\n print '@getting_features, #dataset'#, index_fold\\n pool = Pool(processes=NUMBER_OF_CORES)\\n it = pool.imap(get_dataset_features, texts)\\n pool.close()\\n pool.join()\\n\\n print '@getting_features FINISHED, adding features to dictionary'\\n for author in dataset.authors:\\n # for each ar + ir, get back the features\\n if ar_features is None:\\n for i in range(0, dataset.get_ar_size(author)):\\n dataset.put_feature(author, i, it.next())\\n if ir_features is None:\\n dataset.put_feature(author, dataset.get_ar_size(author), it.next())\\n\\n if ir_features is None:\\n print '@get: we DONOT have the file', ir_filename, 'is going to be created and saved.'\\n with open(ir_filename, 'wb') as fp:\\n tmp = dict()\\n for key, value in dataset.features.iteritems():\\n tmp[key] = value[-1]\\n pickle.dump(tmp, fp)\\n\\n if ar_features is None:\\n print '@get: we DONOT have the file', ar_filename, 'is going to be created and saved.'\\n with open(ar_filename, 'wb') as fp:\\n tmp = defaultdict(list)\\n for key, value in dataset.features.iteritems():\\n tmp[key] = value[:-1]\\n pickle.dump(tmp, fp)\\n\\n return datasets\",\n \"def train(self, algorithm):\\n\\n kfold = StratifiedKFold(10, True, 1)\\n f1_score = []\\n precision_score = []\\n recall_score = []\\n for train, test in kfold.split(self.data_training, self.data_target):\\n model = algorithm.fit(self.data_training.iloc[train], self.data_target.iloc[train])\\n scores = self.score_model(model, self.data_training.iloc[test], self.data_target.iloc[test])\\n f1_score.append(scores[0])\\n precision_score.append(scores[1])\\n recall_score.append(scores[2])\\n\\n self.print_results(f1_score, precision_score, recall_score)\",\n \"def generate_data(project_data, config, split_method = RAW) :\\n training_data = []\\n testing_data = []\\n \\n # Flatten the data (collapse the project and session hierarchy into a list of session_data)\\n for v in config.train_project_names:\\n # Data in all sessions of one project\\n project_session_data = random.sample(project_data[v], len(project_data[v]))\\n\\n training_data += project_session_data[int(config.session_training_percentage[0] * len(project_session_data)):\\n int(config.session_training_percentage[1] * len(project_session_data))]\\n\\n if config.double_training:\\n for i in xrange(int(config.session_training_percentage[0] * len(project_session_data)),\\n int(config.session_training_percentage[1] * len(project_session_data))):\\n session_data = project_session_data[i]\\n\\n reversed_session_data = {}\\n reversed_session_data[SESSION_NAME] = session_data[SESSION_NAME] + \\\"_reversed\\\"\\n reversed_session_data[SESSION_EVENTS] = []\\n\\n def reverse_point_data_qsr(point_data):\\n reversed_point_data = point_data[:4]\\n # Hands to objects feature swap\\n reversed_point_data += point_data[8:12] \\n reversed_point_data += point_data[4:8]\\n\\n # Centroid direction and distance difference is symmetric\\n reversed_point_data += point_data[12:14]\\n\\n # Object corners swap\\n reversed_point_data += point_data[16:18] \\n reversed_point_data += point_data[14:16]\\n\\n reversed_point_data += point_data[18:19]\\n reversed_point_data += point_data[20:21] \\n reversed_point_data += point_data[19:20]\\n\\n # For QTCCS\\n reversed_point_data += point_data[22:23]\\n reversed_point_data += point_data[21:22]\\n reversed_point_data += point_data[24:25]\\n reversed_point_data += point_data[23:24]\\n\\n # # For difference of features\\n # fl = 21\\n # reversed_point_data += point_data[fl:fl + 4]\\n # # Hands to objects feature swap\\n # reversed_point_data += point_data[fl + 8:fl + 12] \\n # reversed_point_data += point_data[fl + 4:fl + 8]\\n\\n # # Centroid direction and distance difference is symmetric\\n # reversed_point_data += point_data[fl + 12:fl + 14]\\n\\n # # Object corners swap\\n # reversed_point_data += point_data[fl + 16:fl + 18] \\n # reversed_point_data += point_data[fl + 14:fl + 16]\\n\\n # reversed_point_data += point_data[fl + 18:fl + 19]\\n # reversed_point_data += point_data[fl + 20:fl + 21] \\n # reversed_point_data += point_data[fl + 19:fl + 20]\\n\\n return reversed_point_data\\n\\n def reverse_point_data_sparse_qsr(point_data):\\n reversed_point_data = point_data[:2 * 56]\\n # Hands to objects feature swap\\n reversed_point_data += point_data[4 * 56:6 * 56] \\n reversed_point_data += point_data[2 * 56:4 * 56]\\n\\n # Centroid direction and distance difference is symmetric\\n reversed_point_data += point_data[6 * 56:7 * 56]\\n\\n # Object corners swap\\n reversed_point_data += point_data[8 * 56:9 * 56] \\n reversed_point_data += point_data[7 * 56:8 * 56]\\n\\n anchor = 9 * 56\\n reversed_point_data += point_data[anchor:anchor + 2]\\n reversed_point_data += point_data[anchor + 2 * 2:anchor + 3 * 2] \\n reversed_point_data += point_data[anchor + 2:anchor + 2 * 2]\\n\\n anchor = 9 * 56 + 3 * 2\\n # For QTCCS\\n reversed_point_data += point_data[anchor + 3:anchor + 2 * 3]\\n reversed_point_data += point_data[anchor:anchor + 3]\\n reversed_point_data += point_data[anchor + 3 * 3:anchor + 4 * 3]\\n reversed_point_data += point_data[anchor + 2 * 3:anchor + 3 * 3]\\n\\n return reversed_point_data\\n\\n reversed_session_data[SESSION_DATA] = []\\n for point_data in session_data[SESSION_DATA]:\\n if split_method == RAW:\\n reversed_point_data = point_data[:39]\\n reversed_point_data += point_data[51:63]\\n reversed_point_data += point_data[39:51]\\n elif split_method == PCAS:\\n reversed_point_data = point_data[:6]\\n # Object centroid swap\\n reversed_point_data += point_data[8:10] \\n reversed_point_data += point_data[6:8]\\n # Object corners swap\\n reversed_point_data += point_data[14:18] \\n reversed_point_data += point_data[10:14]\\n elif split_method == QSR or split_method == EVENT:\\n reversed_point_data = reverse_point_data_qsr(point_data)\\n elif split_method == SPARSE_QSR:\\n reversed_point_data = reverse_point_data_sparse_qsr(point_data)\\n\\n reversed_session_data[SESSION_DATA].append(reversed_point_data)\\n\\n for event_str in session_data[SESSION_EVENTS]:\\n reversed_event_str = {}\\n for key in event_str:\\n reversed_event_str[key] = event_str[key]\\n\\n subj, obj, theme, event, prep = event_str['label']\\n def swap_objects(value):\\n if value == 2:\\n return 3\\n if value == 3:\\n return 2\\n return value\\n\\n reversed_event_str['label'] = (swap_objects(subj), swap_objects(obj), swap_objects(theme), event, prep)\\n\\n reversed_session_data[SESSION_EVENTS].append(reversed_event_str)\\n\\n training_data.append(reversed_session_data)\\n\\n\\n testing_data += project_session_data[int(config.session_testing_percentage[0] * len(project_session_data)):\\n int(config.session_testing_percentage[1] * len(project_session_data))]\\n \\n return (training_data, testing_data)\",\n \"def training(df, type=None):\\r\\n df=dataCleaner(df[DISC_FEATURES_COL_TO_USE+CONT_FEATURES_COL_TO_USE+[DISC_TARGET_COL_TO_USE]])\\r\\n print(\\\"Using %d numbers of features\\\"%len(DISC_FEATURES_COL_TO_USE + CONT_FEATURES_COL_TO_USE))\\r\\n df_coded = trainEncode(df)\\r\\n df_coded = scalarNormalizer(df_coded)\\r\\n visualizeHistogram(df_coded)\\r\\n # visualizePCA(df_coded)\\r\\n df_shuffled = df_coded.sample(frac=1, random_state=100).reset_index(drop=True)\\r\\n X, y = df_shuffled[DISC_FEATURES_COL_TO_USE + CONT_FEATURES_COL_TO_USE], df_shuffled[DISC_TARGET_COL_TO_USE]\\r\\n X, y = resampling(X, y)\\r\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = TEST_FR, random_state = 42)\\r\\n\\r\\n print(\\\"Training the classifier!\\\")\\r\\n if type=='LR':\\r\\n print(\\\"Using Logistic Regression Classifier\\\")\\r\\n cls=LogisticRegression(n_jobs=2, class_weight='balanced', tol=1e-4, C=1,random_state=111)\\r\\n elif type=='SVM':\\r\\n print(\\\"Using Support Vector Machine Classifier\\\")\\r\\n cls=SVC(class_weight='balanced', probability=True)\\r\\n elif type=='RF':\\r\\n print(\\\"Using Random Forst Classifier\\\")\\r\\n cls=RandomForestClassifier( n_jobs=3, n_estimators=8192, class_weight='balanced', max_depth=8,\\r\\n min_samples_leaf=1, random_state=24)\\r\\n elif type=='GBC':\\r\\n print(\\\"Using Gradient Boosting Classifier\\\")\\r\\n cls = GradientBoostingClassifier(n_estimators=2048, max_depth=4,\\r\\n subsample=0.8, learning_rate=0.004,\\r\\n random_state=34, min_samples_split=4,\\r\\n max_features=\\r\\n int(0.4*len(DISC_FEATURES_COL_TO_USE+\\r\\n CONT_FEATURES_COL_TO_USE)))\\r\\n else:\\r\\n print(\\\"Using Naive Bayes Classifier\\\")\\r\\n cls = GaussianNB()\\r\\n model = cls.fit(X_train, y_train)\\r\\n print (\\\"Cross-validated scores:\\\", cross_val_score(model, X_train, y_train, cv=10))\\r\\n print (\\\"Score:\\\", model.score(X_test, y_test))\\r\\n predict_test = model.predict(X_test)\\r\\n\\r\\n print('precision_score=%f\\\\nrecall_score=%f'%(precision_score(y_test, predict_test),recall_score(y_test, predict_test)))\\r\\n\\r\\n print(metrics.roc_auc_score(y_test, predict_test))\\r\\n\\r\\n cm=confusion_matrix(y_test, predict_test)\\r\\n print(\\\"Confusion matrix:\\\\n\\\" + str(cm))\\r\\n # showConfusionMatrix(cm)\\r\\n\\r\\n pickle.dump(model, open(MODEL_FILENAME, 'wb'))\\r\\n print(\\\"Model Created!\\\")\",\n \"def main(feats_name, targets_name, model_name, n_boot, seed_start, output_filename, train_test_flag):\\n\\n #load feats and targets\\n input_dict = {}\\n input_dict['feats'] = 'data/%s' % (feats_name)\\n input_dict['targets'] = 'data/%s' % (targets_name)\\n #load the feats and targets\\n df = pd.read_csv(\\\"%s\\\" % (input_dict['feats']))\\n targets = pd.read_csv(\\\"%s\\\" % (input_dict['targets']))\\n #drop columns not used for prediction\\n drop_cols = [\\\"Unnamed: 0\\\",\\\"index\\\"]\\n for dc in drop_cols:\\n if dc in targets.columns:\\n targets = targets.drop(dc,axis=1)\\n if dc in df.columns:\\n df = df.drop(dc,axis=1)\\n #reduce to training or test set only if requested\\n if (train_test_flag == 'train') and ('test_set' in df.columns):\\n targets = targets[df['test_set'] == 0]\\n df = df[df['test_set'] == 0]\\n elif (train_test_flag == 'test') and ('test_set' in df.columns):\\n targets = targets[df['test_set'] == 1]\\n df = df[df['test_set'] == 1]\\n df = df.drop('test_set', axis = 1)\\n \\n #broadcast the feats and targets\\n df_b = sc.broadcast(df)\\n targets_b = sc.broadcast(targets)\\n\\n #Set up the classifier. 3fold CV for selection of regularization term.\\n if model_name == 'linear':\\n model = LinearRegression(fit_intercept=True,\\n normalize=False,\\n copy_X=True,\\n n_jobs=1) \\n elif model_name == 'lasso':\\n model = LassoCV(alphas = [.05,.1,.2],\\n normalize = False,\\n fit_intercept = True,\\n verbose = False,\\n copy_X = False,\\n n_jobs = 3)\\n elif model_name == 'ridge':\\n model = RidgeCV(alphas = [.00001,.0001,.001,.01,.1,1,10,100,1000,10000],\\n normalize = False,\\n fit_intercept = True,\\n verbose = 1,\\n cv = 3)\\n else:\\n raise ValueError('model_name not recognized.')\\n \\n #Create an RDD that specifies prng seed to use\\n samp_list = [(n,) for n in np.arange(seed_start, seed_start+n_boot)]\\n samp_rdd = sc.parallelize(samp_list,n_boot) #create RDD with one partition for each row (second arg is number of partitions)\\n #Create a function that takes a tuple as input and returns \\n def func(tup):\\n \\\"\\\"\\\"\\n Takes as input a tuple containing an integer. The integer specifies the random seed that will be used to \\n randomly sample, with replacement, observations from the feats set provided. The model is fitted to the \\n sampled feats. Resulting best fit parameters, along with some other summary statistics and information are\\n provided as input in a JSON string that will be written to the output file when all jobs are completed.\\n \\n Parameters\\n ----------\\n tup, rdd\\n - series of tuples with different integer values defining the RNG seed to be used to sample observations\\n \\n Returns\\n ----------\\n tup[0], int\\n - the seed that was used\\n json.dumps(results_dict), str\\n - dict in json format with the following keys:\\n - alpha, the regularization term providing the best fit according to 3 fold cross-validation\\n - random_state, the initial state used for fitting\\n - training_feats, the name of the training_feats csv file\\n - training_targets, the name of the target variable csv file\\n - cv, the type of cross-validation used\\n - sklearn_version, which version of sklearn was used\\n - mse_min, the mean squared error for the test set on each fold\\n - r2, the r-squared value (% var explained)\\n - coef, parameter vector\\n - intercept, intercept parameter\\n - column_names, feature name corresponding to each parameter in the parameter vector\\n \\\"\\\"\\\"\\n #take a random sample with replacement\\n np.random.seed(seed=tup[0]) #set the seed\\n n_obs = np.shape(df_b.value)[0] #number of observations determines sample size\\n samp = list(np.random.randint(0,high=n_obs,size=n_obs)) #draw the random sample with replacement\\n #fit the model\\n tic = time.time()\\n results = model.fit(df_b.value.iloc[samp,:],np.ravel(targets_b.value.iloc[samp]))\\n toc = tic - time.time()\\n #save the results in a dict\\n results_dict = {}\\n results_dict['alpha'] = results.alpha_\\n results_dict['random_state'] = results.random_state\\n results_dict['training_feats'] = input_dict['feats']\\n results_dict['training_targets'] = input_dict['targets']\\n results_dict['cv'] = results.cv\\n results_dict['sklearn_version'] = sklearn.__version__\\n results_dict['mse_min'] = results.mse_path_.min()\\n results_dict['r2'] = results.score(df_b.value.iloc[samp,:],np.ravel(targets_b.value.iloc[samp]))\\n results_dict['coef'] = list(results.coef_)\\n results_dict['intercept'] = results.intercept_\\n results_dict['column_names'] = [i for i in df_b.value.columns]\\n results_dict['fit_time'] = toc\\n #convert results dict to json and save in tuple\\n return(json.dumps(results_dict))\\n\\n #fit model in parallel\\n results = samp_rdd.map(lambda p: func(p))\\n #save to text file\\n results.saveAsTextFile(output_filename)\\n #stop the SparkContext.\\n if not local_mode:\\n sc.stop()\",\n \"def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,\\n df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,\\n learning_rate=0.01):\\n\\n som = MiniSom(som_width, som_height, df_train.shape[1], sigma=sigma, learning_rate=learning_rate,\\n random_seed=0)\\n som.train(df_train, n_iter)\\n\\n # converting numpy arrays to dataframes\\n df_train = pd.DataFrame(df_train, columns=df_train_columns)\\n df_test = pd.DataFrame(df_test, columns=df_train_columns)\\n\\n # creating column with cluster basing on model prediction\\n df_train['cluster'] = df_train.apply(lambda x: som_predict(x, som), axis=1)\\n df_test['cluster'] = df_test.apply(lambda x: som_predict(x, som), axis=1)\\n\\n # joining train and test dataframes with previously dropped columns, which will be useful in the further part of\\n # the script\\n final_df_train = df_train.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[:, :len(df_train)],\\n lsuffix='_org')\\n final_df_test = df_test.join(df[['Date', 'Price', 'close_plus_20_days', 'profit']].iloc[len(df_train):],\\n lsuffix='_org')\\n\\n return final_df_train, final_df_test\",\n \"def train():\\n\\t# 1、make dataloader\\n\\ttrain_loader, val_loader, num_query, num_class = make_data_loader(cfg)\\n\\t#print(\\\"num_query:{},num_class:{}\\\".format(num_query,num_class))\\n\\n\\t# 2、make model\\n\\tmodel = build_model(cfg, num_class)\\n\\n\\t# model.eval()\\n\\t# x = model(img_tensor)\\n\\t# print(x.shape)\\n\\t# 3、 make optimizer\\n\\toptimizer = make_optimizer(cfg, model)\\n\\n\\t# 4、 make lr_scheduler\\n\\tscheduler = make_lr_scheduler(cfg, optimizer)\\n\\n\\t# 5、 make loss_func\\n\\tif cfg.MODEL.PCB_NECK:\\n\\t\\t# make loss specificially for pcb \\n\\t\\tloss_func = get_softmax_triplet_loss_fn(cfg, num_class)\\n\\telse:\\n\\t\\tloss_func = make_loss(cfg, num_class)\\n\\n\\t# get paramters\\n\\tlog_period = cfg.OUTPUT.LOG_PERIOD \\n\\tckpt_period =cfg.OUTPUT.CHECKPOINT_PERIOD\\n\\teval_period = cfg.OUTPUT.EVAL_PERIOD\\n\\toutput_dir = cfg.OUTPUT.ROOT_DIR\\n\\tdevice = cfg.MODEL.DEVICE\\n\\tepochs = cfg.SOLVER.MAX_EPOCHS\\n\\tuse_gpu = device == \\\"cuda\\\"\\n\\tuse_neck = cfg.MODEL.NECK or cfg.MODEL.LEARN_REGION \\n\\t# how many batch for each log\\n\\tbatch_size = cfg.SOLVER.IMGS_PER_BATCH\\n\\tbatch_num = len(train_loader) \\n\\t\\n\\tlog_iters = batch_num // log_period\\n\\tpretrained = cfg.MODEL.PRETRAIN_PATH != ''\\n\\tparallel = cfg.MODEL.PARALLEL \\t\\n\\tgrad_clip = cfg.DARTS.GRAD_CLIP \\n\\n\\tfeat_norm = cfg.TEST.FEAT_NORM \\n\\tckpt_save_path = cfg.OUTPUT.ROOT_DIR + cfg.OUTPUT.CKPT_DIR\\n\\tif not os.path.exists(ckpt_save_path):\\n\\t\\tos.makedirs(ckpt_save_path)\\n\\n\\n\\t# create *_result.xlsx\\n\\t# save the result for analyze\\n\\tname = (cfg.OUTPUT.LOG_NAME).split(\\\".\\\")[0] + \\\".xlsx\\\"\\n\\tresult_path = cfg.OUTPUT.ROOT_DIR + name\\n\\n\\twb = xl.Workbook()\\n\\tsheet = wb.worksheets[0]\\n\\ttitles = ['size/M','speed/ms','final_planes', 'acc', 'mAP', 'r1', 'r5', 'r10', 'loss',\\n\\t\\t\\t 'acc', 'mAP', 'r1', 'r5', 'r10', 'loss','acc', 'mAP', 'r1', 'r5', 'r10', 'loss']\\n\\tsheet.append(titles)\\n\\tcheck_epochs = [40, 80, 120, 160, 200, 240, 280, 320, 360, epochs]\\n\\tvalues = []\\n\\n\\tlogger = logging.getLogger('MobileNetReID.train')\\n\\t\\n\\t# count parameter\\n\\tsize = count_parameters(model)\\n\\tlogger.info(\\\"the param number of the model is {:.2f} M\\\".format(size))\\n\\t\\n\\tvalues.append(format(size, '.2f'))\\n\\tvalues.append(model.final_planes)\\n\\n\\tlogger.info(\\\"Start training\\\")\\n\\t\\n\\t#count = 183, x, y = batch -> 11712 for train\\n\\tif pretrained:\\n\\t\\tstart_epoch = model.start_epoch\\n\\n\\tif parallel:\\n\\t\\tmodel = nn.DataParallel(model)\\n\\n\\tif use_gpu:\\n\\t\\t# model = nn.DataParallel(model)\\n\\t\\tmodel.to(device)\\n\\t\\n\\t# save the best model\\n\\tbest_mAP, best_r1 = 0., 0.\\n\\tis_best = False\\n\\t# batch : img, pid, camid, img_path\\n\\tavg_loss, avg_acc = RunningAverageMeter(), RunningAverageMeter()\\n\\tavg_time, global_avg_time = AverageMeter(), AverageMeter()\\n\\tglobal_avg_time.reset()\\n\\tfor epoch in range(epochs):\\n\\t\\tscheduler.step()\\n\\n\\t\\tif pretrained and epoch < start_epoch - 1:\\n\\t\\t\\tcontinue\\n\\t\\n\\t\\tmodel.train()\\n\\t\\t# sum_loss, sum_acc = 0., 0.\\n\\t\\tavg_loss.reset()\\n\\t\\tavg_acc.reset()\\n\\t\\tavg_time.reset()\\n\\t\\tfor i, batch in enumerate(train_loader):\\n\\n\\t\\t\\tt0 = time.time()\\n\\t\\t\\timgs,labels = batch\\n\\n\\t\\t\\tif use_gpu:\\n\\t\\t\\t\\timgs = imgs.to(device)\\n\\t\\t\\t\\tlabels = labels.to(device)\\n\\n\\t\\t\\tres = model(imgs)\\n\\t\\t\\t# score, feat = model(imgs)\\n\\t\\t\\t# loss = loss_func(score, feat, labels)\\n\\t\\t\\tloss, acc = compute_loss_acc(use_neck, res, labels, loss_func)\\n\\t\\t\\t\\n\\t\\t\\tloss.backward()\\n\\t\\t\\tif grad_clip != 0:\\n\\t\\t\\t\\tnn.utils.clip_grad_norm(model.parameters(), grad_clip)\\n\\n\\t\\t\\toptimizer.step()\\n\\n\\t\\t\\toptimizer.zero_grad()\\n\\n\\t\\t\\t# acc = (score.max(1)[1] == labels).float().mean()\\n\\n\\t\\t\\t# sum_loss += loss\\n\\t\\t\\t# sum_acc += acc \\n\\t\\t\\tt1 = time.time()\\n\\t\\t\\tavg_time.update((t1 - t0) / batch_size)\\n\\t\\t\\tavg_loss.update(loss)\\n\\t\\t\\tavg_acc.update(acc)\\n\\n\\t\\t\\t#log the info \\n\\t\\t\\tif (i+1) % log_iters == 0:\\n\\n\\t\\t\\t\\tlogger.info(\\\"epoch {}: {}/{} with loss is {:.5f} and acc is {:.3f}\\\".format(\\n\\t\\t\\t\\t\\t epoch+1, i+1, batch_num, avg_loss.avg, avg_acc.avg))\\n\\n\\t\\tlr = optimizer.state_dict()['param_groups'][0]['lr']\\n\\t\\tlogger.info(\\\"end epochs {}/{} with lr: {:.5f} and avg_time is {:.3f} ms\\\".format(epoch+1, epochs, lr, avg_time.avg * 1000))\\n\\t\\tglobal_avg_time.update(avg_time.avg)\\n\\t\\t# change the lr \\n\\n\\t\\t# eval the model \\n\\t\\tif (epoch+1) % eval_period == 0 or (epoch + 1) == epochs :\\n\\t\\t\\t\\n\\t\\t\\tmodel.eval()\\n\\t\\t\\tmetrics = R1_mAP(num_query, use_gpu = use_gpu, feat_norm = feat_norm)\\n\\n\\t\\t\\twith torch.no_grad():\\n\\n\\t\\t\\t\\tfor vi, batch in enumerate(val_loader):\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\timgs, labels, camids = batch\\n\\n\\t\\t\\t\\t\\tif use_gpu:\\n\\t\\t\\t\\t\\t\\timgs = imgs.to(device)\\n\\n\\t\\t\\t\\t\\tfeats = model(imgs)\\n\\t\\t\\t\\t\\tmetrics.update((feats,labels, camids))\\n\\n\\t\\t\\t\\t#compute cmc and mAP\\n\\t\\t\\t\\tcmc, mAP = metrics.compute()\\n\\t\\t\\t\\tlogger.info(\\\"validation results at epoch:{}\\\".format(epoch + 1))\\n\\t\\t\\t\\tlogger.info(\\\"mAP:{:.2%}\\\".format(mAP))\\n\\t\\t\\t\\tfor r in [1,5,10]:\\n\\t\\t\\t\\t\\tlogger.info(\\\"CMC curve, Rank-{:<3}:{:.2%}\\\".format(r,cmc[r-1]))\\t\\n\\n\\t\\t\\t\\t# determine whether cur model is the best \\n\\t\\t\\t\\tif mAP > best_mAP:\\n\\t\\t\\t\\t\\tis_best = True\\n\\t\\t\\t\\t\\tbest_mAP = mAP\\n\\t\\t\\t\\t\\tlogger.info(\\\"Get a new best mAP\\\")\\n\\t\\t\\t\\tif cmc[0] > best_r1:\\n\\t\\t\\t\\t\\tis_best = True\\n\\t\\t\\t\\t\\tbest_r1 = cmc[0]\\n\\t\\t\\t\\t\\tlogger.info(\\\"Get a new best r1\\\")\\n\\n\\t\\t\\t\\t# add the result to sheet\\n\\t\\t\\t\\tif (epoch + 1) in check_epochs:\\n\\t\\t\\t\\t\\tval = [avg_acc.avg, mAP, cmc[0], cmc[4], cmc[9]]\\n\\t\\t\\t\\t\\tchange = [format(v * 100, '.2f') for v in val]\\n\\t\\t\\t\\t\\tchange.append(format(avg_loss.avg, '.3f'))\\n\\t\\t\\t\\t\\tvalues.extend(change)\\n\\n\\n\\t\\t# we hope that eval_period == ckpt_period or eval_period == k* ckpt_period where k is int\\t\\t\\t\\n\\t\\t# whether to save the model\\n\\t\\tif (epoch+1) % ckpt_period == 0 or is_best:\\n\\n\\t\\t\\tif parallel:\\n\\t\\t\\t\\ttorch.save(model.module.state_dict(), ckpt_save_path + \\\"checkpoint_{}.pth\\\".format(epoch + 1 ))\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttorch.save(model.state_dict(), ckpt_save_path + \\\"checkpoint_{}.pth\\\".format(epoch + 1 ))\\n\\n\\t\\t\\tlogger.info(\\\"checkpoint {} saved !\\\".format(epoch + 1))\\n\\n\\t\\t\\tif is_best:\\n\\t\\t\\t\\tif parallel:\\n\\t\\t\\t\\t\\ttorch.save(model.module.state_dict(), ckpt_save_path + \\\"best_ckpt.pth\\\")\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttorch.save(model.state_dict(), ckpt_save_path + \\\"best_ckpt.pth\\\")\\n\\t\\t\\t\\tlogger.info(\\\"best checkpoint was saved\\\")\\n\\t\\t\\t\\tis_best = False\\n\\t\\n\\tvalues.insert(1, format(global_avg_time.avg * 1000, '.2f'))\\n\\tsheet.append(values)\\n\\twb.save(result_path)\\n\\n\\tlogger.info(\\\"training is end, time for per imgs is {} ms\\\".format(global_avg_time.avg *1000))\",\n \"def train(self):\\n\\t\\traise NotImplementedError\",\n \"def predict_progression(final):\\n #Import the dataset for prediction\\n dataset = read_excel('SampleProgressionData.xlsx', sheet_name=0)\\n \\\"\\\"\\\"\\n Split the data into a training and a testing set\\n \\\"\\\"\\\"\\n train_features = dataset.iloc[0:197,:-1]\\n train_targets = dataset.iloc[0:197,-1]\\n i=0\\n df_cluster_data_col = {}\\n Dict_progression = {} \\n Dict_rec_progression = {} \\n while i < 5:\\n # Number of employees in this cluster\\n array_n = final[final.cluster == i][\\\"EmployeeID\\\"].unique()\\n len(array_n)\\n print(\\\"cluster \\\", i )\\n print(\\\"Employees: \\\", array_n)\\n # List of employees\\n final[final.cluster == i]\\n cluster_data_n=final[final.cluster == i]\\n cluster_data_n=cluster_data_n[0:len(array_n)]\\n # cluster_data_n\\n df_cluster_data_n=pd.DataFrame(cluster_data_n, columns = ['EmployeeID', 'MajorityBand','CurrentBand','NumberYears','Progression']) \\n df_cluster_data_n['MajorityBand']=df_cluster_data_n['CurrentBand'].max()\\n df_cluster_data_n.fillna(0, inplace=True)\\n dataset_cluster_n = pd.DataFrame(df_cluster_data_n,columns = ['EmployeeID','MajorityBand', 'CurrentBand','NumberYears','Progression'])\\n test_features = dataset_cluster_n.iloc[:,1:4]\\n test_targets = dataset_cluster_n.iloc[:,-1]\\n \\\"\\\"\\\"\\n Train the model\\n \\\"\\\"\\\"\\n tree = DecisionTreeClassifier(criterion = 'entropy').fit(train_features,train_targets)\\n \\\"\\\"\\\"\\n Predict the classes of new, unseen data\\n \\\"\\\"\\\"\\n prediction = tree.predict(test_features)\\n \\\"\\\"\\\"\\n Check the accuracy\\n \\\"\\\"\\\"\\n print(\\\"The prediction accuracy is: \\\",tree.score(test_features,test_targets)*100,\\\"%\\\")\\n df_cluster_data_n['Progression']=list(prediction)\\n strmax = df_cluster_data_n['CurrentBand'].max()\\n print(\\\"strmax \\\", strmax)\\n print(\\\"prediction \\\", prediction)\\n print('---------------------------------------------------------------------')\\n print(\\\"PREDICTION FOR BAND \\\", strmax)\\n print('---------------------------------------------------------------------')\\n df_cluster_data_n = df_cluster_data_n.loc[df_cluster_data_n[\\\"Progression\\\"]==1]\\n df_cluster_data_empid=pd.DataFrame(df_cluster_data_n, columns = ['EmployeeID'])\\n df_cluster_data_col[i]=df_cluster_data_empid\\n Dict_progression[strmax]=list(df_cluster_data_empid['EmployeeID'].unique())\\n print(\\\"Dict_progression \\\", Dict_progression)\\n i=i+1\\n # Show the next promotion band and not the cluster highest band for recommendation to employees\\n list_promotion = Dict_progression[strmax]\\n for emp_band_promo in list_promotion:\\n array = df_cluster_data_n.loc[df_cluster_data_n['EmployeeID'] == emp_band_promo]['CurrentBand'].unique()\\n promotion_band = array[0]+1 \\n list_emp_band = []\\n if promotion_band in Dict_rec_progression:\\n list_emp_band = Dict_rec_progression[promotion_band]\\n list_emp_band.append(emp_band_promo) \\n list_emp_band.sort()\\n Dict_rec_progression[promotion_band] = list_emp_band\\n print(\\\"Dict_progression\\\", Dict_progression)\\n print(\\\"Dict_rec_progression\\\", Dict_rec_progression) \\n return Dict_rec_progression\",\n \"def kmeans_004():\\n crops = [200] # Should probably also add 250\\n scales = [30, 50] # Scaling is probably the most important part here\\n\\n scores = []\\n for s in scales:\\n crop = 200\\n n_centroids = 1600\\n n_patches = 400000\\n # rf_size = int(round(s * .2))\\n rf_size = 10\\n logger.info(\\\"Training with crop {}, scale {}, patch size {}, patches {}, centroids {}\\\".format(crop, s, rf_size, n_patches, n_centroids))\\n\\n train_x_crop_scale = CropScaleImageTransformer(training=True,\\n result_path='data/data_train_crop_{}_scale_{}.npy'.format(crop, s),\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n\\n # spherical generator\\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\\n rf_size=rf_size,\\n result_path='data/mdl_kmeans_004_scale_{}_rf_{}'.format(s, rf_size),\\n n_iterations=20,\\n n_jobs=-1,)\\n\\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\\n patch_size=rf_size,\\n n_jobs=-1)\\n images = train_x_crop_scale.transform()\\n logger.info(\\\"Images ndarray shape: {}\\\".format(images.shape))\\n patches = patch_extractor.transform(images)\\n logger.info(\\\"Patches ndarray shape: {}\\\".format(patches.shape))\\n\\n kmeans_generator.fit(patches)\\n\\n del patches\\n gc.collect()\\n\\n train_x = kmeans_generator.transform(images, save_to_file='data/data_kmeans_features_004_scale_{}_rf_{}.npy'.format(s, rf_size), memmap=True)\\n train_y = classes.train_solutions.data\\n # Unload some objects\\n del images\\n gc.collect()\\n logger.info(\\\"Train X ndarray shape: {}\\\".format(train_x.shape))\\n\\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 250}, n_jobs=-1)\\n wrapper.cross_validation(train_x, train_y, n_folds=2, parallel_estimator=True)\\n scores.append((s, wrapper.cv_scores))\\n del wrapper\\n gc.collect()\",\n \"def trainSOM_getK(model):\\n model.detect_serialized_datasets()\\n model.detect_prepared_datasets()\\n model.train_SOM()\\n model.detect_som_products()\\n model.generate_k()\\n cluster_num = model.get_k()\\n return cluster_num\",\n \"def classify():\\n yes_dataset = df[df[\\\"_class\\\"] == 1] # 470588\\n no_dataset = df[df[\\\"_class\\\"] == 0] # 1971\\n\\n parameter_analysis = list()\\n for criterion in np.arange(0.05, 0.91, 0.05):\\n print(\\\"doing experiment at criterion = %s ...\\\" % criterion)\\n rate_list = list()\\n for i in range(10):\\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\\n yes_index = yes_dataset.index.tolist()\\n random.shuffle(yes_index)\\n no_index = no_dataset.index.tolist()\\n random.shuffle(no_index)\\n \\n # concatenate 90%yes + 90%no, 10%yes + 10%no\\n train = pd.concat([\\n yes_dataset.loc[yes_index[:1774], :],\\n no_dataset.loc[no_index[:423530], :]\\n ])\\n test = pd.concat([\\n yes_dataset.loc[yes_index[1774:], :],\\n no_dataset.loc[no_index[423530:], :]\\n ]) \\n \\n # split data and label\\n train_data, train_label = (train[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n train[\\\"_class\\\"])\\n test_data, test_label = (test[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n test[\\\"_class\\\"])\\n \\n # apply classifier\\n clf = GaussianNB()\\n clf.fit(train_data, train_label)\\n probability = clf.predict_proba(test_data).T[1]\\n \\n result = pd.DataFrame()\\n result[\\\"_class\\\"] = test_label\\n result[\\\"_predict\\\"] = probability >= criterion\\n \\n result_yes = result[result[\\\"_class\\\"] == 1]\\n yes_yes_rate = sum(result_yes[\\\"_class\\\"] == result_yes[\\\"_predict\\\"])/len(result_yes[\\\"_predict\\\"])\\n \\n result_no = result[result[\\\"_class\\\"] == 0]\\n no_no_rate = sum(result_no[\\\"_class\\\"] == result_no[\\\"_predict\\\"])/len(result_no[\\\"_predict\\\"])\\n \\n rate_list.append((yes_yes_rate, no_no_rate))\\n\\n rate_list = pd.DataFrame(rate_list)\\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\\n \\n # save data to excel spreadsheet\\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\\\"criterion\\\", \\\"yes_yes_rate\\\", \\\"no_no_rate\\\"])\\n writer = pd.ExcelWriter(\\\"parameter_analysis.xlsx\\\")\\n parameter_analysis.to_excel(writer, \\\"parameter_analysis\\\", index=False)\\n writer.save()\",\n \"def final_clf_training(Xs, ys, X_holdout, y_holdout, scorer_type, sanity_check=False, oversampling=False):\\n\\n # stack all the feature vectors of all the folds\\n X_train = np.vstack(tuple([Xs[i] for i in range(10)]))\\n y_train = np.hstack(tuple([ys[i] for i in range(10)]))\\n\\n # stack the holdout feature vectors on the feature vectors of all folds\\n X_all = np.concatenate([X_train, X_holdout], axis=0)\\n y_all = np.concatenate([y_train, y_holdout], axis=0)\\n\\n # define and create parent folder to save all trained classifiers into\\n parent_folder = \\\"%s/data/fnc-1/mlp_models/\\\" % (path.dirname(path.dirname(path.abspath(__file__))))\\n\\n # create the new save folder for the specific classifer\\n scorer_folder_name = scorer_type+\\\"_final\\\"\\n save_folder = get_save_folder(parent_folder, scorer_folder_name+\\\"_new\\\")\\n\\n # get classifier and only pass a save folder if the classifier should be saved\\n clf = esitmator_definitions.get_estimator(scorer_type, save_folder=save_folder)\\n\\n #perform oversampling if selected\\n if oversampling == True:\\n if 'f_ext' in scorer_type:\\n print(\\\"Oversampling not defined for LSTM\\\")\\n exit()\\n\\n import datetime\\n start = datetime.datetime.now().time()\\n print(\\\"Started oversampling/undersampling at: \\\" + str(start))\\n # uncomment following lines for the different sampling methods #####\\n # Oversampling\\n from imblearn.over_sampling import SMOTE, ADASYN, RandomOverSampler\\n print(\\\"Oversampling data\\\")\\n #kind = ['regular', 'borderline1', 'borderline2', 'svm']\\n #sm = SMOTE(kind='regular',)\\n #X_res, y_res = sm.fit_sample(X_all, y_all)\\n\\n #ros = RandomOverSampler()\\n #X_res, y_res = ros.fit_sample(X_all, y_all)\\n\\n #ada = ADASYN()\\n #X_res, y_res = ada.fit_sample(X_all, y_all)\\n\\n ######################################################\\n # Undersampling\\n from imblearn.under_sampling import TomekLinks, EditedNearestNeighbours, CondensedNearestNeighbour, \\\\\\n NeighbourhoodCleaningRule, InstanceHardnessThreshold\\n # remove Tomek links\\n tl = TomekLinks(return_indices=True)\\n X_res, y_res, idx_resampled = tl.fit_sample(X_all, y_all)\\n\\n #enn = EditedNearestNeighbours(random_state=0)\\n #X_res, y_res = enn.fit_sample(X_all, y_all)\\n\\n #cnn = CondensedNearestNeighbour(random_state=0)\\n #X_res, y_res = cnn.fit_sample(X_all, y_all)\\n\\n #ncr = NeighbourhoodCleaningRule(random_state=0)\\n #X_res, y_res = ncr.fit_sample(X_all, y_all)\\n\\n #iht = InstanceHardnessThreshold(random_state=0, estimator=clf)\\n #X_res, y_res = iht.fit_sample(X_all, y_all)\\n\\n\\n ##################\\n # Combination of Undersampling and oversampling\\n\\n from imblearn.combine import SMOTEENN, SMOTETomek\\n #smote_enn = SMOTEENN(random_state=0)\\n #X_res, y_res = smote_enn.fit_sample(X_all, y_all)\\n\\n #smote_tomek = SMOTETomek(random_state=0)\\n #X_res, y_res = smote_tomek.fit_sample(X_all, y_all)\\n\\n end = datetime.datetime.now().time()\\n print(\\\"Ended oversampling/undersampling at: \\\" + str(end))\\n\\n clf.fit(X_res, y_res)\\n else: # if oversampling is false\\n import datetime\\n # fit the final classifier\\n loss_monitor_file_dir = \\\"%s/data/fnc-1/model_results/loss_results/\\\" % (\\n path.dirname(path.dirname(path.abspath(__file__))))\\n loss_filename = loss_monitor_file_dir + str(datetime.datetime.now().strftime(\\\"%Y-%m-%d_%H-%M\\\")) + \\\".txt\\\"\\n # fit the classifier\\n if 'f_ext' in scorer_type:\\n append_to_loss_monitor_file(\\\"\\\\n\\\\nFOLD holdout and classifier: \\\" + scorer_type + \\\"\\\\n\\\", loss_filename)\\n append_to_loss_monitor_file(str(datetime.datetime.now()).split('.')[0], loss_filename)\\n clf.fit(X_train, y_train, X_holdout, np.array(y_holdout), 'holdout', loss_filename)\\n else:\\n clf.fit(X_all, y_all)\\n\\n # save the model\\n filename = scorer_folder_name + \\\".sav\\\"\\n save_model(clf, save_folder, filename) # save model with filename to specific folder\\n\\n # predict on the data the classifier was trained on => should give near perfect score\\n if sanity_check == True:\\n # get predicted and actual labels\\n y_predicted = clf.predict(X_all)\\n predicted = [LABELS[int(a)] for a in y_predicted]\\n actual = [LABELS[int(a)] for a in y_all]\\n\\n # calc FNC score\\n fold_score, _ = score_submission(actual, predicted)\\n max_fold_score, _ = score_submission(actual, actual)\\n score = fold_score / max_fold_score\\n\\n # calc accuracy, f1 macro\\n accuracy_stance = score_calculation.get_accuracy(y_predicted, y_all, stance=True)\\n accuracy_related = score_calculation.get_accuracy(y_predicted, y_all, stance=False)\\n f1_stance = score_calculation.get_f1score(y_predicted, y_all, stance=True)\\n f1_related = score_calculation.get_f1score(y_predicted, y_all, stance=False)\\n\\n # printout results\\n printout = printout_manager.get_holdout_printout(save_folder, accuracy_related, accuracy_stance, f1_related,\\n f1_stance, score)\\n print(\\\"SANITY CHECK (predict on train data):\\\")\\n print(printout)\\n return clf\",\n \"def separate(self):\\n print(\\\"start dataset separating\\\")\\n sum = 0\\n for i in tqdm(range(len(self.itemlen))):\\n il = self.itemlen[i]\\n if il < 3:\\n sum += il\\n continue\\n rarr = list(range(sum, sum+il))\\n random.shuffle(rarr)\\n self.train.append({\\n 'input': self.input[rarr[0]],\\n 'label': self.label[i]\\n })\\n self.val.append({\\n 'input': self.input[rarr[1]],\\n 'label': self.label[i]\\n })\\n for j in range(2, len(rarr)):\\n self.test.append({\\n 'input': self.input[rarr[j]],\\n 'label': self.label[i]\\n })\\n sum += il\",\n \"def train_test_split(self):\\n random.seed(self.args.seed)\\n nodes = [node for node in range(self.ncount)]\\n random.shuffle(nodes)\\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.args.training_size+self.args.validation_size])\\n self.test_nodes = torch.LongTensor(nodes[self.args.training_size+self.args.validation_size:])\",\n \"def train_batches(feature_matrix,y):\\r\\n X_org,y_org = shuffle(feature_matrix, y, random_state=13)\\r\\n \\r\\n # Splitting 20% of dataset to be test later\\r\\n X_train_org, X_test_org, y_train_org, y_test_org = train_test_split(X_org, y_org,test_size=0.20)\\r\\n X = X_train_org\\r\\n y = y_train_org\\r\\n \\r\\n \\r\\n for name, clf in classifiers:\\r\\n inc = Incremental(clf, scoring='accuracy')\\r\\n batch_size=5000\\r\\n counter=0\\r\\n train_acc = [] \\r\\n test_acc = []\\r\\n \\r\\n # Initializing Standard Scaler and IPCA for each classifier\\r\\n \\r\\n SS = StandardScaler()\\r\\n # IPCA = IncrementalPCA(n_components = 500)\\r\\n n=1\\r\\n print(\\\"Training \\\", name,\\\".......\\\\n\\\")\\r\\n for j in range(80):\\r\\n if counter >= len(X):\\r\\n break\\r\\n \\r\\n # Splitting each batch into training and validation datset\\r\\n X_train, X_test, y_train, y_test = train_test_split(X[counter:counter+batch_size], y[counter:counter+batch_size],test_size=0.25)\\r\\n print(\\\"Iteration:\\\",n)\\r\\n \\r\\n classes = da.unique(y_train).compute()\\r\\n \\r\\n # Feature Scaling\\r\\n SS.partial_fit(np.asarray(X_train))\\r\\n SS.transform(np.asarray(X_test))\\r\\n \\r\\n # Feature Decomposition\\r\\n # IPCA.partial_fit(X_train)\\r\\n # IPCA.transform(X_test)\\r\\n \\r\\n # Partial fitting - Stochastic Gradient Descent\\r\\n inc.partial_fit(X_train, y_train, classes=classes)\\r\\n print('Training Score:', inc.score(X_train, y_train))\\r\\n print('Validation Score:', inc.score(X_test, y_test))\\r\\n print(\\\"\\\\n\\\")\\r\\n \\r\\n # Concatenating batch scores\\r\\n train_acc.append(inc.score(X_train, y_train)) \\r\\n test_acc.append(inc.score(X_test, y_test)) \\r\\n \\r\\n if(len(X)-counter < batch_size):\\r\\n batch_size = len(X)-counter\\r\\n counter += batch_size\\r\\n n += 1\\r\\n \\r\\n \\r\\n # Savings the model\\r\\n filename = r'C:\\\\PythonCodes\\\\MM803\\\\code\\\\Outputs\\\\New\\\\f_canny_'+name+'.sav'\\r\\n pickle.dump(inc, open(filename, 'wb'))\\r\\n \\r\\n # Printing Model Accuracy\\r\\n print(name,\\\" MODEL ACCURACY\\\")\\r\\n print(\\\"_______________________\\\")\\r\\n print(\\\"Avg Training Accuracy of \\\", name,\\\":\\\", statistics.mean(train_acc)) \\r\\n print(\\\"Avg Test Accuracy \\\", name,\\\":\\\",statistics.mean(test_acc))\\r\\n \\r\\n \\r\\n # Testing on Unseen Data\\r\\n SS.transform(np.asarray(X_test_org[:5000]))\\r\\n # IPCA.transform(X_test_org[:5000])\\r\\n print('\\\\nFinal Testing Score on Unseen data 1 by ', name,':', inc.score(X_test_org[:10], y_test_org[:10]))\\r\\n print('Final Testing Score on Unseen data 2 by ', name,':', inc.score(X_test_org[10:100], y_test_org[10:100]))\\r\\n print('Final Testing Score on Unseen data 3 by ', name,':', inc.score(X_test_org[500:1000], y_test_org[500:1000]))\\r\\n \\r\\n print('\\\\n\\\\nClassification Report of', name)\\r\\n print('------------------------------------')\\r\\n print(classification_report(y_test_org[:5000],inc.predict(X_test_org[:5000]), digits = 4))\\r\\n print('====================================')\\r\\n print('\\\\n')\\r\\n \\r\\n # Saving the trained StandardScaler to be used for testing\\r\\n filename_ss = r'C:\\\\PythonCodes\\\\MM803\\\\code\\\\Outputs\\\\New\\\\f_canny_SS.sav'\\r\\n pickle.dump(SS, open(filename_ss, 'wb'))\\r\\n \\r\\n # Saving the trained Incremental PCA to be used for testing\\r\\n #filename_ipca = r'C:\\\\PythonCodes\\\\MM803\\\\code\\\\Outputs\\\\New\\\\f_hed_IPCA.sav'\\r\\n #pickle.dump(IPCA, open(filename_ipca, 'wb')) \\r\",\n \"def _train_model(\\n self,\\n dataset: DatasetEntity,\\n ):\\n logger.info(\\\"init data cfg.\\\")\\n self._data_cfg = ConfigDict(data=ConfigDict())\\n\\n for cfg_key, subset in zip(\\n [\\\"train\\\", \\\"val\\\", \\\"unlabeled\\\"],\\n [Subset.TRAINING, Subset.VALIDATION, Subset.UNLABELED],\\n ):\\n subset = get_dataset(dataset, subset)\\n if subset and self._data_cfg is not None:\\n self._data_cfg.data[cfg_key] = ConfigDict(\\n otx_dataset=subset,\\n labels=self._labels,\\n )\\n\\n self._is_training = True\\n\\n self._init_task()\\n\\n cfg = self.configure(True, None)\\n logger.info(\\\"train!\\\")\\n\\n timestamp = time.strftime(\\\"%Y%m%d_%H%M%S\\\", time.localtime())\\n\\n # Environment\\n logger.info(f\\\"cfg.gpu_ids = {cfg.gpu_ids}, distributed = {cfg.distributed}\\\")\\n env_info_dict = collect_env()\\n env_info = \\\"\\\\n\\\".join([(f\\\"{k}: {v}\\\") for k, v in env_info_dict.items()])\\n dash_line = \\\"-\\\" * 60 + \\\"\\\\n\\\"\\n logger.info(f\\\"Environment info:\\\\n{dash_line}{env_info}\\\\n{dash_line}\\\")\\n\\n # Data\\n datasets = [build_dataset(cfg.data.train)]\\n\\n if self._train_type == TrainType.Semisupervised:\\n # forward the knowledge of num iters per epoch to model for filter loss\\n bs_per_gpu = cfg.data.train_dataloader[\\\"samples_per_gpu\\\"]\\n actual_bs = bs_per_gpu * torch.distributed.get_world_size() if cfg.distributed else bs_per_gpu\\n cfg.model.num_iters_per_epoch = math.ceil(len(datasets[0]) / actual_bs)\\n\\n # FIXME: Currently segmentor does not support multi batch evaluation.\\n # For the Self-SL case, there is no val data. So, need to check the\\n\\n if \\\"val\\\" in cfg.data and \\\"val_dataloader\\\" in cfg.data:\\n cfg.data.val_dataloader[\\\"samples_per_gpu\\\"] = 1\\n\\n # Target classes\\n if \\\"task_adapt\\\" in cfg:\\n target_classes = cfg.task_adapt.final\\n else:\\n target_classes = datasets[0].CLASSES\\n\\n # Metadata\\n meta = dict()\\n meta[\\\"env_info\\\"] = env_info\\n meta[\\\"seed\\\"] = cfg.seed\\n meta[\\\"exp_name\\\"] = cfg.work_dir\\n if cfg.checkpoint_config is not None:\\n cfg.checkpoint_config.meta = dict(\\n mmseg_version=__version__ + get_git_hash()[:7],\\n CLASSES=target_classes,\\n )\\n\\n # Model\\n model = self.build_model(cfg, fp16=cfg.get(\\\"fp16\\\", False), is_training=self._is_training)\\n model.train()\\n model.CLASSES = target_classes\\n\\n if cfg.distributed:\\n convert_sync_batchnorm(model)\\n\\n validate = bool(cfg.data.get(\\\"val\\\", None))\\n\\n if self._hyperparams.learning_parameters.auto_adapt_batch_size != BatchSizeAdaptType.NONE:\\n train_func = partial(train_segmentor, meta=deepcopy(meta), model=deepcopy(model), distributed=False)\\n adapt_batch_size(\\n train_func,\\n cfg,\\n datasets,\\n isinstance(self, NNCFBaseTask), # nncf needs eval hooks\\n not_increase=(self._hyperparams.learning_parameters.auto_adapt_batch_size == BatchSizeAdaptType.SAFE),\\n )\\n\\n train_segmentor(\\n model,\\n datasets,\\n cfg,\\n distributed=cfg.distributed,\\n validate=validate,\\n timestamp=timestamp,\\n meta=meta,\\n )\\n\\n # Save outputs\\n output_ckpt_path = os.path.join(cfg.work_dir, \\\"latest.pth\\\")\\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \\\"best_mDice_*.pth\\\"))\\n if len(best_ckpt_path) > 0:\\n output_ckpt_path = best_ckpt_path[0]\\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \\\"best_mIoU_*.pth\\\"))\\n if len(best_ckpt_path) > 0:\\n output_ckpt_path = best_ckpt_path[0]\\n return dict(\\n final_ckpt=output_ckpt_path,\\n )\",\n \"def worker(selection_idx, results_table):\\n randgen = np.random.RandomState()\\n \\n # Data-specific positive set partition (the real-world dataset consists of multiple motif classes, always exactly 3 instances of each class stored consequently).\\n # The partition assures that the training and test sets do not share instances of the same motif class\\n positive_n_train = round(0.8 * len(positive_set_) / 3) * 3\\n block_start_idx = randgen.randint(positive_n_train / 3 + 1) * 3 \\n block_end_idx = block_start_idx + len(positive_set_) - positive_n_train\\n positive_set_part_train, positive_set_part_test = (np.concatenate((positive_set_[: block_start_idx], positive_set_[block_end_idx: ])), positive_set_[block_start_idx: block_end_idx])\\n \\n # Negative set partition with random selection of elements to match the size of the positive set\\n negative_set = negative_set_[randgen.choice(len(negative_set_), size = positive_set_.shape[0], replace = False)]\\n negative_n = len(negative_set)\\n negative_n_train = round(negative_n * 0.8)\\n negative_set_part_train, negative_set_part_test = (negative_set[: negative_n_train], negative_set[negative_n_train: ])\\n \\n data_part_train = np.float64(np.concatenate((positive_set_part_train, negative_set_part_train)))\\n labels_part_train = np.concatenate((np.ones(len(positive_set_part_train), dtype = 'i1'), np.zeros(len(negative_set_part_train), dtype = 'i1')))\\n data_part_test = np.float64(np.concatenate((positive_set_part_test, negative_set_part_test)))\\n labels_part_test = np.concatenate((np.ones(len(positive_set_part_test), dtype = 'i1'), np.zeros(len(negative_set_part_test), dtype = 'i1')))\\n \\n # Specifying the pipeline and the CV structure\\n pruner = feature_selection.VarianceThreshold()\\n scaler = preprocessing.StandardScaler()\\n feature_selector = feature_selection.SelectKBest(feature_selection.f_classif)\\n classifier = svm.SVC(kernel = 'rbf', gamma = 0.01, class_weight = 'balanced')\\n pipeline0 = pipeline.Pipeline([\\n ('pruning', pruner),\\n ('scaling', scaler),\\n ('selection', feature_selector),\\n ('classification', classifier)\\n ])\\n cv_structure = model_selection.StratifiedShuffleSplit(n_splits = 10, test_size = 0.2)\\n scoring = 'recall_macro' #same as balanced accuracy\\n grid = model_selection.GridSearchCV(pipeline0, scoring = scoring, param_grid = param_grid, cv = cv_structure, n_jobs = 1)\\n \\n # Training the pipeline, saving the data\\n grid.fit(data_part_train, labels_part_train)\\n results_table[selection_idx][0] = np.log10(grid.best_params_['classification__C'])\\n results_table[selection_idx][1] = grid.best_params_['selection__k']\\n results_table[selection_idx][2] = grid.best_score_\\n \\n # Testing the pipeline, saving the data\\n results_table[selection_idx][3] = grid.score(data_part_test, labels_part_test)\",\n \"def finetuned():\\n launch_training_on_all_splits(experiment='full', splits=NAME_SPLIT, base_model='ft', dropout=0.7304, learning_rate=0.0000976)\",\n \"def train(self, train_dataset, val_dataset):\\n\\n # check fine_tuning option\\n model_path = os.path.join(self.check_point, 'model.pt')\\n if self.fine_tune and not os.path.exists(model_path):\\n raise Exception('Cannot find %s.' % model_path)\\n elif self.fine_tune and os.path.exists(model_path):\\n if self.verbose:\\n print('Loading %s for finetuning.' % model_path)\\n self.model = torch.load(model_path)\\n '''\\n if isinstance(net, torch.nn.DataParallel):\\n net = net.module\\n model_dict = self.model.state_dict()\\n net_dict = net.state_dict()\\n # 1. filter out unnecessary keys\\n pretrained_dict = {k: v for k, v in net_dict.items() if k in model_dict}\\n # 2. overwrite entries in the existing state dict\\n model_dict.update(pretrained_dict)\\n # 3. load the new state dict\\n self.model.load_state_dict(model_dict)\\n '''\\n self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)\\n\\n # capture best model\\n best_val_psnr = -1\\n best_psnr = -1\\n best_model_state = self.model.state_dict()\\n\\n with open(os.path.join(self.check_point, 'PSNR' + '.txt'), 'w') as f:\\n # Train the model\\n for epoch in range(self.num_epochs):\\n self._epoch_step(train_dataset, epoch)\\n self.scheduler.step()\\n\\n if epoch % 10 == 0:\\n if self.verbose:\\n print('Computing PSNR...')\\n\\n # capture running PSNR on train and val dataset\\n train_psnr, train_ssim, _, _, _ = self._check_PSNR(val_dataset)\\n self.hist_train_psnr.append(train_psnr)\\n\\n f.write('epoch%d:\\\\t%.3f\\\\n' % (epoch, train_psnr))\\n\\n if self.verbose:\\n print('Average train PSNR:%.3fdB average ssim: %.3f' % (train_psnr, train_ssim))\\n print('')\\n if best_psnr < train_psnr:\\n best_psnr = train_psnr\\n # write the model to hard-disk for testing\\n if not os.path.exists(self.check_point):\\n os.makedirs(self.check_point)\\n model_path = os.path.join(self.check_point, 'model.pt')\\n torch.save(self.model, model_path)\\n print(' Best average psnr: %.3f' % (best_psnr))\\n print('')\",\n \"def main(args):\\n \\n ## Load & Preprocess data \\n if args.data_name == 'amsterdam': \\n file_name = '../data/amsterdam/test_longitudinal_data.csv'\\n ori_data = data_preprocess(file_name, args.max_seq_len)\\n \\n # Divide the data into training and testing\\n divided_data, _ = data_division(ori_data, seed = args.seed, divide_rates = [args.train_rate, 1-args.train_rate])\\n \\n train_data = np.asarray(divided_data[0])\\n test_data = np.asarray(divided_data[1])\\n\\n print('Finish data loading: ' + str(args.data_name)) \\n \\n ## Run hider algorithm\\n if args.hider_model == 'timegan':\\n generated_data = timegan.timegan(train_data)\\n elif args.hider_model == 'add_noise':\\n generated_data = add_noise.add_noise(train_data, args.noise_size) \\n print('Finish hider algorithm training') \\n \\n ## Define enlarge data and its labels\\n enlarge_data = np.concatenate((train_data, test_data), axis = 0)\\n enlarge_data_label = np.concatenate((np.ones([train_data.shape[0],]), np.zeros([test_data.shape[0],])), axis = 0)\\n \\n # Mix the order\\n idx = np.random.permutation(enlarge_data.shape[0])\\n enlarge_data = enlarge_data[idx]\\n enlarge_data_label = enlarge_data_label[idx]\\n \\n ## Run seeker algorithm\\n reidentified_data = knn_seeker(generated_data, enlarge_data)\\n \\n print('Finish seeker algorithm training') \\n \\n ## Evaluate the performance\\n # 1. Feature prediction\\n feat_idx = np.random.permutation(train_data.shape[2])[:args.feature_prediction_no]\\n ori_feat_pred_perf = feature_prediction(train_data, test_data, feat_idx)\\n new_feat_pred_perf = feature_prediction(generated_data, test_data, feat_idx)\\n \\n feat_pred = [ori_feat_pred_perf, new_feat_pred_perf]\\n \\n print('Feature prediction results: ' + \\n '(1) Ori: ' + str(np.round(ori_feat_pred_perf, 4)) + \\n '(2) New: ' + str(np.round(new_feat_pred_perf, 4)))\\n \\n # 2. One step ahead prediction\\n ori_step_ahead_pred_perf = one_step_ahead_prediction(train_data, test_data)\\n new_step_ahead_pred_perf = one_step_ahead_prediction(generated_data, test_data)\\n \\n step_ahead_pred = [ori_step_ahead_pred_perf, new_step_ahead_pred_perf]\\n \\n print('One step ahead prediction results: ' + \\n '(1) Ori: ' + str(np.round(ori_step_ahead_pred_perf, 4)) + \\n '(2) New: ' + str(np.round(new_step_ahead_pred_perf, 4)))\\n \\n # 3. Reidentification score\\n reidentification_score = reidentify_score(enlarge_data_label, reidentified_data)\\n \\n print('Reidentification score: ' + str(np.round(reidentification_score, 4)))\\n \\n shutil.rmtree('tmp')\\n \\n return feat_pred, step_ahead_pred, reidentification_score\",\n \"def train(self, training_data):\\n pass\",\n \"def run_training(self, schema_params, export_model=False, output_model_dir=None):\\n # Log distributed execution context, which includes cluster configuration\\n logger.info(f\\\"Commencing {self.effect_name} training\\\")\\n logger.info(f\\\"Execution context : {self.execution_context}\\\")\\n\\n # Create partition_index_list\\n partition_index_list = self._get_partition_list()\\n logger.info(f\\\"This worker on work on the following list of partitions : {partition_index_list}\\\")\\n\\n # Sequentially train model on partitions\\n for partition_index in partition_index_list:\\n logger.info(f\\\"Commencing {self.effect_name} training for partition index : {partition_index}\\\")\\n\\n # Resolve partitioned data directory from raw path params from user\\n checkpoint_path = self._anchor_directory(\\n self.model.checkpoint_path,\\n partition_index)\\n training_data_dir = self._anchor_directory(self.model.training_data_dir,\\n partition_index)\\n validation_data_dir = self._anchor_directory(self.model.validation_data_dir,\\n partition_index) if self.model.validation_data_dir else None\\n\\n if is_empty_directory(training_data_dir):\\n logger.info(f\\\"{training_data_dir} is empty, no dataset to train on.\\\")\\n continue\\n # Train model\\n self.execution_context[constants.PARTITION_INDEX] = partition_index\\n self.model.train(training_data_dir=training_data_dir,\\n validation_data_dir=validation_data_dir,\\n metadata_file=self.model.metadata_file,\\n checkpoint_path=checkpoint_path,\\n execution_context=self._prepare_training_context(partition_index),\\n schema_params=schema_params)\\n\\n # Chief should export model\\n is_chief = self.execution_context[constants.IS_CHIEF]\\n if export_model and is_chief:\\n logger.info(f\\\"Exporting model to directory : {output_model_dir}\\\")\\n self.model.export(output_model_dir=output_model_dir)\",\n \"def train(self, args_hpo, index):\\n\\n PrintColors.prYellow(f'\\\\n===== training with: {args_hpo} index={index}')\\n PrintColors.prGreen(f'---- in mode: {self.configurations.execution_mode}, tag: {self.configurations.tag} ----')\\n ''' ============ LOAD DATA ================================================================================ '''\\n starting_time = time.time()\\n dataset_reader = self.dataset_reader(\\n candidate_types=self.configurations.clustering_mode,\\n word_indexer={'words': PretrainedTransformerIndexer(self.configurations.pretrained_model_name)},\\n mode=self.configurations.loading_mode)\\n ''' .read returns list of instances '''\\n train_data, val_data, test_data = (dataset_reader.read(folder) for folder in\\n [self.configurations.train_data_dir,\\n self.configurations.val_data_dir,\\n self.configurations.test_data_dir])\\n\\n # count state pairs\\n preceeds = dict()\\n\\n for instance in train_data:\\n for ind in range(len(instance.fields['squeezed_labels'].tokens) - 1):\\n [event_1, event_2] = [instance.fields['squeezed_labels'].tokens[i].text for i in [ind, ind + 1]]\\n scenario = self.dataset_reader.scenario_of_label(event_1)\\n if scenario not in preceeds:\\n preceeds[scenario] = dict()\\n if (event_1, event_2) not in preceeds[scenario]:\\n preceeds[scenario][(event_1, event_2)] = 0\\n preceeds[scenario][(event_1, event_2)] += 1\\n\\n pretrained_tokenizer = PretrainedTransformerTokenizer(self.configurations.pretrained_model_name)\\n supply_token_indices(train_data + val_data, 'story', pretrained_tokenizer)\\n\\n ''' build vocabulary and associate it with datasets '''\\n vocabulary = Vocabulary.from_instances(train_data + val_data)\\n train_data.index_with(vocabulary), val_data.index_with(vocabulary)\\n\\n train_data_loader = DataLoader(dataset=train_data, batch_size=args_hpo.batch_size)\\n val_data_loader = DataLoader(dataset=val_data, batch_size=args_hpo.batch_size)\\n\\n ''' ============ DEFINE MODEL ============================================================================= '''\\n ''' i keep .to() here instead of in model.__init__() to accomadate better abstraction '''\\n event_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\\n if '#' in vocabulary.get_token_from_index(i, 'scr_labels')]\\n participant_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\\n if '@' in vocabulary.get_token_from_index(i, 'scr_labels')]\\n model = self.model(args_hpo, vocabulary, configurations=self.configurations,\\n preceeds=preceeds,\\n event_indices=event_labels,\\n participant_indices=participant_labels).to(self.configurations.device)\\n\\n ''' ============ DEFINE TRAINER =========================================================================== '''\\n ''' -- serialization --------------------------------------------------- '''\\n if not os.path.exists(os.path.join(*['.', 'models'])):\\n os.mkdir(os.path.join(*['.', 'models']))\\n if index == 0:\\n for file in os.listdir(os.path.join(*['.', 'models'])):\\n path = os.path.join(*['.', 'models', file])\\n if os.path.isfile(path):\\n os.remove(path)\\n else:\\n shutil.rmtree(path)\\n serialization_path = 'models_{}_{}'.format(self.configurations.tag, index)\\n serialization_path_longer = os.path.join(*['.', 'models', serialization_path])\\n vocab_path = 'vocab_{}_{}'.format(self.configurations.tag, index)\\n vocab_dir_longer = os.path.join(*['.', 'models', vocab_path])\\n if not os.path.exists(serialization_path_longer):\\n os.mkdir(serialization_path_longer)\\n model_checkpointer = Checkpointer(serialization_dir=serialization_path_longer, num_serialized_models_to_keep=1)\\n ''' -- logging ---------------------------------------------------------- '''\\n tensorboard_writer = TensorboardWriter(serialization_dir='tensorboard', summary_interval=1)\\n if index == 0:\\n shutil.rmtree(os.path.join(*['.', 'tensorboard', 'log']))\\n\\n optimizer = torch.optim.Adam(model.parameters(), lr=args_hpo.lr, weight_decay=args_hpo.l2)\\n trainer = GradientDescentTrainer(\\n model=model,\\n optimizer=optimizer,\\n data_loader=train_data_loader,\\n validation_data_loader=val_data_loader,\\n # note: this is the metric for early stopping\\n validation_metric='-loss',\\n patience=self.configurations.patience,\\n num_epochs=self.configurations.max_epochs,\\n serialization_dir=serialization_path_longer,\\n checkpointer=model_checkpointer,\\n cuda_device=self.configurations.device,\\n grad_norm=args_hpo.clip,\\n tensorboard_writer=tensorboard_writer,\\n learning_rate_scheduler=ReduceOnPlateauLearningRateScheduler(optimizer=optimizer)\\n )\\n\\n ''' trainer saves the model, but the vocabulary needs to be saved, too '''\\n vocabulary.save_to_files(vocab_dir_longer)\\n\\n ''' check the metric names to synchronize with the class '''\\n metrics = trainer.train()\\n test_metrics = model.test(test_data=test_data, dataset_reader=dataset_reader)\\n metrics.update(test_metrics)\\n metrics['time_consumed(hrs)'] = round((time.time() - starting_time) / 3600, 4)\\n\\n return metrics\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train_data_split(self, selected_sr, selected_ss):\\n \\\"\\\"\\\"\\n Arguments:\\n selected_sr: ordinal number of the selected split ratio\\n selected_ss: ordinal number of split shift\\n \\\"\\\"\\\"\\n assert selected_sr < len(self.split_ratios),\\\\\\n \\\"The total number of possible split ratios is: %d\\\"\\\\\\n % len(self.split_ratios)\\n\\n max_shifts = 100 / self.split_ratios[selected_sr][-1]\\n\\n assert selected_ss < max_shifts,\\\\\\n \\\"The total number of split shifts is: %d\\\" % max_shifts\\n\\n self.empty_split()\\n\\n n = float(self.n_train) / max_shifts\\n self.n_develop = int(self.split_ratios[selected_sr][0] /\\n (100 / max_shifts) * n)\\n\\n self.n_valid = int(self.split_ratios[selected_sr][1] /\\n (100 / max_shifts) * n)\\n\\n self.n_eval = self.n_train - self.n_develop - self.n_valid\\n\\n for i in range(self.n_develop):\\n self.development_subjects.\\\\\\n append(self.training_subjects[(selected_ss * self.n_eval + i) %\\n self.n_train])\\n\\n for i in range(self.n_valid):\\n self.validation_subjects.\\\\\\n append(self.training_subjects[(selected_ss * self.n_eval +\\n self.n_develop + i) %\\n self.n_train])\\n\\n for i in range(self.n_eval):\\n self.evaluation_subjects.\\\\\\n append(self.training_subjects[(selected_ss * self.n_eval +\\n self.n_develop +\\n self.n_valid + i) %\\n self.n_train])\",\n \"def create_cub200_task_distribution(path_to_pkl,\\n num_training_samples_per_class=10,\\n num_test_samples_per_class=15,\\n num_training_classes=20,\\n meta_batch_size=5):\\n\\n global cub200_trainX\\n global cub200_trainY\\n\\n global cub200_valX\\n global cub200_valY\\n\\n global cub200_testX\\n global cub200_testY\\n\\n\\n with open(path_to_pkl, 'rb') as f:\\n d = pickle.load(f)\\n cub200_X, cub200_Y = d['dataset']\\n\\n cub200_X = cub200_X.astype(np.float32) / 255.0\\n cub200_X = (cub200_X - np.asarray((0.4914, 0.4822, 0.4465))) / np.asarray((0.2023, 0.1994, 0.2010))\\n\\n #\\n # TODO\\n # random horiz flip + normalize by: \\n # transforms.Normalize((0.4914, 0.4822, 0.4465),\\n # (0.2023, 0.1994, 0.2010)) (mean, std)\\n\\n\\n\\n #np.random.seed(0)\\n # TODO: shuffle allocation of class indices to train/val/test\\n num_train = 100\\n num_val = 50\\n num_test = 50\\n\\n classes = list(set(cub200_Y))\\n train_classes = classes[:num_train]\\n val_classes = classes[num_train:(num_train+num_val)]\\n test_classes = classes[(num_train+num_val):]\\n\\n train_indices = []\\n val_indices = []\\n test_indices = []\\n\\n for i in range(len(cub200_Y)):\\n if cub200_Y[i] in train_classes:\\n train_indices.append(i)\\n elif cub200_Y[i] in val_classes:\\n val_indices.append(i)\\n elif cub200_Y[i] in test_classes:\\n test_indices.append(i)\\n\\n cub200_trainX = cub200_X[train_indices]\\n cub200_trainY = cub200_Y[train_indices]\\n\\n cub200_valX = cub200_X[val_indices]\\n cub200_valY = cub200_Y[val_indices]\\n\\n cub200_testX = cub200_X[test_indices]\\n cub200_testY = cub200_Y[test_indices]\\n\\n\\n train_tasks_list = [ClassificationTask(cub200_trainX,\\n cub200_trainY,\\n num_training_samples_per_class,\\n num_test_samples_per_class,\\n num_training_classes,\\n split_train_test=0.5)]\\n\\n # TODO: NOTE: HACK -- validation and test tasks use a fixed number of test-set samples, instead of the supplied\\n # ones. This is because in MAML/FOMAML the test set is used to compute the meta-gradient, and a small number of\\n # samples is used (in the philosophy of few-shot learning, where only few samples are available).\\n # However, in this case we wish to use a few more test-samples to better estimate the accuracy of the model on the validation\\n # and test tasks!\\n num_test_samples_per_class = 20\\n validation_tasks_list = [ClassificationTask(cub200_valX,\\n cub200_valY,\\n num_training_samples_per_class,\\n num_test_samples_per_class,\\n num_training_classes,\\n split_train_test=0.5)]\\n\\n test_tasks_list = [ClassificationTask(cub200_valX,\\n cub200_valY,\\n num_training_samples_per_class,\\n num_test_samples_per_class,\\n num_training_classes,\\n split_train_test=0.5)]\\n\\n metatrain_task_distribution = TaskDistribution(tasks=train_tasks_list,\\n task_probabilities=[1.0],\\n batch_size=meta_batch_size,\\n sample_with_replacement=True,\\n use_classes_only_once=True)\\n\\n metaval_task_distribution = TaskDistribution(tasks=validation_tasks_list,\\n task_probabilities=[1.0],\\n batch_size=meta_batch_size,\\n sample_with_replacement=True,\\n use_classes_only_once=True)\\n\\n metatest_task_distribution = TaskDistribution(tasks=test_tasks_list,\\n task_probabilities=[1.0],\\n batch_size=meta_batch_size,\\n sample_with_replacement=True,\\n use_classes_only_once=True)\\n\\n return metatrain_task_distribution, metaval_task_distribution, metatest_task_distribution\",\n \"def process_data(train_file, test_file):\\n y_train, tx_train, ids_train, y_test, tx_test, ids_test = load(train_file, test_file)\\n header_train = get_header(train_file)\\n header_test = get_header(test_file)\\n print('\\\\nData set will be split into four, each representing data with different jet numbers.')\\n for jet_num in range(4):\\n print('\\\\nProcess training set with jet number = ' + str(jet_num) + '...')\\n y_train_jet, tx_train_jet, ids_train_jet = split_data(y_train, tx_train, ids_train, jet_num)\\n columns_to_remove = analyze(tx_train_jet)\\n tx_train_jet, header_train_jet = remove_columns(tx_train_jet, header_train, columns_to_remove)\\n create_csv('train_jet_' + str(jet_num) + '.csv', y_train_jet, tx_train_jet, ids_train_jet, header_train_jet, False)\\n print('\\\\n... created train_jet_' + str(jet_num) + '.csv file.')\\n print('\\\\nProcess test set with jet number = ' + str(jet_num) + '...')\\n y_test_jet, tx_test_jet, ids_test_jet = split_data(y_test, tx_test, ids_test, jet_num)\\n columns_to_remove = analyze(tx_test_jet)\\n tx_test_jet, header_test_jet = remove_columns(tx_test_jet, header_test, columns_to_remove)\\n create_csv('test_jet_' + str(jet_num) + '.csv', y_test_jet, tx_test_jet, ids_test_jet, header_test_jet, True)\\n print('\\\\n... created test_jet_' + str(jet_num) + '.csv file.')\",\n \"def prediction(prediction_file_name, clusters_list, svd_use_flag):\\n \\n coords = misc_functions.getWindowCoords()\\n \\n test_users = range(coords[0], coords[2] + 1) \\n test_items = range(coords[1], coords[3] + 1)\\n \\n #print \\\"len(test_users) = \\\", len(test_users)\\n #print \\\"len(test_items) = \\\", len(test_items)\\n #print \\\"test_items = \\\", test_items\\n \\n # this matrix to be written as result finally\\n #misc_functions.step()\\n prediction_matrix = zeros((len(test_users), len(test_items)), dtype = float)\\n \\n training_matrix = scipy.io.mmio.mmread(\\\"history.mtx\\\").tocsr()\\n \\n item_X_meta_matrix = scipy.io.mmio.mmread(\\\"../../../well_done/items-metas_global.mtx\\\").toarray()\\n \\n # getting meta matrices for corresponding using metas\\n meta_ctr = 0\\n meta_matrices = []\\n for meta in METAS_TO_USE:\\n if svd_use_flag:\\n meta_matrice_file_name = \\\"users-\\\" + METAS_TO_USE[meta] + \\\".svd.mtx\\\"\\n else:\\n meta_matrice_file_name = \\\"users-\\\" + METAS_TO_USE[meta] + \\\".mtx\\\"\\n exec(\\\"meta_matrices.append(scipy.io.mmio.mmread(\\\\\\\"\\\" + meta_matrice_file_name + \\\"\\\\\\\").toarray())\\\")\\n\\n #user_counter = 0\\n #for user in test_users:\\n for cur_cluster in clusters_list:\\n \\n #print \\\"cur_cluster[0] = \\\", cur_cluster[0]\\n user = int (cur_cluster[0].split(\\\"\\\\t\\\")[1])\\n #print \\\"user #\\\", user\\n \\n #user_metas = {} - changed to list because of problem with dimension\\n user_metas = []\\n \\n values = zeros((len(METAS_TO_USE), len(test_items)), dtype = float)\\n meta_ctr = 0\\n for meta in METAS_TO_USE:\\n \\n #print \\\" meta_matrices = \\\", meta_matrices\\n #print \\\" meta_matrices[meta_ctr] = \\\", meta_matrices[meta_ctr]\\n user_vector = meta_matrices[meta_ctr][user]\\n #print \\\" user_vector = \\\", user_vector\\n #print \\\" len(user_metas) = \\\", len(user_metas)\\n #print \\\" meta_ctr = \\\", meta_ctr\\n #print \\\"meta = \\\", meta\\n #misc_functions.step()\\n \\n # normalizing counts of visited metas to use them as weights later\\n if max(user_vector) != 0:\\n user_metas.append(1.0 * user_vector / max(user_vector))\\n else:\\n user_metas.append(zeros((len(user_vector), ), dtype = float))\\n #print \\\" user_metas[meta_ctr] = \\\", user_metas[meta_ctr]\\n #print \\\" user_metas[meta_ctr].shape = \\\", user_metas[meta_ctr].shape\\n \\n #for item in test_items:\\n for cluster in cur_cluster[1 : ]:\\n start_cluster_item = int(cluster.split(\\\"\\\\t\\\")[0])\\n stop_cluster_item = int(cluster.split(\\\"\\\\t\\\")[2])\\n \\n cluster_items = range(start_cluster_item, stop_cluster_item + 1)\\n \\n for item in cluster_items:\\n meta_value = item_X_meta_matrix[item, meta]\\n \\n # PRICE\\n if meta == 8:\\n meta_value = priceToPriceCat(meta_value)\\n \\n # CITY HEURISTIC\\n if meta == 11:\\n if user_metas[meta_ctr][meta_value - 1] < CITY_TRESHOLD:\\n values[:, item - coords[1]] *= CITY_COEF\\n \\\"\\\"\\\"\\n # DAYTIME\\n if meta == 17:\\n meta_value = dayTime(meta_value)\\n \\\"\\\"\\\"\\n \\n #print \\\" meta_value = \\\", meta_value\\n #print \\\" item = \\\", item\\n #step()\\n values[meta_ctr][item - coords[1]] = (user_metas[meta_ctr])[meta_value - 1]\\n \\n \\\"\\\"\\\"HEURISTICS \\\"\\\"\\\"\\n \\n \\n \\n \\n \\n \\\"\\\"\\\"\\\\\\\\ HEURISTICS \\\"\\\"\\\"\\n\\n meta_ctr += 1\\n #print \\\"values[:, 0:10] = \\\", values[:, 0:10]\\n prediction_vector = numpy.sum(META_WEIGHTS * values, axis = 0)\\n #print \\\"prediction_vector[0:10] = \\\", prediction_vector[0:10]\\n #print \\\"sum(prediction_vector) = \\\", sum(prediction_vector)\\n prediction_matrix[user - coords[0]] = prediction_vector\\n \\n #step()\\n \\n# ===== END OF MAIN CYCLE ===== \\n\\n result_matrix = scipy.sparse.csr_matrix(prediction_matrix)\\n scipy.io.mmio.mmwrite(prediction_file_name, result_matrix, field = 'real', precision = 5)\",\n \"def __init__(self, sc, dataset_path):\\n\\n logger.info(\\\"Starting up the Recommendation Engine: \\\")\\n\\n self.sc = sc\\n\\n\\t#Load cusomer data for later use\\n\\t\\n logger.info(\\\"Loading Customer data...\\\")\\n customer_file_path = os.path.join(dataset_path, 'tpo_customer.csv')\\n customer_raw_RDD = self.sc.textFile(customer_file_path)\\n customer_raw_data_header = customer_raw_RDD.take(1)[0]\\n self.customer_RDD = customer_raw_RDD.filter(lambda line: line!=customer_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[4]),(tokens[5]),(tokens[6]),(tokens[7]))).cache()\\n\\tlogger.info(\\\"Loading Customer data success...\\\")\\n\\t#CUSTOMCUSTOMER_NAME,CUSTOMER_ADDRESS1,CUSTOMER_ADDRESS2,CUSTOMER_CITY,CUSTOMER_STATE,CUSTOMER_COUNTRY,CUSTOMER_ZIPCODE,CREATED_BY,CREATION_DATE,LAST_UPDATED_BY,LAST_UPDATE_DATE\\n \\n\\n\\n\\t\\n\\t#Load turbine data for later use\\t\\n logger.info(\\\"Loading Turbine data...\\\")\\n turbine_file_path = os.path.join(dataset_path, 'test_tpo_unit_config.csv')\\n turbine_raw_RDD = self.sc.textFile(turbine_file_path)\\n turbine_raw_data_header = turbine_raw_RDD.take(1)[0]\\n self.turbine_RDD = turbine_raw_RDD.filter(lambda line: line!=turbine_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[5]),(tokens[34]),(tokens[51]),(tokens[35]))).cache()\\n\\tlogger.info(\\\"Loading Turbine data success...\\\")\\n \\n\\t\\n\\t\\n\\t\\n\\t#Load site data for later use\\t\\n logger.info(\\\"Loading Site data...\\\")\\n site_file_path = os.path.join(dataset_path, 'tpo_site.csv')\\n site_raw_RDD = self.sc.textFile(site_file_path)\\n site_raw_data_header = site_raw_RDD.take(1)[0]\\n self.site_RDD = site_raw_RDD.filter(lambda line: line!=site_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: ((tokens[0]),(tokens[1]),(tokens[2]),(tokens[3]),(tokens[4]),(tokens[5]),(tokens[6]),(tokens[7]),(tokens[16]))).cache()\\n\\tlogger.info(\\\"Loading Site data success...\\\")\\n\\t\\n\\n\\n\\n\\t# Load ratings data for later use\\n logger.info(\\\"Loading Ratings data...\\\")\\n ratings_file_path = os.path.join(dataset_path, 'ratings.csv')\\n ratings_raw_RDD = self.sc.textFile(ratings_file_path)\\n ratings_raw_data_header = ratings_raw_RDD.take(1)[0]\\n self.ratings_RDD = ratings_raw_RDD.filter(lambda line: line!=ratings_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: (int(tokens[0]),int(tokens[1]),float(tokens[2]))).cache()\\n # Load movies data for later use\\n logger.info(\\\"Loading Movies data...\\\")\\n movies_file_path = os.path.join(dataset_path, 'movies.csv')\\n movies_raw_RDD = self.sc.textFile(movies_file_path)\\n movies_raw_data_header = movies_raw_RDD.take(1)[0]\\n self.movies_RDD = movies_raw_RDD.filter(lambda line: line!=movies_raw_data_header)\\\\\\n .map(lambda line: line.split(\\\",\\\")).map(lambda tokens: (int(tokens[0]),tokens[1],tokens[2])).cache()\\n self.movies_titles_RDD = self.movies_RDD.map(lambda x: (int(x[0]),x[1])).cache()\\n # Pre-calculate movies ratings counts\\n self.__count_and_average_ratings()\\n\\n # Train the model\\n self.rank = 8\\n self.seed = 5L\\n self.iterations = 10\\n self.regularization_parameter = 0.1\\n self.__train_model()\",\n \"def train(self, clfs, dataset):\\n # TODO: implement stacking to help with resolving ties\\n pass\",\n \"def trainAndCalculate(self):\\n f = open(\\\"congressional_voting_dataset.csv\\\")\\n data = np.genfromtxt(fname = f, delimiter=',', dtype=str, encoding=None)\\n X = data[:, :-1]\\n y = data[:, -1]\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)\\n self.svclassifier.fit(X_train, y_train)\",\n \"def train_test_model_batch():\\n train=learning.Train_kmer_clf()\\n train.run()\",\n \"def train(self):\\n raise NotImplementedError\",\n \"def prepare_train_data(self):\\r\\n ## Impute rlkpis\\r\\n print(\\\"Imputing rlKPI df\\\")\\r\\n self.rlkpi.add_target_labels(1)\\r\\n self.rlkpi.impute_rl_kpis()\\r\\n\\r\\n print(\\\"Add 'met-real-station_no' & met-forecast-station_no to rl_kpis_df\\\")\\r\\n self.add_met_real_forecast_station_col_to_rlkpis()\\r\\n print(\\\"Merge 'met-real-sampled df to rl kps \\\")\\r\\n self.merge_met_real_sampled_df_to_rlkpis()\\r\\n\\r\\n ## Imputations for met-forecast\\r\\n print(\\\"Impute met-forecast\\\")\\r\\n met_forecast_obj = self.metfcast\\r\\n met_forecast_obj.impute_met_forecast()\\r\\n\\r\\n #Merge met forecast data to earlier merged data\\r\\n print(\\\"Merge Train data with imputed forecast df\\\")\\r\\n self.train_data = pd.merge(self.train_data,\\r\\n met_forecast_obj.imputed_forecast_df,\\r\\n on=['datetime-station_no'], indicator=True, how='inner')\\r\\n print(\\\"Check any imputation needed\\\", self.train_data.isna().sum().sum())\\r\\n self.train_data.drop(['_merge'], axis=1, inplace=True)\\r\\n self.perform_data_under_sampling(self.train_data)\",\n \"def computeSoftwareMLModels(df,data_label,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,group_col,model_type,ml_model,rank_features=False,compute_null=False,n_splits=10,n_repeats=10,n_jobs=1):\\n software_list = df[data_label].unique()\\n print('Running ML classifer on {} {}'.format(len(software_list),data_label))\\n scores_concat_df = pd.DataFrame()\\n feature_rank_concat_df = pd.DataFrame()\\n external_scores_concat_df = pd.DataFrame()\\n\\n perf_pval_dict = {}\\n for pipe in software_list:\\n ml_df = df[df[data_label]==pipe]\\n print('{} {}'.format(data_label, pipe))\\n\\n #cross_val_score\\n scores_df, null_df, pvalue, feature_rank_df = getMLModelPerf(ml_df,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,model_type,ml_model,rank_features,compute_null,n_splits,n_repeats,n_jobs) \\n scores_df[data_label] = np.tile(pipe,len(scores_df))\\n scores_concat_df = scores_concat_df.append(scores_df)\\n \\n if compute_null:\\n null_df[data_label] = np.tile('null',len(null_df))\\n scores_concat_df = scores_concat_df.append(null_df)\\n perf_pval_dict[pipe] = pvalue\\n\\n # RFECV\\n if rank_features:\\n feature_rank_df[data_label] = np.tile(pipe,len(feature_rank_df))\\n feature_rank_concat_df = feature_rank_concat_df.append(feature_rank_df)\\n\\n # explicit CV for internal vs external perfomance\\n if group_col:\\n external_scores_df = getIndependentTestSetPerf(ml_df,roi_cols,covar_continuous_cols,covar_cat_cols,outcome_col,group_col,model_type,ml_model)\\n external_scores_df[data_label] = np.tile(pipe,len(external_scores_df))\\n external_scores_concat_df = external_scores_concat_df.append(external_scores_df) \\n\\n return scores_concat_df, perf_pval_dict, feature_rank_concat_df, external_scores_concat_df\",\n \"def train_KMean(data: np.array, labels: np.array, n_clusters: int)->None:\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n\\n # Scale the data so that Euclidian distance makes sense\\n means = np.mean(data, axis = 0)\\n stddevs = np.std(data, axis = 0, ddof = 1)\\n\\n #print(means)\\n #print(stddevs)\\n\\n data_scaled = np.zeros((n_examples, n_features))\\n\\n for i in range(n_features):\\n data_scaled[:, i] = (data[:,i] - means[i]) / stddevs[i]\\n\\n study_correlation(data_scaled)\\n\\n # Initialize the centroids\\n idx = np.random.randint(n_examples, size = n_clusters)\\n centroids = data_scaled[idx, :]\\n\\n counter = 0\\n\\n while True:\\n\\n distances = np.array([[np.sqrt(np.sum(np.square(example-centroid))) for centroid in centroids] for example in data_scaled])\\n centroid_idx = np.argmin(distances, axis = 1)\\n old_centroids = centroids\\n centroids = update_centroids(data_scaled, centroid_idx, n_examples)\\n #displacement = get_displacement(old_centroids, centroids)\\n displacement = np.linalg.norm(np.array([old - new for old, new in zip(old_centroids, centroids)]))\\n\\n #assert np.linalg.norm(np.array([old - new for old, new in zip([1, 2, 3, 4], [5, 6, 7, 8])])) == 8\\n\\n if counter == 0:\\n# print(\\\"Initial displacement = {}\\\".format(displacement))\\n initial_displacement = displacement\\n\\n counter += 1\\n\\n if displacement < (initial_displacement / 10000): break\\n\\n #print(\\\"Total number of loops before ending : {}\\\".format(counter))\\n converted_predictions = convert_predictions(centroid_idx)\\n accuracy = np.mean([p == l for p, l in zip(converted_predictions, labels)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def train_and_test(self, data):\\n\\n np.random.shuffle(data)\\n datalist = self.unpack_data(data)\\n\\n logger.info('[*] 75-25 partition of datasets ...')\\n\\n markline1 = math.floor(0.75*(len(datalist['features'])))\\n markline2 = math.floor(0.75*len(datalist['labels']))\\n\\n train_features = datalist['features'][:(markline1)]\\n test_features = datalist['features'][(markline1):]\\n \\n train_labels = datalist['labels'][:(markline2)]\\n test_labels = datalist['labels'][(markline2):]\\n\\n logger.info('[*] Training started with 75% Dataset ...')\\n\\n self.knn_model.fit(train_features, train_labels)\\n\\n logger.info('[*] Testing started with 25% Dataset ...')\\n print('\\\\n/---------------Accuracy----------------/') \\n \\n accuracy = self.knn_model.score(train_features, train_labels)\\n print('Test set accuracy {:.2f} %'.format(accuracy*100))\\n\\n if accuracy < 0.40:\\n logger.warning('[-.-!] Thanks for tryin\\\\' but this machine ain\\\\'t learning.')\\n\\n return True\",\n \"def train_model_pipeline(conform_shape=True, indi_proportion=0.50, incl_group_imgs=True,\\r\\n feature_extractor=flatten_array, model=train_logistic_regression): \\r\\n # Create dataframe subject to feature extractor requirements\\r\\n X_train, y_train, X_test_indi, y_test_indi, X_test_group, y_test_group = \\\\\\r\\n create_train_test_sets(conform_shape=conform_shape, indi_proportion=indi_proportion, \\r\\n incl_group_imgs=incl_group_imgs)\\r\\n \\r\\n # Extract features\\r\\n if feature_extractor == extract_ORB_features:\\r\\n if os.path.isfile('Trained_Models/Kmeans_model.sav'):\\r\\n kmeans_model = load_model('Trained_Models/Kmeans_model.sav')\\r\\n else:\\r\\n kmeans_model = kmeans_cluster(X_train, 500)\\r\\n X_train = feature_extractor(X_train, kmeans_model, normalize = False)\\r\\n X_test_indi = feature_extractor(X_test_indi, kmeans_model, normalize = False)\\r\\n X_test_group = feature_extractor(X_test_group, kmeans_model, normalize = False)\\r\\n\\r\\n else:\\r\\n X_train = feature_extractor(X_train)\\r\\n X_test_indi = feature_extractor(X_test_indi)\\r\\n X_test_group = feature_extractor(X_test_group)\\r\\n \\r\\n # Train model on flattened array (no feature extraction)\\r\\n trained_model = model(X_train, y_train)\\r\\n \\r\\n indi_pred_class, indi_accuracy = evaluate_model(trained_model, X_test_indi, y_test_indi)\\r\\n group_pred_class, group_accuracy = evaluate_model(trained_model, X_test_group, y_test_group)\\r\\n \\r\\n return trained_model, indi_pred_class, indi_accuracy, group_pred_class, group_accuracy\",\n \"def trainOnFold(data, labels, outDir, numModels, partition, params):\\n\\ttrainPart, devPart = partition\\n\\n\\t#partition the data and labels\\n\\ttrainX, trainY = partitionData(data, labels, trainPart)\\n\\tdevX, devY = partitionData(data, labels, devPart)\\n\\n\\tmodels = []\\n\\n\\t#train multiple models\\n\\tfor i in range(numModels):\\n\\n\\t\\tmodelDir = join(outDir, str(i))\\n\\n\\t\\tmkdir(modelDir)\\n\\n\\t\\t#setup logger\\n\\t\\tlogger = makeLogger(modelDir, params.eventMap)\\n\\n\\t\\t#train model\\n\\t\\tmodel, index = trainModel(trainX, trainY, devX, devY, logger, params)\\n\\n\\t\\t#make predictions\\n\\t\\tpred = predictClasses(model, devX, params.batchSize)\\n\\n\\t\\t#evaluate using F1\\n\\t\\tscore = evaluatePredictions(pred, params.eventMap.matrixToNames(devY), params.eventMap, False)\\n\\n\\t\\tmodels.append((score, i, index, model))\\n\\n\\t\\t#need to clean up after building a model\\n\\t\\tb.clear_session()\\n\\n\\t#return best model\\n\\treturn max(models)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67675084","0.6755315","0.673634","0.67276907","0.67021465","0.66885126","0.6578545","0.65512574","0.65313745","0.65287274","0.6499436","0.64882433","0.64505625","0.6448712","0.6448493","0.64040166","0.6400989","0.63855517","0.6363851","0.63565266","0.6355039","0.63513255","0.63394916","0.63358796","0.6323756","0.63177633","0.6306879","0.6306813","0.62864643","0.62819207","0.62798995","0.62655264","0.6264523","0.6260918","0.6258278","0.6246252","0.62460464","0.62391067","0.6222034","0.6219873","0.62185293","0.6209385","0.6209103","0.61981857","0.6181469","0.6180602","0.6177824","0.6171097","0.61503774","0.6149866","0.61437243","0.6141688","0.614032","0.6135952","0.6135518","0.61307395","0.6126692","0.61260664","0.60894376","0.6083403","0.60827494","0.6079924","0.60768545","0.60697025","0.6069044","0.60683244","0.6055864","0.60529375","0.60458267","0.6045652","0.60398644","0.603296","0.60318285","0.6023186","0.6022862","0.602192","0.60214174","0.6020396","0.60172564","0.60133606","0.6010357","0.6010357","0.6010357","0.6010357","0.6010357","0.6007789","0.6004554","0.6000548","0.5995889","0.5990973","0.5985902","0.5974989","0.59747","0.59736216","0.5965963","0.5962746","0.5961334","0.595095","0.5945715","0.59418136"],"string":"[\n \"0.67675084\",\n \"0.6755315\",\n \"0.673634\",\n \"0.67276907\",\n \"0.67021465\",\n \"0.66885126\",\n \"0.6578545\",\n \"0.65512574\",\n \"0.65313745\",\n \"0.65287274\",\n \"0.6499436\",\n \"0.64882433\",\n \"0.64505625\",\n \"0.6448712\",\n \"0.6448493\",\n \"0.64040166\",\n \"0.6400989\",\n \"0.63855517\",\n \"0.6363851\",\n \"0.63565266\",\n \"0.6355039\",\n \"0.63513255\",\n \"0.63394916\",\n \"0.63358796\",\n \"0.6323756\",\n \"0.63177633\",\n \"0.6306879\",\n \"0.6306813\",\n \"0.62864643\",\n \"0.62819207\",\n \"0.62798995\",\n \"0.62655264\",\n \"0.6264523\",\n \"0.6260918\",\n \"0.6258278\",\n \"0.6246252\",\n \"0.62460464\",\n \"0.62391067\",\n \"0.6222034\",\n \"0.6219873\",\n \"0.62185293\",\n \"0.6209385\",\n \"0.6209103\",\n \"0.61981857\",\n \"0.6181469\",\n \"0.6180602\",\n \"0.6177824\",\n \"0.6171097\",\n \"0.61503774\",\n \"0.6149866\",\n \"0.61437243\",\n \"0.6141688\",\n \"0.614032\",\n \"0.6135952\",\n \"0.6135518\",\n \"0.61307395\",\n \"0.6126692\",\n \"0.61260664\",\n \"0.60894376\",\n \"0.6083403\",\n \"0.60827494\",\n \"0.6079924\",\n \"0.60768545\",\n \"0.60697025\",\n \"0.6069044\",\n \"0.60683244\",\n \"0.6055864\",\n \"0.60529375\",\n \"0.60458267\",\n \"0.6045652\",\n \"0.60398644\",\n \"0.603296\",\n \"0.60318285\",\n \"0.6023186\",\n \"0.6022862\",\n \"0.602192\",\n \"0.60214174\",\n \"0.6020396\",\n \"0.60172564\",\n \"0.60133606\",\n \"0.6010357\",\n \"0.6010357\",\n \"0.6010357\",\n \"0.6010357\",\n \"0.6010357\",\n \"0.6007789\",\n \"0.6004554\",\n \"0.6000548\",\n \"0.5995889\",\n \"0.5990973\",\n \"0.5985902\",\n \"0.5974989\",\n \"0.59747\",\n \"0.59736216\",\n \"0.5965963\",\n \"0.5962746\",\n \"0.5961334\",\n \"0.595095\",\n \"0.5945715\",\n \"0.59418136\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62798804"},"document_rank":{"kind":"string","value":"31"}}},{"rowIdx":19498,"cells":{"query":{"kind":"string","value":"Creates strategy which can be used in testing part of the script. reads preprocessed split into training and testing sets data train som model calculates mean profit per cluster in training and testing dataset gets mean profits"},"document":{"kind":"string","value":"def create_strategy(filename: str, columns_list: List[str], som_width: int, som_height: int, n_iter: int, sigma=0.3,\n learning_rate=0.01) -> tuple:\n # get prepared data\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\n\n # train som\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\n sigma=sigma, learning_rate=learning_rate)\n\n # get profit per cluster in train and test datasets\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\n df_profit_per_cluster_test = get_profit_per_cluster(final_df_test)\n\n # get mean profit for sell and buy class in training and testing datasets\n try:\n buy_clusters_mean_profit_train, buy_clusters_list, sell_clusters_mean_profit_train, sell_clusters_list = \\\n get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train)\n\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = \\\n get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test, buy_clusters_list, sell_clusters_list)\n # if the data was assigned to less than to 3 clusters\n except:\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test = None, None, None, None\n\n return len(df_profit_per_cluster_train), len(df_profit_per_cluster_test), \\\n buy_clusters_mean_profit_train, sell_clusters_mean_profit_train, \\\n buy_clusters_mean_profit_test, sell_clusters_mean_profit_test"},"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_train_test(option, transform, params, split=0.2):\r\n clip_im_dir = option.clip_im_dir\r\n matting_dir = option.matting_dir\r\n csv_path = option.csv_path\r\n \r\n print(\"create datasets\")\r\n \r\n \r\n data_df = pd.read_csv(csv_path)\r\n # data_df = MergeDataframe(clip_im_dir, matting_dir)\r\n \r\n #separate data in training and test data (20/80)\r\n train_df, test_df = train_test_split(data_df, test_size=split)\r\n \r\n #search right Dataset class\r\n package_dir = Path(src.dataset.__file__).resolve().parent\r\n\r\n for (_, module_name, _) in iter_modules([package_dir]):\r\n # print(module_name, self.ComType)\r\n if option.dataset.lower() == module_name.lower() :\r\n modelModule = importlib.import_module(\".\"+module_name)\r\n break\r\n \r\n # train data\r\n training_set = modelModule(train_df, clip_im_dir, matting_dir, transform, transform)\r\n train_loader = DataLoader(training_set, **params)\r\n \r\n \r\n #test data\r\n testing_set = modelModule(test_df, clip_im_dir, matting_dir, transform, transform)\r\n test_loader = DataLoader(testing_set, **params)\r\n \r\n return train_loader, test_loader","def main_predefined_split():\n\n average_performance = []\n fold_num = 'predefined'\n output_file_folder = \"output/{}\".format(args.experiment_name)\n output_file_name = \"{}/lnnel_{}.csv\".format(output_file_folder, fold_num)\n Path(output_file_folder).mkdir(parents=True, exist_ok=True)\n args.output_file_name = output_file_name\n\n if args.use_blink:\n df_train = pd.read_csv(\"./data/lcquad/blink/lcquad_train_sorted.csv\")\n df_test = pd.read_csv(\"./data/lcquad/blink/lcquad_test_sorted.csv\")\n else:\n df_train = pd.read_csv(\"./data/lcquad/dbpedia/lcquad_train_sorted.csv\")\n df_test = pd.read_csv(\"./data/lcquad/dbpedia/lcquad_test_sorted.csv\")\n\n # filter out the questions with single positive or many negatives in trianing set\n filtered_question_mentions = []\n for qm in df_train.QuestionMention.unique():\n df_ = df_train[df_train.QuestionMention == qm]\n if df_.Label.sum() == 0:\n filtered_question_mentions.append(qm)\n if df_.Label.sum() == 1 and df_.shape[0] == 1:\n filtered_question_mentions.append(qm)\n # print(df_.Label.values)\n df_train_split_filtered = df_train[~df_train.QuestionMention.isin(filtered_question_mentions)]\n df_train_split_filtered = df_train_split_filtered.sort_values(by=['QuestionMention', 'Label'])\n df_train = df_train_split_filtered\n\n # train\n features_train = np.array(\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_train.Features.values])\n x_train = torch.from_numpy(features_train).float()\n y_train = torch.from_numpy(df_train.Label.values).float().reshape(-1, 1)\n m_labels_train = df_train.Mention_label.values\n ques_train = df_train.Question.values\n\n # test\n features_test = np.array(\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_test.Features.values])\n x_test = torch.from_numpy(features_test).float()\n y_test = torch.from_numpy(df_test.Label.values).float().reshape(-1, 1)\n m_labels_test = df_test.Mention_label.values\n ques_test = df_test.Question.values\n\n # train model and evaluate\n model = pick_model(args.model_name, args.alpha)\n model = model.to(device)\n\n # move to gpu\n x_train, y_train = x_train.to(device), y_train.to(device)\n x_test, y_test = x_test.to(device), y_test.to(device)\n\n print(model)\n\n print(\"model: \", args.model_name, args.alpha)\n print(model(x_train, m_labels_train))\n\n print(\"y_train sum\", sum(y_train), sum(y_train) / len(y_train))\n print(\"y_test sum\", sum(y_test), sum(y_test) / len(y_test))\n\n # aggregate the data into train, val, and test\n train_data = (x_train, y_train, m_labels_train, ques_train)\n print(\"train:\", x_train.shape, y_train.shape, m_labels_train.shape, ques_train.shape)\n test_data = (x_test, y_test, m_labels_test, ques_test)\n print(\"test:\", x_test.shape, y_test.shape, m_labels_test.shape, ques_test.shape)\n\n # check class distribution\n print(\"y_train sum\", sum(y_train), sum(y_train) / len(y_train))\n print(\"y_test sum\", sum(y_test), sum(y_test) / len(y_test))\n\n train(model, train_data, test_data, test_data, args.checkpoint_name, args.num_epoch, args.margin,\n args.learning_rate)\n test_pred, best_scores = test(x_test, m_labels_test, ques_test, args.alpha, args.checkpoint_name,\n args.model_name,\n args.output_file_name)\n with open(args.log_file_name, 'a') as f:\n f.write(\n \"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}; lr={}; margin={}\\n\".format(\n args.model_name,\n args.use_fixed_threshold,\n args.alpha,\n best_scores[\n 'precision'],\n best_scores[\n 'recall'],\n best_scores['f1'],\n args.learning_rate,\n args.margin))\n print(\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}\\n\".format(args.model_name,\n args.use_fixed_threshold,\n args.alpha,\n best_scores['precision'],\n best_scores['recall'],\n best_scores['f1']))\n average_performance.append([best_scores['precision'], best_scores['recall'], best_scores['f1']])\n\n average_performance = np.array(average_performance)\n print(\"Avg performance is prec - rec - f1: \", average_performance.mean(0))","def create_train_test_sample(input_parcel_filepath: Path,\n output_parcel_train_filepath: Path,\n output_parcel_test_filepath: Path,\n balancing_strategy: str,\n force: bool = False):\n\n # If force == False Check and the output files exist already, stop.\n if(force is False\n and output_parcel_train_filepath.exists() is True\n and output_parcel_test_filepath.exists() is True):\n logger.warning(f\"create_train_test_sample: output files already exist and force == False, so stop: {output_parcel_train_filepath}, {output_parcel_test_filepath}\")\n return\n\n # Load input data...\n logger.info(f\"Start create_train_test_sample with balancing_strategy {balancing_strategy}\")\n logger.info(f\"Read input file {input_parcel_filepath}\")\n df_in = pdh.read_file(input_parcel_filepath)\n logger.debug(f\"Read input file ready, shape: {df_in.shape}\")\n\n # Init some many-used variables from config\n class_balancing_column = conf.columns['class_balancing']\n class_column = conf.columns['class']\n\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\n count_per_class = df_in.groupby(class_balancing_column, as_index=False).size()\n logger.info(f\"Number of elements per classname in input dataset:\\n{count_per_class}\")\n\n # The test dataset should be as representative as possible for the entire dataset, so create\n # this first as a 20% sample of each class without any additional checks...\n # Remark: group_keys=False evades that apply creates an extra index-level of the groups above\n # the data and evades having to do .reset_index(level=class_balancing_column_NAME, drop=True)\n # to get rid of the group level\n df_test = df_in.groupby(class_balancing_column, group_keys=False).apply(pd.DataFrame.sample, frac=0.20)\n logger.debug(f\"df_test after sampling 20% of data per class, shape: {df_test.shape}\")\n\n # The candidate parcel for training are all non-test parcel\n df_train_base = df_in[~df_in.index.isin(df_test.index)]\n logger.debug(f\"df_train_base after isin\\n{df_train_base}\")\n\n # Remove parcel with too few pixels from the train sample\n min_pixcount = conf.marker.getfloat('min_nb_pixels_train')\n df_train_base = df_train_base[df_train_base[conf.columns['pixcount_s1s2']] >= min_pixcount]\n logger.debug(f\"Number of parcels in df_train_base after filter on pixcount >= {min_pixcount}: {len(df_train_base)}\")\n\n # Some classes shouldn't be used for training... so remove them!\n logger.info(f\"Remove 'classes_to_ignore_for_train' from train sample (= where {class_column} is in: {conf.marker.getlist('classes_to_ignore_for_train')}\")\n df_train_base = df_train_base[~df_train_base[class_column].isin(conf.marker.getlist('classes_to_ignore_for_train'))]\n\n # All classes_to_ignore aren't meant for training either...\n logger.info(f\"Remove 'classes_to_ignore' from train sample (= where {class_column} is in: {conf.marker.getlist('classes_to_ignore')}\")\n df_train_base = df_train_base[~df_train_base[class_column].isin(conf.marker.getlist('classes_to_ignore'))]\n\n # Print the train base result before applying any balancing\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\n count_per_class = df_train_base.groupby(class_balancing_column, as_index=False).size()\n logger.info(f\"Number of elements per classname for train dataset, before balancing:\\n{count_per_class}\")\n\n # Depending on the balancing_strategy, use different way to get a training sample\n if balancing_strategy == 'BALANCING_STRATEGY_NONE':\n # Just use 25% of all non-test data as train data -> 25% of 80% of data -> 20% of all data\n # will be training date\n # Remark: - this is very unbalanced, eg. classes with 10.000 times the input size than other\n # classes\n # - this results in a relatively high accuracy in overall numbers, but the small\n # classes are not detected at all\n df_train = (df_train_base\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, frac=0.25))\n\n elif balancing_strategy == 'BALANCING_STRATEGY_MEDIUM':\n # Balance the train data, but still use some larger samples for the classes that have a lot\n # of members in the input dataset\n # Remark: with the upper limit of 10.000 this gives still OK results overall, and also the\n # smaller classes give some results with upper limit of 4000 results significantly\n # less good.\n\n # For the larger classes, favor them by leaving the samples larger but cap at upper_limit\n upper_limit = 10000\n lower_limit = 1000\n logger.info(f\"Cap over {upper_limit}, keep the full number of training sample till {lower_limit}, samples smaller than that are oversampled\")\n df_train = (df_train_base.groupby(class_balancing_column).filter(lambda x: len(x) >= upper_limit)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_limit))\n # Middle classes use the number as they are\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_limit)\n .groupby(class_balancing_column).filter(lambda x: len(x) >= lower_limit))\n # For smaller classes, oversample...\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < lower_limit)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, lower_limit, replace=True))\n\n elif balancing_strategy == 'BALANCING_STRATEGY_MEDIUM2':\n # Balance the train data, but still use some larger samples for the classes that have a lot\n # of members in the input dataset\n # Remark: with the upper limit of 10.000 this gives still OK results overall, and also the\n # smaller classes give some results with upper limit of 4000 results significantly\n # less good.\n\n # For the larger classes, leave the samples larger but cap\n cap_count_limit1 = 100000\n cap_train_limit1 = 30000\n logger.info(f\"Cap balancing classes over {cap_count_limit1} to {cap_train_limit1}\")\n df_train = (df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) >= cap_count_limit1)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, cap_train_limit1))\n cap_count_limit2 = 50000\n cap_train_limit2 = 20000\n logger.info(f\"Cap balancing classes between {cap_count_limit2} and {cap_count_limit1} to {cap_train_limit2}\")\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < cap_count_limit1)\n .groupby(class_balancing_column).filter(lambda x: len(x) >= cap_count_limit2)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, cap_train_limit2))\n cap_count_limit3 = 20000\n cap_train_limit3 = 10000\n logger.info(f\"Cap balancing classes between {cap_count_limit3} and {cap_count_limit2} to {cap_train_limit3}\")\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < cap_count_limit2)\n .groupby(class_balancing_column).filter(lambda x: len(x) >= cap_count_limit3)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, cap_train_limit3))\n cap_count_limit4 = 10000\n cap_train_limit4 = 10000\n logger.info(f\"Cap balancing classes between {cap_count_limit4} and {cap_count_limit3} to {cap_train_limit4}\")\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < cap_count_limit3)\n .groupby(class_balancing_column).filter(lambda x: len(x) >= cap_count_limit4)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, cap_train_limit4))\n oversample_count = 1000\n # Middle classes use the number as they are\n logger.info(f\"For classes between {cap_count_limit4} and {oversample_count}, just use all samples\")\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < cap_count_limit4)\n .groupby(class_balancing_column).filter(lambda x: len(x) >= oversample_count))\n # For smaller classes, oversample...\n logger.info(f\"For classes smaller than {oversample_count}, oversample to {oversample_count}\")\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < oversample_count)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, oversample_count, replace=True))\n\n elif balancing_strategy == 'BALANCING_STRATEGY_PROPORTIONAL_GROUPS':\n # Balance the train data, but still use some larger samples for the classes that have a lot\n # of members in the input dataset\n # Remark: with the upper limit of 10.000 this gives still OK results overall, and also the\n # smaller classes give some results with upper limit of 4000 results significantly\n # less good.\n\n # For the larger classes, leave the samples larger but cap\n upper_count_limit1 = 100000\n upper_train_limit1 = 30000\n logger.info(f\"Cap balancing classes over {upper_count_limit1} to {upper_train_limit1}\")\n df_train = (df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) >= upper_count_limit1)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_train_limit1))\n upper_count_limit2 = 50000\n upper_train_limit2 = 20000\n logger.info(f\"Cap balancing classes between {upper_count_limit2} and {upper_count_limit1} to {upper_train_limit2}\")\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_count_limit1)\n .groupby(class_balancing_column).filter(lambda x: len(x) >= upper_count_limit2)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_train_limit2))\n upper_count_limit3 = 20000\n upper_train_limit3 = 10000\n logger.info(f\"Cap balancing classes between {upper_count_limit3} and {upper_count_limit2} to {upper_train_limit3}\")\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_count_limit2)\n .groupby(class_balancing_column).filter(lambda x: len(x) >= upper_count_limit3)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_train_limit3))\n upper_count_limit4 = 10000\n upper_train_limit4 = 5000\n logger.info(f\"Cap balancing classes between {upper_count_limit4} and {upper_count_limit3} to {upper_train_limit4}\")\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_count_limit3)\n .groupby(class_balancing_column).filter(lambda x: len(x) >= upper_count_limit4)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_train_limit4))\n\n # For smaller balancing classes, just use all samples\n df_train = df_train.append(\n df_train_base.groupby(class_balancing_column).filter(lambda x: len(x) < upper_count_limit4))\n\n elif balancing_strategy == 'BALANCING_STRATEGY_UPPER_LIMIT':\n # Balance the train data, but still use some larger samples for the classes that have a lot\n # of members in the input dataset\n # Remark: with the upper limit of 10.000 this gives still OK results overall, and also the\n # smaller classes give some results with upper limit of 4000 results significantly\n # less good.\n\n # For the larger classes, favor them by leaving the samples larger but cap at upper_limit\n upper_limit = 10000\n logger.info(f\"Cap over {upper_limit}...\")\n df_train = (df_train_base.groupby(class_balancing_column).filter(lambda x: len(x) >= upper_limit)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_limit))\n # For smaller classes, just use all samples\n df_train = df_train.append(df_train_base\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_limit))\n\n elif balancing_strategy == 'BALANCING_STRATEGY_EQUAL':\n # In theory the most logical way to balance: make sure all classes have the same amount of\n # training data by undersampling the largest classes and oversampling the small classes.\n df_train = (df_train_base.groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, 2000, replace=True))\n\n else:\n raise Exception(f\"Unknown balancing strategy, STOP!: {balancing_strategy}\")\n\n # Log the resulting numbers per class in the train sample\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\n count_per_class = df_train.groupby(class_balancing_column, as_index=False).size()\n logger.info(f'Number of elements per class_balancing_column in train dataset:\\n{count_per_class}')\n if class_balancing_column != class_column:\n count_per_class = df_train.groupby(class_column, as_index=False).size()\n logger.info(f'Number of elements per class_column in train dataset:\\n{count_per_class}')\n\n # Log the resulting numbers per class in the test sample\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\n count_per_class = df_test.groupby(class_balancing_column, as_index=False).size()\n logger.info(f'Number of elements per class_balancing_column in test dataset:\\n{count_per_class}')\n if class_balancing_column != class_column:\n count_per_class = df_test.groupby(class_column, as_index=False).size()\n logger.info(f'Number of elements per class_column in test dataset:\\n{count_per_class}')\n\n # Write to output files\n logger.info('Write the output files')\n df_train.set_index(conf.columns['id'], inplace=True)\n df_test.set_index(conf.columns['id'], inplace=True)\n pdh.to_file(df_train, output_parcel_train_filepath) # The ID column is the index...\n pdh.to_file(df_test, output_parcel_test_filepath) # The ID column is the index...","def create_train_test_sample(\n input_parcel_path: Path,\n output_parcel_train_path: Path,\n output_parcel_test_path: Path,\n balancing_strategy: str,\n force: bool = False,\n):\n\n # If force == False Check and the output files exist already, stop.\n if (\n force is False\n and output_parcel_train_path.exists() is True\n and output_parcel_test_path.exists() is True\n ):\n logger.warning(\n \"create_train_test_sample: output files already exist and force is False: \"\n f\"{output_parcel_train_path}, {output_parcel_test_path}\"\n )\n return\n\n # Load input data...\n logger.info(\n f\"Start create_train_test_sample with balancing_strategy {balancing_strategy}\"\n )\n logger.info(f\"Read input file {input_parcel_path}\")\n df_in = pdh.read_file(input_parcel_path)\n logger.debug(f\"Read input file ready, shape: {df_in.shape}\")\n\n # Init some many-used variables from config\n class_balancing_column = conf.columns[\"class_balancing\"]\n class_column = conf.columns[\"class\"]\n\n with pd.option_context(\n \"display.max_rows\", None, \"display.max_columns\", None\n ): # type: ignore\n count_per_class = df_in.groupby(class_balancing_column, as_index=False).size()\n logger.info(\n f\"Number of elements per classname in input dataset:\\n{count_per_class}\"\n )\n\n # The test dataset should be as representative as possible for the entire dataset,\n # so create this first as a 20% sample of each class without any additional checks.\n # Remark: group_keys=False evades that apply creates an extra index-level of the\n # groups above the data and evades having to do\n # .reset_index(level=class_balancing_column_NAME, drop=True)\n # to get rid of the group level\n test_df = df_in.groupby(class_balancing_column, group_keys=False).apply(\n pd.DataFrame.sample, frac=0.20\n )\n logger.debug(\n f\"df_test after sampling 20% of data per class, shape: {test_df.shape}\"\n )\n\n # The candidate parcel for training are all non-test parcel\n train_base_df = df_in[~df_in.index.isin(test_df.index)]\n logger.debug(f\"df_train_base after isin\\n{train_base_df}\")\n\n # Remove parcel with too few pixels from the train sample\n min_pixcount = conf.marker.getfloat(\"min_nb_pixels_train\")\n train_base_df = train_base_df[\n train_base_df[conf.columns[\"pixcount_s1s2\"]] >= min_pixcount\n ]\n logger.debug(\n \"Number of parcels in df_train_base after filter on pixcount >= \"\n f\"{min_pixcount}: {len(train_base_df)}\"\n )\n\n # Some classes shouldn't be used for training... so remove them!\n logger.info(\n \"Remove 'classes_to_ignore_for_train' from train sample (= where \"\n f\"{class_column} is in: {conf.marker.getlist('classes_to_ignore_for_train')}\"\n )\n train_base_df = train_base_df[\n ~train_base_df[class_column].isin(\n conf.marker.getlist(\"classes_to_ignore_for_train\")\n )\n ]\n\n # All classes_to_ignore aren't meant for training either...\n logger.info(\n f\"Remove 'classes_to_ignore' from train sample (= where {class_column} is in: \"\n f\"{conf.marker.getlist('classes_to_ignore')}\"\n )\n train_base_df = train_base_df[\n ~train_base_df[class_column].isin(conf.marker.getlist(\"classes_to_ignore\"))\n ]\n\n # Print the train base result before applying any balancing\n with pd.option_context(\n \"display.max_rows\", None, \"display.max_columns\", None\n ): # type: ignore\n count_per_class = train_base_df.groupby(\n class_balancing_column, as_index=False\n ).size()\n logger.info(\n \"Number of elements per classname for train dataset, before balancing:\\n\"\n f\"{count_per_class}\"\n )\n\n # Depending on the balancing_strategy, use different way to get a training sample\n train_df = pd.DataFrame().reindex_like(train_base_df)\n if balancing_strategy == \"BALANCING_STRATEGY_NONE\":\n # Just use 25% of all non-test data as train data -> 25% of 80% of data -> 20%\n # of all data will be training date\n # Remark: - this is very unbalanced, eg. classes with 10.000 times the input\n # size than other classes\n # - this results in a relatively high accuracy in overall numbers, but\n # the small classes are not detected at all\n train_df = train_base_df.groupby(\n class_balancing_column, group_keys=False\n ).apply(pd.DataFrame.sample, frac=0.25)\n\n elif balancing_strategy == \"BALANCING_STRATEGY_MEDIUM\":\n # Balance the train data, but still use some larger samples for the classes\n # that have a lot of members in the input dataset\n # Remark: with the upper limit of 10.000 this gives still OK results overall,\n # and also the smaller classes give some results with upper limit of 4000\n # results significantly less good.\n\n # For the larger classes, favor them by leaving the samples larger but cap at\n # upper_limit\n upper_limit = 10000\n lower_limit = 1000\n logger.info(\n f\"Cap over {upper_limit}, keep the full number of training sample till \"\n f\"{lower_limit}, samples smaller than that are oversampled\"\n )\n train_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) >= upper_limit)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_limit)\n )\n # Middle classes use the number as they are\n train_df = pd.concat(\n [\n train_df,\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < upper_limit)\n .groupby(class_balancing_column)\n .filter(lambda x: len(x) >= lower_limit),\n ]\n )\n # For smaller classes, oversample...\n train_df = pd.concat(\n [\n train_df,\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < lower_limit)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, lower_limit, replace=True),\n ]\n )\n\n elif balancing_strategy == \"BALANCING_STRATEGY_MEDIUM2\":\n # Balance the train data, but still use some larger samples for the classes\n # that have a lot of members in the input dataset\n # Remark: with the upper limit of 10.000 this gives still OK results overall,\n # and also the smaller classes give some results with upper limit of 4000\n # results significantly less good.\n\n # For the larger classes, leave the samples larger but cap\n # Cap 1\n cap_count_limit1 = 100000\n cap_train_limit1 = 30000\n logger.info(\n f\"Cap balancing classes over {cap_count_limit1} to {cap_train_limit1}\"\n )\n train_capped_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) >= cap_count_limit1)\n .groupby(class_balancing_column, group_keys=False)\n )\n if len(train_capped_df) > 0:\n train_df = pd.concat(\n [train_df, train_capped_df.apply(pd.DataFrame.sample, cap_train_limit1)]\n )\n\n # Cap 2\n cap_count_limit2 = 50000\n cap_train_limit2 = 20000\n logger.info(\n f\"Cap balancing classes between {cap_count_limit2} and {cap_count_limit1} \"\n f\"to {cap_train_limit2}\"\n )\n train_capped_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < cap_count_limit1)\n .groupby(class_balancing_column)\n .filter(lambda x: len(x) >= cap_count_limit2)\n .groupby(class_balancing_column, group_keys=False)\n )\n if len(train_capped_df) > 0:\n train_df = pd.concat(\n [train_df, train_capped_df.apply(pd.DataFrame.sample, cap_train_limit2)]\n )\n\n # Cap 3\n cap_count_limit3 = 20000\n cap_train_limit3 = 10000\n logger.info(\n f\"Cap balancing classes between {cap_count_limit3} and {cap_count_limit2} \"\n f\"to {cap_train_limit3}\"\n )\n train_capped_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < cap_count_limit2)\n .groupby(class_balancing_column)\n .filter(lambda x: len(x) >= cap_count_limit3)\n .groupby(class_balancing_column, group_keys=False)\n )\n if len(train_capped_df) > 0:\n train_df = pd.concat(\n [train_df, train_capped_df.apply(pd.DataFrame.sample, cap_train_limit3)]\n )\n\n # Cap 4\n cap_count_limit4 = 10000\n cap_train_limit4 = 10000\n logger.info(\n f\"Cap balancing classes between {cap_count_limit4} and {cap_count_limit3} \"\n f\"to {cap_train_limit4}\"\n )\n train_capped_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < cap_count_limit3)\n .groupby(class_balancing_column)\n .filter(lambda x: len(x) >= cap_count_limit4)\n .groupby(class_balancing_column, group_keys=False)\n )\n if len(train_capped_df) > 0:\n train_df = pd.concat(\n [train_df, train_capped_df.apply(pd.DataFrame.sample, cap_train_limit4)]\n )\n\n # Middle classes use the number as they are, smaller classes are oversampled\n oversample_count = 1000\n logger.info(\n f\"For classes between {cap_count_limit4} and {oversample_count}, just use \"\n \"all samples\"\n )\n train_df = pd.concat(\n [\n train_df,\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < cap_count_limit4)\n .groupby(class_balancing_column)\n .filter(lambda x: len(x) >= oversample_count),\n ]\n )\n # For smaller classes, oversample...\n logger.info(\n f\"For classes smaller than {oversample_count}, oversample to \"\n f\"{oversample_count}\"\n )\n train_capped_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < oversample_count)\n .groupby(class_balancing_column, group_keys=False)\n )\n if len(train_capped_df) > 0:\n train_df = pd.concat(\n [\n train_df,\n train_capped_df.apply(\n pd.DataFrame.sample, oversample_count, replace=True\n ),\n ]\n )\n\n elif balancing_strategy == \"BALANCING_STRATEGY_PROPORTIONAL_GROUPS\":\n # Balance the train data, but still use some larger samples for the classes\n # that have a lot of members in the input dataset\n # Remark: with the upper limit of 10.000 this gives still OK results overall,\n # and also the smaller classes give some results with upper limit of 4000\n # results significantly less good.\n\n # For the larger classes, leave the samples larger but cap\n upper_count_limit1 = 100000\n upper_train_limit1 = 30000\n logger.info(\n f\"Cap balancing classes over {upper_count_limit1} to {upper_train_limit1}\"\n )\n train_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) >= upper_count_limit1)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_train_limit1)\n )\n upper_count_limit2 = 50000\n upper_train_limit2 = 20000\n logger.info(\n f\"Cap balancing classes between {upper_count_limit2} and \"\n f\"{upper_count_limit1} to {upper_train_limit2}\"\n )\n train_limit2_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < upper_count_limit1)\n .groupby(class_balancing_column)\n .filter(lambda x: len(x) >= upper_count_limit2)\n .groupby(class_balancing_column, group_keys=False)\n )\n if len(train_limit2_df) > 0:\n train_df = pd.concat(\n [\n train_df,\n train_limit2_df.apply(pd.DataFrame.sample, upper_train_limit2),\n ]\n )\n upper_count_limit3 = 20000\n upper_train_limit3 = 10000\n logger.info(\n f\"Cap balancing classes between {upper_count_limit3} and \"\n f\"{upper_count_limit2} to {upper_train_limit3}\"\n )\n train_limit3_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < upper_count_limit2)\n .groupby(class_balancing_column)\n .filter(lambda x: len(x) >= upper_count_limit3)\n .groupby(class_balancing_column, group_keys=False)\n )\n if len(train_limit3_df) > 0:\n train_df = pd.concat(\n [\n train_df,\n train_limit3_df.apply(pd.DataFrame.sample, upper_train_limit3),\n ]\n )\n upper_count_limit4 = 10000\n upper_train_limit4 = 5000\n logger.info(\n f\"Cap balancing classes between {upper_count_limit4} and \"\n f\"{upper_count_limit3} to {upper_train_limit4}\"\n )\n train_limit4_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) < upper_count_limit3)\n .groupby(class_balancing_column)\n .filter(lambda x: len(x) >= upper_count_limit4)\n .groupby(class_balancing_column, group_keys=False)\n )\n if len(train_limit4_df) > 0:\n train_df = pd.concat(\n [\n train_df,\n train_limit4_df.apply(pd.DataFrame.sample, upper_train_limit4),\n ]\n )\n # For smaller balancing classes, just use all samples\n train_df = pd.concat(\n [\n train_df,\n train_base_df.groupby(class_balancing_column).filter(\n lambda x: len(x) < upper_count_limit4\n ),\n ]\n )\n\n elif balancing_strategy == \"BALANCING_STRATEGY_UPPER_LIMIT\":\n # Balance the train data, but still use some larger samples for the classes\n # that have a lot of members in the input dataset\n # Remark: with the upper limit of 10.000 this gives still OK results overall,\n # and also the smaller classes give some results with upper limit of 4000\n # results significantly less good.\n\n # For the larger classes, favor them by leaving the samples larger but cap at\n # upper_limit\n upper_limit = 10000\n logger.info(f\"Cap over {upper_limit}...\")\n train_df = (\n train_base_df.groupby(class_balancing_column)\n .filter(lambda x: len(x) >= upper_limit)\n .groupby(class_balancing_column, group_keys=False)\n .apply(pd.DataFrame.sample, upper_limit)\n )\n # For smaller classes, just use all samples\n train_df = pd.concat(\n [\n train_df,\n train_base_df.groupby(class_balancing_column).filter(\n lambda x: len(x) < upper_limit\n ),\n ]\n )\n\n elif balancing_strategy == \"BALANCING_STRATEGY_EQUAL\":\n # In theory the most logical way to balance: make sure all classes have the\n # same amount of training data by undersampling the largest classes and\n # oversampling the small classes.\n train_df = train_base_df.groupby(\n class_balancing_column, group_keys=False\n ).apply(pd.DataFrame.sample, 2000, replace=True)\n\n else:\n raise Exception(f\"Unknown balancing strategy, STOP!: {balancing_strategy}\")\n\n # Log the resulting numbers per class in the train sample\n with pd.option_context(\n \"display.max_rows\", None, \"display.max_columns\", None\n ): # type: ignore\n count_per_class = train_df.groupby(\n class_balancing_column, as_index=False\n ).size()\n logger.info(\n \"Number of elements per class_balancing_column in train dataset:\\n\"\n f\"{count_per_class}\"\n )\n if class_balancing_column != class_column:\n count_per_class = train_df.groupby(class_column, as_index=False).size()\n logger.info(\n \"Number of elements per class_column in train dataset:\\n\"\n f\"{count_per_class}\"\n )\n\n # Log the resulting numbers per class in the test sample\n with pd.option_context(\n \"display.max_rows\", None, \"display.max_columns\", None\n ): # type: ignore\n count_per_class = test_df.groupby(class_balancing_column, as_index=False).size()\n logger.info(\n \"Number of elements per class_balancing_column in test dataset:\\n\"\n f\"{count_per_class}\"\n )\n if class_balancing_column != class_column:\n count_per_class = test_df.groupby(class_column, as_index=False).size()\n logger.info(\n \"Number of elements per class_column in test dataset:\\n\"\n f\"{count_per_class}\"\n )\n\n # Write to output files\n logger.info(\"Write the output files\")\n train_df.set_index(conf.columns[\"id\"], inplace=True)\n test_df.set_index(conf.columns[\"id\"], inplace=True)\n pdh.to_file(train_df, output_parcel_train_path) # The ID column is the index...\n pdh.to_file(test_df, output_parcel_test_path) # The ID column is the index...","def run_train_test_split():\n # Load all documents\n conn = sq.connect(config.DB_FILE)\n documents = pd.read_sql_query('select pubmed_id, review_id, included, title, abstract from article ', conn)\n\n # Identify unique review IDs\n review_ids = documents['review_id'].unique()\n\n # Set seed for random sampling\n np.random.seed(2)\n\n # List of Reviews in the partial data set and full data set\n partial_set = list(np.random.choice(review_ids, 10, replace=False))\n full_set = list(review_ids.copy())\n\n # Load array (X) and labels (Y) of all documents\n with (open(config.DOC_TERM_MATRIX, \"rb\")) as openfile:\n X = pickle.load(openfile)\n\n y = documents['included']\n\n # Train-test split of the partial dataset\n train_test_split(X, y, partial_set, 'min_max', 'partial', review_ids)\n train_test_split(X, y, partial_set, 'tf_idf', 'partial', review_ids)\n\n # Train-test split of the full dataset\n train_test_split(X, y, full_set, 'min_max', 'full', review_ids)\n train_test_split(X, y, full_set, 'tf_idf', 'full', review_ids)","def main_modeling_pipeline():\n\n\n data_df = pd.read_csv('gs://aiplatformfilipegracio2020/head_train_data.csv')\n data_df = data_df[[LABEL, 'price', 'days_on_site']]\n\n class_weights = calculate_class_weights(data_df[LABEL])\n print('class weights', class_weights)\n logging.info('Data loaded and processed')\n train_ds, val_ds, test_ds = make_tf_datasets(data_df, LABEL)\n logging.info('Tensorflow datasets created')\n\n with strategy.scope():\n logging.info('Inside strategy')\n simple_feature_layer = make_simple_feature_layer(data_df)\n logging.info('Going to make model')\n simple_model = make_simple_model(simple_feature_layer)\n\n logging.info('Going fit model')\n simple_model_results, simple_model = model_fit_and_evaluate(model=simple_model,\n train_ds=train_ds,\n val_ds=val_ds,\n test_ds=test_ds,\n class_weights=class_weights,\n epochs=TRAINING_EPOCHS,\n job_name='simple_model')\n\n simple_model.save('gs://aiplatformfilipegracio2020/')","def main(source_dir, ksplit, out_dir, data_pattern, label_pattern, test_mode,\r\n numTopVars = [10, 50, 100, 500, 1000], compute_results=True):\r\n # Load input and labels.\r\n data, labels, data_file = load_data(source_dir, data_pattern)\r\n filename_base = path.splitext(path.basename(mname))[0]\r\n # Get classifiers and params.\r\n global NAMES\r\n if test_mode:\r\n NAMES = [\"Chance\", \"Nearest Neighbors\", \"Linear SVM\", \"Decision Tree\",\r\n \"Logistic Regression\", \"Naive Bayes\", \"LDA\"]\r\n ksplit = 3\r\n\r\n classifiers, params = make_classifiers(NAMES) # data.shape, ksplit)\r\n\r\n\r\n # Make the folds.\r\n logging.info(\"Making %d folds\" % ksplit)\r\n #kf = StratifiedKFold(labels, n_folds=ksplit)\r\n kf = KFold(labels.shape[0], n_folds=ksplit)\r\n\r\n # Extract the training and testing indices from the k-fold object,\r\n # which stores fold pairs of indices.\r\n fold_pairs = [(tr, ts) for (tr, ts) in kf]\r\n assert len(fold_pairs) == ksplit\r\n rank_per_fold = get_rank_per_fold(data, labels, fold_pairs,\r\n save_path=out_dir, parallel=True)\r\n #dhjelm: were we planning on using this dict?\r\n #score={}\r\n dscore=[]\r\n totalErrs = []\r\n if compute_results:\r\n for name in NAMES:\r\n mdl = classifiers[name]\r\n param = params[name]\r\n # get_score runs the classifier on each fold,\r\n # each subset of selected top variables and does a grid search for\r\n # classifier-specific parameters (selects the best)\r\n clf, allConfMats, allTotalErrs, allFittedClassifiers = \\\r\n get_score(data, labels, fold_pairs, name, mdl, param,\r\n numTopVars=numTopVars,\r\n rank_per_fold=rank_per_fold, parallel=True,\r\n rand_iter=-1)\r\n # save classifier object and results to file\r\n save_classifier_results(name, out_dir, allConfMats,\r\n allTotalErrs)\r\n save_classifier_object(clf, allFittedClassifiers, name, out_dir)\r\n # Append classifier results to list of all results\r\n dscore.append(allConfMats)\r\n totalErrs.append(allTotalErrs)\r\n '''\r\n First do some saving of total results\r\n '''\r\n save_combined_results(NAMES, dscore, totalErrs,\r\n numTopVars, out_dir, filename_base)\r\n\r\n plot_errors(NAMES, numTopVars, dscore, totalErrs,\r\n filename_base, out_dir,compute_results)\r\n\r\n logging.shutdown()","def create_simple_data_set(\n n_training_points,\n n_testing_points,\n low=0,\n high=3,\n mode=training_testing_split.SEPERATE,\n kernel=kernel_matern,\n shuffle=True,\n):\n gp = gaussian_process(kernel=kernel, verbose=True)\n\n mid = (low + high) / 2\n\n if mode == training_testing_split.SEPERATE_LONG:\n x_training, x_testing = __seperate_long(\n n_training_points, n_testing_points, low, high\n )\n elif mode == training_testing_split.SEPERATE:\n x_training, x_testing = __seperate(\n n_training_points, n_testing_points, low, high\n )\n elif mode == training_testing_split.INTERSPREAD:\n x_training, x_testing = __interspread(\n n_training_points, n_testing_points, low, high\n )\n elif mode == training_testing_split.RANDOM:\n x_training, x_testing = __random(n_training_points, n_testing_points, low, high)\n elif mode == training_testing_split.MIXED:\n\n def r(z):\n dist = np.random.randint(low=1, high=100, size=4)\n λ = lambda x: x / dist.sum()\n vfunc = np.vectorize(λ)\n dist = vfunc(dist)\n return (z * dist).round().astype(int)\n\n training_dist = r(n_training_points)\n testing_dist = r(n_testing_points)\n x1, x2 = __random(training_dist[0], testing_dist[0], low, high)\n x11, x22 = __interspread(training_dist[1], testing_dist[1], low, high)\n x111, x222 = __interspread(training_dist[2], testing_dist[2], low, high)\n x1111, x2222 = __seperate(training_dist[3], testing_dist[3], low, high)\n x_training = np.vstack([x1, x11, x111, x1111])\n x_testing = np.vstack([x2, x22, x222, x222])\n\n y_samples = gp.sample(np.vstack([x_training, x_testing]), 1).squeeze()\n y_training = y_samples[: len(x_training)].reshape(-1, 1)\n y_testing = y_samples[len(x_training) :].reshape(-1, 1)\n training_data_set = data_loader.DataSet(X=x_training, Y=y_training)\n testing_data_set = data_loader.DataSet(X=x_testing, Y=y_testing)\n\n if shuffle:\n training_data_set.shuffle()\n testing_data_set.shuffle()\n\n return training_data_set, testing_data_set","def prepare_nfold_datasets(self): # i.e. split into different train/ground-truth(test) dataset\n for alpha in range(1, self.ALPHAs+1):\n if alpha != self.ALPHAs:\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI], separator='-')\n else:\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI+self.runoff_years], separator='-')\n new_cluster_dir = str(Path(self.tl_model.cluster_dir) / f'alpha_{alpha}_GT-{gt_years}')\n os.makedirs(new_cluster_dir, exist_ok=True)\n\n new_prepared_data_dir = str(Path(self.tl_model.prepared_data_dir) / f'alpha_{alpha}')\n os.makedirs(new_prepared_data_dir, exist_ok=True)\n \n if utils.find(f'*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir) and utils.find(f'*alpha_{alpha}_standardized_stacked_arr.pkl', new_prepared_data_dir):\n pass\n else:\n if not utils.find(f'*target*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\n print(f\"=> No input datasets pre-processed for alpha of {alpha}\")\n prepare.cut_target_dataset(self, alpha, new_prepared_data_dir)\n\n if not utils.find(f'*rf*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\n print(f\"=> No rainfall datasets pre-processed for alpha of {alpha}\")\n prepare.cut_rf_dataset(self, alpha, new_prepared_data_dir)\n \n print(f'Preprocessed pickles for alpha split {alpha} can be found @:\\n{new_prepared_data_dir}')","def test_training(self):\n\t\tpass","def data_split(self, split_index=0, thinning=None, apply_mask=False, mask=[], **kwargs):\n \n self.learn_sets = ['train','vali','test']\n self.ind_train = self.train_splitdict[split_index]\n self.ind_train.sort()\n self.ind_test = self.test_splitdict[split_index]\n self.ind_test.sort()\n if len(self.vali_splitdict) !=0:\n self.learn_sets = ['train','vali','test']\n self.ind_vali = self.vali_splitdict[split_index]\n self.ind_vali.sort()\n self.indices_learn_dict = dict(zip(self.learn_sets, [self.ind_train, self.ind_vali, self.ind_test]))\n else:\n self.learn_sets = ['train','test']\n self.indices_learn_dict = dict(zip(self.learn_sets, [self.ind_train, self.ind_test]))\n\n\n self.train_samples = self.fullspace[self.ind_train]\n self.train_size = len(self.train_samples)\n\n if len(self.vali_splitdict) !=0:\n self.vali_samples = self.fullspace[self.ind_vali]\n self.vali_samples.sort()\n self.vali_size = len(self.vali_samples)\n else:\n self.vali_size = 0\n self.test_samples = self.fullspace[self.ind_test]\n #self.test_samples.sort()\n self.test_size = len(self.test_samples)\n verbosity = kwargs.get('verbosity', 1)\n\n too.condprint(\"number of obtained training vectors\", self.train_size, level=1, verbosity=verbosity)\n too.condprint(\"number of obtained validation vectors\", self.vali_size, level=1, verbosity=verbosity)\n too.condprint(\"number of obtained test vectors\", self.test_size, level=2, verbosity=verbosity)\n\n\n self.matrix_datalearn_dict = dict()\n\n for dli in self.learn_sets:\n matrixdata = np.copy(self.matrix_z)\n self.matrixdata=matrixdata\n\n ## copy of mask to avoid modifying orginal mask after iterations\n if apply_mask==False:\n maskcopy=np.arange(0,len(matrixdata[0])) ##range over all axis length, does not mask anything\n else:\n maskcopy=np.copy(mask)\n \n ## apply thinning (if set to None, there is no thinning)\n self.mask_true=maskcopy[::thinning] \n\n ## apply mask also to feature grid and save as masked_+...\n setattr(self, 'masked_'+self.features_str, self.fgrid[self.mask_true]) \n\n matrixdata = matrixdata[:,self.mask_true] ## apply mask and thinning to feature space (k-grid)\n indices_l = self.indices_learn_dict[dli]\n matrixdata = matrixdata[indices_l,:] ##choose learning set\n self.matrix_datalearn_dict[dli] = matrixdata\n self.matrix_datalearn_dict = objdict(self.matrix_datalearn_dict)\n return self.matrix_datalearn_dict","def setup(self, stage: Optional[str] = None):\n if stage in (None, 'fit'):\n # Get a 20% of the train data for validation in a stratified way.\n _x = [i[1] for i in self.splits['train']]\n _y = [i[0] for i in self.splits['train']]\n\n _train_x, _val_x, _train_y, _val_y = train_test_split(_x, _y, test_size=0.2,\n stratify=_y)\n #print(np.unique(_train_y, return_counts=True))\n #print(np.unique(_val_y, return_counts=True))\n\n self.splits['train'] = [[i, j] for i,j in zip(_train_y, _train_x)]\n self.splits['valid'] = [[i, j] for i,j in zip(_val_y, _val_x)]\n\n self.datasets['train'] = FewShotDataset(self.splits['train'], self.ops)\n self.datasets['valid'] = FewShotDataset(self.splits['valid'], self.ops)\n\n if stage in (None, 'test'):\n self.datasets['test'] = FewShotDataset(self.splits['test'], self.ops)","def prediction_data(median_split,mean_split,std_split,degrees_split,weight_split,export_file):\n DATA_TEST_PATH = '../data/test.csv' # Download train data and supply path here \n print('\\nIMPORTING TESTING DATA :',end=\" \")\n y_test, tX_test, ids_test = load_csv_data(DATA_TEST_PATH)\n print('DONE')\n \n #5.a. Splitting the testing data\n print('SPLITTING TESTING DATA :',end=\" \")\n y_test_split,tx_test_split,id_test_split = split_dataset(y_test,tX_test,ids_test) \n print('DONE') \n #5.b. prediction on each model\n y_pred = list()\n \n for split,(y_test_s,tx_test_s,id_test_s) in enumerate(zip(y_test_split,tx_test_split,id_test_split)): \n print('PREDICTION FOR TESTING DATA SPLIT NUMBER',split)\n \n #Formatting to the correct datatype\n y_test_s = np.squeeze(y_test_s)\n tx_test_s = np.squeeze(tx_test_s)\n id_test_s = np.squeeze(id_test_s)\n print('Size of the vectors',y_test_s.shape,tx_test_s.shape) \n #Formatting the data themselves\n print('Counting NaN',end='. ')\n tx_test_s = count_NaN(tx_test_s)\n print('Sanitizing',end = ' . ')\n tx_test_s,median_vec = sanitize_NaN(tx_test_s,median_split[split])\n print('Standardizing',end = ' .')\n tx_test_s,mean_te,std_te = standardize(tx_test_s,mean_split[split],std_split[split])\n print('Building polynomial basis') \n tx_test_s = build_poly(tx_test_s, degrees_split[split])\n \n #Prediction\n y_pred.append(predict_labels(np.array(weight_split[split]), np.array(tx_test_s))) \n \n print('MERGING TESTING DATA',end=\"\")\n y_pred_merged, ids_merged = merge_dataset(y_pred,id_test_split)\n print('DONE')\n \n OUTPUT_PATH = 'results/output_sanitized_normalization_'+export_file+'.csv' \n print('EXPORTING TESTING DATA WITH PREDICTIONS :',end=\" \")\n \n create_csv_submission(ids_merged, y_pred_merged, OUTPUT_PATH)\n print('DONE')","def create_final_strategy(filename: str, columns_list: List[str], som_width=Config.som_width,\n som_height=Config.som_height, n_iter=Config.n_iter, sigma=Config.sigma,\n learning_rate=Config.learning_rate) -> tuple:\n\n print(\n f'Creating final strategy for parameters: \\nmap_size: {som_height}\\nn_iter: {n_iter}\\nsigma:{sigma}\\nlr: {learning_rate}')\n # get prepared data\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\n\n # train som\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\n sigma=sigma, learning_rate=learning_rate)\n\n # get profit per cluster in train datasets\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\n\n assert len(df_profit_per_cluster_train) >= 3, \"Algorithm, returned less than 3 clusters.\"\n\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\n group_size = int(len(df_profit_per_cluster) / 3)\n\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\n\n return final_df_train, final_df_test, buy_clusters_list, sell_clusters_list","def load_data(self,split='train'):\n raise NotImplementedError","def read_data_split_and_search():\n\n\n\n dataReader = Movielens10MReader()\n dataset = dataReader.load_data()\n\n URM_train, URM_test = split_train_in_two_percentage_global_sample(dataset.get_URM_all(), train_percentage = 0.80)\n URM_train, URM_validation = split_train_in_two_percentage_global_sample(URM_train, train_percentage = 0.80)\n\n output_folder_path = \"result_experiments/\"\n\n\n # If directory does not exist, create\n if not os.path.exists(output_folder_path):\n os.makedirs(output_folder_path)\n\n\n\n\n\n\n\n collaborative_algorithm_list = [\n Random,\n TopPop,\n P3alphaRecommender,\n RP3betaRecommender,\n ItemKNNCFRecommender,\n UserKNNCFRecommender,\n MatrixFactorization_BPR_Cython,\n MatrixFactorization_FunkSVD_Cython,\n PureSVDRecommender,\n SLIM_BPR_Cython,\n SLIMElasticNetRecommender\n ]\n\n\n\n\n from Base.Evaluation.Evaluator import EvaluatorHoldout\n\n evaluator_validation = EvaluatorHoldout(URM_validation, cutoff_list=[5])\n evaluator_test = EvaluatorHoldout(URM_test, cutoff_list=[5, 10])\n\n\n runParameterSearch_Collaborative_partial = partial(runParameterSearch_Collaborative,\n URM_train = URM_train,\n metric_to_optimize = \"MAP\",\n n_cases = 10,\n evaluator_validation_earlystopping = evaluator_validation,\n evaluator_validation = evaluator_validation,\n evaluator_test = evaluator_test,\n output_folder_path = output_folder_path,\n similarity_type_list = [\"cosine\"],\n parallelizeKNN = False)\n\n\n\n\n\n pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)\n pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)\n\n #\n #\n # for recommender_class in collaborative_algorithm_list:\n #\n # try:\n #\n # runParameterSearch_Collaborative_partial(recommender_class)\n #\n # except Exception as e:\n #\n # print(\"On recommender {} Exception {}\".format(recommender_class, str(e)))\n # traceback.print_exc()\n #","def split_data(basedir, data_split=0.80):\n manip = data_manipulator(basedir)\n manip.train_test_split(data_split=data_split)","def generate_data(project_data, config, split_method = RAW) :\n training_data = []\n testing_data = []\n \n # Flatten the data (collapse the project and session hierarchy into a list of session_data)\n for v in config.train_project_names:\n # Data in all sessions of one project\n project_session_data = random.sample(project_data[v], len(project_data[v]))\n\n training_data += project_session_data[int(config.session_training_percentage[0] * len(project_session_data)):\n int(config.session_training_percentage[1] * len(project_session_data))]\n\n if config.double_training:\n for i in xrange(int(config.session_training_percentage[0] * len(project_session_data)),\n int(config.session_training_percentage[1] * len(project_session_data))):\n session_data = project_session_data[i]\n\n reversed_session_data = {}\n reversed_session_data[SESSION_NAME] = session_data[SESSION_NAME] + \"_reversed\"\n reversed_session_data[SESSION_EVENTS] = []\n\n def reverse_point_data_qsr(point_data):\n reversed_point_data = point_data[:4]\n # Hands to objects feature swap\n reversed_point_data += point_data[8:12] \n reversed_point_data += point_data[4:8]\n\n # Centroid direction and distance difference is symmetric\n reversed_point_data += point_data[12:14]\n\n # Object corners swap\n reversed_point_data += point_data[16:18] \n reversed_point_data += point_data[14:16]\n\n reversed_point_data += point_data[18:19]\n reversed_point_data += point_data[20:21] \n reversed_point_data += point_data[19:20]\n\n # For QTCCS\n reversed_point_data += point_data[22:23]\n reversed_point_data += point_data[21:22]\n reversed_point_data += point_data[24:25]\n reversed_point_data += point_data[23:24]\n\n # # For difference of features\n # fl = 21\n # reversed_point_data += point_data[fl:fl + 4]\n # # Hands to objects feature swap\n # reversed_point_data += point_data[fl + 8:fl + 12] \n # reversed_point_data += point_data[fl + 4:fl + 8]\n\n # # Centroid direction and distance difference is symmetric\n # reversed_point_data += point_data[fl + 12:fl + 14]\n\n # # Object corners swap\n # reversed_point_data += point_data[fl + 16:fl + 18] \n # reversed_point_data += point_data[fl + 14:fl + 16]\n\n # reversed_point_data += point_data[fl + 18:fl + 19]\n # reversed_point_data += point_data[fl + 20:fl + 21] \n # reversed_point_data += point_data[fl + 19:fl + 20]\n\n return reversed_point_data\n\n def reverse_point_data_sparse_qsr(point_data):\n reversed_point_data = point_data[:2 * 56]\n # Hands to objects feature swap\n reversed_point_data += point_data[4 * 56:6 * 56] \n reversed_point_data += point_data[2 * 56:4 * 56]\n\n # Centroid direction and distance difference is symmetric\n reversed_point_data += point_data[6 * 56:7 * 56]\n\n # Object corners swap\n reversed_point_data += point_data[8 * 56:9 * 56] \n reversed_point_data += point_data[7 * 56:8 * 56]\n\n anchor = 9 * 56\n reversed_point_data += point_data[anchor:anchor + 2]\n reversed_point_data += point_data[anchor + 2 * 2:anchor + 3 * 2] \n reversed_point_data += point_data[anchor + 2:anchor + 2 * 2]\n\n anchor = 9 * 56 + 3 * 2\n # For QTCCS\n reversed_point_data += point_data[anchor + 3:anchor + 2 * 3]\n reversed_point_data += point_data[anchor:anchor + 3]\n reversed_point_data += point_data[anchor + 3 * 3:anchor + 4 * 3]\n reversed_point_data += point_data[anchor + 2 * 3:anchor + 3 * 3]\n\n return reversed_point_data\n\n reversed_session_data[SESSION_DATA] = []\n for point_data in session_data[SESSION_DATA]:\n if split_method == RAW:\n reversed_point_data = point_data[:39]\n reversed_point_data += point_data[51:63]\n reversed_point_data += point_data[39:51]\n elif split_method == PCAS:\n reversed_point_data = point_data[:6]\n # Object centroid swap\n reversed_point_data += point_data[8:10] \n reversed_point_data += point_data[6:8]\n # Object corners swap\n reversed_point_data += point_data[14:18] \n reversed_point_data += point_data[10:14]\n elif split_method == QSR or split_method == EVENT:\n reversed_point_data = reverse_point_data_qsr(point_data)\n elif split_method == SPARSE_QSR:\n reversed_point_data = reverse_point_data_sparse_qsr(point_data)\n\n reversed_session_data[SESSION_DATA].append(reversed_point_data)\n\n for event_str in session_data[SESSION_EVENTS]:\n reversed_event_str = {}\n for key in event_str:\n reversed_event_str[key] = event_str[key]\n\n subj, obj, theme, event, prep = event_str['label']\n def swap_objects(value):\n if value == 2:\n return 3\n if value == 3:\n return 2\n return value\n\n reversed_event_str['label'] = (swap_objects(subj), swap_objects(obj), swap_objects(theme), event, prep)\n\n reversed_session_data[SESSION_EVENTS].append(reversed_event_str)\n\n training_data.append(reversed_session_data)\n\n\n testing_data += project_session_data[int(config.session_testing_percentage[0] * len(project_session_data)):\n int(config.session_testing_percentage[1] * len(project_session_data))]\n \n return (training_data, testing_data)","def test_split_data(self, whp_pandas):\n test_class = Slug_Forecasting(whp_pandas.copy())\n test_class.stationarity_check()\n test_class.split_data()\n\n assert hasattr(test_class, \"y_train\"), \"y_train attribute must have been create\"\n assert hasattr(test_class, \"y_pred\"), \"y_test attribute must have been create\"\n\n assert len(test_class.y_train) == 180, \"In this example, y_train should be 180 long\"\n assert len(test_class.y_pred) == 60, \"In this example, y_pred should be 60 long\"\n\n test_class = Slug_Forecasting(whp_pandas.copy())\n\n # test train size data\n try:\n test_class.split_data(train_size=400)\n print(\"Not enough data to fulfill train_size requirement\")\n raise ValueError\n except AssertionError:\n pass","def __init__(self, h5_path='../dataset/lob.h5', split=1,\n train=True, n_window=1, normalization='std', epsilon=1e-15, horizon=0, shift=None):\n\n self.window = n_window\n\n assert 0 <= split <= 8\n assert 0 <= horizon <= 2\n\n # Translate the prediction to horizon to the data\n if horizon == 1:\n horizon = 3\n elif horizon == 2:\n horizon = 4\n\n # Load the data\n file = h5py.File(h5_path, 'r', )\n features = np.float32(file['features'])\n targets = np.int32(file['targets'])\n day_train_split_idx = file['day_train_split_idx'][:].astype('bool')\n day_test_split_idx = file['day_test_split_idx'][:].astype('bool')\n stock_idx = file['stock_idx'][:].astype('bool')\n file.close()\n\n # Get the data for the specific split and setup (train/test)\n if train:\n idx = day_train_split_idx[split]\n\n # Get the statistics needed for normalization\n if normalization == 'std':\n self.mean = np.mean(features[idx], axis=0)\n self.std = np.std(features[idx], axis=0)\n features = (features - self.mean) / (self.std + epsilon)\n else:\n idx = day_test_split_idx[split]\n\n if shift is not None:\n print(\"testing shift = \", shift)\n # Shift the testing features only\n features[idx] += shift[0]*np.mean(features, axis=0)\n features[idx] *= shift[1]\n\n\n # Also get the train data to normalize the test data accordingly (if needed)\n if normalization == 'std':\n train_idx = day_train_split_idx[split]\n self.mean = np.mean(features[train_idx], axis=0)\n self.std = np.std(features[train_idx], axis=0)\n features = (features - self.mean) / (self.std + epsilon)\n del train_idx\n\n # Get the data per stock\n self.features_per_stock = []\n self.labels = []\n for i in range(len(stock_idx)):\n cur_idx = np.logical_and(idx, stock_idx[i])\n self.features_per_stock.append(features[cur_idx])\n self.labels.append(targets[cur_idx, horizon])\n\n # Create a lookup table to find the correct stock\n self.look_up_margins = []\n current_sum = 0\n for i in range(len(self.features_per_stock)):\n # Remove n_window since they are used to ensure that we are always operate on a full window\n cur_limit = self.features_per_stock[i].shape[0] - n_window - 1\n current_sum += cur_limit\n self.look_up_margins.append(current_sum)\n\n\n # Get the total number of samples\n self.n = self.look_up_margins[-1]\n self.n_stocks = len(self.look_up_margins)","def train(self,path,mode):\n if mode == \"porto\":\n self.prepare_data(path)\n else:\n self.prepare_sumo_data(path)\n self.poly_regression()","def __init__(self, scoring_function=None, partition_index=0):\n self.trained_data = dict()\n self.scoring_function = scoring_function or diff_score\n self.last_pred = []\n self.partitions = dict()\n self.partition_index = partition_index","def prepare_data(dataset, train_ratio=0.8, input_dim=None, seed=10):\n # Retrieve main path of project\n dirname = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))\n\n # Download and store dataset at chosen location\n if dataset == 'Cora' or dataset == 'PubMed' or dataset == 'Citeseer':\n path = os.path.join(dirname, 'data')\n data = Planetoid(path, name=dataset, split='full')[0]\n data.name = dataset\n data.num_classes = (max(data.y)+1).item()\n # data.train_mask, data.val_mask, data.test_mask = split_function(data.y.numpy())\n # data = Planetoid(path, name=dataset, split='public', transform=T.NormalizeFeatures(), num_train_per_class=20, num_val=500, num_test=1000)\n\n elif dataset == 'Amazon':\n path = os.path.join(dirname, 'data', 'Amazon')\n data = Amazon(path, 'photo')[0]\n data.name = dataset\n data.num_classes = (max(data.y)+1).item()\n data.train_mask, data.val_mask, data.test_mask = split_function(\n data.y.numpy(), seed=seed)\n # Amazon: 4896 train, 1224 val, 1530 test\n \n elif dataset in ['syn1', 'syn2', 'syn4', 'syn5']: \n data = synthetic_data(\n dataset, dirname, train_ratio, input_dim)\n \n elif dataset == 'syn6':\n data = gc_data(dataset, dirname, train_ratio)\n\n elif dataset == 'Mutagenicity':\n data = gc_data(dataset, dirname, train_ratio)\n\n return data","def split_data_metrics_learning(cfg):\n actual_pose = cfg['actual_pose']\n target = cfg['target']\n person_ids = cfg['person_ids']\n \n # Split train and val data based on the person ids.\n all_ids = np.arange(1, 21)\n val_ids = cfg['val_ids']\n train_ids = set(all_ids).symmetric_difference(val_ids)\n \n anchor_gallery_split_size = cfg['anchor_gallery_split_size']\n window_width = cfg['window_width']\n overlap = cfg['overlap']\n random_state = cfg['random_state']\n \n # Get only the training set data and the label.\n X_train, y_train = get_req_ids(actual_pose, target, train_ids, person_ids)\n \n # Select the evaluation data that measures the performance of the model on the training set.\n train_accuracy_ids = random.sample(train_ids, len(val_ids))\n X_train_acc, y_train_acc = get_req_ids(actual_pose, target, train_accuracy_ids, person_ids)\n \n # Anchor/Gallery set split for the training set.\n X_train_gal, X_train_anchor, y_train_gal, y_train_anchor = train_test(X_train = X_train_acc, y_train = y_train_acc, \n test_size=anchor_gallery_split_size, \n random_state=random_state, stratify=y_train_acc)\n \n # Subsample the gait sequences of the anchor/gallery set of the training set based on the window width and the overlap.\n X_train_gal, y_train_gal = subsample(cfg, X_train_gal, y_train_gal, window_width=window_width, overlap=overlap)\n X_train_anchor, y_train_anchor = subsample(cfg, X_train_anchor, y_train_anchor, window_width=window_width, overlap=overlap)\n \n # Get only the validation set data and the label.\n X_val, y_val = get_req_ids(actual_pose, target, val_ids, person_ids)\n \n # Anchor/Gallery set split for the validation set.\n X_val_gal, X_val_anchor, y_val_gal, y_val_anchor = train_test(X_train = X_val, \n y_train = y_val, \n test_size=anchor_gallery_split_size, \n random_state=random_state, \n stratify=y_val)\n \n \n # If data augmentation parameter is set to True in the configuration dictionary, data augmentation is done for the training set.\n if cfg['augment_data']:\n X_train, y_train = augment_data(X_train, y_train)\n \n # Subsample the gait sequences of the whole training set based on the window width and the overlap.\n X_train, y_train = subsample(cfg, X_train, y_train, window_width=window_width, overlap=overlap)\n \n # Subsample the gait sequences of the anchor/gallery set of the validation set based on the window width and the overlap.\n X_val_gal, y_val_gal = subsample(cfg, X_val_gal, y_val_gal, window_width=window_width, overlap=overlap)\n X_val_anchor, y_val_anchor = subsample(cfg, X_val_anchor, y_val_anchor, window_width=window_width, overlap=overlap)\n \n # Concatenate the gallery and anchor set of the validation data and label as a whole. This is just to maintain the train-val uniformity and \n # is not used anywhere in the project.\n X_val, y_val = np.concatenate((X_val_gal, X_val_anchor)), np.concatenate((y_val_gal, y_val_anchor))\n \n return X_train, X_val, X_train_gal, X_train_anchor, X_val_gal, X_val_anchor, y_train, y_val, y_train_gal, y_train_anchor, y_val_gal, y_val_anchor","def main(input_filepath, output_filepath):\n\n logging.info(\"reading %s\", input_filepath)\n train_test = pd.read_hdf(input_filepath, 'train_test')\n meta = pd.read_hdf(input_filepath, 'meta')\n meta_org = pd.read_hdf(input_filepath, 'meta_org')\n\n sel_series = train_test[train_test.entry_type.isin(['train', 'cold_start'])]\\\n ['series_id'].unique()\n train_series, validate_series = train_test_split(sel_series, random_state=1)\n\n logging.info(\"calc train_test\")\n train_test = calc_final_features(train_test, meta, meta_org=meta_org, verbose=True)\n\n sel = train_test[train_test.entry_type.isin(['train', 'cold_start'])]\n train = sel[sel.series_id.isin(train_series)]\n validate = sel[sel.series_id.isin(validate_series)]\n test = train_test[train_test.entry_type.isin(['test'])]\n\n logging.info(\"writing %s\", output_filepath)\n train.to_hdf(output_filepath, \"train\", mode=\"w\")\n validate.to_hdf(output_filepath, \"validate\", mode=\"a\")\n test.to_hdf(output_filepath, \"test\", mode=\"a\")\n for k in ['meta', 'submission']:\n df = pd.read_hdf(input_filepath, k)\n df.to_hdf(output_filepath, k, mode=\"a\")","def main():\n datasets = {}\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\"Processing datasets and fitting base models\"):\n logger.info(f\"processing dataset {dataset_name}\")\n clusters_path: Optional[str] = None\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \"_clusters.json\")\n train_pairs_path = None\n val_pairs_path = None\n test_pairs_path = None\n else:\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \"train_pairs.csv\")\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \"val_pairs.csv\")\n if not os.path.exists(val_pairs_path):\n val_pairs_path = None\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \"test_pairs.csv\")\n\n logger.info(f\"loading dataset {dataset_name}\")\n anddata = ANDData(\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_signatures.json\"),\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_papers.json\"),\n name=dataset_name,\n mode=\"train\",\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \"_specter.pickle\"),\n clusters=clusters_path,\n block_type=BLOCK_TYPE,\n train_pairs=train_pairs_path,\n val_pairs=val_pairs_path,\n test_pairs=test_pairs_path,\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\n val_pairs_size=N_VAL_TEST_SIZE,\n test_pairs_size=N_VAL_TEST_SIZE,\n preprocess=True,\n )\n\n logger.info(f\"featurizing {dataset_name}\")\n train, val, test = featurize(\n anddata,\n FEATURIZER_INFO,\n n_jobs=N_JOBS,\n use_cache=True,\n chunk_size=100,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\n nan_value=NAN_VALUE,\n )\n X_train, y_train, nameless_X_train = train\n X_val, y_val, nameless_X_val = val\n X_test, y_test, nameless_X_test = test\n\n dataset = {}\n dataset[\"anddata\"] = anddata\n dataset[\"X_train\"] = X_train\n dataset[\"y_train\"] = y_train\n dataset[\"X_val\"] = X_val\n dataset[\"y_val\"] = y_val\n dataset[\"X_test\"] = X_test\n dataset[\"y_test\"] = y_test\n dataset[\"nameless_X_train\"] = nameless_X_train\n dataset[\"nameless_X_val\"] = nameless_X_val\n dataset[\"nameless_X_test\"] = nameless_X_test\n dataset[\"name\"] = anddata.name\n datasets[dataset_name] = dataset\n\n anddatas = [\n datasets[dataset_name][\"anddata\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in PAIRWISE_ONLY_DATASETS\n ]\n\n X_train = np.vstack([datasets[dataset_name][\"X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n y_train = np.hstack([datasets[dataset_name][\"y_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n X_val = np.vstack(\n [datasets[dataset_name][\"X_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n y_val = np.hstack(\n [datasets[dataset_name][\"y_val\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\"augmented\"}]\n )\n\n nameless_X_train = np.vstack([datasets[dataset_name][\"nameless_X_train\"] for dataset_name in SOURCE_DATASET_NAMES])\n nameless_X_val = np.vstack(\n [\n datasets[dataset_name][\"nameless_X_val\"]\n for dataset_name in SOURCE_DATASET_NAMES\n if dataset_name not in {\"augmented\"}\n ]\n )\n\n logger.info(\"fitting pairwise\")\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\n union_classifier.fit(X_train, y_train, X_val, y_val)\n\n nameless_union_classifier = None\n if USE_NAMELESS_MODEL:\n logger.info(\"nameless fitting pairwise for \" + str(SOURCE_DATASET_NAMES))\n nameless_union_classifier = PairwiseModeler(\n n_iter=N_ITER,\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\n )\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\n logger.info(\"nameless pairwise fit for \" + str(SOURCE_DATASET_NAMES))\n\n logger.info(\"fitting clusterer for\")\n union_clusterer = Clusterer(\n FEATURIZER_INFO,\n union_classifier.classifier,\n cluster_model=FastCluster(),\n search_space=search_space,\n n_jobs=N_JOBS,\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\n )\n union_clusterer.fit(anddatas)\n print(\n \"best clustering parameters:\",\n union_clusterer.best_params,\n )\n\n models = {}\n models[\"clusterer\"] = union_clusterer\n\n with open(\n f\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\",\n \"wb\",\n ) as _pickle_file:\n pickle.dump(models, _pickle_file)\n logger.info(\"Done.\")","def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\n distribute_training=False):\n train_set = np.array(train_set)\n test_set = np.array(test_set)\n\n print(\"The shape of training set before dimension reduction is {0}\".format(train_set.shape))\n print(\"The shape of test set before dimension reduction is {0}\".format(test_set.shape))\n print('Use distribute training ? >> {0}'.format(distribute_training))\n reg = linear_model.BayesianRidge()\n\n if dimension_reduce:\n pca = PCA(n_components=128)\n train_set = pca.fit_transform(train_set)\n test_set = pca.fit_transform(test_set)\n\n print(\"The shape of training set after dimension reduction is {0}\".format(train_set.shape))\n print(\"The shape of test set after dimension reduction is {0}\".format(test_set.shape))\n\n if not distribute_training:\n reg.fit(train_set, train_label)\n else:\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\n train_label), da.array(test_label)\n reg.fit(train_set, train_label)\n\n predicted_label = reg.predict(test_set)\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\n\n mkdirs_if_not_exist('./model')\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\n print('The regression model has been persisted...')\n\n mkdirs_if_not_exist('./result')\n\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\n\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\n df.to_csv('./result/%s.csv' % data_name, index=False)\n print('The result csv file has been generated...')","def split_dataset(self, split):\n trunk_pos_size = math.ceil((1 - split) * len(self.Pos))\n trunk_neg_size = math.ceil((1 - split) * len(self.Neg))\n trunk_num = int(1 / (1 - split))\n pos_temp = list()\n neg_temp = list()\n for index in range(trunk_num):\n pos_temp.append(self.Pos[index * trunk_pos_size:(index + 1) *\n trunk_pos_size])\n neg_temp.append(self.Neg[index * trunk_neg_size:(index + 1) *\n trunk_neg_size])\n self.test = pos_temp.pop(2) + neg_temp.pop(2)\n # self.train = [i for item in pos_temp + neg_temp for i in item]\n self.train = []\n for item in pos_temp + neg_temp:\n for i in item:\n self.train.append(i)\n\n random.shuffle(self.train)\n random.shuffle(self.test)","def train(self, algorithm):\n\n kfold = StratifiedKFold(10, True, 1)\n f1_score = []\n precision_score = []\n recall_score = []\n for train, test in kfold.split(self.data_training, self.data_target):\n model = algorithm.fit(self.data_training.iloc[train], self.data_target.iloc[train])\n scores = self.score_model(model, self.data_training.iloc[test], self.data_target.iloc[test])\n f1_score.append(scores[0])\n precision_score.append(scores[1])\n recall_score.append(scores[2])\n\n self.print_results(f1_score, precision_score, recall_score)","def main():\n df = prepro_last()\n X, y = train_build(df)\n fit_store(X, y)","def main(cls, args):\n #cls.trainOfflineAndTest(100, 0.1, 0.1, 0.9);\n #cls.trainOfflineAndTest(500, 0.1, 0.1, 1.0);\n\n cls.trainer.teachActiveAndSaveStatistics(\"onlineTest\", 10, 0.8, 1.0 ,1.0, 0.0, 0.3, True, True,True);\n cls.trainer.teachActiveAndSaveStatistics(\"path\", 10, 0.0, 0.0, 0.0, 0.0, 0.0, True, False, False)\n\n #trainer.teachActiveAndSaveStatistics(\"onlineTest\", 10000, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f,true, true, true);\n # \t\ttrainer.teachActiveAndSaveStatistics(\"onlineTest\", 10000, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f,\n # \t\t\t\tfalse, true, true);\n # \t\t\n # \t\ttestAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1_first.net\", 10000, true);\n # \t\ttestAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1_secound.net\", 10000, true);\n #cls.testAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1_first.net\", 10000, False)\n #cls.testAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1_secound.net\", 10, False)\n # \t\ttestAgentFromFileWithOutLearning(\"net10000_a0.1_b0.1g_1.0e_0.1.net\", 10000, false);","def split_data(self,test=False):\n shuffle_index = torch.randperm(self.train_target.shape[0])\n load = shuffle_index.shape[0]\n train_input_shuffle = self.train_input[shuffle_index]\n train_target_shuffle = self.train_target[shuffle_index]\n train_classes_shuffle = self.train_classes[shuffle_index]\n index_train = self.index_for_equal_class(train_target_shuffle[:load//2])\n train_input = train_input_shuffle[index_train]\n train_target = train_target_shuffle[index_train]\n train_classes = train_classes_shuffle[index_train]\n if not test:\n index_test = self.index_for_equal_class( train_target_shuffle[load//2:]) + load//2\n test_input = train_input_shuffle[index_test]\n test_target = train_target_shuffle[index_test]\n test_classes = train_classes_shuffle[index_test]\n else:\n index_test = self.index_for_equal_class(self.test_target)\n test_input = self.test_input[index_test]\n test_target = self.test_target[index_test]\n test_classes = self.test_classes[index_test]\n train_input, mean, std = normalize(train_input)\n test_input, _, _ = normalize(test_input,mean,std)\n return train_input, train_target, train_classes ,test_input ,test_target ,test_classes","def split_train_test_classifier(self, split_method, method):\n \n # split data balance based on user and act (if provided)\n if method == 'window_based':\n data_train, data_val, label_user_train, label_user_val, id_window_train, id_window_val = self.split_train_val_classifier(\n self.classifier['data'], self.classifier['user_label'], self.classifier['act_label'], self.classifier['id'], 'standard', train_size=0.9) \n\n print(f'Train window before delete overlap sequence: {data_train.shape[0]}')\n\n # delete overlap sequence\n if self.overlap != 0:\n if self.overlap == 0.5:\n distance_to_delete = [1]\n elif self.overlap == 0.75:\n distance_to_delete = [1,2,3]\n invalid_idx = delete_overlap(id_window_train, id_window_val, distance_to_delete)\n data_train = np.delete(data_train, invalid_idx, axis=0)\n label_user_train = np.delete(label_user_train, invalid_idx, axis=0)\n\n print(f'Train window after delete overlap sequence: {data_train.shape[0]}')\n print(f'Validation set: {data_val.shape[0]}')\n \n elif method == 'cycle_based':\n data_train, data_val, label_user_train, label_user_val = self.split_train_val_classifier(\n self.classifier['data'], self.classifier['user_label'], self.classifier['act_label'], None, split_method, train_size=0.9) \n\n self.train = data_train\n self.train_user = label_user_train\n self.val = data_val\n self.val_user = label_user_val","def train_model_pipeline(conform_shape=True, indi_proportion=0.50, incl_group_imgs=True,\r\n feature_extractor=flatten_array, model=train_logistic_regression): \r\n # Create dataframe subject to feature extractor requirements\r\n X_train, y_train, X_test_indi, y_test_indi, X_test_group, y_test_group = \\\r\n create_train_test_sets(conform_shape=conform_shape, indi_proportion=indi_proportion, \r\n incl_group_imgs=incl_group_imgs)\r\n \r\n # Extract features\r\n if feature_extractor == extract_ORB_features:\r\n if os.path.isfile('Trained_Models/Kmeans_model.sav'):\r\n kmeans_model = load_model('Trained_Models/Kmeans_model.sav')\r\n else:\r\n kmeans_model = kmeans_cluster(X_train, 500)\r\n X_train = feature_extractor(X_train, kmeans_model, normalize = False)\r\n X_test_indi = feature_extractor(X_test_indi, kmeans_model, normalize = False)\r\n X_test_group = feature_extractor(X_test_group, kmeans_model, normalize = False)\r\n\r\n else:\r\n X_train = feature_extractor(X_train)\r\n X_test_indi = feature_extractor(X_test_indi)\r\n X_test_group = feature_extractor(X_test_group)\r\n \r\n # Train model on flattened array (no feature extraction)\r\n trained_model = model(X_train, y_train)\r\n \r\n indi_pred_class, indi_accuracy = evaluate_model(trained_model, X_test_indi, y_test_indi)\r\n group_pred_class, group_accuracy = evaluate_model(trained_model, X_test_group, y_test_group)\r\n \r\n return trained_model, indi_pred_class, indi_accuracy, group_pred_class, group_accuracy","def train(cfg):\n # Set up environment.\n distributed.init_distributed_training(cfg)\n\n # Set random seed from configs.\n np.random.seed(cfg.RNG_SEED)\n torch.manual_seed(cfg.RNG_SEED)\n\n # Print config.\n if distributed.is_master_proc():\n print(\"Train with config:\")\n print(pprint.pformat(cfg))\n\n # Create train and val loaders.\n train_dataset = PanopticNarrativeGroundingDataset(cfg, cfg.DATA.TRAIN_SPLIT, train=True)\n train_loader = DataLoader(\n train_dataset,\n batch_size=int(cfg.TRAIN.BATCH_SIZE / max(1, cfg.NUM_GPUS)),\n shuffle=(False if cfg.NUM_GPUS > 1 else True),\n sampler=(DistributedSampler(train_dataset) if cfg.NUM_GPUS > 1 else None),\n num_workers=cfg.DATA_LOADER.NUM_WORKERS,\n pin_memory=cfg.DATA_LOADER.PIN_MEMORY\n )\n if cfg.DATA.VAL_SPLIT is not None:\n val_dataset = PanopticNarrativeGroundingDataset(cfg, cfg.DATA.VAL_SPLIT, train=False)\n val_loader = DataLoader(\n val_dataset,\n batch_size=(1 if cfg.NUM_GPUS > 1 else cfg.TRAIN.BATCH_SIZE),\n shuffle=False,\n sampler=(DistributedSampler(val_dataset) if cfg.NUM_GPUS > 1 else None),\n num_workers=cfg.DATA_LOADER.NUM_WORKERS,\n pin_memory=cfg.DATA_LOADER.PIN_MEMORY\n )\n\n # Build the model and print model statistics.\n # Use cuda if available\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n # Construct the model\n model = PanopticNarrativeGroundingBaseline(cfg, device=device)\n # Determine the GPU used by the current process\n cur_device = torch.cuda.current_device()\n # Transfer the model to the current GPU device\n model = model.cuda(device=cur_device)\n # Use multi-process data parallel model in the multi-gpu setting\n if cfg.NUM_GPUS > 1:\n # Make model replica operate on the current device\n model = torch.nn.parallel.DistributedDataParallel(\n module=model, device_ids=[cur_device], output_device=cur_device,\n find_unused_parameters=True\n )\n if cfg.LOG_MODEL_INFO and distributed.is_master_proc():\n print(\"Model:\\n{}\".format(model))\n print(\"Params: {:,}\".format(np.sum([p.numel() for p in model.parameters()]).item()))\n print(\"Mem: {:,} MB\".format(torch.cuda.max_memory_allocated() / 1024 ** 3))\n print(\"nvidia-smi\")\n os.system(\"nvidia-smi\")\n\n if cfg.MODEL.BERT_FREEZE:\n if cfg.NUM_GPUS > 1:\n for param in model.module.bert_encoder.model.bert.encoder.layer.parameters():\n param.requires_grad = False\n else:\n for param in model.bert_encoder.model.bert.encoder.layer.parameters():\n param.requires_grad = False\n\n # Construct the optimizer.\n def optimizer_wrapper(Optim, **kwargs):\n def init_func(model):\n return Optim(model.parameters(), **kwargs)\n return init_func\n\n optimizers = {\n \"adamax\": (\n optimizer_wrapper(optim.Adamax, lr=cfg.SOLVER.BASE_LR),\n lambda optim: optim.param_groups[0][\"lr\"],\n ),\n \"adam\": (\n optimizer_wrapper(optim.Adam, lr=cfg.SOLVER.BASE_LR),\n lambda optim: optim.param_groups[0][\"lr\"],\n ),\n \"sgd\": (\n optimizer_wrapper(optim.SGD, lr=cfg.SOLVER.BASE_LR, momentum=0.9),\n lambda optim: optim.param_groups[0][\"lr\"],\n ),\n }\n\n if cfg.SOLVER.OPTIMIZING_METHOD not in optimizers:\n cfg.SOLVER.OPTIMIZING_METHOD = 'adam'\n if distributed.is_master_proc():\n print(\"{0} not defined in available optimizer list, fallback to Adam\")\n\n optimizer, _ = optimizers[cfg.SOLVER.OPTIMIZING_METHOD]\n optimizer = optimizer(model)\n if distributed.is_master_proc():\n print('optimizer: {}'.format(optimizer))\n\n # Load a checkpoint to resume training if applicable.\n checkpoint_path = osp.join(cfg.OUTPUT_DIR, 'checkpoint.pth')\n if osp.exists(checkpoint_path):\n if distributed.is_master_proc():\n print('Resuming training: loading model from: {0}'.format(checkpoint_path))\n checkpoint = torch.load(checkpoint_path, map_location=\"cpu\")\n if cfg.NUM_GPUS > 1:\n model.module.load_state_dict(checkpoint['model_state'])\n else:\n model.load_state_dict(checkpoint['model_state'])\n optimizer.load_state_dict(checkpoint['optimizer_state'])\n start_epoch = checkpoint['epoch'] + 1\n model_final_path = osp.join(cfg.OUTPUT_DIR, 'model_final.pth')\n if osp.exists(model_final_path):\n model_final = torch.load(model_final_path)\n best_val_score = model_final['accuracy']\n else:\n best_val_score = None\n elif osp.exists(cfg.TRAIN.CHECKPOINT_FILE_PATH):\n if distributed.is_master_proc():\n print('Loading model from: {0}'.format(cfg.TRAIN.CHECKPOINT_FILE_PATH))\n checkpoint = torch.load(cfg.TRAIN.CHECKPOINT_FILE_PATH, map_location=\"cpu\")\n if cfg.NUM_GPUS > 1:\n model.module.load_state_dict(checkpoint['model_state'])\n else:\n model.load_state_dict(checkpoint['model_state'])\n start_epoch, best_val_score = 0, None\n else: \n start_epoch, best_val_score = 0, None\n\n # Define loss function\n loss_function = nn.BCEWithLogitsLoss()\n\n if distributed.is_master_proc():\n print('Train begins...')\n if cfg.TRAIN.EVAL_FIRST:\n accuracy = evaluate(val_loader, model, -1, cfg)\n if best_val_score is None or accuracy > best_val_score:\n best_val_score = accuracy\n try:\n # Perform the training loop\n for epoch in range(start_epoch, cfg.SOLVER.MAX_EPOCH):\n epoch_start_time = time.time()\n # Shuffle the dataset\n if cfg.NUM_GPUS > 1:\n train_loader.sampler.set_epoch(epoch)\n # Train for one epoch\n train_loss = train_epoch(train_loader, model, optimizer, loss_function, epoch, cfg)\n accuracy = evaluate(val_loader, model, epoch, cfg) \n\n if distributed.is_master_proc():\n # Save best model in the validation set\n if best_val_score is None or accuracy > best_val_score:\n best_val_score = accuracy\n model_final_path = osp.join(cfg.OUTPUT_DIR, 'model_final.pth')\n model_final = {\n \"epoch\": epoch,\n \"model_state\": model.state_dict(),\n \"optimizer_state\": optimizer.state_dict(),\n \"accuracy\": accuracy\n }\n torch.save(model_final, model_final_path)\n print('-' * 89)\n print('| end of epoch {:3d} | time: {:5.2f}s '\n '| epoch loss {:.6f} |'.format(\n epoch, time.time() - epoch_start_time, train_loss))\n print('-' * 89)\n except KeyboardInterrupt:\n if distributed.is_master_proc():\n print('-' * 89)\n print('Exiting from training early')","def init_data(dataset_config: dict):\n # train and dev will be in random order, test may be ordered according to labels\n if dataset_config[\"name\"] == \"CoLA\":\n train, dev, test, num_classes = load_cola(dataset_config)\n elif dataset_config[\"name\"] == \"AGNews\":\n train, dev, test, num_classes = load_ag_news(dataset_config)\n elif dataset_config[\"name\"] == \"DBPedia\":\n train, dev, test, num_classes = load_dbpedia(dataset_config)\n elif dataset_config[\"name\"] == \"YRF\":\n train, dev, test, num_classes = load_yrf(dataset_config)\n else:\n raise NameError(f\"Dataset {dataset_config['name']} not implemented.\")\n # etc.\n\n # shrink size if debugging\n if dataset_config[\"debug\"]:\n # choose a random subset using huggingface select function\n train = train.select(random.sample(range(len(train)), k=200))\n dev = dev.select(random.sample(range(len(dev)), k=40))\n test = test.select(random.sample(range(len(test)), k=200))\n\n # create class imbalance\n random.seed(dataset_config[\"seed\"])\n if dataset_config[\"pool_balance\"] == \"balanced\":\n pass\n elif dataset_config[\"pool_balance\"] == \"imbalanced\":\n train = train.filter(lambda example: create_imbalanced_dataset(example, dataset_config[\"imbalance_prop\"], dataset_config['imbalance_cls']))\n else:\n NameError(f\"pool_balance = {dataset_config['pool_balance']} not allowed\")\n\n if dataset_config[\"dev_balance\"] == \"balanced\":\n pass\n elif dataset_config[\"dev_balance\"] == \"imbalanced\":\n dev = dev.filter(lambda example: create_imbalanced_dataset(example, dataset_config[\"imbalance_prop\"], dataset_config['imbalance_cls']))\n else:\n NameError(f\"dev_balance = {dataset_config['dev_balance']} not allowed\")\n\n # get seed labelled pool indices (using the same seed data every time)\n random.seed(dataset_config[\"seed\"])\n if dataset_config[\"seed_balance\"] == \"balanced\":\n # this is random (will have some variance vs pool)\n indices = list(range(len(train)))\n unlabelled_pool_idx, labelled_pool_idx = split(\n indices,\n random_state=dataset_config[\"seed\"],\n test_size=dataset_config[\"seed_size\"]\n )\n elif dataset_config[\"seed_balance\"] == \"stratified\":\n # this is the same as the underlying train set (which may be unbalanced)\n indices = list(range(len(train)))\n unlabelled_pool_idx, labelled_pool_idx = split(\n indices,\n random_state=dataset_config[\"seed\"],\n test_size=dataset_config[\"seed_size\"],\n stratify=train['label']\n )\n elif dataset_config[\"seed_balance\"] == \"imbalanced\":\n # artificially sample an imbalanced seed set from the pool\n unlabelled_pool_idx, labelled_pool_idx = create_imbalanced_seed(\n train,\n num_classes,\n dataset_config[\"seed_size\"],\n dataset_config['imbalance_prop'],\n dataset_config['imbalance_cls']\n )\n else:\n raise NameError(f\"seed_balance = {dataset_config['seed_balance']} not allowed\")\n\n return train, dev, test, num_classes, labelled_pool_idx, unlabelled_pool_idx","def preprocess(self,\n balance=True,\n partition=\"iid\",\n unbalance_sgm=0,\n num_shards=None,\n dir_alpha=None,\n verbose=True,\n seed=None,\n download=True):\n self.download = download\n\n if os.path.exists(self.path) is not True:\n os.mkdir(self.path)\n os.mkdir(os.path.join(self.path, \"train\"))\n os.mkdir(os.path.join(self.path, \"var\"))\n os.mkdir(os.path.join(self.path, \"test\"))\n # train dataset partitioning\n if self.dataname == 'cifar10':\n trainset = torchvision.datasets.CIFAR10(root=self.root,\n train=True,\n download=self.download)\n partitioner = CIFAR10Partitioner(trainset.targets,\n self.num_clients,\n balance=balance,\n partition=partition,\n unbalance_sgm=unbalance_sgm,\n num_shards=num_shards,\n dir_alpha=dir_alpha,\n verbose=verbose,\n seed=seed)\n elif self.dataname == 'cifar100':\n trainset = torchvision.datasets.CIFAR100(root=self.root,\n train=True,\n download=self.download)\n partitioner = CIFAR100Partitioner(trainset.targets,\n self.num_clients,\n balance=balance,\n partition=partition,\n unbalance_sgm=unbalance_sgm,\n num_shards=num_shards,\n dir_alpha=dir_alpha,\n verbose=verbose,\n seed=seed)\n else:\n raise ValueError(\n f\"'dataname'={self.dataname} currently is not supported. Only 'cifar10', and 'cifar100' are supported.\"\n )\n\n subsets = {\n cid: CIFARSubset(trainset,\n partitioner.client_dict[cid],\n transform=self.transform,\n target_transform=self.targt_transform)\n for cid in range(self.num_clients)\n }\n for cid in subsets:\n torch.save(\n subsets[cid],\n os.path.join(self.path, \"train\", \"data{}.pkl\".format(cid)))","def _split_train_tst(self):\n num_samples = self.Y.shape[0]\n mapper_file = self.checkpointer.get_mapper_file_location()\n if not self.checkpointer.is_mapper_checkpointed():\n print 'No mapper checkpoint found. Fresh loading in progress ...'\n # Now shuffle the data\n sample_id = range(num_samples)\n random.shuffle(sample_id)\n print 'Dumping the mapper shuffle for reuse.'\n Pickle.dump(sample_id, open(mapper_file, 'wb'))\n print 'Dump complete. Moving Forward...'\n else:\n print 'Mapper Checkpoint found... Reading from mapper dump'\n sample_id = Pickle.load(open(mapper_file, 'rb'))\n print 'Mapping unpickling complete.. Moving forward...'\n\n self.X_fwd = self.X_fwd[sample_id]\n self.X_bwd = self.X_bwd[sample_id]\n self.Y = self.Y[sample_id]\n # Now divide the data into test ans train set\n test_fraction = 0.01\n self.test_size = int(test_fraction * num_samples)\n self.train_size = num_samples - self.test_size\n # Forward review\n self.X_trn_fwd = self.X_fwd[0:self.train_size]\n self.X_tst_fwd = self.X_fwd[self.train_size:num_samples]\n # Backward review\n self.X_trn_bwd = self.X_bwd[0:self.train_size]\n self.X_tst_bwd = self.X_bwd[self.train_size:num_samples]\n # Summary\n self.Y_trn = self.Y[0:self.train_size]\n self.Y_tst = self.Y[self.train_size:num_samples]","def splitting(X, y, TrainingShare=0.5, seed=0):\n\n\t#target_name = 'default'\n\t#X = default.drop('default', axis=1)\n\t#robust_scaler = RobustScaler()\n\t#sc = StandardScaler()\n\t#X = robust_scaler.fit_transform(X)\n\t#y = default[target_name]\n\n\t# Train-test split\n\tX_train, X_test, y_train, y_test=train_test_split(X, y, train_size=TrainingShare, test_size = 1-TrainingShare, random_state=seed)\n\treturn X_train, X_test, y_train, y_test","def config1() :\n data_name = \"titanic\" ### in data/input/\n model_class = 'AutoML' ### ACTUAL Class name for model_sklearn.py\n n_sample = 1000\n\n def post_process_fun(y): ### After prediction is done\n return int(y)\n\n def pre_process_fun(y): ### Before the prediction is done\n return int(y)\n\n\n model_dict = {'model_pars': {\n ### LightGBM API model #######################################\n 'model_class': model_class\n ,'model_pars' : {\n 'total_time_limit' : 20,\n 'algorithms' : 'auto',\n 'results_path' : root_repo + f'/data/output/{data_name}/{os_get_function_name()}/automl_1',\n 'eval_metric' : 'auto'\n\n # mode='Explain',\n # ml_task='auto', model_time_limit=None, algorithms='auto', train_ensemble=True,\n # stack_models='auto', eval_metric='auto', validation_strategy='auto', explain_level='auto',\n # golden_features='auto', features_selection='auto', start_random_models='auto',\n # hill_climbing_steps='auto', top_models_to_improve='auto', verbose=1, random_state=1234)\n }\n\n , 'post_process_fun' : post_process_fun ### After prediction ##########################################\n , 'pre_process_pars' : {'y_norm_fun' : pre_process_fun , ### Before training ##########################\n\n\n ### Pipeline for data processing ##############################\n 'pipe_list': [\n #### coly target prorcessing\n {'uri': 'source/prepro.py::pd_coly', 'pars': {}, 'cols_family': 'coly', 'cols_out': 'coly', 'type': 'coly' },\n\n\n {'uri': 'source/prepro.py::pd_colnum_bin', 'pars': {}, 'cols_family': 'colnum', 'cols_out': 'colnum_bin', 'type': '' },\n {'uri': 'source/prepro.py::pd_colnum_binto_onehot', 'pars': {}, 'cols_family': 'colnum_bin', 'cols_out': 'colnum_onehot', 'type': '' },\n\n #### catcol INTO integer, colcat into OneHot\n {'uri': 'source/prepro.py::pd_colcat_bin', 'pars': {}, 'cols_family': 'colcat', 'cols_out': 'colcat_bin', 'type': '' },\n # {'uri': 'source/prepro.py::pd_colcat_to_onehot', 'pars': {}, 'cols_family': 'colcat_bin', 'cols_out': 'colcat_onehot', 'type': '' },\n\n\n ### Cross_feat = feat1 X feat2\n # {'uri': 'source/prepro.py::pd_colcross', 'pars': {}, 'cols_family': 'colcross', 'cols_out': 'colcross_pair', 'type': 'cross'},\n\n\n #### Example of Custom processor\n #{'uri': THIS_FILEPATH + '::pd_col_myfun', 'pars': {}, 'cols_family': 'colnum', 'cols_out': 'col_myfun', 'type': '' }, \n\n\n ],\n }\n },\n\n 'compute_pars': { 'metric_list': ['accuracy_score','average_precision_score']\n\n ,'mlflow_pars' : None # {} ### Not empty --> use mlflow\n },\n\n 'data_pars': { 'n_sample' : n_sample,\n\n 'download_pars' : None,\n\n\n 'cols_input_type' : cols_input_type_1,\n ### family of columns for MODEL #########################################################\n # \"colnum\", \"colnum_bin\", \"colnum_onehot\", \"colnum_binmap\", #### Colnum columns\n # \"colcat\", \"colcat_bin\", \"colcat_onehot\", \"colcat_bin_map\", #### colcat columns\n # 'colcross_single_onehot_select', \"colcross_pair_onehot\", 'colcross_pair', #### colcross columns 'coldate', 'coltext',\n 'cols_model_group': [ 'colnum_bin',\n 'colcat_bin',\n # 'coltext',\n # 'coldate',\n #'colcross_pair',\n \n ### example of custom\n # 'col_myfun'\n ]\n\n ### Filter data rows ##################################################################\n ,'filter_pars': { 'ymax' : 2 ,'ymin' : -1 }\n\n }\n }\n\n ##### Filling Global parameters ############################################################\n model_dict = global_pars_update(model_dict, data_name, config_name=os_get_function_name() )\n return model_dict","def make_testing_training(data, percent_training, random_split=False, seed=None):\n ## Making testing and training sets\n data['computed Case Date/Time Closed'] = pd.to_datetime(data['Case Date/Time Closed'])\n ordered_data = data.sort(columns=['computed Case Date/Time Closed'])\n np.random.seed(seed=seed) \n nrows, ncols = ordered_data.shape\n\n if random_split:\n training_indices = np.random.choice(ordered_data.index, size=int(nrows*percent_training), replace=False)\n training = ordered_data.ix[training_indices]\n testing = ordered_data[~data['case_id'].isin(training['case_id'])]\n else: # split by date\n training_stop_index = int(percent_training * nrows)\n training = ordered_data[:training_stop_index]\n testing = ordered_data[training_stop_index:]\n\n return training, testing","def learn(self):\n metrics_hist = dict()\n max_runs = 3\n for run in range(max_runs):\n all_indices, initial_indices = self._init_al_dataset()\n\n metrics_hist[str(run)] = dict()\n\n current_indices = list(initial_indices)\n \n for split in self.data_splits_frac:\n print(f'\\nRUN {run} - SPLIT - {split*100:0.0f}%')\n\n # Initialise models\n self._init_models(mode='svaal')\n\n # Do some label stuff\n unlabelled_indices = np.setdiff1d(list(all_indices), current_indices)\n unlabelled_sampler = data.sampler.SubsetRandomSampler(unlabelled_indices)\n unlabelled_dataloader = data.DataLoader(self.datasets['train'],\n sampler=unlabelled_sampler,\n batch_size=64,\n drop_last=False)\n\n print(f'Labelled: {len(current_indices)} Unlabelled: {len(unlabelled_indices)} Total: {len(all_indices)}')\n\n # TODO: Make the SVAAL allow 100% labelled and 0% unlabelled to pass through it. Breaking out of loop for now when data hits 100% labelled.\n if len(unlabelled_indices) == 0:\n break\n\n metrics, svae, discriminator = self.train(dataloader_l=self.labelled_dataloader,\n dataloader_u=unlabelled_dataloader,\n dataloader_v=self.val_dataloader,\n dataloader_t=self.test_dataloader,\n mode='svaal') \n print(f'Test Eval.: F1 Scores - Macro {metrics[0]*100:0.2f}% Micro {metrics[1]*100:0.2f}%') \n \n # Record performance at each split\n metrics_hist[str(run)][str(split)] = metrics\n\n \n sampled_indices = self.sample_adversarial(svae, discriminator, unlabelled_dataloader, indices=unlabelled_indices, cuda=True) # TODO: review usage of indices arg\n current_indices = list(current_indices) + list(sampled_indices)\n sampler = data.sampler.SubsetRandomSampler(current_indices)\n self.labelled_dataloader = data.DataLoader(self.datasets['train'], sampler=sampler, batch_size=self.batch_size, drop_last=True)\n \n # write results to disk\n with open('results.json', 'w') as fj:\n json.dump(metrics_hist, fj, indent=4)","def train_and_eval():\n # train_file_name = 'adult.data'\n # test_file_name = 'adult.test'\n train_file_name = 'poker-hand-testing.data'\n test_file_name = 'poker-hand-training-true.data'\n #test_file_name = maybe_download()\n df_train = pd.read_csv(\n tf.gfile.Open(\"/opt/tensor/race_result_clean.csv\"),\n names=COLUMNS,\n skipinitialspace=True,\n skiprows=1)\n df_test = pd.read_csv(\n tf.gfile.Open(\"/opt/tensor/race_result_clean.csv\"),\n names=COLUMNS,\n skipinitialspace=True,\n skiprows=1)\n\n #df_train[LABEL_COLUMN] = (df_train[\"CLASS_Poker_Hand\"].apply(lambda x: x>5)).astype(int)\n #df_test[LABEL_COLUMN] = (df_test[\"CLASS_Poker_Hand\"].apply(lambda x: x>5)).astype(int)\n\n model_dir = tempfile.mkdtemp() if not FLAGS.model_dir else FLAGS.model_dir\n print(\"model directory = %s\" % model_dir)\n m = build_estimator(model_dir)\n print(m)\n m.fit(input_fn=lambda: input_fn(df_train), steps=FLAGS.train_steps)\n results = m.evaluate(input_fn=lambda: input_fn(df_test), steps=1)\n for key in sorted(results):\n print(\"%s: %s\" % (key, results[key]))","def train(self):\n for data_tier in self.data_tiers:\n fd = open(self.data_path + '/training_data_' + data_tier + '.json', 'r')\n self.preprocessed_data[data_tier] = json.load(fd)\n fd.close()\n tot = len(self.preprocessed_data[data_tier]['features'])\n p = int(math.ceil(tot*0.8))\n training_features = np.array(self.preprocessed_data[data_tier]['features'][:p])\n trend_training_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][:p])\n avg_training_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][:p])\n t1 = datetime.datetime.utcnow()\n self.clf_trend[data_tier].fit(training_features, trend_training_classifications)\n self.clf_avg[data_tier].fit(training_features, avg_training_classifications)\n t2 = datetime.datetime.utcnow()\n td = t2 - t1\n self.logger.info('Training %s for data tier %s took %s', self.name, data_tier, str(td))\n joblib.dump(self.clf_trend[data_tier], self.data_path + '/' + self.name + '_trend_' + data_tier + '.pkl')\n joblib.dump(self.clf_avg[data_tier], self.data_path + '/' + self.name + '_avg_' + data_tier + '.pkl')","def train(self):\n\t\traise NotImplementedError","def train_test_split(\n self,\n default_train_prop: float,\n *,\n train_props: dict[str | int, dict[str | int, float]] | None = None,\n seed: int | None = None,\n ) -> NICOTrainTestSplit:\n # Initialise the random-number generator\n rng = np.random.default_rng(seed)\n # List to store the indices of the samples apportioned to the train set\n # - those for the test set will be computed by complement\n train_inds: list[int] = []\n # Track which indices have been sampled for either split\n unvisited = np.ones(len(self), dtype=np.bool_)\n\n def _sample_train_inds(\n _mask: np.ndarray,\n *,\n _context: str | int | None = None,\n _concept: str | None = None,\n _train_prop: float = default_train_prop,\n ) -> list[int]:\n if _context is not None and _concept is None:\n raise ValueError(\"Concept must be specified if context is.\")\n if _context is not None:\n # Allow the context to be speicifed either by its name or its label-encoding\n _context = (\n self.context_label_decoder(_context) if isinstance(_context, int) else _context\n )\n if _context not in self.class_tree[_concept]:\n raise ValueError(\n f\"'{_context}' is not a valid context for concept '{_concept}'.\"\n )\n # Condition the mask on the context\n _mask = _mask & (self.metadata[\"context\"] == _context).to_numpy()\n # Compute the overall size of the concept/context subset\n _subset_size = np.count_nonzero(_mask)\n # Compute the size of the train split\n _train_subset_size = round(_train_prop * _subset_size)\n # Sample the train indices (without replacement)\n _train_inds = rng.choice(\n np.nonzero(_mask)[0], size=_train_subset_size, replace=False\n ).tolist()\n # Mark the sampled indices as 'visited'\n unvisited[_mask] = False\n\n return _train_inds\n\n if train_props is not None:\n for concept, value in train_props.items():\n # Allow the concept to be speicifed either by its name or its label-encoding\n concept = (\n self.concept_label_decoder[concept] if isinstance(concept, int) else concept\n )\n if concept not in self.class_tree.keys():\n raise ValueError(f\"'{concept}' is not a valid concept.\")\n concept_mask = (self.metadata[\"concept\"] == concept).to_numpy()\n # Specifying proportions at the context/concept level, rather than concept-wide\n if isinstance(value, dict):\n for context, train_prop in value.items():\n train_inds.extend(\n _sample_train_inds(\n _mask=concept_mask,\n _concept=concept,\n _context=context,\n _train_prop=train_prop,\n )\n )\n # Split at the class level (without conditioning on contexts)\n else:\n train_inds.extend(\n _sample_train_inds(_mask=concept_mask, _context=None, _train_prop=value)\n )\n # Apportion any remaining samples to the training set using default_train_prop\n train_inds.extend(_sample_train_inds(_mask=unvisited, _train_prop=default_train_prop))\n # Compute the test indices by complement of the train indices\n train_data = self.make_subset(indices=train_inds)\n test_inds = list(set(range(len(self))) - set(train_inds))\n test_data = self.make_subset(indices=test_inds)\n\n return NICOTrainTestSplit(train=train_data, test=test_data)","def train_val_test_split(data):\n raise NotImplementedError","def train_val_test_split(\n reframed, n_hours, n_features, target_var=\"temp\", ascending_sampling=False\n):\n\n n_train_hours = int(reframed.shape[0] * 0.6)\n n_val_hours = int(reframed.shape[0] * 0.2)\n\n if ascending_sampling:\n print(\"Sampleamos datasets de pasado a futuro\")\n train = reframed.iloc[:n_train_hours, :]\n validation = reframed.iloc[n_train_hours : n_train_hours + n_val_hours, :]\n test = reframed.iloc[n_train_hours + n_val_hours :, :]\n else:\n print(\"Sampleamos datasets de futuro a pasado\")\n train = reframed.iloc[-n_train_hours:, :]\n validation = reframed.iloc[-(n_train_hours + n_val_hours) : -n_train_hours :, :]\n test = reframed.iloc[: -(n_train_hours + n_val_hours), :]\n\n # split into input and outputs\n n_obs = n_hours * n_features\n\n target_col = \"{}_t\".format(target_var)\n out_model_name = \"{}.hdf5\".format(target_var)\n # target_var = 'prcp(t)'\n train_X, train_y = train.iloc[:, :n_obs].values, train[target_col].values\n val_X, val_y = validation.iloc[:, :n_obs].values, validation[target_col].values\n test_X, test_y = test.iloc[:, :n_obs].values, test[target_col].values\n print(train_X.shape, len(train_X), train_y.shape)\n\n # reshape input to be 3D [samples, timesteps, features]\n train_X = train_X.reshape((train_X.shape[0], n_hours, n_features))\n val_X = val_X.reshape((val_X.shape[0], n_hours, n_features))\n test_X = test_X.reshape((test_X.shape[0], n_hours, n_features))\n print(\n train_X.shape,\n train_y.shape,\n val_X.shape,\n val_y.shape,\n test_X.shape,\n test_y.shape,\n )\n\n return {\n \"trainset\": {\"X\": train_X, \"y\": train_y},\n \"valset\": {\"X\": val_X, \"y\": val_y},\n \"testset\": {\"X\": test_X, \"y\": test_y},\n }","def load_data(self,split='train'):\n raise ValueError('Please implement me!')","def train_test_split(self):\n random.seed(self.args.seed)\n nodes = [node for node in range(self.ncount)]\n random.shuffle(nodes)\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.args.training_size+self.args.validation_size])\n self.test_nodes = torch.LongTensor(nodes[self.args.training_size+self.args.validation_size:])","def split_train_test_dev(self):\n for dir_name in (self.config.train_dir, self.config.dev_dir,\n self.config.test_dir):\n create_dir(dir_name)\n\n self.split_helper(self.config.parsed_train_file_pos, 'pos')\n self.split_helper(self.config.parsed_train_file_neg, 'neg')","def finetuned():\n launch_training_on_all_splits(experiment='full', splits=NAME_SPLIT, base_model='ft', dropout=0.7304, learning_rate=0.0000976)","def _fit_split_(self, dataset, targets, val_set, val_targets, checkpoints):\n dir = ''.join(random.choices(string.ascii_lowercase + string.digits, k=16))\n dir = '.tmp' + dir + '/'\n os.mkdir(dir)\n grid = self.grid\n if self.folds is not None or self.folds != 0:\n if self.task == 'Classification':\n if self.folds > 1:\n sf = StratifiedKFold(n_splits=self.folds, shuffle=True, random_state=0)\n elif 0 <= self.folds < 1:\n sf = StratifiedShuffleSplit(n_splits=1, test_size=self.folds, random_state=0)\n elif self.task == 'Regression':\n folds, dataset, targets = self.split_regression(dataset, targets)\n results = []\n for params in grid:\n try:\n nn = NeuralNetwork()\n for i in range(len(params['layers'])):\n if i == 0:\n nn.add_layer('dense', params['layers'][i], params['activation'], dataset.shape[1])\n else:\n if i == len(params['layers']) - 1 and self.task == 'Regression':\n nn.add_layer('dense', params['layers'][i], 'linear')\n else:\n nn.add_layer('dense', params['layers'][i], params['activation'])\n curr_res = {'params': params,\n 'metric_stats': [],\n 'test_stats': [],\n 'vl_stats': [],\n 'tr_stats': []}\n\n if self.task == 'Classification':\n folds = sf.split(dataset, targets)\n for train_index, test_index in folds:\n X_train, X_test = dataset[train_index], dataset[test_index]\n Y_train, Y_test = targets[train_index], targets[test_index]\n nested_best = None\n nested_best_metric = None\n nested_tr_pred = None\n nested_vl_pred = None\n for i in range(self.restarts):\n nn.compile(task=self.task,\n loss=self.loss_name,\n l2_lambda=params['l2_lambda'],\n dropout=params['dropout'],\n optimizer=SGD(lr_init=params['lr'],\n momentum=params['momentum'],\n nesterov=params['nesterov'],\n lr_sched=StepDecayScheduler(drop=params['lr_sched'][0],\n epochs_drop=params['lr_sched'][1])))\n\n curr_model, curr_metric, best_epoch = nn.fit(X_train, Y_train,\n val_set=val_set, val_targets=val_targets,\n batch_size=params['batch_size'],\n test_size=params['test_size'],\n epochs=params['epoch'],\n patience=params['patience'],\n save_pred=dir + 'tmp_gs',\n save_model=None)\n\n nested_best_metric = metrics.metric_improve(self.metric, nested_best_metric, curr_metric)\n if nested_best_metric[1]:\n nested_tr_pred = np.load(dir + 'tmp_gs_tr_predictions.npy')[best_epoch]\n nested_vl_pred = np.load(dir + 'tmp_gs_vl_predictions.npy')[best_epoch]\n nested_best = copy.deepcopy(curr_model)\n if nested_best_metric[2]:\n break\n\n Y_pred = nested_best.predict(X_test)\n if self.metric == 'loss':\n curr_metric = np.sum(self.loss(Y_test, Y_pred), axis=0) / len(Y_test)\n else:\n curr_metric = metrics.metric_computation(self.metric, Y_test, Y_pred)\n\n curr_res['metric_stats'].append(curr_metric)\n tr_stats = []\n vl_stats = []\n test_stats = []\n for stat in self.statistics:\n if stat == 'loss':\n\n tr_stats.append(np.mean(self.loss(nested_tr_pred[:, :targets.shape[1]],\n nested_tr_pred[:, targets.shape[1]:])))\n vl_stats.append(np.mean(self.loss(nested_vl_pred[:, :targets.shape[1]],\n nested_vl_pred[:, targets.shape[1]:])))\n test_stats.append(np.mean(self.loss(Y_test, Y_pred)))\n else:\n tr_stats.append(metrics.metric_computation(stat,\n nested_tr_pred[:, :targets.shape[1]],\n nested_tr_pred[:, targets.shape[1]:]))\n vl_stats.append(metrics.metric_computation(stat,\n nested_vl_pred[:, :targets.shape[1]],\n nested_vl_pred[:, targets.shape[1]:]))\n test_stats.append(metrics.metric_computation(stat, Y_test, Y_pred))\n curr_res['tr_stats'].append(tr_stats)\n curr_res['vl_stats'].append(vl_stats)\n curr_res['test_stats'].append(test_stats)\n\n results.append(curr_res)\n if checkpoints is not None:\n with open(checkpoints + '.pkl', 'wb') as output:\n pickle.dump(results, output, pickle.HIGHEST_PROTOCOL)\n\n except NesterovError:\n continue\n shutil.rmtree(dir)\n return results","def load_random_split(\n self,\n test_rate=0.1,\n random=False,\n n_negative=100,\n by_user=False,\n n_test=10,\n download=False,\n force_redo=False,\n ):\n processed_random_split_path = os.path.join(self.processed_path, \"random\")\n if not os.path.exists(processed_random_split_path):\n os.mkdir(processed_random_split_path)\n\n parameterized_path = generate_parameterized_path(\n test_rate=test_rate, random=random, n_negative=n_negative, by_user=by_user\n )\n download_path = processed_random_split_path\n processed_random_split_path = os.path.join(\n processed_random_split_path, parameterized_path\n )\n if force_redo:\n self.make_random_split(\n test_rate=test_rate,\n random=random,\n n_negative=n_negative,\n by_user=by_user,\n n_test=n_test,\n )\n elif not os.path.exists(processed_random_split_path):\n if (\n download\n and test_rate == 0.1\n and random is False\n and n_negative == 100\n and by_user is False\n ):\n # default parameters, can be downloaded from Onedrive\n folder = OneDrive(\n url=self.processed_random_split_url, path=download_path\n )\n folder.download()\n un_zip(processed_random_split_path + \".zip\", download_path)\n else:\n # make\n self.make_random_split(\n test_rate=test_rate,\n random=random,\n n_negative=n_negative,\n by_user=by_user,\n n_test=n_test,\n )\n\n # load data from local storage\n return load_split_data(processed_random_split_path, n_test=n_test)","def calculate_data_split(self, n_train=2, n_vali=0, n_test=1, n_splits=1,\n num_percentiles=4, random_state=87, verbosity=1,\n manual_split=False,train_indices=None, test_indices=None,\n train_redshift_indices=[0], test_redshift_indices=[0],\n interpolate_over_redshift_only=False, **kwargs):\n \n n_extrema=kwargs.get('n_extrema', 2)\n ind_extrema=kwargs.get('ind_extrema', [0,-1])\n self.data_separation(n_extrema=n_extrema, ind_extrema=ind_extrema)\n\n too.condprint(\"number of wanted training vectors\", n_train, level=2, verbosity=verbosity)\n too.condprint(\"number of wanted test vectors\", n_test, level=1, verbosity=verbosity)\n if n_train+n_test > (self.size_fullspace):\n print(\"Warning n_train is larger than total full sample space\")\n\n self.random_state = random_state\n self.num_percentiles = num_percentiles\n self.n_splits = n_splits\n\n stratif_labels = self.stratify_array(self.midspace, num_percentiles=self.num_percentiles)\n self.test_splitdict = dict()\n self.train_splitdict = dict()\n self.vali_splitdict = dict()\n\n if manual_split == False:\n n_vali = self.size_midspace-n_test-n_train\n if n_vali !=0 and len(self.ind_midspace)> 1:\n kf = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=n_test, random_state=self.random_state)\n for ii, (trainvali, test) in enumerate(kf.split(self.midspace,stratif_labels)):\n #test = test[np.in1d(test, extspace_ind, invert=True)]\n\n test = self.ind_midspace[test]\n if n_train > 0:\n train, valitest = train_test_split(trainvali, test_size=n_vali, shuffle=True, random_state=self.random_state)\n train = self.ind_midspace[train]\n train = np.unique(np.concatenate([train,self.ind_extremaspace]))\n train = self.ind_fullspace[train]\n else:\n train = self.ind_extremaspace\n train = self.ind_fullspace[train]\n valitest=trainvali\n\n #valitest = valitest[np.in1d(valitest, extspace_ind, invert=True)]\n valitest = self.ind_midspace[valitest]\n #print(test, trr, \" s tr\", len(train)-2, \" tr: \", train, \" va: \", valitest)\n self.test_splitdict[ii] = test\n self.vali_splitdict[ii]= valitest\n self.train_splitdict[ii] = train\n elif len(self.ind_midspace)> 1 and n_vali == 0:\n kf = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=n_test, random_state=self.random_state)\n for ii, (train, test) in enumerate(kf.split(self.midspace,stratif_labels)):\n test = self.ind_midspace[test]\n train = self.ind_midspace[train]\n train = np.unique(np.concatenate([train,self.ind_extremaspace]))\n train = self.ind_fullspace[train]\n self.test_splitdict[ii] = test\n self.train_splitdict[ii] = train\n\n else:\n test = self.ind_midspace\n train = self.ind_extremaspace\n self.test_splitdict[0] = test\n self.train_splitdict[0] = train\n \n ###/!\\ Warning /!\\ For now we always use manual split (which not really manual now...)\n elif manual_split == True:\n ### Determine the number of samples avaible with different values of parameters. e.g nb_param = 101 for MassiveNus\n nb_param = int(len(self.fullspace)/len(self.z_requested)) \n if len(self.z_requested)==1:\n nb_param = int(len(self.fullspace))\n \n\n for ii in range (n_splits):\n ###Here the user has chosen to provide the test indices\n if test_indices is not None:\n test_indices = np.atleast_2d(test_indices)\n test = test_indices[ii]\n ###We make sure that the indice lies into a correct space. e.g if we have nb_param = 101, and a indices i = 103 it will become i =2\n test_origin = [tt%nb_param for tt in test]\n \n ###Do we want to construct a interpolation only over the redshift ? /!\\ Warning /!\\ this is case is not really used....\n if interpolate_over_redshift_only == False and train_indices is None:\n train_origin = [ii for ii in range(1,nb_param-1) if ii not in test_origin ]\n\n elif interpolate_over_redshift_only == False and train_indices is not None:\n train_origin = [tt%nb_param for tt in train ]\n else :\n train_origin = test_origin\n ###Here the user has chosen not to provide the test indices\n ## so we first randomly generate them\n else:\n if train_indices is None:\n test_origin = [ii for ii in range(1,nb_param-1)]\n test_origin = shuffle(test_origin)[:n_test]\n if interpolate_over_redshift_only == False:\n train_origin = [ii for ii in range(1,nb_param-1) if ii not in test_origin ]\n else:\n train_origin = test_origin\n ###The user has specified train indices so must be sure that train and test do not overlap !\n else:\n train_indices = np.atleast_2d(train_indices)\n train = train_indices[ii]\n train_origin = [tt%nb_param for tt in train ]\n test_origin = [ii for ii in range(1,nb_param-1) if ii not in train_origin ] ####!!!\n \n train_origin = shuffle(train_origin)\n \n train_origin = train_origin[:n_train]\n test_origin = shuffle(test_origin)[:n_test]\n if train_indices is None:\n if [0] not in test_origin:\n train_origin +=[0]\n if [nb_param-1]not in test_origin:\n \n train_origin += [nb_param-1]\n if [0] in test_origin or [nb_param-1] in test_origin :\n print(\"Warning : trying to interpolate a extramal value\")\n \n\n train_redshift = self.z_requested[train_redshift_indices]\n test_redshift = self.z_requested[test_redshift_indices]\n self.train_redshift = train_redshift \n self.test_redshift = test_redshift\n too.condprint(\"redshift used for training\", train_redshift,level=1,verbosity=verbosity)\n too.condprint(\"redshfit used for testing\", test_redshift,level=1,verbosity=verbosity)\n train = []\n test = []\n ### looping over the redshift \n for zz in train_redshift_indices:\n train+= [ii + zz*nb_param for ii in train_origin ]\n\n for zz in test_redshift_indices: \n test += [ii + zz*nb_param for ii in test_origin ]\n \n\n self.train_splitdict[ii] = train\n self.test_splitdict[ii] = test\n shuffled = shuffle(train)\n self.train_splitdict[ii] = shuffled\n self.vali_splitdict[ii] = shuffled\n\n return None","def __train_test_splits(self):\n # By default, our indices are just 0-n\n split_indices = list(range(len(self.data)))\n # If shuffling, use our shared Random instance to shuffle our indices before slicing\n if self.shuffle:\n np.random.shuffle(split_indices)\n # Regardless of shuffle, take the first self.train_proportion for training, and the last\n # 1 - self.train_proportion records as test\n train_n = int(self.train_proportion * len(self.data))\n training_indices = split_indices[:train_n]\n test_indices = split_indices[train_n:]\n return training_indices, test_indices","def split_data(self, model_data, tuning=True):\n pass","def split_data(train_split, src_dir, train_dir, test_dir, classes):\n for cls in classes:\n # get all dat files of this class\n data = get_instances_of_class(cls, src_dir)\n \n # how many of the data points are for training?\n train_count = round(len(data) * train_split / 100)\n \n # randomly choose indexes\n train_indexes = set()\n while len(train_indexes) < train_count:\n train_indexes.add(random.randrange(len(data)))\n \n # move all train_indexes to train_dir, others to test_dir\n COPY = lambda src, dst, filename:\\\n shutil.copy2(\n \"{}/{}\".format(src, data[i]),\n \"{}/{}\".format(dst, data[i])\n )\n \n for i in range(len(data)):\n if i in train_indexes:\n COPY(src_dir, train_dir, data[i])\n else:\n COPY(src_dir, test_dir, data[i])","def main(cfg):\n # logging.info(f'Found base dir {cfg.BASE_DIR}')\n\n rng = cfg.experiment.random_seed\n if rng == -1:\n rng = np.random.randint(0, 1000)\n\n if rng is not False:\n np.random.seed(rng)\n torch.torch.manual_seed(rng)\n\n dcc = cfg.dataset.get('creation_args', dict())\n if dcc.get('dim_normalise_mean', False):\n dim = dcc.dim\n dcc.f_mean = float(dcc.f_mean / np.sqrt(dim))\n dcc.p_mean = float(dcc.p_mean / np.sqrt(dim))\n logging.info(\n f'Updating means in dataset cfg: {cfg.dataset.creation_args}')\n\n stats = dict(\n dir=os.getcwd(),\n host=socket.gethostname(),\n job_id=os.getenv(\"SLURM_JOB_ID\", None),\n random_state=rng)\n STATS_STATUS = False\n\n logging.info(\n f'Logging to {stats[\"dir\"]} on {stats[\"host\"]} '\n f'for id={cfg.get(\"id\", -1)}')\n\n logging.info(f'Slurm job: {stats[\"job_id\"]}.')\n logging.info(f'Setting random seed to {rng}.')\n logging.info(f'Uniform clip val is {cfg.acquisition.uniform_clip}.')\n\n hoover = Hoover(cfg.hoover)\n\n model = None\n\n # Right now this averages over both train and testing!\n for run in range(cfg.experiment.n_runs):\n if run % cfg.experiment.log_every == 0 or cfg.experiment.debug:\n logging.info(f'Run {run} in {os.getcwd()} ****NEW RUN****')\n if cuda := torch.cuda.is_available():\n logging.info(f'Still using cuda: {cuda}.')\n else:\n logging.info('No cuda found!')\n os.system('touch cuda_failure.txt')\n\n dataset = maps.dataset[cfg.dataset.name](\n cfg.dataset, model_cfg=cfg.model)\n\n # Train model on training data.\n if (not cfg.model.get('keep_constant', False)) or (model is None):\n # default case\n model = maps.model[cfg.model.name](cfg.model)\n\n # test_data = model.make_loader(dataset.test_data, train=False)\n # loss = model.evaluate(model.model, test_data)\n # logging.info(f'Model test loss is {loss}.')\n\n # train_data = model.make_loader(dataset.train_data, train=False)\n # loss = model.evaluate(model.model, train_data)\n # logging.info(f'Model train loss is {loss}.')\n\n model.fit(*dataset.train_data)\n\n loss = model.performance(\n *dataset.test_data, dataset.cfg['task_type'])\n # logging.info(\n # f'Weights vs 1 : {np.sqrt(np.sum((model.model.coef_ - 1)**2))}')\n\n if cfg.experiment.get('constant_val_set', False):\n add_val_idxs_to_cfg(cfg, model.val_idxs)\n\n if not STATS_STATUS:\n STATS_STATUS = True\n stats['loss'] = loss\n to_json(stats, 'stats.json')\n # test_data = model.make_loader(dataset.test_data, train=False)\n # loss = model.evaluate(model.model, test_data)\n # logging.info(f'Model test loss is {loss}.')\n\n # Always predict on test data again\n # TODO: need to fix this for efficient prediction\n if cfg.model.get('efficient', False):\n logging.debug('Eficient prediction on test set.')\n model = make_efficient(model, dataset)\n\n # if cfg.experiment.debug:\n # Report train error\n # logging.info('Model train error:')\n # model.performance(\n # *dataset.train_data, dataset.cfg.task_type)\n\n # if not check_valid(model, dataset):\n # continue\n\n if run < cfg.experiment.save_data_until:\n hoover.add_data(run, dataset.export())\n\n for acq_dict in cfg.acquisition_functions:\n # Slightly unclean, but could not figure out how to make\n # this work with Hydra otherwise\n acquisition = list(acq_dict.keys())[0]\n acq_cfg_name = list(acq_dict.values())[0]\n\n if cfg.experiment.debug:\n logging.info(f'\\t Acquisition: {acquisition}')\n\n # Reset selected test_indices.\n dataset.restart(acquisition)\n\n if (n := acq_cfg_name) is not None:\n acq_config = cfg['acquisition_configs'][n]\n else:\n acq_config = None\n\n experiment = Experiment(\n run, cfg, dataset, model, acquisition, acq_config)\n\n i = 0\n while not experiment.finished:\n i += 1\n # print('debug', i)\n if cfg.experiment.debug:\n logging.info(\n f'\\t Acquisition: {acquisition} – \\t Step {i}.')\n\n experiment.step(i)\n\n # Add config to name for logging.\n if (n := acq_cfg_name) is not None:\n acquisition = f'{acquisition}_{n}'\n\n # Extract results from acquisition experiment\n hoover.add_results(run, acquisition, experiment.export_data())\n\n if run % cfg.experiment.get('save_every', 1e19) == 0:\n logging.info('Intermediate save.')\n hoover.save()\n\n logging.info('Completed all runs.')\n hoover.save()","def runner(self):\n\n print('[ INFO ]: Initializing the abalone program runner...')\n\n df, features, predictor, classes = self.preprocess()\n\n df = alg.random_feature_sample(self, df, 0.10)\n\n # Set up the training, testing and validation sets\n split = round(len(df) * 0.10)\n v_set = df[df.index < split]\n t_set = df[df.index >= split]\n\n tree = alg()\n folds_dict = tree.cross_validation(t_set, predictor, type='classification', folds=5)\n\n # Initialize comparion values\n best_fold_tree = None\n best_fold_score = 0\n best_fold_pred_labels = None\n best_fold_df = None\n\n # Loop through each fold in the folds dictionary\n for fold in folds_dict:\n\n test_set = folds_dict[fold]\n train_set = pd.DataFrame()\n for inner_fold in folds_dict:\n if inner_fold != fold:\n train_set = train_set.append(folds_dict[inner_fold], ignore_index=True)\n\n # Build an ID3 tree\n root = tree.build_tree(train_set, features, predictor)\n df, labels, pred_labels, score = tree.test(test_set, features, predictor, root)\n\n # Determine which tree is the best\n if score > best_fold_score:\n best_fold_tree = root\n best_fold_score = score\n best_fold_pred_labels = pred_labels\n best_fold_df = df\n\n # Validate results and prune the ID3 tree\n v_tree = alg()\n df, labels, pred_labels, score = v_tree.test(v_set, features, predictor, best_fold_tree)\n prune_root = v_tree.prune(df, predictor, best_fold_tree)\n prune_df, prune_labels, prune_pred_labels, prune_score = v_tree.test(v_set, features, predictor, prune_root)\n\n return best_fold_tree, score, labels, pred_labels, prune_root, prune_score, prune_labels, prune_pred_labels","def get_split(split_name, dataset_dir, seed, batch_size, file_pattern=None, reader=None):\n\n train_questions = pd.read_json(os.path.join(dataset_dir, '../raw-data/VQA_Dataset/train_questions_annotations.json'))\n #os.path.join(dataset_dir, '../raw-data/VQA_Dataset/')\n\n #Questions\n questions = list(train_questions.iloc[0])\n #Answers\n answers = list(train_questions.iloc[2])\n #Images\n images = np.array(train_questions.iloc[1])\n\n #transform answers into values of dictionary\n for i in range(len(answers)):\n answers[i] = labels_dict[answers[i]]\n \n\n \n dataset = CustomDataset(os.path.join(dataset_dir, '../raw-data/VQA_Dataset'), 'training', train_questions=train_questions) #preprocessing_function=preprocess_input\n dataset_valid = CustomDataset(os.path.join(dataset_dir, '../raw-data/VQA_Dataset'), 'validation', train_questions=train_questions) #preprocessing_function=preprocess_input\n\n \n\n train_dataset = tf.data.Dataset.from_generator(lambda: dataset,\n output_types=((tf.int32, tf.float32), tf.int32),\n output_shapes=(([max_questions_length], [int(img_h/2), int(img_w/2), 3]), [num_classes]))\n\n\n\n validation_dataset = tf.data.Dataset.from_generator(lambda: dataset_valid,\n output_types=(( tf.int32, tf.float32), tf.int32),\n output_shapes=(([max_questions_length], [int(img_h/2), int(img_w/2), 3]), [num_classes]))\n\n #train_dataset = train_dataset.shuffle(2048, seed = seed)\n\n train_dataset = train_dataset.prefetch(buffer_size = tf.data.experimental.AUTOTUNE)\n\n #validation_dataset = validation_dataset.shuffle(2048, seed = seed)\n\n validation_dataset = validation_dataset.prefetch(buffer_size = tf.data.experimental.AUTOTUNE)\n\n train_dataset = train_dataset.batch(batch_size) \n\n train_dataset = train_dataset.repeat() \n \n validation_dataset = validation_dataset.batch(batch_size)\n \n validation_dataset = validation_dataset.repeat()\n\n\n return _NUM_CLASSES, SPLITS_TO_SIZES['train'] ,SPLITS_TO_SIZES['validation'], train_dataset, validation_dataset","def train(self):\n raise NotImplementedError","def load_split(self, config):\n data_split_str = config[\"data_split\"]\n split_paras = {}\n split_paras[\"test_rate\"] = config[\"test_rate\"] if \"test_rate\" in config else 0.1\n split_paras[\"random\"] = config[\"random\"] if \"random\" in config else False\n split_paras[\"download\"] = config[\"download\"] if \"download\" in config else False\n split_paras[\"n_negative\"] = (\n config[\"n_negative\"] if \"n_negative\" in config else 100\n )\n split_paras[\"by_user\"] = config[\"by_user\"] if \"by_user\" in config else False\n split_paras[\"n_test\"] = config[\"n_test\"] if \"n_test\" in config else 10\n\n if split_paras[\"n_negative\"] < 0 and split_paras[\"n_test\"] > 1:\n # n_negative < 0, validate and testing sets of splits will contain all the negative items.\n # There will be only one validata and one testing sets.\n split_paras[\"n_test\"] = 1\n\n data_split_mapping = {\n \"leave_one_out\": self.load_leave_one_out,\n \"leave_one_basket\": self.load_leave_one_basket,\n \"random_split\": self.load_random_split,\n \"random_basket_split\": self.load_random_basket_split,\n \"temporal\": self.load_temporal_split,\n \"temporal_basket\": self.load_temporal_basket_split,\n }\n\n split_para_mapping = {\n \"leave_one_out\": [\"random\", \"download\", \"n_negative\", \"n_test\"],\n \"leave_one_basket\": [\"random\", \"download\", \"n_negative\", \"n_test\"],\n \"random_split\": [\n \"test_rate\",\n \"download\",\n \"by_user\",\n \"n_negative\",\n \"n_test\",\n ],\n \"random_basket_split\": [\n \"test_rate\",\n \"download\",\n \"by_user\",\n \"n_negative\",\n \"n_test\",\n ],\n \"temporal\": [\"test_rate\", \"by_user\", \"download\", \"n_negative\", \"n_test\"],\n \"temporal_basket\": [\n \"test_rate\",\n \"download\",\n \"by_user\",\n \"n_negative\",\n \"n_test\",\n ],\n }\n para_dic = {\n split_para_key: split_paras[split_para_key]\n if split_para_key in split_paras\n else None\n for split_para_key in split_para_mapping[data_split_str]\n }\n train_data, valid_data, test_data = data_split_mapping[data_split_str](\n **para_dic\n )\n return train_data, valid_data, test_data","def _train_and_evaluate(estimator, output_dir):\n \n \"\"\"X_train, y_train =utils._feature_label_split(df_train,\"is_churn\",\"msno\")\n df_val = utils.read_from_bigquery(\"amiable-octane-267022.kkbox.output_val_1\",\"amiable-octane-267022\")\n X_val, y_val =utils._feature_label_split(df_val,\"is_churn\",\"msno\")\"\"\"\n \n df_train=utils.over_sample(\"amiable-octane-267022.kkbox.output_train_1\",\"amiable-octane-267022\")\n X_train, y_train =utils._feature_label_split(df_train,\"is_churn\",\"msno\")\n df_val=utils.over_sample(\"amiable-octane-267022.kkbox.output_val_1\",\"amiable-octane-267022\")\n X_val, y_val =utils._feature_label_split(df_val,\"is_churn\",\"msno\")\n\n estimator.fit(X_train, y_train)\n f1_scorer = make_scorer(f1_score)\n accuracy_scorer =make_scorer(accuracy_score)\n\n if metadata.HYPERPARAMTER_TUNING:\n scores=model_selection.cross_val_score(estimator, X_val, y_val, cv=3,scoring=f1_scorer)\n #,scoring=f1_scorer\n\n logging.info('Score: %s', scores)\n\n #tune hyper\n hpt = hypertune.HyperTune()\n hpt.report_hyperparameter_tuning_metric(\n hyperparameter_metric_tag='F1_SCORE',\n metric_value=np.mean(scores),\n global_step=10000)\n \n#joblib.dump(estimator, 'model.joblib')\n\n # Write model and eval metrics to `output_dir`\n model_output_path = os.path.join(output_dir, 'model',metadata.MODEL_FILE_NAME)\n \n utils.dump_object(estimator, model_output_path)","def pre_process(self, dataset):\n\n # np.empty creates an empty array only. You have to replace this with your code.\n X = np.empty((0,0))\n y = np.empty((0))\n\n if dataset == 0:\n # Implement for the abalone dataset\n df = pd.DataFrame(columns=['sex', 'length', 'diameter', 'height', 'whole_weight', 'shucked_weight', 'viscera_weight', 'shell_weight', 'rings'])\n count = 0\n\n with open('Dataset.data') as file: # reading data from file\n data = file.read()\n\n data = data.split('\\n') # split data into different rows\n data = data[:-1] # last one is empty\n for row in data:\n row = row.split()\n df.loc[count] = row # add in dataframe\n count += 1\n\n df['M'] = np.where(df.sex=='M', 1,0) # genders are turned to a one hot encoding\n df['F'] = np.where(df.sex=='F', 1,0)\n df['I'] = np.where(df.sex=='I', 1,0)\n df = df.drop(['sex'], axis=1)\n df = df.dropna()\n\n df = df.sample(frac=1).reset_index(drop=True) # shuffle dataframe\n\n X = df.drop(['rings'], axis=1)\n X = X.values\n X = X.astype(float)\n y = df['rings'].values\n y = y.astype(float)\n\n elif dataset == 1:\n # Implement for the video game dataset\n df = pd.read_csv('VideoGameDataset - Video_Games_Sales_as_at_22_Dec_2016.csv') # read csv directly into a dataframe\n df1 = df[['Critic_Score', 'User_Score', 'Global_Sales']]\n df1 = df1.dropna()\n df1 = df1[df1.User_Score != 'tbd']\n\n df1 = df1.sample(frac=1).reset_index(drop=True) # shuffle rows\n\n X = df1.drop(['Global_Sales'], axis=1)\n X = X.values\n X = X.astype(float)\n y = df1['Global_Sales'].values\n y = y.astype(float)\n\n elif dataset == 2:\n # Implement for the banknote authentication dataset\n df = pd.DataFrame(columns=['variance', 'skewness', 'curtosis', 'entropy', 'class'])\n count = 0\n\n with open('data_banknote_authentication.txt') as file: # reading file \n data = file.read()\n data = data.split('\\n')\n data = data[:-1]\n for row in data:\n row = row.split(',')\n df.loc[count] = [float(elt) for elt in row[:-1]] + [int(row[-1])] # last column has class so it is int rest are float\n count += 1\n\n df = df.sample(frac=1).reset_index(drop=True) # shuffle dataset\n\n X = df.drop(['class'], axis=1)\n X = X.values\n y = df['class'].values\n y = y.astype(int)\n\n return X, y","def __init__(self, data_split_filename, num_rounds, early_stopping_round, xgboost_params, verbose_eval=False):\n super().__init__(num_rounds, early_stopping_round, xgboost_params, verbose_eval)\n self.data_split_filename = data_split_filename\n self.train_data = None\n self.test_data = None","def split_train_test_application_data(self, test_size, test_split_proportion, view=0):\n X_train, X_test, y_train, y_test = train_test_split(self.data[view], self.class_data, test_size=test_size)\n X_test, X_application, y_test, y_application = train_test_split(X_test, y_test, test_size=test_split_proportion)\n return X_train, X_test, X_application, y_train, y_test, y_application","def run_train_test(training_file, testing_file):\n\n training = parse_file(training_file)\n training = np.array(training)\n\n X_train = training[:,:4]\n Y_train = training[:,4]\n\n testing = parse_file(testing_file)\n testing = np.array(testing)\n\n X_test = testing[:,:4]\n Y_test = testing[:,4]\n\n gini_clf = DecisionTreeClassifier(random_state=0)\n gini_clf.fit(X_train, Y_train)\n gini_Y_hat = gini_clf.predict(X_test)\n gini_tp, gini_tn, gini_fp, gini_fn, gini_err = eval_results(Y_test, gini_Y_hat)\n\n entropy_clf = DecisionTreeClassifier(criterion=\"entropy\", random_state=0)\n entropy_clf.fit(X_train, Y_train)\n entropy_Y_hat = entropy_clf.predict(X_test)\n entropy_tp, entropy_tn, entropy_fp, entropy_fn, entropy_err = eval_results(Y_test, entropy_Y_hat)\n\n return {\n \"gini\":{\n 'True positives': gini_tp,\n 'True negatives': gini_tn,\n 'False positives': gini_fp,\n 'False negatives': gini_fn,\n 'Error rate': gini_err\n },\n \"entropy\":{\n 'True positives': entropy_tp,\n 'True negatives': entropy_tn,\n 'False positives': entropy_fp,\n 'False negatives': entropy_fn,\n 'Error rate': entropy_err\n }\n }","def main():\n \n # The following 5 command lines can be outcommented if the features are already created.\n # There is no need to process the data every single time.\n # Fine tuning the learning algorythm is much faster without that extra step.\n \n # by reading the train dataset the feature index is created.\n # First calling of the processdata function\n # Data limited to 300000\n featureIndexes = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000)\n print \"featureIndex generated!\"\n print len(featureIndexes)\n\n # Trainfeature is created using the indexfeatures...\n # Second calling of the processdata function\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000) # Original itemsLimit=300000\n\n # Building the test dataset... just like the training...\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\"avito_test.tsv\"), featureIndexes)\n\n # Dumping data into file...\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\"train_data.pkl\"))\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\"SeparatedByCategory.pkl\"))\n\n\n # loading data pack...\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\"train_data.pkl\"))\n\n #logging.info(\"Feature preparation done, fitting model...\")\n\n # Stochastic gradient model","def create_models(self):\r\n self.all_ratings = AllRatingsWithCommon(\r\n experts=self.users,\r\n objects=self.videos,\r\n output_features=self.features,\r\n name=\"prod\",\r\n )\r\n\r\n print_memory(stage=\"DPLF:ratings_nodata_created\")\r\n\r\n # creating models\r\n self.user_to_model = {\r\n user: FeaturelessPreferenceLearningModel(\r\n expert=user, all_ratings=self.all_ratings\r\n )\r\n for user in self.users\r\n }\r\n\r\n print_memory(stage=\"DPLF:models_created\")\r\n\r\n # before creating the aggregator, filling models with data\r\n self.user_to_size = {\r\n user: self.fill_model_data(self.user_to_model[user], user)\r\n for user in tqdmem(self.users, desc=\"fill_data\")\r\n }\r\n\r\n # virtual 'common' data\r\n fplm_common = FeaturelessPreferenceLearningModel(\r\n expert=AllRatingsWithCommon.COMMON_EXPERT, all_ratings=self.all_ratings\r\n )\r\n fplm_common.on_dataset_end()\r\n\r\n print_memory(stage=\"DPLF:data_filled\")\r\n\r\n # resetting the model given the data\r\n self.all_ratings.reset_model()\r\n\r\n print_memory(stage=\"DPLF:model_reset_ok\")\r\n\r\n # aggregating models\r\n self.aggregator = FeaturelessMedianPreferenceAverageRegularizationAggregator(\r\n models=[self.user_to_model[u] for u in self.users]\r\n )\r\n self.aggregator.certification_status = self.user_certified\r\n\r\n print_memory(stage=\"DPLF:aggregator_created\")","def main():\n # Read in trainingSet and testSet as a DataFrame\n trainingOriginal = pd.read_csv(\n filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.train.5fold.csv\")\n testOriginal = pd.read_csv(filepath_or_buffer=\"~/Desktop/KNN Implementation/adult.test.csv\")\n\n # Select only the numeric data\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\n training = pd.concat([training.reset_index(drop=True),\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Select only the numeric data\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\n test = pd.concat([test.reset_index(drop=True),\n testOriginal['earns'].reset_index(drop=True)], axis=1)\n\n # Normalize the columns for training and test\n # print training['age'].min()\n # print training['age'].max()\n # print training.head()\n\n # Run max-min normalization on numerical columns for testing and training data\n for i in range(6):\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\n\n # Convert the 'earns' column to boolean as follows\n training['earns'] = training['earns'] == '>50K'\n test['earns'] = test['earns'] == ' >50K'\n\n # Group the training set by the fold attribute as given by the dataset\n trainingForFinal = training\n training = training.groupby('fold')\n\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\n kList = []\n for i in range(40):\n if i % 2 == 1:\n kList.append(i)\n\n # Empty dictionary to hold performance of each k-values and its accuracy\n performance = {}\n\n # Compute the performance for each k-value\n for k in kList:\n performance = crossValidation(training, k, performance)\n\n # Sort the performance dictionary by its accuracy (value)\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\n\n # Open file to write results\n file = open('grid.results.txt', 'w')\n # Write the results to file\n file.write(\"K | Accuracy\\n\")\n for item in performance:\n if item[0] < 10:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n else:\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\n')\n # Close file\n file.close()\n\n # The best K is the one at the top of the list after the sorting\n bestK = performance[0][0]\n\n print 'Running Test Set with K = ' + str(bestK)\n\n applyModel(test,trainingForFinal,bestK)","def auto_ml():\r\n # Reading from file\r\n my_data = my_reader(config.filename, separ=config.file_separ)\r\n\r\n # Binary and Unary columns search\r\n is_binary_list = is_binary(my_data)\r\n is_unary_list = is_unary(my_data)\r\n\r\n # Time columns search\r\n is_time_list = is_time(my_data)\r\n\r\n # To dummy\r\n my_data = to_dummies(my_data)\r\n\r\n # Train-test split\r\n train_df, test_df = \\\r\n my_train_test_split(my_data, act_test_size=config.test_size)\r\n\r\n # Pure numbers will be the input variables\r\n input_vars = to_pure_numbers(my_data)\r\n\r\n # Choosing if it is a regression or classification\r\n global regression, classification\r\n regression, classification = guess_goal(my_data, config.target)\r\n\r\n # Modelling and building the pipeline\r\n n_neighbors = 15\r\n x_df = train_df[input_vars]\r\n if regression:\r\n pipe_1 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', LinearRegression(fit_intercept=True))])\r\n pipe_2 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model',\r\n neighbors.KNeighborsRegressor(n_neighbors,\r\n weights='distance'))])\r\n pipe_3 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', linear_model.BayesianRidge())])\r\n pipe_4 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', linear_model.SGDRegressor())])\r\n pipe_5 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', linear_model.ElasticNet())])\r\n pipe_6 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', linear_model.Ridge())])\r\n pipe_7 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', linear_model.Lasso())])\r\n pipe_8 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', RandomForestRegressor(max_depth=2,\r\n random_state=0,\r\n n_estimators=100))])\r\n pipe_dict = {0: 'LinearRegression',\r\n 1: 'KNeighborsRegressor',\r\n 2: 'BayesianRidge',\r\n 3: 'SGDRegressor',\r\n 4: 'ElasticNet',\r\n 5: 'Ridge',\r\n 6: 'Lasso',\r\n 7: 'RandomForestRegressor'}\r\n\r\n if classification:\r\n pipe_1 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', LogisticRegression(random_state=42))])\r\n pipe_2 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model',\r\n neighbors.KNeighborsClassifier(n_neighbors))])\r\n pipe_3 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', RandomForestClassifier(n_estimators=100,\r\n max_depth=2,\r\n random_state=0))])\r\n pipe_4 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', linear_model.SGDClassifier())])\r\n pipe_5 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', MLPClassifier())])\r\n pipe_6 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', GradientBoostingClassifier())])\r\n pipe_7 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', GaussianNB())])\r\n pipe_8 = Pipeline([('missing', MissingValueHandle()),\r\n ('duplicated', DuplicatedRowHandle()),\r\n ('discretize', Digitize()),\r\n ('standardize', Standardize()),\r\n ('minmaxscaler', MyMinMaxScaler()),\r\n ('model', SVC(gamma='auto'))])\r\n pipe_dict = {0: 'LogisticRegression',\r\n 1: 'KNeighborsClassifier',\r\n 2: 'RandomForestClassifier',\r\n 3: 'SGDClassifier',\r\n 4: 'MLPClassifier',\r\n 5: 'GradientBoostingClassifier',\r\n 6: 'GaussianNB',\r\n 7: 'SVC'}\r\n\r\n # List of pipelines\r\n pipelines = [pipe_1, pipe_2, pipe_3, pipe_4, pipe_5, pipe_6, pipe_7, pipe_8]\r\n\r\n # Fit the pipelines\r\n for pipe in pipelines:\r\n pipe.fit(x_df, train_df[config.target])\r\n\r\n # Is there outlier\r\n outlier_bool = is_outlier(x_df)\r\n\r\n corr_df = x_df.corr()\r\n\r\n # Open new file\r\n result_path = './test_eval/Result_params_' +\\\r\n str(config.filename.split(\"/\")[-1].split(\".\")[0]) + '.txt'\r\n result_file = open(result_path, 'w')\r\n result_file.write(\"Filename: \" + str(config.filename) + '\\n')\r\n result_file.write(\"Target: \" + str(config.target) + '\\n')\r\n if regression:\r\n result_file.write(\"Prediction type: Regression\" + '\\n')\r\n else:\r\n result_file.write(\"Prediction type: Classification\" + '\\n')\r\n result_file.write(\"Test size: \" + str(config.test_size*100) + \"%\" + '\\n')\r\n result_file.write(\"Model input columns: \" + str(input_vars) + '\\n')\r\n result_file.write(\"Used preparations: \" + '\\n')\r\n if config.missing_bool:\r\n result_file.write(\"Missing value handle (\" +\r\n str(config. missing_value_handle) +\r\n \"), \")\r\n if config.min_scaler_bool:\r\n result_file.write(\"Min scaling, \")\r\n if config.standardize_bool:\r\n result_file.write(\"Standardize, \")\r\n if config.to_dummies:\r\n result_file.write(\"To dummies\")\r\n result_file.write('\\n' + \"Discretize columns: \" +\r\n str(config.discretize) + '\\n')\r\n result_file.write(\"Binary columns: \" + str(is_binary_list) + '\\n')\r\n result_file.write(\"Unary columns: \" + str(is_unary_list) + '\\n')\r\n result_file.write(\"Time columns: \" + str(is_time_list) + '\\n')\r\n if outlier_bool:\r\n result_file.write(\"There is outlier in the data.\" + '\\n')\r\n\r\n # Evaluation\r\n result_df = pd.DataFrame()\r\n result_cols = []\r\n for idx, val in enumerate(pipelines):\r\n result_df = pd.concat([result_df,\r\n my_evaluation(val.predict(test_df[input_vars]),\r\n test_df[config.target])])\r\n result_cols.append(pipe_dict[idx])\r\n\r\n result_df.index = result_cols\r\n result_file.close()\r\n\r\n with pd.ExcelWriter(\"./test_eval/Evaluation_\"\r\n + str(config.filename.split(\"/\")[-1].split(\".\")[0])\r\n + \".xlsx\") as writer:\r\n if regression:\r\n result_df.to_excel(writer, sheet_name=\"Regression\")\r\n else:\r\n result_df.to_excel(writer, sheet_name=\"Classification\")\r\n corr_df.to_excel(writer, sheet_name=\"Correlation\")","def partition_data(dataset, datadir, logdir, partition, n_parties, beta=0.4):\n if dataset == 'mnist':\n X_train, y_train, X_test, y_test = load_mnist_data(datadir)\n elif dataset == 'fmnist':\n X_train, y_train, X_test, y_test = load_fmnist_data(datadir)\n elif dataset == 'cifar10':\n X_train, y_train, X_test, y_test = load_cifar10_data(datadir)\n elif dataset == 'svhn':\n X_train, y_train, X_test, y_test = load_svhn_data(datadir)\n elif dataset == 'celeba':\n X_train, y_train, X_test, y_test = load_celeba_data(datadir)\n elif dataset == 'femnist':\n X_train, y_train, u_train, X_test, y_test, u_test = load_femnist_data(datadir)\n elif dataset == 'cifar100':\n X_train, y_train, X_test, y_test = load_cifar100_data(datadir)\n elif dataset == 'tinyimagenet':\n X_train, y_train, X_test, y_test = load_tinyimagenet_data(datadir)\n print(\"y_train\",y_train.shape)\n print(\"y_test\",y_test.shape)\n\n elif dataset == 'generated':\n X_train, y_train = [], []\n for loc in range(4):\n for i in range(1000):\n p1 = random.random()\n p2 = random.random()\n p3 = random.random()\n if loc > 1:\n p2 = -p2\n if loc % 2 ==1:\n p3 = -p3\n if i % 2 == 0:\n X_train.append([p1, p2, p3])\n y_train.append(0)\n else:\n X_train.append([-p1, -p2, -p3])\n y_train.append(1)\n X_test, y_test = [], []\n for i in range(1000):\n p1 = random.random() * 2 - 1\n p2 = random.random() * 2 - 1\n p3 = random.random() * 2 - 1\n X_test.append([p1, p2, p3])\n if p1>0:\n y_test.append(0)\n else:\n y_test.append(1)\n X_train = np.array(X_train, dtype=np.float32)\n X_test = np.array(X_test, dtype=np.float32)\n y_train = np.array(y_train, dtype=np.int32)\n y_test = np.array(y_test, dtype=np.int64)\n idxs = np.linspace(0,3999,4000,dtype=np.int64)\n batch_idxs = np.array_split(idxs, n_parties)\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\n mkdirs(\"data/generated/\")\n np.save(\"data/generated/X_train.npy\",X_train)\n np.save(\"data/generated/X_test.npy\",X_test)\n np.save(\"data/generated/y_train.npy\",y_train)\n np.save(\"data/generated/y_test.npy\",y_test)\n \n #elif dataset == 'covtype':\n # cov_type = sk.fetch_covtype('./data')\n # num_train = int(581012 * 0.75)\n # idxs = np.random.permutation(581012)\n # X_train = np.array(cov_type['data'][idxs[:num_train]], dtype=np.float32)\n # y_train = np.array(cov_type['target'][idxs[:num_train]], dtype=np.int32) - 1\n # X_test = np.array(cov_type['data'][idxs[num_train:]], dtype=np.float32)\n # y_test = np.array(cov_type['target'][idxs[num_train:]], dtype=np.int32) - 1\n # mkdirs(\"data/generated/\")\n # np.save(\"data/generated/X_train.npy\",X_train)\n # np.save(\"data/generated/X_test.npy\",X_test)\n # np.save(\"data/generated/y_train.npy\",y_train)\n # np.save(\"data/generated/y_test.npy\",y_test)\n\n elif dataset in ('rcv1', 'SUSY', 'covtype'):\n X_train, y_train = load_svmlight_file(\"../../../data/{}\".format(dataset))\n X_train = X_train.todense()\n num_train = int(X_train.shape[0] * 0.75)\n if dataset == 'covtype':\n y_train = y_train-1\n else:\n y_train = (y_train+1)/2\n idxs = np.random.permutation(X_train.shape[0])\n\n X_test = np.array(X_train[idxs[num_train:]], dtype=np.float32)\n y_test = np.array(y_train[idxs[num_train:]], dtype=np.int32)\n X_train = np.array(X_train[idxs[:num_train]], dtype=np.float32)\n y_train = np.array(y_train[idxs[:num_train]], dtype=np.int32)\n\n mkdirs(\"data/generated/\")\n np.save(\"data/generated/X_train.npy\",X_train)\n np.save(\"data/generated/X_test.npy\",X_test)\n np.save(\"data/generated/y_train.npy\",y_train)\n np.save(\"data/generated/y_test.npy\",y_test)\n\n elif dataset in ('a9a'):\n X_train, y_train = load_svmlight_file(\"../../../data/{}\".format(dataset))\n X_test, y_test = load_svmlight_file(\"../../../data/{}.t\".format(dataset))\n X_train = X_train.todense()\n X_test = X_test.todense()\n X_test = np.c_[X_test, np.zeros((len(y_test), X_train.shape[1] - np.size(X_test[0, :])))]\n\n X_train = np.array(X_train, dtype=np.float32)\n X_test = np.array(X_test, dtype=np.float32)\n y_train = (y_train+1)/2\n y_test = (y_test+1)/2\n y_train = np.array(y_train, dtype=np.int32)\n y_test = np.array(y_test, dtype=np.int32)\n\n mkdirs(\"data/generated/\")\n np.save(\"data/generated/X_train.npy\",X_train)\n np.save(\"data/generated/X_test.npy\",X_test)\n np.save(\"data/generated/y_train.npy\",y_train)\n np.save(\"data/generated/y_test.npy\",y_test)\n\n\n n_train = y_train.shape[0]\n \n if partition == \"manual\":\n label_idxs = {i:[] for i in np.unique(y_train)}\n label_node_map = {i:[] for i in label_idxs.keys()} \n label_node_map[0] = [0,5,10,15,20]\n label_node_map[1] = [0,5,10,15,20]\n label_node_map[2] = [1,6,11,16,21]\n label_node_map[3] = [1,6,11,16,21]\n label_node_map[4] = [2,7,12,17,22]\n label_node_map[5] = [2,7,12,17,22]\n label_node_map[6] = [3,8,13,18,23]\n label_node_map[7] = [3,8,13,18,23]\n label_node_map[8] = [4,9,14,19]\n label_node_map[9] = [4,9,14,19]\n\n \n for i,label in enumerate(y_train):\n label_idxs[label].append(i)\n \n net_dataidx_map = {i:[] for i in range(n_parties)}\n for label, idxs in label_idxs.items():\n batch_idxs = np.array_split(idxs, len(label_node_map[label]))\n for i, net_id in enumerate(label_node_map[label]):\n net_dataidx_map[net_id] += list(batch_idxs[i])\n \n\n if partition == \"homo\":\n idxs = np.random.permutation(n_train)\n batch_idxs = np.array_split(idxs, n_parties)\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\n \n\n\n elif partition == \"noniid-labeldir\":\n min_size = 0\n min_require_size = 10\n K = 10\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\n K = 2\n elif dataset in ('tinyimagenet'):\n K = 200\n # min_require_size = 100\n elif dataset in ('cifar100'):\n K = 100\n\n N = y_train.shape[0]\n #np.random.seed(2020)\n net_dataidx_map = {}\n\n while min_size < min_require_size:\n idx_batch = [[] for _ in range(n_parties)]\n for k in range(K):\n idx_k = np.where(y_train == k)[0]\n np.random.shuffle(idx_k)\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\n # logger.info(\"proportions1: \", proportions)\n # logger.info(\"sum pro1:\", np.sum(proportions))\n ## Balance\n proportions = np.array([p * (len(idx_j) < N / n_parties) for p, idx_j in zip(proportions, idx_batch)])\n # logger.info(\"proportions2: \", proportions)\n proportions = proportions / proportions.sum()\n # logger.info(\"proportions3: \", proportions)\n proportions = (np.cumsum(proportions) * len(idx_k)).astype(int)[:-1]\n # logger.info(\"proportions4: \", proportions)\n idx_batch = [idx_j + idx.tolist() for idx_j, idx in zip(idx_batch, np.split(idx_k, proportions))]\n min_size = min([len(idx_j) for idx_j in idx_batch])\n # if K == 2 and n_parties <= 10:\n # if np.min(proportions) < 200:\n # min_size = 0\n # break\n\n\n for j in range(n_parties):\n np.random.shuffle(idx_batch[j])\n net_dataidx_map[j] = idx_batch[j]\n\n elif partition > \"noniid-#label0\" and partition <= \"noniid-#label9\":\n num = eval(partition[13:])\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\n num = 1\n K = 2\n else:\n K = 10\n if dataset == \"cifar100\":\n K = 100\n elif dataset == \"tinyimagenet\":\n K = 200\n if num == 10:\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\n for i in range(10):\n idx_k = np.where(y_train==i)[0]\n np.random.shuffle(idx_k)\n split = np.array_split(idx_k,n_parties)\n for j in range(n_parties):\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[j])\n else:\n times=[0 for i in range(K)]\n contain=[]\n for i in range(n_parties):\n current=[i%K]\n times[i%K]+=1\n j=1\n while (j<num):\n ind=random.randint(0,K-1)\n if (ind not in current):\n j=j+1\n current.append(ind)\n times[ind]+=1\n contain.append(current)\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\n for i in range(K):\n idx_k = np.where(y_train==i)[0]\n np.random.shuffle(idx_k)\n split = np.array_split(idx_k,times[i])\n ids=0\n for j in range(n_parties):\n if i in contain[j]:\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[ids])\n ids+=1\n\n\n elif partition == \"iid-diff-quantity\":\n idxs = np.random.permutation(n_train)\n min_size = 0\n while min_size < 10:\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\n proportions = proportions/proportions.sum()\n min_size = np.min(proportions*len(idxs))\n proportions = (np.cumsum(proportions)*len(idxs)).astype(int)[:-1]\n batch_idxs = np.split(idxs,proportions)\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\n \n elif partition == \"mixed\":\n min_size = 0\n min_require_size = 10\n K = 10\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\n K = 2\n # min_require_size = 100\n\n N = y_train.shape[0]\n net_dataidx_map = {}\n\n times=[1 for i in range(10)]\n contain=[]\n for i in range(n_parties):\n current=[i%K]\n j=1\n while (j<2):\n ind=random.randint(0,K-1)\n if (ind not in current and times[ind]<2):\n j=j+1\n current.append(ind)\n times[ind]+=1\n contain.append(current)\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\n \n\n min_size = 0\n while min_size < 10:\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\n proportions = proportions/proportions.sum()\n min_size = np.min(proportions*n_train)\n\n for i in range(K):\n idx_k = np.where(y_train==i)[0]\n np.random.shuffle(idx_k)\n\n proportions_k = np.random.dirichlet(np.repeat(beta, 2))\n #proportions_k = np.ndarray(0,dtype=np.float64)\n #for j in range(n_parties):\n # if i in contain[j]:\n # proportions_k=np.append(proportions_k ,proportions[j])\n\n proportions_k = (np.cumsum(proportions_k)*len(idx_k)).astype(int)[:-1]\n\n split = np.split(idx_k, proportions_k)\n ids=0\n for j in range(n_parties):\n if i in contain[j]:\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[ids])\n ids+=1\n\n elif partition == \"real\" and dataset == \"femnist\":\n num_user = u_train.shape[0]\n user = np.zeros(num_user+1,dtype=np.int32)\n for i in range(1,num_user+1):\n user[i] = user[i-1] + u_train[i-1]\n no = np.random.permutation(num_user)\n batch_idxs = np.array_split(no, n_parties)\n net_dataidx_map = {i:np.zeros(0,dtype=np.int32) for i in range(n_parties)}\n for i in range(n_parties):\n for j in batch_idxs[i]:\n net_dataidx_map[i]=np.append(net_dataidx_map[i], np.arange(user[j], user[j+1]))\n\n traindata_cls_counts = record_net_data_stats(y_train, net_dataidx_map, logdir)\n return (X_train, y_train, X_test, y_test, net_dataidx_map, traindata_cls_counts)","def fit(self, training_data_x, training_data_y, fraction_opt):\n self.training_data_train_x, self.training_data_opt_x, self.training_data_train_y, \\\n self.training_data_opt_y = train_test_split(training_data_x, training_data_y,\n test_size=fraction_opt, random_state=0)\n self.result = self.cherry_pick()","def data_setup(self):\n # Make sure the dataset is download and put into the data folder\n training_data = pd.read_csv('./data/train.csv', sep=',', nrows=self.training_dataset_size)\n testing_data = pd.read_csv('./data/test.csv', sep=',' , nrows=self.training_dataset_size)\n question_list1 = training_data['question1']\n question_list2 = training_data['question2']\n is_duplicate = training_data['is_duplicate']\n # for will\n X = []\n Y = []\n for i in range(0, 1000):\n print(\"*\"*20, i ,\"*\"*20 )\n feature = self.call_feature_generator(question_list1[i],question_list2[i], self.feature_code )\n X.append(feature)\n Y.append(is_duplicate[i])\n print(feature)\n print(is_duplicate[i])\n print(question_list1[i])\n print(question_list2[i])\n\n # we train classifier\n\n classifer = self.call_classifier(X, Y, self.classifier_code)\n\n # testing\n testX = []\n testY = []\n\n for i in range(1001, 1500):\n print(\"-\"*20, i ,\"-\"*20 )\n feature = self.call_feature_generator(question_list1[i],question_list2[i], self.feature_code )\n testX.append(feature)\n testY.append(is_duplicate[i])\n\n X= np.array(testX).reshape(-1,1)\n\n calculate_y = classifer.predict(X)\n\n print(calculate_y)\n tp = 0.0\n fp = 0.0\n fn = 0.0\n\n for i in range(0, len(calculate_y)):\n if calculate_y[i] == testY[i]:\n print(\"Tp : \", testX[i], question_list1[i], question_list2[i], is_duplicate[i] )\n tp += 1.0\n else:\n if testY[i] == 1 and calculate_y[i] == 0:\n print(\"Fn : \", testX[i] , question_list1[i], question_list2[i], is_duplicate[i] )\n fn += 1.0\n else:\n print(\"Fp : \", testX[i], question_list1[i], question_list2[i], is_duplicate[i])\n fp += 1.0\n\n print(\"Tp: \", tp, \" Fp: \", fp, \" Fn: \", fn)\n print(\"Accuracy \", tp/( tp+fn), \"%\")\n\n result = precision_recall_fscore_support(testY, calculate_y)\n print (\"Precision: Class 1 - \", result[0][0], \"% and Class 0 - \", result[0][1], \"%\")\n print (\"Recall: Class 1 - \", result[1][0], \"% and Class 0 - \", result[1][1], \"%\")\n print (\"F-Score: Class 1 - \", result[2][0], \"% and Class 0 - \", result[2][1], \"%\")","def prepare_data(self, *args, **kwargs):\n # get paths to train and test splits\n _split_paths = [os.path.join(self.path_to_data, split)\n for split in os.listdir(self.path_to_data)]\n\n # for each split [train, test]\n for _path in _split_paths:\n _img_classes = os.listdir(_path) # get subfolders representing each class\n self.splits[os.path.basename(_path)] = []\n\n # get the images in pairs with its corresponding class\n for _class in _img_classes:\n _data = self.get_img_text_pair(os.path.join(_path, _class))\n\n if os.path.basename(_path) == 'train':\n self.weights[self.encode_label(_class)] = len(_data)\n self.splits[os.path.basename(_path)].extend(_data)","def assessStrategyGlobal(test_beginning_match,\r\n duration_train_matches,\r\n duration_val_matches,\r\n duration_test_matches,\r\n xgb_params,\r\n nb_players,\r\n nb_tournaments,\r\n features,\r\n data,\r\n model_name=\"0\"):\r\n ########## Training/validation/testing set generation\r\n\r\n # Number of matches in our dataset (ie. nb. of outcomes divided by 2)\r\n nm = int(len(features) / 2)\r\n\r\n # Id of the first and last match of the testing,validation,training set\r\n beg_test = test_beginning_match\r\n end_test = min(test_beginning_match + duration_test_matches - 1, nm - 1)\r\n end_val = min(beg_test - 1, nm - 1)\r\n beg_val = beg_test - duration_val_matches\r\n end_train = beg_val - 1\r\n beg_train = beg_val - duration_train_matches\r\n\r\n train_indices = range(2 * beg_train, 2 * end_train + 2)\r\n val_indices = range(2 * beg_val, 2 * end_val + 2)\r\n test_indices = range(2 * beg_test, 2 * end_test + 2)\r\n\r\n if (len(test_indices) == 0) | (len(train_indices) == 0):\r\n return 0\r\n\r\n # Split in train/validation/test\r\n xval = features.iloc[val_indices, :].reset_index(drop=True)\r\n xtest = features.iloc[test_indices, :].reset_index(drop=True)\r\n xtrain = features.iloc[train_indices, :].reset_index(drop=True)\r\n ytrain = pd.Series([1, 0] * int(len(train_indices) / 2))\r\n yval = pd.Series([1, 0] * int(len(val_indices) / 2))\r\n\r\n # We limit the number of players and tournaments one-hot encoded : we'll keep only the\r\n # players that won the most matches to avoid overfitting and make the process quicker\r\n # Biggest players :\r\n biggest_players = data.iloc[range(beg_train, end_train), :][[\"Winner\", \"Loser\"]]\r\n biggest_players = pd.concat([biggest_players.Winner, biggest_players.Loser], 0)\r\n biggest_players = list(biggest_players.value_counts().index[:nb_players])\r\n player_columns = [el for el in xtrain.columns if el[:6] == \"player\"]\r\n to_drop_players = [el for el in player_columns if el[7:] not in biggest_players]\r\n # Biggest Tournaments\r\n biggest_tournaments = data.iloc[range(beg_train, end_train), :][\"Tournament\"]\r\n biggest_tournaments = list(biggest_tournaments.value_counts().index[:nb_tournaments])\r\n tournament_columns = [el for el in xtrain.columns if el[:10] == \"tournament\"]\r\n to_drop_tournaments = [el for el in tournament_columns if el[11:] not in biggest_tournaments]\r\n # We drop smallest Tournaments and players\r\n xtrain = xtrain.drop(to_drop_players + to_drop_tournaments, 1)\r\n xval = xval.drop(to_drop_players + to_drop_tournaments, 1)\r\n xtest = xtest.drop(to_drop_players + to_drop_tournaments, 1)\r\n\r\n ### ML model training\r\n model = xgbModelBinary(xtrain, ytrain, xval, yval, xgb_params, sample_weights=None)\r\n\r\n # The probability given by the model to each outcome of each match :\r\n pred_test = model.predict(xgb.DMatrix(xtest, label=None))\r\n # For each match, the winning probability the model gave to the players that won (should be high...) :\r\n prediction_test_winner = pred_test[range(0, len(pred_test), 2)]\r\n # For each match, the winning probability the model gave to the players that lost (should be low...) :\r\n prediction_test_loser = pred_test[range(1, len(pred_test), 2)]\r\n\r\n ### Odds and predicted probabilities for the testing set (1 row/match)\r\n odds = data[[\"PSW\", \"PSL\"]].iloc[range(beg_test, end_test + 1)]\r\n implied_probabilities = 1 / odds\r\n p = pd.Series(\r\n list(zip(prediction_test_winner, prediction_test_loser, implied_probabilities.PSW, implied_probabilities.PSL)))\r\n\r\n ### For each match in the testing set, if the model predicted the right winner :\r\n right = (prediction_test_winner > prediction_test_loser).astype(int)\r\n\r\n ### For each match in the testing set, the confidence of the model in the outcome it chose\r\n def sel_match_confidence(x):\r\n if x[0] > x[1]:\r\n return x[0] / x[2]\r\n else:\r\n return x[1] / x[3]\r\n\r\n confidence = p.apply(lambda x: sel_match_confidence(x))\r\n\r\n ### The final confidence dataset\r\n confidenceTest = pd.DataFrame({\"match\": range(beg_test, end_test + 1),\r\n \"win\" + model_name: right,\r\n \"confidence\" + model_name: confidence,\r\n \"PSW\": odds.PSW.values})\r\n confidenceTest = confidenceTest.sort_values(\"confidence\" + model_name, ascending=False).reset_index(drop=True)\r\n\r\n return confidenceTest","def _train_model(\n self,\n dataset: DatasetEntity,\n ):\n logger.info(\"init data cfg.\")\n self._data_cfg = ConfigDict(data=ConfigDict())\n\n for cfg_key, subset in zip(\n [\"train\", \"val\", \"unlabeled\"],\n [Subset.TRAINING, Subset.VALIDATION, Subset.UNLABELED],\n ):\n subset = get_dataset(dataset, subset)\n if subset and self._data_cfg is not None:\n self._data_cfg.data[cfg_key] = ConfigDict(\n otx_dataset=subset,\n labels=self._labels,\n )\n\n self._is_training = True\n\n self._init_task()\n\n cfg = self.configure(True, None)\n logger.info(\"train!\")\n\n timestamp = time.strftime(\"%Y%m%d_%H%M%S\", time.localtime())\n\n # Environment\n logger.info(f\"cfg.gpu_ids = {cfg.gpu_ids}, distributed = {cfg.distributed}\")\n env_info_dict = collect_env()\n env_info = \"\\n\".join([(f\"{k}: {v}\") for k, v in env_info_dict.items()])\n dash_line = \"-\" * 60 + \"\\n\"\n logger.info(f\"Environment info:\\n{dash_line}{env_info}\\n{dash_line}\")\n\n # Data\n datasets = [build_dataset(cfg.data.train)]\n\n if self._train_type == TrainType.Semisupervised:\n # forward the knowledge of num iters per epoch to model for filter loss\n bs_per_gpu = cfg.data.train_dataloader[\"samples_per_gpu\"]\n actual_bs = bs_per_gpu * torch.distributed.get_world_size() if cfg.distributed else bs_per_gpu\n cfg.model.num_iters_per_epoch = math.ceil(len(datasets[0]) / actual_bs)\n\n # FIXME: Currently segmentor does not support multi batch evaluation.\n # For the Self-SL case, there is no val data. So, need to check the\n\n if \"val\" in cfg.data and \"val_dataloader\" in cfg.data:\n cfg.data.val_dataloader[\"samples_per_gpu\"] = 1\n\n # Target classes\n if \"task_adapt\" in cfg:\n target_classes = cfg.task_adapt.final\n else:\n target_classes = datasets[0].CLASSES\n\n # Metadata\n meta = dict()\n meta[\"env_info\"] = env_info\n meta[\"seed\"] = cfg.seed\n meta[\"exp_name\"] = cfg.work_dir\n if cfg.checkpoint_config is not None:\n cfg.checkpoint_config.meta = dict(\n mmseg_version=__version__ + get_git_hash()[:7],\n CLASSES=target_classes,\n )\n\n # Model\n model = self.build_model(cfg, fp16=cfg.get(\"fp16\", False), is_training=self._is_training)\n model.train()\n model.CLASSES = target_classes\n\n if cfg.distributed:\n convert_sync_batchnorm(model)\n\n validate = bool(cfg.data.get(\"val\", None))\n\n if self._hyperparams.learning_parameters.auto_adapt_batch_size != BatchSizeAdaptType.NONE:\n train_func = partial(train_segmentor, meta=deepcopy(meta), model=deepcopy(model), distributed=False)\n adapt_batch_size(\n train_func,\n cfg,\n datasets,\n isinstance(self, NNCFBaseTask), # nncf needs eval hooks\n not_increase=(self._hyperparams.learning_parameters.auto_adapt_batch_size == BatchSizeAdaptType.SAFE),\n )\n\n train_segmentor(\n model,\n datasets,\n cfg,\n distributed=cfg.distributed,\n validate=validate,\n timestamp=timestamp,\n meta=meta,\n )\n\n # Save outputs\n output_ckpt_path = os.path.join(cfg.work_dir, \"latest.pth\")\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \"best_mDice_*.pth\"))\n if len(best_ckpt_path) > 0:\n output_ckpt_path = best_ckpt_path[0]\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \"best_mIoU_*.pth\"))\n if len(best_ckpt_path) > 0:\n output_ckpt_path = best_ckpt_path[0]\n return dict(\n final_ckpt=output_ckpt_path,\n )","def main():\n housing = pd.read_csv(\"Data/train_original.csv\")\n housing[\"TotalSF\"] = (\n housing[\"TotalBsmtSF\"] + housing[\"1stFlrSF\"] + housing[\"2ndFlrSF\"]\n )\n training_features, testing_features, training_target, testing_target = impute_dummify_and_split(\n housing, drop_target=False\n )\n\n p_values = [\n (c, pearsonr(training_features[\"SalePrice\"], training_features[c])[1])\n for c in training_features.columns\n ]\n\n p_value_limits = [0.05]\n\n result = []\n ps_and_cols = {}\n\n for p_value_limit in p_value_limits:\n\n high_ps = list(\n map(lambda t: t[0], sorted(p_values, key=lambda t1: t1[1])[:15])\n )\n\n print(training_features[high_ps].corr())\n\n columns = [p[0] for p in p_values if p[1] < p_value_limit]\n\n training_features_restricted = training_features[columns].drop(\n \"SalePrice\", axis=\"columns\"\n )\n\n testing_features_restricted = testing_features[columns].drop(\n \"SalePrice\", axis=\"columns\"\n )\n\n for model in (\n linear_model.Lasso(alpha=2.1),\n linear_model.Ridge(alpha=2.1),\n ):\n\n model.fit(training_features_restricted, training_target)\n\n train_score = model.score(\n training_features_restricted, training_target\n )\n\n test_score = model.score(\n testing_features_restricted, testing_target\n )\n\n name = str(model).split(\"(\")[0]\n\n result = result + [\n (\n \"_2_restrict_features\",\n name,\n \"p value limit: {:.3f}, alpha: 2.1\".format(p_value_limit),\n train_score,\n test_score,\n )\n ]\n\n print(ps_and_cols)\n return training_features[high_ps].corr()","def growing_testset(train_filename, test_filename, clf, clf_name=None):\n train_features, train_groundtruths = read_file(train_filename)\n test_features, test_groundtruths = read_file(test_filename)\n \n if clf_name is not None and \"RANSAC\" in clf_name:\n train_groundtruths = [True if i ==\"s\" else False for i in train_groundtruths]\n test_groundtruths = [True if i ==\"s\" else False for i in test_groundtruths]\n\n clf.fit(train_features, train_groundtruths)\n\n if clf_name is not None and \"RANSAC\" in clf_name:\n preds_float = clf.predict(test_features)\n predictions = [True if i > 0.5 else False for i in preds_float]\n else:\n predictions = clf.predict(test_features)\n \n test_acc = []\n # test_acc.append(accuracy_score(test_groundtruths, predictions))\n test_acc.append(precision_score(test_groundtruths, predictions, average=None)[0])\n print(\"Accuracy : \" + str(test_acc))\n print(\"Precision: \" + str(precision_score(test_groundtruths, predictions, average=None)))\n print(\"Recall : \" + str(recall_score(test_groundtruths, predictions, average=None)))\n print(\"F-score : \" + str(f1_score(test_groundtruths, predictions, average=None)))\n\n n_splits = 10\n for n_split in range(2, n_splits+1):\n print(n_split)\n feats_array, gts_array = split(test_features, test_groundtruths, n_split)\n tmp_acc = []\n for feats, gts in zip(feats_array, gts_array):\n if clf_name is not None and \"RANSAC\" in clf_name:\n preds_float = clf.predict(feats)\n predictions = [True if i > 0.5 else False for i in preds_float]\n else:\n predictions = clf.predict(feats)\n # cur_acc = accuracy_score(gts, predictions)\n cur_acc = precision_score(gts, predictions, average=None)[0]\n tmp_acc.append(cur_acc)\n print(\"\\t\" + str(cur_acc))\n accuracy = sum(tmp_acc) / float(len(tmp_acc))\n test_acc.append(accuracy)\n return test_acc","def testTrainSplit(self, feature, Class, test_size = 0.2, \n random_state = 0):\n # training and testing sets\n fTrain, fTest, cTrain, cTest = train_test_split( feature, Class,\n test_size = test_size, \n random_state = random_state)\n self.fTrain = fTrain\n self.fTest = fTest\n self.cTrain = cTrain\n self.cTest = cTest\n \n return fTrain, fTest, cTrain, cTest","def gen_train_val_test_split(self, splits=[0.7, 0.2, 0.1], random_state=42):\n patient_dirs = os.listdir(self.out_dir)\n msk_list, img_list, patient_list, is_tumor = [], [], [], []\n\n for patient in patient_dirs:\n patient_folder = os.path.join(self.out_dir, patient)\n if not os.path.isdir(patient_folder):\n continue\n\n patient_root = os.path.join(self.out_dir, patient)\n for file in os.listdir(patient_root):\n if \"mask\" not in file:\n patient_list.append(patient)\n img_list.append(os.path.join(patient_root, file))\n msk_list.append(os.path.join(patient_root, file[:file.find(\".npy\")] + \"_mask.npy\"))\n \n img = np.load(msk_list[-1])\n if np.mean(img) > 0:\n is_tumor.append(1)\n else:\n is_tumor.append(0)\n \n data = pd.DataFrame(data={\"Patient\": patient_list, \"Image\": img_list, \"Mask\": msk_list, \"Tumor Present\": is_tumor})\n self.train_df, self.valid_df, self.test_df = self._split_by_patients(data, val_split=splits[1], test_split=splits[2], random_state=random_state)\n # print(len(train), len(val), len(test))\n # self.train_df = data[data[\"Patient\"].isin(train)]\n # self.valid_df = data[data[\"Patient\"].isin(val)]\n # self.test_df = data[data[\"Patient\"].isin(test)]","def train(self, args_hpo, index):\n\n PrintColors.prYellow(f'\\n===== training with: {args_hpo} index={index}')\n PrintColors.prGreen(f'---- in mode: {self.configurations.execution_mode}, tag: {self.configurations.tag} ----')\n ''' ============ LOAD DATA ================================================================================ '''\n starting_time = time.time()\n dataset_reader = self.dataset_reader(\n candidate_types=self.configurations.clustering_mode,\n word_indexer={'words': PretrainedTransformerIndexer(self.configurations.pretrained_model_name)},\n mode=self.configurations.loading_mode)\n ''' .read returns list of instances '''\n train_data, val_data, test_data = (dataset_reader.read(folder) for folder in\n [self.configurations.train_data_dir,\n self.configurations.val_data_dir,\n self.configurations.test_data_dir])\n\n # count state pairs\n preceeds = dict()\n\n for instance in train_data:\n for ind in range(len(instance.fields['squeezed_labels'].tokens) - 1):\n [event_1, event_2] = [instance.fields['squeezed_labels'].tokens[i].text for i in [ind, ind + 1]]\n scenario = self.dataset_reader.scenario_of_label(event_1)\n if scenario not in preceeds:\n preceeds[scenario] = dict()\n if (event_1, event_2) not in preceeds[scenario]:\n preceeds[scenario][(event_1, event_2)] = 0\n preceeds[scenario][(event_1, event_2)] += 1\n\n pretrained_tokenizer = PretrainedTransformerTokenizer(self.configurations.pretrained_model_name)\n supply_token_indices(train_data + val_data, 'story', pretrained_tokenizer)\n\n ''' build vocabulary and associate it with datasets '''\n vocabulary = Vocabulary.from_instances(train_data + val_data)\n train_data.index_with(vocabulary), val_data.index_with(vocabulary)\n\n train_data_loader = DataLoader(dataset=train_data, batch_size=args_hpo.batch_size)\n val_data_loader = DataLoader(dataset=val_data, batch_size=args_hpo.batch_size)\n\n ''' ============ DEFINE MODEL ============================================================================= '''\n ''' i keep .to() here instead of in model.__init__() to accomadate better abstraction '''\n event_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\n if '#' in vocabulary.get_token_from_index(i, 'scr_labels')]\n participant_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\n if '@' in vocabulary.get_token_from_index(i, 'scr_labels')]\n model = self.model(args_hpo, vocabulary, configurations=self.configurations,\n preceeds=preceeds,\n event_indices=event_labels,\n participant_indices=participant_labels).to(self.configurations.device)\n\n ''' ============ DEFINE TRAINER =========================================================================== '''\n ''' -- serialization --------------------------------------------------- '''\n if not os.path.exists(os.path.join(*['.', 'models'])):\n os.mkdir(os.path.join(*['.', 'models']))\n if index == 0:\n for file in os.listdir(os.path.join(*['.', 'models'])):\n path = os.path.join(*['.', 'models', file])\n if os.path.isfile(path):\n os.remove(path)\n else:\n shutil.rmtree(path)\n serialization_path = 'models_{}_{}'.format(self.configurations.tag, index)\n serialization_path_longer = os.path.join(*['.', 'models', serialization_path])\n vocab_path = 'vocab_{}_{}'.format(self.configurations.tag, index)\n vocab_dir_longer = os.path.join(*['.', 'models', vocab_path])\n if not os.path.exists(serialization_path_longer):\n os.mkdir(serialization_path_longer)\n model_checkpointer = Checkpointer(serialization_dir=serialization_path_longer, num_serialized_models_to_keep=1)\n ''' -- logging ---------------------------------------------------------- '''\n tensorboard_writer = TensorboardWriter(serialization_dir='tensorboard', summary_interval=1)\n if index == 0:\n shutil.rmtree(os.path.join(*['.', 'tensorboard', 'log']))\n\n optimizer = torch.optim.Adam(model.parameters(), lr=args_hpo.lr, weight_decay=args_hpo.l2)\n trainer = GradientDescentTrainer(\n model=model,\n optimizer=optimizer,\n data_loader=train_data_loader,\n validation_data_loader=val_data_loader,\n # note: this is the metric for early stopping\n validation_metric='-loss',\n patience=self.configurations.patience,\n num_epochs=self.configurations.max_epochs,\n serialization_dir=serialization_path_longer,\n checkpointer=model_checkpointer,\n cuda_device=self.configurations.device,\n grad_norm=args_hpo.clip,\n tensorboard_writer=tensorboard_writer,\n learning_rate_scheduler=ReduceOnPlateauLearningRateScheduler(optimizer=optimizer)\n )\n\n ''' trainer saves the model, but the vocabulary needs to be saved, too '''\n vocabulary.save_to_files(vocab_dir_longer)\n\n ''' check the metric names to synchronize with the class '''\n metrics = trainer.train()\n test_metrics = model.test(test_data=test_data, dataset_reader=dataset_reader)\n metrics.update(test_metrics)\n metrics['time_consumed(hrs)'] = round((time.time() - starting_time) / 3600, 4)\n\n return metrics","def test(cfg):\n # Set up environment.\n distributed.init_distributed_training(cfg)\n\n # Set random seed from configs.\n np.random.seed(cfg.RNG_SEED)\n torch.manual_seed(cfg.RNG_SEED)\n\n # Print config.\n if distributed.is_master_proc():\n print(\"Test with config:\")\n print(cfg)\n\n # Build the model and print model statistics.\n # Use cuda if available\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n # Construct the model\n model = PanopticNarrativeGroundingBaseline(cfg, device=device)\n # Determine the GPU used by the current process\n cur_device = torch.cuda.current_device()\n # Transfer the model to the current GPU device\n model = model.cuda(device=cur_device)\n if cfg.NUM_GPUS > 1:\n # Make model replica operate on the current device\n model = torch.nn.parallel.DistributedDataParallel(\n module=model, device_ids=[cur_device], output_device=cur_device,\n find_unused_parameters=True\n )\n if cfg.LOG_MODEL_INFO and distributed.is_master_proc():\n print(\"Model:\\n{}\".format(model))\n print(\"Params: {:,}\".format(np.sum([p.numel() for p in model.parameters()]).item()))\n print(\"Mem: {:,} MB\".format(torch.cuda.max_memory_allocated() / 1024 ** 3))\n print(\"nvidia-smi\")\n os.system(\"nvidia-smi\")\n\n # Load a checkpoint to test if applicable.\n checkpoint_path = osp.join(cfg.OUTPUT_DIR, 'model_final.pth')\n if cfg.TEST.CHECKPOINT_FILE_PATH != \"\":\n checkpoint_path = cfg.TEST.CHECKPOINT_FILE_PATH\n if osp.exists(checkpoint_path):\n if distributed.is_master_proc():\n print('Loading model from: {0}'.format(checkpoint_path))\n checkpoint = torch.load(checkpoint_path, map_location=\"cpu\")\n if cfg.NUM_GPUS > 1:\n model.module.load_state_dict(checkpoint['model_state'])\n else:\n model.load_state_dict(checkpoint['model_state'])\n elif cfg.TRAIN.CHECKPOINT_FILE_PATH != \"\":\n # If no checkpoint found in TEST.CHECKPOINT_FILE_PATH or in the current\n # checkpoint folder, try to load checkpoint from\n # TRAIN.CHECKPOINT_FILE_PATH and test it.\n checkpoint_path = cfg.TRAIN.CHECKPOINT_FILE_PATH\n checkpoint = torch.load(checkpoint_path, map_location=\"cpu\")\n if cfg.NUM_GPUS > 1:\n model.module.load_state_dict(checkpoint['model_state'])\n else:\n model.load_state_dict(checkpoint['model_state'])\n else:\n if distributed.is_master_proc():\n print(\"Testing with random initialization. Only for debugging.\")\n\n # Create testing loaders.\n test_dataset = PanopticNarrativeGroundingDataset(cfg, cfg.DATA.VAL_SPLIT, train=False)\n test_loader = DataLoader(\n test_dataset,\n batch_size=int(cfg.TRAIN.BATCH_SIZE / max(1, cfg.NUM_GPUS)),\n shuffle=False,\n sampler=(DistributedSampler(test_dataset) if cfg.NUM_GPUS > 1 else None),\n num_workers=cfg.DATA_LOADER.NUM_WORKERS,\n pin_memory=cfg.DATA_LOADER.PIN_MEMORY\n )\n \n if distributed.is_master_proc():\n print(\"Testing model for {} iterations\".format(len(test_loader)))\n\n # Perform test on the entire dataset.\n perform_test(test_loader, model, cfg)","def train_test_split(self) -> None:\n\n X = self._df[['Avg. Area Income', 'Avg. Area House Age', 'Avg. Area Number of Rooms',\n 'Avg. Area Number of Bedrooms', 'Area Population']]\n y = self._df['Price']\n\n self._X_train, self._X_test, self._y_train, self._y_test = train_test_split(\n X, y, test_size=0.4, random_state=42)","def generate_train_test(self):\n x, y = self.read_data()\n x_train, y_train, x_test, y_test = self.sample_data(x, y)\n self.train = (x_train, y_train)\n self.test = (x_test, y_test)","def get_dataloader(data_folder, model_name, data_name, size=\"default\"):\n training_set = None\n validation_set = None\n\n if model_name == \"Howe_Patterson\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\n\n elif size == \"small\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\n elif size == \"tiny\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\n\n\n if data_name == \"SHHS\":\n training_set = Dataset_full_SHHS(partition['train'], data_folder)\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder)\n elif data_name == \"snooze\":\n training_set = Dataset_full(partition['train'], data_folder)\n validation_set = Dataset_full(partition['validation'], data_folder)\n elif data_name == \"philips\":\n training_set = Dataset_Philips_full(partition['train'], data_folder)\n validation_set = Dataset_Philips_full(partition['validation'], data_folder)\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n training_set = ConcatDataset(\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n validation_set = ConcatDataset(\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n elif model_name == \"Deep_Sleep\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\n\n elif size == \"small\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\n elif size == \"tiny\":\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\n\n if data_name == \"SHHS\":\n training_set = Dataset_full_SHHS(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"snooze\":\n training_set = Dataset_full(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_full(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"philips\":\n training_set = Dataset_Philips_full(partition['train'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n validation_set = Dataset_Philips_full(partition['validation'], data_folder, downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False)\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n # TODO combined dataset https://discuss.pytorch.org/t/train-simultaneously-on-two-datasets/649/17\n training_set = ConcatDataset(\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n validation_set = ConcatDataset(\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False),\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\n pre_allocation=2 ** 22, down_sample_annotation=False))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n elif model_name == \"ConvNet_IID\":\n if data_name == \"combined\":\n partition = []\n for data_fold in data_folder:\n partition.append(load_obj(os.path.join(data_fold, 'data_partition_IID_windows.pkl')))\n else:\n partition = load_obj(os.path.join(data_folder, 'data_partition_IID_windows.pkl'))\n if data_name == \"SHHS\":\n training_set = Dataset_IID_window_SHHS(partition['train'], data_folder)\n validation_set = Dataset_IID_window_SHHS(partition['validation'], data_folder)\n elif data_name == \"snooze\":\n training_set = Dataset_IID_window(partition['train'], data_folder)\n validation_set = Dataset_IID_window(partition['validation'], data_folder)\n elif data_name == \"philips\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"HMC\":\n print(\"{} not implemented data\".format(data_name))\n exit()\n elif data_name == \"combined\":\n training_set = ConcatDataset(\n Dataset_IID_window(partition[0]['train'], data_folder[0]),\n Dataset_IID_window_SHHS(partition[1]['train'], data_folder[1]))\n validation_set = ConcatDataset(\n Dataset_IID_window(partition[0]['validation'], data_folder[0]),\n Dataset_IID_window_SHHS(partition[1]['validation'], data_folder[1]))\n else:\n print(\"{} wrong data for dataloader\".format(data_name))\n exit()\n\n else:\n print(\"{} wrong model for dataloader\".format(model_name))\n exit()\n\n return training_set, validation_set","def split_reco_train_test(\n X,\n split_type = \"separated\",\n users_test_fraction = 0.1,\n max_test_users = 10000,\n items_test_fraction = 0.3,\n min_items_pool = 2,\n min_pos_test = 1,\n consider_cold_start = False,\n seed = 1\n):\n if (max_test_users is None) or (max_test_users == 0):\n max_test_users = X.shape[0]\n \n assert max_test_users > 0\n assert seed >= 0\n assert min_pos_test >= 0\n assert min_items_pool >= 0\n \n max_test_users = int(max_test_users)\n seed = int(seed)\n min_pos_test = int(min_pos_test)\n min_items_pool = int(min_items_pool)\n \n if users_test_fraction is not None:\n assert (users_test_fraction > 0) and (users_test_fraction < 1)\n users_test_fraction = float(users_test_fraction)\n\n assert (items_test_fraction > 0) and (items_test_fraction < 1)\n items_test_fraction = float(items_test_fraction)\n\n assert split_type in (\"all\", \"separated\", \"joined\")\n\n consider_cold_start = bool(consider_cold_start)\n\n\n if min_pos_test >= X.shape[1]:\n raise ValueError(\"'min_pos_test' must be smaller than the number of columns in 'X'.\")\n\n if min_items_pool >= X.shape[1]:\n raise ValueError(\"'min_items_pool' must be smaller than the number of columns in 'X'.\")\n\n if split_type != \"all\":\n if X.shape[0] < 2:\n raise ValueError(\"'X' has less than 2 rows.\")\n if users_test_fraction is not None:\n n_users_take = X.shape[0] * users_test_fraction\n if n_users_take < 1:\n warn(\"Desired fraction of test users implies <1, will select 1 user.\")\n n_users_take = 1\n n_users_take = round(n_users_take)\n n_users_take = min(n_users_take, max_test_users)\n else:\n if max_test_users > X.shape[0]:\n warn(\"'max_test_users' is larger than number of users. Will take all.\")\n n_users_take = min(max_test_users, X.shape[0])\n\n if not isspmatrix_csr(X):\n X = csr_matrix(X)\n else:\n X.sort_indices()\n if (not X.shape[0]) or (not X.shape[1]):\n raise ValueError(\"'X' cannot be empty.\")\n if X.dtype not in (np.float32, np.float64):\n X = X.astype(np.float64)\n if not X.data.shape[0]:\n raise ValueError(\"'X' contains no non-zero entries.\")\n X = _cast_indices_to_int32(X)\n\n if split_type == \"all\":\n return cpp_funs.split_csr_selected_users(X, items_test_fraction, seed)\n elif split_type == \"separated\":\n return cpp_funs.split_csr_separated_users(\n X,\n n_users_take,\n items_test_fraction,\n consider_cold_start,\n min_items_pool,\n min_pos_test,\n True,\n seed\n )\n elif split_type == \"joined\":\n return cpp_funs.split_csr_separated_users(\n X,\n n_users_take,\n items_test_fraction,\n consider_cold_start,\n min_items_pool,\n min_pos_test,\n False,\n seed\n )\n else:\n raise ValueError(\"Unexpected error.\")","def prepareSplitClassifier(df, models, choice):\n\n\n def classificationOutput(clf, X, Y):\n \"\"\"\n Fit the model and print the classification results\n - confusion_matrix\n - avg scores etc\n \"\"\"\n n_samples = 36\n\n print \"\\n\\nClassifier: \\n %s\" % (clf)\n print \"#\" * 79\n # classifier_gnb = naive_bayes.GaussianNB() # initiating the classifier\n\n clf.fit(X[:n_samples], Y[:n_samples]) # train on first n_samples and test on last 10\n\n expected = Y[n_samples:]\n predicted = clf.predict(X[n_samples:])\n print(\"Classification report:\\n%s\\n\" % (metrics.classification_report(expected, predicted)))\n print(\"\\nConfusion matrix:\\n%s\" % metrics.confusion_matrix(expected, predicted))\n\n\n\n\n def splitclassify(cDf):\n \"\"\"\n Given the dataframe combined with equal fair and unfair apps,\n classify them\n \"\"\"\n cDf = cDf.reindex(np.random.permutation(cDf.index)) # shuffle the dataframe\n featCols = set(cDf.columns)\n featCols.remove('appLabel')\n\n features = cDf[list(featCols)].astype('float')\n\n ## Scale the features to a common range\n min_max_scaler = preprocessing.MinMaxScaler()\n X = min_max_scaler.fit_transform(features.values)\n\n Y = cDf['appLabel'].values\n\n\n if choice == 'all':\n for key in models:\n classifier = models[key]\n classificationOutput(classifier, X, Y)\n else:\n if choice in models:\n classifier = models[choice]\n classificationOutput(classifier, X, Y)\n else:\n print \"Incorrect Choice\"\n\n\n\n fairDf = df[df['appLabel'] == False]\n unfairDf = df[df['appLabel'] == True]\n\n\n # calculate total possible splits of fair data frame relatie to\n # size of unfair dataframe\n splits = len(fairDf) // len(unfairDf)\n\n for i in range(splits):\n clDf = fairDf[i : i+len(unfairDf)].append(unfairDf)\n\n # print fairDf.values, unfairDf.values\n print \"Classifying %d th split of fair apps with unfair app\" % (i)\n print \"-\" * 79\n splitclassify(clDf)\n print \"\\n\\n\"","def create_data_generators(shuffle=True, novelty_type='normal', item_to_include='None',\n scale_level=1):\n\n total_noi_i = 10 # Number of processed images from one environemnt i\n noe = 1 # Numer of environments\n n_p = 32 # Patch size, patch --> n_p x n_p\n\n novelty = novelty_type\n datasets = []\n\n for i in range(noe):\n\n # Load only images of the environment which includes images of the stated novel item.\n if item_to_include is not None and novelty == 'novel_item':\n dataset_env_i = PolycraftDatasetWithSpecificItem(\n nov_type=novelty, noi=total_noi_i, env_idx=i, p_size=n_p, scale_factor=scale_level,\n item_name=item_to_include)\n datasets.append(dataset_env_i)\n # We only process the one environment with the item (maybe change this\n # if we have more than one environement per novel_item!?)\n break\n\n # No specific item given which should be included.\n else:\n dataset_env_i = PolycraftDatasetNoSpecificItem(\n nov_type=novelty, noi=total_noi_i, env_idx=i, p_size=n_p, scale_factor=scale_level)\n datasets.append(dataset_env_i)\n\n final_dataset = ConcatDataset(datasets)\n\n total_noi = len(final_dataset) # Total number of processed images from all datasets\n\n if(total_noi < 7):\n print('Number of samples too small for splitting dataset in training-/valid-/test set.')\n\n train_noi = int(0.7 * total_noi) # Number of images used for training (70 %)\n valid_noi = int(0.15 * total_noi) # Number of images used for validation (15 %)\n test_noi = total_noi - train_noi - valid_noi # Number of images used for testing (15 %)\n train_dataset, valid_dataset, test_dataset = torch.utils.data.random_split(\n final_dataset, [train_noi, valid_noi, test_noi])\n\n train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True)\n valid_loader = DataLoader(valid_dataset, batch_size=1, shuffle=True)\n test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True)\n\n return train_loader, valid_loader, test_loader","def model(classifier, data):\n print(\"Beggining to test model\")\n train, test = cross_validation.train_test_split(data, test_size=.30)\n f,c = train[:,1:], train[:,0]\n classifier.fit(f,c,False)\n print(\"Score: \" + classifier.score(f,c))\n print(\"Finished testing model\")","def run_training(self, schema_params, export_model=False, output_model_dir=None):\n # Log distributed execution context, which includes cluster configuration\n logger.info(f\"Commencing {self.effect_name} training\")\n logger.info(f\"Execution context : {self.execution_context}\")\n\n # Create partition_index_list\n partition_index_list = self._get_partition_list()\n logger.info(f\"This worker on work on the following list of partitions : {partition_index_list}\")\n\n # Sequentially train model on partitions\n for partition_index in partition_index_list:\n logger.info(f\"Commencing {self.effect_name} training for partition index : {partition_index}\")\n\n # Resolve partitioned data directory from raw path params from user\n checkpoint_path = self._anchor_directory(\n self.model.checkpoint_path,\n partition_index)\n training_data_dir = self._anchor_directory(self.model.training_data_dir,\n partition_index)\n validation_data_dir = self._anchor_directory(self.model.validation_data_dir,\n partition_index) if self.model.validation_data_dir else None\n\n if is_empty_directory(training_data_dir):\n logger.info(f\"{training_data_dir} is empty, no dataset to train on.\")\n continue\n # Train model\n self.execution_context[constants.PARTITION_INDEX] = partition_index\n self.model.train(training_data_dir=training_data_dir,\n validation_data_dir=validation_data_dir,\n metadata_file=self.model.metadata_file,\n checkpoint_path=checkpoint_path,\n execution_context=self._prepare_training_context(partition_index),\n schema_params=schema_params)\n\n # Chief should export model\n is_chief = self.execution_context[constants.IS_CHIEF]\n if export_model and is_chief:\n logger.info(f\"Exporting model to directory : {output_model_dir}\")\n self.model.export(output_model_dir=output_model_dir)","def main(args, base_dir):\n for i in range(args.n_training):\n # value of the next seed\n seed = args.seed + i\n\n # The time when the current experiment started.\n now = strftime(\"%Y-%m-%d-%H:%M:%S\")\n\n # Create a save directory folder (if it doesn't exist).\n if args.log_dir is not None:\n dir_name = args.log_dir\n else:\n dir_name = os.path.join(base_dir, '{}/{}'.format(\n args.env_name, now))\n ensure_dir(dir_name)\n\n # Get the policy class.\n if args.alg == \"TD3\":\n from hbaselines.multiagent.td3 import MultiFeedForwardPolicy\n elif args.alg == \"SAC\":\n from hbaselines.multiagent.sac import MultiFeedForwardPolicy\n elif args.alg == \"PPO\":\n from hbaselines.multiagent.ppo import MultiFeedForwardPolicy\n elif args.alg == \"TRPO\":\n from hbaselines.multiagent.trpo import MultiFeedForwardPolicy\n else:\n raise ValueError(\"Unknown algorithm: {}\".format(args.alg))\n\n # Get the hyperparameters.\n hp = get_hyperparameters(args, MultiFeedForwardPolicy)\n\n # add the seed for logging purposes\n params_with_extra = hp.copy()\n params_with_extra['seed'] = seed\n params_with_extra['env_name'] = args.env_name\n params_with_extra['policy_name'] = \"MultiFeedForwardPolicy\"\n params_with_extra['algorithm'] = args.alg\n params_with_extra['date/time'] = now\n\n # Add the hyperparameters to the folder.\n with open(os.path.join(dir_name, 'hyperparameters.json'), 'w') as f:\n json.dump(params_with_extra, f, sort_keys=True, indent=4)\n\n run_exp(\n env=args.env_name,\n policy=MultiFeedForwardPolicy,\n hp=hp,\n dir_name=dir_name,\n evaluate=args.evaluate,\n seed=seed,\n eval_interval=args.eval_interval,\n log_interval=args.log_interval,\n save_interval=args.save_interval,\n initial_exploration_steps=args.initial_exploration_steps,\n ckpt_path=args.ckpt_path,\n )","def __split_dataset(self):\n self.train, self.valid, _, _ = train_test_split(self.data, self.data, test_size=0.2)\n self.valid, self.test, _, _ = train_test_split(self.valid, self.valid, test_size=0.5)","def compute_strategy(self, strategy):\n if strategy == DataLoaderStrategies.OneRecordPerLine:\n self.one_record_per_line(self.res_predictions, self.dir_predictions)\n self.one_record_per_line(self.res_references, self.dir_references)\n elif strategy == DataLoaderStrategies.OneRecordPerFile:\n self.one_record_per_file(self.res_predictions, self.dir_predictions)\n self.one_record_per_file(self.res_references, self.dir_references)\n return","def run_trainig_and_testing(company = \"FB\", training_window = 60,\n trainig_period_y=8, testing_period_y=1,\n prediction_day=dt.datetime.now() ):\n # Load data for model\n training_data, testing_data = fetch_data(company, trainig_period_y, testing_period_y, prediction_day)\n # prepare data\n # scaler is object which will scale whole series values to defined feature_range interval\n scaler = MinMaxScaler(feature_range=(0,1))\n # we are insterested only in the closing values\n # optionaly we can use AdjClose -> adjusted for splits\n scaled_data = scaler.fit_transform(training_data['Close'].values.reshape(-1,1))\n\n # x is our learning data\n x_train, y_train = create_training_tensors(training_window, scaled_data)\n\n # build the model\n model = create_model((x_train.shape[1], 1))\n model.fit(x_train, y_train, epochs=5, batch_size=32)\n\n # for future we can save the model here and load for future\n\n \"\"\"\n TESTING MODEL ACCURACY\n \"\"\"\n\n # load test data\n\n tst_start_dt = dt.datetime(2020,1,1)\n tst_end_dt = dt.datetime(2021,1,1)\n\n\n actual_prices = testing_data['Close'].values\n total_dataset = pd.concat((training_data['Close'], testing_data['Close']), axis=0)\n\n model_inputs = total_dataset[len(total_dataset) - len(testing_data) - training_window:].values\n model_inputs = model_inputs.reshape(-1,1)\n model_inputs = scaler.fit_transform(model_inputs)\n\n # make prediction on test data\n\n x_test, y_test = create_training_tensors(training_window, model_inputs)\n\n predicted_prices = model.predict(x_test)\n # predicted prices are scaled to (0-1) so we need to rescale them to actual prices\n predicted_prices = scaler.inverse_transform(predicted_prices)\n\n plot_actual_vs_predicted(predicted_prices,actual_prices, company,\n x_labels=[date.strftime(\"%d-%m-%y\") for date in testing_data.index] )\n\n # predict next day\n real_data = [model_inputs[len(model_inputs) + 1 - training_window: len(model_inputs)+1, 0]]\n real_data = np.array(real_data)\n real_data = np.reshape(real_data, (real_data.shape[0], real_data.shape[1], 1))\n print(scaler.inverse_transform(real_data[-1]))\n\n prediction = model.predict(real_data)\n prediction = scaler.inverse_transform(prediction)\n print(f\"Next day value is: {prediction}\")\n\n print(\"===================================\")\n print(model.summary())\n print(\"===================================\")\n print(\"Evaluating model\")\n result = model.evaluate(x_test, y_test)\n print(dict(zip(model.metrics_names, result)))\n\n\n # TODO\n # experiment with next days predictions","def _test_train_partition(self, sent_partition_size):\n\n self._train_data_partitioned = self._partition_dataset(\n unpartitioned_dataset=self._train_data,\n sent_partition_size=sent_partition_size\n )\n\n self._test_data_partitioned = self._partition_dataset(\n unpartitioned_dataset=self._test_data,\n sent_partition_size=sent_partition_size\n )","def _split_data(self):\n\n # Set training data\n self.train_data = torchvision.datasets.ImageFolder(\n os.path.join(self.path, 'train'),\n transform=self._transform()\n )\n self.classes = self.train_data.classes\n\n # Set validation data\n self.val_data = torchvision.datasets.ImageFolder(\n os.path.join(self.path, 'test'),\n transform=self._transform(train=False)\n )","def construct_test_model(self):\n # Set the placeholder for the input episode\n self.inputa = tf.placeholder(tf.float32)\n self.inputb = tf.placeholder(tf.float32)\n self.labela = tf.placeholder(tf.float32)\n self.labelb = tf.placeholder(tf.float32)\n\n with tf.variable_scope('meta-test-model', reuse=None) as training_scope: \n # construct the model weights \n self.ss_weights = ss_weights = self.construct_resnet_ss_weights()\n self.weights = weights = self.construct_resnet_weights()\n self.fc_weights = fc_weights = self.construct_fc_weights()\n\n # Load test base epoch number from FLAGS\n num_updates = FLAGS.test_base_epoch_num\n\n def task_metalearn(inp, reuse=True):\n \"\"\"The function to process one episode in a meta-batch.\n Args:\n inp: the input episode.\n reuse: whether reuse the variables for the normalization.\n Returns:\n A serious outputs like losses and accuracies.\n \"\"\"\n # Seperate inp to different variables\n inputa, inputb, labela, labelb = inp\n # Generate empty list to record accuracies\n accb_list = []\n\n # Embed the input images to embeddings with ss weights\n emb_outputa = self.forward_resnet(inputa, weights, ss_weights, reuse=reuse)\n emb_outputb = self.forward_resnet(inputb, weights, ss_weights, reuse=True)\n\n # This part is similar to the meta-train function, you may refer to the comments above\n outputa = self.forward_fc(emb_outputa, fc_weights)\n lossa = self.loss_func(outputa, labela) \n grads = tf.gradients(lossa, list(fc_weights.values()))\n gradients = dict(zip(fc_weights.keys(), grads))\n fast_fc_weights = dict(zip(fc_weights.keys(), [fc_weights[key] - \\\n self.update_lr*gradients[key] for key in fc_weights.keys()]))\n outputb = self.forward_fc(emb_outputb, fast_fc_weights)\n accb = tf.contrib.metrics.accuracy(tf.argmax(tf.nn.softmax(outputb), 1), tf.argmax(labelb, 1))\n accb_list.append(accb)\n \n for j in range(num_updates - 1):\n lossa = self.loss_func(self.forward_fc(emb_outputa, fast_fc_weights), labela)\n grads = tf.gradients(lossa, list(fast_fc_weights.values()))\n gradients = dict(zip(fast_fc_weights.keys(), grads))\n fast_fc_weights = dict(zip(fast_fc_weights.keys(), [fast_fc_weights[key] - \\\n self.update_lr*gradients[key] for key in fast_fc_weights.keys()]))\n outputb = self.forward_fc(emb_outputb, fast_fc_weights)\n accb = tf.contrib.metrics.accuracy(tf.argmax(tf.nn.softmax(outputb), 1), tf.argmax(labelb, 1))\n accb_list.append(accb)\n\n lossb = self.loss_func(outputb, labelb)\n\n task_output = [lossb, accb, accb_list]\n\n return task_output\n\n if FLAGS.norm is not 'None':\n unused = task_metalearn((self.inputa[0], self.inputb[0], self.labela[0], self.labelb[0]), False)\n\n out_dtype = [tf.float32, tf.float32, [tf.float32]*num_updates]\n\n result = tf.map_fn(task_metalearn, elems=(self.inputa, self.inputb, self.labela, self.labelb), \\\n dtype=out_dtype, parallel_iterations=FLAGS.meta_batch_size)\n lossesb, accsb, accsb_list = result\n\n self.metaval_total_loss = total_loss = tf.reduce_sum(lossesb)\n self.metaval_total_accuracy = total_accuracy = tf.reduce_sum(accsb)\n self.metaval_total_accuracies = total_accuracies =[tf.reduce_sum(accsb_list[j]) for j in range(num_updates)]","def make_splits(input_pkl, test_split=0.1, val_split=0.1):\n if (test_split > 1) or (val_split > 1) or (test_split + val_split > 1) or (test_split <= 0) or (val_split <= 0):\n logging.warning('Check the input for make splits, quitting')\n exit()\n\n main_dict = load_pickle(input_pkl)\n data, labels = main_dict['data'], main_dict['labels']\n idx_arr = np.random.choice(len(data), len(data))\n data, labels = data[idx_arr], labels[idx_arr]\n print(len(data[0][-1]))\n # Find the split sizes\n val_split = int(len(data) * val_split)\n test_split = val_split + int(len(data) * test_split)\n\n # Make and save the splits\n save_pickle({'data': data[:val_split], 'labels': labels[:val_split]}, 'data/val.pkl')\n save_pickle({'data': data[val_split:test_split], 'labels': labels[val_split:test_split]}, 'data/test.pkl')\n save_pickle({'data': data[test_split:], 'labels': labels[test_split:]}, 'data/train.pkl')"],"string":"[\n \"def create_train_test(option, transform, params, split=0.2):\\r\\n clip_im_dir = option.clip_im_dir\\r\\n matting_dir = option.matting_dir\\r\\n csv_path = option.csv_path\\r\\n \\r\\n print(\\\"create datasets\\\")\\r\\n \\r\\n \\r\\n data_df = pd.read_csv(csv_path)\\r\\n # data_df = MergeDataframe(clip_im_dir, matting_dir)\\r\\n \\r\\n #separate data in training and test data (20/80)\\r\\n train_df, test_df = train_test_split(data_df, test_size=split)\\r\\n \\r\\n #search right Dataset class\\r\\n package_dir = Path(src.dataset.__file__).resolve().parent\\r\\n\\r\\n for (_, module_name, _) in iter_modules([package_dir]):\\r\\n # print(module_name, self.ComType)\\r\\n if option.dataset.lower() == module_name.lower() :\\r\\n modelModule = importlib.import_module(\\\".\\\"+module_name)\\r\\n break\\r\\n \\r\\n # train data\\r\\n training_set = modelModule(train_df, clip_im_dir, matting_dir, transform, transform)\\r\\n train_loader = DataLoader(training_set, **params)\\r\\n \\r\\n \\r\\n #test data\\r\\n testing_set = modelModule(test_df, clip_im_dir, matting_dir, transform, transform)\\r\\n test_loader = DataLoader(testing_set, **params)\\r\\n \\r\\n return train_loader, test_loader\",\n \"def main_predefined_split():\\n\\n average_performance = []\\n fold_num = 'predefined'\\n output_file_folder = \\\"output/{}\\\".format(args.experiment_name)\\n output_file_name = \\\"{}/lnnel_{}.csv\\\".format(output_file_folder, fold_num)\\n Path(output_file_folder).mkdir(parents=True, exist_ok=True)\\n args.output_file_name = output_file_name\\n\\n if args.use_blink:\\n df_train = pd.read_csv(\\\"./data/lcquad/blink/lcquad_train_sorted.csv\\\")\\n df_test = pd.read_csv(\\\"./data/lcquad/blink/lcquad_test_sorted.csv\\\")\\n else:\\n df_train = pd.read_csv(\\\"./data/lcquad/dbpedia/lcquad_train_sorted.csv\\\")\\n df_test = pd.read_csv(\\\"./data/lcquad/dbpedia/lcquad_test_sorted.csv\\\")\\n\\n # filter out the questions with single positive or many negatives in trianing set\\n filtered_question_mentions = []\\n for qm in df_train.QuestionMention.unique():\\n df_ = df_train[df_train.QuestionMention == qm]\\n if df_.Label.sum() == 0:\\n filtered_question_mentions.append(qm)\\n if df_.Label.sum() == 1 and df_.shape[0] == 1:\\n filtered_question_mentions.append(qm)\\n # print(df_.Label.values)\\n df_train_split_filtered = df_train[~df_train.QuestionMention.isin(filtered_question_mentions)]\\n df_train_split_filtered = df_train_split_filtered.sort_values(by=['QuestionMention', 'Label'])\\n df_train = df_train_split_filtered\\n\\n # train\\n features_train = np.array(\\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_train.Features.values])\\n x_train = torch.from_numpy(features_train).float()\\n y_train = torch.from_numpy(df_train.Label.values).float().reshape(-1, 1)\\n m_labels_train = df_train.Mention_label.values\\n ques_train = df_train.Question.values\\n\\n # test\\n features_test = np.array(\\n [np.fromstring(s[1:-1], dtype=np.float, sep=', ') for s in df_test.Features.values])\\n x_test = torch.from_numpy(features_test).float()\\n y_test = torch.from_numpy(df_test.Label.values).float().reshape(-1, 1)\\n m_labels_test = df_test.Mention_label.values\\n ques_test = df_test.Question.values\\n\\n # train model and evaluate\\n model = pick_model(args.model_name, args.alpha)\\n model = model.to(device)\\n\\n # move to gpu\\n x_train, y_train = x_train.to(device), y_train.to(device)\\n x_test, y_test = x_test.to(device), y_test.to(device)\\n\\n print(model)\\n\\n print(\\\"model: \\\", args.model_name, args.alpha)\\n print(model(x_train, m_labels_train))\\n\\n print(\\\"y_train sum\\\", sum(y_train), sum(y_train) / len(y_train))\\n print(\\\"y_test sum\\\", sum(y_test), sum(y_test) / len(y_test))\\n\\n # aggregate the data into train, val, and test\\n train_data = (x_train, y_train, m_labels_train, ques_train)\\n print(\\\"train:\\\", x_train.shape, y_train.shape, m_labels_train.shape, ques_train.shape)\\n test_data = (x_test, y_test, m_labels_test, ques_test)\\n print(\\\"test:\\\", x_test.shape, y_test.shape, m_labels_test.shape, ques_test.shape)\\n\\n # check class distribution\\n print(\\\"y_train sum\\\", sum(y_train), sum(y_train) / len(y_train))\\n print(\\\"y_test sum\\\", sum(y_test), sum(y_test) / len(y_test))\\n\\n train(model, train_data, test_data, test_data, args.checkpoint_name, args.num_epoch, args.margin,\\n args.learning_rate)\\n test_pred, best_scores = test(x_test, m_labels_test, ques_test, args.alpha, args.checkpoint_name,\\n args.model_name,\\n args.output_file_name)\\n with open(args.log_file_name, 'a') as f:\\n f.write(\\n \\\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}; lr={}; margin={}\\\\n\\\".format(\\n args.model_name,\\n args.use_fixed_threshold,\\n args.alpha,\\n best_scores[\\n 'precision'],\\n best_scores[\\n 'recall'],\\n best_scores['f1'],\\n args.learning_rate,\\n args.margin))\\n print(\\\"model={}; use_fixed_threshold={}; alpha={}; p={}; r={}; f1={}\\\\n\\\".format(args.model_name,\\n args.use_fixed_threshold,\\n args.alpha,\\n best_scores['precision'],\\n best_scores['recall'],\\n best_scores['f1']))\\n average_performance.append([best_scores['precision'], best_scores['recall'], best_scores['f1']])\\n\\n average_performance = np.array(average_performance)\\n print(\\\"Avg performance is prec - rec - f1: \\\", average_performance.mean(0))\",\n \"def create_train_test_sample(input_parcel_filepath: Path,\\n output_parcel_train_filepath: Path,\\n output_parcel_test_filepath: Path,\\n balancing_strategy: str,\\n force: bool = False):\\n\\n # If force == False Check and the output files exist already, stop.\\n if(force is False\\n and output_parcel_train_filepath.exists() is True\\n and output_parcel_test_filepath.exists() is True):\\n logger.warning(f\\\"create_train_test_sample: output files already exist and force == False, so stop: {output_parcel_train_filepath}, {output_parcel_test_filepath}\\\")\\n return\\n\\n # Load input data...\\n logger.info(f\\\"Start create_train_test_sample with balancing_strategy {balancing_strategy}\\\")\\n logger.info(f\\\"Read input file {input_parcel_filepath}\\\")\\n df_in = pdh.read_file(input_parcel_filepath)\\n logger.debug(f\\\"Read input file ready, shape: {df_in.shape}\\\")\\n\\n # Init some many-used variables from config\\n class_balancing_column = conf.columns['class_balancing']\\n class_column = conf.columns['class']\\n\\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\\n count_per_class = df_in.groupby(class_balancing_column, as_index=False).size()\\n logger.info(f\\\"Number of elements per classname in input dataset:\\\\n{count_per_class}\\\")\\n\\n # The test dataset should be as representative as possible for the entire dataset, so create\\n # this first as a 20% sample of each class without any additional checks...\\n # Remark: group_keys=False evades that apply creates an extra index-level of the groups above\\n # the data and evades having to do .reset_index(level=class_balancing_column_NAME, drop=True)\\n # to get rid of the group level\\n df_test = df_in.groupby(class_balancing_column, group_keys=False).apply(pd.DataFrame.sample, frac=0.20)\\n logger.debug(f\\\"df_test after sampling 20% of data per class, shape: {df_test.shape}\\\")\\n\\n # The candidate parcel for training are all non-test parcel\\n df_train_base = df_in[~df_in.index.isin(df_test.index)]\\n logger.debug(f\\\"df_train_base after isin\\\\n{df_train_base}\\\")\\n\\n # Remove parcel with too few pixels from the train sample\\n min_pixcount = conf.marker.getfloat('min_nb_pixels_train')\\n df_train_base = df_train_base[df_train_base[conf.columns['pixcount_s1s2']] >= min_pixcount]\\n logger.debug(f\\\"Number of parcels in df_train_base after filter on pixcount >= {min_pixcount}: {len(df_train_base)}\\\")\\n\\n # Some classes shouldn't be used for training... so remove them!\\n logger.info(f\\\"Remove 'classes_to_ignore_for_train' from train sample (= where {class_column} is in: {conf.marker.getlist('classes_to_ignore_for_train')}\\\")\\n df_train_base = df_train_base[~df_train_base[class_column].isin(conf.marker.getlist('classes_to_ignore_for_train'))]\\n\\n # All classes_to_ignore aren't meant for training either...\\n logger.info(f\\\"Remove 'classes_to_ignore' from train sample (= where {class_column} is in: {conf.marker.getlist('classes_to_ignore')}\\\")\\n df_train_base = df_train_base[~df_train_base[class_column].isin(conf.marker.getlist('classes_to_ignore'))]\\n\\n # Print the train base result before applying any balancing\\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\\n count_per_class = df_train_base.groupby(class_balancing_column, as_index=False).size()\\n logger.info(f\\\"Number of elements per classname for train dataset, before balancing:\\\\n{count_per_class}\\\")\\n\\n # Depending on the balancing_strategy, use different way to get a training sample\\n if balancing_strategy == 'BALANCING_STRATEGY_NONE':\\n # Just use 25% of all non-test data as train data -> 25% of 80% of data -> 20% of all data\\n # will be training date\\n # Remark: - this is very unbalanced, eg. classes with 10.000 times the input size than other\\n # classes\\n # - this results in a relatively high accuracy in overall numbers, but the small\\n # classes are not detected at all\\n df_train = (df_train_base\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, frac=0.25))\\n\\n elif balancing_strategy == 'BALANCING_STRATEGY_MEDIUM':\\n # Balance the train data, but still use some larger samples for the classes that have a lot\\n # of members in the input dataset\\n # Remark: with the upper limit of 10.000 this gives still OK results overall, and also the\\n # smaller classes give some results with upper limit of 4000 results significantly\\n # less good.\\n\\n # For the larger classes, favor them by leaving the samples larger but cap at upper_limit\\n upper_limit = 10000\\n lower_limit = 1000\\n logger.info(f\\\"Cap over {upper_limit}, keep the full number of training sample till {lower_limit}, samples smaller than that are oversampled\\\")\\n df_train = (df_train_base.groupby(class_balancing_column).filter(lambda x: len(x) >= upper_limit)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_limit))\\n # Middle classes use the number as they are\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_limit)\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= lower_limit))\\n # For smaller classes, oversample...\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < lower_limit)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, lower_limit, replace=True))\\n\\n elif balancing_strategy == 'BALANCING_STRATEGY_MEDIUM2':\\n # Balance the train data, but still use some larger samples for the classes that have a lot\\n # of members in the input dataset\\n # Remark: with the upper limit of 10.000 this gives still OK results overall, and also the\\n # smaller classes give some results with upper limit of 4000 results significantly\\n # less good.\\n\\n # For the larger classes, leave the samples larger but cap\\n cap_count_limit1 = 100000\\n cap_train_limit1 = 30000\\n logger.info(f\\\"Cap balancing classes over {cap_count_limit1} to {cap_train_limit1}\\\")\\n df_train = (df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= cap_count_limit1)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, cap_train_limit1))\\n cap_count_limit2 = 50000\\n cap_train_limit2 = 20000\\n logger.info(f\\\"Cap balancing classes between {cap_count_limit2} and {cap_count_limit1} to {cap_train_limit2}\\\")\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < cap_count_limit1)\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= cap_count_limit2)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, cap_train_limit2))\\n cap_count_limit3 = 20000\\n cap_train_limit3 = 10000\\n logger.info(f\\\"Cap balancing classes between {cap_count_limit3} and {cap_count_limit2} to {cap_train_limit3}\\\")\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < cap_count_limit2)\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= cap_count_limit3)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, cap_train_limit3))\\n cap_count_limit4 = 10000\\n cap_train_limit4 = 10000\\n logger.info(f\\\"Cap balancing classes between {cap_count_limit4} and {cap_count_limit3} to {cap_train_limit4}\\\")\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < cap_count_limit3)\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= cap_count_limit4)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, cap_train_limit4))\\n oversample_count = 1000\\n # Middle classes use the number as they are\\n logger.info(f\\\"For classes between {cap_count_limit4} and {oversample_count}, just use all samples\\\")\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < cap_count_limit4)\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= oversample_count))\\n # For smaller classes, oversample...\\n logger.info(f\\\"For classes smaller than {oversample_count}, oversample to {oversample_count}\\\")\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < oversample_count)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, oversample_count, replace=True))\\n\\n elif balancing_strategy == 'BALANCING_STRATEGY_PROPORTIONAL_GROUPS':\\n # Balance the train data, but still use some larger samples for the classes that have a lot\\n # of members in the input dataset\\n # Remark: with the upper limit of 10.000 this gives still OK results overall, and also the\\n # smaller classes give some results with upper limit of 4000 results significantly\\n # less good.\\n\\n # For the larger classes, leave the samples larger but cap\\n upper_count_limit1 = 100000\\n upper_train_limit1 = 30000\\n logger.info(f\\\"Cap balancing classes over {upper_count_limit1} to {upper_train_limit1}\\\")\\n df_train = (df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= upper_count_limit1)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_train_limit1))\\n upper_count_limit2 = 50000\\n upper_train_limit2 = 20000\\n logger.info(f\\\"Cap balancing classes between {upper_count_limit2} and {upper_count_limit1} to {upper_train_limit2}\\\")\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_count_limit1)\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= upper_count_limit2)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_train_limit2))\\n upper_count_limit3 = 20000\\n upper_train_limit3 = 10000\\n logger.info(f\\\"Cap balancing classes between {upper_count_limit3} and {upper_count_limit2} to {upper_train_limit3}\\\")\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_count_limit2)\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= upper_count_limit3)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_train_limit3))\\n upper_count_limit4 = 10000\\n upper_train_limit4 = 5000\\n logger.info(f\\\"Cap balancing classes between {upper_count_limit4} and {upper_count_limit3} to {upper_train_limit4}\\\")\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_count_limit3)\\n .groupby(class_balancing_column).filter(lambda x: len(x) >= upper_count_limit4)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_train_limit4))\\n\\n # For smaller balancing classes, just use all samples\\n df_train = df_train.append(\\n df_train_base.groupby(class_balancing_column).filter(lambda x: len(x) < upper_count_limit4))\\n\\n elif balancing_strategy == 'BALANCING_STRATEGY_UPPER_LIMIT':\\n # Balance the train data, but still use some larger samples for the classes that have a lot\\n # of members in the input dataset\\n # Remark: with the upper limit of 10.000 this gives still OK results overall, and also the\\n # smaller classes give some results with upper limit of 4000 results significantly\\n # less good.\\n\\n # For the larger classes, favor them by leaving the samples larger but cap at upper_limit\\n upper_limit = 10000\\n logger.info(f\\\"Cap over {upper_limit}...\\\")\\n df_train = (df_train_base.groupby(class_balancing_column).filter(lambda x: len(x) >= upper_limit)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_limit))\\n # For smaller classes, just use all samples\\n df_train = df_train.append(df_train_base\\n .groupby(class_balancing_column).filter(lambda x: len(x) < upper_limit))\\n\\n elif balancing_strategy == 'BALANCING_STRATEGY_EQUAL':\\n # In theory the most logical way to balance: make sure all classes have the same amount of\\n # training data by undersampling the largest classes and oversampling the small classes.\\n df_train = (df_train_base.groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, 2000, replace=True))\\n\\n else:\\n raise Exception(f\\\"Unknown balancing strategy, STOP!: {balancing_strategy}\\\")\\n\\n # Log the resulting numbers per class in the train sample\\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\\n count_per_class = df_train.groupby(class_balancing_column, as_index=False).size()\\n logger.info(f'Number of elements per class_balancing_column in train dataset:\\\\n{count_per_class}')\\n if class_balancing_column != class_column:\\n count_per_class = df_train.groupby(class_column, as_index=False).size()\\n logger.info(f'Number of elements per class_column in train dataset:\\\\n{count_per_class}')\\n\\n # Log the resulting numbers per class in the test sample\\n with pd.option_context('display.max_rows', None, 'display.max_columns', None):\\n count_per_class = df_test.groupby(class_balancing_column, as_index=False).size()\\n logger.info(f'Number of elements per class_balancing_column in test dataset:\\\\n{count_per_class}')\\n if class_balancing_column != class_column:\\n count_per_class = df_test.groupby(class_column, as_index=False).size()\\n logger.info(f'Number of elements per class_column in test dataset:\\\\n{count_per_class}')\\n\\n # Write to output files\\n logger.info('Write the output files')\\n df_train.set_index(conf.columns['id'], inplace=True)\\n df_test.set_index(conf.columns['id'], inplace=True)\\n pdh.to_file(df_train, output_parcel_train_filepath) # The ID column is the index...\\n pdh.to_file(df_test, output_parcel_test_filepath) # The ID column is the index...\",\n \"def create_train_test_sample(\\n input_parcel_path: Path,\\n output_parcel_train_path: Path,\\n output_parcel_test_path: Path,\\n balancing_strategy: str,\\n force: bool = False,\\n):\\n\\n # If force == False Check and the output files exist already, stop.\\n if (\\n force is False\\n and output_parcel_train_path.exists() is True\\n and output_parcel_test_path.exists() is True\\n ):\\n logger.warning(\\n \\\"create_train_test_sample: output files already exist and force is False: \\\"\\n f\\\"{output_parcel_train_path}, {output_parcel_test_path}\\\"\\n )\\n return\\n\\n # Load input data...\\n logger.info(\\n f\\\"Start create_train_test_sample with balancing_strategy {balancing_strategy}\\\"\\n )\\n logger.info(f\\\"Read input file {input_parcel_path}\\\")\\n df_in = pdh.read_file(input_parcel_path)\\n logger.debug(f\\\"Read input file ready, shape: {df_in.shape}\\\")\\n\\n # Init some many-used variables from config\\n class_balancing_column = conf.columns[\\\"class_balancing\\\"]\\n class_column = conf.columns[\\\"class\\\"]\\n\\n with pd.option_context(\\n \\\"display.max_rows\\\", None, \\\"display.max_columns\\\", None\\n ): # type: ignore\\n count_per_class = df_in.groupby(class_balancing_column, as_index=False).size()\\n logger.info(\\n f\\\"Number of elements per classname in input dataset:\\\\n{count_per_class}\\\"\\n )\\n\\n # The test dataset should be as representative as possible for the entire dataset,\\n # so create this first as a 20% sample of each class without any additional checks.\\n # Remark: group_keys=False evades that apply creates an extra index-level of the\\n # groups above the data and evades having to do\\n # .reset_index(level=class_balancing_column_NAME, drop=True)\\n # to get rid of the group level\\n test_df = df_in.groupby(class_balancing_column, group_keys=False).apply(\\n pd.DataFrame.sample, frac=0.20\\n )\\n logger.debug(\\n f\\\"df_test after sampling 20% of data per class, shape: {test_df.shape}\\\"\\n )\\n\\n # The candidate parcel for training are all non-test parcel\\n train_base_df = df_in[~df_in.index.isin(test_df.index)]\\n logger.debug(f\\\"df_train_base after isin\\\\n{train_base_df}\\\")\\n\\n # Remove parcel with too few pixels from the train sample\\n min_pixcount = conf.marker.getfloat(\\\"min_nb_pixels_train\\\")\\n train_base_df = train_base_df[\\n train_base_df[conf.columns[\\\"pixcount_s1s2\\\"]] >= min_pixcount\\n ]\\n logger.debug(\\n \\\"Number of parcels in df_train_base after filter on pixcount >= \\\"\\n f\\\"{min_pixcount}: {len(train_base_df)}\\\"\\n )\\n\\n # Some classes shouldn't be used for training... so remove them!\\n logger.info(\\n \\\"Remove 'classes_to_ignore_for_train' from train sample (= where \\\"\\n f\\\"{class_column} is in: {conf.marker.getlist('classes_to_ignore_for_train')}\\\"\\n )\\n train_base_df = train_base_df[\\n ~train_base_df[class_column].isin(\\n conf.marker.getlist(\\\"classes_to_ignore_for_train\\\")\\n )\\n ]\\n\\n # All classes_to_ignore aren't meant for training either...\\n logger.info(\\n f\\\"Remove 'classes_to_ignore' from train sample (= where {class_column} is in: \\\"\\n f\\\"{conf.marker.getlist('classes_to_ignore')}\\\"\\n )\\n train_base_df = train_base_df[\\n ~train_base_df[class_column].isin(conf.marker.getlist(\\\"classes_to_ignore\\\"))\\n ]\\n\\n # Print the train base result before applying any balancing\\n with pd.option_context(\\n \\\"display.max_rows\\\", None, \\\"display.max_columns\\\", None\\n ): # type: ignore\\n count_per_class = train_base_df.groupby(\\n class_balancing_column, as_index=False\\n ).size()\\n logger.info(\\n \\\"Number of elements per classname for train dataset, before balancing:\\\\n\\\"\\n f\\\"{count_per_class}\\\"\\n )\\n\\n # Depending on the balancing_strategy, use different way to get a training sample\\n train_df = pd.DataFrame().reindex_like(train_base_df)\\n if balancing_strategy == \\\"BALANCING_STRATEGY_NONE\\\":\\n # Just use 25% of all non-test data as train data -> 25% of 80% of data -> 20%\\n # of all data will be training date\\n # Remark: - this is very unbalanced, eg. classes with 10.000 times the input\\n # size than other classes\\n # - this results in a relatively high accuracy in overall numbers, but\\n # the small classes are not detected at all\\n train_df = train_base_df.groupby(\\n class_balancing_column, group_keys=False\\n ).apply(pd.DataFrame.sample, frac=0.25)\\n\\n elif balancing_strategy == \\\"BALANCING_STRATEGY_MEDIUM\\\":\\n # Balance the train data, but still use some larger samples for the classes\\n # that have a lot of members in the input dataset\\n # Remark: with the upper limit of 10.000 this gives still OK results overall,\\n # and also the smaller classes give some results with upper limit of 4000\\n # results significantly less good.\\n\\n # For the larger classes, favor them by leaving the samples larger but cap at\\n # upper_limit\\n upper_limit = 10000\\n lower_limit = 1000\\n logger.info(\\n f\\\"Cap over {upper_limit}, keep the full number of training sample till \\\"\\n f\\\"{lower_limit}, samples smaller than that are oversampled\\\"\\n )\\n train_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= upper_limit)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_limit)\\n )\\n # Middle classes use the number as they are\\n train_df = pd.concat(\\n [\\n train_df,\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < upper_limit)\\n .groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= lower_limit),\\n ]\\n )\\n # For smaller classes, oversample...\\n train_df = pd.concat(\\n [\\n train_df,\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < lower_limit)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, lower_limit, replace=True),\\n ]\\n )\\n\\n elif balancing_strategy == \\\"BALANCING_STRATEGY_MEDIUM2\\\":\\n # Balance the train data, but still use some larger samples for the classes\\n # that have a lot of members in the input dataset\\n # Remark: with the upper limit of 10.000 this gives still OK results overall,\\n # and also the smaller classes give some results with upper limit of 4000\\n # results significantly less good.\\n\\n # For the larger classes, leave the samples larger but cap\\n # Cap 1\\n cap_count_limit1 = 100000\\n cap_train_limit1 = 30000\\n logger.info(\\n f\\\"Cap balancing classes over {cap_count_limit1} to {cap_train_limit1}\\\"\\n )\\n train_capped_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= cap_count_limit1)\\n .groupby(class_balancing_column, group_keys=False)\\n )\\n if len(train_capped_df) > 0:\\n train_df = pd.concat(\\n [train_df, train_capped_df.apply(pd.DataFrame.sample, cap_train_limit1)]\\n )\\n\\n # Cap 2\\n cap_count_limit2 = 50000\\n cap_train_limit2 = 20000\\n logger.info(\\n f\\\"Cap balancing classes between {cap_count_limit2} and {cap_count_limit1} \\\"\\n f\\\"to {cap_train_limit2}\\\"\\n )\\n train_capped_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < cap_count_limit1)\\n .groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= cap_count_limit2)\\n .groupby(class_balancing_column, group_keys=False)\\n )\\n if len(train_capped_df) > 0:\\n train_df = pd.concat(\\n [train_df, train_capped_df.apply(pd.DataFrame.sample, cap_train_limit2)]\\n )\\n\\n # Cap 3\\n cap_count_limit3 = 20000\\n cap_train_limit3 = 10000\\n logger.info(\\n f\\\"Cap balancing classes between {cap_count_limit3} and {cap_count_limit2} \\\"\\n f\\\"to {cap_train_limit3}\\\"\\n )\\n train_capped_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < cap_count_limit2)\\n .groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= cap_count_limit3)\\n .groupby(class_balancing_column, group_keys=False)\\n )\\n if len(train_capped_df) > 0:\\n train_df = pd.concat(\\n [train_df, train_capped_df.apply(pd.DataFrame.sample, cap_train_limit3)]\\n )\\n\\n # Cap 4\\n cap_count_limit4 = 10000\\n cap_train_limit4 = 10000\\n logger.info(\\n f\\\"Cap balancing classes between {cap_count_limit4} and {cap_count_limit3} \\\"\\n f\\\"to {cap_train_limit4}\\\"\\n )\\n train_capped_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < cap_count_limit3)\\n .groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= cap_count_limit4)\\n .groupby(class_balancing_column, group_keys=False)\\n )\\n if len(train_capped_df) > 0:\\n train_df = pd.concat(\\n [train_df, train_capped_df.apply(pd.DataFrame.sample, cap_train_limit4)]\\n )\\n\\n # Middle classes use the number as they are, smaller classes are oversampled\\n oversample_count = 1000\\n logger.info(\\n f\\\"For classes between {cap_count_limit4} and {oversample_count}, just use \\\"\\n \\\"all samples\\\"\\n )\\n train_df = pd.concat(\\n [\\n train_df,\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < cap_count_limit4)\\n .groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= oversample_count),\\n ]\\n )\\n # For smaller classes, oversample...\\n logger.info(\\n f\\\"For classes smaller than {oversample_count}, oversample to \\\"\\n f\\\"{oversample_count}\\\"\\n )\\n train_capped_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < oversample_count)\\n .groupby(class_balancing_column, group_keys=False)\\n )\\n if len(train_capped_df) > 0:\\n train_df = pd.concat(\\n [\\n train_df,\\n train_capped_df.apply(\\n pd.DataFrame.sample, oversample_count, replace=True\\n ),\\n ]\\n )\\n\\n elif balancing_strategy == \\\"BALANCING_STRATEGY_PROPORTIONAL_GROUPS\\\":\\n # Balance the train data, but still use some larger samples for the classes\\n # that have a lot of members in the input dataset\\n # Remark: with the upper limit of 10.000 this gives still OK results overall,\\n # and also the smaller classes give some results with upper limit of 4000\\n # results significantly less good.\\n\\n # For the larger classes, leave the samples larger but cap\\n upper_count_limit1 = 100000\\n upper_train_limit1 = 30000\\n logger.info(\\n f\\\"Cap balancing classes over {upper_count_limit1} to {upper_train_limit1}\\\"\\n )\\n train_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= upper_count_limit1)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_train_limit1)\\n )\\n upper_count_limit2 = 50000\\n upper_train_limit2 = 20000\\n logger.info(\\n f\\\"Cap balancing classes between {upper_count_limit2} and \\\"\\n f\\\"{upper_count_limit1} to {upper_train_limit2}\\\"\\n )\\n train_limit2_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < upper_count_limit1)\\n .groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= upper_count_limit2)\\n .groupby(class_balancing_column, group_keys=False)\\n )\\n if len(train_limit2_df) > 0:\\n train_df = pd.concat(\\n [\\n train_df,\\n train_limit2_df.apply(pd.DataFrame.sample, upper_train_limit2),\\n ]\\n )\\n upper_count_limit3 = 20000\\n upper_train_limit3 = 10000\\n logger.info(\\n f\\\"Cap balancing classes between {upper_count_limit3} and \\\"\\n f\\\"{upper_count_limit2} to {upper_train_limit3}\\\"\\n )\\n train_limit3_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < upper_count_limit2)\\n .groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= upper_count_limit3)\\n .groupby(class_balancing_column, group_keys=False)\\n )\\n if len(train_limit3_df) > 0:\\n train_df = pd.concat(\\n [\\n train_df,\\n train_limit3_df.apply(pd.DataFrame.sample, upper_train_limit3),\\n ]\\n )\\n upper_count_limit4 = 10000\\n upper_train_limit4 = 5000\\n logger.info(\\n f\\\"Cap balancing classes between {upper_count_limit4} and \\\"\\n f\\\"{upper_count_limit3} to {upper_train_limit4}\\\"\\n )\\n train_limit4_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) < upper_count_limit3)\\n .groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= upper_count_limit4)\\n .groupby(class_balancing_column, group_keys=False)\\n )\\n if len(train_limit4_df) > 0:\\n train_df = pd.concat(\\n [\\n train_df,\\n train_limit4_df.apply(pd.DataFrame.sample, upper_train_limit4),\\n ]\\n )\\n # For smaller balancing classes, just use all samples\\n train_df = pd.concat(\\n [\\n train_df,\\n train_base_df.groupby(class_balancing_column).filter(\\n lambda x: len(x) < upper_count_limit4\\n ),\\n ]\\n )\\n\\n elif balancing_strategy == \\\"BALANCING_STRATEGY_UPPER_LIMIT\\\":\\n # Balance the train data, but still use some larger samples for the classes\\n # that have a lot of members in the input dataset\\n # Remark: with the upper limit of 10.000 this gives still OK results overall,\\n # and also the smaller classes give some results with upper limit of 4000\\n # results significantly less good.\\n\\n # For the larger classes, favor them by leaving the samples larger but cap at\\n # upper_limit\\n upper_limit = 10000\\n logger.info(f\\\"Cap over {upper_limit}...\\\")\\n train_df = (\\n train_base_df.groupby(class_balancing_column)\\n .filter(lambda x: len(x) >= upper_limit)\\n .groupby(class_balancing_column, group_keys=False)\\n .apply(pd.DataFrame.sample, upper_limit)\\n )\\n # For smaller classes, just use all samples\\n train_df = pd.concat(\\n [\\n train_df,\\n train_base_df.groupby(class_balancing_column).filter(\\n lambda x: len(x) < upper_limit\\n ),\\n ]\\n )\\n\\n elif balancing_strategy == \\\"BALANCING_STRATEGY_EQUAL\\\":\\n # In theory the most logical way to balance: make sure all classes have the\\n # same amount of training data by undersampling the largest classes and\\n # oversampling the small classes.\\n train_df = train_base_df.groupby(\\n class_balancing_column, group_keys=False\\n ).apply(pd.DataFrame.sample, 2000, replace=True)\\n\\n else:\\n raise Exception(f\\\"Unknown balancing strategy, STOP!: {balancing_strategy}\\\")\\n\\n # Log the resulting numbers per class in the train sample\\n with pd.option_context(\\n \\\"display.max_rows\\\", None, \\\"display.max_columns\\\", None\\n ): # type: ignore\\n count_per_class = train_df.groupby(\\n class_balancing_column, as_index=False\\n ).size()\\n logger.info(\\n \\\"Number of elements per class_balancing_column in train dataset:\\\\n\\\"\\n f\\\"{count_per_class}\\\"\\n )\\n if class_balancing_column != class_column:\\n count_per_class = train_df.groupby(class_column, as_index=False).size()\\n logger.info(\\n \\\"Number of elements per class_column in train dataset:\\\\n\\\"\\n f\\\"{count_per_class}\\\"\\n )\\n\\n # Log the resulting numbers per class in the test sample\\n with pd.option_context(\\n \\\"display.max_rows\\\", None, \\\"display.max_columns\\\", None\\n ): # type: ignore\\n count_per_class = test_df.groupby(class_balancing_column, as_index=False).size()\\n logger.info(\\n \\\"Number of elements per class_balancing_column in test dataset:\\\\n\\\"\\n f\\\"{count_per_class}\\\"\\n )\\n if class_balancing_column != class_column:\\n count_per_class = test_df.groupby(class_column, as_index=False).size()\\n logger.info(\\n \\\"Number of elements per class_column in test dataset:\\\\n\\\"\\n f\\\"{count_per_class}\\\"\\n )\\n\\n # Write to output files\\n logger.info(\\\"Write the output files\\\")\\n train_df.set_index(conf.columns[\\\"id\\\"], inplace=True)\\n test_df.set_index(conf.columns[\\\"id\\\"], inplace=True)\\n pdh.to_file(train_df, output_parcel_train_path) # The ID column is the index...\\n pdh.to_file(test_df, output_parcel_test_path) # The ID column is the index...\",\n \"def run_train_test_split():\\n # Load all documents\\n conn = sq.connect(config.DB_FILE)\\n documents = pd.read_sql_query('select pubmed_id, review_id, included, title, abstract from article ', conn)\\n\\n # Identify unique review IDs\\n review_ids = documents['review_id'].unique()\\n\\n # Set seed for random sampling\\n np.random.seed(2)\\n\\n # List of Reviews in the partial data set and full data set\\n partial_set = list(np.random.choice(review_ids, 10, replace=False))\\n full_set = list(review_ids.copy())\\n\\n # Load array (X) and labels (Y) of all documents\\n with (open(config.DOC_TERM_MATRIX, \\\"rb\\\")) as openfile:\\n X = pickle.load(openfile)\\n\\n y = documents['included']\\n\\n # Train-test split of the partial dataset\\n train_test_split(X, y, partial_set, 'min_max', 'partial', review_ids)\\n train_test_split(X, y, partial_set, 'tf_idf', 'partial', review_ids)\\n\\n # Train-test split of the full dataset\\n train_test_split(X, y, full_set, 'min_max', 'full', review_ids)\\n train_test_split(X, y, full_set, 'tf_idf', 'full', review_ids)\",\n \"def main_modeling_pipeline():\\n\\n\\n data_df = pd.read_csv('gs://aiplatformfilipegracio2020/head_train_data.csv')\\n data_df = data_df[[LABEL, 'price', 'days_on_site']]\\n\\n class_weights = calculate_class_weights(data_df[LABEL])\\n print('class weights', class_weights)\\n logging.info('Data loaded and processed')\\n train_ds, val_ds, test_ds = make_tf_datasets(data_df, LABEL)\\n logging.info('Tensorflow datasets created')\\n\\n with strategy.scope():\\n logging.info('Inside strategy')\\n simple_feature_layer = make_simple_feature_layer(data_df)\\n logging.info('Going to make model')\\n simple_model = make_simple_model(simple_feature_layer)\\n\\n logging.info('Going fit model')\\n simple_model_results, simple_model = model_fit_and_evaluate(model=simple_model,\\n train_ds=train_ds,\\n val_ds=val_ds,\\n test_ds=test_ds,\\n class_weights=class_weights,\\n epochs=TRAINING_EPOCHS,\\n job_name='simple_model')\\n\\n simple_model.save('gs://aiplatformfilipegracio2020/')\",\n \"def main(source_dir, ksplit, out_dir, data_pattern, label_pattern, test_mode,\\r\\n numTopVars = [10, 50, 100, 500, 1000], compute_results=True):\\r\\n # Load input and labels.\\r\\n data, labels, data_file = load_data(source_dir, data_pattern)\\r\\n filename_base = path.splitext(path.basename(mname))[0]\\r\\n # Get classifiers and params.\\r\\n global NAMES\\r\\n if test_mode:\\r\\n NAMES = [\\\"Chance\\\", \\\"Nearest Neighbors\\\", \\\"Linear SVM\\\", \\\"Decision Tree\\\",\\r\\n \\\"Logistic Regression\\\", \\\"Naive Bayes\\\", \\\"LDA\\\"]\\r\\n ksplit = 3\\r\\n\\r\\n classifiers, params = make_classifiers(NAMES) # data.shape, ksplit)\\r\\n\\r\\n\\r\\n # Make the folds.\\r\\n logging.info(\\\"Making %d folds\\\" % ksplit)\\r\\n #kf = StratifiedKFold(labels, n_folds=ksplit)\\r\\n kf = KFold(labels.shape[0], n_folds=ksplit)\\r\\n\\r\\n # Extract the training and testing indices from the k-fold object,\\r\\n # which stores fold pairs of indices.\\r\\n fold_pairs = [(tr, ts) for (tr, ts) in kf]\\r\\n assert len(fold_pairs) == ksplit\\r\\n rank_per_fold = get_rank_per_fold(data, labels, fold_pairs,\\r\\n save_path=out_dir, parallel=True)\\r\\n #dhjelm: were we planning on using this dict?\\r\\n #score={}\\r\\n dscore=[]\\r\\n totalErrs = []\\r\\n if compute_results:\\r\\n for name in NAMES:\\r\\n mdl = classifiers[name]\\r\\n param = params[name]\\r\\n # get_score runs the classifier on each fold,\\r\\n # each subset of selected top variables and does a grid search for\\r\\n # classifier-specific parameters (selects the best)\\r\\n clf, allConfMats, allTotalErrs, allFittedClassifiers = \\\\\\r\\n get_score(data, labels, fold_pairs, name, mdl, param,\\r\\n numTopVars=numTopVars,\\r\\n rank_per_fold=rank_per_fold, parallel=True,\\r\\n rand_iter=-1)\\r\\n # save classifier object and results to file\\r\\n save_classifier_results(name, out_dir, allConfMats,\\r\\n allTotalErrs)\\r\\n save_classifier_object(clf, allFittedClassifiers, name, out_dir)\\r\\n # Append classifier results to list of all results\\r\\n dscore.append(allConfMats)\\r\\n totalErrs.append(allTotalErrs)\\r\\n '''\\r\\n First do some saving of total results\\r\\n '''\\r\\n save_combined_results(NAMES, dscore, totalErrs,\\r\\n numTopVars, out_dir, filename_base)\\r\\n\\r\\n plot_errors(NAMES, numTopVars, dscore, totalErrs,\\r\\n filename_base, out_dir,compute_results)\\r\\n\\r\\n logging.shutdown()\",\n \"def create_simple_data_set(\\n n_training_points,\\n n_testing_points,\\n low=0,\\n high=3,\\n mode=training_testing_split.SEPERATE,\\n kernel=kernel_matern,\\n shuffle=True,\\n):\\n gp = gaussian_process(kernel=kernel, verbose=True)\\n\\n mid = (low + high) / 2\\n\\n if mode == training_testing_split.SEPERATE_LONG:\\n x_training, x_testing = __seperate_long(\\n n_training_points, n_testing_points, low, high\\n )\\n elif mode == training_testing_split.SEPERATE:\\n x_training, x_testing = __seperate(\\n n_training_points, n_testing_points, low, high\\n )\\n elif mode == training_testing_split.INTERSPREAD:\\n x_training, x_testing = __interspread(\\n n_training_points, n_testing_points, low, high\\n )\\n elif mode == training_testing_split.RANDOM:\\n x_training, x_testing = __random(n_training_points, n_testing_points, low, high)\\n elif mode == training_testing_split.MIXED:\\n\\n def r(z):\\n dist = np.random.randint(low=1, high=100, size=4)\\n λ = lambda x: x / dist.sum()\\n vfunc = np.vectorize(λ)\\n dist = vfunc(dist)\\n return (z * dist).round().astype(int)\\n\\n training_dist = r(n_training_points)\\n testing_dist = r(n_testing_points)\\n x1, x2 = __random(training_dist[0], testing_dist[0], low, high)\\n x11, x22 = __interspread(training_dist[1], testing_dist[1], low, high)\\n x111, x222 = __interspread(training_dist[2], testing_dist[2], low, high)\\n x1111, x2222 = __seperate(training_dist[3], testing_dist[3], low, high)\\n x_training = np.vstack([x1, x11, x111, x1111])\\n x_testing = np.vstack([x2, x22, x222, x222])\\n\\n y_samples = gp.sample(np.vstack([x_training, x_testing]), 1).squeeze()\\n y_training = y_samples[: len(x_training)].reshape(-1, 1)\\n y_testing = y_samples[len(x_training) :].reshape(-1, 1)\\n training_data_set = data_loader.DataSet(X=x_training, Y=y_training)\\n testing_data_set = data_loader.DataSet(X=x_testing, Y=y_testing)\\n\\n if shuffle:\\n training_data_set.shuffle()\\n testing_data_set.shuffle()\\n\\n return training_data_set, testing_data_set\",\n \"def prepare_nfold_datasets(self): # i.e. split into different train/ground-truth(test) dataset\\n for alpha in range(1, self.ALPHAs+1):\\n if alpha != self.ALPHAs:\\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI], separator='-')\\n else:\\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI+self.runoff_years], separator='-')\\n new_cluster_dir = str(Path(self.tl_model.cluster_dir) / f'alpha_{alpha}_GT-{gt_years}')\\n os.makedirs(new_cluster_dir, exist_ok=True)\\n\\n new_prepared_data_dir = str(Path(self.tl_model.prepared_data_dir) / f'alpha_{alpha}')\\n os.makedirs(new_prepared_data_dir, exist_ok=True)\\n \\n if utils.find(f'*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir) and utils.find(f'*alpha_{alpha}_standardized_stacked_arr.pkl', new_prepared_data_dir):\\n pass\\n else:\\n if not utils.find(f'*target*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\\n print(f\\\"=> No input datasets pre-processed for alpha of {alpha}\\\")\\n prepare.cut_target_dataset(self, alpha, new_prepared_data_dir)\\n\\n if not utils.find(f'*rf*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\\n print(f\\\"=> No rainfall datasets pre-processed for alpha of {alpha}\\\")\\n prepare.cut_rf_dataset(self, alpha, new_prepared_data_dir)\\n \\n print(f'Preprocessed pickles for alpha split {alpha} can be found @:\\\\n{new_prepared_data_dir}')\",\n \"def test_training(self):\\n\\t\\tpass\",\n \"def data_split(self, split_index=0, thinning=None, apply_mask=False, mask=[], **kwargs):\\n \\n self.learn_sets = ['train','vali','test']\\n self.ind_train = self.train_splitdict[split_index]\\n self.ind_train.sort()\\n self.ind_test = self.test_splitdict[split_index]\\n self.ind_test.sort()\\n if len(self.vali_splitdict) !=0:\\n self.learn_sets = ['train','vali','test']\\n self.ind_vali = self.vali_splitdict[split_index]\\n self.ind_vali.sort()\\n self.indices_learn_dict = dict(zip(self.learn_sets, [self.ind_train, self.ind_vali, self.ind_test]))\\n else:\\n self.learn_sets = ['train','test']\\n self.indices_learn_dict = dict(zip(self.learn_sets, [self.ind_train, self.ind_test]))\\n\\n\\n self.train_samples = self.fullspace[self.ind_train]\\n self.train_size = len(self.train_samples)\\n\\n if len(self.vali_splitdict) !=0:\\n self.vali_samples = self.fullspace[self.ind_vali]\\n self.vali_samples.sort()\\n self.vali_size = len(self.vali_samples)\\n else:\\n self.vali_size = 0\\n self.test_samples = self.fullspace[self.ind_test]\\n #self.test_samples.sort()\\n self.test_size = len(self.test_samples)\\n verbosity = kwargs.get('verbosity', 1)\\n\\n too.condprint(\\\"number of obtained training vectors\\\", self.train_size, level=1, verbosity=verbosity)\\n too.condprint(\\\"number of obtained validation vectors\\\", self.vali_size, level=1, verbosity=verbosity)\\n too.condprint(\\\"number of obtained test vectors\\\", self.test_size, level=2, verbosity=verbosity)\\n\\n\\n self.matrix_datalearn_dict = dict()\\n\\n for dli in self.learn_sets:\\n matrixdata = np.copy(self.matrix_z)\\n self.matrixdata=matrixdata\\n\\n ## copy of mask to avoid modifying orginal mask after iterations\\n if apply_mask==False:\\n maskcopy=np.arange(0,len(matrixdata[0])) ##range over all axis length, does not mask anything\\n else:\\n maskcopy=np.copy(mask)\\n \\n ## apply thinning (if set to None, there is no thinning)\\n self.mask_true=maskcopy[::thinning] \\n\\n ## apply mask also to feature grid and save as masked_+...\\n setattr(self, 'masked_'+self.features_str, self.fgrid[self.mask_true]) \\n\\n matrixdata = matrixdata[:,self.mask_true] ## apply mask and thinning to feature space (k-grid)\\n indices_l = self.indices_learn_dict[dli]\\n matrixdata = matrixdata[indices_l,:] ##choose learning set\\n self.matrix_datalearn_dict[dli] = matrixdata\\n self.matrix_datalearn_dict = objdict(self.matrix_datalearn_dict)\\n return self.matrix_datalearn_dict\",\n \"def setup(self, stage: Optional[str] = None):\\n if stage in (None, 'fit'):\\n # Get a 20% of the train data for validation in a stratified way.\\n _x = [i[1] for i in self.splits['train']]\\n _y = [i[0] for i in self.splits['train']]\\n\\n _train_x, _val_x, _train_y, _val_y = train_test_split(_x, _y, test_size=0.2,\\n stratify=_y)\\n #print(np.unique(_train_y, return_counts=True))\\n #print(np.unique(_val_y, return_counts=True))\\n\\n self.splits['train'] = [[i, j] for i,j in zip(_train_y, _train_x)]\\n self.splits['valid'] = [[i, j] for i,j in zip(_val_y, _val_x)]\\n\\n self.datasets['train'] = FewShotDataset(self.splits['train'], self.ops)\\n self.datasets['valid'] = FewShotDataset(self.splits['valid'], self.ops)\\n\\n if stage in (None, 'test'):\\n self.datasets['test'] = FewShotDataset(self.splits['test'], self.ops)\",\n \"def prediction_data(median_split,mean_split,std_split,degrees_split,weight_split,export_file):\\n DATA_TEST_PATH = '../data/test.csv' # Download train data and supply path here \\n print('\\\\nIMPORTING TESTING DATA :',end=\\\" \\\")\\n y_test, tX_test, ids_test = load_csv_data(DATA_TEST_PATH)\\n print('DONE')\\n \\n #5.a. Splitting the testing data\\n print('SPLITTING TESTING DATA :',end=\\\" \\\")\\n y_test_split,tx_test_split,id_test_split = split_dataset(y_test,tX_test,ids_test) \\n print('DONE') \\n #5.b. prediction on each model\\n y_pred = list()\\n \\n for split,(y_test_s,tx_test_s,id_test_s) in enumerate(zip(y_test_split,tx_test_split,id_test_split)): \\n print('PREDICTION FOR TESTING DATA SPLIT NUMBER',split)\\n \\n #Formatting to the correct datatype\\n y_test_s = np.squeeze(y_test_s)\\n tx_test_s = np.squeeze(tx_test_s)\\n id_test_s = np.squeeze(id_test_s)\\n print('Size of the vectors',y_test_s.shape,tx_test_s.shape) \\n #Formatting the data themselves\\n print('Counting NaN',end='. ')\\n tx_test_s = count_NaN(tx_test_s)\\n print('Sanitizing',end = ' . ')\\n tx_test_s,median_vec = sanitize_NaN(tx_test_s,median_split[split])\\n print('Standardizing',end = ' .')\\n tx_test_s,mean_te,std_te = standardize(tx_test_s,mean_split[split],std_split[split])\\n print('Building polynomial basis') \\n tx_test_s = build_poly(tx_test_s, degrees_split[split])\\n \\n #Prediction\\n y_pred.append(predict_labels(np.array(weight_split[split]), np.array(tx_test_s))) \\n \\n print('MERGING TESTING DATA',end=\\\"\\\")\\n y_pred_merged, ids_merged = merge_dataset(y_pred,id_test_split)\\n print('DONE')\\n \\n OUTPUT_PATH = 'results/output_sanitized_normalization_'+export_file+'.csv' \\n print('EXPORTING TESTING DATA WITH PREDICTIONS :',end=\\\" \\\")\\n \\n create_csv_submission(ids_merged, y_pred_merged, OUTPUT_PATH)\\n print('DONE')\",\n \"def create_final_strategy(filename: str, columns_list: List[str], som_width=Config.som_width,\\n som_height=Config.som_height, n_iter=Config.n_iter, sigma=Config.sigma,\\n learning_rate=Config.learning_rate) -> tuple:\\n\\n print(\\n f'Creating final strategy for parameters: \\\\nmap_size: {som_height}\\\\nn_iter: {n_iter}\\\\nsigma:{sigma}\\\\nlr: {learning_rate}')\\n # get prepared data\\n df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)\\n\\n # train som\\n final_df_train, final_df_test = train_som(som_width, som_height, df, df_train, df_test, df_train_columns, n_iter,\\n sigma=sigma, learning_rate=learning_rate)\\n\\n # get profit per cluster in train datasets\\n df_profit_per_cluster_train = get_profit_per_cluster(final_df_train)\\n\\n assert len(df_profit_per_cluster_train) >= 3, \\\"Algorithm, returned less than 3 clusters.\\\"\\n\\n df_profit_per_cluster = df_profit_per_cluster_train.sort_values(by='profit', ascending=False)\\n group_size = int(len(df_profit_per_cluster) / 3)\\n\\n buy_clusters_list = list(df_profit_per_cluster.iloc[:group_size]['cluster'])\\n sell_clusters_list = list(df_profit_per_cluster.iloc[-group_size:]['cluster'])\\n\\n return final_df_train, final_df_test, buy_clusters_list, sell_clusters_list\",\n \"def load_data(self,split='train'):\\n raise NotImplementedError\",\n \"def read_data_split_and_search():\\n\\n\\n\\n dataReader = Movielens10MReader()\\n dataset = dataReader.load_data()\\n\\n URM_train, URM_test = split_train_in_two_percentage_global_sample(dataset.get_URM_all(), train_percentage = 0.80)\\n URM_train, URM_validation = split_train_in_two_percentage_global_sample(URM_train, train_percentage = 0.80)\\n\\n output_folder_path = \\\"result_experiments/\\\"\\n\\n\\n # If directory does not exist, create\\n if not os.path.exists(output_folder_path):\\n os.makedirs(output_folder_path)\\n\\n\\n\\n\\n\\n\\n\\n collaborative_algorithm_list = [\\n Random,\\n TopPop,\\n P3alphaRecommender,\\n RP3betaRecommender,\\n ItemKNNCFRecommender,\\n UserKNNCFRecommender,\\n MatrixFactorization_BPR_Cython,\\n MatrixFactorization_FunkSVD_Cython,\\n PureSVDRecommender,\\n SLIM_BPR_Cython,\\n SLIMElasticNetRecommender\\n ]\\n\\n\\n\\n\\n from Base.Evaluation.Evaluator import EvaluatorHoldout\\n\\n evaluator_validation = EvaluatorHoldout(URM_validation, cutoff_list=[5])\\n evaluator_test = EvaluatorHoldout(URM_test, cutoff_list=[5, 10])\\n\\n\\n runParameterSearch_Collaborative_partial = partial(runParameterSearch_Collaborative,\\n URM_train = URM_train,\\n metric_to_optimize = \\\"MAP\\\",\\n n_cases = 10,\\n evaluator_validation_earlystopping = evaluator_validation,\\n evaluator_validation = evaluator_validation,\\n evaluator_test = evaluator_test,\\n output_folder_path = output_folder_path,\\n similarity_type_list = [\\\"cosine\\\"],\\n parallelizeKNN = False)\\n\\n\\n\\n\\n\\n pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)\\n pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)\\n\\n #\\n #\\n # for recommender_class in collaborative_algorithm_list:\\n #\\n # try:\\n #\\n # runParameterSearch_Collaborative_partial(recommender_class)\\n #\\n # except Exception as e:\\n #\\n # print(\\\"On recommender {} Exception {}\\\".format(recommender_class, str(e)))\\n # traceback.print_exc()\\n #\",\n \"def split_data(basedir, data_split=0.80):\\n manip = data_manipulator(basedir)\\n manip.train_test_split(data_split=data_split)\",\n \"def generate_data(project_data, config, split_method = RAW) :\\n training_data = []\\n testing_data = []\\n \\n # Flatten the data (collapse the project and session hierarchy into a list of session_data)\\n for v in config.train_project_names:\\n # Data in all sessions of one project\\n project_session_data = random.sample(project_data[v], len(project_data[v]))\\n\\n training_data += project_session_data[int(config.session_training_percentage[0] * len(project_session_data)):\\n int(config.session_training_percentage[1] * len(project_session_data))]\\n\\n if config.double_training:\\n for i in xrange(int(config.session_training_percentage[0] * len(project_session_data)),\\n int(config.session_training_percentage[1] * len(project_session_data))):\\n session_data = project_session_data[i]\\n\\n reversed_session_data = {}\\n reversed_session_data[SESSION_NAME] = session_data[SESSION_NAME] + \\\"_reversed\\\"\\n reversed_session_data[SESSION_EVENTS] = []\\n\\n def reverse_point_data_qsr(point_data):\\n reversed_point_data = point_data[:4]\\n # Hands to objects feature swap\\n reversed_point_data += point_data[8:12] \\n reversed_point_data += point_data[4:8]\\n\\n # Centroid direction and distance difference is symmetric\\n reversed_point_data += point_data[12:14]\\n\\n # Object corners swap\\n reversed_point_data += point_data[16:18] \\n reversed_point_data += point_data[14:16]\\n\\n reversed_point_data += point_data[18:19]\\n reversed_point_data += point_data[20:21] \\n reversed_point_data += point_data[19:20]\\n\\n # For QTCCS\\n reversed_point_data += point_data[22:23]\\n reversed_point_data += point_data[21:22]\\n reversed_point_data += point_data[24:25]\\n reversed_point_data += point_data[23:24]\\n\\n # # For difference of features\\n # fl = 21\\n # reversed_point_data += point_data[fl:fl + 4]\\n # # Hands to objects feature swap\\n # reversed_point_data += point_data[fl + 8:fl + 12] \\n # reversed_point_data += point_data[fl + 4:fl + 8]\\n\\n # # Centroid direction and distance difference is symmetric\\n # reversed_point_data += point_data[fl + 12:fl + 14]\\n\\n # # Object corners swap\\n # reversed_point_data += point_data[fl + 16:fl + 18] \\n # reversed_point_data += point_data[fl + 14:fl + 16]\\n\\n # reversed_point_data += point_data[fl + 18:fl + 19]\\n # reversed_point_data += point_data[fl + 20:fl + 21] \\n # reversed_point_data += point_data[fl + 19:fl + 20]\\n\\n return reversed_point_data\\n\\n def reverse_point_data_sparse_qsr(point_data):\\n reversed_point_data = point_data[:2 * 56]\\n # Hands to objects feature swap\\n reversed_point_data += point_data[4 * 56:6 * 56] \\n reversed_point_data += point_data[2 * 56:4 * 56]\\n\\n # Centroid direction and distance difference is symmetric\\n reversed_point_data += point_data[6 * 56:7 * 56]\\n\\n # Object corners swap\\n reversed_point_data += point_data[8 * 56:9 * 56] \\n reversed_point_data += point_data[7 * 56:8 * 56]\\n\\n anchor = 9 * 56\\n reversed_point_data += point_data[anchor:anchor + 2]\\n reversed_point_data += point_data[anchor + 2 * 2:anchor + 3 * 2] \\n reversed_point_data += point_data[anchor + 2:anchor + 2 * 2]\\n\\n anchor = 9 * 56 + 3 * 2\\n # For QTCCS\\n reversed_point_data += point_data[anchor + 3:anchor + 2 * 3]\\n reversed_point_data += point_data[anchor:anchor + 3]\\n reversed_point_data += point_data[anchor + 3 * 3:anchor + 4 * 3]\\n reversed_point_data += point_data[anchor + 2 * 3:anchor + 3 * 3]\\n\\n return reversed_point_data\\n\\n reversed_session_data[SESSION_DATA] = []\\n for point_data in session_data[SESSION_DATA]:\\n if split_method == RAW:\\n reversed_point_data = point_data[:39]\\n reversed_point_data += point_data[51:63]\\n reversed_point_data += point_data[39:51]\\n elif split_method == PCAS:\\n reversed_point_data = point_data[:6]\\n # Object centroid swap\\n reversed_point_data += point_data[8:10] \\n reversed_point_data += point_data[6:8]\\n # Object corners swap\\n reversed_point_data += point_data[14:18] \\n reversed_point_data += point_data[10:14]\\n elif split_method == QSR or split_method == EVENT:\\n reversed_point_data = reverse_point_data_qsr(point_data)\\n elif split_method == SPARSE_QSR:\\n reversed_point_data = reverse_point_data_sparse_qsr(point_data)\\n\\n reversed_session_data[SESSION_DATA].append(reversed_point_data)\\n\\n for event_str in session_data[SESSION_EVENTS]:\\n reversed_event_str = {}\\n for key in event_str:\\n reversed_event_str[key] = event_str[key]\\n\\n subj, obj, theme, event, prep = event_str['label']\\n def swap_objects(value):\\n if value == 2:\\n return 3\\n if value == 3:\\n return 2\\n return value\\n\\n reversed_event_str['label'] = (swap_objects(subj), swap_objects(obj), swap_objects(theme), event, prep)\\n\\n reversed_session_data[SESSION_EVENTS].append(reversed_event_str)\\n\\n training_data.append(reversed_session_data)\\n\\n\\n testing_data += project_session_data[int(config.session_testing_percentage[0] * len(project_session_data)):\\n int(config.session_testing_percentage[1] * len(project_session_data))]\\n \\n return (training_data, testing_data)\",\n \"def test_split_data(self, whp_pandas):\\n test_class = Slug_Forecasting(whp_pandas.copy())\\n test_class.stationarity_check()\\n test_class.split_data()\\n\\n assert hasattr(test_class, \\\"y_train\\\"), \\\"y_train attribute must have been create\\\"\\n assert hasattr(test_class, \\\"y_pred\\\"), \\\"y_test attribute must have been create\\\"\\n\\n assert len(test_class.y_train) == 180, \\\"In this example, y_train should be 180 long\\\"\\n assert len(test_class.y_pred) == 60, \\\"In this example, y_pred should be 60 long\\\"\\n\\n test_class = Slug_Forecasting(whp_pandas.copy())\\n\\n # test train size data\\n try:\\n test_class.split_data(train_size=400)\\n print(\\\"Not enough data to fulfill train_size requirement\\\")\\n raise ValueError\\n except AssertionError:\\n pass\",\n \"def __init__(self, h5_path='../dataset/lob.h5', split=1,\\n train=True, n_window=1, normalization='std', epsilon=1e-15, horizon=0, shift=None):\\n\\n self.window = n_window\\n\\n assert 0 <= split <= 8\\n assert 0 <= horizon <= 2\\n\\n # Translate the prediction to horizon to the data\\n if horizon == 1:\\n horizon = 3\\n elif horizon == 2:\\n horizon = 4\\n\\n # Load the data\\n file = h5py.File(h5_path, 'r', )\\n features = np.float32(file['features'])\\n targets = np.int32(file['targets'])\\n day_train_split_idx = file['day_train_split_idx'][:].astype('bool')\\n day_test_split_idx = file['day_test_split_idx'][:].astype('bool')\\n stock_idx = file['stock_idx'][:].astype('bool')\\n file.close()\\n\\n # Get the data for the specific split and setup (train/test)\\n if train:\\n idx = day_train_split_idx[split]\\n\\n # Get the statistics needed for normalization\\n if normalization == 'std':\\n self.mean = np.mean(features[idx], axis=0)\\n self.std = np.std(features[idx], axis=0)\\n features = (features - self.mean) / (self.std + epsilon)\\n else:\\n idx = day_test_split_idx[split]\\n\\n if shift is not None:\\n print(\\\"testing shift = \\\", shift)\\n # Shift the testing features only\\n features[idx] += shift[0]*np.mean(features, axis=0)\\n features[idx] *= shift[1]\\n\\n\\n # Also get the train data to normalize the test data accordingly (if needed)\\n if normalization == 'std':\\n train_idx = day_train_split_idx[split]\\n self.mean = np.mean(features[train_idx], axis=0)\\n self.std = np.std(features[train_idx], axis=0)\\n features = (features - self.mean) / (self.std + epsilon)\\n del train_idx\\n\\n # Get the data per stock\\n self.features_per_stock = []\\n self.labels = []\\n for i in range(len(stock_idx)):\\n cur_idx = np.logical_and(idx, stock_idx[i])\\n self.features_per_stock.append(features[cur_idx])\\n self.labels.append(targets[cur_idx, horizon])\\n\\n # Create a lookup table to find the correct stock\\n self.look_up_margins = []\\n current_sum = 0\\n for i in range(len(self.features_per_stock)):\\n # Remove n_window since they are used to ensure that we are always operate on a full window\\n cur_limit = self.features_per_stock[i].shape[0] - n_window - 1\\n current_sum += cur_limit\\n self.look_up_margins.append(current_sum)\\n\\n\\n # Get the total number of samples\\n self.n = self.look_up_margins[-1]\\n self.n_stocks = len(self.look_up_margins)\",\n \"def train(self,path,mode):\\n if mode == \\\"porto\\\":\\n self.prepare_data(path)\\n else:\\n self.prepare_sumo_data(path)\\n self.poly_regression()\",\n \"def __init__(self, scoring_function=None, partition_index=0):\\n self.trained_data = dict()\\n self.scoring_function = scoring_function or diff_score\\n self.last_pred = []\\n self.partitions = dict()\\n self.partition_index = partition_index\",\n \"def prepare_data(dataset, train_ratio=0.8, input_dim=None, seed=10):\\n # Retrieve main path of project\\n dirname = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))\\n\\n # Download and store dataset at chosen location\\n if dataset == 'Cora' or dataset == 'PubMed' or dataset == 'Citeseer':\\n path = os.path.join(dirname, 'data')\\n data = Planetoid(path, name=dataset, split='full')[0]\\n data.name = dataset\\n data.num_classes = (max(data.y)+1).item()\\n # data.train_mask, data.val_mask, data.test_mask = split_function(data.y.numpy())\\n # data = Planetoid(path, name=dataset, split='public', transform=T.NormalizeFeatures(), num_train_per_class=20, num_val=500, num_test=1000)\\n\\n elif dataset == 'Amazon':\\n path = os.path.join(dirname, 'data', 'Amazon')\\n data = Amazon(path, 'photo')[0]\\n data.name = dataset\\n data.num_classes = (max(data.y)+1).item()\\n data.train_mask, data.val_mask, data.test_mask = split_function(\\n data.y.numpy(), seed=seed)\\n # Amazon: 4896 train, 1224 val, 1530 test\\n \\n elif dataset in ['syn1', 'syn2', 'syn4', 'syn5']: \\n data = synthetic_data(\\n dataset, dirname, train_ratio, input_dim)\\n \\n elif dataset == 'syn6':\\n data = gc_data(dataset, dirname, train_ratio)\\n\\n elif dataset == 'Mutagenicity':\\n data = gc_data(dataset, dirname, train_ratio)\\n\\n return data\",\n \"def split_data_metrics_learning(cfg):\\n actual_pose = cfg['actual_pose']\\n target = cfg['target']\\n person_ids = cfg['person_ids']\\n \\n # Split train and val data based on the person ids.\\n all_ids = np.arange(1, 21)\\n val_ids = cfg['val_ids']\\n train_ids = set(all_ids).symmetric_difference(val_ids)\\n \\n anchor_gallery_split_size = cfg['anchor_gallery_split_size']\\n window_width = cfg['window_width']\\n overlap = cfg['overlap']\\n random_state = cfg['random_state']\\n \\n # Get only the training set data and the label.\\n X_train, y_train = get_req_ids(actual_pose, target, train_ids, person_ids)\\n \\n # Select the evaluation data that measures the performance of the model on the training set.\\n train_accuracy_ids = random.sample(train_ids, len(val_ids))\\n X_train_acc, y_train_acc = get_req_ids(actual_pose, target, train_accuracy_ids, person_ids)\\n \\n # Anchor/Gallery set split for the training set.\\n X_train_gal, X_train_anchor, y_train_gal, y_train_anchor = train_test(X_train = X_train_acc, y_train = y_train_acc, \\n test_size=anchor_gallery_split_size, \\n random_state=random_state, stratify=y_train_acc)\\n \\n # Subsample the gait sequences of the anchor/gallery set of the training set based on the window width and the overlap.\\n X_train_gal, y_train_gal = subsample(cfg, X_train_gal, y_train_gal, window_width=window_width, overlap=overlap)\\n X_train_anchor, y_train_anchor = subsample(cfg, X_train_anchor, y_train_anchor, window_width=window_width, overlap=overlap)\\n \\n # Get only the validation set data and the label.\\n X_val, y_val = get_req_ids(actual_pose, target, val_ids, person_ids)\\n \\n # Anchor/Gallery set split for the validation set.\\n X_val_gal, X_val_anchor, y_val_gal, y_val_anchor = train_test(X_train = X_val, \\n y_train = y_val, \\n test_size=anchor_gallery_split_size, \\n random_state=random_state, \\n stratify=y_val)\\n \\n \\n # If data augmentation parameter is set to True in the configuration dictionary, data augmentation is done for the training set.\\n if cfg['augment_data']:\\n X_train, y_train = augment_data(X_train, y_train)\\n \\n # Subsample the gait sequences of the whole training set based on the window width and the overlap.\\n X_train, y_train = subsample(cfg, X_train, y_train, window_width=window_width, overlap=overlap)\\n \\n # Subsample the gait sequences of the anchor/gallery set of the validation set based on the window width and the overlap.\\n X_val_gal, y_val_gal = subsample(cfg, X_val_gal, y_val_gal, window_width=window_width, overlap=overlap)\\n X_val_anchor, y_val_anchor = subsample(cfg, X_val_anchor, y_val_anchor, window_width=window_width, overlap=overlap)\\n \\n # Concatenate the gallery and anchor set of the validation data and label as a whole. This is just to maintain the train-val uniformity and \\n # is not used anywhere in the project.\\n X_val, y_val = np.concatenate((X_val_gal, X_val_anchor)), np.concatenate((y_val_gal, y_val_anchor))\\n \\n return X_train, X_val, X_train_gal, X_train_anchor, X_val_gal, X_val_anchor, y_train, y_val, y_train_gal, y_train_anchor, y_val_gal, y_val_anchor\",\n \"def main(input_filepath, output_filepath):\\n\\n logging.info(\\\"reading %s\\\", input_filepath)\\n train_test = pd.read_hdf(input_filepath, 'train_test')\\n meta = pd.read_hdf(input_filepath, 'meta')\\n meta_org = pd.read_hdf(input_filepath, 'meta_org')\\n\\n sel_series = train_test[train_test.entry_type.isin(['train', 'cold_start'])]\\\\\\n ['series_id'].unique()\\n train_series, validate_series = train_test_split(sel_series, random_state=1)\\n\\n logging.info(\\\"calc train_test\\\")\\n train_test = calc_final_features(train_test, meta, meta_org=meta_org, verbose=True)\\n\\n sel = train_test[train_test.entry_type.isin(['train', 'cold_start'])]\\n train = sel[sel.series_id.isin(train_series)]\\n validate = sel[sel.series_id.isin(validate_series)]\\n test = train_test[train_test.entry_type.isin(['test'])]\\n\\n logging.info(\\\"writing %s\\\", output_filepath)\\n train.to_hdf(output_filepath, \\\"train\\\", mode=\\\"w\\\")\\n validate.to_hdf(output_filepath, \\\"validate\\\", mode=\\\"a\\\")\\n test.to_hdf(output_filepath, \\\"test\\\", mode=\\\"a\\\")\\n for k in ['meta', 'submission']:\\n df = pd.read_hdf(input_filepath, k)\\n df.to_hdf(output_filepath, k, mode=\\\"a\\\")\",\n \"def main():\\n datasets = {}\\n for dataset_name in tqdm(SOURCE_DATASET_NAMES, desc=\\\"Processing datasets and fitting base models\\\"):\\n logger.info(f\\\"processing dataset {dataset_name}\\\")\\n clusters_path: Optional[str] = None\\n if dataset_name not in PAIRWISE_ONLY_DATASETS:\\n clusters_path = os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_clusters.json\\\")\\n train_pairs_path = None\\n val_pairs_path = None\\n test_pairs_path = None\\n else:\\n train_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"train_pairs.csv\\\")\\n val_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"val_pairs.csv\\\")\\n if not os.path.exists(val_pairs_path):\\n val_pairs_path = None\\n test_pairs_path = os.path.join(DATA_DIR, dataset_name, \\\"test_pairs.csv\\\")\\n\\n logger.info(f\\\"loading dataset {dataset_name}\\\")\\n anddata = ANDData(\\n signatures=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_signatures.json\\\"),\\n papers=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_papers.json\\\"),\\n name=dataset_name,\\n mode=\\\"train\\\",\\n specter_embeddings=os.path.join(DATA_DIR, dataset_name, dataset_name + \\\"_specter.pickle\\\"),\\n clusters=clusters_path,\\n block_type=BLOCK_TYPE,\\n train_pairs=train_pairs_path,\\n val_pairs=val_pairs_path,\\n test_pairs=test_pairs_path,\\n train_pairs_size=N_TRAIN_PAIRS_SIZE,\\n val_pairs_size=N_VAL_TEST_SIZE,\\n test_pairs_size=N_VAL_TEST_SIZE,\\n preprocess=True,\\n )\\n\\n logger.info(f\\\"featurizing {dataset_name}\\\")\\n train, val, test = featurize(\\n anddata,\\n FEATURIZER_INFO,\\n n_jobs=N_JOBS,\\n use_cache=True,\\n chunk_size=100,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO,\\n nan_value=NAN_VALUE,\\n )\\n X_train, y_train, nameless_X_train = train\\n X_val, y_val, nameless_X_val = val\\n X_test, y_test, nameless_X_test = test\\n\\n dataset = {}\\n dataset[\\\"anddata\\\"] = anddata\\n dataset[\\\"X_train\\\"] = X_train\\n dataset[\\\"y_train\\\"] = y_train\\n dataset[\\\"X_val\\\"] = X_val\\n dataset[\\\"y_val\\\"] = y_val\\n dataset[\\\"X_test\\\"] = X_test\\n dataset[\\\"y_test\\\"] = y_test\\n dataset[\\\"nameless_X_train\\\"] = nameless_X_train\\n dataset[\\\"nameless_X_val\\\"] = nameless_X_val\\n dataset[\\\"nameless_X_test\\\"] = nameless_X_test\\n dataset[\\\"name\\\"] = anddata.name\\n datasets[dataset_name] = dataset\\n\\n anddatas = [\\n datasets[dataset_name][\\\"anddata\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in PAIRWISE_ONLY_DATASETS\\n ]\\n\\n X_train = np.vstack([datasets[dataset_name][\\\"X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n y_train = np.hstack([datasets[dataset_name][\\\"y_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n X_val = np.vstack(\\n [datasets[dataset_name][\\\"X_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n y_val = np.hstack(\\n [datasets[dataset_name][\\\"y_val\\\"] for dataset_name in SOURCE_DATASET_NAMES if dataset_name not in {\\\"augmented\\\"}]\\n )\\n\\n nameless_X_train = np.vstack([datasets[dataset_name][\\\"nameless_X_train\\\"] for dataset_name in SOURCE_DATASET_NAMES])\\n nameless_X_val = np.vstack(\\n [\\n datasets[dataset_name][\\\"nameless_X_val\\\"]\\n for dataset_name in SOURCE_DATASET_NAMES\\n if dataset_name not in {\\\"augmented\\\"}\\n ]\\n )\\n\\n logger.info(\\\"fitting pairwise\\\")\\n union_classifier = PairwiseModeler(n_iter=N_ITER, monotone_constraints=MONOTONE_CONSTRAINTS)\\n union_classifier.fit(X_train, y_train, X_val, y_val)\\n\\n nameless_union_classifier = None\\n if USE_NAMELESS_MODEL:\\n logger.info(\\\"nameless fitting pairwise for \\\" + str(SOURCE_DATASET_NAMES))\\n nameless_union_classifier = PairwiseModeler(\\n n_iter=N_ITER,\\n monotone_constraints=NAMELESS_MONOTONE_CONSTRAINTS,\\n )\\n nameless_union_classifier.fit(nameless_X_train, y_train, nameless_X_val, y_val)\\n logger.info(\\\"nameless pairwise fit for \\\" + str(SOURCE_DATASET_NAMES))\\n\\n logger.info(\\\"fitting clusterer for\\\")\\n union_clusterer = Clusterer(\\n FEATURIZER_INFO,\\n union_classifier.classifier,\\n cluster_model=FastCluster(),\\n search_space=search_space,\\n n_jobs=N_JOBS,\\n nameless_classifier=nameless_union_classifier.classifier if nameless_union_classifier is not None else None,\\n nameless_featurizer_info=NAMELESS_FEATURIZER_INFO if nameless_union_classifier is not None else None,\\n )\\n union_clusterer.fit(anddatas)\\n print(\\n \\\"best clustering parameters:\\\",\\n union_clusterer.best_params,\\n )\\n\\n models = {}\\n models[\\\"clusterer\\\"] = union_clusterer\\n\\n with open(\\n f\\\"full_union_model_script_dump_average_{FEATURIZER_VERSION}.pickle\\\",\\n \\\"wb\\\",\\n ) as _pickle_file:\\n pickle.dump(models, _pickle_file)\\n logger.info(\\\"Done.\\\")\",\n \"def train(train_set, test_set, train_label, test_label, data_name, test_filenames, dimension_reduce=False,\\n distribute_training=False):\\n train_set = np.array(train_set)\\n test_set = np.array(test_set)\\n\\n print(\\\"The shape of training set before dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set before dimension reduction is {0}\\\".format(test_set.shape))\\n print('Use distribute training ? >> {0}'.format(distribute_training))\\n reg = linear_model.BayesianRidge()\\n\\n if dimension_reduce:\\n pca = PCA(n_components=128)\\n train_set = pca.fit_transform(train_set)\\n test_set = pca.fit_transform(test_set)\\n\\n print(\\\"The shape of training set after dimension reduction is {0}\\\".format(train_set.shape))\\n print(\\\"The shape of test set after dimension reduction is {0}\\\".format(test_set.shape))\\n\\n if not distribute_training:\\n reg.fit(train_set, train_label)\\n else:\\n train_set, test_set, train_label, test_label = da.array(train_set), da.array(test_set), da.array(\\n train_label), da.array(test_label)\\n reg.fit(train_set, train_label)\\n\\n predicted_label = reg.predict(test_set)\\n mae_lr = round(mean_absolute_error(test_label, predicted_label), 4)\\n rmse_lr = round(math.sqrt(mean_squared_error(test_label, predicted_label)), 4)\\n pc = round(np.corrcoef(test_label, predicted_label)[0, 1], 4)\\n print('===============The Mean Absolute Error of Model is {0}===================='.format(mae_lr))\\n print('===============The Root Mean Square Error of Model is {0}===================='.format(rmse_lr))\\n print('===============The Pearson Correlation of Model is {0}===================='.format(pc))\\n\\n mkdirs_if_not_exist('./model')\\n joblib.dump(reg, './model/BayesRidge_%s.pkl' % data_name)\\n print('The regression model has been persisted...')\\n\\n mkdirs_if_not_exist('./result')\\n\\n out_result(test_filenames, predicted_label, test_label, None, path='./result/Pred_GT_{0}.csv'.format(data_name))\\n\\n df = pd.DataFrame([mae_lr, rmse_lr, pc])\\n df.to_csv('./result/%s.csv' % data_name, index=False)\\n print('The result csv file has been generated...')\",\n \"def split_dataset(self, split):\\n trunk_pos_size = math.ceil((1 - split) * len(self.Pos))\\n trunk_neg_size = math.ceil((1 - split) * len(self.Neg))\\n trunk_num = int(1 / (1 - split))\\n pos_temp = list()\\n neg_temp = list()\\n for index in range(trunk_num):\\n pos_temp.append(self.Pos[index * trunk_pos_size:(index + 1) *\\n trunk_pos_size])\\n neg_temp.append(self.Neg[index * trunk_neg_size:(index + 1) *\\n trunk_neg_size])\\n self.test = pos_temp.pop(2) + neg_temp.pop(2)\\n # self.train = [i for item in pos_temp + neg_temp for i in item]\\n self.train = []\\n for item in pos_temp + neg_temp:\\n for i in item:\\n self.train.append(i)\\n\\n random.shuffle(self.train)\\n random.shuffle(self.test)\",\n \"def train(self, algorithm):\\n\\n kfold = StratifiedKFold(10, True, 1)\\n f1_score = []\\n precision_score = []\\n recall_score = []\\n for train, test in kfold.split(self.data_training, self.data_target):\\n model = algorithm.fit(self.data_training.iloc[train], self.data_target.iloc[train])\\n scores = self.score_model(model, self.data_training.iloc[test], self.data_target.iloc[test])\\n f1_score.append(scores[0])\\n precision_score.append(scores[1])\\n recall_score.append(scores[2])\\n\\n self.print_results(f1_score, precision_score, recall_score)\",\n \"def main():\\n df = prepro_last()\\n X, y = train_build(df)\\n fit_store(X, y)\",\n \"def main(cls, args):\\n #cls.trainOfflineAndTest(100, 0.1, 0.1, 0.9);\\n #cls.trainOfflineAndTest(500, 0.1, 0.1, 1.0);\\n\\n cls.trainer.teachActiveAndSaveStatistics(\\\"onlineTest\\\", 10, 0.8, 1.0 ,1.0, 0.0, 0.3, True, True,True);\\n cls.trainer.teachActiveAndSaveStatistics(\\\"path\\\", 10, 0.0, 0.0, 0.0, 0.0, 0.0, True, False, False)\\n\\n #trainer.teachActiveAndSaveStatistics(\\\"onlineTest\\\", 10000, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f,true, true, true);\\n # \\t\\ttrainer.teachActiveAndSaveStatistics(\\\"onlineTest\\\", 10000, 0.1f, 0.1f, 1.0f, 0.0f, 0.1f,\\n # \\t\\t\\t\\tfalse, true, true);\\n # \\t\\t\\n # \\t\\ttestAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1_first.net\\\", 10000, true);\\n # \\t\\ttestAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1_secound.net\\\", 10000, true);\\n #cls.testAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1_first.net\\\", 10000, False)\\n #cls.testAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1_secound.net\\\", 10, False)\\n # \\t\\ttestAgentFromFileWithOutLearning(\\\"net10000_a0.1_b0.1g_1.0e_0.1.net\\\", 10000, false);\",\n \"def split_data(self,test=False):\\n shuffle_index = torch.randperm(self.train_target.shape[0])\\n load = shuffle_index.shape[0]\\n train_input_shuffle = self.train_input[shuffle_index]\\n train_target_shuffle = self.train_target[shuffle_index]\\n train_classes_shuffle = self.train_classes[shuffle_index]\\n index_train = self.index_for_equal_class(train_target_shuffle[:load//2])\\n train_input = train_input_shuffle[index_train]\\n train_target = train_target_shuffle[index_train]\\n train_classes = train_classes_shuffle[index_train]\\n if not test:\\n index_test = self.index_for_equal_class( train_target_shuffle[load//2:]) + load//2\\n test_input = train_input_shuffle[index_test]\\n test_target = train_target_shuffle[index_test]\\n test_classes = train_classes_shuffle[index_test]\\n else:\\n index_test = self.index_for_equal_class(self.test_target)\\n test_input = self.test_input[index_test]\\n test_target = self.test_target[index_test]\\n test_classes = self.test_classes[index_test]\\n train_input, mean, std = normalize(train_input)\\n test_input, _, _ = normalize(test_input,mean,std)\\n return train_input, train_target, train_classes ,test_input ,test_target ,test_classes\",\n \"def split_train_test_classifier(self, split_method, method):\\n \\n # split data balance based on user and act (if provided)\\n if method == 'window_based':\\n data_train, data_val, label_user_train, label_user_val, id_window_train, id_window_val = self.split_train_val_classifier(\\n self.classifier['data'], self.classifier['user_label'], self.classifier['act_label'], self.classifier['id'], 'standard', train_size=0.9) \\n\\n print(f'Train window before delete overlap sequence: {data_train.shape[0]}')\\n\\n # delete overlap sequence\\n if self.overlap != 0:\\n if self.overlap == 0.5:\\n distance_to_delete = [1]\\n elif self.overlap == 0.75:\\n distance_to_delete = [1,2,3]\\n invalid_idx = delete_overlap(id_window_train, id_window_val, distance_to_delete)\\n data_train = np.delete(data_train, invalid_idx, axis=0)\\n label_user_train = np.delete(label_user_train, invalid_idx, axis=0)\\n\\n print(f'Train window after delete overlap sequence: {data_train.shape[0]}')\\n print(f'Validation set: {data_val.shape[0]}')\\n \\n elif method == 'cycle_based':\\n data_train, data_val, label_user_train, label_user_val = self.split_train_val_classifier(\\n self.classifier['data'], self.classifier['user_label'], self.classifier['act_label'], None, split_method, train_size=0.9) \\n\\n self.train = data_train\\n self.train_user = label_user_train\\n self.val = data_val\\n self.val_user = label_user_val\",\n \"def train_model_pipeline(conform_shape=True, indi_proportion=0.50, incl_group_imgs=True,\\r\\n feature_extractor=flatten_array, model=train_logistic_regression): \\r\\n # Create dataframe subject to feature extractor requirements\\r\\n X_train, y_train, X_test_indi, y_test_indi, X_test_group, y_test_group = \\\\\\r\\n create_train_test_sets(conform_shape=conform_shape, indi_proportion=indi_proportion, \\r\\n incl_group_imgs=incl_group_imgs)\\r\\n \\r\\n # Extract features\\r\\n if feature_extractor == extract_ORB_features:\\r\\n if os.path.isfile('Trained_Models/Kmeans_model.sav'):\\r\\n kmeans_model = load_model('Trained_Models/Kmeans_model.sav')\\r\\n else:\\r\\n kmeans_model = kmeans_cluster(X_train, 500)\\r\\n X_train = feature_extractor(X_train, kmeans_model, normalize = False)\\r\\n X_test_indi = feature_extractor(X_test_indi, kmeans_model, normalize = False)\\r\\n X_test_group = feature_extractor(X_test_group, kmeans_model, normalize = False)\\r\\n\\r\\n else:\\r\\n X_train = feature_extractor(X_train)\\r\\n X_test_indi = feature_extractor(X_test_indi)\\r\\n X_test_group = feature_extractor(X_test_group)\\r\\n \\r\\n # Train model on flattened array (no feature extraction)\\r\\n trained_model = model(X_train, y_train)\\r\\n \\r\\n indi_pred_class, indi_accuracy = evaluate_model(trained_model, X_test_indi, y_test_indi)\\r\\n group_pred_class, group_accuracy = evaluate_model(trained_model, X_test_group, y_test_group)\\r\\n \\r\\n return trained_model, indi_pred_class, indi_accuracy, group_pred_class, group_accuracy\",\n \"def train(cfg):\\n # Set up environment.\\n distributed.init_distributed_training(cfg)\\n\\n # Set random seed from configs.\\n np.random.seed(cfg.RNG_SEED)\\n torch.manual_seed(cfg.RNG_SEED)\\n\\n # Print config.\\n if distributed.is_master_proc():\\n print(\\\"Train with config:\\\")\\n print(pprint.pformat(cfg))\\n\\n # Create train and val loaders.\\n train_dataset = PanopticNarrativeGroundingDataset(cfg, cfg.DATA.TRAIN_SPLIT, train=True)\\n train_loader = DataLoader(\\n train_dataset,\\n batch_size=int(cfg.TRAIN.BATCH_SIZE / max(1, cfg.NUM_GPUS)),\\n shuffle=(False if cfg.NUM_GPUS > 1 else True),\\n sampler=(DistributedSampler(train_dataset) if cfg.NUM_GPUS > 1 else None),\\n num_workers=cfg.DATA_LOADER.NUM_WORKERS,\\n pin_memory=cfg.DATA_LOADER.PIN_MEMORY\\n )\\n if cfg.DATA.VAL_SPLIT is not None:\\n val_dataset = PanopticNarrativeGroundingDataset(cfg, cfg.DATA.VAL_SPLIT, train=False)\\n val_loader = DataLoader(\\n val_dataset,\\n batch_size=(1 if cfg.NUM_GPUS > 1 else cfg.TRAIN.BATCH_SIZE),\\n shuffle=False,\\n sampler=(DistributedSampler(val_dataset) if cfg.NUM_GPUS > 1 else None),\\n num_workers=cfg.DATA_LOADER.NUM_WORKERS,\\n pin_memory=cfg.DATA_LOADER.PIN_MEMORY\\n )\\n\\n # Build the model and print model statistics.\\n # Use cuda if available\\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\\n # Construct the model\\n model = PanopticNarrativeGroundingBaseline(cfg, device=device)\\n # Determine the GPU used by the current process\\n cur_device = torch.cuda.current_device()\\n # Transfer the model to the current GPU device\\n model = model.cuda(device=cur_device)\\n # Use multi-process data parallel model in the multi-gpu setting\\n if cfg.NUM_GPUS > 1:\\n # Make model replica operate on the current device\\n model = torch.nn.parallel.DistributedDataParallel(\\n module=model, device_ids=[cur_device], output_device=cur_device,\\n find_unused_parameters=True\\n )\\n if cfg.LOG_MODEL_INFO and distributed.is_master_proc():\\n print(\\\"Model:\\\\n{}\\\".format(model))\\n print(\\\"Params: {:,}\\\".format(np.sum([p.numel() for p in model.parameters()]).item()))\\n print(\\\"Mem: {:,} MB\\\".format(torch.cuda.max_memory_allocated() / 1024 ** 3))\\n print(\\\"nvidia-smi\\\")\\n os.system(\\\"nvidia-smi\\\")\\n\\n if cfg.MODEL.BERT_FREEZE:\\n if cfg.NUM_GPUS > 1:\\n for param in model.module.bert_encoder.model.bert.encoder.layer.parameters():\\n param.requires_grad = False\\n else:\\n for param in model.bert_encoder.model.bert.encoder.layer.parameters():\\n param.requires_grad = False\\n\\n # Construct the optimizer.\\n def optimizer_wrapper(Optim, **kwargs):\\n def init_func(model):\\n return Optim(model.parameters(), **kwargs)\\n return init_func\\n\\n optimizers = {\\n \\\"adamax\\\": (\\n optimizer_wrapper(optim.Adamax, lr=cfg.SOLVER.BASE_LR),\\n lambda optim: optim.param_groups[0][\\\"lr\\\"],\\n ),\\n \\\"adam\\\": (\\n optimizer_wrapper(optim.Adam, lr=cfg.SOLVER.BASE_LR),\\n lambda optim: optim.param_groups[0][\\\"lr\\\"],\\n ),\\n \\\"sgd\\\": (\\n optimizer_wrapper(optim.SGD, lr=cfg.SOLVER.BASE_LR, momentum=0.9),\\n lambda optim: optim.param_groups[0][\\\"lr\\\"],\\n ),\\n }\\n\\n if cfg.SOLVER.OPTIMIZING_METHOD not in optimizers:\\n cfg.SOLVER.OPTIMIZING_METHOD = 'adam'\\n if distributed.is_master_proc():\\n print(\\\"{0} not defined in available optimizer list, fallback to Adam\\\")\\n\\n optimizer, _ = optimizers[cfg.SOLVER.OPTIMIZING_METHOD]\\n optimizer = optimizer(model)\\n if distributed.is_master_proc():\\n print('optimizer: {}'.format(optimizer))\\n\\n # Load a checkpoint to resume training if applicable.\\n checkpoint_path = osp.join(cfg.OUTPUT_DIR, 'checkpoint.pth')\\n if osp.exists(checkpoint_path):\\n if distributed.is_master_proc():\\n print('Resuming training: loading model from: {0}'.format(checkpoint_path))\\n checkpoint = torch.load(checkpoint_path, map_location=\\\"cpu\\\")\\n if cfg.NUM_GPUS > 1:\\n model.module.load_state_dict(checkpoint['model_state'])\\n else:\\n model.load_state_dict(checkpoint['model_state'])\\n optimizer.load_state_dict(checkpoint['optimizer_state'])\\n start_epoch = checkpoint['epoch'] + 1\\n model_final_path = osp.join(cfg.OUTPUT_DIR, 'model_final.pth')\\n if osp.exists(model_final_path):\\n model_final = torch.load(model_final_path)\\n best_val_score = model_final['accuracy']\\n else:\\n best_val_score = None\\n elif osp.exists(cfg.TRAIN.CHECKPOINT_FILE_PATH):\\n if distributed.is_master_proc():\\n print('Loading model from: {0}'.format(cfg.TRAIN.CHECKPOINT_FILE_PATH))\\n checkpoint = torch.load(cfg.TRAIN.CHECKPOINT_FILE_PATH, map_location=\\\"cpu\\\")\\n if cfg.NUM_GPUS > 1:\\n model.module.load_state_dict(checkpoint['model_state'])\\n else:\\n model.load_state_dict(checkpoint['model_state'])\\n start_epoch, best_val_score = 0, None\\n else: \\n start_epoch, best_val_score = 0, None\\n\\n # Define loss function\\n loss_function = nn.BCEWithLogitsLoss()\\n\\n if distributed.is_master_proc():\\n print('Train begins...')\\n if cfg.TRAIN.EVAL_FIRST:\\n accuracy = evaluate(val_loader, model, -1, cfg)\\n if best_val_score is None or accuracy > best_val_score:\\n best_val_score = accuracy\\n try:\\n # Perform the training loop\\n for epoch in range(start_epoch, cfg.SOLVER.MAX_EPOCH):\\n epoch_start_time = time.time()\\n # Shuffle the dataset\\n if cfg.NUM_GPUS > 1:\\n train_loader.sampler.set_epoch(epoch)\\n # Train for one epoch\\n train_loss = train_epoch(train_loader, model, optimizer, loss_function, epoch, cfg)\\n accuracy = evaluate(val_loader, model, epoch, cfg) \\n\\n if distributed.is_master_proc():\\n # Save best model in the validation set\\n if best_val_score is None or accuracy > best_val_score:\\n best_val_score = accuracy\\n model_final_path = osp.join(cfg.OUTPUT_DIR, 'model_final.pth')\\n model_final = {\\n \\\"epoch\\\": epoch,\\n \\\"model_state\\\": model.state_dict(),\\n \\\"optimizer_state\\\": optimizer.state_dict(),\\n \\\"accuracy\\\": accuracy\\n }\\n torch.save(model_final, model_final_path)\\n print('-' * 89)\\n print('| end of epoch {:3d} | time: {:5.2f}s '\\n '| epoch loss {:.6f} |'.format(\\n epoch, time.time() - epoch_start_time, train_loss))\\n print('-' * 89)\\n except KeyboardInterrupt:\\n if distributed.is_master_proc():\\n print('-' * 89)\\n print('Exiting from training early')\",\n \"def init_data(dataset_config: dict):\\n # train and dev will be in random order, test may be ordered according to labels\\n if dataset_config[\\\"name\\\"] == \\\"CoLA\\\":\\n train, dev, test, num_classes = load_cola(dataset_config)\\n elif dataset_config[\\\"name\\\"] == \\\"AGNews\\\":\\n train, dev, test, num_classes = load_ag_news(dataset_config)\\n elif dataset_config[\\\"name\\\"] == \\\"DBPedia\\\":\\n train, dev, test, num_classes = load_dbpedia(dataset_config)\\n elif dataset_config[\\\"name\\\"] == \\\"YRF\\\":\\n train, dev, test, num_classes = load_yrf(dataset_config)\\n else:\\n raise NameError(f\\\"Dataset {dataset_config['name']} not implemented.\\\")\\n # etc.\\n\\n # shrink size if debugging\\n if dataset_config[\\\"debug\\\"]:\\n # choose a random subset using huggingface select function\\n train = train.select(random.sample(range(len(train)), k=200))\\n dev = dev.select(random.sample(range(len(dev)), k=40))\\n test = test.select(random.sample(range(len(test)), k=200))\\n\\n # create class imbalance\\n random.seed(dataset_config[\\\"seed\\\"])\\n if dataset_config[\\\"pool_balance\\\"] == \\\"balanced\\\":\\n pass\\n elif dataset_config[\\\"pool_balance\\\"] == \\\"imbalanced\\\":\\n train = train.filter(lambda example: create_imbalanced_dataset(example, dataset_config[\\\"imbalance_prop\\\"], dataset_config['imbalance_cls']))\\n else:\\n NameError(f\\\"pool_balance = {dataset_config['pool_balance']} not allowed\\\")\\n\\n if dataset_config[\\\"dev_balance\\\"] == \\\"balanced\\\":\\n pass\\n elif dataset_config[\\\"dev_balance\\\"] == \\\"imbalanced\\\":\\n dev = dev.filter(lambda example: create_imbalanced_dataset(example, dataset_config[\\\"imbalance_prop\\\"], dataset_config['imbalance_cls']))\\n else:\\n NameError(f\\\"dev_balance = {dataset_config['dev_balance']} not allowed\\\")\\n\\n # get seed labelled pool indices (using the same seed data every time)\\n random.seed(dataset_config[\\\"seed\\\"])\\n if dataset_config[\\\"seed_balance\\\"] == \\\"balanced\\\":\\n # this is random (will have some variance vs pool)\\n indices = list(range(len(train)))\\n unlabelled_pool_idx, labelled_pool_idx = split(\\n indices,\\n random_state=dataset_config[\\\"seed\\\"],\\n test_size=dataset_config[\\\"seed_size\\\"]\\n )\\n elif dataset_config[\\\"seed_balance\\\"] == \\\"stratified\\\":\\n # this is the same as the underlying train set (which may be unbalanced)\\n indices = list(range(len(train)))\\n unlabelled_pool_idx, labelled_pool_idx = split(\\n indices,\\n random_state=dataset_config[\\\"seed\\\"],\\n test_size=dataset_config[\\\"seed_size\\\"],\\n stratify=train['label']\\n )\\n elif dataset_config[\\\"seed_balance\\\"] == \\\"imbalanced\\\":\\n # artificially sample an imbalanced seed set from the pool\\n unlabelled_pool_idx, labelled_pool_idx = create_imbalanced_seed(\\n train,\\n num_classes,\\n dataset_config[\\\"seed_size\\\"],\\n dataset_config['imbalance_prop'],\\n dataset_config['imbalance_cls']\\n )\\n else:\\n raise NameError(f\\\"seed_balance = {dataset_config['seed_balance']} not allowed\\\")\\n\\n return train, dev, test, num_classes, labelled_pool_idx, unlabelled_pool_idx\",\n \"def preprocess(self,\\n balance=True,\\n partition=\\\"iid\\\",\\n unbalance_sgm=0,\\n num_shards=None,\\n dir_alpha=None,\\n verbose=True,\\n seed=None,\\n download=True):\\n self.download = download\\n\\n if os.path.exists(self.path) is not True:\\n os.mkdir(self.path)\\n os.mkdir(os.path.join(self.path, \\\"train\\\"))\\n os.mkdir(os.path.join(self.path, \\\"var\\\"))\\n os.mkdir(os.path.join(self.path, \\\"test\\\"))\\n # train dataset partitioning\\n if self.dataname == 'cifar10':\\n trainset = torchvision.datasets.CIFAR10(root=self.root,\\n train=True,\\n download=self.download)\\n partitioner = CIFAR10Partitioner(trainset.targets,\\n self.num_clients,\\n balance=balance,\\n partition=partition,\\n unbalance_sgm=unbalance_sgm,\\n num_shards=num_shards,\\n dir_alpha=dir_alpha,\\n verbose=verbose,\\n seed=seed)\\n elif self.dataname == 'cifar100':\\n trainset = torchvision.datasets.CIFAR100(root=self.root,\\n train=True,\\n download=self.download)\\n partitioner = CIFAR100Partitioner(trainset.targets,\\n self.num_clients,\\n balance=balance,\\n partition=partition,\\n unbalance_sgm=unbalance_sgm,\\n num_shards=num_shards,\\n dir_alpha=dir_alpha,\\n verbose=verbose,\\n seed=seed)\\n else:\\n raise ValueError(\\n f\\\"'dataname'={self.dataname} currently is not supported. Only 'cifar10', and 'cifar100' are supported.\\\"\\n )\\n\\n subsets = {\\n cid: CIFARSubset(trainset,\\n partitioner.client_dict[cid],\\n transform=self.transform,\\n target_transform=self.targt_transform)\\n for cid in range(self.num_clients)\\n }\\n for cid in subsets:\\n torch.save(\\n subsets[cid],\\n os.path.join(self.path, \\\"train\\\", \\\"data{}.pkl\\\".format(cid)))\",\n \"def _split_train_tst(self):\\n num_samples = self.Y.shape[0]\\n mapper_file = self.checkpointer.get_mapper_file_location()\\n if not self.checkpointer.is_mapper_checkpointed():\\n print 'No mapper checkpoint found. Fresh loading in progress ...'\\n # Now shuffle the data\\n sample_id = range(num_samples)\\n random.shuffle(sample_id)\\n print 'Dumping the mapper shuffle for reuse.'\\n Pickle.dump(sample_id, open(mapper_file, 'wb'))\\n print 'Dump complete. Moving Forward...'\\n else:\\n print 'Mapper Checkpoint found... Reading from mapper dump'\\n sample_id = Pickle.load(open(mapper_file, 'rb'))\\n print 'Mapping unpickling complete.. Moving forward...'\\n\\n self.X_fwd = self.X_fwd[sample_id]\\n self.X_bwd = self.X_bwd[sample_id]\\n self.Y = self.Y[sample_id]\\n # Now divide the data into test ans train set\\n test_fraction = 0.01\\n self.test_size = int(test_fraction * num_samples)\\n self.train_size = num_samples - self.test_size\\n # Forward review\\n self.X_trn_fwd = self.X_fwd[0:self.train_size]\\n self.X_tst_fwd = self.X_fwd[self.train_size:num_samples]\\n # Backward review\\n self.X_trn_bwd = self.X_bwd[0:self.train_size]\\n self.X_tst_bwd = self.X_bwd[self.train_size:num_samples]\\n # Summary\\n self.Y_trn = self.Y[0:self.train_size]\\n self.Y_tst = self.Y[self.train_size:num_samples]\",\n \"def splitting(X, y, TrainingShare=0.5, seed=0):\\n\\n\\t#target_name = 'default'\\n\\t#X = default.drop('default', axis=1)\\n\\t#robust_scaler = RobustScaler()\\n\\t#sc = StandardScaler()\\n\\t#X = robust_scaler.fit_transform(X)\\n\\t#y = default[target_name]\\n\\n\\t# Train-test split\\n\\tX_train, X_test, y_train, y_test=train_test_split(X, y, train_size=TrainingShare, test_size = 1-TrainingShare, random_state=seed)\\n\\treturn X_train, X_test, y_train, y_test\",\n \"def config1() :\\n data_name = \\\"titanic\\\" ### in data/input/\\n model_class = 'AutoML' ### ACTUAL Class name for model_sklearn.py\\n n_sample = 1000\\n\\n def post_process_fun(y): ### After prediction is done\\n return int(y)\\n\\n def pre_process_fun(y): ### Before the prediction is done\\n return int(y)\\n\\n\\n model_dict = {'model_pars': {\\n ### LightGBM API model #######################################\\n 'model_class': model_class\\n ,'model_pars' : {\\n 'total_time_limit' : 20,\\n 'algorithms' : 'auto',\\n 'results_path' : root_repo + f'/data/output/{data_name}/{os_get_function_name()}/automl_1',\\n 'eval_metric' : 'auto'\\n\\n # mode='Explain',\\n # ml_task='auto', model_time_limit=None, algorithms='auto', train_ensemble=True,\\n # stack_models='auto', eval_metric='auto', validation_strategy='auto', explain_level='auto',\\n # golden_features='auto', features_selection='auto', start_random_models='auto',\\n # hill_climbing_steps='auto', top_models_to_improve='auto', verbose=1, random_state=1234)\\n }\\n\\n , 'post_process_fun' : post_process_fun ### After prediction ##########################################\\n , 'pre_process_pars' : {'y_norm_fun' : pre_process_fun , ### Before training ##########################\\n\\n\\n ### Pipeline for data processing ##############################\\n 'pipe_list': [\\n #### coly target prorcessing\\n {'uri': 'source/prepro.py::pd_coly', 'pars': {}, 'cols_family': 'coly', 'cols_out': 'coly', 'type': 'coly' },\\n\\n\\n {'uri': 'source/prepro.py::pd_colnum_bin', 'pars': {}, 'cols_family': 'colnum', 'cols_out': 'colnum_bin', 'type': '' },\\n {'uri': 'source/prepro.py::pd_colnum_binto_onehot', 'pars': {}, 'cols_family': 'colnum_bin', 'cols_out': 'colnum_onehot', 'type': '' },\\n\\n #### catcol INTO integer, colcat into OneHot\\n {'uri': 'source/prepro.py::pd_colcat_bin', 'pars': {}, 'cols_family': 'colcat', 'cols_out': 'colcat_bin', 'type': '' },\\n # {'uri': 'source/prepro.py::pd_colcat_to_onehot', 'pars': {}, 'cols_family': 'colcat_bin', 'cols_out': 'colcat_onehot', 'type': '' },\\n\\n\\n ### Cross_feat = feat1 X feat2\\n # {'uri': 'source/prepro.py::pd_colcross', 'pars': {}, 'cols_family': 'colcross', 'cols_out': 'colcross_pair', 'type': 'cross'},\\n\\n\\n #### Example of Custom processor\\n #{'uri': THIS_FILEPATH + '::pd_col_myfun', 'pars': {}, 'cols_family': 'colnum', 'cols_out': 'col_myfun', 'type': '' }, \\n\\n\\n ],\\n }\\n },\\n\\n 'compute_pars': { 'metric_list': ['accuracy_score','average_precision_score']\\n\\n ,'mlflow_pars' : None # {} ### Not empty --> use mlflow\\n },\\n\\n 'data_pars': { 'n_sample' : n_sample,\\n\\n 'download_pars' : None,\\n\\n\\n 'cols_input_type' : cols_input_type_1,\\n ### family of columns for MODEL #########################################################\\n # \\\"colnum\\\", \\\"colnum_bin\\\", \\\"colnum_onehot\\\", \\\"colnum_binmap\\\", #### Colnum columns\\n # \\\"colcat\\\", \\\"colcat_bin\\\", \\\"colcat_onehot\\\", \\\"colcat_bin_map\\\", #### colcat columns\\n # 'colcross_single_onehot_select', \\\"colcross_pair_onehot\\\", 'colcross_pair', #### colcross columns 'coldate', 'coltext',\\n 'cols_model_group': [ 'colnum_bin',\\n 'colcat_bin',\\n # 'coltext',\\n # 'coldate',\\n #'colcross_pair',\\n \\n ### example of custom\\n # 'col_myfun'\\n ]\\n\\n ### Filter data rows ##################################################################\\n ,'filter_pars': { 'ymax' : 2 ,'ymin' : -1 }\\n\\n }\\n }\\n\\n ##### Filling Global parameters ############################################################\\n model_dict = global_pars_update(model_dict, data_name, config_name=os_get_function_name() )\\n return model_dict\",\n \"def make_testing_training(data, percent_training, random_split=False, seed=None):\\n ## Making testing and training sets\\n data['computed Case Date/Time Closed'] = pd.to_datetime(data['Case Date/Time Closed'])\\n ordered_data = data.sort(columns=['computed Case Date/Time Closed'])\\n np.random.seed(seed=seed) \\n nrows, ncols = ordered_data.shape\\n\\n if random_split:\\n training_indices = np.random.choice(ordered_data.index, size=int(nrows*percent_training), replace=False)\\n training = ordered_data.ix[training_indices]\\n testing = ordered_data[~data['case_id'].isin(training['case_id'])]\\n else: # split by date\\n training_stop_index = int(percent_training * nrows)\\n training = ordered_data[:training_stop_index]\\n testing = ordered_data[training_stop_index:]\\n\\n return training, testing\",\n \"def learn(self):\\n metrics_hist = dict()\\n max_runs = 3\\n for run in range(max_runs):\\n all_indices, initial_indices = self._init_al_dataset()\\n\\n metrics_hist[str(run)] = dict()\\n\\n current_indices = list(initial_indices)\\n \\n for split in self.data_splits_frac:\\n print(f'\\\\nRUN {run} - SPLIT - {split*100:0.0f}%')\\n\\n # Initialise models\\n self._init_models(mode='svaal')\\n\\n # Do some label stuff\\n unlabelled_indices = np.setdiff1d(list(all_indices), current_indices)\\n unlabelled_sampler = data.sampler.SubsetRandomSampler(unlabelled_indices)\\n unlabelled_dataloader = data.DataLoader(self.datasets['train'],\\n sampler=unlabelled_sampler,\\n batch_size=64,\\n drop_last=False)\\n\\n print(f'Labelled: {len(current_indices)} Unlabelled: {len(unlabelled_indices)} Total: {len(all_indices)}')\\n\\n # TODO: Make the SVAAL allow 100% labelled and 0% unlabelled to pass through it. Breaking out of loop for now when data hits 100% labelled.\\n if len(unlabelled_indices) == 0:\\n break\\n\\n metrics, svae, discriminator = self.train(dataloader_l=self.labelled_dataloader,\\n dataloader_u=unlabelled_dataloader,\\n dataloader_v=self.val_dataloader,\\n dataloader_t=self.test_dataloader,\\n mode='svaal') \\n print(f'Test Eval.: F1 Scores - Macro {metrics[0]*100:0.2f}% Micro {metrics[1]*100:0.2f}%') \\n \\n # Record performance at each split\\n metrics_hist[str(run)][str(split)] = metrics\\n\\n \\n sampled_indices = self.sample_adversarial(svae, discriminator, unlabelled_dataloader, indices=unlabelled_indices, cuda=True) # TODO: review usage of indices arg\\n current_indices = list(current_indices) + list(sampled_indices)\\n sampler = data.sampler.SubsetRandomSampler(current_indices)\\n self.labelled_dataloader = data.DataLoader(self.datasets['train'], sampler=sampler, batch_size=self.batch_size, drop_last=True)\\n \\n # write results to disk\\n with open('results.json', 'w') as fj:\\n json.dump(metrics_hist, fj, indent=4)\",\n \"def train_and_eval():\\n # train_file_name = 'adult.data'\\n # test_file_name = 'adult.test'\\n train_file_name = 'poker-hand-testing.data'\\n test_file_name = 'poker-hand-training-true.data'\\n #test_file_name = maybe_download()\\n df_train = pd.read_csv(\\n tf.gfile.Open(\\\"/opt/tensor/race_result_clean.csv\\\"),\\n names=COLUMNS,\\n skipinitialspace=True,\\n skiprows=1)\\n df_test = pd.read_csv(\\n tf.gfile.Open(\\\"/opt/tensor/race_result_clean.csv\\\"),\\n names=COLUMNS,\\n skipinitialspace=True,\\n skiprows=1)\\n\\n #df_train[LABEL_COLUMN] = (df_train[\\\"CLASS_Poker_Hand\\\"].apply(lambda x: x>5)).astype(int)\\n #df_test[LABEL_COLUMN] = (df_test[\\\"CLASS_Poker_Hand\\\"].apply(lambda x: x>5)).astype(int)\\n\\n model_dir = tempfile.mkdtemp() if not FLAGS.model_dir else FLAGS.model_dir\\n print(\\\"model directory = %s\\\" % model_dir)\\n m = build_estimator(model_dir)\\n print(m)\\n m.fit(input_fn=lambda: input_fn(df_train), steps=FLAGS.train_steps)\\n results = m.evaluate(input_fn=lambda: input_fn(df_test), steps=1)\\n for key in sorted(results):\\n print(\\\"%s: %s\\\" % (key, results[key]))\",\n \"def train(self):\\n for data_tier in self.data_tiers:\\n fd = open(self.data_path + '/training_data_' + data_tier + '.json', 'r')\\n self.preprocessed_data[data_tier] = json.load(fd)\\n fd.close()\\n tot = len(self.preprocessed_data[data_tier]['features'])\\n p = int(math.ceil(tot*0.8))\\n training_features = np.array(self.preprocessed_data[data_tier]['features'][:p])\\n trend_training_classifications = np.array(self.preprocessed_data[data_tier]['trend_classifications'][:p])\\n avg_training_classifications = np.array(self.preprocessed_data[data_tier]['avg_classifications'][:p])\\n t1 = datetime.datetime.utcnow()\\n self.clf_trend[data_tier].fit(training_features, trend_training_classifications)\\n self.clf_avg[data_tier].fit(training_features, avg_training_classifications)\\n t2 = datetime.datetime.utcnow()\\n td = t2 - t1\\n self.logger.info('Training %s for data tier %s took %s', self.name, data_tier, str(td))\\n joblib.dump(self.clf_trend[data_tier], self.data_path + '/' + self.name + '_trend_' + data_tier + '.pkl')\\n joblib.dump(self.clf_avg[data_tier], self.data_path + '/' + self.name + '_avg_' + data_tier + '.pkl')\",\n \"def train(self):\\n\\t\\traise NotImplementedError\",\n \"def train_test_split(\\n self,\\n default_train_prop: float,\\n *,\\n train_props: dict[str | int, dict[str | int, float]] | None = None,\\n seed: int | None = None,\\n ) -> NICOTrainTestSplit:\\n # Initialise the random-number generator\\n rng = np.random.default_rng(seed)\\n # List to store the indices of the samples apportioned to the train set\\n # - those for the test set will be computed by complement\\n train_inds: list[int] = []\\n # Track which indices have been sampled for either split\\n unvisited = np.ones(len(self), dtype=np.bool_)\\n\\n def _sample_train_inds(\\n _mask: np.ndarray,\\n *,\\n _context: str | int | None = None,\\n _concept: str | None = None,\\n _train_prop: float = default_train_prop,\\n ) -> list[int]:\\n if _context is not None and _concept is None:\\n raise ValueError(\\\"Concept must be specified if context is.\\\")\\n if _context is not None:\\n # Allow the context to be speicifed either by its name or its label-encoding\\n _context = (\\n self.context_label_decoder(_context) if isinstance(_context, int) else _context\\n )\\n if _context not in self.class_tree[_concept]:\\n raise ValueError(\\n f\\\"'{_context}' is not a valid context for concept '{_concept}'.\\\"\\n )\\n # Condition the mask on the context\\n _mask = _mask & (self.metadata[\\\"context\\\"] == _context).to_numpy()\\n # Compute the overall size of the concept/context subset\\n _subset_size = np.count_nonzero(_mask)\\n # Compute the size of the train split\\n _train_subset_size = round(_train_prop * _subset_size)\\n # Sample the train indices (without replacement)\\n _train_inds = rng.choice(\\n np.nonzero(_mask)[0], size=_train_subset_size, replace=False\\n ).tolist()\\n # Mark the sampled indices as 'visited'\\n unvisited[_mask] = False\\n\\n return _train_inds\\n\\n if train_props is not None:\\n for concept, value in train_props.items():\\n # Allow the concept to be speicifed either by its name or its label-encoding\\n concept = (\\n self.concept_label_decoder[concept] if isinstance(concept, int) else concept\\n )\\n if concept not in self.class_tree.keys():\\n raise ValueError(f\\\"'{concept}' is not a valid concept.\\\")\\n concept_mask = (self.metadata[\\\"concept\\\"] == concept).to_numpy()\\n # Specifying proportions at the context/concept level, rather than concept-wide\\n if isinstance(value, dict):\\n for context, train_prop in value.items():\\n train_inds.extend(\\n _sample_train_inds(\\n _mask=concept_mask,\\n _concept=concept,\\n _context=context,\\n _train_prop=train_prop,\\n )\\n )\\n # Split at the class level (without conditioning on contexts)\\n else:\\n train_inds.extend(\\n _sample_train_inds(_mask=concept_mask, _context=None, _train_prop=value)\\n )\\n # Apportion any remaining samples to the training set using default_train_prop\\n train_inds.extend(_sample_train_inds(_mask=unvisited, _train_prop=default_train_prop))\\n # Compute the test indices by complement of the train indices\\n train_data = self.make_subset(indices=train_inds)\\n test_inds = list(set(range(len(self))) - set(train_inds))\\n test_data = self.make_subset(indices=test_inds)\\n\\n return NICOTrainTestSplit(train=train_data, test=test_data)\",\n \"def train_val_test_split(data):\\n raise NotImplementedError\",\n \"def train_val_test_split(\\n reframed, n_hours, n_features, target_var=\\\"temp\\\", ascending_sampling=False\\n):\\n\\n n_train_hours = int(reframed.shape[0] * 0.6)\\n n_val_hours = int(reframed.shape[0] * 0.2)\\n\\n if ascending_sampling:\\n print(\\\"Sampleamos datasets de pasado a futuro\\\")\\n train = reframed.iloc[:n_train_hours, :]\\n validation = reframed.iloc[n_train_hours : n_train_hours + n_val_hours, :]\\n test = reframed.iloc[n_train_hours + n_val_hours :, :]\\n else:\\n print(\\\"Sampleamos datasets de futuro a pasado\\\")\\n train = reframed.iloc[-n_train_hours:, :]\\n validation = reframed.iloc[-(n_train_hours + n_val_hours) : -n_train_hours :, :]\\n test = reframed.iloc[: -(n_train_hours + n_val_hours), :]\\n\\n # split into input and outputs\\n n_obs = n_hours * n_features\\n\\n target_col = \\\"{}_t\\\".format(target_var)\\n out_model_name = \\\"{}.hdf5\\\".format(target_var)\\n # target_var = 'prcp(t)'\\n train_X, train_y = train.iloc[:, :n_obs].values, train[target_col].values\\n val_X, val_y = validation.iloc[:, :n_obs].values, validation[target_col].values\\n test_X, test_y = test.iloc[:, :n_obs].values, test[target_col].values\\n print(train_X.shape, len(train_X), train_y.shape)\\n\\n # reshape input to be 3D [samples, timesteps, features]\\n train_X = train_X.reshape((train_X.shape[0], n_hours, n_features))\\n val_X = val_X.reshape((val_X.shape[0], n_hours, n_features))\\n test_X = test_X.reshape((test_X.shape[0], n_hours, n_features))\\n print(\\n train_X.shape,\\n train_y.shape,\\n val_X.shape,\\n val_y.shape,\\n test_X.shape,\\n test_y.shape,\\n )\\n\\n return {\\n \\\"trainset\\\": {\\\"X\\\": train_X, \\\"y\\\": train_y},\\n \\\"valset\\\": {\\\"X\\\": val_X, \\\"y\\\": val_y},\\n \\\"testset\\\": {\\\"X\\\": test_X, \\\"y\\\": test_y},\\n }\",\n \"def load_data(self,split='train'):\\n raise ValueError('Please implement me!')\",\n \"def train_test_split(self):\\n random.seed(self.args.seed)\\n nodes = [node for node in range(self.ncount)]\\n random.shuffle(nodes)\\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.args.training_size+self.args.validation_size])\\n self.test_nodes = torch.LongTensor(nodes[self.args.training_size+self.args.validation_size:])\",\n \"def split_train_test_dev(self):\\n for dir_name in (self.config.train_dir, self.config.dev_dir,\\n self.config.test_dir):\\n create_dir(dir_name)\\n\\n self.split_helper(self.config.parsed_train_file_pos, 'pos')\\n self.split_helper(self.config.parsed_train_file_neg, 'neg')\",\n \"def finetuned():\\n launch_training_on_all_splits(experiment='full', splits=NAME_SPLIT, base_model='ft', dropout=0.7304, learning_rate=0.0000976)\",\n \"def _fit_split_(self, dataset, targets, val_set, val_targets, checkpoints):\\n dir = ''.join(random.choices(string.ascii_lowercase + string.digits, k=16))\\n dir = '.tmp' + dir + '/'\\n os.mkdir(dir)\\n grid = self.grid\\n if self.folds is not None or self.folds != 0:\\n if self.task == 'Classification':\\n if self.folds > 1:\\n sf = StratifiedKFold(n_splits=self.folds, shuffle=True, random_state=0)\\n elif 0 <= self.folds < 1:\\n sf = StratifiedShuffleSplit(n_splits=1, test_size=self.folds, random_state=0)\\n elif self.task == 'Regression':\\n folds, dataset, targets = self.split_regression(dataset, targets)\\n results = []\\n for params in grid:\\n try:\\n nn = NeuralNetwork()\\n for i in range(len(params['layers'])):\\n if i == 0:\\n nn.add_layer('dense', params['layers'][i], params['activation'], dataset.shape[1])\\n else:\\n if i == len(params['layers']) - 1 and self.task == 'Regression':\\n nn.add_layer('dense', params['layers'][i], 'linear')\\n else:\\n nn.add_layer('dense', params['layers'][i], params['activation'])\\n curr_res = {'params': params,\\n 'metric_stats': [],\\n 'test_stats': [],\\n 'vl_stats': [],\\n 'tr_stats': []}\\n\\n if self.task == 'Classification':\\n folds = sf.split(dataset, targets)\\n for train_index, test_index in folds:\\n X_train, X_test = dataset[train_index], dataset[test_index]\\n Y_train, Y_test = targets[train_index], targets[test_index]\\n nested_best = None\\n nested_best_metric = None\\n nested_tr_pred = None\\n nested_vl_pred = None\\n for i in range(self.restarts):\\n nn.compile(task=self.task,\\n loss=self.loss_name,\\n l2_lambda=params['l2_lambda'],\\n dropout=params['dropout'],\\n optimizer=SGD(lr_init=params['lr'],\\n momentum=params['momentum'],\\n nesterov=params['nesterov'],\\n lr_sched=StepDecayScheduler(drop=params['lr_sched'][0],\\n epochs_drop=params['lr_sched'][1])))\\n\\n curr_model, curr_metric, best_epoch = nn.fit(X_train, Y_train,\\n val_set=val_set, val_targets=val_targets,\\n batch_size=params['batch_size'],\\n test_size=params['test_size'],\\n epochs=params['epoch'],\\n patience=params['patience'],\\n save_pred=dir + 'tmp_gs',\\n save_model=None)\\n\\n nested_best_metric = metrics.metric_improve(self.metric, nested_best_metric, curr_metric)\\n if nested_best_metric[1]:\\n nested_tr_pred = np.load(dir + 'tmp_gs_tr_predictions.npy')[best_epoch]\\n nested_vl_pred = np.load(dir + 'tmp_gs_vl_predictions.npy')[best_epoch]\\n nested_best = copy.deepcopy(curr_model)\\n if nested_best_metric[2]:\\n break\\n\\n Y_pred = nested_best.predict(X_test)\\n if self.metric == 'loss':\\n curr_metric = np.sum(self.loss(Y_test, Y_pred), axis=0) / len(Y_test)\\n else:\\n curr_metric = metrics.metric_computation(self.metric, Y_test, Y_pred)\\n\\n curr_res['metric_stats'].append(curr_metric)\\n tr_stats = []\\n vl_stats = []\\n test_stats = []\\n for stat in self.statistics:\\n if stat == 'loss':\\n\\n tr_stats.append(np.mean(self.loss(nested_tr_pred[:, :targets.shape[1]],\\n nested_tr_pred[:, targets.shape[1]:])))\\n vl_stats.append(np.mean(self.loss(nested_vl_pred[:, :targets.shape[1]],\\n nested_vl_pred[:, targets.shape[1]:])))\\n test_stats.append(np.mean(self.loss(Y_test, Y_pred)))\\n else:\\n tr_stats.append(metrics.metric_computation(stat,\\n nested_tr_pred[:, :targets.shape[1]],\\n nested_tr_pred[:, targets.shape[1]:]))\\n vl_stats.append(metrics.metric_computation(stat,\\n nested_vl_pred[:, :targets.shape[1]],\\n nested_vl_pred[:, targets.shape[1]:]))\\n test_stats.append(metrics.metric_computation(stat, Y_test, Y_pred))\\n curr_res['tr_stats'].append(tr_stats)\\n curr_res['vl_stats'].append(vl_stats)\\n curr_res['test_stats'].append(test_stats)\\n\\n results.append(curr_res)\\n if checkpoints is not None:\\n with open(checkpoints + '.pkl', 'wb') as output:\\n pickle.dump(results, output, pickle.HIGHEST_PROTOCOL)\\n\\n except NesterovError:\\n continue\\n shutil.rmtree(dir)\\n return results\",\n \"def load_random_split(\\n self,\\n test_rate=0.1,\\n random=False,\\n n_negative=100,\\n by_user=False,\\n n_test=10,\\n download=False,\\n force_redo=False,\\n ):\\n processed_random_split_path = os.path.join(self.processed_path, \\\"random\\\")\\n if not os.path.exists(processed_random_split_path):\\n os.mkdir(processed_random_split_path)\\n\\n parameterized_path = generate_parameterized_path(\\n test_rate=test_rate, random=random, n_negative=n_negative, by_user=by_user\\n )\\n download_path = processed_random_split_path\\n processed_random_split_path = os.path.join(\\n processed_random_split_path, parameterized_path\\n )\\n if force_redo:\\n self.make_random_split(\\n test_rate=test_rate,\\n random=random,\\n n_negative=n_negative,\\n by_user=by_user,\\n n_test=n_test,\\n )\\n elif not os.path.exists(processed_random_split_path):\\n if (\\n download\\n and test_rate == 0.1\\n and random is False\\n and n_negative == 100\\n and by_user is False\\n ):\\n # default parameters, can be downloaded from Onedrive\\n folder = OneDrive(\\n url=self.processed_random_split_url, path=download_path\\n )\\n folder.download()\\n un_zip(processed_random_split_path + \\\".zip\\\", download_path)\\n else:\\n # make\\n self.make_random_split(\\n test_rate=test_rate,\\n random=random,\\n n_negative=n_negative,\\n by_user=by_user,\\n n_test=n_test,\\n )\\n\\n # load data from local storage\\n return load_split_data(processed_random_split_path, n_test=n_test)\",\n \"def calculate_data_split(self, n_train=2, n_vali=0, n_test=1, n_splits=1,\\n num_percentiles=4, random_state=87, verbosity=1,\\n manual_split=False,train_indices=None, test_indices=None,\\n train_redshift_indices=[0], test_redshift_indices=[0],\\n interpolate_over_redshift_only=False, **kwargs):\\n \\n n_extrema=kwargs.get('n_extrema', 2)\\n ind_extrema=kwargs.get('ind_extrema', [0,-1])\\n self.data_separation(n_extrema=n_extrema, ind_extrema=ind_extrema)\\n\\n too.condprint(\\\"number of wanted training vectors\\\", n_train, level=2, verbosity=verbosity)\\n too.condprint(\\\"number of wanted test vectors\\\", n_test, level=1, verbosity=verbosity)\\n if n_train+n_test > (self.size_fullspace):\\n print(\\\"Warning n_train is larger than total full sample space\\\")\\n\\n self.random_state = random_state\\n self.num_percentiles = num_percentiles\\n self.n_splits = n_splits\\n\\n stratif_labels = self.stratify_array(self.midspace, num_percentiles=self.num_percentiles)\\n self.test_splitdict = dict()\\n self.train_splitdict = dict()\\n self.vali_splitdict = dict()\\n\\n if manual_split == False:\\n n_vali = self.size_midspace-n_test-n_train\\n if n_vali !=0 and len(self.ind_midspace)> 1:\\n kf = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=n_test, random_state=self.random_state)\\n for ii, (trainvali, test) in enumerate(kf.split(self.midspace,stratif_labels)):\\n #test = test[np.in1d(test, extspace_ind, invert=True)]\\n\\n test = self.ind_midspace[test]\\n if n_train > 0:\\n train, valitest = train_test_split(trainvali, test_size=n_vali, shuffle=True, random_state=self.random_state)\\n train = self.ind_midspace[train]\\n train = np.unique(np.concatenate([train,self.ind_extremaspace]))\\n train = self.ind_fullspace[train]\\n else:\\n train = self.ind_extremaspace\\n train = self.ind_fullspace[train]\\n valitest=trainvali\\n\\n #valitest = valitest[np.in1d(valitest, extspace_ind, invert=True)]\\n valitest = self.ind_midspace[valitest]\\n #print(test, trr, \\\" s tr\\\", len(train)-2, \\\" tr: \\\", train, \\\" va: \\\", valitest)\\n self.test_splitdict[ii] = test\\n self.vali_splitdict[ii]= valitest\\n self.train_splitdict[ii] = train\\n elif len(self.ind_midspace)> 1 and n_vali == 0:\\n kf = StratifiedShuffleSplit(n_splits=self.n_splits, test_size=n_test, random_state=self.random_state)\\n for ii, (train, test) in enumerate(kf.split(self.midspace,stratif_labels)):\\n test = self.ind_midspace[test]\\n train = self.ind_midspace[train]\\n train = np.unique(np.concatenate([train,self.ind_extremaspace]))\\n train = self.ind_fullspace[train]\\n self.test_splitdict[ii] = test\\n self.train_splitdict[ii] = train\\n\\n else:\\n test = self.ind_midspace\\n train = self.ind_extremaspace\\n self.test_splitdict[0] = test\\n self.train_splitdict[0] = train\\n \\n ###/!\\\\ Warning /!\\\\ For now we always use manual split (which not really manual now...)\\n elif manual_split == True:\\n ### Determine the number of samples avaible with different values of parameters. e.g nb_param = 101 for MassiveNus\\n nb_param = int(len(self.fullspace)/len(self.z_requested)) \\n if len(self.z_requested)==1:\\n nb_param = int(len(self.fullspace))\\n \\n\\n for ii in range (n_splits):\\n ###Here the user has chosen to provide the test indices\\n if test_indices is not None:\\n test_indices = np.atleast_2d(test_indices)\\n test = test_indices[ii]\\n ###We make sure that the indice lies into a correct space. e.g if we have nb_param = 101, and a indices i = 103 it will become i =2\\n test_origin = [tt%nb_param for tt in test]\\n \\n ###Do we want to construct a interpolation only over the redshift ? /!\\\\ Warning /!\\\\ this is case is not really used....\\n if interpolate_over_redshift_only == False and train_indices is None:\\n train_origin = [ii for ii in range(1,nb_param-1) if ii not in test_origin ]\\n\\n elif interpolate_over_redshift_only == False and train_indices is not None:\\n train_origin = [tt%nb_param for tt in train ]\\n else :\\n train_origin = test_origin\\n ###Here the user has chosen not to provide the test indices\\n ## so we first randomly generate them\\n else:\\n if train_indices is None:\\n test_origin = [ii for ii in range(1,nb_param-1)]\\n test_origin = shuffle(test_origin)[:n_test]\\n if interpolate_over_redshift_only == False:\\n train_origin = [ii for ii in range(1,nb_param-1) if ii not in test_origin ]\\n else:\\n train_origin = test_origin\\n ###The user has specified train indices so must be sure that train and test do not overlap !\\n else:\\n train_indices = np.atleast_2d(train_indices)\\n train = train_indices[ii]\\n train_origin = [tt%nb_param for tt in train ]\\n test_origin = [ii for ii in range(1,nb_param-1) if ii not in train_origin ] ####!!!\\n \\n train_origin = shuffle(train_origin)\\n \\n train_origin = train_origin[:n_train]\\n test_origin = shuffle(test_origin)[:n_test]\\n if train_indices is None:\\n if [0] not in test_origin:\\n train_origin +=[0]\\n if [nb_param-1]not in test_origin:\\n \\n train_origin += [nb_param-1]\\n if [0] in test_origin or [nb_param-1] in test_origin :\\n print(\\\"Warning : trying to interpolate a extramal value\\\")\\n \\n\\n train_redshift = self.z_requested[train_redshift_indices]\\n test_redshift = self.z_requested[test_redshift_indices]\\n self.train_redshift = train_redshift \\n self.test_redshift = test_redshift\\n too.condprint(\\\"redshift used for training\\\", train_redshift,level=1,verbosity=verbosity)\\n too.condprint(\\\"redshfit used for testing\\\", test_redshift,level=1,verbosity=verbosity)\\n train = []\\n test = []\\n ### looping over the redshift \\n for zz in train_redshift_indices:\\n train+= [ii + zz*nb_param for ii in train_origin ]\\n\\n for zz in test_redshift_indices: \\n test += [ii + zz*nb_param for ii in test_origin ]\\n \\n\\n self.train_splitdict[ii] = train\\n self.test_splitdict[ii] = test\\n shuffled = shuffle(train)\\n self.train_splitdict[ii] = shuffled\\n self.vali_splitdict[ii] = shuffled\\n\\n return None\",\n \"def __train_test_splits(self):\\n # By default, our indices are just 0-n\\n split_indices = list(range(len(self.data)))\\n # If shuffling, use our shared Random instance to shuffle our indices before slicing\\n if self.shuffle:\\n np.random.shuffle(split_indices)\\n # Regardless of shuffle, take the first self.train_proportion for training, and the last\\n # 1 - self.train_proportion records as test\\n train_n = int(self.train_proportion * len(self.data))\\n training_indices = split_indices[:train_n]\\n test_indices = split_indices[train_n:]\\n return training_indices, test_indices\",\n \"def split_data(self, model_data, tuning=True):\\n pass\",\n \"def split_data(train_split, src_dir, train_dir, test_dir, classes):\\n for cls in classes:\\n # get all dat files of this class\\n data = get_instances_of_class(cls, src_dir)\\n \\n # how many of the data points are for training?\\n train_count = round(len(data) * train_split / 100)\\n \\n # randomly choose indexes\\n train_indexes = set()\\n while len(train_indexes) < train_count:\\n train_indexes.add(random.randrange(len(data)))\\n \\n # move all train_indexes to train_dir, others to test_dir\\n COPY = lambda src, dst, filename:\\\\\\n shutil.copy2(\\n \\\"{}/{}\\\".format(src, data[i]),\\n \\\"{}/{}\\\".format(dst, data[i])\\n )\\n \\n for i in range(len(data)):\\n if i in train_indexes:\\n COPY(src_dir, train_dir, data[i])\\n else:\\n COPY(src_dir, test_dir, data[i])\",\n \"def main(cfg):\\n # logging.info(f'Found base dir {cfg.BASE_DIR}')\\n\\n rng = cfg.experiment.random_seed\\n if rng == -1:\\n rng = np.random.randint(0, 1000)\\n\\n if rng is not False:\\n np.random.seed(rng)\\n torch.torch.manual_seed(rng)\\n\\n dcc = cfg.dataset.get('creation_args', dict())\\n if dcc.get('dim_normalise_mean', False):\\n dim = dcc.dim\\n dcc.f_mean = float(dcc.f_mean / np.sqrt(dim))\\n dcc.p_mean = float(dcc.p_mean / np.sqrt(dim))\\n logging.info(\\n f'Updating means in dataset cfg: {cfg.dataset.creation_args}')\\n\\n stats = dict(\\n dir=os.getcwd(),\\n host=socket.gethostname(),\\n job_id=os.getenv(\\\"SLURM_JOB_ID\\\", None),\\n random_state=rng)\\n STATS_STATUS = False\\n\\n logging.info(\\n f'Logging to {stats[\\\"dir\\\"]} on {stats[\\\"host\\\"]} '\\n f'for id={cfg.get(\\\"id\\\", -1)}')\\n\\n logging.info(f'Slurm job: {stats[\\\"job_id\\\"]}.')\\n logging.info(f'Setting random seed to {rng}.')\\n logging.info(f'Uniform clip val is {cfg.acquisition.uniform_clip}.')\\n\\n hoover = Hoover(cfg.hoover)\\n\\n model = None\\n\\n # Right now this averages over both train and testing!\\n for run in range(cfg.experiment.n_runs):\\n if run % cfg.experiment.log_every == 0 or cfg.experiment.debug:\\n logging.info(f'Run {run} in {os.getcwd()} ****NEW RUN****')\\n if cuda := torch.cuda.is_available():\\n logging.info(f'Still using cuda: {cuda}.')\\n else:\\n logging.info('No cuda found!')\\n os.system('touch cuda_failure.txt')\\n\\n dataset = maps.dataset[cfg.dataset.name](\\n cfg.dataset, model_cfg=cfg.model)\\n\\n # Train model on training data.\\n if (not cfg.model.get('keep_constant', False)) or (model is None):\\n # default case\\n model = maps.model[cfg.model.name](cfg.model)\\n\\n # test_data = model.make_loader(dataset.test_data, train=False)\\n # loss = model.evaluate(model.model, test_data)\\n # logging.info(f'Model test loss is {loss}.')\\n\\n # train_data = model.make_loader(dataset.train_data, train=False)\\n # loss = model.evaluate(model.model, train_data)\\n # logging.info(f'Model train loss is {loss}.')\\n\\n model.fit(*dataset.train_data)\\n\\n loss = model.performance(\\n *dataset.test_data, dataset.cfg['task_type'])\\n # logging.info(\\n # f'Weights vs 1 : {np.sqrt(np.sum((model.model.coef_ - 1)**2))}')\\n\\n if cfg.experiment.get('constant_val_set', False):\\n add_val_idxs_to_cfg(cfg, model.val_idxs)\\n\\n if not STATS_STATUS:\\n STATS_STATUS = True\\n stats['loss'] = loss\\n to_json(stats, 'stats.json')\\n # test_data = model.make_loader(dataset.test_data, train=False)\\n # loss = model.evaluate(model.model, test_data)\\n # logging.info(f'Model test loss is {loss}.')\\n\\n # Always predict on test data again\\n # TODO: need to fix this for efficient prediction\\n if cfg.model.get('efficient', False):\\n logging.debug('Eficient prediction on test set.')\\n model = make_efficient(model, dataset)\\n\\n # if cfg.experiment.debug:\\n # Report train error\\n # logging.info('Model train error:')\\n # model.performance(\\n # *dataset.train_data, dataset.cfg.task_type)\\n\\n # if not check_valid(model, dataset):\\n # continue\\n\\n if run < cfg.experiment.save_data_until:\\n hoover.add_data(run, dataset.export())\\n\\n for acq_dict in cfg.acquisition_functions:\\n # Slightly unclean, but could not figure out how to make\\n # this work with Hydra otherwise\\n acquisition = list(acq_dict.keys())[0]\\n acq_cfg_name = list(acq_dict.values())[0]\\n\\n if cfg.experiment.debug:\\n logging.info(f'\\\\t Acquisition: {acquisition}')\\n\\n # Reset selected test_indices.\\n dataset.restart(acquisition)\\n\\n if (n := acq_cfg_name) is not None:\\n acq_config = cfg['acquisition_configs'][n]\\n else:\\n acq_config = None\\n\\n experiment = Experiment(\\n run, cfg, dataset, model, acquisition, acq_config)\\n\\n i = 0\\n while not experiment.finished:\\n i += 1\\n # print('debug', i)\\n if cfg.experiment.debug:\\n logging.info(\\n f'\\\\t Acquisition: {acquisition} – \\\\t Step {i}.')\\n\\n experiment.step(i)\\n\\n # Add config to name for logging.\\n if (n := acq_cfg_name) is not None:\\n acquisition = f'{acquisition}_{n}'\\n\\n # Extract results from acquisition experiment\\n hoover.add_results(run, acquisition, experiment.export_data())\\n\\n if run % cfg.experiment.get('save_every', 1e19) == 0:\\n logging.info('Intermediate save.')\\n hoover.save()\\n\\n logging.info('Completed all runs.')\\n hoover.save()\",\n \"def runner(self):\\n\\n print('[ INFO ]: Initializing the abalone program runner...')\\n\\n df, features, predictor, classes = self.preprocess()\\n\\n df = alg.random_feature_sample(self, df, 0.10)\\n\\n # Set up the training, testing and validation sets\\n split = round(len(df) * 0.10)\\n v_set = df[df.index < split]\\n t_set = df[df.index >= split]\\n\\n tree = alg()\\n folds_dict = tree.cross_validation(t_set, predictor, type='classification', folds=5)\\n\\n # Initialize comparion values\\n best_fold_tree = None\\n best_fold_score = 0\\n best_fold_pred_labels = None\\n best_fold_df = None\\n\\n # Loop through each fold in the folds dictionary\\n for fold in folds_dict:\\n\\n test_set = folds_dict[fold]\\n train_set = pd.DataFrame()\\n for inner_fold in folds_dict:\\n if inner_fold != fold:\\n train_set = train_set.append(folds_dict[inner_fold], ignore_index=True)\\n\\n # Build an ID3 tree\\n root = tree.build_tree(train_set, features, predictor)\\n df, labels, pred_labels, score = tree.test(test_set, features, predictor, root)\\n\\n # Determine which tree is the best\\n if score > best_fold_score:\\n best_fold_tree = root\\n best_fold_score = score\\n best_fold_pred_labels = pred_labels\\n best_fold_df = df\\n\\n # Validate results and prune the ID3 tree\\n v_tree = alg()\\n df, labels, pred_labels, score = v_tree.test(v_set, features, predictor, best_fold_tree)\\n prune_root = v_tree.prune(df, predictor, best_fold_tree)\\n prune_df, prune_labels, prune_pred_labels, prune_score = v_tree.test(v_set, features, predictor, prune_root)\\n\\n return best_fold_tree, score, labels, pred_labels, prune_root, prune_score, prune_labels, prune_pred_labels\",\n \"def get_split(split_name, dataset_dir, seed, batch_size, file_pattern=None, reader=None):\\n\\n train_questions = pd.read_json(os.path.join(dataset_dir, '../raw-data/VQA_Dataset/train_questions_annotations.json'))\\n #os.path.join(dataset_dir, '../raw-data/VQA_Dataset/')\\n\\n #Questions\\n questions = list(train_questions.iloc[0])\\n #Answers\\n answers = list(train_questions.iloc[2])\\n #Images\\n images = np.array(train_questions.iloc[1])\\n\\n #transform answers into values of dictionary\\n for i in range(len(answers)):\\n answers[i] = labels_dict[answers[i]]\\n \\n\\n \\n dataset = CustomDataset(os.path.join(dataset_dir, '../raw-data/VQA_Dataset'), 'training', train_questions=train_questions) #preprocessing_function=preprocess_input\\n dataset_valid = CustomDataset(os.path.join(dataset_dir, '../raw-data/VQA_Dataset'), 'validation', train_questions=train_questions) #preprocessing_function=preprocess_input\\n\\n \\n\\n train_dataset = tf.data.Dataset.from_generator(lambda: dataset,\\n output_types=((tf.int32, tf.float32), tf.int32),\\n output_shapes=(([max_questions_length], [int(img_h/2), int(img_w/2), 3]), [num_classes]))\\n\\n\\n\\n validation_dataset = tf.data.Dataset.from_generator(lambda: dataset_valid,\\n output_types=(( tf.int32, tf.float32), tf.int32),\\n output_shapes=(([max_questions_length], [int(img_h/2), int(img_w/2), 3]), [num_classes]))\\n\\n #train_dataset = train_dataset.shuffle(2048, seed = seed)\\n\\n train_dataset = train_dataset.prefetch(buffer_size = tf.data.experimental.AUTOTUNE)\\n\\n #validation_dataset = validation_dataset.shuffle(2048, seed = seed)\\n\\n validation_dataset = validation_dataset.prefetch(buffer_size = tf.data.experimental.AUTOTUNE)\\n\\n train_dataset = train_dataset.batch(batch_size) \\n\\n train_dataset = train_dataset.repeat() \\n \\n validation_dataset = validation_dataset.batch(batch_size)\\n \\n validation_dataset = validation_dataset.repeat()\\n\\n\\n return _NUM_CLASSES, SPLITS_TO_SIZES['train'] ,SPLITS_TO_SIZES['validation'], train_dataset, validation_dataset\",\n \"def train(self):\\n raise NotImplementedError\",\n \"def load_split(self, config):\\n data_split_str = config[\\\"data_split\\\"]\\n split_paras = {}\\n split_paras[\\\"test_rate\\\"] = config[\\\"test_rate\\\"] if \\\"test_rate\\\" in config else 0.1\\n split_paras[\\\"random\\\"] = config[\\\"random\\\"] if \\\"random\\\" in config else False\\n split_paras[\\\"download\\\"] = config[\\\"download\\\"] if \\\"download\\\" in config else False\\n split_paras[\\\"n_negative\\\"] = (\\n config[\\\"n_negative\\\"] if \\\"n_negative\\\" in config else 100\\n )\\n split_paras[\\\"by_user\\\"] = config[\\\"by_user\\\"] if \\\"by_user\\\" in config else False\\n split_paras[\\\"n_test\\\"] = config[\\\"n_test\\\"] if \\\"n_test\\\" in config else 10\\n\\n if split_paras[\\\"n_negative\\\"] < 0 and split_paras[\\\"n_test\\\"] > 1:\\n # n_negative < 0, validate and testing sets of splits will contain all the negative items.\\n # There will be only one validata and one testing sets.\\n split_paras[\\\"n_test\\\"] = 1\\n\\n data_split_mapping = {\\n \\\"leave_one_out\\\": self.load_leave_one_out,\\n \\\"leave_one_basket\\\": self.load_leave_one_basket,\\n \\\"random_split\\\": self.load_random_split,\\n \\\"random_basket_split\\\": self.load_random_basket_split,\\n \\\"temporal\\\": self.load_temporal_split,\\n \\\"temporal_basket\\\": self.load_temporal_basket_split,\\n }\\n\\n split_para_mapping = {\\n \\\"leave_one_out\\\": [\\\"random\\\", \\\"download\\\", \\\"n_negative\\\", \\\"n_test\\\"],\\n \\\"leave_one_basket\\\": [\\\"random\\\", \\\"download\\\", \\\"n_negative\\\", \\\"n_test\\\"],\\n \\\"random_split\\\": [\\n \\\"test_rate\\\",\\n \\\"download\\\",\\n \\\"by_user\\\",\\n \\\"n_negative\\\",\\n \\\"n_test\\\",\\n ],\\n \\\"random_basket_split\\\": [\\n \\\"test_rate\\\",\\n \\\"download\\\",\\n \\\"by_user\\\",\\n \\\"n_negative\\\",\\n \\\"n_test\\\",\\n ],\\n \\\"temporal\\\": [\\\"test_rate\\\", \\\"by_user\\\", \\\"download\\\", \\\"n_negative\\\", \\\"n_test\\\"],\\n \\\"temporal_basket\\\": [\\n \\\"test_rate\\\",\\n \\\"download\\\",\\n \\\"by_user\\\",\\n \\\"n_negative\\\",\\n \\\"n_test\\\",\\n ],\\n }\\n para_dic = {\\n split_para_key: split_paras[split_para_key]\\n if split_para_key in split_paras\\n else None\\n for split_para_key in split_para_mapping[data_split_str]\\n }\\n train_data, valid_data, test_data = data_split_mapping[data_split_str](\\n **para_dic\\n )\\n return train_data, valid_data, test_data\",\n \"def _train_and_evaluate(estimator, output_dir):\\n \\n \\\"\\\"\\\"X_train, y_train =utils._feature_label_split(df_train,\\\"is_churn\\\",\\\"msno\\\")\\n df_val = utils.read_from_bigquery(\\\"amiable-octane-267022.kkbox.output_val_1\\\",\\\"amiable-octane-267022\\\")\\n X_val, y_val =utils._feature_label_split(df_val,\\\"is_churn\\\",\\\"msno\\\")\\\"\\\"\\\"\\n \\n df_train=utils.over_sample(\\\"amiable-octane-267022.kkbox.output_train_1\\\",\\\"amiable-octane-267022\\\")\\n X_train, y_train =utils._feature_label_split(df_train,\\\"is_churn\\\",\\\"msno\\\")\\n df_val=utils.over_sample(\\\"amiable-octane-267022.kkbox.output_val_1\\\",\\\"amiable-octane-267022\\\")\\n X_val, y_val =utils._feature_label_split(df_val,\\\"is_churn\\\",\\\"msno\\\")\\n\\n estimator.fit(X_train, y_train)\\n f1_scorer = make_scorer(f1_score)\\n accuracy_scorer =make_scorer(accuracy_score)\\n\\n if metadata.HYPERPARAMTER_TUNING:\\n scores=model_selection.cross_val_score(estimator, X_val, y_val, cv=3,scoring=f1_scorer)\\n #,scoring=f1_scorer\\n\\n logging.info('Score: %s', scores)\\n\\n #tune hyper\\n hpt = hypertune.HyperTune()\\n hpt.report_hyperparameter_tuning_metric(\\n hyperparameter_metric_tag='F1_SCORE',\\n metric_value=np.mean(scores),\\n global_step=10000)\\n \\n#joblib.dump(estimator, 'model.joblib')\\n\\n # Write model and eval metrics to `output_dir`\\n model_output_path = os.path.join(output_dir, 'model',metadata.MODEL_FILE_NAME)\\n \\n utils.dump_object(estimator, model_output_path)\",\n \"def pre_process(self, dataset):\\n\\n # np.empty creates an empty array only. You have to replace this with your code.\\n X = np.empty((0,0))\\n y = np.empty((0))\\n\\n if dataset == 0:\\n # Implement for the abalone dataset\\n df = pd.DataFrame(columns=['sex', 'length', 'diameter', 'height', 'whole_weight', 'shucked_weight', 'viscera_weight', 'shell_weight', 'rings'])\\n count = 0\\n\\n with open('Dataset.data') as file: # reading data from file\\n data = file.read()\\n\\n data = data.split('\\\\n') # split data into different rows\\n data = data[:-1] # last one is empty\\n for row in data:\\n row = row.split()\\n df.loc[count] = row # add in dataframe\\n count += 1\\n\\n df['M'] = np.where(df.sex=='M', 1,0) # genders are turned to a one hot encoding\\n df['F'] = np.where(df.sex=='F', 1,0)\\n df['I'] = np.where(df.sex=='I', 1,0)\\n df = df.drop(['sex'], axis=1)\\n df = df.dropna()\\n\\n df = df.sample(frac=1).reset_index(drop=True) # shuffle dataframe\\n\\n X = df.drop(['rings'], axis=1)\\n X = X.values\\n X = X.astype(float)\\n y = df['rings'].values\\n y = y.astype(float)\\n\\n elif dataset == 1:\\n # Implement for the video game dataset\\n df = pd.read_csv('VideoGameDataset - Video_Games_Sales_as_at_22_Dec_2016.csv') # read csv directly into a dataframe\\n df1 = df[['Critic_Score', 'User_Score', 'Global_Sales']]\\n df1 = df1.dropna()\\n df1 = df1[df1.User_Score != 'tbd']\\n\\n df1 = df1.sample(frac=1).reset_index(drop=True) # shuffle rows\\n\\n X = df1.drop(['Global_Sales'], axis=1)\\n X = X.values\\n X = X.astype(float)\\n y = df1['Global_Sales'].values\\n y = y.astype(float)\\n\\n elif dataset == 2:\\n # Implement for the banknote authentication dataset\\n df = pd.DataFrame(columns=['variance', 'skewness', 'curtosis', 'entropy', 'class'])\\n count = 0\\n\\n with open('data_banknote_authentication.txt') as file: # reading file \\n data = file.read()\\n data = data.split('\\\\n')\\n data = data[:-1]\\n for row in data:\\n row = row.split(',')\\n df.loc[count] = [float(elt) for elt in row[:-1]] + [int(row[-1])] # last column has class so it is int rest are float\\n count += 1\\n\\n df = df.sample(frac=1).reset_index(drop=True) # shuffle dataset\\n\\n X = df.drop(['class'], axis=1)\\n X = X.values\\n y = df['class'].values\\n y = y.astype(int)\\n\\n return X, y\",\n \"def __init__(self, data_split_filename, num_rounds, early_stopping_round, xgboost_params, verbose_eval=False):\\n super().__init__(num_rounds, early_stopping_round, xgboost_params, verbose_eval)\\n self.data_split_filename = data_split_filename\\n self.train_data = None\\n self.test_data = None\",\n \"def split_train_test_application_data(self, test_size, test_split_proportion, view=0):\\n X_train, X_test, y_train, y_test = train_test_split(self.data[view], self.class_data, test_size=test_size)\\n X_test, X_application, y_test, y_application = train_test_split(X_test, y_test, test_size=test_split_proportion)\\n return X_train, X_test, X_application, y_train, y_test, y_application\",\n \"def run_train_test(training_file, testing_file):\\n\\n training = parse_file(training_file)\\n training = np.array(training)\\n\\n X_train = training[:,:4]\\n Y_train = training[:,4]\\n\\n testing = parse_file(testing_file)\\n testing = np.array(testing)\\n\\n X_test = testing[:,:4]\\n Y_test = testing[:,4]\\n\\n gini_clf = DecisionTreeClassifier(random_state=0)\\n gini_clf.fit(X_train, Y_train)\\n gini_Y_hat = gini_clf.predict(X_test)\\n gini_tp, gini_tn, gini_fp, gini_fn, gini_err = eval_results(Y_test, gini_Y_hat)\\n\\n entropy_clf = DecisionTreeClassifier(criterion=\\\"entropy\\\", random_state=0)\\n entropy_clf.fit(X_train, Y_train)\\n entropy_Y_hat = entropy_clf.predict(X_test)\\n entropy_tp, entropy_tn, entropy_fp, entropy_fn, entropy_err = eval_results(Y_test, entropy_Y_hat)\\n\\n return {\\n \\\"gini\\\":{\\n 'True positives': gini_tp,\\n 'True negatives': gini_tn,\\n 'False positives': gini_fp,\\n 'False negatives': gini_fn,\\n 'Error rate': gini_err\\n },\\n \\\"entropy\\\":{\\n 'True positives': entropy_tp,\\n 'True negatives': entropy_tn,\\n 'False positives': entropy_fp,\\n 'False negatives': entropy_fn,\\n 'Error rate': entropy_err\\n }\\n }\",\n \"def main():\\n \\n # The following 5 command lines can be outcommented if the features are already created.\\n # There is no need to process the data every single time.\\n # Fine tuning the learning algorythm is much faster without that extra step.\\n \\n # by reading the train dataset the feature index is created.\\n # First calling of the processdata function\\n # Data limited to 300000\\n featureIndexes = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000)\\n print \\\"featureIndex generated!\\\"\\n print len(featureIndexes)\\n\\n # Trainfeature is created using the indexfeatures...\\n # Second calling of the processdata function\\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000) # Original itemsLimit=300000\\n\\n # Building the test dataset... just like the training...\\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\\\"avito_test.tsv\\\"), featureIndexes)\\n\\n # Dumping data into file...\\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\\\"SeparatedByCategory.pkl\\\"))\\n\\n\\n # loading data pack...\\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n\\n #logging.info(\\\"Feature preparation done, fitting model...\\\")\\n\\n # Stochastic gradient model\",\n \"def create_models(self):\\r\\n self.all_ratings = AllRatingsWithCommon(\\r\\n experts=self.users,\\r\\n objects=self.videos,\\r\\n output_features=self.features,\\r\\n name=\\\"prod\\\",\\r\\n )\\r\\n\\r\\n print_memory(stage=\\\"DPLF:ratings_nodata_created\\\")\\r\\n\\r\\n # creating models\\r\\n self.user_to_model = {\\r\\n user: FeaturelessPreferenceLearningModel(\\r\\n expert=user, all_ratings=self.all_ratings\\r\\n )\\r\\n for user in self.users\\r\\n }\\r\\n\\r\\n print_memory(stage=\\\"DPLF:models_created\\\")\\r\\n\\r\\n # before creating the aggregator, filling models with data\\r\\n self.user_to_size = {\\r\\n user: self.fill_model_data(self.user_to_model[user], user)\\r\\n for user in tqdmem(self.users, desc=\\\"fill_data\\\")\\r\\n }\\r\\n\\r\\n # virtual 'common' data\\r\\n fplm_common = FeaturelessPreferenceLearningModel(\\r\\n expert=AllRatingsWithCommon.COMMON_EXPERT, all_ratings=self.all_ratings\\r\\n )\\r\\n fplm_common.on_dataset_end()\\r\\n\\r\\n print_memory(stage=\\\"DPLF:data_filled\\\")\\r\\n\\r\\n # resetting the model given the data\\r\\n self.all_ratings.reset_model()\\r\\n\\r\\n print_memory(stage=\\\"DPLF:model_reset_ok\\\")\\r\\n\\r\\n # aggregating models\\r\\n self.aggregator = FeaturelessMedianPreferenceAverageRegularizationAggregator(\\r\\n models=[self.user_to_model[u] for u in self.users]\\r\\n )\\r\\n self.aggregator.certification_status = self.user_certified\\r\\n\\r\\n print_memory(stage=\\\"DPLF:aggregator_created\\\")\",\n \"def main():\\n # Read in trainingSet and testSet as a DataFrame\\n trainingOriginal = pd.read_csv(\\n filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.train.5fold.csv\\\")\\n testOriginal = pd.read_csv(filepath_or_buffer=\\\"~/Desktop/KNN Implementation/adult.test.csv\\\")\\n\\n # Select only the numeric data\\n training = pd.DataFrame(trainingOriginal.select_dtypes(['number']))\\n training = pd.concat([training.reset_index(drop=True),\\n trainingOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Select only the numeric data\\n test = pd.DataFrame(testOriginal.select_dtypes(['number']))\\n test = pd.concat([test.reset_index(drop=True),\\n testOriginal['earns'].reset_index(drop=True)], axis=1)\\n\\n # Normalize the columns for training and test\\n # print training['age'].min()\\n # print training['age'].max()\\n # print training.head()\\n\\n # Run max-min normalization on numerical columns for testing and training data\\n for i in range(6):\\n training.iloc[:, i] = (training.iloc[:, i]- training.iloc[:, i].min())/(training.iloc[:, i].max() - training.iloc[:, i].min())\\n test.iloc[:, i] = (test.iloc[:, i]- test.iloc[:, i].min())/(test.iloc[:, i].max() - test.iloc[:, i].min())\\n\\n # Convert the 'earns' column to boolean as follows\\n training['earns'] = training['earns'] == '>50K'\\n test['earns'] = test['earns'] == ' >50K'\\n\\n # Group the training set by the fold attribute as given by the dataset\\n trainingForFinal = training\\n training = training.groupby('fold')\\n\\n # Since we want to consider odd k-values from 1 to 39, construct a list with these values\\n kList = []\\n for i in range(40):\\n if i % 2 == 1:\\n kList.append(i)\\n\\n # Empty dictionary to hold performance of each k-values and its accuracy\\n performance = {}\\n\\n # Compute the performance for each k-value\\n for k in kList:\\n performance = crossValidation(training, k, performance)\\n\\n # Sort the performance dictionary by its accuracy (value)\\n performance = sorted(performance.items(), key=operator.itemgetter(1), reverse=True)\\n\\n # Open file to write results\\n file = open('grid.results.txt', 'w')\\n # Write the results to file\\n file.write(\\\"K | Accuracy\\\\n\\\")\\n for item in performance:\\n if item[0] < 10:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n else:\\n file.write(str(item[0]) + ' | ' + str(item[1]) + '\\\\n')\\n # Close file\\n file.close()\\n\\n # The best K is the one at the top of the list after the sorting\\n bestK = performance[0][0]\\n\\n print 'Running Test Set with K = ' + str(bestK)\\n\\n applyModel(test,trainingForFinal,bestK)\",\n \"def auto_ml():\\r\\n # Reading from file\\r\\n my_data = my_reader(config.filename, separ=config.file_separ)\\r\\n\\r\\n # Binary and Unary columns search\\r\\n is_binary_list = is_binary(my_data)\\r\\n is_unary_list = is_unary(my_data)\\r\\n\\r\\n # Time columns search\\r\\n is_time_list = is_time(my_data)\\r\\n\\r\\n # To dummy\\r\\n my_data = to_dummies(my_data)\\r\\n\\r\\n # Train-test split\\r\\n train_df, test_df = \\\\\\r\\n my_train_test_split(my_data, act_test_size=config.test_size)\\r\\n\\r\\n # Pure numbers will be the input variables\\r\\n input_vars = to_pure_numbers(my_data)\\r\\n\\r\\n # Choosing if it is a regression or classification\\r\\n global regression, classification\\r\\n regression, classification = guess_goal(my_data, config.target)\\r\\n\\r\\n # Modelling and building the pipeline\\r\\n n_neighbors = 15\\r\\n x_df = train_df[input_vars]\\r\\n if regression:\\r\\n pipe_1 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', LinearRegression(fit_intercept=True))])\\r\\n pipe_2 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model',\\r\\n neighbors.KNeighborsRegressor(n_neighbors,\\r\\n weights='distance'))])\\r\\n pipe_3 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', linear_model.BayesianRidge())])\\r\\n pipe_4 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', linear_model.SGDRegressor())])\\r\\n pipe_5 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', linear_model.ElasticNet())])\\r\\n pipe_6 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', linear_model.Ridge())])\\r\\n pipe_7 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', linear_model.Lasso())])\\r\\n pipe_8 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', RandomForestRegressor(max_depth=2,\\r\\n random_state=0,\\r\\n n_estimators=100))])\\r\\n pipe_dict = {0: 'LinearRegression',\\r\\n 1: 'KNeighborsRegressor',\\r\\n 2: 'BayesianRidge',\\r\\n 3: 'SGDRegressor',\\r\\n 4: 'ElasticNet',\\r\\n 5: 'Ridge',\\r\\n 6: 'Lasso',\\r\\n 7: 'RandomForestRegressor'}\\r\\n\\r\\n if classification:\\r\\n pipe_1 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', LogisticRegression(random_state=42))])\\r\\n pipe_2 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model',\\r\\n neighbors.KNeighborsClassifier(n_neighbors))])\\r\\n pipe_3 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', RandomForestClassifier(n_estimators=100,\\r\\n max_depth=2,\\r\\n random_state=0))])\\r\\n pipe_4 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', linear_model.SGDClassifier())])\\r\\n pipe_5 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', MLPClassifier())])\\r\\n pipe_6 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', GradientBoostingClassifier())])\\r\\n pipe_7 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', GaussianNB())])\\r\\n pipe_8 = Pipeline([('missing', MissingValueHandle()),\\r\\n ('duplicated', DuplicatedRowHandle()),\\r\\n ('discretize', Digitize()),\\r\\n ('standardize', Standardize()),\\r\\n ('minmaxscaler', MyMinMaxScaler()),\\r\\n ('model', SVC(gamma='auto'))])\\r\\n pipe_dict = {0: 'LogisticRegression',\\r\\n 1: 'KNeighborsClassifier',\\r\\n 2: 'RandomForestClassifier',\\r\\n 3: 'SGDClassifier',\\r\\n 4: 'MLPClassifier',\\r\\n 5: 'GradientBoostingClassifier',\\r\\n 6: 'GaussianNB',\\r\\n 7: 'SVC'}\\r\\n\\r\\n # List of pipelines\\r\\n pipelines = [pipe_1, pipe_2, pipe_3, pipe_4, pipe_5, pipe_6, pipe_7, pipe_8]\\r\\n\\r\\n # Fit the pipelines\\r\\n for pipe in pipelines:\\r\\n pipe.fit(x_df, train_df[config.target])\\r\\n\\r\\n # Is there outlier\\r\\n outlier_bool = is_outlier(x_df)\\r\\n\\r\\n corr_df = x_df.corr()\\r\\n\\r\\n # Open new file\\r\\n result_path = './test_eval/Result_params_' +\\\\\\r\\n str(config.filename.split(\\\"/\\\")[-1].split(\\\".\\\")[0]) + '.txt'\\r\\n result_file = open(result_path, 'w')\\r\\n result_file.write(\\\"Filename: \\\" + str(config.filename) + '\\\\n')\\r\\n result_file.write(\\\"Target: \\\" + str(config.target) + '\\\\n')\\r\\n if regression:\\r\\n result_file.write(\\\"Prediction type: Regression\\\" + '\\\\n')\\r\\n else:\\r\\n result_file.write(\\\"Prediction type: Classification\\\" + '\\\\n')\\r\\n result_file.write(\\\"Test size: \\\" + str(config.test_size*100) + \\\"%\\\" + '\\\\n')\\r\\n result_file.write(\\\"Model input columns: \\\" + str(input_vars) + '\\\\n')\\r\\n result_file.write(\\\"Used preparations: \\\" + '\\\\n')\\r\\n if config.missing_bool:\\r\\n result_file.write(\\\"Missing value handle (\\\" +\\r\\n str(config. missing_value_handle) +\\r\\n \\\"), \\\")\\r\\n if config.min_scaler_bool:\\r\\n result_file.write(\\\"Min scaling, \\\")\\r\\n if config.standardize_bool:\\r\\n result_file.write(\\\"Standardize, \\\")\\r\\n if config.to_dummies:\\r\\n result_file.write(\\\"To dummies\\\")\\r\\n result_file.write('\\\\n' + \\\"Discretize columns: \\\" +\\r\\n str(config.discretize) + '\\\\n')\\r\\n result_file.write(\\\"Binary columns: \\\" + str(is_binary_list) + '\\\\n')\\r\\n result_file.write(\\\"Unary columns: \\\" + str(is_unary_list) + '\\\\n')\\r\\n result_file.write(\\\"Time columns: \\\" + str(is_time_list) + '\\\\n')\\r\\n if outlier_bool:\\r\\n result_file.write(\\\"There is outlier in the data.\\\" + '\\\\n')\\r\\n\\r\\n # Evaluation\\r\\n result_df = pd.DataFrame()\\r\\n result_cols = []\\r\\n for idx, val in enumerate(pipelines):\\r\\n result_df = pd.concat([result_df,\\r\\n my_evaluation(val.predict(test_df[input_vars]),\\r\\n test_df[config.target])])\\r\\n result_cols.append(pipe_dict[idx])\\r\\n\\r\\n result_df.index = result_cols\\r\\n result_file.close()\\r\\n\\r\\n with pd.ExcelWriter(\\\"./test_eval/Evaluation_\\\"\\r\\n + str(config.filename.split(\\\"/\\\")[-1].split(\\\".\\\")[0])\\r\\n + \\\".xlsx\\\") as writer:\\r\\n if regression:\\r\\n result_df.to_excel(writer, sheet_name=\\\"Regression\\\")\\r\\n else:\\r\\n result_df.to_excel(writer, sheet_name=\\\"Classification\\\")\\r\\n corr_df.to_excel(writer, sheet_name=\\\"Correlation\\\")\",\n \"def partition_data(dataset, datadir, logdir, partition, n_parties, beta=0.4):\\n if dataset == 'mnist':\\n X_train, y_train, X_test, y_test = load_mnist_data(datadir)\\n elif dataset == 'fmnist':\\n X_train, y_train, X_test, y_test = load_fmnist_data(datadir)\\n elif dataset == 'cifar10':\\n X_train, y_train, X_test, y_test = load_cifar10_data(datadir)\\n elif dataset == 'svhn':\\n X_train, y_train, X_test, y_test = load_svhn_data(datadir)\\n elif dataset == 'celeba':\\n X_train, y_train, X_test, y_test = load_celeba_data(datadir)\\n elif dataset == 'femnist':\\n X_train, y_train, u_train, X_test, y_test, u_test = load_femnist_data(datadir)\\n elif dataset == 'cifar100':\\n X_train, y_train, X_test, y_test = load_cifar100_data(datadir)\\n elif dataset == 'tinyimagenet':\\n X_train, y_train, X_test, y_test = load_tinyimagenet_data(datadir)\\n print(\\\"y_train\\\",y_train.shape)\\n print(\\\"y_test\\\",y_test.shape)\\n\\n elif dataset == 'generated':\\n X_train, y_train = [], []\\n for loc in range(4):\\n for i in range(1000):\\n p1 = random.random()\\n p2 = random.random()\\n p3 = random.random()\\n if loc > 1:\\n p2 = -p2\\n if loc % 2 ==1:\\n p3 = -p3\\n if i % 2 == 0:\\n X_train.append([p1, p2, p3])\\n y_train.append(0)\\n else:\\n X_train.append([-p1, -p2, -p3])\\n y_train.append(1)\\n X_test, y_test = [], []\\n for i in range(1000):\\n p1 = random.random() * 2 - 1\\n p2 = random.random() * 2 - 1\\n p3 = random.random() * 2 - 1\\n X_test.append([p1, p2, p3])\\n if p1>0:\\n y_test.append(0)\\n else:\\n y_test.append(1)\\n X_train = np.array(X_train, dtype=np.float32)\\n X_test = np.array(X_test, dtype=np.float32)\\n y_train = np.array(y_train, dtype=np.int32)\\n y_test = np.array(y_test, dtype=np.int64)\\n idxs = np.linspace(0,3999,4000,dtype=np.int64)\\n batch_idxs = np.array_split(idxs, n_parties)\\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\\n mkdirs(\\\"data/generated/\\\")\\n np.save(\\\"data/generated/X_train.npy\\\",X_train)\\n np.save(\\\"data/generated/X_test.npy\\\",X_test)\\n np.save(\\\"data/generated/y_train.npy\\\",y_train)\\n np.save(\\\"data/generated/y_test.npy\\\",y_test)\\n \\n #elif dataset == 'covtype':\\n # cov_type = sk.fetch_covtype('./data')\\n # num_train = int(581012 * 0.75)\\n # idxs = np.random.permutation(581012)\\n # X_train = np.array(cov_type['data'][idxs[:num_train]], dtype=np.float32)\\n # y_train = np.array(cov_type['target'][idxs[:num_train]], dtype=np.int32) - 1\\n # X_test = np.array(cov_type['data'][idxs[num_train:]], dtype=np.float32)\\n # y_test = np.array(cov_type['target'][idxs[num_train:]], dtype=np.int32) - 1\\n # mkdirs(\\\"data/generated/\\\")\\n # np.save(\\\"data/generated/X_train.npy\\\",X_train)\\n # np.save(\\\"data/generated/X_test.npy\\\",X_test)\\n # np.save(\\\"data/generated/y_train.npy\\\",y_train)\\n # np.save(\\\"data/generated/y_test.npy\\\",y_test)\\n\\n elif dataset in ('rcv1', 'SUSY', 'covtype'):\\n X_train, y_train = load_svmlight_file(\\\"../../../data/{}\\\".format(dataset))\\n X_train = X_train.todense()\\n num_train = int(X_train.shape[0] * 0.75)\\n if dataset == 'covtype':\\n y_train = y_train-1\\n else:\\n y_train = (y_train+1)/2\\n idxs = np.random.permutation(X_train.shape[0])\\n\\n X_test = np.array(X_train[idxs[num_train:]], dtype=np.float32)\\n y_test = np.array(y_train[idxs[num_train:]], dtype=np.int32)\\n X_train = np.array(X_train[idxs[:num_train]], dtype=np.float32)\\n y_train = np.array(y_train[idxs[:num_train]], dtype=np.int32)\\n\\n mkdirs(\\\"data/generated/\\\")\\n np.save(\\\"data/generated/X_train.npy\\\",X_train)\\n np.save(\\\"data/generated/X_test.npy\\\",X_test)\\n np.save(\\\"data/generated/y_train.npy\\\",y_train)\\n np.save(\\\"data/generated/y_test.npy\\\",y_test)\\n\\n elif dataset in ('a9a'):\\n X_train, y_train = load_svmlight_file(\\\"../../../data/{}\\\".format(dataset))\\n X_test, y_test = load_svmlight_file(\\\"../../../data/{}.t\\\".format(dataset))\\n X_train = X_train.todense()\\n X_test = X_test.todense()\\n X_test = np.c_[X_test, np.zeros((len(y_test), X_train.shape[1] - np.size(X_test[0, :])))]\\n\\n X_train = np.array(X_train, dtype=np.float32)\\n X_test = np.array(X_test, dtype=np.float32)\\n y_train = (y_train+1)/2\\n y_test = (y_test+1)/2\\n y_train = np.array(y_train, dtype=np.int32)\\n y_test = np.array(y_test, dtype=np.int32)\\n\\n mkdirs(\\\"data/generated/\\\")\\n np.save(\\\"data/generated/X_train.npy\\\",X_train)\\n np.save(\\\"data/generated/X_test.npy\\\",X_test)\\n np.save(\\\"data/generated/y_train.npy\\\",y_train)\\n np.save(\\\"data/generated/y_test.npy\\\",y_test)\\n\\n\\n n_train = y_train.shape[0]\\n \\n if partition == \\\"manual\\\":\\n label_idxs = {i:[] for i in np.unique(y_train)}\\n label_node_map = {i:[] for i in label_idxs.keys()} \\n label_node_map[0] = [0,5,10,15,20]\\n label_node_map[1] = [0,5,10,15,20]\\n label_node_map[2] = [1,6,11,16,21]\\n label_node_map[3] = [1,6,11,16,21]\\n label_node_map[4] = [2,7,12,17,22]\\n label_node_map[5] = [2,7,12,17,22]\\n label_node_map[6] = [3,8,13,18,23]\\n label_node_map[7] = [3,8,13,18,23]\\n label_node_map[8] = [4,9,14,19]\\n label_node_map[9] = [4,9,14,19]\\n\\n \\n for i,label in enumerate(y_train):\\n label_idxs[label].append(i)\\n \\n net_dataidx_map = {i:[] for i in range(n_parties)}\\n for label, idxs in label_idxs.items():\\n batch_idxs = np.array_split(idxs, len(label_node_map[label]))\\n for i, net_id in enumerate(label_node_map[label]):\\n net_dataidx_map[net_id] += list(batch_idxs[i])\\n \\n\\n if partition == \\\"homo\\\":\\n idxs = np.random.permutation(n_train)\\n batch_idxs = np.array_split(idxs, n_parties)\\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\\n \\n\\n\\n elif partition == \\\"noniid-labeldir\\\":\\n min_size = 0\\n min_require_size = 10\\n K = 10\\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\\n K = 2\\n elif dataset in ('tinyimagenet'):\\n K = 200\\n # min_require_size = 100\\n elif dataset in ('cifar100'):\\n K = 100\\n\\n N = y_train.shape[0]\\n #np.random.seed(2020)\\n net_dataidx_map = {}\\n\\n while min_size < min_require_size:\\n idx_batch = [[] for _ in range(n_parties)]\\n for k in range(K):\\n idx_k = np.where(y_train == k)[0]\\n np.random.shuffle(idx_k)\\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\\n # logger.info(\\\"proportions1: \\\", proportions)\\n # logger.info(\\\"sum pro1:\\\", np.sum(proportions))\\n ## Balance\\n proportions = np.array([p * (len(idx_j) < N / n_parties) for p, idx_j in zip(proportions, idx_batch)])\\n # logger.info(\\\"proportions2: \\\", proportions)\\n proportions = proportions / proportions.sum()\\n # logger.info(\\\"proportions3: \\\", proportions)\\n proportions = (np.cumsum(proportions) * len(idx_k)).astype(int)[:-1]\\n # logger.info(\\\"proportions4: \\\", proportions)\\n idx_batch = [idx_j + idx.tolist() for idx_j, idx in zip(idx_batch, np.split(idx_k, proportions))]\\n min_size = min([len(idx_j) for idx_j in idx_batch])\\n # if K == 2 and n_parties <= 10:\\n # if np.min(proportions) < 200:\\n # min_size = 0\\n # break\\n\\n\\n for j in range(n_parties):\\n np.random.shuffle(idx_batch[j])\\n net_dataidx_map[j] = idx_batch[j]\\n\\n elif partition > \\\"noniid-#label0\\\" and partition <= \\\"noniid-#label9\\\":\\n num = eval(partition[13:])\\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\\n num = 1\\n K = 2\\n else:\\n K = 10\\n if dataset == \\\"cifar100\\\":\\n K = 100\\n elif dataset == \\\"tinyimagenet\\\":\\n K = 200\\n if num == 10:\\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\\n for i in range(10):\\n idx_k = np.where(y_train==i)[0]\\n np.random.shuffle(idx_k)\\n split = np.array_split(idx_k,n_parties)\\n for j in range(n_parties):\\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[j])\\n else:\\n times=[0 for i in range(K)]\\n contain=[]\\n for i in range(n_parties):\\n current=[i%K]\\n times[i%K]+=1\\n j=1\\n while (j<num):\\n ind=random.randint(0,K-1)\\n if (ind not in current):\\n j=j+1\\n current.append(ind)\\n times[ind]+=1\\n contain.append(current)\\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\\n for i in range(K):\\n idx_k = np.where(y_train==i)[0]\\n np.random.shuffle(idx_k)\\n split = np.array_split(idx_k,times[i])\\n ids=0\\n for j in range(n_parties):\\n if i in contain[j]:\\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[ids])\\n ids+=1\\n\\n\\n elif partition == \\\"iid-diff-quantity\\\":\\n idxs = np.random.permutation(n_train)\\n min_size = 0\\n while min_size < 10:\\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\\n proportions = proportions/proportions.sum()\\n min_size = np.min(proportions*len(idxs))\\n proportions = (np.cumsum(proportions)*len(idxs)).astype(int)[:-1]\\n batch_idxs = np.split(idxs,proportions)\\n net_dataidx_map = {i: batch_idxs[i] for i in range(n_parties)}\\n \\n elif partition == \\\"mixed\\\":\\n min_size = 0\\n min_require_size = 10\\n K = 10\\n if dataset in ('celeba', 'covtype', 'a9a', 'rcv1', 'SUSY'):\\n K = 2\\n # min_require_size = 100\\n\\n N = y_train.shape[0]\\n net_dataidx_map = {}\\n\\n times=[1 for i in range(10)]\\n contain=[]\\n for i in range(n_parties):\\n current=[i%K]\\n j=1\\n while (j<2):\\n ind=random.randint(0,K-1)\\n if (ind not in current and times[ind]<2):\\n j=j+1\\n current.append(ind)\\n times[ind]+=1\\n contain.append(current)\\n net_dataidx_map ={i:np.ndarray(0,dtype=np.int64) for i in range(n_parties)}\\n \\n\\n min_size = 0\\n while min_size < 10:\\n proportions = np.random.dirichlet(np.repeat(beta, n_parties))\\n proportions = proportions/proportions.sum()\\n min_size = np.min(proportions*n_train)\\n\\n for i in range(K):\\n idx_k = np.where(y_train==i)[0]\\n np.random.shuffle(idx_k)\\n\\n proportions_k = np.random.dirichlet(np.repeat(beta, 2))\\n #proportions_k = np.ndarray(0,dtype=np.float64)\\n #for j in range(n_parties):\\n # if i in contain[j]:\\n # proportions_k=np.append(proportions_k ,proportions[j])\\n\\n proportions_k = (np.cumsum(proportions_k)*len(idx_k)).astype(int)[:-1]\\n\\n split = np.split(idx_k, proportions_k)\\n ids=0\\n for j in range(n_parties):\\n if i in contain[j]:\\n net_dataidx_map[j]=np.append(net_dataidx_map[j],split[ids])\\n ids+=1\\n\\n elif partition == \\\"real\\\" and dataset == \\\"femnist\\\":\\n num_user = u_train.shape[0]\\n user = np.zeros(num_user+1,dtype=np.int32)\\n for i in range(1,num_user+1):\\n user[i] = user[i-1] + u_train[i-1]\\n no = np.random.permutation(num_user)\\n batch_idxs = np.array_split(no, n_parties)\\n net_dataidx_map = {i:np.zeros(0,dtype=np.int32) for i in range(n_parties)}\\n for i in range(n_parties):\\n for j in batch_idxs[i]:\\n net_dataidx_map[i]=np.append(net_dataidx_map[i], np.arange(user[j], user[j+1]))\\n\\n traindata_cls_counts = record_net_data_stats(y_train, net_dataidx_map, logdir)\\n return (X_train, y_train, X_test, y_test, net_dataidx_map, traindata_cls_counts)\",\n \"def fit(self, training_data_x, training_data_y, fraction_opt):\\n self.training_data_train_x, self.training_data_opt_x, self.training_data_train_y, \\\\\\n self.training_data_opt_y = train_test_split(training_data_x, training_data_y,\\n test_size=fraction_opt, random_state=0)\\n self.result = self.cherry_pick()\",\n \"def data_setup(self):\\n # Make sure the dataset is download and put into the data folder\\n training_data = pd.read_csv('./data/train.csv', sep=',', nrows=self.training_dataset_size)\\n testing_data = pd.read_csv('./data/test.csv', sep=',' , nrows=self.training_dataset_size)\\n question_list1 = training_data['question1']\\n question_list2 = training_data['question2']\\n is_duplicate = training_data['is_duplicate']\\n # for will\\n X = []\\n Y = []\\n for i in range(0, 1000):\\n print(\\\"*\\\"*20, i ,\\\"*\\\"*20 )\\n feature = self.call_feature_generator(question_list1[i],question_list2[i], self.feature_code )\\n X.append(feature)\\n Y.append(is_duplicate[i])\\n print(feature)\\n print(is_duplicate[i])\\n print(question_list1[i])\\n print(question_list2[i])\\n\\n # we train classifier\\n\\n classifer = self.call_classifier(X, Y, self.classifier_code)\\n\\n # testing\\n testX = []\\n testY = []\\n\\n for i in range(1001, 1500):\\n print(\\\"-\\\"*20, i ,\\\"-\\\"*20 )\\n feature = self.call_feature_generator(question_list1[i],question_list2[i], self.feature_code )\\n testX.append(feature)\\n testY.append(is_duplicate[i])\\n\\n X= np.array(testX).reshape(-1,1)\\n\\n calculate_y = classifer.predict(X)\\n\\n print(calculate_y)\\n tp = 0.0\\n fp = 0.0\\n fn = 0.0\\n\\n for i in range(0, len(calculate_y)):\\n if calculate_y[i] == testY[i]:\\n print(\\\"Tp : \\\", testX[i], question_list1[i], question_list2[i], is_duplicate[i] )\\n tp += 1.0\\n else:\\n if testY[i] == 1 and calculate_y[i] == 0:\\n print(\\\"Fn : \\\", testX[i] , question_list1[i], question_list2[i], is_duplicate[i] )\\n fn += 1.0\\n else:\\n print(\\\"Fp : \\\", testX[i], question_list1[i], question_list2[i], is_duplicate[i])\\n fp += 1.0\\n\\n print(\\\"Tp: \\\", tp, \\\" Fp: \\\", fp, \\\" Fn: \\\", fn)\\n print(\\\"Accuracy \\\", tp/( tp+fn), \\\"%\\\")\\n\\n result = precision_recall_fscore_support(testY, calculate_y)\\n print (\\\"Precision: Class 1 - \\\", result[0][0], \\\"% and Class 0 - \\\", result[0][1], \\\"%\\\")\\n print (\\\"Recall: Class 1 - \\\", result[1][0], \\\"% and Class 0 - \\\", result[1][1], \\\"%\\\")\\n print (\\\"F-Score: Class 1 - \\\", result[2][0], \\\"% and Class 0 - \\\", result[2][1], \\\"%\\\")\",\n \"def prepare_data(self, *args, **kwargs):\\n # get paths to train and test splits\\n _split_paths = [os.path.join(self.path_to_data, split)\\n for split in os.listdir(self.path_to_data)]\\n\\n # for each split [train, test]\\n for _path in _split_paths:\\n _img_classes = os.listdir(_path) # get subfolders representing each class\\n self.splits[os.path.basename(_path)] = []\\n\\n # get the images in pairs with its corresponding class\\n for _class in _img_classes:\\n _data = self.get_img_text_pair(os.path.join(_path, _class))\\n\\n if os.path.basename(_path) == 'train':\\n self.weights[self.encode_label(_class)] = len(_data)\\n self.splits[os.path.basename(_path)].extend(_data)\",\n \"def assessStrategyGlobal(test_beginning_match,\\r\\n duration_train_matches,\\r\\n duration_val_matches,\\r\\n duration_test_matches,\\r\\n xgb_params,\\r\\n nb_players,\\r\\n nb_tournaments,\\r\\n features,\\r\\n data,\\r\\n model_name=\\\"0\\\"):\\r\\n ########## Training/validation/testing set generation\\r\\n\\r\\n # Number of matches in our dataset (ie. nb. of outcomes divided by 2)\\r\\n nm = int(len(features) / 2)\\r\\n\\r\\n # Id of the first and last match of the testing,validation,training set\\r\\n beg_test = test_beginning_match\\r\\n end_test = min(test_beginning_match + duration_test_matches - 1, nm - 1)\\r\\n end_val = min(beg_test - 1, nm - 1)\\r\\n beg_val = beg_test - duration_val_matches\\r\\n end_train = beg_val - 1\\r\\n beg_train = beg_val - duration_train_matches\\r\\n\\r\\n train_indices = range(2 * beg_train, 2 * end_train + 2)\\r\\n val_indices = range(2 * beg_val, 2 * end_val + 2)\\r\\n test_indices = range(2 * beg_test, 2 * end_test + 2)\\r\\n\\r\\n if (len(test_indices) == 0) | (len(train_indices) == 0):\\r\\n return 0\\r\\n\\r\\n # Split in train/validation/test\\r\\n xval = features.iloc[val_indices, :].reset_index(drop=True)\\r\\n xtest = features.iloc[test_indices, :].reset_index(drop=True)\\r\\n xtrain = features.iloc[train_indices, :].reset_index(drop=True)\\r\\n ytrain = pd.Series([1, 0] * int(len(train_indices) / 2))\\r\\n yval = pd.Series([1, 0] * int(len(val_indices) / 2))\\r\\n\\r\\n # We limit the number of players and tournaments one-hot encoded : we'll keep only the\\r\\n # players that won the most matches to avoid overfitting and make the process quicker\\r\\n # Biggest players :\\r\\n biggest_players = data.iloc[range(beg_train, end_train), :][[\\\"Winner\\\", \\\"Loser\\\"]]\\r\\n biggest_players = pd.concat([biggest_players.Winner, biggest_players.Loser], 0)\\r\\n biggest_players = list(biggest_players.value_counts().index[:nb_players])\\r\\n player_columns = [el for el in xtrain.columns if el[:6] == \\\"player\\\"]\\r\\n to_drop_players = [el for el in player_columns if el[7:] not in biggest_players]\\r\\n # Biggest Tournaments\\r\\n biggest_tournaments = data.iloc[range(beg_train, end_train), :][\\\"Tournament\\\"]\\r\\n biggest_tournaments = list(biggest_tournaments.value_counts().index[:nb_tournaments])\\r\\n tournament_columns = [el for el in xtrain.columns if el[:10] == \\\"tournament\\\"]\\r\\n to_drop_tournaments = [el for el in tournament_columns if el[11:] not in biggest_tournaments]\\r\\n # We drop smallest Tournaments and players\\r\\n xtrain = xtrain.drop(to_drop_players + to_drop_tournaments, 1)\\r\\n xval = xval.drop(to_drop_players + to_drop_tournaments, 1)\\r\\n xtest = xtest.drop(to_drop_players + to_drop_tournaments, 1)\\r\\n\\r\\n ### ML model training\\r\\n model = xgbModelBinary(xtrain, ytrain, xval, yval, xgb_params, sample_weights=None)\\r\\n\\r\\n # The probability given by the model to each outcome of each match :\\r\\n pred_test = model.predict(xgb.DMatrix(xtest, label=None))\\r\\n # For each match, the winning probability the model gave to the players that won (should be high...) :\\r\\n prediction_test_winner = pred_test[range(0, len(pred_test), 2)]\\r\\n # For each match, the winning probability the model gave to the players that lost (should be low...) :\\r\\n prediction_test_loser = pred_test[range(1, len(pred_test), 2)]\\r\\n\\r\\n ### Odds and predicted probabilities for the testing set (1 row/match)\\r\\n odds = data[[\\\"PSW\\\", \\\"PSL\\\"]].iloc[range(beg_test, end_test + 1)]\\r\\n implied_probabilities = 1 / odds\\r\\n p = pd.Series(\\r\\n list(zip(prediction_test_winner, prediction_test_loser, implied_probabilities.PSW, implied_probabilities.PSL)))\\r\\n\\r\\n ### For each match in the testing set, if the model predicted the right winner :\\r\\n right = (prediction_test_winner > prediction_test_loser).astype(int)\\r\\n\\r\\n ### For each match in the testing set, the confidence of the model in the outcome it chose\\r\\n def sel_match_confidence(x):\\r\\n if x[0] > x[1]:\\r\\n return x[0] / x[2]\\r\\n else:\\r\\n return x[1] / x[3]\\r\\n\\r\\n confidence = p.apply(lambda x: sel_match_confidence(x))\\r\\n\\r\\n ### The final confidence dataset\\r\\n confidenceTest = pd.DataFrame({\\\"match\\\": range(beg_test, end_test + 1),\\r\\n \\\"win\\\" + model_name: right,\\r\\n \\\"confidence\\\" + model_name: confidence,\\r\\n \\\"PSW\\\": odds.PSW.values})\\r\\n confidenceTest = confidenceTest.sort_values(\\\"confidence\\\" + model_name, ascending=False).reset_index(drop=True)\\r\\n\\r\\n return confidenceTest\",\n \"def _train_model(\\n self,\\n dataset: DatasetEntity,\\n ):\\n logger.info(\\\"init data cfg.\\\")\\n self._data_cfg = ConfigDict(data=ConfigDict())\\n\\n for cfg_key, subset in zip(\\n [\\\"train\\\", \\\"val\\\", \\\"unlabeled\\\"],\\n [Subset.TRAINING, Subset.VALIDATION, Subset.UNLABELED],\\n ):\\n subset = get_dataset(dataset, subset)\\n if subset and self._data_cfg is not None:\\n self._data_cfg.data[cfg_key] = ConfigDict(\\n otx_dataset=subset,\\n labels=self._labels,\\n )\\n\\n self._is_training = True\\n\\n self._init_task()\\n\\n cfg = self.configure(True, None)\\n logger.info(\\\"train!\\\")\\n\\n timestamp = time.strftime(\\\"%Y%m%d_%H%M%S\\\", time.localtime())\\n\\n # Environment\\n logger.info(f\\\"cfg.gpu_ids = {cfg.gpu_ids}, distributed = {cfg.distributed}\\\")\\n env_info_dict = collect_env()\\n env_info = \\\"\\\\n\\\".join([(f\\\"{k}: {v}\\\") for k, v in env_info_dict.items()])\\n dash_line = \\\"-\\\" * 60 + \\\"\\\\n\\\"\\n logger.info(f\\\"Environment info:\\\\n{dash_line}{env_info}\\\\n{dash_line}\\\")\\n\\n # Data\\n datasets = [build_dataset(cfg.data.train)]\\n\\n if self._train_type == TrainType.Semisupervised:\\n # forward the knowledge of num iters per epoch to model for filter loss\\n bs_per_gpu = cfg.data.train_dataloader[\\\"samples_per_gpu\\\"]\\n actual_bs = bs_per_gpu * torch.distributed.get_world_size() if cfg.distributed else bs_per_gpu\\n cfg.model.num_iters_per_epoch = math.ceil(len(datasets[0]) / actual_bs)\\n\\n # FIXME: Currently segmentor does not support multi batch evaluation.\\n # For the Self-SL case, there is no val data. So, need to check the\\n\\n if \\\"val\\\" in cfg.data and \\\"val_dataloader\\\" in cfg.data:\\n cfg.data.val_dataloader[\\\"samples_per_gpu\\\"] = 1\\n\\n # Target classes\\n if \\\"task_adapt\\\" in cfg:\\n target_classes = cfg.task_adapt.final\\n else:\\n target_classes = datasets[0].CLASSES\\n\\n # Metadata\\n meta = dict()\\n meta[\\\"env_info\\\"] = env_info\\n meta[\\\"seed\\\"] = cfg.seed\\n meta[\\\"exp_name\\\"] = cfg.work_dir\\n if cfg.checkpoint_config is not None:\\n cfg.checkpoint_config.meta = dict(\\n mmseg_version=__version__ + get_git_hash()[:7],\\n CLASSES=target_classes,\\n )\\n\\n # Model\\n model = self.build_model(cfg, fp16=cfg.get(\\\"fp16\\\", False), is_training=self._is_training)\\n model.train()\\n model.CLASSES = target_classes\\n\\n if cfg.distributed:\\n convert_sync_batchnorm(model)\\n\\n validate = bool(cfg.data.get(\\\"val\\\", None))\\n\\n if self._hyperparams.learning_parameters.auto_adapt_batch_size != BatchSizeAdaptType.NONE:\\n train_func = partial(train_segmentor, meta=deepcopy(meta), model=deepcopy(model), distributed=False)\\n adapt_batch_size(\\n train_func,\\n cfg,\\n datasets,\\n isinstance(self, NNCFBaseTask), # nncf needs eval hooks\\n not_increase=(self._hyperparams.learning_parameters.auto_adapt_batch_size == BatchSizeAdaptType.SAFE),\\n )\\n\\n train_segmentor(\\n model,\\n datasets,\\n cfg,\\n distributed=cfg.distributed,\\n validate=validate,\\n timestamp=timestamp,\\n meta=meta,\\n )\\n\\n # Save outputs\\n output_ckpt_path = os.path.join(cfg.work_dir, \\\"latest.pth\\\")\\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \\\"best_mDice_*.pth\\\"))\\n if len(best_ckpt_path) > 0:\\n output_ckpt_path = best_ckpt_path[0]\\n best_ckpt_path = glob.glob(os.path.join(cfg.work_dir, \\\"best_mIoU_*.pth\\\"))\\n if len(best_ckpt_path) > 0:\\n output_ckpt_path = best_ckpt_path[0]\\n return dict(\\n final_ckpt=output_ckpt_path,\\n )\",\n \"def main():\\n housing = pd.read_csv(\\\"Data/train_original.csv\\\")\\n housing[\\\"TotalSF\\\"] = (\\n housing[\\\"TotalBsmtSF\\\"] + housing[\\\"1stFlrSF\\\"] + housing[\\\"2ndFlrSF\\\"]\\n )\\n training_features, testing_features, training_target, testing_target = impute_dummify_and_split(\\n housing, drop_target=False\\n )\\n\\n p_values = [\\n (c, pearsonr(training_features[\\\"SalePrice\\\"], training_features[c])[1])\\n for c in training_features.columns\\n ]\\n\\n p_value_limits = [0.05]\\n\\n result = []\\n ps_and_cols = {}\\n\\n for p_value_limit in p_value_limits:\\n\\n high_ps = list(\\n map(lambda t: t[0], sorted(p_values, key=lambda t1: t1[1])[:15])\\n )\\n\\n print(training_features[high_ps].corr())\\n\\n columns = [p[0] for p in p_values if p[1] < p_value_limit]\\n\\n training_features_restricted = training_features[columns].drop(\\n \\\"SalePrice\\\", axis=\\\"columns\\\"\\n )\\n\\n testing_features_restricted = testing_features[columns].drop(\\n \\\"SalePrice\\\", axis=\\\"columns\\\"\\n )\\n\\n for model in (\\n linear_model.Lasso(alpha=2.1),\\n linear_model.Ridge(alpha=2.1),\\n ):\\n\\n model.fit(training_features_restricted, training_target)\\n\\n train_score = model.score(\\n training_features_restricted, training_target\\n )\\n\\n test_score = model.score(\\n testing_features_restricted, testing_target\\n )\\n\\n name = str(model).split(\\\"(\\\")[0]\\n\\n result = result + [\\n (\\n \\\"_2_restrict_features\\\",\\n name,\\n \\\"p value limit: {:.3f}, alpha: 2.1\\\".format(p_value_limit),\\n train_score,\\n test_score,\\n )\\n ]\\n\\n print(ps_and_cols)\\n return training_features[high_ps].corr()\",\n \"def growing_testset(train_filename, test_filename, clf, clf_name=None):\\n train_features, train_groundtruths = read_file(train_filename)\\n test_features, test_groundtruths = read_file(test_filename)\\n \\n if clf_name is not None and \\\"RANSAC\\\" in clf_name:\\n train_groundtruths = [True if i ==\\\"s\\\" else False for i in train_groundtruths]\\n test_groundtruths = [True if i ==\\\"s\\\" else False for i in test_groundtruths]\\n\\n clf.fit(train_features, train_groundtruths)\\n\\n if clf_name is not None and \\\"RANSAC\\\" in clf_name:\\n preds_float = clf.predict(test_features)\\n predictions = [True if i > 0.5 else False for i in preds_float]\\n else:\\n predictions = clf.predict(test_features)\\n \\n test_acc = []\\n # test_acc.append(accuracy_score(test_groundtruths, predictions))\\n test_acc.append(precision_score(test_groundtruths, predictions, average=None)[0])\\n print(\\\"Accuracy : \\\" + str(test_acc))\\n print(\\\"Precision: \\\" + str(precision_score(test_groundtruths, predictions, average=None)))\\n print(\\\"Recall : \\\" + str(recall_score(test_groundtruths, predictions, average=None)))\\n print(\\\"F-score : \\\" + str(f1_score(test_groundtruths, predictions, average=None)))\\n\\n n_splits = 10\\n for n_split in range(2, n_splits+1):\\n print(n_split)\\n feats_array, gts_array = split(test_features, test_groundtruths, n_split)\\n tmp_acc = []\\n for feats, gts in zip(feats_array, gts_array):\\n if clf_name is not None and \\\"RANSAC\\\" in clf_name:\\n preds_float = clf.predict(feats)\\n predictions = [True if i > 0.5 else False for i in preds_float]\\n else:\\n predictions = clf.predict(feats)\\n # cur_acc = accuracy_score(gts, predictions)\\n cur_acc = precision_score(gts, predictions, average=None)[0]\\n tmp_acc.append(cur_acc)\\n print(\\\"\\\\t\\\" + str(cur_acc))\\n accuracy = sum(tmp_acc) / float(len(tmp_acc))\\n test_acc.append(accuracy)\\n return test_acc\",\n \"def testTrainSplit(self, feature, Class, test_size = 0.2, \\n random_state = 0):\\n # training and testing sets\\n fTrain, fTest, cTrain, cTest = train_test_split( feature, Class,\\n test_size = test_size, \\n random_state = random_state)\\n self.fTrain = fTrain\\n self.fTest = fTest\\n self.cTrain = cTrain\\n self.cTest = cTest\\n \\n return fTrain, fTest, cTrain, cTest\",\n \"def gen_train_val_test_split(self, splits=[0.7, 0.2, 0.1], random_state=42):\\n patient_dirs = os.listdir(self.out_dir)\\n msk_list, img_list, patient_list, is_tumor = [], [], [], []\\n\\n for patient in patient_dirs:\\n patient_folder = os.path.join(self.out_dir, patient)\\n if not os.path.isdir(patient_folder):\\n continue\\n\\n patient_root = os.path.join(self.out_dir, patient)\\n for file in os.listdir(patient_root):\\n if \\\"mask\\\" not in file:\\n patient_list.append(patient)\\n img_list.append(os.path.join(patient_root, file))\\n msk_list.append(os.path.join(patient_root, file[:file.find(\\\".npy\\\")] + \\\"_mask.npy\\\"))\\n \\n img = np.load(msk_list[-1])\\n if np.mean(img) > 0:\\n is_tumor.append(1)\\n else:\\n is_tumor.append(0)\\n \\n data = pd.DataFrame(data={\\\"Patient\\\": patient_list, \\\"Image\\\": img_list, \\\"Mask\\\": msk_list, \\\"Tumor Present\\\": is_tumor})\\n self.train_df, self.valid_df, self.test_df = self._split_by_patients(data, val_split=splits[1], test_split=splits[2], random_state=random_state)\\n # print(len(train), len(val), len(test))\\n # self.train_df = data[data[\\\"Patient\\\"].isin(train)]\\n # self.valid_df = data[data[\\\"Patient\\\"].isin(val)]\\n # self.test_df = data[data[\\\"Patient\\\"].isin(test)]\",\n \"def train(self, args_hpo, index):\\n\\n PrintColors.prYellow(f'\\\\n===== training with: {args_hpo} index={index}')\\n PrintColors.prGreen(f'---- in mode: {self.configurations.execution_mode}, tag: {self.configurations.tag} ----')\\n ''' ============ LOAD DATA ================================================================================ '''\\n starting_time = time.time()\\n dataset_reader = self.dataset_reader(\\n candidate_types=self.configurations.clustering_mode,\\n word_indexer={'words': PretrainedTransformerIndexer(self.configurations.pretrained_model_name)},\\n mode=self.configurations.loading_mode)\\n ''' .read returns list of instances '''\\n train_data, val_data, test_data = (dataset_reader.read(folder) for folder in\\n [self.configurations.train_data_dir,\\n self.configurations.val_data_dir,\\n self.configurations.test_data_dir])\\n\\n # count state pairs\\n preceeds = dict()\\n\\n for instance in train_data:\\n for ind in range(len(instance.fields['squeezed_labels'].tokens) - 1):\\n [event_1, event_2] = [instance.fields['squeezed_labels'].tokens[i].text for i in [ind, ind + 1]]\\n scenario = self.dataset_reader.scenario_of_label(event_1)\\n if scenario not in preceeds:\\n preceeds[scenario] = dict()\\n if (event_1, event_2) not in preceeds[scenario]:\\n preceeds[scenario][(event_1, event_2)] = 0\\n preceeds[scenario][(event_1, event_2)] += 1\\n\\n pretrained_tokenizer = PretrainedTransformerTokenizer(self.configurations.pretrained_model_name)\\n supply_token_indices(train_data + val_data, 'story', pretrained_tokenizer)\\n\\n ''' build vocabulary and associate it with datasets '''\\n vocabulary = Vocabulary.from_instances(train_data + val_data)\\n train_data.index_with(vocabulary), val_data.index_with(vocabulary)\\n\\n train_data_loader = DataLoader(dataset=train_data, batch_size=args_hpo.batch_size)\\n val_data_loader = DataLoader(dataset=val_data, batch_size=args_hpo.batch_size)\\n\\n ''' ============ DEFINE MODEL ============================================================================= '''\\n ''' i keep .to() here instead of in model.__init__() to accomadate better abstraction '''\\n event_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\\n if '#' in vocabulary.get_token_from_index(i, 'scr_labels')]\\n participant_labels = [i for i in range(vocabulary.get_vocab_size('scr_labels'))\\n if '@' in vocabulary.get_token_from_index(i, 'scr_labels')]\\n model = self.model(args_hpo, vocabulary, configurations=self.configurations,\\n preceeds=preceeds,\\n event_indices=event_labels,\\n participant_indices=participant_labels).to(self.configurations.device)\\n\\n ''' ============ DEFINE TRAINER =========================================================================== '''\\n ''' -- serialization --------------------------------------------------- '''\\n if not os.path.exists(os.path.join(*['.', 'models'])):\\n os.mkdir(os.path.join(*['.', 'models']))\\n if index == 0:\\n for file in os.listdir(os.path.join(*['.', 'models'])):\\n path = os.path.join(*['.', 'models', file])\\n if os.path.isfile(path):\\n os.remove(path)\\n else:\\n shutil.rmtree(path)\\n serialization_path = 'models_{}_{}'.format(self.configurations.tag, index)\\n serialization_path_longer = os.path.join(*['.', 'models', serialization_path])\\n vocab_path = 'vocab_{}_{}'.format(self.configurations.tag, index)\\n vocab_dir_longer = os.path.join(*['.', 'models', vocab_path])\\n if not os.path.exists(serialization_path_longer):\\n os.mkdir(serialization_path_longer)\\n model_checkpointer = Checkpointer(serialization_dir=serialization_path_longer, num_serialized_models_to_keep=1)\\n ''' -- logging ---------------------------------------------------------- '''\\n tensorboard_writer = TensorboardWriter(serialization_dir='tensorboard', summary_interval=1)\\n if index == 0:\\n shutil.rmtree(os.path.join(*['.', 'tensorboard', 'log']))\\n\\n optimizer = torch.optim.Adam(model.parameters(), lr=args_hpo.lr, weight_decay=args_hpo.l2)\\n trainer = GradientDescentTrainer(\\n model=model,\\n optimizer=optimizer,\\n data_loader=train_data_loader,\\n validation_data_loader=val_data_loader,\\n # note: this is the metric for early stopping\\n validation_metric='-loss',\\n patience=self.configurations.patience,\\n num_epochs=self.configurations.max_epochs,\\n serialization_dir=serialization_path_longer,\\n checkpointer=model_checkpointer,\\n cuda_device=self.configurations.device,\\n grad_norm=args_hpo.clip,\\n tensorboard_writer=tensorboard_writer,\\n learning_rate_scheduler=ReduceOnPlateauLearningRateScheduler(optimizer=optimizer)\\n )\\n\\n ''' trainer saves the model, but the vocabulary needs to be saved, too '''\\n vocabulary.save_to_files(vocab_dir_longer)\\n\\n ''' check the metric names to synchronize with the class '''\\n metrics = trainer.train()\\n test_metrics = model.test(test_data=test_data, dataset_reader=dataset_reader)\\n metrics.update(test_metrics)\\n metrics['time_consumed(hrs)'] = round((time.time() - starting_time) / 3600, 4)\\n\\n return metrics\",\n \"def test(cfg):\\n # Set up environment.\\n distributed.init_distributed_training(cfg)\\n\\n # Set random seed from configs.\\n np.random.seed(cfg.RNG_SEED)\\n torch.manual_seed(cfg.RNG_SEED)\\n\\n # Print config.\\n if distributed.is_master_proc():\\n print(\\\"Test with config:\\\")\\n print(cfg)\\n\\n # Build the model and print model statistics.\\n # Use cuda if available\\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\\n # Construct the model\\n model = PanopticNarrativeGroundingBaseline(cfg, device=device)\\n # Determine the GPU used by the current process\\n cur_device = torch.cuda.current_device()\\n # Transfer the model to the current GPU device\\n model = model.cuda(device=cur_device)\\n if cfg.NUM_GPUS > 1:\\n # Make model replica operate on the current device\\n model = torch.nn.parallel.DistributedDataParallel(\\n module=model, device_ids=[cur_device], output_device=cur_device,\\n find_unused_parameters=True\\n )\\n if cfg.LOG_MODEL_INFO and distributed.is_master_proc():\\n print(\\\"Model:\\\\n{}\\\".format(model))\\n print(\\\"Params: {:,}\\\".format(np.sum([p.numel() for p in model.parameters()]).item()))\\n print(\\\"Mem: {:,} MB\\\".format(torch.cuda.max_memory_allocated() / 1024 ** 3))\\n print(\\\"nvidia-smi\\\")\\n os.system(\\\"nvidia-smi\\\")\\n\\n # Load a checkpoint to test if applicable.\\n checkpoint_path = osp.join(cfg.OUTPUT_DIR, 'model_final.pth')\\n if cfg.TEST.CHECKPOINT_FILE_PATH != \\\"\\\":\\n checkpoint_path = cfg.TEST.CHECKPOINT_FILE_PATH\\n if osp.exists(checkpoint_path):\\n if distributed.is_master_proc():\\n print('Loading model from: {0}'.format(checkpoint_path))\\n checkpoint = torch.load(checkpoint_path, map_location=\\\"cpu\\\")\\n if cfg.NUM_GPUS > 1:\\n model.module.load_state_dict(checkpoint['model_state'])\\n else:\\n model.load_state_dict(checkpoint['model_state'])\\n elif cfg.TRAIN.CHECKPOINT_FILE_PATH != \\\"\\\":\\n # If no checkpoint found in TEST.CHECKPOINT_FILE_PATH or in the current\\n # checkpoint folder, try to load checkpoint from\\n # TRAIN.CHECKPOINT_FILE_PATH and test it.\\n checkpoint_path = cfg.TRAIN.CHECKPOINT_FILE_PATH\\n checkpoint = torch.load(checkpoint_path, map_location=\\\"cpu\\\")\\n if cfg.NUM_GPUS > 1:\\n model.module.load_state_dict(checkpoint['model_state'])\\n else:\\n model.load_state_dict(checkpoint['model_state'])\\n else:\\n if distributed.is_master_proc():\\n print(\\\"Testing with random initialization. Only for debugging.\\\")\\n\\n # Create testing loaders.\\n test_dataset = PanopticNarrativeGroundingDataset(cfg, cfg.DATA.VAL_SPLIT, train=False)\\n test_loader = DataLoader(\\n test_dataset,\\n batch_size=int(cfg.TRAIN.BATCH_SIZE / max(1, cfg.NUM_GPUS)),\\n shuffle=False,\\n sampler=(DistributedSampler(test_dataset) if cfg.NUM_GPUS > 1 else None),\\n num_workers=cfg.DATA_LOADER.NUM_WORKERS,\\n pin_memory=cfg.DATA_LOADER.PIN_MEMORY\\n )\\n \\n if distributed.is_master_proc():\\n print(\\\"Testing model for {} iterations\\\".format(len(test_loader)))\\n\\n # Perform test on the entire dataset.\\n perform_test(test_loader, model, cfg)\",\n \"def train_test_split(self) -> None:\\n\\n X = self._df[['Avg. Area Income', 'Avg. Area House Age', 'Avg. Area Number of Rooms',\\n 'Avg. Area Number of Bedrooms', 'Area Population']]\\n y = self._df['Price']\\n\\n self._X_train, self._X_test, self._y_train, self._y_test = train_test_split(\\n X, y, test_size=0.4, random_state=42)\",\n \"def generate_train_test(self):\\n x, y = self.read_data()\\n x_train, y_train, x_test, y_test = self.sample_data(x, y)\\n self.train = (x_train, y_train)\\n self.test = (x_test, y_test)\",\n \"def get_dataloader(data_folder, model_name, data_name, size=\\\"default\\\"):\\n training_set = None\\n validation_set = None\\n\\n if model_name == \\\"Howe_Patterson\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\\n\\n elif size == \\\"small\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\\n elif size == \\\"tiny\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\\n\\n\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_full_SHHS(partition['train'], data_folder)\\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_full(partition['train'], data_folder)\\n validation_set = Dataset_full(partition['validation'], data_folder)\\n elif data_name == \\\"philips\\\":\\n training_set = Dataset_Philips_full(partition['train'], data_folder)\\n validation_set = Dataset_Philips_full(partition['validation'], data_folder)\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n training_set = ConcatDataset(\\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n validation_set = ConcatDataset(\\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n elif model_name == \\\"Deep_Sleep\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition.pkl')))\\n\\n elif size == \\\"small\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_small.pkl'))\\n elif size == \\\"tiny\\\":\\n partition = load_obj(os.path.join(data_folder, 'data_partition_tiny.pkl'))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition.pkl'))\\n\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_full_SHHS(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_full_SHHS(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_full(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_full(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"philips\\\":\\n training_set = Dataset_Philips_full(partition['train'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n validation_set = Dataset_Philips_full(partition['validation'], data_folder, downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False)\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n # TODO combined dataset https://discuss.pytorch.org/t/train-simultaneously-on-two-datasets/649/17\\n training_set = ConcatDataset(\\n Dataset_full(partition[0]['train'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['train'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n validation_set = ConcatDataset(\\n Dataset_full(partition[0]['validation'], data_folder[0], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False),\\n Dataset_full_SHHS(partition[1]['validation'], data_folder[1], downsample_ratio=4,\\n pre_allocation=2 ** 22, down_sample_annotation=False))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n elif model_name == \\\"ConvNet_IID\\\":\\n if data_name == \\\"combined\\\":\\n partition = []\\n for data_fold in data_folder:\\n partition.append(load_obj(os.path.join(data_fold, 'data_partition_IID_windows.pkl')))\\n else:\\n partition = load_obj(os.path.join(data_folder, 'data_partition_IID_windows.pkl'))\\n if data_name == \\\"SHHS\\\":\\n training_set = Dataset_IID_window_SHHS(partition['train'], data_folder)\\n validation_set = Dataset_IID_window_SHHS(partition['validation'], data_folder)\\n elif data_name == \\\"snooze\\\":\\n training_set = Dataset_IID_window(partition['train'], data_folder)\\n validation_set = Dataset_IID_window(partition['validation'], data_folder)\\n elif data_name == \\\"philips\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"HMC\\\":\\n print(\\\"{} not implemented data\\\".format(data_name))\\n exit()\\n elif data_name == \\\"combined\\\":\\n training_set = ConcatDataset(\\n Dataset_IID_window(partition[0]['train'], data_folder[0]),\\n Dataset_IID_window_SHHS(partition[1]['train'], data_folder[1]))\\n validation_set = ConcatDataset(\\n Dataset_IID_window(partition[0]['validation'], data_folder[0]),\\n Dataset_IID_window_SHHS(partition[1]['validation'], data_folder[1]))\\n else:\\n print(\\\"{} wrong data for dataloader\\\".format(data_name))\\n exit()\\n\\n else:\\n print(\\\"{} wrong model for dataloader\\\".format(model_name))\\n exit()\\n\\n return training_set, validation_set\",\n \"def split_reco_train_test(\\n X,\\n split_type = \\\"separated\\\",\\n users_test_fraction = 0.1,\\n max_test_users = 10000,\\n items_test_fraction = 0.3,\\n min_items_pool = 2,\\n min_pos_test = 1,\\n consider_cold_start = False,\\n seed = 1\\n):\\n if (max_test_users is None) or (max_test_users == 0):\\n max_test_users = X.shape[0]\\n \\n assert max_test_users > 0\\n assert seed >= 0\\n assert min_pos_test >= 0\\n assert min_items_pool >= 0\\n \\n max_test_users = int(max_test_users)\\n seed = int(seed)\\n min_pos_test = int(min_pos_test)\\n min_items_pool = int(min_items_pool)\\n \\n if users_test_fraction is not None:\\n assert (users_test_fraction > 0) and (users_test_fraction < 1)\\n users_test_fraction = float(users_test_fraction)\\n\\n assert (items_test_fraction > 0) and (items_test_fraction < 1)\\n items_test_fraction = float(items_test_fraction)\\n\\n assert split_type in (\\\"all\\\", \\\"separated\\\", \\\"joined\\\")\\n\\n consider_cold_start = bool(consider_cold_start)\\n\\n\\n if min_pos_test >= X.shape[1]:\\n raise ValueError(\\\"'min_pos_test' must be smaller than the number of columns in 'X'.\\\")\\n\\n if min_items_pool >= X.shape[1]:\\n raise ValueError(\\\"'min_items_pool' must be smaller than the number of columns in 'X'.\\\")\\n\\n if split_type != \\\"all\\\":\\n if X.shape[0] < 2:\\n raise ValueError(\\\"'X' has less than 2 rows.\\\")\\n if users_test_fraction is not None:\\n n_users_take = X.shape[0] * users_test_fraction\\n if n_users_take < 1:\\n warn(\\\"Desired fraction of test users implies <1, will select 1 user.\\\")\\n n_users_take = 1\\n n_users_take = round(n_users_take)\\n n_users_take = min(n_users_take, max_test_users)\\n else:\\n if max_test_users > X.shape[0]:\\n warn(\\\"'max_test_users' is larger than number of users. Will take all.\\\")\\n n_users_take = min(max_test_users, X.shape[0])\\n\\n if not isspmatrix_csr(X):\\n X = csr_matrix(X)\\n else:\\n X.sort_indices()\\n if (not X.shape[0]) or (not X.shape[1]):\\n raise ValueError(\\\"'X' cannot be empty.\\\")\\n if X.dtype not in (np.float32, np.float64):\\n X = X.astype(np.float64)\\n if not X.data.shape[0]:\\n raise ValueError(\\\"'X' contains no non-zero entries.\\\")\\n X = _cast_indices_to_int32(X)\\n\\n if split_type == \\\"all\\\":\\n return cpp_funs.split_csr_selected_users(X, items_test_fraction, seed)\\n elif split_type == \\\"separated\\\":\\n return cpp_funs.split_csr_separated_users(\\n X,\\n n_users_take,\\n items_test_fraction,\\n consider_cold_start,\\n min_items_pool,\\n min_pos_test,\\n True,\\n seed\\n )\\n elif split_type == \\\"joined\\\":\\n return cpp_funs.split_csr_separated_users(\\n X,\\n n_users_take,\\n items_test_fraction,\\n consider_cold_start,\\n min_items_pool,\\n min_pos_test,\\n False,\\n seed\\n )\\n else:\\n raise ValueError(\\\"Unexpected error.\\\")\",\n \"def prepareSplitClassifier(df, models, choice):\\n\\n\\n def classificationOutput(clf, X, Y):\\n \\\"\\\"\\\"\\n Fit the model and print the classification results\\n - confusion_matrix\\n - avg scores etc\\n \\\"\\\"\\\"\\n n_samples = 36\\n\\n print \\\"\\\\n\\\\nClassifier: \\\\n %s\\\" % (clf)\\n print \\\"#\\\" * 79\\n # classifier_gnb = naive_bayes.GaussianNB() # initiating the classifier\\n\\n clf.fit(X[:n_samples], Y[:n_samples]) # train on first n_samples and test on last 10\\n\\n expected = Y[n_samples:]\\n predicted = clf.predict(X[n_samples:])\\n print(\\\"Classification report:\\\\n%s\\\\n\\\" % (metrics.classification_report(expected, predicted)))\\n print(\\\"\\\\nConfusion matrix:\\\\n%s\\\" % metrics.confusion_matrix(expected, predicted))\\n\\n\\n\\n\\n def splitclassify(cDf):\\n \\\"\\\"\\\"\\n Given the dataframe combined with equal fair and unfair apps,\\n classify them\\n \\\"\\\"\\\"\\n cDf = cDf.reindex(np.random.permutation(cDf.index)) # shuffle the dataframe\\n featCols = set(cDf.columns)\\n featCols.remove('appLabel')\\n\\n features = cDf[list(featCols)].astype('float')\\n\\n ## Scale the features to a common range\\n min_max_scaler = preprocessing.MinMaxScaler()\\n X = min_max_scaler.fit_transform(features.values)\\n\\n Y = cDf['appLabel'].values\\n\\n\\n if choice == 'all':\\n for key in models:\\n classifier = models[key]\\n classificationOutput(classifier, X, Y)\\n else:\\n if choice in models:\\n classifier = models[choice]\\n classificationOutput(classifier, X, Y)\\n else:\\n print \\\"Incorrect Choice\\\"\\n\\n\\n\\n fairDf = df[df['appLabel'] == False]\\n unfairDf = df[df['appLabel'] == True]\\n\\n\\n # calculate total possible splits of fair data frame relatie to\\n # size of unfair dataframe\\n splits = len(fairDf) // len(unfairDf)\\n\\n for i in range(splits):\\n clDf = fairDf[i : i+len(unfairDf)].append(unfairDf)\\n\\n # print fairDf.values, unfairDf.values\\n print \\\"Classifying %d th split of fair apps with unfair app\\\" % (i)\\n print \\\"-\\\" * 79\\n splitclassify(clDf)\\n print \\\"\\\\n\\\\n\\\"\",\n \"def create_data_generators(shuffle=True, novelty_type='normal', item_to_include='None',\\n scale_level=1):\\n\\n total_noi_i = 10 # Number of processed images from one environemnt i\\n noe = 1 # Numer of environments\\n n_p = 32 # Patch size, patch --> n_p x n_p\\n\\n novelty = novelty_type\\n datasets = []\\n\\n for i in range(noe):\\n\\n # Load only images of the environment which includes images of the stated novel item.\\n if item_to_include is not None and novelty == 'novel_item':\\n dataset_env_i = PolycraftDatasetWithSpecificItem(\\n nov_type=novelty, noi=total_noi_i, env_idx=i, p_size=n_p, scale_factor=scale_level,\\n item_name=item_to_include)\\n datasets.append(dataset_env_i)\\n # We only process the one environment with the item (maybe change this\\n # if we have more than one environement per novel_item!?)\\n break\\n\\n # No specific item given which should be included.\\n else:\\n dataset_env_i = PolycraftDatasetNoSpecificItem(\\n nov_type=novelty, noi=total_noi_i, env_idx=i, p_size=n_p, scale_factor=scale_level)\\n datasets.append(dataset_env_i)\\n\\n final_dataset = ConcatDataset(datasets)\\n\\n total_noi = len(final_dataset) # Total number of processed images from all datasets\\n\\n if(total_noi < 7):\\n print('Number of samples too small for splitting dataset in training-/valid-/test set.')\\n\\n train_noi = int(0.7 * total_noi) # Number of images used for training (70 %)\\n valid_noi = int(0.15 * total_noi) # Number of images used for validation (15 %)\\n test_noi = total_noi - train_noi - valid_noi # Number of images used for testing (15 %)\\n train_dataset, valid_dataset, test_dataset = torch.utils.data.random_split(\\n final_dataset, [train_noi, valid_noi, test_noi])\\n\\n train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True)\\n valid_loader = DataLoader(valid_dataset, batch_size=1, shuffle=True)\\n test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True)\\n\\n return train_loader, valid_loader, test_loader\",\n \"def model(classifier, data):\\n print(\\\"Beggining to test model\\\")\\n train, test = cross_validation.train_test_split(data, test_size=.30)\\n f,c = train[:,1:], train[:,0]\\n classifier.fit(f,c,False)\\n print(\\\"Score: \\\" + classifier.score(f,c))\\n print(\\\"Finished testing model\\\")\",\n \"def run_training(self, schema_params, export_model=False, output_model_dir=None):\\n # Log distributed execution context, which includes cluster configuration\\n logger.info(f\\\"Commencing {self.effect_name} training\\\")\\n logger.info(f\\\"Execution context : {self.execution_context}\\\")\\n\\n # Create partition_index_list\\n partition_index_list = self._get_partition_list()\\n logger.info(f\\\"This worker on work on the following list of partitions : {partition_index_list}\\\")\\n\\n # Sequentially train model on partitions\\n for partition_index in partition_index_list:\\n logger.info(f\\\"Commencing {self.effect_name} training for partition index : {partition_index}\\\")\\n\\n # Resolve partitioned data directory from raw path params from user\\n checkpoint_path = self._anchor_directory(\\n self.model.checkpoint_path,\\n partition_index)\\n training_data_dir = self._anchor_directory(self.model.training_data_dir,\\n partition_index)\\n validation_data_dir = self._anchor_directory(self.model.validation_data_dir,\\n partition_index) if self.model.validation_data_dir else None\\n\\n if is_empty_directory(training_data_dir):\\n logger.info(f\\\"{training_data_dir} is empty, no dataset to train on.\\\")\\n continue\\n # Train model\\n self.execution_context[constants.PARTITION_INDEX] = partition_index\\n self.model.train(training_data_dir=training_data_dir,\\n validation_data_dir=validation_data_dir,\\n metadata_file=self.model.metadata_file,\\n checkpoint_path=checkpoint_path,\\n execution_context=self._prepare_training_context(partition_index),\\n schema_params=schema_params)\\n\\n # Chief should export model\\n is_chief = self.execution_context[constants.IS_CHIEF]\\n if export_model and is_chief:\\n logger.info(f\\\"Exporting model to directory : {output_model_dir}\\\")\\n self.model.export(output_model_dir=output_model_dir)\",\n \"def main(args, base_dir):\\n for i in range(args.n_training):\\n # value of the next seed\\n seed = args.seed + i\\n\\n # The time when the current experiment started.\\n now = strftime(\\\"%Y-%m-%d-%H:%M:%S\\\")\\n\\n # Create a save directory folder (if it doesn't exist).\\n if args.log_dir is not None:\\n dir_name = args.log_dir\\n else:\\n dir_name = os.path.join(base_dir, '{}/{}'.format(\\n args.env_name, now))\\n ensure_dir(dir_name)\\n\\n # Get the policy class.\\n if args.alg == \\\"TD3\\\":\\n from hbaselines.multiagent.td3 import MultiFeedForwardPolicy\\n elif args.alg == \\\"SAC\\\":\\n from hbaselines.multiagent.sac import MultiFeedForwardPolicy\\n elif args.alg == \\\"PPO\\\":\\n from hbaselines.multiagent.ppo import MultiFeedForwardPolicy\\n elif args.alg == \\\"TRPO\\\":\\n from hbaselines.multiagent.trpo import MultiFeedForwardPolicy\\n else:\\n raise ValueError(\\\"Unknown algorithm: {}\\\".format(args.alg))\\n\\n # Get the hyperparameters.\\n hp = get_hyperparameters(args, MultiFeedForwardPolicy)\\n\\n # add the seed for logging purposes\\n params_with_extra = hp.copy()\\n params_with_extra['seed'] = seed\\n params_with_extra['env_name'] = args.env_name\\n params_with_extra['policy_name'] = \\\"MultiFeedForwardPolicy\\\"\\n params_with_extra['algorithm'] = args.alg\\n params_with_extra['date/time'] = now\\n\\n # Add the hyperparameters to the folder.\\n with open(os.path.join(dir_name, 'hyperparameters.json'), 'w') as f:\\n json.dump(params_with_extra, f, sort_keys=True, indent=4)\\n\\n run_exp(\\n env=args.env_name,\\n policy=MultiFeedForwardPolicy,\\n hp=hp,\\n dir_name=dir_name,\\n evaluate=args.evaluate,\\n seed=seed,\\n eval_interval=args.eval_interval,\\n log_interval=args.log_interval,\\n save_interval=args.save_interval,\\n initial_exploration_steps=args.initial_exploration_steps,\\n ckpt_path=args.ckpt_path,\\n )\",\n \"def __split_dataset(self):\\n self.train, self.valid, _, _ = train_test_split(self.data, self.data, test_size=0.2)\\n self.valid, self.test, _, _ = train_test_split(self.valid, self.valid, test_size=0.5)\",\n \"def compute_strategy(self, strategy):\\n if strategy == DataLoaderStrategies.OneRecordPerLine:\\n self.one_record_per_line(self.res_predictions, self.dir_predictions)\\n self.one_record_per_line(self.res_references, self.dir_references)\\n elif strategy == DataLoaderStrategies.OneRecordPerFile:\\n self.one_record_per_file(self.res_predictions, self.dir_predictions)\\n self.one_record_per_file(self.res_references, self.dir_references)\\n return\",\n \"def run_trainig_and_testing(company = \\\"FB\\\", training_window = 60,\\n trainig_period_y=8, testing_period_y=1,\\n prediction_day=dt.datetime.now() ):\\n # Load data for model\\n training_data, testing_data = fetch_data(company, trainig_period_y, testing_period_y, prediction_day)\\n # prepare data\\n # scaler is object which will scale whole series values to defined feature_range interval\\n scaler = MinMaxScaler(feature_range=(0,1))\\n # we are insterested only in the closing values\\n # optionaly we can use AdjClose -> adjusted for splits\\n scaled_data = scaler.fit_transform(training_data['Close'].values.reshape(-1,1))\\n\\n # x is our learning data\\n x_train, y_train = create_training_tensors(training_window, scaled_data)\\n\\n # build the model\\n model = create_model((x_train.shape[1], 1))\\n model.fit(x_train, y_train, epochs=5, batch_size=32)\\n\\n # for future we can save the model here and load for future\\n\\n \\\"\\\"\\\"\\n TESTING MODEL ACCURACY\\n \\\"\\\"\\\"\\n\\n # load test data\\n\\n tst_start_dt = dt.datetime(2020,1,1)\\n tst_end_dt = dt.datetime(2021,1,1)\\n\\n\\n actual_prices = testing_data['Close'].values\\n total_dataset = pd.concat((training_data['Close'], testing_data['Close']), axis=0)\\n\\n model_inputs = total_dataset[len(total_dataset) - len(testing_data) - training_window:].values\\n model_inputs = model_inputs.reshape(-1,1)\\n model_inputs = scaler.fit_transform(model_inputs)\\n\\n # make prediction on test data\\n\\n x_test, y_test = create_training_tensors(training_window, model_inputs)\\n\\n predicted_prices = model.predict(x_test)\\n # predicted prices are scaled to (0-1) so we need to rescale them to actual prices\\n predicted_prices = scaler.inverse_transform(predicted_prices)\\n\\n plot_actual_vs_predicted(predicted_prices,actual_prices, company,\\n x_labels=[date.strftime(\\\"%d-%m-%y\\\") for date in testing_data.index] )\\n\\n # predict next day\\n real_data = [model_inputs[len(model_inputs) + 1 - training_window: len(model_inputs)+1, 0]]\\n real_data = np.array(real_data)\\n real_data = np.reshape(real_data, (real_data.shape[0], real_data.shape[1], 1))\\n print(scaler.inverse_transform(real_data[-1]))\\n\\n prediction = model.predict(real_data)\\n prediction = scaler.inverse_transform(prediction)\\n print(f\\\"Next day value is: {prediction}\\\")\\n\\n print(\\\"===================================\\\")\\n print(model.summary())\\n print(\\\"===================================\\\")\\n print(\\\"Evaluating model\\\")\\n result = model.evaluate(x_test, y_test)\\n print(dict(zip(model.metrics_names, result)))\\n\\n\\n # TODO\\n # experiment with next days predictions\",\n \"def _test_train_partition(self, sent_partition_size):\\n\\n self._train_data_partitioned = self._partition_dataset(\\n unpartitioned_dataset=self._train_data,\\n sent_partition_size=sent_partition_size\\n )\\n\\n self._test_data_partitioned = self._partition_dataset(\\n unpartitioned_dataset=self._test_data,\\n sent_partition_size=sent_partition_size\\n )\",\n \"def _split_data(self):\\n\\n # Set training data\\n self.train_data = torchvision.datasets.ImageFolder(\\n os.path.join(self.path, 'train'),\\n transform=self._transform()\\n )\\n self.classes = self.train_data.classes\\n\\n # Set validation data\\n self.val_data = torchvision.datasets.ImageFolder(\\n os.path.join(self.path, 'test'),\\n transform=self._transform(train=False)\\n )\",\n \"def construct_test_model(self):\\n # Set the placeholder for the input episode\\n self.inputa = tf.placeholder(tf.float32)\\n self.inputb = tf.placeholder(tf.float32)\\n self.labela = tf.placeholder(tf.float32)\\n self.labelb = tf.placeholder(tf.float32)\\n\\n with tf.variable_scope('meta-test-model', reuse=None) as training_scope: \\n # construct the model weights \\n self.ss_weights = ss_weights = self.construct_resnet_ss_weights()\\n self.weights = weights = self.construct_resnet_weights()\\n self.fc_weights = fc_weights = self.construct_fc_weights()\\n\\n # Load test base epoch number from FLAGS\\n num_updates = FLAGS.test_base_epoch_num\\n\\n def task_metalearn(inp, reuse=True):\\n \\\"\\\"\\\"The function to process one episode in a meta-batch.\\n Args:\\n inp: the input episode.\\n reuse: whether reuse the variables for the normalization.\\n Returns:\\n A serious outputs like losses and accuracies.\\n \\\"\\\"\\\"\\n # Seperate inp to different variables\\n inputa, inputb, labela, labelb = inp\\n # Generate empty list to record accuracies\\n accb_list = []\\n\\n # Embed the input images to embeddings with ss weights\\n emb_outputa = self.forward_resnet(inputa, weights, ss_weights, reuse=reuse)\\n emb_outputb = self.forward_resnet(inputb, weights, ss_weights, reuse=True)\\n\\n # This part is similar to the meta-train function, you may refer to the comments above\\n outputa = self.forward_fc(emb_outputa, fc_weights)\\n lossa = self.loss_func(outputa, labela) \\n grads = tf.gradients(lossa, list(fc_weights.values()))\\n gradients = dict(zip(fc_weights.keys(), grads))\\n fast_fc_weights = dict(zip(fc_weights.keys(), [fc_weights[key] - \\\\\\n self.update_lr*gradients[key] for key in fc_weights.keys()]))\\n outputb = self.forward_fc(emb_outputb, fast_fc_weights)\\n accb = tf.contrib.metrics.accuracy(tf.argmax(tf.nn.softmax(outputb), 1), tf.argmax(labelb, 1))\\n accb_list.append(accb)\\n \\n for j in range(num_updates - 1):\\n lossa = self.loss_func(self.forward_fc(emb_outputa, fast_fc_weights), labela)\\n grads = tf.gradients(lossa, list(fast_fc_weights.values()))\\n gradients = dict(zip(fast_fc_weights.keys(), grads))\\n fast_fc_weights = dict(zip(fast_fc_weights.keys(), [fast_fc_weights[key] - \\\\\\n self.update_lr*gradients[key] for key in fast_fc_weights.keys()]))\\n outputb = self.forward_fc(emb_outputb, fast_fc_weights)\\n accb = tf.contrib.metrics.accuracy(tf.argmax(tf.nn.softmax(outputb), 1), tf.argmax(labelb, 1))\\n accb_list.append(accb)\\n\\n lossb = self.loss_func(outputb, labelb)\\n\\n task_output = [lossb, accb, accb_list]\\n\\n return task_output\\n\\n if FLAGS.norm is not 'None':\\n unused = task_metalearn((self.inputa[0], self.inputb[0], self.labela[0], self.labelb[0]), False)\\n\\n out_dtype = [tf.float32, tf.float32, [tf.float32]*num_updates]\\n\\n result = tf.map_fn(task_metalearn, elems=(self.inputa, self.inputb, self.labela, self.labelb), \\\\\\n dtype=out_dtype, parallel_iterations=FLAGS.meta_batch_size)\\n lossesb, accsb, accsb_list = result\\n\\n self.metaval_total_loss = total_loss = tf.reduce_sum(lossesb)\\n self.metaval_total_accuracy = total_accuracy = tf.reduce_sum(accsb)\\n self.metaval_total_accuracies = total_accuracies =[tf.reduce_sum(accsb_list[j]) for j in range(num_updates)]\",\n \"def make_splits(input_pkl, test_split=0.1, val_split=0.1):\\n if (test_split > 1) or (val_split > 1) or (test_split + val_split > 1) or (test_split <= 0) or (val_split <= 0):\\n logging.warning('Check the input for make splits, quitting')\\n exit()\\n\\n main_dict = load_pickle(input_pkl)\\n data, labels = main_dict['data'], main_dict['labels']\\n idx_arr = np.random.choice(len(data), len(data))\\n data, labels = data[idx_arr], labels[idx_arr]\\n print(len(data[0][-1]))\\n # Find the split sizes\\n val_split = int(len(data) * val_split)\\n test_split = val_split + int(len(data) * test_split)\\n\\n # Make and save the splits\\n save_pickle({'data': data[:val_split], 'labels': labels[:val_split]}, 'data/val.pkl')\\n save_pickle({'data': data[val_split:test_split], 'labels': labels[val_split:test_split]}, 'data/test.pkl')\\n save_pickle({'data': data[test_split:], 'labels': labels[test_split:]}, 'data/train.pkl')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67197025","0.6372317","0.6326024","0.62784594","0.62007445","0.6187098","0.61727315","0.61609745","0.6150832","0.61274564","0.6109672","0.60908484","0.60526675","0.60400504","0.5990867","0.59906036","0.59859765","0.5970628","0.5950032","0.5942936","0.5933349","0.5925814","0.5925297","0.5916644","0.5913775","0.5902966","0.5898248","0.58884454","0.588773","0.58804816","0.58642906","0.5863265","0.5860488","0.5853281","0.58520436","0.58497775","0.58456975","0.58382815","0.5827297","0.5823974","0.5821267","0.5815358","0.5813277","0.5812545","0.5803977","0.57958746","0.5786164","0.57836455","0.5775122","0.5772087","0.5750619","0.5746191","0.5738956","0.57372427","0.57366776","0.57364535","0.573471","0.57344925","0.57292765","0.5728624","0.5725084","0.5721469","0.5721056","0.57188463","0.5717269","0.5711487","0.5704796","0.5703867","0.5694832","0.56893796","0.568596","0.56832045","0.56754893","0.56687844","0.56685174","0.5664662","0.565216","0.5650261","0.5648547","0.56455714","0.56454647","0.56436527","0.5639317","0.5637173","0.5636885","0.5628495","0.56241363","0.5623275","0.56156474","0.5614974","0.5614034","0.56086016","0.56071067","0.5606387","0.5604858","0.5604078","0.5593985","0.5582342","0.5580516","0.5579477"],"string":"[\n \"0.67197025\",\n \"0.6372317\",\n \"0.6326024\",\n \"0.62784594\",\n \"0.62007445\",\n \"0.6187098\",\n \"0.61727315\",\n \"0.61609745\",\n \"0.6150832\",\n \"0.61274564\",\n \"0.6109672\",\n \"0.60908484\",\n \"0.60526675\",\n \"0.60400504\",\n \"0.5990867\",\n \"0.59906036\",\n \"0.59859765\",\n \"0.5970628\",\n \"0.5950032\",\n \"0.5942936\",\n \"0.5933349\",\n \"0.5925814\",\n \"0.5925297\",\n \"0.5916644\",\n \"0.5913775\",\n \"0.5902966\",\n \"0.5898248\",\n \"0.58884454\",\n \"0.588773\",\n \"0.58804816\",\n \"0.58642906\",\n \"0.5863265\",\n \"0.5860488\",\n \"0.5853281\",\n \"0.58520436\",\n \"0.58497775\",\n \"0.58456975\",\n \"0.58382815\",\n \"0.5827297\",\n \"0.5823974\",\n \"0.5821267\",\n \"0.5815358\",\n \"0.5813277\",\n \"0.5812545\",\n \"0.5803977\",\n \"0.57958746\",\n \"0.5786164\",\n \"0.57836455\",\n \"0.5775122\",\n \"0.5772087\",\n \"0.5750619\",\n \"0.5746191\",\n \"0.5738956\",\n \"0.57372427\",\n \"0.57366776\",\n \"0.57364535\",\n \"0.573471\",\n \"0.57344925\",\n \"0.57292765\",\n \"0.5728624\",\n \"0.5725084\",\n \"0.5721469\",\n \"0.5721056\",\n \"0.57188463\",\n \"0.5717269\",\n \"0.5711487\",\n \"0.5704796\",\n \"0.5703867\",\n \"0.5694832\",\n \"0.56893796\",\n \"0.568596\",\n \"0.56832045\",\n \"0.56754893\",\n \"0.56687844\",\n \"0.56685174\",\n \"0.5664662\",\n \"0.565216\",\n \"0.5650261\",\n \"0.5648547\",\n \"0.56455714\",\n \"0.56454647\",\n \"0.56436527\",\n \"0.5639317\",\n \"0.5637173\",\n \"0.5636885\",\n \"0.5628495\",\n \"0.56241363\",\n \"0.5623275\",\n \"0.56156474\",\n \"0.5614974\",\n \"0.5614034\",\n \"0.56086016\",\n \"0.56071067\",\n \"0.5606387\",\n \"0.5604858\",\n \"0.5604078\",\n \"0.5593985\",\n \"0.5582342\",\n \"0.5580516\",\n \"0.5579477\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6798001"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":19499,"cells":{"query":{"kind":"string","value":"Returns parameters which should be used in one iteration of the testing process."},"document":{"kind":"string","value":"def set_model_parameters(test_type: str, parameter_value: float):\n # assigning default parameters for the model\n som_width = Config.som_width\n som_height = Config.som_height\n n_iter = Config.n_iter\n sigma = Config.sigma\n learning_rate = Config.learning_rate\n\n # assign testing parameter to the model parameter basing on test_parameter value\n if test_type == 'map_size':\n som_width = parameter_value\n som_height = parameter_value\n if test_type == 'n_iter':\n n_iter = parameter_value\n if test_type == 'learning_rate':\n learning_rate = parameter_value / 1000\n if test_type == 'sigma':\n sigma = parameter_value / 100\n return som_width, som_height, n_iter, sigma, learning_rate"},"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_test_params(cls, parameter_set=\"default\"):\n params1 = {\n \"n_clusters\": 3,\n \"n_init\": 2,\n \"max_iter\": 2,\n \"tol\": 1e-3,\n \"verbose\": False,\n \"random_state\": 2,\n }\n params2 = {\n \"n_clusters\": 2,\n \"init_algorithm\": \"random\",\n \"n_init\": 1,\n \"max_iter\": 1,\n \"tol\": 1e-4,\n \"verbose\": False,\n \"random_state\": 1,\n }\n return [params1, params2]","def get_test_params(cls, parameter_set=\"default\"):\n params = {\"state_dim\": 2}\n return params","def get_test_params(cls, parameter_set=\"default\"):\n params = {\"state_dim\": 2}\n return params","def get_params(self):\n return {'threshold': self.threshold,\n 'subsample': self.subsample,\n 'estimator': self.estimator,\n 'n_folds': self.n_folds,\n 'stratify': self.stratify,\n 'random_state': self.random_state,\n 'n_jobs': self.n_jobs}","def get_test_params(cls, parameter_set=\"default\"):\n params1 = {\"low\": 8, \"high\": 26, \"drift\": False}\n params2 = {}\n return [params1, params2]","def get_params(self):","def get_test_params(cls, parameter_set=\"default\"):\n params1 = {}\n params2 = {\"p_threshold\": 0.1, \"regression\": \"ctt\", \"nlags\": 5}\n\n return [params1, params2]","def parameters(self):","def test_parameters(self):\n self.assert_initialize_driver()\n #reply = self.driver_client.cmd_dvr('get_resource', Parameter.ALL)\n #self.assert_driver_parameters(reply, verify_sample_interval=True)","def get_test_params(cls, parameter_set=\"default\"):\n params1 = {}\n params2 = {\n \"p_threshold\": 0.1,\n \"maxlag\": 5,\n \"regression\": \"ctt\",\n \"autolag\": \"t-stat\",\n }\n\n return [params1, params2]","def get_test_params(cls, parameter_set=\"default\"):\n params = {\n \"default_fc_parameters\": \"efficient\",\n \"disable_progressbar\": True,\n \"show_warnings\": False,\n \"fdr_level\": 0.01,\n }\n return params","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=1,\n task=30,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.1,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"tiled_coarse\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\"Error in {}\".format(key))\n self.assertEqual(self.tree.get_job()[0], 1)\n self.assertEqual(self.tree.get_job()[1], 30)","def parameters(self):\n pass","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=3,\n task=3,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.1,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"none\",\n coarse_map_x=13,\n coarse_map_y=13,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\"Error in {}\".format(key))\n self.assertEqual(self.tree.get_job()[0], 3)\n self.assertEqual(self.tree.get_job()[1], 3)","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=1,\n task=29,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.1,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"none\",\n coarse_map_x=13,\n coarse_map_y=13,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"tiled_fine\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\"Error in {}\".format(key))\n self.assertEqual(self.tree.get_job()[0], 1)\n self.assertEqual(self.tree.get_job()[1], 29)","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=1,\n task=1,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=1.0,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"null\",\n coarse_map_x=20,\n coarse_map_y=20,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"null\",\n fine_map_x=10,\n fine_map_y=10,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=10,\n grid_y=10,\n sample_x=10,\n sample_y=10,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"fat-tail\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"infinite\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key])\n self.assertEqual(self.tree.get_job()[0], 1)\n self.assertEqual(self.tree.get_job()[1], 1)","def read_test_parameters():\n DBHelperRaw.get_test_data_bunch() # return DBHelper.test_exposure_sequences \n return DBHelperRaw.test_exposure_sequences","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=2,\n task=2,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=1.0,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"null\",\n coarse_map_x=20,\n coarse_map_y=20,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"null\",\n fine_map_x=10,\n fine_map_y=10,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=10,\n grid_y=10,\n sample_x=10,\n sample_y=10,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=1.0,\n cutoff=0.0,\n landscape_type=\"infinite\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\"Error in {}\".format(key))\n self.assertEqual(self.tree.get_job()[0], 2)\n self.assertEqual(self.tree.get_job()[1], 2)","def get_params(self):\n pass","def default_indefinite_iteration_parameters():\n tol = 10 ** -8\n err = 1\n counter = 1\n return tol, err, counter","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=4,\n task=4,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.01,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"fat-tail\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(\n params[key],\n actual_sim_parameters[key],\n msg=\"Error in {}: {}!={}\".format(key, params[key], actual_sim_parameters[key]),\n )\n self.assertEqual(self.tree.get_job()[0], 4, msg=\"Job number not stored correctly.\")\n self.assertEqual(self.tree.get_job()[1], 4, msg=\"Job number not stored correctly.\")","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=5,\n task=4,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=1.0,\n deme=0.25,\n sample_size=1.0,\n max_time=3600.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(\n params[key],\n actual_sim_parameters[key],\n msg=\"Error in {}: {}!={}\".format(key, params[key], actual_sim_parameters[key]),\n )\n self.assertEqual(self.tree.get_job()[0], 5, msg=\"Seed not stored correctly.\")\n self.assertEqual(self.tree.get_job()[1], 4, msg=\"Job number not stored correctly.\")","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=7,\n task=4,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=1.0,\n deme=0.01,\n sample_size=1.5,\n max_time=3600.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(\n params[key],\n actual_sim_parameters[key],\n msg=\"Error in {}: {}!={}\".format(key, params[key], actual_sim_parameters[key]),\n )\n self.assertEqual(self.tree.get_job()[0], 7, msg=\"Seed not stored correctly.\")\n self.assertEqual(self.tree.get_job()[1], 4, msg=\"Job number not stored correctly.\")","def get_parameters(self):\n d = Algorithm.get_parameters(self)\n d.update({\n 'M': d.pop('population_size', self.population_size),\n 'num_tests': self.num_tests,\n 'num_searches': self.num_searches,\n 'num_searches_best': self.num_searches_best,\n 'bonus1': self.bonus1,\n 'bonus2': self.bonus2,\n 'num_enabled': self.num_enabled,\n 'local_searches': self.local_searches\n })\n return d","def _get_params_for_run(self):\n if self._optimizer is not None:\n return self._optimizer.get_next_params()\n else:\n return self._params","def get_params(self):\n params = {}\n for step in self.steps:\n params[step[0]] = step[1].get_params()\n return params","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=2,\n task=5,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=1.0,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"null\",\n coarse_map_x=20,\n coarse_map_y=20,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"null\",\n fine_map_x=10,\n fine_map_y=10,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=10,\n grid_y=10,\n sample_x=10,\n sample_y=10,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key])\n # self.assertDictEqual(params, actual_sim_parameters)\n self.assertEqual(self.tree.get_job()[0], 2)\n self.assertEqual(self.tree.get_job()[1], 5)","def parameters(self):\n #print \"in instrument.parameter()\"\n return self._params","def getParameters(self):\n\t\td = AdaptiveBatAlgorithm.getParameters(self)\n\t\td.update({\n\t\t\t'A_l': self.A_l,\n\t\t\t'A_u': self.A_u,\n\t\t\t'r_l': self.r_l,\n\t\t\t'r_u': self.r_u,\n\t\t\t'tao_1': self.tao_1,\n\t\t\t'tao_2': self.tao_2\n\t\t})\n\t\treturn d","def get_test_params(cls, parameter_set=\"default\"):\n features_to_calc = [\n \"dim_0__quantile__q_0.6\",\n \"dim_0__longest_strike_above_mean\",\n \"dim_0__variance\",\n ]\n\n return [\n {\n \"disable_progressbar\": True,\n \"show_warnings\": False,\n \"default_fc_parameters\": \"minimal\",\n },\n {\n \"disable_progressbar\": True,\n \"show_warnings\": False,\n \"kind_to_fc_parameters\": features_to_calc,\n },\n ]","def get_test_params(cls, parameter_set=\"default\"):\n from sktime.forecasting.naive import NaiveForecaster\n\n params1 = {\n \"forecasters\": [\n (\"Naive_mean\", NaiveForecaster(strategy=\"mean\")),\n (\"Naive_last\", NaiveForecaster(strategy=\"last\")),\n (\"Naive_drift\", NaiveForecaster(strategy=\"drift\")),\n ],\n \"selected_forecaster\": \"Naive_mean\",\n }\n params2 = {\n \"forecasters\": [\n NaiveForecaster(strategy=\"mean\"),\n NaiveForecaster(strategy=\"last\"),\n NaiveForecaster(strategy=\"drift\"),\n ],\n }\n return [params1, params2]","def get_test_params(cls, parameter_set=\"default\"):\n # non-default distance and algorithm\n params1 = {\"distance\": \"euclidean\"}\n\n # testing distance_params\n params2 = {\"distance\": \"dtw\", \"distance_params\": {\"epsilon\": 0.1}}\n\n # testing that callables/classes can be passed\n from sktime.dists_kernels.compose_tab_to_panel import AggrDist\n\n dist = AggrDist.create_test_instance()\n params3 = {\"distance\": dist}\n\n return [params1, params2, params3]","def test_get_params():\n ejob = EvaluationJob({},\n CLASSIFIERS,\n cache_path=CACHE_PATH)\n\n assert len(ejob.get_params()) > 0","def testSimulationParametersStored(self):\n simulation_parameters = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=6,\n task=6,\n output_dir=\"output\",\n speciation_rate=0.5,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.1,\n max_time=10.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"set\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in simulation_parameters.keys():\n self.assertEqual(simulation_parameters[key], actual_sim_parameters[key])\n self.assertDictEqual(simulation_parameters, actual_sim_parameters)\n # self.assertListEqual(simulation_parameters, actual_sim_parameters)\n self.assertEqual(self.tree.get_job()[0], 6)\n self.assertEqual(self.tree.get_job()[1], 6)","def getParams(self):\n return self.trainError, self.trainAcc, self.w","def parameters(self):\n return self._params","def test_get_measure_parameters(self):\n pass","def _generate_params(self):\n return {\n 'lis_outcome_service_url': self.lis_outcome_service_url,\n 'lis_result_sourcedid': self.lis_result_sourcedid,\n 'oauth_consumer_key': self.key\n }","def next_parameters(self):\n\n if self.number_of_runs == -1 or self.runs_performed < self.number_of_runs:\n self.runs_performed += 1\n _log.debug('%d runs performed (calls to `next_parameters()`)' % self.runs_performed)\n else:\n _log.info('No more parameters to test in the database.')\n return None\n \n records = self.db.get_table()\n _log.debug('Retrieved %d parameters' % len(records))\n\n # Do we have a last-test in the config file\n if self.config and \"last-test\" in self.config and self.config[\"last-test\"]:\n _log.info('Using `last-test` with id=\"%s\" from config.txt' %\n str(self.config[\"last-test\"]))\n for i in range(0, len(records)):\n if (\n str(self.config.config[\"last-test\"]) == str(records[i][\"id\"]) and\n records[i][\"status\"] != \"successful\"\n ):\n records[i][\"status\"] = \"in progress\"\n if \"start-time\" in records[i]:\n records[i][\"start-time\"] = \\\n datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')\n if \"performed-by\" in records[i]:\n records[i][\"performed-by\"] = self.performed_by\n\n self.db.update_row(i, records[i])\n\n return records[i]\n\n for i in range(0, len(records)):\n if not len(records[i][\"status\"]):\n if (\n 'computer-strength' in records[i] and \n self.computer_strength < int(records[i][\"computer-strength\"])\n ):\n continue\n \n records[i][\"status\"] = \"in progress\"\n if \"start-time\" in records[i]:\n records[i][\"start-time\"] = \\\n datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')\n if \"performed-by\" in records[i]:\n records[i][\"performed-by\"] = self.performed_by\n self.db.update_row(i, records[i])\n\n # Save id to local cache\n if self.config:\n self.config.update(key='last-test', value=str(records[i][\"id\"]))\n\n return records[i]\n\n return None","def get_params(self):\n raise NotImplementedError","def get_test_params(cls, parameter_set=\"default\"):\n from sktime.forecasting.compose._reduce import DirectReductionForecaster\n from sktime.forecasting.naive import NaiveForecaster\n\n # univariate case\n FORECASTER = NaiveForecaster()\n params = [{\"forecasters\": [(\"f1\", FORECASTER), (\"f2\", FORECASTER)]}]\n\n # test multivariate case, i.e., ensembling multiple variables at same time\n FORECASTER = DirectReductionForecaster.create_test_instance()\n params = params + [{\"forecasters\": [(\"f1\", FORECASTER), (\"f2\", FORECASTER)]}]\n\n return params","def get_params(self):\n return {'classifier': self.classifier,\n 'grid_param': self.grid_param,\n 'n_param_comb': self.n_param_comb,\n 'top_bagging': self.bagging,\n 'bagging_param': self.bagging_param,\n 'comb_seed': self.comb_seed}","def get_prob_params():\n prob = Namespace()\n prob.study_name = STUDY_NAME\n if IS_DEBUG:\n prob.num_trials = 3\n prob.max_capital = 10\n else:\n prob.num_trials = NUM_TRIALS\n prob.max_capital = MAX_CAPITAL\n # Common\n prob.time_distro = TIME_DISTRO\n prob.num_workers = NUM_WORKERS\n _study_params = {\n 'branin': ('synthetic/branin/config_mf.json',\n branin_mf, cost_branin_mf, 0.1, 0, 1),\n 'hartmann3_2': ('synthetic/hartmann3_2/config_mf.json',\n hartmann3_2_mf, cost_hartmann3_2_mf, 0.1, 0, 1),\n 'hartmann6_4': ('synthetic/hartmann6_4/config_mf.json',\n hartmann6_4_mf, cost_hartmann6_4_mf, 0.1, 0, 1),\n 'borehole_6': ('synthetic/borehole_6/config_mf.json',\n borehole_6_mf, cost_borehole_6_mf, 1, 0, 1),\n 'park2_4': ('synthetic/park2_4/config_mf.json',\n park2_4_mf, cost_park2_4_mf, 0.3, 0, 1),\n 'park2_3': ('synthetic/park2_3/config_mf.json',\n park2_3_mf, cost_park2_3_mf, 0.1, 0, 1),\n 'park1_3': ('synthetic/park1_3/config_mf.json',\n park1_3_mf, cost_park1_3_mf, 0.5, 0, 1),\n }\n (domain_config_file_suffix, raw_func, raw_fidel_cost_func, _fc_noise_scale,\n _initial_pool_size, _) = _study_params[prob.study_name]\n domain_config_file = os.path.join(DRAGONFLY_EXPERIMENTS_DIR, domain_config_file_suffix)\n # noisy\n prob.noisy_evals = NOISY_EVALS\n if NOISY_EVALS:\n noise_type = 'gauss'\n noise_scale = _fc_noise_scale\n else:\n noise_type = 'no_noise'\n noise_scale = None\n # Create domain, function_caller and worker_manager\n config = load_config_file(domain_config_file)\n func_caller = get_multifunction_caller_from_config(raw_func, config,\n raw_fidel_cost_func=raw_fidel_cost_func, noise_type=noise_type,\n noise_scale=noise_scale)\n # Set max_capital\n if hasattr(func_caller, 'fidel_cost_func'):\n prob.max_capital = prob.max_capital * \\\n func_caller.fidel_cost_func(func_caller.fidel_to_opt)\n else:\n prob.max_capital = prob.max_capital\n # Store everything in prob\n prob.func_caller = func_caller\n prob.worker_manager = SyntheticWorkerManager(prob.num_workers,\n time_distro='caller_eval_cost')\n prob.save_file_prefix = prob.study_name + ('-debug' if IS_DEBUG else '')\n prob.methods = METHODS\n prob.save_results_dir = SAVE_RESULTS_DIR\n prob.reporter = get_reporter('default')\n # evaluation options\n prob.evaluation_options = Namespace(prev_eval_points='none',\n initial_pool_size=_initial_pool_size)\n return prob","def _get_parameters(self):\n return None","def parameters(self):\n return self.trainer_parameters","def parameters(self):\n return self.trainer_parameters","def _get_parameters(self) -> list:\n return self.parameters","def random_parameters():\n res = dict()\n res[\"population_size\"] = random.randrange(2, 21)\n res[\"mutation_prob\"] = random.choice([0.02, 0.05, 0.10, 0.20, 0.30, 0.40, 0.50])\n res[\"crossover\"] = random.choice([True, False])\n res[\"selection\"] = random.choice([True, False])\n res[\"sigma\"] = random.choice([0.1, 0.25, 0.5, 1])\n res[\"crossover_method\"] = random.choice([\"single_swap\", \"uniform_swap\", \"arithmetic\"])\n res[\"selection_method\"] = random.choice([\"truncated\", \"fitness_based\", \"rank_based\"])\n res[\"best_rate\"] = random.choice([0.2, 0.3, 0.5])\n res[\"n_parents\"] = random.choice([2, 3, 4])\n res[\"elitism\"] = random.choice([True, False])\n return res","def getParameters(self):\n\n current_params = {'taux': self.taux, 'mu': self.mu, 'G': self.G, 'alpha_0': self.alpha_0,\n 'delta': self.delta, 'p': self.p, 'I0': self.I0, 'kparam': self.kparam}\n\n return (current_params)","def get_params_iter(self):\n return []","def params(self):\n return {'cfg': self.cfg,\n 'momentum': self.momentum,\n 'center': self.center,\n 'scale': self.scale,\n 'epsilon': self.epsilon,\n 'act_fn': self.act_fn}","def generate_params(self, randomize=True):\n pass","def get_fixed_params():\n fixed_params = {\n 'total_time_steps': 8 * 24,\n 'num_encoder_steps': 7 * 24,\n 'num_epochs': 100,\n 'early_stopping_patience': 5,\n 'multiprocessing_workers': 5\n }\n return fixed_params","def parameters(self):\n res = dict()\n res[\"population_size\"] = self.population_size\n res[\"mutation_prob\"] = self.mutation_prob\n res[\"crossover\"] = self.crossover\n res[\"selection\"] = self.selection\n res[\"sigma\"] = self.sigma\n res[\"crossover_method\"] = self.crossover_method\n res[\"selection_method\"] = self.selection_method\n res[\"best_rate\"] = self.best_rate\n res[\"n_parents\"] = self.n_parents\n res[\"model_parameters\"] = self.model.total_parameters()\n res[\"IDCT_from\"] = self.IDCT_from\n res[\"elitism\"] = self.elitism\n return res","def parameters(self):\n return {\"P\": self.P,\n \"T\": self.T}","def get_next_params(self) -> dict:\n params = {arg_name: caller() for arg_name, caller in self.parameters}\n return params","def parameters(self) -> Dict[str, Any]:\n return self.trainer_parameters","def parameters(self):\n return []","def getInitParams(self):\n paramDict = Distribution.getInitParams(self)\n paramDict['strategy'] = self.strategy\n paramDict['nPoints'] = self.nPoints\n return paramDict","def get_test_params(cls):\n from sktime.utils.validation._dependencies import _check_soft_dependencies\n\n params = [\n {\n \"bootstrap_transformer\": MovingBlockBootstrapTransformer(),\n \"forecaster\": MockForecaster(),\n },\n ]\n\n # the default param set causes a statsmodels based estimator\n # to be created as bootstrap_transformer\n if _check_soft_dependencies(\"statsmodels\", severity=\"none\"):\n params += [{}]\n\n return params","def fixture_allparams():\n clp = Policy()\n return clp.metadata()","def get_params(self):\n return {\n \"nspecies\": self.nspecies,\n \"lmax\": self.lmax,\n \"nmax\": self.nmax,\n \"rcut\": self.rcut,\n \"sigma\": self.sigma,\n \"trans_width\": self.trans_width\n }","def get_test_params(cls, parameter_set=\"default\"):\n from sktime.forecasting.exp_smoothing import ExponentialSmoothing\n from sktime.forecasting.trend import TrendForecaster\n from sktime.utils.validation._dependencies import _check_estimator_deps\n\n # accessing a nested parameter\n params = [\n {\n \"forecaster\": TrendForecaster(),\n \"param_names\": [\"regressor__intercept\"],\n }\n ]\n\n # ExponentialSmoothing requires statsmodels\n if _check_estimator_deps(ExponentialSmoothing, severity=\"none\"):\n # accessing a top level parameter\n params = params + [\n {\n \"forecaster\": ExponentialSmoothing(),\n \"param_names\": [\"initial_level\"],\n }\n ]\n\n return params","def get_params(self, test):\n super(DaosServer, self).get_params(test)\n self.yaml_params.get_params(test)","def __init__(self):\n self.param_names = []\n self.param_values = []\n self.param_settings = []\n self.result = []\n self.best_params = None\n self.best_score = None\n self.max_reps = 5\n self.num_values = False\n self.algorithm_done = False","def iter_params(self):\n for var, val in self._params.iteritems():\n yield var, val","def _get_params(self):\r\n return self.k._get_params()","def get_fixed_params(self):\n\n fixed_params = {\n 'total_time_steps': 40,\n 'num_encoder_steps': 39,\n 'num_epochs': 100,\n 'early_stopping_patience': 10,\n 'multiprocessing_workers': 2,\n }\n\n return fixed_params","def task_parameters(self):\n yield self.properties","def get_params(self):\n\n return None","def get_params(self):\n\n return None","def get_params(self):\n\n return None","def get_params(self) -> np.array:\n pass","def getParams(self):\n\n\t\tparams = {\"Nparticles\":self.__Nparticles,\"Nkicks\":self.__Nkicks,\"kappa\":self.__kappa, \"eta\":self.__eta,\"gamma\":self.__gamma, \"omega\":self.__omega,\n\t\t\"Kbt\":self.__Kbt, \"tk\":self.__tk}\n\n\t\treturn params","def params(self):\n return {'out_dim': self.out_dim,\n 'act_fn': self.act_fn,\n 'use_bias': self.use_bias,\n 'idx': self.idx}","def parameters(self):\n return self.pars","def get_params(self, deep=...):\n ...","def params():\n return utils.Params('../experiments/base-model/params.json')","def autoset_numerical_parameters():\n testenv = env(\n Ndim=N_DIMS,\n lambda_over_dx=LAMBDA_OVER_DX,\n R_dt=R_DT,\n norm_Poisson=NORM_POISSON,\n Ngrid=N_GRID,\n Nhits=N_HITS,\n dummy=True,\n )\n if STOP_t is None:\n if N_DIMS == 1:\n stop_t = int(round(4 * testenv.N))\n else:\n if testenv.mu0_Poisson < 1e-3:\n stop_t = 10 * testenv.N ** N_DIMS\n elif testenv.mu0_Poisson < 1:\n stop_t = int(round(5 * 10 ** N_DIMS * LAMBDA_OVER_DX / np.sqrt(testenv.mu0_Poisson)))\n else:\n stop_t = int(round(5 * 10 ** N_DIMS * LAMBDA_OVER_DX))\n else:\n stop_t = STOP_t\n\n if N_RUNS is None:\n # predefined for REL_TOL = 0.01\n if N_DIMS == 1:\n Nruns = 16000\n elif N_DIMS == 2:\n Nruns = 6400\n elif N_DIMS == 3:\n Nruns = 25600\n elif N_DIMS == 4:\n Nruns = 102400\n else:\n raise Exception(\"Nruns not pre-defined for N_DIMS > 4\")\n Nruns = int(Nruns * (0.01 / REL_TOL) ** 2)\n else:\n Nruns = N_RUNS\n\n if MAX_N_RUNS is None:\n max_Nruns = MAX_N_RUNS\n else:\n max_Nruns = 10 * Nruns\n\n if ADAPTIVE_N_RUNS or WITH_MPI:\n Nruns = int(N_PARALLEL * (np.ceil(Nruns / N_PARALLEL))) # make it multiple of N_PARALLEL\n max_Nruns = int(N_PARALLEL * (np.ceil(max_Nruns / N_PARALLEL))) # make it multiple of N_PARALLEL\n\n return testenv.N, testenv.Nhits, stop_t, Nruns, max_Nruns, testenv.mu0_Poisson","def getInitParams(self):\n paramDict = BoostDistribution.getInitParams(self)\n paramDict['n' ] = self.n\n paramDict['p' ] = self.p\n return paramDict","def get_params(self):\n return []","def sequence_params(self):","def paramDetails(cls):\n return {\n 'dim': (10, 20, 2, 20),\n 'nIter': (1, 10, 2, 5),\n 'lamb': (.1, 1., .1, .05),\n 'alph': (30, 50, 5, 40)\n }","def params():\n raise NotImplementedError","def get_parameters(self):\n run_parameters = []\n max_clusters = self.parameters[\"clustering\"][\"evaluation\"][\"maximum_clusters\"]\n min_clusters = self.parameters[\"clustering\"][\"evaluation\"][\"minimum_clusters\"]\n hierarchicalAlgorithm = HierarchicalClusteringAlgorithm(self.distance_matrix)\n clusters_and_cutoff = hierarchicalTools.get_clusters_with_ranged_search(\n hierarchicalAlgorithm,\n 0.,\n self.distance_matrix.calculateMean(),\n min_clusters,\n max_clusters,\n ParametersGenerator.HIERARCHICAL_REFINEMENT_VALUE)\n clusterings = []\n cutoffs = []\n for numclusters in clusters_and_cutoff:\n clusterings.append(clusters_and_cutoff[numclusters][1])\n cutoffs.append(clusters_and_cutoff[numclusters][0])\n\n for cutoff in cutoffs:\n run_parameter = ParametersGenerator.get_base_parameters()\n run_parameter[\"method\"] = 'complete'\n run_parameter[\"cutoff\"] = cutoff\n run_parameters.append(run_parameter)\n\n return run_parameters, clusterings","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 parameters(self):\n for parameters in self:\n for parameter in parameters:\n yield parameter","def testParams ():\n params = {}\n params['MessageID'] = 1\n params['RepeatIndicator'] = 1\n params['UserID'] = 1193046\n params['NavigationStatus'] = 3\n params['ROT'] = -2\n params['SOG'] = Decimal('101.9')\n params['PositionAccuracy'] = 1\n params['longitude'] = Decimal('-122.16328055555556')\n params['latitude'] = Decimal('37.424458333333334')\n params['COG'] = Decimal('34.5')\n params['TrueHeading'] = 41\n params['TimeStamp'] = 35\n params['RegionalReserved'] = 0\n params['Spare'] = 0\n params['RAIM'] = False\n params['state_syncstate'] = 2\n params['state_slottimeout'] = 0\n params['state_slotoffset'] = 1221\n \n return params","def parameters(self):\n return {\"W\": self.W,\n \"T\": self.T,\n \"P\": self.P}","def required_parameters(self):\n return ['seed', 'run_params']","def get_test_params(cls, parameter_set=\"default\"):\n from sklearn.linear_model import LinearRegression\n\n from sktime.forecasting.naive import NaiveForecaster\n\n FORECASTER = NaiveForecaster()\n params1 = {\"forecasters\": [(\"f1\", FORECASTER), (\"f2\", FORECASTER)]}\n\n params2 = {\n \"forecasters\": [(\"f1\", FORECASTER), (\"f2\", FORECASTER)],\n \"method\": \"inverse-variance\",\n \"regressor\": LinearRegression(),\n \"test_size\": 0.2,\n }\n\n return [params1, params2]","def calculate_parameters(self, item):","def trial_setup(params):\n runs = []\n trials = []\n for run in range(params['runs']):\n runs = runs + [run]*params['trials_per_run']\n for trial in range(params['trials_per_run']):\n trials.append(trial)\n return(runs,trials)","def define_parameters(self):","def params(self):\n\t\treturn self.params_","def output_parameters(self):\n output_params = get_data_node(\n 'parameter',\n dict={\n 'stress': self.vasprun_obj.ionic_steps[-1]['stress'],\n 'efermi': self.vasprun_obj.efermi,\n 'energy': self.vasprun_obj.final_energy\n })\n return output_params","def get_parameter_estimation_parameters(self, friendly=True):\n #Get the sensitivities task:\n fitTask=self._getTask('parameterFitting')\n fitProblem = fitTask.find(xmlns + 'Problem')\n optimizationItems = fitProblem.find(xmlns + 'ParameterGroup')\n parameters = []\n for subGroup in optimizationItems:\n name = None\n lowerBound = None\n upperBound = None\n startValue = None\n \n for item in subGroup:\n if item.attrib['name'] == 'ObjectCN':\n name = item.attrib['value']\n elif item.attrib['name'] == 'UpperBound':\n upperBound = item.attrib['value']\n elif item.attrib['name'] == 'LowerBound':\n lowerBound = item.attrib['value']\n elif item.attrib['name'] == 'StartValue':\n startValue = item.attrib['value']\n assert name !=None\n assert lowerBound != None\n assert upperBound != None\n assert startValue != None\n \n if friendly:\n #Construct a user-friendly name for the parameter name using regexs\n #Look for a match for global parameters: Vector=Values[Test parameter],\n global_string = r'.*Vector=Values\\[(?P<name>.*)\\].*'\n global_string_re = re.compile(global_string)\n global_match = re.match(global_string_re, name)\n \n if global_match:\n name = global_match.group('name')\n \n #else check for a local match.\n #Vector=Reactions[Reaction] Parameter=k1\n local_string = r'.*Vector=Reactions\\[(?P<reaction>.*)\\].*Parameter=(?P<parameter>.*),Reference=Value.*'\n local_string_re = re.compile(local_string)\n local_match = re.match(local_string_re, name)\n \n if local_match:\n reaction = local_match.group('reaction')\n parameter = local_match.group('parameter')\n name = '(%s).%s'%(reaction, parameter)\n\n parameters.append((name, lowerBound, upperBound, startValue))\n\n return parameters","def testParametersCorrectlyStored(self):\n params = self.tree.get_community_parameters(1)\n self.assertEqual(0.1, params[\"speciation_rate\"])\n self.assertEqual(0, params[\"metacommunity_reference\"])\n params = self.tree.get_community_parameters(2)\n self.assertEqual(0.5, params[\"speciation_rate\"])\n self.assertEqual(0, params[\"metacommunity_reference\"])\n params = self.tree.get_community_parameters(3)\n self.assertEqual(0.9, params[\"speciation_rate\"])\n self.assertEqual(0, params[\"metacommunity_reference\"])\n params = self.tree.get_community_parameters(4)\n self.assertEqual(0.1, params[\"speciation_rate\"])\n self.assertEqual(1, params[\"metacommunity_reference\"])\n params = self.tree.get_community_parameters(5)\n self.assertEqual(0.5, params[\"speciation_rate\"])\n self.assertEqual(1, params[\"metacommunity_reference\"])\n params = self.tree.get_community_parameters(6)\n self.assertEqual(0.9, params[\"speciation_rate\"])\n self.assertEqual(1, params[\"metacommunity_reference\"])","def test_params(self):\n cr = CaseReader(self.filename)\n last_case = cr.get_case(-1)\n last_case_id = cr.list_cases()[-1]\n n = cr.num_cases\n with h5py.File(self.filename, 'r') as f:\n for key in f[last_case_id]['Parameters'].keys():\n val = f[last_case_id]['Parameters'][key][()]\n np.testing.assert_almost_equal(last_case.parameters[key], val,\n err_msg='Case reader gives'\n ' incorrect Parameter'\n ' value for'\n ' {0}'.format(key))","def getExpectations():","def get_params(self, deep=False):\n return {\"alpha\": self.alpha, \"beta\": self.beta, \"gamma\": self.gamma, \"W\": self.W, \"bias\": self.bias, \"add_bias\": self.add_bias, \"opts\": self.opts}"],"string":"[\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n params1 = {\\n \\\"n_clusters\\\": 3,\\n \\\"n_init\\\": 2,\\n \\\"max_iter\\\": 2,\\n \\\"tol\\\": 1e-3,\\n \\\"verbose\\\": False,\\n \\\"random_state\\\": 2,\\n }\\n params2 = {\\n \\\"n_clusters\\\": 2,\\n \\\"init_algorithm\\\": \\\"random\\\",\\n \\\"n_init\\\": 1,\\n \\\"max_iter\\\": 1,\\n \\\"tol\\\": 1e-4,\\n \\\"verbose\\\": False,\\n \\\"random_state\\\": 1,\\n }\\n return [params1, params2]\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n params = {\\\"state_dim\\\": 2}\\n return params\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n params = {\\\"state_dim\\\": 2}\\n return params\",\n \"def get_params(self):\\n return {'threshold': self.threshold,\\n 'subsample': self.subsample,\\n 'estimator': self.estimator,\\n 'n_folds': self.n_folds,\\n 'stratify': self.stratify,\\n 'random_state': self.random_state,\\n 'n_jobs': self.n_jobs}\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n params1 = {\\\"low\\\": 8, \\\"high\\\": 26, \\\"drift\\\": False}\\n params2 = {}\\n return [params1, params2]\",\n \"def get_params(self):\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n params1 = {}\\n params2 = {\\\"p_threshold\\\": 0.1, \\\"regression\\\": \\\"ctt\\\", \\\"nlags\\\": 5}\\n\\n return [params1, params2]\",\n \"def parameters(self):\",\n \"def test_parameters(self):\\n self.assert_initialize_driver()\\n #reply = self.driver_client.cmd_dvr('get_resource', Parameter.ALL)\\n #self.assert_driver_parameters(reply, verify_sample_interval=True)\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n params1 = {}\\n params2 = {\\n \\\"p_threshold\\\": 0.1,\\n \\\"maxlag\\\": 5,\\n \\\"regression\\\": \\\"ctt\\\",\\n \\\"autolag\\\": \\\"t-stat\\\",\\n }\\n\\n return [params1, params2]\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n params = {\\n \\\"default_fc_parameters\\\": \\\"efficient\\\",\\n \\\"disable_progressbar\\\": True,\\n \\\"show_warnings\\\": False,\\n \\\"fdr_level\\\": 0.01,\\n }\\n return params\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=1,\\n task=30,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.1,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"tiled_coarse\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\\\"Error in {}\\\".format(key))\\n self.assertEqual(self.tree.get_job()[0], 1)\\n self.assertEqual(self.tree.get_job()[1], 30)\",\n \"def parameters(self):\\n pass\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=3,\\n task=3,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.1,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"none\\\",\\n coarse_map_x=13,\\n coarse_map_y=13,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\\\"Error in {}\\\".format(key))\\n self.assertEqual(self.tree.get_job()[0], 3)\\n self.assertEqual(self.tree.get_job()[1], 3)\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=1,\\n task=29,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.1,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"none\\\",\\n coarse_map_x=13,\\n coarse_map_y=13,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"tiled_fine\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\\\"Error in {}\\\".format(key))\\n self.assertEqual(self.tree.get_job()[0], 1)\\n self.assertEqual(self.tree.get_job()[1], 29)\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=1,\\n task=1,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=1.0,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"null\\\",\\n coarse_map_x=20,\\n coarse_map_y=20,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"null\\\",\\n fine_map_x=10,\\n fine_map_y=10,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=10,\\n grid_y=10,\\n sample_x=10,\\n sample_y=10,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"fat-tail\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"infinite\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key])\\n self.assertEqual(self.tree.get_job()[0], 1)\\n self.assertEqual(self.tree.get_job()[1], 1)\",\n \"def read_test_parameters():\\n DBHelperRaw.get_test_data_bunch() # return DBHelper.test_exposure_sequences \\n return DBHelperRaw.test_exposure_sequences\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=2,\\n task=2,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=1.0,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"null\\\",\\n coarse_map_x=20,\\n coarse_map_y=20,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"null\\\",\\n fine_map_x=10,\\n fine_map_y=10,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=10,\\n grid_y=10,\\n sample_x=10,\\n sample_y=10,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=1.0,\\n cutoff=0.0,\\n landscape_type=\\\"infinite\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\\\"Error in {}\\\".format(key))\\n self.assertEqual(self.tree.get_job()[0], 2)\\n self.assertEqual(self.tree.get_job()[1], 2)\",\n \"def get_params(self):\\n pass\",\n \"def default_indefinite_iteration_parameters():\\n tol = 10 ** -8\\n err = 1\\n counter = 1\\n return tol, err, counter\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=4,\\n task=4,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.01,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"fat-tail\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(\\n params[key],\\n actual_sim_parameters[key],\\n msg=\\\"Error in {}: {}!={}\\\".format(key, params[key], actual_sim_parameters[key]),\\n )\\n self.assertEqual(self.tree.get_job()[0], 4, msg=\\\"Job number not stored correctly.\\\")\\n self.assertEqual(self.tree.get_job()[1], 4, msg=\\\"Job number not stored correctly.\\\")\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=5,\\n task=4,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=1.0,\\n deme=0.25,\\n sample_size=1.0,\\n max_time=3600.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(\\n params[key],\\n actual_sim_parameters[key],\\n msg=\\\"Error in {}: {}!={}\\\".format(key, params[key], actual_sim_parameters[key]),\\n )\\n self.assertEqual(self.tree.get_job()[0], 5, msg=\\\"Seed not stored correctly.\\\")\\n self.assertEqual(self.tree.get_job()[1], 4, msg=\\\"Job number not stored correctly.\\\")\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=7,\\n task=4,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=1.0,\\n deme=0.01,\\n sample_size=1.5,\\n max_time=3600.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(\\n params[key],\\n actual_sim_parameters[key],\\n msg=\\\"Error in {}: {}!={}\\\".format(key, params[key], actual_sim_parameters[key]),\\n )\\n self.assertEqual(self.tree.get_job()[0], 7, msg=\\\"Seed not stored correctly.\\\")\\n self.assertEqual(self.tree.get_job()[1], 4, msg=\\\"Job number not stored correctly.\\\")\",\n \"def get_parameters(self):\\n d = Algorithm.get_parameters(self)\\n d.update({\\n 'M': d.pop('population_size', self.population_size),\\n 'num_tests': self.num_tests,\\n 'num_searches': self.num_searches,\\n 'num_searches_best': self.num_searches_best,\\n 'bonus1': self.bonus1,\\n 'bonus2': self.bonus2,\\n 'num_enabled': self.num_enabled,\\n 'local_searches': self.local_searches\\n })\\n return d\",\n \"def _get_params_for_run(self):\\n if self._optimizer is not None:\\n return self._optimizer.get_next_params()\\n else:\\n return self._params\",\n \"def get_params(self):\\n params = {}\\n for step in self.steps:\\n params[step[0]] = step[1].get_params()\\n return params\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=2,\\n task=5,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=1.0,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"null\\\",\\n coarse_map_x=20,\\n coarse_map_y=20,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"null\\\",\\n fine_map_x=10,\\n fine_map_y=10,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=10,\\n grid_y=10,\\n sample_x=10,\\n sample_y=10,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key])\\n # self.assertDictEqual(params, actual_sim_parameters)\\n self.assertEqual(self.tree.get_job()[0], 2)\\n self.assertEqual(self.tree.get_job()[1], 5)\",\n \"def parameters(self):\\n #print \\\"in instrument.parameter()\\\"\\n return self._params\",\n \"def getParameters(self):\\n\\t\\td = AdaptiveBatAlgorithm.getParameters(self)\\n\\t\\td.update({\\n\\t\\t\\t'A_l': self.A_l,\\n\\t\\t\\t'A_u': self.A_u,\\n\\t\\t\\t'r_l': self.r_l,\\n\\t\\t\\t'r_u': self.r_u,\\n\\t\\t\\t'tao_1': self.tao_1,\\n\\t\\t\\t'tao_2': self.tao_2\\n\\t\\t})\\n\\t\\treturn d\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n features_to_calc = [\\n \\\"dim_0__quantile__q_0.6\\\",\\n \\\"dim_0__longest_strike_above_mean\\\",\\n \\\"dim_0__variance\\\",\\n ]\\n\\n return [\\n {\\n \\\"disable_progressbar\\\": True,\\n \\\"show_warnings\\\": False,\\n \\\"default_fc_parameters\\\": \\\"minimal\\\",\\n },\\n {\\n \\\"disable_progressbar\\\": True,\\n \\\"show_warnings\\\": False,\\n \\\"kind_to_fc_parameters\\\": features_to_calc,\\n },\\n ]\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n from sktime.forecasting.naive import NaiveForecaster\\n\\n params1 = {\\n \\\"forecasters\\\": [\\n (\\\"Naive_mean\\\", NaiveForecaster(strategy=\\\"mean\\\")),\\n (\\\"Naive_last\\\", NaiveForecaster(strategy=\\\"last\\\")),\\n (\\\"Naive_drift\\\", NaiveForecaster(strategy=\\\"drift\\\")),\\n ],\\n \\\"selected_forecaster\\\": \\\"Naive_mean\\\",\\n }\\n params2 = {\\n \\\"forecasters\\\": [\\n NaiveForecaster(strategy=\\\"mean\\\"),\\n NaiveForecaster(strategy=\\\"last\\\"),\\n NaiveForecaster(strategy=\\\"drift\\\"),\\n ],\\n }\\n return [params1, params2]\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n # non-default distance and algorithm\\n params1 = {\\\"distance\\\": \\\"euclidean\\\"}\\n\\n # testing distance_params\\n params2 = {\\\"distance\\\": \\\"dtw\\\", \\\"distance_params\\\": {\\\"epsilon\\\": 0.1}}\\n\\n # testing that callables/classes can be passed\\n from sktime.dists_kernels.compose_tab_to_panel import AggrDist\\n\\n dist = AggrDist.create_test_instance()\\n params3 = {\\\"distance\\\": dist}\\n\\n return [params1, params2, params3]\",\n \"def test_get_params():\\n ejob = EvaluationJob({},\\n CLASSIFIERS,\\n cache_path=CACHE_PATH)\\n\\n assert len(ejob.get_params()) > 0\",\n \"def testSimulationParametersStored(self):\\n simulation_parameters = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=6,\\n task=6,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.5,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.1,\\n max_time=10.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"set\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in simulation_parameters.keys():\\n self.assertEqual(simulation_parameters[key], actual_sim_parameters[key])\\n self.assertDictEqual(simulation_parameters, actual_sim_parameters)\\n # self.assertListEqual(simulation_parameters, actual_sim_parameters)\\n self.assertEqual(self.tree.get_job()[0], 6)\\n self.assertEqual(self.tree.get_job()[1], 6)\",\n \"def getParams(self):\\n return self.trainError, self.trainAcc, self.w\",\n \"def parameters(self):\\n return self._params\",\n \"def test_get_measure_parameters(self):\\n pass\",\n \"def _generate_params(self):\\n return {\\n 'lis_outcome_service_url': self.lis_outcome_service_url,\\n 'lis_result_sourcedid': self.lis_result_sourcedid,\\n 'oauth_consumer_key': self.key\\n }\",\n \"def next_parameters(self):\\n\\n if self.number_of_runs == -1 or self.runs_performed < self.number_of_runs:\\n self.runs_performed += 1\\n _log.debug('%d runs performed (calls to `next_parameters()`)' % self.runs_performed)\\n else:\\n _log.info('No more parameters to test in the database.')\\n return None\\n \\n records = self.db.get_table()\\n _log.debug('Retrieved %d parameters' % len(records))\\n\\n # Do we have a last-test in the config file\\n if self.config and \\\"last-test\\\" in self.config and self.config[\\\"last-test\\\"]:\\n _log.info('Using `last-test` with id=\\\"%s\\\" from config.txt' %\\n str(self.config[\\\"last-test\\\"]))\\n for i in range(0, len(records)):\\n if (\\n str(self.config.config[\\\"last-test\\\"]) == str(records[i][\\\"id\\\"]) and\\n records[i][\\\"status\\\"] != \\\"successful\\\"\\n ):\\n records[i][\\\"status\\\"] = \\\"in progress\\\"\\n if \\\"start-time\\\" in records[i]:\\n records[i][\\\"start-time\\\"] = \\\\\\n datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')\\n if \\\"performed-by\\\" in records[i]:\\n records[i][\\\"performed-by\\\"] = self.performed_by\\n\\n self.db.update_row(i, records[i])\\n\\n return records[i]\\n\\n for i in range(0, len(records)):\\n if not len(records[i][\\\"status\\\"]):\\n if (\\n 'computer-strength' in records[i] and \\n self.computer_strength < int(records[i][\\\"computer-strength\\\"])\\n ):\\n continue\\n \\n records[i][\\\"status\\\"] = \\\"in progress\\\"\\n if \\\"start-time\\\" in records[i]:\\n records[i][\\\"start-time\\\"] = \\\\\\n datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')\\n if \\\"performed-by\\\" in records[i]:\\n records[i][\\\"performed-by\\\"] = self.performed_by\\n self.db.update_row(i, records[i])\\n\\n # Save id to local cache\\n if self.config:\\n self.config.update(key='last-test', value=str(records[i][\\\"id\\\"]))\\n\\n return records[i]\\n\\n return None\",\n \"def get_params(self):\\n raise NotImplementedError\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n from sktime.forecasting.compose._reduce import DirectReductionForecaster\\n from sktime.forecasting.naive import NaiveForecaster\\n\\n # univariate case\\n FORECASTER = NaiveForecaster()\\n params = [{\\\"forecasters\\\": [(\\\"f1\\\", FORECASTER), (\\\"f2\\\", FORECASTER)]}]\\n\\n # test multivariate case, i.e., ensembling multiple variables at same time\\n FORECASTER = DirectReductionForecaster.create_test_instance()\\n params = params + [{\\\"forecasters\\\": [(\\\"f1\\\", FORECASTER), (\\\"f2\\\", FORECASTER)]}]\\n\\n return params\",\n \"def get_params(self):\\n return {'classifier': self.classifier,\\n 'grid_param': self.grid_param,\\n 'n_param_comb': self.n_param_comb,\\n 'top_bagging': self.bagging,\\n 'bagging_param': self.bagging_param,\\n 'comb_seed': self.comb_seed}\",\n \"def get_prob_params():\\n prob = Namespace()\\n prob.study_name = STUDY_NAME\\n if IS_DEBUG:\\n prob.num_trials = 3\\n prob.max_capital = 10\\n else:\\n prob.num_trials = NUM_TRIALS\\n prob.max_capital = MAX_CAPITAL\\n # Common\\n prob.time_distro = TIME_DISTRO\\n prob.num_workers = NUM_WORKERS\\n _study_params = {\\n 'branin': ('synthetic/branin/config_mf.json',\\n branin_mf, cost_branin_mf, 0.1, 0, 1),\\n 'hartmann3_2': ('synthetic/hartmann3_2/config_mf.json',\\n hartmann3_2_mf, cost_hartmann3_2_mf, 0.1, 0, 1),\\n 'hartmann6_4': ('synthetic/hartmann6_4/config_mf.json',\\n hartmann6_4_mf, cost_hartmann6_4_mf, 0.1, 0, 1),\\n 'borehole_6': ('synthetic/borehole_6/config_mf.json',\\n borehole_6_mf, cost_borehole_6_mf, 1, 0, 1),\\n 'park2_4': ('synthetic/park2_4/config_mf.json',\\n park2_4_mf, cost_park2_4_mf, 0.3, 0, 1),\\n 'park2_3': ('synthetic/park2_3/config_mf.json',\\n park2_3_mf, cost_park2_3_mf, 0.1, 0, 1),\\n 'park1_3': ('synthetic/park1_3/config_mf.json',\\n park1_3_mf, cost_park1_3_mf, 0.5, 0, 1),\\n }\\n (domain_config_file_suffix, raw_func, raw_fidel_cost_func, _fc_noise_scale,\\n _initial_pool_size, _) = _study_params[prob.study_name]\\n domain_config_file = os.path.join(DRAGONFLY_EXPERIMENTS_DIR, domain_config_file_suffix)\\n # noisy\\n prob.noisy_evals = NOISY_EVALS\\n if NOISY_EVALS:\\n noise_type = 'gauss'\\n noise_scale = _fc_noise_scale\\n else:\\n noise_type = 'no_noise'\\n noise_scale = None\\n # Create domain, function_caller and worker_manager\\n config = load_config_file(domain_config_file)\\n func_caller = get_multifunction_caller_from_config(raw_func, config,\\n raw_fidel_cost_func=raw_fidel_cost_func, noise_type=noise_type,\\n noise_scale=noise_scale)\\n # Set max_capital\\n if hasattr(func_caller, 'fidel_cost_func'):\\n prob.max_capital = prob.max_capital * \\\\\\n func_caller.fidel_cost_func(func_caller.fidel_to_opt)\\n else:\\n prob.max_capital = prob.max_capital\\n # Store everything in prob\\n prob.func_caller = func_caller\\n prob.worker_manager = SyntheticWorkerManager(prob.num_workers,\\n time_distro='caller_eval_cost')\\n prob.save_file_prefix = prob.study_name + ('-debug' if IS_DEBUG else '')\\n prob.methods = METHODS\\n prob.save_results_dir = SAVE_RESULTS_DIR\\n prob.reporter = get_reporter('default')\\n # evaluation options\\n prob.evaluation_options = Namespace(prev_eval_points='none',\\n initial_pool_size=_initial_pool_size)\\n return prob\",\n \"def _get_parameters(self):\\n return None\",\n \"def parameters(self):\\n return self.trainer_parameters\",\n \"def parameters(self):\\n return self.trainer_parameters\",\n \"def _get_parameters(self) -> list:\\n return self.parameters\",\n \"def random_parameters():\\n res = dict()\\n res[\\\"population_size\\\"] = random.randrange(2, 21)\\n res[\\\"mutation_prob\\\"] = random.choice([0.02, 0.05, 0.10, 0.20, 0.30, 0.40, 0.50])\\n res[\\\"crossover\\\"] = random.choice([True, False])\\n res[\\\"selection\\\"] = random.choice([True, False])\\n res[\\\"sigma\\\"] = random.choice([0.1, 0.25, 0.5, 1])\\n res[\\\"crossover_method\\\"] = random.choice([\\\"single_swap\\\", \\\"uniform_swap\\\", \\\"arithmetic\\\"])\\n res[\\\"selection_method\\\"] = random.choice([\\\"truncated\\\", \\\"fitness_based\\\", \\\"rank_based\\\"])\\n res[\\\"best_rate\\\"] = random.choice([0.2, 0.3, 0.5])\\n res[\\\"n_parents\\\"] = random.choice([2, 3, 4])\\n res[\\\"elitism\\\"] = random.choice([True, False])\\n return res\",\n \"def getParameters(self):\\n\\n current_params = {'taux': self.taux, 'mu': self.mu, 'G': self.G, 'alpha_0': self.alpha_0,\\n 'delta': self.delta, 'p': self.p, 'I0': self.I0, 'kparam': self.kparam}\\n\\n return (current_params)\",\n \"def get_params_iter(self):\\n return []\",\n \"def params(self):\\n return {'cfg': self.cfg,\\n 'momentum': self.momentum,\\n 'center': self.center,\\n 'scale': self.scale,\\n 'epsilon': self.epsilon,\\n 'act_fn': self.act_fn}\",\n \"def generate_params(self, randomize=True):\\n pass\",\n \"def get_fixed_params():\\n fixed_params = {\\n 'total_time_steps': 8 * 24,\\n 'num_encoder_steps': 7 * 24,\\n 'num_epochs': 100,\\n 'early_stopping_patience': 5,\\n 'multiprocessing_workers': 5\\n }\\n return fixed_params\",\n \"def parameters(self):\\n res = dict()\\n res[\\\"population_size\\\"] = self.population_size\\n res[\\\"mutation_prob\\\"] = self.mutation_prob\\n res[\\\"crossover\\\"] = self.crossover\\n res[\\\"selection\\\"] = self.selection\\n res[\\\"sigma\\\"] = self.sigma\\n res[\\\"crossover_method\\\"] = self.crossover_method\\n res[\\\"selection_method\\\"] = self.selection_method\\n res[\\\"best_rate\\\"] = self.best_rate\\n res[\\\"n_parents\\\"] = self.n_parents\\n res[\\\"model_parameters\\\"] = self.model.total_parameters()\\n res[\\\"IDCT_from\\\"] = self.IDCT_from\\n res[\\\"elitism\\\"] = self.elitism\\n return res\",\n \"def parameters(self):\\n return {\\\"P\\\": self.P,\\n \\\"T\\\": self.T}\",\n \"def get_next_params(self) -> dict:\\n params = {arg_name: caller() for arg_name, caller in self.parameters}\\n return params\",\n \"def parameters(self) -> Dict[str, Any]:\\n return self.trainer_parameters\",\n \"def parameters(self):\\n return []\",\n \"def getInitParams(self):\\n paramDict = Distribution.getInitParams(self)\\n paramDict['strategy'] = self.strategy\\n paramDict['nPoints'] = self.nPoints\\n return paramDict\",\n \"def get_test_params(cls):\\n from sktime.utils.validation._dependencies import _check_soft_dependencies\\n\\n params = [\\n {\\n \\\"bootstrap_transformer\\\": MovingBlockBootstrapTransformer(),\\n \\\"forecaster\\\": MockForecaster(),\\n },\\n ]\\n\\n # the default param set causes a statsmodels based estimator\\n # to be created as bootstrap_transformer\\n if _check_soft_dependencies(\\\"statsmodels\\\", severity=\\\"none\\\"):\\n params += [{}]\\n\\n return params\",\n \"def fixture_allparams():\\n clp = Policy()\\n return clp.metadata()\",\n \"def get_params(self):\\n return {\\n \\\"nspecies\\\": self.nspecies,\\n \\\"lmax\\\": self.lmax,\\n \\\"nmax\\\": self.nmax,\\n \\\"rcut\\\": self.rcut,\\n \\\"sigma\\\": self.sigma,\\n \\\"trans_width\\\": self.trans_width\\n }\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n from sktime.forecasting.exp_smoothing import ExponentialSmoothing\\n from sktime.forecasting.trend import TrendForecaster\\n from sktime.utils.validation._dependencies import _check_estimator_deps\\n\\n # accessing a nested parameter\\n params = [\\n {\\n \\\"forecaster\\\": TrendForecaster(),\\n \\\"param_names\\\": [\\\"regressor__intercept\\\"],\\n }\\n ]\\n\\n # ExponentialSmoothing requires statsmodels\\n if _check_estimator_deps(ExponentialSmoothing, severity=\\\"none\\\"):\\n # accessing a top level parameter\\n params = params + [\\n {\\n \\\"forecaster\\\": ExponentialSmoothing(),\\n \\\"param_names\\\": [\\\"initial_level\\\"],\\n }\\n ]\\n\\n return params\",\n \"def get_params(self, test):\\n super(DaosServer, self).get_params(test)\\n self.yaml_params.get_params(test)\",\n \"def __init__(self):\\n self.param_names = []\\n self.param_values = []\\n self.param_settings = []\\n self.result = []\\n self.best_params = None\\n self.best_score = None\\n self.max_reps = 5\\n self.num_values = False\\n self.algorithm_done = False\",\n \"def iter_params(self):\\n for var, val in self._params.iteritems():\\n yield var, val\",\n \"def _get_params(self):\\r\\n return self.k._get_params()\",\n \"def get_fixed_params(self):\\n\\n fixed_params = {\\n 'total_time_steps': 40,\\n 'num_encoder_steps': 39,\\n 'num_epochs': 100,\\n 'early_stopping_patience': 10,\\n 'multiprocessing_workers': 2,\\n }\\n\\n return fixed_params\",\n \"def task_parameters(self):\\n yield self.properties\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params(self):\\n\\n return None\",\n \"def get_params(self) -> np.array:\\n pass\",\n \"def getParams(self):\\n\\n\\t\\tparams = {\\\"Nparticles\\\":self.__Nparticles,\\\"Nkicks\\\":self.__Nkicks,\\\"kappa\\\":self.__kappa, \\\"eta\\\":self.__eta,\\\"gamma\\\":self.__gamma, \\\"omega\\\":self.__omega,\\n\\t\\t\\\"Kbt\\\":self.__Kbt, \\\"tk\\\":self.__tk}\\n\\n\\t\\treturn params\",\n \"def params(self):\\n return {'out_dim': self.out_dim,\\n 'act_fn': self.act_fn,\\n 'use_bias': self.use_bias,\\n 'idx': self.idx}\",\n \"def parameters(self):\\n return self.pars\",\n \"def get_params(self, deep=...):\\n ...\",\n \"def params():\\n return utils.Params('../experiments/base-model/params.json')\",\n \"def autoset_numerical_parameters():\\n testenv = env(\\n Ndim=N_DIMS,\\n lambda_over_dx=LAMBDA_OVER_DX,\\n R_dt=R_DT,\\n norm_Poisson=NORM_POISSON,\\n Ngrid=N_GRID,\\n Nhits=N_HITS,\\n dummy=True,\\n )\\n if STOP_t is None:\\n if N_DIMS == 1:\\n stop_t = int(round(4 * testenv.N))\\n else:\\n if testenv.mu0_Poisson < 1e-3:\\n stop_t = 10 * testenv.N ** N_DIMS\\n elif testenv.mu0_Poisson < 1:\\n stop_t = int(round(5 * 10 ** N_DIMS * LAMBDA_OVER_DX / np.sqrt(testenv.mu0_Poisson)))\\n else:\\n stop_t = int(round(5 * 10 ** N_DIMS * LAMBDA_OVER_DX))\\n else:\\n stop_t = STOP_t\\n\\n if N_RUNS is None:\\n # predefined for REL_TOL = 0.01\\n if N_DIMS == 1:\\n Nruns = 16000\\n elif N_DIMS == 2:\\n Nruns = 6400\\n elif N_DIMS == 3:\\n Nruns = 25600\\n elif N_DIMS == 4:\\n Nruns = 102400\\n else:\\n raise Exception(\\\"Nruns not pre-defined for N_DIMS > 4\\\")\\n Nruns = int(Nruns * (0.01 / REL_TOL) ** 2)\\n else:\\n Nruns = N_RUNS\\n\\n if MAX_N_RUNS is None:\\n max_Nruns = MAX_N_RUNS\\n else:\\n max_Nruns = 10 * Nruns\\n\\n if ADAPTIVE_N_RUNS or WITH_MPI:\\n Nruns = int(N_PARALLEL * (np.ceil(Nruns / N_PARALLEL))) # make it multiple of N_PARALLEL\\n max_Nruns = int(N_PARALLEL * (np.ceil(max_Nruns / N_PARALLEL))) # make it multiple of N_PARALLEL\\n\\n return testenv.N, testenv.Nhits, stop_t, Nruns, max_Nruns, testenv.mu0_Poisson\",\n \"def getInitParams(self):\\n paramDict = BoostDistribution.getInitParams(self)\\n paramDict['n' ] = self.n\\n paramDict['p' ] = self.p\\n return paramDict\",\n \"def get_params(self):\\n return []\",\n \"def sequence_params(self):\",\n \"def paramDetails(cls):\\n return {\\n 'dim': (10, 20, 2, 20),\\n 'nIter': (1, 10, 2, 5),\\n 'lamb': (.1, 1., .1, .05),\\n 'alph': (30, 50, 5, 40)\\n }\",\n \"def params():\\n raise NotImplementedError\",\n \"def get_parameters(self):\\n run_parameters = []\\n max_clusters = self.parameters[\\\"clustering\\\"][\\\"evaluation\\\"][\\\"maximum_clusters\\\"]\\n min_clusters = self.parameters[\\\"clustering\\\"][\\\"evaluation\\\"][\\\"minimum_clusters\\\"]\\n hierarchicalAlgorithm = HierarchicalClusteringAlgorithm(self.distance_matrix)\\n clusters_and_cutoff = hierarchicalTools.get_clusters_with_ranged_search(\\n hierarchicalAlgorithm,\\n 0.,\\n self.distance_matrix.calculateMean(),\\n min_clusters,\\n max_clusters,\\n ParametersGenerator.HIERARCHICAL_REFINEMENT_VALUE)\\n clusterings = []\\n cutoffs = []\\n for numclusters in clusters_and_cutoff:\\n clusterings.append(clusters_and_cutoff[numclusters][1])\\n cutoffs.append(clusters_and_cutoff[numclusters][0])\\n\\n for cutoff in cutoffs:\\n run_parameter = ParametersGenerator.get_base_parameters()\\n run_parameter[\\\"method\\\"] = 'complete'\\n run_parameter[\\\"cutoff\\\"] = cutoff\\n run_parameters.append(run_parameter)\\n\\n return run_parameters, clusterings\",\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 parameters(self):\\n for parameters in self:\\n for parameter in parameters:\\n yield parameter\",\n \"def testParams ():\\n params = {}\\n params['MessageID'] = 1\\n params['RepeatIndicator'] = 1\\n params['UserID'] = 1193046\\n params['NavigationStatus'] = 3\\n params['ROT'] = -2\\n params['SOG'] = Decimal('101.9')\\n params['PositionAccuracy'] = 1\\n params['longitude'] = Decimal('-122.16328055555556')\\n params['latitude'] = Decimal('37.424458333333334')\\n params['COG'] = Decimal('34.5')\\n params['TrueHeading'] = 41\\n params['TimeStamp'] = 35\\n params['RegionalReserved'] = 0\\n params['Spare'] = 0\\n params['RAIM'] = False\\n params['state_syncstate'] = 2\\n params['state_slottimeout'] = 0\\n params['state_slotoffset'] = 1221\\n \\n return params\",\n \"def parameters(self):\\n return {\\\"W\\\": self.W,\\n \\\"T\\\": self.T,\\n \\\"P\\\": self.P}\",\n \"def required_parameters(self):\\n return ['seed', 'run_params']\",\n \"def get_test_params(cls, parameter_set=\\\"default\\\"):\\n from sklearn.linear_model import LinearRegression\\n\\n from sktime.forecasting.naive import NaiveForecaster\\n\\n FORECASTER = NaiveForecaster()\\n params1 = {\\\"forecasters\\\": [(\\\"f1\\\", FORECASTER), (\\\"f2\\\", FORECASTER)]}\\n\\n params2 = {\\n \\\"forecasters\\\": [(\\\"f1\\\", FORECASTER), (\\\"f2\\\", FORECASTER)],\\n \\\"method\\\": \\\"inverse-variance\\\",\\n \\\"regressor\\\": LinearRegression(),\\n \\\"test_size\\\": 0.2,\\n }\\n\\n return [params1, params2]\",\n \"def calculate_parameters(self, item):\",\n \"def trial_setup(params):\\n runs = []\\n trials = []\\n for run in range(params['runs']):\\n runs = runs + [run]*params['trials_per_run']\\n for trial in range(params['trials_per_run']):\\n trials.append(trial)\\n return(runs,trials)\",\n \"def define_parameters(self):\",\n \"def params(self):\\n\\t\\treturn self.params_\",\n \"def output_parameters(self):\\n output_params = get_data_node(\\n 'parameter',\\n dict={\\n 'stress': self.vasprun_obj.ionic_steps[-1]['stress'],\\n 'efermi': self.vasprun_obj.efermi,\\n 'energy': self.vasprun_obj.final_energy\\n })\\n return output_params\",\n \"def get_parameter_estimation_parameters(self, friendly=True):\\n #Get the sensitivities task:\\n fitTask=self._getTask('parameterFitting')\\n fitProblem = fitTask.find(xmlns + 'Problem')\\n optimizationItems = fitProblem.find(xmlns + 'ParameterGroup')\\n parameters = []\\n for subGroup in optimizationItems:\\n name = None\\n lowerBound = None\\n upperBound = None\\n startValue = None\\n \\n for item in subGroup:\\n if item.attrib['name'] == 'ObjectCN':\\n name = item.attrib['value']\\n elif item.attrib['name'] == 'UpperBound':\\n upperBound = item.attrib['value']\\n elif item.attrib['name'] == 'LowerBound':\\n lowerBound = item.attrib['value']\\n elif item.attrib['name'] == 'StartValue':\\n startValue = item.attrib['value']\\n assert name !=None\\n assert lowerBound != None\\n assert upperBound != None\\n assert startValue != None\\n \\n if friendly:\\n #Construct a user-friendly name for the parameter name using regexs\\n #Look for a match for global parameters: Vector=Values[Test parameter],\\n global_string = r'.*Vector=Values\\\\[(?P<name>.*)\\\\].*'\\n global_string_re = re.compile(global_string)\\n global_match = re.match(global_string_re, name)\\n \\n if global_match:\\n name = global_match.group('name')\\n \\n #else check for a local match.\\n #Vector=Reactions[Reaction] Parameter=k1\\n local_string = r'.*Vector=Reactions\\\\[(?P<reaction>.*)\\\\].*Parameter=(?P<parameter>.*),Reference=Value.*'\\n local_string_re = re.compile(local_string)\\n local_match = re.match(local_string_re, name)\\n \\n if local_match:\\n reaction = local_match.group('reaction')\\n parameter = local_match.group('parameter')\\n name = '(%s).%s'%(reaction, parameter)\\n\\n parameters.append((name, lowerBound, upperBound, startValue))\\n\\n return parameters\",\n \"def testParametersCorrectlyStored(self):\\n params = self.tree.get_community_parameters(1)\\n self.assertEqual(0.1, params[\\\"speciation_rate\\\"])\\n self.assertEqual(0, params[\\\"metacommunity_reference\\\"])\\n params = self.tree.get_community_parameters(2)\\n self.assertEqual(0.5, params[\\\"speciation_rate\\\"])\\n self.assertEqual(0, params[\\\"metacommunity_reference\\\"])\\n params = self.tree.get_community_parameters(3)\\n self.assertEqual(0.9, params[\\\"speciation_rate\\\"])\\n self.assertEqual(0, params[\\\"metacommunity_reference\\\"])\\n params = self.tree.get_community_parameters(4)\\n self.assertEqual(0.1, params[\\\"speciation_rate\\\"])\\n self.assertEqual(1, params[\\\"metacommunity_reference\\\"])\\n params = self.tree.get_community_parameters(5)\\n self.assertEqual(0.5, params[\\\"speciation_rate\\\"])\\n self.assertEqual(1, params[\\\"metacommunity_reference\\\"])\\n params = self.tree.get_community_parameters(6)\\n self.assertEqual(0.9, params[\\\"speciation_rate\\\"])\\n self.assertEqual(1, params[\\\"metacommunity_reference\\\"])\",\n \"def test_params(self):\\n cr = CaseReader(self.filename)\\n last_case = cr.get_case(-1)\\n last_case_id = cr.list_cases()[-1]\\n n = cr.num_cases\\n with h5py.File(self.filename, 'r') as f:\\n for key in f[last_case_id]['Parameters'].keys():\\n val = f[last_case_id]['Parameters'][key][()]\\n np.testing.assert_almost_equal(last_case.parameters[key], val,\\n err_msg='Case reader gives'\\n ' incorrect Parameter'\\n ' value for'\\n ' {0}'.format(key))\",\n \"def getExpectations():\",\n \"def get_params(self, deep=False):\\n return {\\\"alpha\\\": self.alpha, \\\"beta\\\": self.beta, \\\"gamma\\\": self.gamma, \\\"W\\\": self.W, \\\"bias\\\": self.bias, \\\"add_bias\\\": self.add_bias, \\\"opts\\\": self.opts}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72552997","0.7055899","0.7055899","0.7009616","0.69649035","0.6943783","0.68921715","0.68921447","0.68385094","0.6832389","0.6796779","0.6747082","0.6738572","0.6733773","0.6733502","0.6733482","0.6692859","0.6686844","0.6658831","0.6651606","0.6640636","0.662825","0.6622283","0.6618436","0.6614192","0.6600061","0.6592691","0.65646297","0.65421027","0.6528988","0.65227515","0.6520424","0.64834446","0.6480218","0.647229","0.64674926","0.6457893","0.64503956","0.6445306","0.642557","0.6419065","0.64100146","0.6387589","0.63844836","0.63804215","0.63804215","0.63793945","0.63682365","0.63552964","0.63323694","0.63262206","0.6314124","0.6311017","0.6307658","0.6292271","0.6280296","0.627962","0.6277879","0.6277877","0.6272936","0.62563634","0.62432534","0.62325644","0.62306005","0.62199736","0.6219914","0.6218061","0.6217091","0.6216319","0.62156594","0.62156594","0.62156594","0.6211354","0.6210988","0.6203383","0.62004256","0.6198716","0.6197085","0.61961925","0.61928016","0.61919653","0.61918586","0.6176535","0.61745757","0.6158792","0.61527413","0.6149857","0.6127572","0.61273396","0.612205","0.6117889","0.6111066","0.6108476","0.6105486","0.6101202","0.6101153","0.6099881","0.6095138","0.6094204","0.60923094","0.6090812"],"string":"[\n \"0.72552997\",\n \"0.7055899\",\n \"0.7055899\",\n \"0.7009616\",\n \"0.69649035\",\n \"0.6943783\",\n \"0.68921715\",\n \"0.68921447\",\n \"0.68385094\",\n \"0.6832389\",\n \"0.6796779\",\n \"0.6747082\",\n \"0.6738572\",\n \"0.6733773\",\n \"0.6733502\",\n \"0.6733482\",\n \"0.6692859\",\n \"0.6686844\",\n \"0.6658831\",\n \"0.6651606\",\n \"0.6640636\",\n \"0.662825\",\n \"0.6622283\",\n \"0.6618436\",\n \"0.6614192\",\n \"0.6600061\",\n \"0.6592691\",\n \"0.65646297\",\n \"0.65421027\",\n \"0.6528988\",\n \"0.65227515\",\n \"0.6520424\",\n \"0.64834446\",\n \"0.6480218\",\n \"0.647229\",\n \"0.64674926\",\n \"0.6457893\",\n \"0.64503956\",\n \"0.6445306\",\n \"0.642557\",\n \"0.6419065\",\n \"0.64100146\",\n \"0.6387589\",\n \"0.63844836\",\n \"0.63804215\",\n \"0.63804215\",\n \"0.63793945\",\n \"0.63682365\",\n \"0.63552964\",\n \"0.63323694\",\n \"0.63262206\",\n \"0.6314124\",\n \"0.6311017\",\n \"0.6307658\",\n \"0.6292271\",\n \"0.6280296\",\n \"0.627962\",\n \"0.6277879\",\n \"0.6277877\",\n \"0.6272936\",\n \"0.62563634\",\n \"0.62432534\",\n \"0.62325644\",\n \"0.62306005\",\n \"0.62199736\",\n \"0.6219914\",\n \"0.6218061\",\n \"0.6217091\",\n \"0.6216319\",\n \"0.62156594\",\n \"0.62156594\",\n \"0.62156594\",\n \"0.6211354\",\n \"0.6210988\",\n \"0.6203383\",\n \"0.62004256\",\n \"0.6198716\",\n \"0.6197085\",\n \"0.61961925\",\n \"0.61928016\",\n \"0.61919653\",\n \"0.61918586\",\n \"0.6176535\",\n \"0.61745757\",\n \"0.6158792\",\n \"0.61527413\",\n \"0.6149857\",\n \"0.6127572\",\n \"0.61273396\",\n \"0.612205\",\n \"0.6117889\",\n \"0.6111066\",\n \"0.6108476\",\n \"0.6105486\",\n \"0.6101202\",\n \"0.6101153\",\n \"0.6099881\",\n \"0.6095138\",\n \"0.6094204\",\n \"0.60923094\",\n \"0.6090812\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":194,"numItemsPerPage":100,"numTotalItems":95772,"offset":19400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMwMTc2NCwianRpIjoiZWI0OGEwNmQtZmIwMy00Njk3LWE5N2EtMDFlMTA1MTU5MjIwIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMDUzNjQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Q2zcNHmO1g-KD044aHGIg_sk6NWTb0csB2UX63_QathaKWGDPBRQqMNa-EFMZ0ERkqWyIQ1HAK_c8m_yf0gCAw","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 |
|---|---|---|---|---|---|---|
Get a random software license. | def software_license(self) -> str:
return self.random.choice(LICENSES) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_license(self) -> APIReturn:\n return await self._request(\"GET\", \"/getLicense\")",
"def get_license():\n repo_fs()\n return LICENSE",
"def license(self): # noqa: A003\n logger.debug(\"Get license\")\n return self._raw_api.license.get()",
"def license_plate(self) ->... | [
"0.7257501",
"0.71489984",
"0.70458555",
"0.6904726",
"0.6888948",
"0.68682706",
"0.6559753",
"0.63974625",
"0.6345092",
"0.63441616",
"0.63224334",
"0.62866235",
"0.6221269",
"0.6201027",
"0.6021887",
"0.597207",
"0.5964664",
"0.593197",
"0.59197384",
"0.5912311",
"0.5888606... | 0.8545533 | 0 |
Get a random programming language from the list. | def programming_language(self) -> str:
return self.random.choice(PROGRAMMING_LANGS) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def language():\r\n\r\n cursor.execute('SELECT name from languages order by RANDOM() limit 1;')\r\n return cursor.fetchone()[0]",
"def choose_language(self):\n\n current_dir = os.curdir\n path = os.path.join(current_dir, \"audio\")\n languages = os.listdir(path)\n language_num =... | [
"0.7798375",
"0.75217885",
"0.6663096",
"0.657567",
"0.6547032",
"0.6538302",
"0.6538302",
"0.6538302",
"0.6450568",
"0.6426865",
"0.62987846",
"0.6250212",
"0.624393",
"0.62252414",
"0.6214424",
"0.62047374",
"0.61436826",
"0.61385137",
"0.6122823",
"0.6067962",
"0.6052699",... | 0.7644547 | 1 |
Get a random operating system or distributive name. | def os(self) -> str:
return self.random.choice(OS) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_rand_name() -> str:\n suf = \"\".join(random.choices(string.ascii_uppercase + string.digits, k=6))\n return f\"exporters_{suf}\"",
"def GetOSName():\n return Config.osName_",
"def platform_distro():\n distro = platform_information()[0] or ''\n return distro.strip().lower()",
"def... | [
"0.71472675",
"0.7110732",
"0.7060906",
"0.6976703",
"0.69478893",
"0.6882059",
"0.6790889",
"0.6751498",
"0.66147846",
"0.659943",
"0.6580307",
"0.657741",
"0.6558327",
"0.653063",
"0.65062135",
"0.6499304",
"0.6496545",
"0.6487284",
"0.6480682",
"0.6479354",
"0.64615834",
... | 0.7919382 | 0 |
Get a random boolean value. | def boolean(self) -> bool:
return self.random.choice([True, False]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_random_bool() -> bool:\n\n return random.choice([True, False])",
"def random_bool():\n return bool(randint(0, 1))",
"def rand_bool() -> bool:\n # use random() < 0.5 instead of choice([True, False]) since choice\n # is substantially slower\n return rand_uni_val() < 0.5",
"def _rand_bool... | [
"0.90538865",
"0.8984839",
"0.83036524",
"0.80328023",
"0.78080684",
"0.7787965",
"0.7787965",
"0.7749643",
"0.7569312",
"0.7337185",
"0.6960545",
"0.6957034",
"0.6845757",
"0.67257595",
"0.6721427",
"0.6721427",
"0.6425786",
"0.63970894",
"0.63023657",
"0.6301153",
"0.629088... | 0.8287165 | 3 |
Get a random system quality attribute. Within systems engineering, quality attributes are realized nonfunctional requirements used to evaluate the performance of a system. These are sometimes named "ilities" after the suffix many of the words share. | def system_quality_attribute(self) -> str:
return self.random.choice(SYSTEM_QUALITY_ATTRIBUTES) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ility(self) -> str:\n return self.system_quality_attribute()",
"def quality(self):\n try:\n qid = int((self.tool_metadata or {}).get(\"quality\", 0))\n except:\n qid = 0\n\n # We might be able to get the quality strings from the item's tags\n internal_... | [
"0.6713973",
"0.64897156",
"0.61726063",
"0.6065477",
"0.5870625",
"0.55420256",
"0.55384314",
"0.5526172",
"0.541174",
"0.53634155",
"0.53470075",
"0.53367925",
"0.53191906",
"0.52884704",
"0.52797884",
"0.52781254",
"0.52720535",
"0.52499086",
"0.5233074",
"0.5218162",
"0.5... | 0.8372629 | 0 |
Get a random system quality attribute. An alias for system_quality_attribute(). | def ility(self) -> str:
return self.system_quality_attribute() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def system_quality_attribute(self) -> str:\n return self.random.choice(SYSTEM_QUALITY_ATTRIBUTES)",
"def quality(self):\n try:\n qid = int((self.tool_metadata or {}).get(\"quality\", 0))\n except:\n qid = 0\n\n # We might be able to get the quality strings from t... | [
"0.87941146",
"0.61170155",
"0.6050746",
"0.5851535",
"0.5762336",
"0.5579478",
"0.55139697",
"0.5418243",
"0.5411513",
"0.535925",
"0.53295076",
"0.52709144",
"0.52343696",
"0.520349",
"0.51900476",
"0.5188331",
"0.5184759",
"0.5182861",
"0.5176378",
"0.51667213",
"0.5160519... | 0.6239924 | 1 |
Ensure we don't have NaN. | def nonull(val):
return val if not pd.isnull(val) else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ISNA(value):\n return isinstance(value, float) and math.isnan(value)",
"def pd_isnan(val):\n return val is None or val != val",
"def _is_nan(self, x: any) -> bool:\n return isinstance(x, float) and math.isnan(x)",
"def is_scalar_nan(x):\n return isinstance(x, numbers.Real) and math.isnan(x)... | [
"0.74678445",
"0.7439126",
"0.7396373",
"0.73362786",
"0.72977227",
"0.72257054",
"0.72256404",
"0.7209149",
"0.7195599",
"0.70729196",
"0.7055828",
"0.7042421",
"0.703449",
"0.70032156",
"0.6979396",
"0.6954666",
"0.6935699",
"0.6926086",
"0.69070715",
"0.6897858",
"0.688702... | 0.64056647 | 49 |
Traintest validation info and the validity of dataset | def load_dataset_param(splits_path, skeletal_data_path):
f = h5py.File(splits_path, 'r')
tr_subjects = f['tr_subjects'][:].T
te_subjects = f['te_subjects'][:].T
f = h5py.File(skeletal_data_path, 'r')
validity = f['skeletal_data_validity'][:]
return tr_subjects, te_subjects, validity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_data(self):\n\n return self.__valid_data, self.__valid_labels",
"def test_valid_dataset():\n train = ((\"Lorem ipsum dolor sit amet\", 3, 4.5),\n (\"Sed ut perspiciatis unde\", 5, 5.5))\n val = ((\"ipsum quia dolor sit\", 10, 3.5),)\n test = ((\"Ut enim ad minima veniam\", 10... | [
"0.718173",
"0.71711063",
"0.69936323",
"0.6841453",
"0.677554",
"0.6762862",
"0.67480487",
"0.6578853",
"0.6523762",
"0.65092194",
"0.6489128",
"0.64737314",
"0.6444687",
"0.6402101",
"0.63978356",
"0.6348448",
"0.6341878",
"0.63343483",
"0.63258463",
"0.62966496",
"0.629389... | 0.0 | -1 |
Fit scaler and return self Winsorise `X` at `quantile` and `1quantile`. Scale each variable (as long as they aren't binary in which case they are already rules). | def fit(self, X, y=None):
self.fit_transform(X, y)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_transform(self, X, y=None):\n self.scale = np.ones(X.shape[1])\n self.lower = np.percentile(X, self.quantile*100, axis=0)\n self.upper = np.percentile(X, (1-self.quantile)*100, axis=0)\n \n # Winsorize at `self.quantile`\n winX = X.copy()\n is_lower = (winX ... | [
"0.7750412",
"0.69842714",
"0.67774415",
"0.6224853",
"0.59984505",
"0.5898211",
"0.584077",
"0.5825821",
"0.5710472",
"0.56034803",
"0.5498527",
"0.54985",
"0.5478132",
"0.5443603",
"0.5424732",
"0.5424317",
"0.54221374",
"0.5416531",
"0.54004645",
"0.5383857",
"0.5380486",
... | 0.0 | -1 |
Fit scaler and transform input data Winsorise `X` at `quantile` and `1quantile`. Scale each variable (as long as they aren't binary in which case they are already rules). | def fit_transform(self, X, y=None):
self.scale = np.ones(X.shape[1])
self.lower = np.percentile(X, self.quantile*100, axis=0)
self.upper = np.percentile(X, (1-self.quantile)*100, axis=0)
# Winsorize at `self.quantile`
winX = X.copy()
is_lower = (winX < self.lower... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit(self, X):\n q_min, q_max = self.quantile_range\n self.center_ = np.nanmedian(X, axis=0) if self.with_centering else None\n \n if self.with_scaling:\n quantiles = []\n for feature_idx in range(X.shape[1]):\n column_data = X[:, feature_idx]\n ... | [
"0.6935344",
"0.6514156",
"0.6485185",
"0.6348961",
"0.62394345",
"0.606469",
"0.5963839",
"0.591956",
"0.5840398",
"0.58116454",
"0.58023864",
"0.5767737",
"0.5724162",
"0.5704402",
"0.5686381",
"0.5667723",
"0.56520194",
"0.5641679",
"0.5634941",
"0.5634244",
"0.562591",
... | 0.7883213 | 0 |
Transform input data Winsorise `X` at prefitted `quantile` and `1quantile`. Scale each variable (as long as they aren't binary in which case they are already rules) accorded to the already fitted scale factors. | def transform(self, X):
winX = X.copy()
is_lower = (winX <= self.lower)
is_higher = (winX >= self.upper)
for col in range(X.shape[1]):
winX[is_lower[:, col], col] = self.lower[col]
winX[is_higher[:, col], col] = self.upper[col]
return winX*self.scale | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_transform(self, X, y=None):\n self.scale = np.ones(X.shape[1])\n self.lower = np.percentile(X, self.quantile*100, axis=0)\n self.upper = np.percentile(X, (1-self.quantile)*100, axis=0)\n \n # Winsorize at `self.quantile`\n winX = X.copy()\n is_lower = (winX ... | [
"0.75867057",
"0.67999154",
"0.66214746",
"0.5967192",
"0.5888989",
"0.5855381",
"0.5718839",
"0.57124597",
"0.5695854",
"0.56935406",
"0.5588703",
"0.5585414",
"0.5556105",
"0.5542959",
"0.5531994",
"0.55186",
"0.55175906",
"0.54948944",
"0.54849446",
"0.54643995",
"0.545754... | 0.0 | -1 |
Fit model to data | def fit(self, X, y, sample_weight=None):
self.fit_transform(X, y, sample_weight=sample_weight)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit(self, X):",
"def fit_training_data(self):\n self.model.fit(self.X_train)",
"def fit(self, X, y):",
"def fit(self, X, y):",
"def fit(self, X, y):",
"def fit_from_model_data(self, model_data: np.ndarray) -> f.FitDataset:\r\n return f.FitDataset(dataset=self.dataset, model_data=model_d... | [
"0.80873185",
"0.80705625",
"0.7782671",
"0.7782671",
"0.7782671",
"0.7780884",
"0.77498704",
"0.7740986",
"0.7740986",
"0.7740986",
"0.7740986",
"0.7740986",
"0.7740986",
"0.7740986",
"0.7740986",
"0.7740986",
"0.7740986",
"0.7647624",
"0.7614556",
"0.7578705",
"0.75735605",... | 0.0 | -1 |
Transform data into modified features (before being passed to penalised regression step). If `linear_features=True` then this will be scaled linear features followed by the onehotencoding signifying which rules are "on". Otherwise this is just the onehotencoding signifying which rules are "on". | def transform(self, X, y=None):
if isinstance(X, DataFrame):
is_df = True # Serves no purpose
X = check_array(X) # Validate input data
X = self.ext_scaler.transform(X) # Scale and centre features
if self.linear_features:
X_scale = sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_linear_transform(self):\n \n with tf.variable_scope(\"linear_transform\"):\n \n # feature scales/weights\n self.w = tf.get_variable(\"weights\", shape=[self.dim_input], \n initializer= tf.contrib.layers.xavier_initializer())\n ... | [
"0.64672863",
"0.6376041",
"0.620645",
"0.6029789",
"0.59679097",
"0.59625727",
"0.5958583",
"0.5933087",
"0.59234154",
"0.5873284",
"0.57592976",
"0.57417256",
"0.5729975",
"0.57214034",
"0.571568",
"0.57002",
"0.56780124",
"0.56722736",
"0.5665581",
"0.5648128",
"0.56347185... | 0.65656894 | 0 |
Fit and Transform data into modified features (before being passed to penalised regression step). If `linear_features=True` then this will be scaled linear features followed by the onehotencoding signifying which rules are "on". Otherwise this is just the onehotencoding signifying which rules are "on". Fitting process ... | def fit_transform(self, X, y, sample_weight=None):
# Instantiate rule ensemble generator and set parameters
if isinstance(self.base_estimator, XGBClassifier):
self.base_estimator.set_params(n_estimators=self.n_estimators, silent=(self.verbose>0),
max... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_transform(self, X, y=...):\n ...",
"def add_linear_transform(self):\n \n with tf.variable_scope(\"linear_transform\"):\n \n # feature scales/weights\n self.w = tf.get_variable(\"weights\", shape=[self.dim_input], \n initiali... | [
"0.6590726",
"0.643329",
"0.6249411",
"0.615591",
"0.61489266",
"0.6111732",
"0.60932124",
"0.60849077",
"0.607622",
"0.60694087",
"0.6060681",
"0.60569435",
"0.6055038",
"0.6030073",
"0.602565",
"0.60254604",
"0.6016208",
"0.60057116",
"0.59939456",
"0.5983849",
"0.5976737",... | 0.5769847 | 68 |
Get names of features in the model Returns numpy.ndarray | def get_feature_names(self):
if self.linear_features:
self.features_ = np.concatenate([self.features, np.array(self.extract_rules(labels=self.features))], 0)[self.feature_mask_]
else:
self.features_ = np.array(self.extract_rules(labels=self.features))[self.feature_mask_]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_feature_names(self):\n\t\treturn np.array(['nouns', 'adjectives', 'verbs', 'adverbs'])",
"def get_feature_names(self):\n ...",
"def get_feature_names(self, input_features=...):\n ...",
"def featureNames(self):\n return [feature.name for feature in self.features]",
"def get_feat... | [
"0.80556595",
"0.7707658",
"0.7469094",
"0.7322007",
"0.7156526",
"0.71266407",
"0.71156085",
"0.69819415",
"0.6880327",
"0.6811052",
"0.6799486",
"0.6770631",
"0.67257535",
"0.67219526",
"0.67001486",
"0.6681642",
"0.6681472",
"0.66336685",
"0.6609487",
"0.6586122",
"0.65850... | 0.75093997 | 2 |
Output model prediction probability | def predict_proba(self, X):
return self.LR.predict_proba(self.transform(X)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prediction_prob(self):\n return self.a[np.arange(self.a.shape[0]), self.prediction]",
"def probability_of_default(model, prediction_features):\n return model.predict_proba(prediction_features)[:, 1]",
"def predict_prob(self, _input_data):\n yhat_probs = (self.merged_model).predict(_input_d... | [
"0.7202168",
"0.7175441",
"0.7088755",
"0.7079597",
"0.7038377",
"0.7032993",
"0.70295215",
"0.69809556",
"0.6980515",
"0.69351923",
"0.69144815",
"0.68655604",
"0.6802924",
"0.6756837",
"0.67535657",
"0.6752373",
"0.67346364",
"0.6727757",
"0.67167795",
"0.6715653",
"0.66885... | 0.0 | -1 |
Extract rule set from single decision tree according to `XGBClassifier` format | def __extract_xgb_dt_rules__(self, dt):
md = self.max_depth + 1 # upper limit of max_depth?
rules = []
levels = np.zeros((md, 3)) # Stores: (feature name, threshold, next node id)
path = []
# Extract feature numbers and thresholds for all nodes
feat_thresh_l = re.find... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_xgboost_dump(model):\n trees= []\n for tree_string in model._Booster.get_dump():\n nodes = [feature_regex.search('t' + node).groupdict() if '[' in node else leaf_regex.search('t' +node).groupdict() for node in tree_string.split('\\n')[:-1]]\n trees.append(nodes)\n return trees",
... | [
"0.5865318",
"0.5536741",
"0.54987574",
"0.5455966",
"0.54210675",
"0.5409109",
"0.5405483",
"0.53791",
"0.53362054",
"0.53147733",
"0.53034365",
"0.52629757",
"0.51678437",
"0.51664716",
"0.51662976",
"0.5051097",
"0.50148183",
"0.49448028",
"0.49409705",
"0.49294248",
"0.49... | 0.63547754 | 0 |
Extract rule set from single decision tree according to sklearn binarytree format | def __extract_dt_rules__(self, dt):
t = dt.tree_ # Get tree object
rules = []
stack = [(0, -1, -1)] # (node id, parent depth, true[<=thresh]/false[>thresh] arm)
path = [(0, -1, -1)] # Begin path at root
while len(stack) > 0: # While nodes to visit is not empty
n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __extract_xgb_dt_rules__(self, dt): \n md = self.max_depth + 1 # upper limit of max_depth?\n rules = []\n levels = np.zeros((md, 3)) # Stores: (feature name, threshold, next node id)\n path = []\n\n # Extract feature numbers and thresholds for all nodes\n feat_thresh... | [
"0.63081384",
"0.5973033",
"0.5891241",
"0.5791572",
"0.57859606",
"0.5680792",
"0.5676548",
"0.56683165",
"0.5648141",
"0.5642845",
"0.56323576",
"0.562277",
"0.5616259",
"0.5608892",
"0.5596876",
"0.55703026",
"0.55625194",
"0.5539325",
"0.54848295",
"0.5470803",
"0.5442930... | 0.63386476 | 0 |
Convert rule represented by an array to readable format | def __convert_rule__(self, x, labels=None, scaler=None):
strop = ['>', '<=']
if scaler is None:
# If no scaler, do not shift or scale
nf = x[:, 0].astype(int).max()+1
scale = np.ones(nf)
center = np.zeros(nf)
else:
scale = scaler.scale... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _serialize_rules(rules):\n result = [(rule_name, str(rule)) for rule_name, rule in rules.items()]\n return sorted(result, key=lambda rule: rule[0])",
"def _serialize_rules(rules):\n result = [(rule_name, str(rule))\n for rule_name, rule in rules.items()]\n return sorted(result, key=l... | [
"0.6082314",
"0.6008946",
"0.59785944",
"0.5761554",
"0.57400596",
"0.56420326",
"0.5561496",
"0.54893786",
"0.54313695",
"0.53977495",
"0.5357339",
"0.5324876",
"0.5305204",
"0.52618265",
"0.5245784",
"0.52239984",
"0.5177636",
"0.5156451",
"0.5146912",
"0.5122297",
"0.51021... | 0.5250311 | 14 |
Extract rules from `base_estimator` | def extract_rules(self, labels=None):
# Extract flat list of rules in array form
if isinstance(self.base_estimator, RandomForestClassifier):
rules = list(it.chain(*[self.__extract_dt_rules__(dt) for dt in self.base_estimator.estimators_]))
elif isinstance(self.base_estimator, Gradien... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _TP_estimator_requirements(estimator):\n if estimator == 'Natural':\n do_DD = True\n do_DR = False\n do_RR = True\n elif estimator == 'Davis-Peebles':\n do_DD = True\n do_DR = True\n do_RR = False\n elif estimator == 'Hewett':\n do_DD = True\n do... | [
"0.5808173",
"0.5672008",
"0.56038344",
"0.55043817",
"0.54182005",
"0.5397512",
"0.5376288",
"0.53144646",
"0.5294726",
"0.52705055",
"0.5173132",
"0.5156924",
"0.5128409",
"0.5119125",
"0.5093487",
"0.5083402",
"0.50692993",
"0.50663245",
"0.50592685",
"0.5044347",
"0.50386... | 0.6383667 | 0 |
Returns offset of symbol name in loader string table. offset of symbol name in loader string table | def getNameOffset(self) -> int:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_dlsym_offset():\n import ctypes\n libdl = ctypes.PyDLL('libdl.so')\n dlopen = ctypes.cast(libdl.dlopen, ctypes.c_void_p).value\n dlsym = ctypes.cast(libdl.dlsym, ctypes.c_void_p).value\n return dlsym - dlopen",
"def get_symbol(self, name):\n if not self.ksymtab_initialized:\n self.... | [
"0.66889083",
"0.6611202",
"0.6203252",
"0.59230924",
"0.5809549",
"0.57707137",
"0.5730276",
"0.5715004",
"0.5666472",
"0.56297314",
"0.56227905",
"0.5597471",
"0.5563141",
"0.55597746",
"0.5537753",
"0.54879636",
"0.5457473",
"0.5412081",
"0.53920466",
"0.53888345",
"0.5384... | 0.6135863 | 3 |
Returns the index of the section, or pseudosection, for the symbol. the index of the section, or pseudosection, for the symbol | def getSectionIndex(self) -> int:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def state_index_for_symbol(self, symbol):\n for idx, state in enumerate(self):\n if state.symbol == symbol:\n return idx\n if value in self.symbol_synonyms:\n return self.index(self.symbol_synonyms[value])\n raise Exception(\"State with symbol of '%s' not d... | [
"0.6868311",
"0.6411154",
"0.6275179",
"0.6243905",
"0.59100974",
"0.5822145",
"0.5802371",
"0.57700807",
"0.5695456",
"0.56313735",
"0.55781096",
"0.557163",
"0.5570825",
"0.55552155",
"0.55312073",
"0.5525112",
"0.5520313",
"0.5517731",
"0.5509883",
"0.55041385",
"0.5454695... | 0.6920975 | 0 |
Typically the symbol's offset within a section. the symbol's offset within a section | def getSymbolValue(self) -> int:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def address(self, symbol):\r\n return self.s_table[symbol]",
"def find_offset(self,value):\n return self.header.find_offset(value)",
"def offset(self):\r\n return self.buf[0].unib[9:11]",
"def Offset(self) -> int:",
"def Offset(self) -> int:",
"def Offset(self) -> int:",
"def word_offs... | [
"0.6427832",
"0.62289804",
"0.6227516",
"0.61876094",
"0.61876094",
"0.61876094",
"0.60639006",
"0.5875493",
"0.5856736",
"0.58552986",
"0.5801007",
"0.578234",
"0.5776204",
"0.5775643",
"0.57363254",
"0.57303596",
"0.5714447",
"0.57119274",
"0.5706985",
"0.5676521",
"0.56670... | 0.55654424 | 29 |
Efficient line counter courtesy of Ryan Ginstrom answer in stack overflow | def map_count(filename):
f = open(filename, "r+")
buf = mmap.mmap(f.fileno(), 0)
lines = 0
readline = buf.readline
while readline():
lines += 1
return lines | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def linecounter(x):\n return linecount(x) + longlines(x)",
"def line_counter(self, event=None):\n try:\n text_area = self.get_current()\n self.canvas.delete('all')\n i = text_area.index(\"@0,0\")\n while True:\n dline = text_area.dlineinfo(... | [
"0.82242316",
"0.7129824",
"0.6832569",
"0.6802114",
"0.67156047",
"0.6707557",
"0.66925406",
"0.6651793",
"0.6629119",
"0.6614643",
"0.6609141",
"0.65214765",
"0.65072346",
"0.6484806",
"0.6471491",
"0.6464803",
"0.644661",
"0.64097726",
"0.6376117",
"0.6325442",
"0.63130695... | 0.6225128 | 29 |
Read logfile with the profiles written | def read_log(prefix):
l = []
with open('%s.log' % prefix) as F:
for line in F:
if 'profile written' not in line:
continue
else:
l.append(line.split()[0])
return l | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_linelog():",
"def log(length, file):\n\n if user_init.check_pre_init() and user_utility.check_drive_init() == 'True':\n \n data = user_utility.read_log(length, file)\n\n for log in data:\n print(log)\n\n\n else:\n user_utility.print_error(\"Sink folder not Fo... | [
"0.64771223",
"0.6366919",
"0.6224004",
"0.6189014",
"0.6156716",
"0.589416",
"0.56880486",
"0.5653552",
"0.5653552",
"0.5563616",
"0.55355364",
"0.55350137",
"0.55187297",
"0.5504658",
"0.5428539",
"0.54203796",
"0.54149693",
"0.5402457",
"0.53929543",
"0.53881913",
"0.53774... | 0.66682994 | 0 |
Execute line with subprocess | def executeLine(line):
pl = Popen(line, shell=True, stderr=PIPE, stdout=PIPE)
o, e = pl.communicate()
return o, e | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subproc(self,line):\n self.set_stdout()\n proc = subprocess.Popen(line.split(),stdout=self.stdout)\n proc.wait() #ensures that the subprocess executes and terminates before returning to the shell",
"def do_shell(self, line):\n os.system(line)",
"def do_shell(self, line):\n ... | [
"0.748457",
"0.7471307",
"0.7392303",
"0.71741265",
"0.7088497",
"0.69453466",
"0.68881345",
"0.6846201",
"0.6814815",
"0.67655087",
"0.6763409",
"0.6605997",
"0.65672106",
"0.6551925",
"0.6531274",
"0.65091294",
"0.64287466",
"0.6407803",
"0.6388115",
"0.63674563",
"0.634924... | 0.78371656 | 0 |
Read a bim/fam files from the plink fileset | def read_BimFam(prefix):
Bnames = ['CHR', 'SNP', 'cM', 'BP', 'A1', 'A2']
bim = pd.read_table('%s.bim' % (prefix), delim_whitespace=True, header=None,
names=Bnames)
Fnames = ['FID', 'IID', 'father', 'mother', 'Sex', 'Phenotype']
fam = pd.read_table('%s.fam' % (prefix), delim_white... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_plink(file_prefix, verbose=True):\n\n fn = {s: \"%s.%s\" % (file_prefix, s) for s in ['bed', 'bim', 'fam']}\n\n with TimeIt(\"Reading %s...\" % fn['bim'], not verbose):\n bim = _read_bim(fn['bim'])\n nmarkers = bim.shape[0]\n\n with TimeIt(\"Reading %s...\" % fn['fam'], not verbose):\n ... | [
"0.64510775",
"0.5825708",
"0.5510868",
"0.55018467",
"0.5465175",
"0.5433269",
"0.54157674",
"0.53745013",
"0.52349013",
"0.5129814",
"0.5121936",
"0.51169163",
"0.50746495",
"0.5056231",
"0.5055647",
"0.50515175",
"0.5049878",
"0.5017783",
"0.5001219",
"0.4999236",
"0.49899... | 0.6117494 | 1 |
Generate and read frequency files and filter based on threshold | def read_freq(bfile, plinkexe, freq_threshold=0.1, maxmem=1700, threads=1):
high = 1 - freq_threshold
low = freq_threshold
if not os.path.isfile('%s.frq.gz' % bfile):
nname = os.path.split(bfile)[-1]
frq = ('%s --bfile %s --freq gz --keep-allele-order --out %s --memory '
'%d -... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_frequencies(self, args):\n\n for file in args.frequencies:\n self._check_valid_file(file[0])",
"def automatic_checking(files):\n for i in range(10):\n fft_checking(files[i])",
"def update_freq_dist(filename):\r\n pass",
"def test_filtered_scan(self):\n self.run... | [
"0.6244121",
"0.615341",
"0.60893506",
"0.6055009",
"0.5997631",
"0.58850914",
"0.58467615",
"0.5836657",
"0.5833301",
"0.5826538",
"0.5804678",
"0.5772488",
"0.5745384",
"0.5713081",
"0.5678326",
"0.56347597",
"0.5622866",
"0.5610701",
"0.56093115",
"0.55927515",
"0.5584923"... | 0.6175935 | 1 |
Generate a list of individuals for training and a list for validation. The list is to be passed to plink. It will take one split as validation and the rest as training. | def train_test_gen_only(prefix, bfile, plinkexe, splits=10, maxmem=1700,
threads=1):
fam = pd.read_table('%s.fam' % bfile, delim_whitespace=True, header=None,
names=['FID', 'IID', 'a', 'b', 'c', 'd'])
fold = int(np.ceil(fam.shape[0] / splits))
msk = fam.IID.is... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def separate_train_valid(positives, validation_split):\n val_set = []\n shuffled_positives = shuffle_annotations(positives)\n upper = int(round(len(shuffled_positives)*validation_split))\n subset = shuffled_positives[0:upper]\n for each in subset:\n val_set.append(each)\n shuffled_pos... | [
"0.694381",
"0.6477071",
"0.63907367",
"0.6256524",
"0.6256524",
"0.6180422",
"0.61586004",
"0.61576384",
"0.6142876",
"0.61150426",
"0.6102051",
"0.60976",
"0.6076763",
"0.6031108",
"0.6026102",
"0.5993668",
"0.59823596",
"0.596547",
"0.59640354",
"0.5938702",
"0.59328055",
... | 0.0 | -1 |
Generate a list of individuals for training and a list for validation. The list is to be passed to plink. It will take one split as validation and the rest as training. | def train_test(prefix, bfile, plinkexe, pheno, splits=10, maxmem=1700,
threads=1):
pheno = read_pheno(pheno)
# trainthresh = (splits - 1) / splits
fn = os.path.split(bfile)[-1]
keeps = {
'%s_train' % prefix: (os.path.join(os.getcwd(), '%s_train.keep' % fn),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def separate_train_valid(positives, validation_split):\n val_set = []\n shuffled_positives = shuffle_annotations(positives)\n upper = int(round(len(shuffled_positives)*validation_split))\n subset = shuffled_positives[0:upper]\n for each in subset:\n val_set.append(each)\n shuffled_pos... | [
"0.69447994",
"0.64780825",
"0.63923746",
"0.62567776",
"0.62567776",
"0.618161",
"0.6159413",
"0.61588293",
"0.6143759",
"0.6115408",
"0.61027634",
"0.60997844",
"0.6078819",
"0.6032173",
"0.60267323",
"0.59953797",
"0.5984372",
"0.5966264",
"0.5965173",
"0.5940122",
"0.5934... | 0.0 | -1 |
Read a phenotype file with plink profile format | def read_pheno(pheno):
if 'FID' in open(pheno).readline():
## asumes that has 3 columns with the first two with headers FID adn
## IID
pheno = pd.read_table(pheno, delim_whitespace=True)
pheno.rename(columns={pheno.columns[-1]: 'Pheno'}, inplace=True)
else:
Pnames = ['FID... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_profile (filename, index):\n \n col_names = ['m', 'r', 'F', 'P', 'rho', 'T', 'u', 's', \n 'c_P', 'gamma_ad', 'nabla_ad', 'mu', 'n_e', \n 'P_e', 'P_rad', 'nabla_rad', 'nabla', 'v_c',\n 'kappa', 'q_nuc', 'q_PP', \n 'q_CNO', 'q_3a', 'q_nun... | [
"0.5962115",
"0.5881954",
"0.58440053",
"0.5538421",
"0.5515155",
"0.5454003",
"0.5426866",
"0.5300091",
"0.5294381",
"0.5292129",
"0.52890533",
"0.52845263",
"0.52685696",
"0.5247038",
"0.5205397",
"0.5202352",
"0.51866144",
"0.514892",
"0.5131193",
"0.5130793",
"0.5128464",... | 0.521891 | 14 |
Parse and sort clumped file | def parse_sort_clump(fn, allsnps):
# make sure allsnps is a series
allsnps = pd.Series(allsnps)
try:
df = pd.read_table(fn, delim_whitespace=True)
except FileNotFoundError:
spl = fn.split('.')
if spl[0] == '':
idx = 1
else:
idx = 0
fn = '.'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _out_order(self, fname):\r\n # t = 1\r\n orderDict = {}\r\n order = []\r\n readWells = False\r\n lastBlock = False\r\n addOrder = False\r\n with open(fname, \"r\") as fp:\r\n for line in fp:\r\n item ... | [
"0.6187829",
"0.6099515",
"0.6068014",
"0.6001136",
"0.59910196",
"0.5986808",
"0.58804303",
"0.5873911",
"0.57860065",
"0.5770826",
"0.5711253",
"0.57094413",
"0.5662024",
"0.5638028",
"0.5623567",
"0.5581438",
"0.553245",
"0.5521676",
"0.55184275",
"0.5508633",
"0.55056983"... | 0.62394416 | 0 |
helper function to parallelize smartcotagsort | def helper_smartsort(grouped, key):
df = grouped.get_group(key)
head = df.loc[df.index[0], :]
tail = df.loc[df.index[1:], :]
return head, tail | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def custom_sort(arr):\n pass",
"def test_three_split():\n run_mergesort([3, 0, 3], [0, 3, 3])",
"def keysort(*args, **kwargs): # real signature unknown\n pass",
"def mergesort_vs_quicksort():\n runtime_merge = []\n runtime_quick = []\n runtime_system = []\n\n for size in array_sizes:\n\n... | [
"0.675029",
"0.6308638",
"0.6267418",
"0.62532204",
"0.6149817",
"0.6148415",
"0.61287344",
"0.6116317",
"0.6070241",
"0.6069463",
"0.60656625",
"0.6064378",
"0.6029623",
"0.6017315",
"0.60042125",
"0.596248",
"0.59614336",
"0.5955538",
"0.59521264",
"0.59444284",
"0.5929214"... | 0.0 | -1 |
helper function to parallelize smartcotagsort | def helper_smartsort2(grouped, key):
df = grouped.get_group(key)
return df.loc[df.index[0], :] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def custom_sort(arr):\n pass",
"def test_three_split():\n run_mergesort([3, 0, 3], [0, 3, 3])",
"def keysort(*args, **kwargs): # real signature unknown\n pass",
"def mergesort_vs_quicksort():\n runtime_merge = []\n runtime_quick = []\n runtime_system = []\n\n for size in array_sizes:\n\n... | [
"0.675029",
"0.6308638",
"0.6267418",
"0.62532204",
"0.6149817",
"0.6148415",
"0.61287344",
"0.6116317",
"0.6070241",
"0.6069463",
"0.60656625",
"0.6064378",
"0.6029623",
"0.6017315",
"0.60042125",
"0.596248",
"0.59614336",
"0.5955538",
"0.59521264",
"0.59444284",
"0.5929214"... | 0.0 | -1 |
perform a 'clumping' based on Cotagging score, but retain all the rest in the last part of the dataframe | def smartcotagsort(prefix, gwascotag, column='Cotagging', ascending=False,
title=None):
picklefile = '%s_%s.pickle' % (prefix, ''.join(column.split()))
if os.path.isfile(picklefile):
with open(picklefile, 'rb') as F:
df, beforetail = pickle.load(F)
else:
print(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top_cat(df_, feature, top=10):\n alphabet = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')\n labels = alphabet[:top]\n other = alphabet[top + 1]\n top_violation_codes = df_.groupby(feature)[feature].count().sort_values(ascending=False).head(\n top).index.tolist()\n map_values ... | [
"0.5458474",
"0.5458474",
"0.53750175",
"0.53088534",
"0.5261422",
"0.52310926",
"0.52100956",
"0.51852643",
"0.5119328",
"0.51189196",
"0.5037852",
"0.502742",
"0.5006158",
"0.50013584",
"0.4982252",
"0.49814147",
"0.49682853",
"0.49582946",
"0.49404126",
"0.49257052",
"0.49... | 0.46529695 | 61 |
Define the range starting by adding one snp up the the first step | def set_first_step(nsnps, step, init_step=2, every=False):
# Fool proofing
if nsnps < 20:
print('Really? running with less than 20 snps? I am setting your step '
'to 1, and making every equals True')
every = True
step = 1
init_step = 1
onesnp = 100. / float(nsnp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def range100(self):\r\n return self.init(100)",
"def incr_min_step( bgn , end , stepSize ):\n # NOTE: The actual step size will be the size that produces an evenly-spaced list of trunc( (end - bgn) / stepSize ) elements\n return np.linspace( bgn , end , num = trunc( (end - bgn) / stepSize ) , endpoi... | [
"0.6326634",
"0.63014925",
"0.62043864",
"0.61233854",
"0.607282",
"0.6032687",
"0.6021261",
"0.59809196",
"0.59704834",
"0.592812",
"0.5888085",
"0.5760751",
"0.57563084",
"0.5753656",
"0.5750209",
"0.5745185",
"0.57287705",
"0.57117313",
"0.5686095",
"0.5671224",
"0.5671058... | 0.6189637 | 3 |
Generate qrange file to be used with plink qrange | def gen_qrange(prefix, nsnps, prunestep, every=False, qrangefn=None):
order = ['label', 'Min', 'Max']
# dtype = {'label': object, 'Min': float, 'Max': float}
if qrangefn is None:
# Define the number of snps per percentage point and generate the range
percentages = set_first_step(nsnps, prune... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_qubits(self):\n return cq.LineQubit.range(4)",
"def process_qrange_file(filename):\n\n f = open(filename, 'r')\n q_ranges = yaml.load(f)\n\n return q_ranges",
"def write_q_table_file(q_table, q_file=\"Q_Table.txt\"):\n file = open(q_file, \"w+\")\n rows = len(q_table)\n c... | [
"0.60668355",
"0.56891936",
"0.5675259",
"0.56339264",
"0.55886894",
"0.5510636",
"0.5363446",
"0.535094",
"0.53416795",
"0.5267484",
"0.5214582",
"0.5211727",
"0.51969045",
"0.5183751",
"0.51725626",
"0.5170478",
"0.51103914",
"0.5081725",
"0.5069747",
"0.50608844",
"0.50602... | 0.6948805 | 0 |
Read the profile file a.k.a. PRS file or scoresum | def read_scored_qr(profilefn, phenofile, alpha, nsnps, score_type='sum'):
if score_type == 'sum':
col = 'SCORESUM'
else:
col = 'SCORE'
# Read the profile
sc = pd.read_table(profilefn, delim_whitespace=True)
# Read the phenotype file
pheno = pd.read_table(phenofile, delim_whitespa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadProfile(fname):\n \n x = np.loadtxt(fname)\n return x[:,1]",
"def read_profile (filename, index):\n \n col_names = ['m', 'r', 'F', 'P', 'rho', 'T', 'u', 's', \n 'c_P', 'gamma_ad', 'nabla_ad', 'mu', 'n_e', \n 'P_e', 'P_rad', 'nabla_rad', 'nabla', 'v_c',\n ... | [
"0.67490244",
"0.6539704",
"0.64265704",
"0.63860035",
"0.6299824",
"0.6296246",
"0.6175478",
"0.61677104",
"0.6160291",
"0.6003463",
"0.59651375",
"0.59021604",
"0.58780545",
"0.5768216",
"0.56579554",
"0.5647066",
"0.561981",
"0.5615413",
"0.560589",
"0.5548813",
"0.5522177... | 0.57425326 | 14 |
Estimate the potential size of an array | def estimate_size(shape):
total_bytes = reduce(np.multiply, shape) * 8
return total_bytes / 1E6 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def array_size(self):\n return self._array_size",
"def num(an_array):\n return an_array.size",
"def ndarray_size(self) -> int:\n pass",
"def get_length(array):\n return len(list(array))",
"def size(self):\n return len(self.arr)",
"def numel(array):\n _import_modules()\n m... | [
"0.754894",
"0.7541969",
"0.7452033",
"0.7308454",
"0.7239921",
"0.7226865",
"0.714513",
"0.7108841",
"0.70963943",
"0.7083458",
"0.7077772",
"0.7043401",
"0.70346034",
"0.7033545",
"0.70216477",
"0.6995221",
"0.6987276",
"0.6980619",
"0.6974536",
"0.694953",
"0.6943104",
"... | 0.7038034 | 12 |
Find the nearest positivedefinite matrix to input A Python/Numpy port of John D'Errico's `nearestSPD` MATLAB code [1], which credits [2] from Ahmed Fasih | def nearestPD(A, threads=1):
isPD = lambda x: da.all(np.linalg.eigvals(x) > 0).compute()
B = (A + A.T) / 2
_, s, V = da.linalg.svd(B)
H = da.dot(V.T, da.dot(da.diag(s), V))
A2 = (B + H) / 2
A3 = (A2 + A2.T) / 2
if isPD(A3):
return A3
spacing = da.spacing(da.linalg.norm(A))
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nearestPD(A):\n\n B = (A + A.T) / 2\n _, s, V = np.linalg.svd(B)\n\n H = np.dot(V.T, np.dot(np.diag(s), V))\n\n A2 = (B + H) / 2\n\n A3 = (A2 + A2.T) / 2\n\n if isPD(A3):\n return A3\n\n spacing = np.spacing(np.linalg.norm(A))\n # The above is different from [1]. It appears that ... | [
"0.68542147",
"0.6521094",
"0.64592224",
"0.63368255",
"0.6250634",
"0.62383735",
"0.61633074",
"0.6163099",
"0.61562115",
"0.6106572",
"0.5934725",
"0.59224224",
"0.58703405",
"0.58235496",
"0.58216244",
"0.5798199",
"0.57948667",
"0.57833314",
"0.5778119",
"0.576644",
"0.57... | 0.6320866 | 4 |
Helper function to paralellize score_qfiles | def single_score_plink(prefix, qr, tup, plinkexe, gwasfn, qrange, frac_snps,
maxmem, threads):
qfile, phenofile, bfile = tup
suf = qfile[qfile.find('_') + 1: qfile.rfind('.')]
ou = '%s_%s' % (prefix, suf)
# score = ('%s --bfile %s --score %s 2 4 7 header --q-score-range %s %s '
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task3(dataset,writepickle=False,pfilename=None,usepickle=True):\n model,bitext = task1(dataset,printoutput = False,writepickle=writepickle,pfile = pfilename,usepickle=usepickle)\n phrases = extract_phrases(bitext,model)\n scored_phrases = phrase_scoring_ranking(phrases,model,dataset,bitext)\n print... | [
"0.575768",
"0.56732047",
"0.5492514",
"0.548684",
"0.54390764",
"0.5437585",
"0.54353154",
"0.5411575",
"0.53655994",
"0.5360998",
"0.53581184",
"0.535637",
"0.5347568",
"0.5334679",
"0.5334244",
"0.53258014",
"0.53248626",
"0.53238755",
"0.5297921",
"0.5297799",
"0.52928126... | 0.5791598 | 0 |
Prune and score a dataframe of sorted snps | def prune_it(df, geno, pheno, label, step=10, threads=1):
print('Prunning %s...' % label)
print('First 200')
gen = ((df.iloc[:i], geno, pheno, label) for i in
range(1, min(201, df.shape[0] + 1), 1))
delayed_results = [dask.delayed(single_score)(*i) for i in gen]
with ProgressBar():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def analyse_and_sort(self, df):\n if (type(df) is pd.Series):\n df = df.to_frame(\"score\")\n elif (type(df) is pd.DataFrame):\n df.columns = [\"score\"]\n df = self._filter(df)\n df = self._argrelmax(df)\n df = self._drop_close_extrema(df) # by = [deb1[0]]... | [
"0.5949003",
"0.57834405",
"0.57237935",
"0.5530729",
"0.5455612",
"0.5381943",
"0.53662086",
"0.5360469",
"0.5339884",
"0.5305047",
"0.5300142",
"0.5277637",
"0.5252278",
"0.5250166",
"0.52499807",
"0.5238071",
"0.5236248",
"0.52102304",
"0.5197937",
"0.5192069",
"0.5158917"... | 0.5152658 | 22 |
Initialize a `METARdata` instance, and set its default property values. | def __init__(self):
self.site = ('http://vortex.plymouth.edu/cgi-bin/gen_statlog-u.cgi')
"""Root of URL to query for data."""
yesterday = datetime.today() - timedelta(days=1)
self.year = yesterday.year
"""Year to get data for."""
self.month = yesterday.month
"""Mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, defaults={}, data=None):\n\n super().__init__(\n defaults={**ThermodynamicsParameters.parameters, **defaults}, data=data\n )",
"def __init__(self):\n\n # initialise the empty mappings dictionary\n self.data = {\n 'loan_id': None,\n ... | [
"0.65249085",
"0.65091693",
"0.6461086",
"0.6457381",
"0.6440995",
"0.6382057",
"0.63357127",
"0.63347465",
"0.63210326",
"0.62682796",
"0.6264791",
"0.6264062",
"0.62361246",
"0.620263",
"0.61959344",
"0.61653787",
"0.6160545",
"0.6140136",
"0.6102526",
"0.6089607",
"0.60844... | 0.0 | -1 |
Return a list of strings of METAR meteorological data for the specified station on sthe specified date. | def get_met_data(self, stn, ignore_errors, retries, **kwargs):
# Validate the common station name and convert it to the
# corresponding official station ID
try:
stn = self.stns[stn]
except:
raise UnknownStationError, stn
# Process the date components in th... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metar_data(station, begin, end, ignore_errors, retries):\n\n def _parse_date(date_str):\n \"\"\"Minimal date parser.\"\"\"\n yr, mo, day = [int(x) for x in date_str.split('-')]\n try:\n return date(yr, mo, day)\n except ValueError:\n raise InvalidDateError, ... | [
"0.6079679",
"0.60203874",
"0.59128946",
"0.5794843",
"0.57113194",
"0.5494066",
"0.5489716",
"0.5488133",
"0.5465871",
"0.53732324",
"0.53613657",
"0.5346025",
"0.5334262",
"0.5303991",
"0.5268003",
"0.5259103",
"0.523938",
"0.52334833",
"0.52326477",
"0.5229239",
"0.5220071... | 0.6702449 | 0 |
Return the METAR data page as a list of strings. | def _get_metars(self, stn, retries):
# Build the URL parameter string. Note that order of the
# parameters apparently matters to vortex.plymouth.edu, so we
# can't use urllib.urlencode()
params = '='.join(('ident', stn))
params += '&' + '='.join(('pl', 'none0'))
params +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def page_data():\n return scrape()",
"def exportAsArray(self):\n data = []\n data.append(self.title)\n data.append(self.director)\n data.append(self.cast)\n data.append(self.producer)\n data.append(self.writer)\n data.append(self.country)\n data.append(s... | [
"0.59596455",
"0.5940351",
"0.5872467",
"0.5713039",
"0.5710403",
"0.57034284",
"0.56698006",
"0.56524384",
"0.55789405",
"0.5549929",
"0.55382067",
"0.55309206",
"0.55184513",
"0.5496536",
"0.5486317",
"0.547058",
"0.54679865",
"0.5464709",
"0.5449131",
"0.5445956",
"0.54454... | 0.52604043 | 61 |
Validate and clean up the METAR data. | def _clean_data(self, stn, ignore_errors):
# Confirm that we got some data, and confirm that it's the
# expected web page by checking the <title> tag contents
if (not self.data) | (not self.data[0].startswith(
'<TITLE>Generate WXP 24-Hour Meteogram</TITLE>')):
if ignore_e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_up_data(self):\n pass",
"def validate_metadata(self):\n\n # check sampling rate\n if self.has_data():\n # check start time\n if self.start != self.run_metadata.time_period.start:\n if (\n self.run_metadata.time_period.start\n ... | [
"0.64654624",
"0.62384987",
"0.6129969",
"0.6084937",
"0.6040723",
"0.5976599",
"0.5952668",
"0.5908923",
"0.5872254",
"0.57705694",
"0.57631445",
"0.5757449",
"0.57375824",
"0.5724756",
"0.56940866",
"0.56893945",
"0.56518936",
"0.56177545",
"0.55992085",
"0.5596849",
"0.559... | 0.60454017 | 4 |
Parse the command line options. | def parse_options():
# Build the option parser
from optparse import OptionParser
desc = ("Retrieve the METAR data for the specified station "
"and date range and write it to stdout.")
parser = OptionParser(description=desc)
parser.usage += ' station'
help = "beginning date for METAR... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_options():\n global parser\n parser.add_option(\"-r\", \"--regions\", dest=\"input_brain_regions\",\n help=\"Input file for brain region data\",\n action=\"store\", type='string')\n\n parser.add_option(\"-g\", \"--gray\", dest=\"input_gray_levels\",\n ... | [
"0.79766136",
"0.790654",
"0.75567454",
"0.75388986",
"0.7532519",
"0.7529125",
"0.74911195",
"0.7424969",
"0.73958135",
"0.73735034",
"0.7299791",
"0.72880006",
"0.7285438",
"0.7278607",
"0.72572947",
"0.7228134",
"0.7213546",
"0.72073394",
"0.715399",
"0.71270114",
"0.71148... | 0.0 | -1 |
Return the METAR data for the specified station and date range. | def metar_data(station, begin, end, ignore_errors, retries):
def _parse_date(date_str):
"""Minimal date parser."""
yr, mo, day = [int(x) for x in date_str.split('-')]
try:
return date(yr, mo, day)
except ValueError:
raise InvalidDateError, begin
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_met_data(self, stn, ignore_errors, retries, **kwargs):\n # Validate the common station name and convert it to the\n # corresponding official station ID\n try:\n stn = self.stns[stn]\n except:\n raise UnknownStationError, stn\n # Process the date comp... | [
"0.7159997",
"0.5764372",
"0.5731595",
"0.5731141",
"0.56950647",
"0.5617954",
"0.5477128",
"0.5425443",
"0.542119",
"0.540292",
"0.5396697",
"0.5381608",
"0.5376013",
"0.536097",
"0.53551173",
"0.53006876",
"0.5294632",
"0.52827334",
"0.5266694",
"0.52493864",
"0.524286",
... | 0.7412664 | 0 |
Class and Instance Variables. | def test_class_and_instance_variables():
# pylint: disable=too-few-public-methods
class Dog:
"""Dog class example"""
kind = "canine" # Class variable shared by all instances.
def __init__(self, name):
self.name = name # Instance variable unique to each instance.
fid... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def variable(self):",
"def __init__():",
"def attributes(self):",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n ... | [
"0.7025008",
"0.67684484",
"0.67454106",
"0.6679362",
"0.6679362",
"0.6679362",
"0.6679362",
"0.6679362",
"0.6679362",
"0.6679362",
"0.6679362",
"0.6679362",
"0.6679362",
"0.66515243",
"0.6616021",
"0.6606844",
"0.6606844",
"0.6606844",
"0.6606844",
"0.6606844",
"0.6606844",
... | 0.0 | -1 |
Add trick to the dog This function illustrate mistaken use of mutable class variable tricks (see below). | def add_trick(self, trick):
self.tricks.append(trick) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_class_and_instance_variables():\n\n # pylint: disable=too-few-public-methods\n class Dog:\n \"\"\"Dog class example\"\"\"\n\n kind = \"canine\" # Class variable shared by all instances.\n\n def __init__(self, name):\n self.name = name # Instance variable unique to e... | [
"0.62275213",
"0.54250777",
"0.5253472",
"0.5125945",
"0.50684893",
"0.50618595",
"0.50537896",
"0.50460774",
"0.50388473",
"0.5032443",
"0.5029293",
"0.5029293",
"0.5029293",
"0.5029293",
"0.5029293",
"0.5029293",
"0.5029293",
"0.5029293",
"0.5029293",
"0.5029293",
"0.502929... | 0.5709575 | 1 |
Add trick to the dog This function illustrate mistaken use of mutable class variable tricks (see below). | def add_trick(self, trick):
self.tricks.append(trick) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_class_and_instance_variables():\n\n # pylint: disable=too-few-public-methods\n class Dog:\n \"\"\"Dog class example\"\"\"\n\n kind = \"canine\" # Class variable shared by all instances.\n\n def __init__(self, name):\n self.name = name # Instance variable unique to e... | [
"0.62278074",
"0.5426456",
"0.52543545",
"0.5125915",
"0.50691813",
"0.50625455",
"0.50529546",
"0.504636",
"0.50389963",
"0.50328195",
"0.50298977",
"0.50298977",
"0.50298977",
"0.50298977",
"0.50298977",
"0.50298977",
"0.50298977",
"0.50298977",
"0.50298977",
"0.50298977",
... | 0.5709806 | 2 |
friend and msg needs to be strings @ this point | def new_message_from_conn(self, friend, msg):
print("new_msg signal activated with friend",friend,"and msg",msg)
if not self.stack.get_child_by_name(friend):
new_chat_window = chat_layout.ChatLayout(orientation=Gtk.Orientation.VERTICAL,friend=friend)
new_chat_window.show_all()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, msg):\n self.msg = msg",
"def __init__(self, msg):\n self.msg = msg",
"def __init__(self, msg):\n self.msg = msg",
"def __init__(self, msg):\n self.msg = msg",
"def __init__(self, msg):\n self.msg = msg",
"def __init__(self, msg):\n self.msg = ... | [
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.6737745",
"0.66940606",
"0.66782755",
"0.6591113",
"0.6541398",
"0.6541398",
"0.6407637",
"0.63755196",
"0.6330417",
"0.62995756",... | 0.0 | -1 |
Start the instance of the class | def __init__(self):
self.db = Databank()
self.db.connection()
# self.db.cursor.execute('USE library') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start (self):\n pass",
"def start (self):\n pass",
"def start(self):\n ...",
"def Start(self) :\n\t\t...",
"def start(self) -> None:\n ...",
"def start(self) -> None:\n ...",
"def start(self):\n pass",
"def start(self):\n pass",
"def start(self):... | [
"0.7587983",
"0.7587983",
"0.7575441",
"0.75613564",
"0.7483918",
"0.7483918",
"0.7472124",
"0.7472124",
"0.7472124",
"0.7472124",
"0.7472124",
"0.7472124",
"0.7472124",
"0.7472124",
"0.74645305",
"0.7455854",
"0.7399919",
"0.7399919",
"0.73621386",
"0.73125386",
"0.73125386"... | 0.0 | -1 |
This method register the book in the books table, but before checks if the books is already registered. I decided to use the barcode in data string, because I can use the both bar code parameters. And the stock is defined in 0, because if the user doesn't pass the stock, the quantity is already set to 0 | def register_book(self, title: str, author: str, price: float, barcode: str, stock=0):
try:
if not self.verify_register(barcode):
self.db.cursor.execute('INSERT INTO books (title, author, price, bar_code, stock) VALUES (%s, %s, %s, '
'%s, %s)', ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_book(self, data):\n exists = self.check_if_exists(data['isbn'])\n\n if exists:\n query = f\"\"\"UPDATE {TABLE} SET quantity = quantity + 10 WHERE bookID = '{data[\"isbn\"]}'\"\"\"\n else:\n query = f\"\"\"INSERT INTO {TABLE}(bookID, title, authors, avg_rating, rat... | [
"0.7018125",
"0.67015535",
"0.6207142",
"0.6084916",
"0.60626495",
"0.60456854",
"0.59645706",
"0.591887",
"0.5900992",
"0.5860568",
"0.5826839",
"0.57534194",
"0.5710244",
"0.57028556",
"0.5676682",
"0.56455344",
"0.56382316",
"0.5637503",
"0.5599727",
"0.5594511",
"0.558963... | 0.824485 | 0 |
This method update the price of the books, by the barcode. | def update_price_books(self, barcode, new_price):
try:
self.db.cursor.execute('UPDATE books SET price = %s where id_books = %s', (round(new_price, 2), barcode))
except Exception as error:
print(error)
else:
self.db.con.commit()
self.db.con.close()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __on_update_bookticker(self, action, bookticker):\n self.best_bid_price = float(bookticker['b'])\n self.best_ask_price = float(bookticker['a'])",
"def update(self, price, volume):\r\n if price > self.hig:\r\n self.hig = price\r\n if price < self.low:\r\n self... | [
"0.6417695",
"0.62173057",
"0.61378425",
"0.603132",
"0.5936183",
"0.5868149",
"0.58071566",
"0.5730834",
"0.57285744",
"0.5673982",
"0.5657812",
"0.56183827",
"0.5603246",
"0.55851513",
"0.55851513",
"0.55851513",
"0.55851513",
"0.55597377",
"0.555364",
"0.55461675",
"0.5521... | 0.8498672 | 0 |
This method deleted books already registered in the database, by the barcode. | def delete_book(self, barcode):
try:
self.db.cursor.execute('DELETE FROM books where id_books = %s', (barcode,))
except Exception as error:
print(error)
else:
self.db.con.commit()
self.db.con.close()
print('Deleted Successfully!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, book_info, destroy):\n self.connect()\n bid = book_info[0].get()\n\n delete_sql = f\"delete from {self.book_table} where bid = '{bid}'\"\n delete_issue = f\"delete from {self.issued_table} where bid = '{bid}'\"\n try:\n self.cur.execute(delete_sql)\n ... | [
"0.72892725",
"0.7267948",
"0.70717716",
"0.6985194",
"0.6930456",
"0.6827797",
"0.6826523",
"0.6772539",
"0.67015284",
"0.6700609",
"0.6663117",
"0.66131103",
"0.6519632",
"0.6362935",
"0.63454336",
"0.63371575",
"0.6292271",
"0.62690663",
"0.6228916",
"0.6208259",
"0.614254... | 0.8566365 | 0 |
This method return the specifications of the books, consulting the database by barcode | def consult_books(self, bar_code: str):
try:
book_data = []
self.db.cursor.execute('SELECT * from books WHERE bar_code = %s', (bar_code,))
for i in self.db.cursor.fetchall():
book_data.append(i)
except Exception as error:
print(error)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_book(code: str) -> Dict:\n pass",
"def get_all_books() -> List[Dict]:\n pass",
"def search_for_redbooks(book_codes: tuple):\n\n book_dict = {}\n\n global setup\n\n for book_code in book_codes:\n URI_string = build_URI_string(book_code)\n search_web_page = requests.get(URI_... | [
"0.6242606",
"0.6134235",
"0.61072266",
"0.6074063",
"0.601683",
"0.6006033",
"0.5984732",
"0.59228015",
"0.59210134",
"0.59080076",
"0.5892924",
"0.5887974",
"0.5790417",
"0.577142",
"0.57639205",
"0.57627887",
"0.5726483",
"0.5719359",
"0.57189673",
"0.5704592",
"0.5703736"... | 0.7258699 | 0 |
This method checks if the books is already registered in the database, by barcode. | def verify_register(self, barcode: str):
try:
test = []
self.db.cursor.execute(f'SELECT * FROM books where bar_code = {barcode}')
for i in self.db.cursor.fetchall():
test.append(i)
except Exception as error:
print(error)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_book(self, title: str, author: str, price: float, barcode: str, stock=0):\n try:\n if not self.verify_register(barcode):\n self.db.cursor.execute('INSERT INTO books (title, author, price, bar_code, stock) VALUES (%s, %s, %s, '\n '%... | [
"0.7017784",
"0.6627457",
"0.6388775",
"0.6382595",
"0.6364732",
"0.6298332",
"0.6274584",
"0.6257029",
"0.620658",
"0.6175331",
"0.61634517",
"0.6128748",
"0.6127025",
"0.6117657",
"0.60925686",
"0.6036167",
"0.59862727",
"0.5967401",
"0.59655285",
"0.5958692",
"0.5928705",
... | 0.8429786 | 0 |
A method to generate a nonce to send to the validation server. As specified by the protocol, the nonce must be between 16 and 40 alphanumeric characters long with random unique data. | def generate_nonce():
return uuid4().hex | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nonce():\n return random.randint(0, 4294967295)",
"def nonce():\n return random.randint(0, 4294967295)",
"def _generate_nonce(self):\n return str(random.randrange(100000, 999999))",
"def gen_nonce(self, length=32):\n if(length < 32):\n res = {\"message\": 'Invalid nonce len... | [
"0.8042163",
"0.8042163",
"0.8010228",
"0.7921566",
"0.79005414",
"0.78887206",
"0.78473306",
"0.78447676",
"0.78447676",
"0.77639616",
"0.75877625",
"0.75856775",
"0.748053",
"0.74550116",
"0.7397726",
"0.73679745",
"0.73569447",
"0.7110729",
"0.70935357",
"0.7075415",
"0.70... | 0.8238167 | 0 |
Check that the response is a valid response to our request that is, the otp that was returned is the otp we sent originally, that the nonce that was sent was the nonce we had originally, and that the signature (if C{self.api_key} is not C{None}) is valid | def _verify_response(self, text_response, orig_otp, orig_nonce):
response_dict = dict([line.strip(' ').split('=', 1) for line in
re.split(r'\r\n', text_response)
if line.strip()])
if 'otp' in response_dict and response_dict['otp'] != orig_otp:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_response(self, response):\n pass",
"def _check_response(self, res: requests.Response, token: str) -> None:\n return",
"def verify_response_dict(api_key, response):\n LOGGER.debug('Verifying WSAPI response signature')\n\n # Remove signature from the response\n r = dict(respon... | [
"0.6813327",
"0.6812169",
"0.67820585",
"0.65645856",
"0.6504918",
"0.6386462",
"0.63724524",
"0.6230743",
"0.622919",
"0.6145281",
"0.6137439",
"0.60897577",
"0.608821",
"0.6076044",
"0.607178",
"0.6069999",
"0.60647804",
"0.60482323",
"0.6047397",
"0.60116434",
"0.59915906"... | 0.7006299 | 0 |
If the response code is not 200, raise an error | def _check_200(self, response):
if response.code != 200:
raise YubiKeyVerificationError(
"Received {0} response.".format(response.code))
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raise_if_error(response):\n if response.status_code != 200:\n raise SimpleHTTPException(response)",
"def raise_for_status(response):\n if response.status_code != 200:\n res_data = response.json()\n if (response.status_code, res_data['error']) in error_map:\n raise error... | [
"0.8200442",
"0.77988267",
"0.7796814",
"0.77532864",
"0.77236915",
"0.7602498",
"0.75976735",
"0.75056386",
"0.74018836",
"0.7371521",
"0.73343915",
"0.7306833",
"0.73002267",
"0.7287284",
"0.7269197",
"0.72426486",
"0.719703",
"0.71900296",
"0.7165454",
"0.7154237",
"0.7149... | 0.76849234 | 5 |
See if validation failed | def _check_results(results):
if isinstance(results, list):
# this means that none of the requests succeeded, since
# otherwise the result would be a two-tuple
for i, one_result in enumerate(results):
if self.logger is not None: # pragma: n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_validation(self):\n self.validationFails()",
"def validate():",
"def is_valid(self):\n return not self.errors",
"def is_valid(self) -> bool:\n return self.errors == \"\"",
"def hasErrors(self):\n return False",
"def is_valid(self):\n self.clean()\n retur... | [
"0.78729135",
"0.7572437",
"0.7536559",
"0.73924816",
"0.735434",
"0.732329",
"0.7313274",
"0.7291495",
"0.7260773",
"0.7211988",
"0.71832144",
"0.71390224",
"0.71390224",
"0.71390224",
"0.71390224",
"0.71390224",
"0.70216286",
"0.7015459",
"0.7015459",
"0.7015459",
"0.701545... | 0.0 | -1 |
Verifies an OTP against the validation servers provided to the verifier. It queries all servers in parallel and waits for answers. Servers will not respond positively until it has synchronized the new OTP counter with the other servers, and this will wait until it has received one valid (200, otp and nonce match, and s... | def verify(self, otp, timestamp=None, sl=None, timeout=None):
query_dict = {
'id': self.verifier_id,
'otp': otp,
'nonce': self.generate_nonce()
}
if timestamp is not None:
query_dict['timestamp'] = int(bool(timestamp))
if sl is not None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify_otp(request: Request, body: VerifyOTPIn, db: Session = Depends(get_db)):\n mgr = LoginManager()\n mgr.verify_otp(db, body.identifier, body.code)\n request.session[\"access_token\"] = secrets.token_hex(16)\n return {\"status\": \"OK\"}",
"def sync_remote(self, otp_params, local_params, serv... | [
"0.5752108",
"0.5737716",
"0.56494606",
"0.5645329",
"0.5643826",
"0.5574296",
"0.5451564",
"0.5326181",
"0.53075504",
"0.5299279",
"0.52365446",
"0.52112764",
"0.5197768",
"0.51941586",
"0.51802087",
"0.51605034",
"0.514498",
"0.51412606",
"0.5097546",
"0.508744",
"0.5070752... | 0.68441504 | 0 |
r"""Makes a gif using a list of images. | def make_gif(image_list, gif_name):
if not gif_name.endswith(".gif"):
gif_name += ".gif"
imageio.mimsave(gif_name, [imageio.imread(x) for x in image_list]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_gif():\n anim_file = 'sample/training.gif'\n\n with imageio.get_writer(anim_file, mode='I') as writer:\n filenames = glob.glob('sample/*.jpg')\n filenames = sorted(filenames, key=lambda filename: int(filename[11:-4]))\n for filename in filenames:\n image = imageio.imread(filename)\n ... | [
"0.78579974",
"0.7659993",
"0.7557394",
"0.75059664",
"0.72135156",
"0.7159185",
"0.7140775",
"0.7111952",
"0.69703233",
"0.6958537",
"0.694323",
"0.68651026",
"0.68095165",
"0.68038476",
"0.6797115",
"0.6718196",
"0.6681492",
"0.6675865",
"0.66499966",
"0.66303796",
"0.65588... | 0.818792 | 0 |
wrapper function for starting a net.Server connected to `pipe` | async def net_server(pipe):
server = await net.Server(pipe, host="0.0.0.0", port=8080)
return await server.wait_closed() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def net_proc(pipe):\n asyncio.run(net_server(pipe))",
"def new_server(self, name, pipeline, port=None):\n if port is None:\n port = self.next_port\n self.next_port += 1\n\n self.servers[name] = port\n\n args = [\"owl-server\",\"--port\", str(port)] + pipeline.split()... | [
"0.7584677",
"0.6351429",
"0.6300604",
"0.617805",
"0.60826844",
"0.5990248",
"0.5973056",
"0.5972735",
"0.5965008",
"0.5957159",
"0.5957159",
"0.5944811",
"0.58804023",
"0.5860215",
"0.58540183",
"0.58201164",
"0.58175886",
"0.57931465",
"0.57761294",
"0.5772888",
"0.5771360... | 0.8183566 | 0 |
wrapper for running net_server on its own thread/process | def net_proc(pipe):
asyncio.run(net_server(pipe)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n server = TCPServer((self.host, self.port), TCPHandler)\n server.lymphocytes_getter = self.lymphocytes_getter\n\n #runs forever - so make this thread daemon\n server.serve_forever()",
"async def net_server(pipe):\n server = await net.Server(pipe, host=\"0.0.0.0\", p... | [
"0.7307538",
"0.68068635",
"0.6780022",
"0.6780022",
"0.6734137",
"0.6704307",
"0.668211",
"0.66599005",
"0.6595216",
"0.65842754",
"0.6539571",
"0.65383536",
"0.6500156",
"0.6459733",
"0.64578015",
"0.6419993",
"0.6366262",
"0.6355513",
"0.63487566",
"0.6294894",
"0.62633705... | 0.7150661 | 1 |
wait for both terminal and websocket handlers to run | async def main():
# duplex pipe for communication between network and terminal i/o tasks
net_pipe, term_pipe = aiopipe.aioduplex()
# network process
with net_pipe.detach() as net_pipe:
proc = multiprocessing.Process(target=net_proc, args=(net_pipe,))
proc.start()
terminal = term.T... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait():\n pass",
"def _wait(self):\n conn = None\n try:\n conn = libvirt.open(\"qemu:///system\")\n while True:\n time.sleep(10)\n try:\n state = conn.lookupByName(self.domain).info()[0]\n except (libvirt.l... | [
"0.64092374",
"0.6264127",
"0.6235764",
"0.6235764",
"0.6235764",
"0.6235764",
"0.61184424",
"0.6097051",
"0.6084436",
"0.60687375",
"0.6043218",
"0.60034686",
"0.5994405",
"0.5990241",
"0.59745866",
"0.5932926",
"0.5903162",
"0.58702195",
"0.5852462",
"0.58505785",
"0.584319... | 0.54271877 | 63 |
This is the R^2 test, which measures how much of the variance in y is explained by the model f. It runs from 1 to 1, both being good while 0 is very bad | def R_squared(self):
return 1 - ((self.y - self.y_hat(self.x))**2).sum() / ((self.y - self.y.mean())**2).sum() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def r2_score(self):\n print('R^2 (coefficient of determination) regression score function: ' +\n str(r2_score(self.model.dataset.get_y_test(), self.model.get_predicted())))",
"def evaluate(self, X_test, y_test):\n \n y_pred = self.pipeline.predict(X_test)\n test_rmse = co... | [
"0.6759407",
"0.6602552",
"0.6591278",
"0.6515553",
"0.64896923",
"0.64778274",
"0.6439889",
"0.63823986",
"0.63823986",
"0.63823986",
"0.63823986",
"0.63546026",
"0.63121766",
"0.6311863",
"0.62866527",
"0.6259391",
"0.62301654",
"0.6222997",
"0.6214",
"0.61959684",
"0.61939... | 0.57903486 | 56 |
This is a standard correlation test beteween x and y. A value of 1 or 1 implies that a linear model describes perfectly the data, while a value of 0 implies there is no correlation between x and y | def pearson_r(self):
return ((self.x - self.x.mean()) * (self.y - self.error_weighted_average(self.y, self.dy))).sum() / self.x.std() / self.y.std() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def correlation(x, y):\n stdev_x = standard_deviation(x)\n stdev_y = standard_deviation(y)\n if stdev_x > 0 and stdev_y > 0:\n return covariance(x, y) / stdev_x / stdev_y\n else:\n return 0",
"def correlation(x, y):\n stdev_x = standard_deviation(x)\n stdev_y = standard_deviation(... | [
"0.74524945",
"0.74524945",
"0.72285455",
"0.7078785",
"0.70589435",
"0.6973359",
"0.68641263",
"0.6852631",
"0.68099797",
"0.6698745",
"0.6663148",
"0.6663048",
"0.66623944",
"0.66447544",
"0.6609",
"0.65797305",
"0.6571908",
"0.65042186",
"0.64830023",
"0.6434808",
"0.64323... | 0.0 | -1 |
Create a new user request. Modified from default such that the username is equal to the email address. | def create_account(request):
if request.method == 'POST':
post = request.POST
form = forms.RegisterForm(post)
if form.is_valid():
# create a new user
user = models.HAWCUser.objects.create_user(post['email'],
pos... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_user(self, request):\n if User.query(User.name == request.user_name).get():\n raise endpoints.ConflictException(\n 'A User with that name already exists!')\n user = User(name=request.user_name, email=request.email)\n user.put()\n return StringMessage... | [
"0.8106865",
"0.80964696",
"0.79707193",
"0.79511887",
"0.7939506",
"0.7904408",
"0.7811179",
"0.77868485",
"0.77286077",
"0.7665409",
"0.76530784",
"0.76077586",
"0.76066804",
"0.7586554",
"0.756443",
"0.7548708",
"0.75199914",
"0.7515655",
"0.751103",
"0.7509979",
"0.742550... | 0.0 | -1 |
Dynamic import of CVXOPT dense interface. | def get_cvxopt_dense_intf():
import cvxpy.interface.cvxopt_interface.valuerix_interface as dmi
return dmi.DenseMatrixInterface() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cvxopt_sparse_intf():\n import cvxpy.interface.cvxopt_interface.sparse_matrix_interface as smi\n return smi.SparseMatrixInterface()",
"def dense2cvxopt(value):\n import cvxopt\n return cvxopt.matrix(value, tc='d')",
"def test_import_type_dense():\n x = np.random.rand(7, 11)\n export_d... | [
"0.6213993",
"0.6188066",
"0.59842515",
"0.59137076",
"0.58391494",
"0.55679363",
"0.5485139",
"0.5233388",
"0.5186878",
"0.5140729",
"0.5139248",
"0.5135993",
"0.5131671",
"0.5050744",
"0.5043737",
"0.5000771",
"0.4989075",
"0.49857393",
"0.49512193",
"0.4937559",
"0.4929777... | 0.76370394 | 0 |
Dynamic import of CVXOPT sparse interface. | def get_cvxopt_sparse_intf():
import cvxpy.interface.cvxopt_interface.sparse_matrix_interface as smi
return smi.SparseMatrixInterface() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_import_type_sparse():\n x = sps.csr_matrix(np.random.rand(7, 11))\n export_data('/tmp/test.sparse', x)\n assert x.dtype == import_data('/tmp/test.sparse').dtype",
"def test_import_values_sparse():\n x = sps.csr_matrix(np.random.rand(7, 11))\n export_data('/tmp/test.sparse', x)\n assert... | [
"0.6678251",
"0.6325364",
"0.6168615",
"0.61634254",
"0.6101723",
"0.6002239",
"0.59741104",
"0.5861257",
"0.58531886",
"0.5842924",
"0.5654546",
"0.56046325",
"0.5598766",
"0.559268",
"0.557955",
"0.5525964",
"0.5518082",
"0.550019",
"0.5469042",
"0.5434541",
"0.5425496",
... | 0.76998776 | 0 |
Converts a SciPy sparse matrix to a CVXOPT sparse matrix. | def sparse2cvxopt(value):
import cvxopt
if isinstance(value, (np.ndarray, np.matrix)):
return cvxopt.sparse(cvxopt.matrix(value.astype('float64')), tc='d')
# Convert scipy sparse matrices to coo form first.
elif sp.issparse(value):
value = value.tocoo()
return cvxopt.spmatrix(val... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_sparse(self):\n from divisi2.sparse import SparseMatrix\n return SparseMatrix(self, self.row_labels, self.col_labels)",
"def makesparse(matrix):\n n = matrix[0].size\n elements = []\n for i in range(n):\n for j in range(n):\n if matrix[i][j] != 0 :\n ... | [
"0.74020207",
"0.7093455",
"0.70311135",
"0.6989213",
"0.69172007",
"0.68352145",
"0.6795465",
"0.67651546",
"0.6756018",
"0.6749724",
"0.6736512",
"0.67179906",
"0.66992825",
"0.6644021",
"0.6587182",
"0.65845096",
"0.6561744",
"0.6558976",
"0.65500927",
"0.65500927",
"0.655... | 0.80747503 | 0 |
Converts a NumPy matrix to a CVXOPT matrix. | def dense2cvxopt(value):
import cvxopt
return cvxopt.matrix(value, tc='d') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cvxopt2dense(value):\n return np.array(value)",
"def sparse2cvxopt(value):\n import cvxopt\n if isinstance(value, (np.ndarray, np.matrix)):\n return cvxopt.sparse(cvxopt.matrix(value.astype('float64')), tc='d')\n # Convert scipy sparse matrices to coo form first.\n elif sp.issparse(valu... | [
"0.6312579",
"0.6233762",
"0.58347297",
"0.5797177",
"0.56139076",
"0.5566805",
"0.54767096",
"0.5372099",
"0.53622454",
"0.535068",
"0.5341642",
"0.52930886",
"0.52172667",
"0.5217212",
"0.51898384",
"0.51890403",
"0.5079698",
"0.50713885",
"0.5059637",
"0.5054085",
"0.50439... | 0.66287154 | 0 |
Converts a CVXOPT matrix to a NumPy ndarray. | def cvxopt2dense(value):
return np.array(value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_numpy(x):\r\n return x.squeeze().detach().cpu().numpy()",
"def toarray(x):\n if is_SparseDataFrame(x):\n x = x.to_coo().toarray()\n elif is_SparseSeries(x):\n x = x.to_dense().to_numpy()\n elif isinstance(x, (pd.DataFrame, pd.Series, pd.Index)):\n x = x.to_numpy()\n eli... | [
"0.67291087",
"0.65662235",
"0.6408317",
"0.6399814",
"0.63628644",
"0.6203062",
"0.61928123",
"0.6082726",
"0.6044713",
"0.6028564",
"0.6015846",
"0.5950616",
"0.5935821",
"0.5877838",
"0.58768505",
"0.5856204",
"0.5840025",
"0.58212465",
"0.58202916",
"0.58162457",
"0.58080... | 0.6429498 | 2 |
Is the constant a sparse matrix? | def is_sparse(constant) -> bool:
return sp.issparse(constant) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_sparse(A):\n if isinstance(A, torch.Tensor):\n return A.layout == torch.sparse_coo\n raise TypeError(\"expected Tensor but got %s\" % (type(A).__name__))",
"def is_sparse(tensor):\n return isinstance(tensor, sparse_tensor.SparseTensor)",
"def is_sparse(x: Any, backend=None) -> bool:\r\n ... | [
"0.76833653",
"0.7436849",
"0.74230564",
"0.72037745",
"0.7105081",
"0.6872479",
"0.6814387",
"0.67973125",
"0.67928153",
"0.67843324",
"0.66110086",
"0.6596236",
"0.6586943",
"0.65716755",
"0.6568378",
"0.64620703",
"0.641447",
"0.6402279",
"0.6368499",
"0.62777996",
"0.6246... | 0.7981942 | 0 |
Convert 2D Numpy matrices or arrays to 1D. | def from_2D_to_1D(constant):
if isinstance(constant, np.ndarray) and constant.ndim == 2:
return np.asarray(constant)[:, 0]
else:
return constant | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_1d_array(self):\n return reshape_fns.to_1d(self._obj, raw=True)",
"def _asarray1d(arr, copy=False):\n if copy:\n return asarray(arr).flatten()\n else:\n return asarray(arr).ravel()",
"def _to_matrix(self, y):\n if hasattr(y, \"shape\"):\n if len(y.shape) == 1... | [
"0.70328456",
"0.6536092",
"0.6400261",
"0.63641346",
"0.63088894",
"0.62903285",
"0.6238182",
"0.62333584",
"0.6229632",
"0.6153521",
"0.61396265",
"0.61174077",
"0.60771555",
"0.598066",
"0.5975083",
"0.5957192",
"0.5935709",
"0.588951",
"0.5882828",
"0.5869165",
"0.5865906... | 0.6170691 | 9 |
Convert 1D Numpy arrays to matrices. | def from_1D_to_2D(constant):
if isinstance(constant, np.ndarray) and constant.ndim == 1:
return np.mat(constant).T
else:
return constant | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_matrix(array):\n return Matrix(array.tolist())",
"def n2m(a):\n if not isinstance(a, np.ndarray): a = np.array(a)\n return multiprocessing.Array(a.dtype.char, a.flat, lock=False), tuple(a.shape), a.dtype.char, isinstance(a, np.matrix)",
"def array_to_matrix(array):\n\n assert len(array.shape) ... | [
"0.70715255",
"0.65589106",
"0.6528237",
"0.6280818",
"0.6259741",
"0.62007457",
"0.61990327",
"0.61861753",
"0.6150136",
"0.6111489",
"0.60827094",
"0.6006862",
"0.5995141",
"0.5972217",
"0.5919056",
"0.5843375",
"0.5827259",
"0.580557",
"0.57884365",
"0.5774397",
"0.5770293... | 0.0 | -1 |
Convert to appropriate type. | def convert(constant, sparse: bool = False, convert_scalars: bool = False):
if isinstance(constant, (list, np.matrix)):
return DEFAULT_INTF.const_to_matrix(constant,
convert_scalars=convert_scalars)
elif sparse:
return DEFAULT_SPARSE_INTF.const_to_matr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast(self, value):\n if value is None:\n return None\n return self.type(value)",
"def convert(self):\n return",
"def castType(self, valueType, value):\n try:\n return valueType(value)\n except (ValueError, TypeError):\n self.error('incorre... | [
"0.7190359",
"0.7120859",
"0.7052454",
"0.7036384",
"0.6984004",
"0.68194294",
"0.6797164",
"0.67359906",
"0.6674825",
"0.6651274",
"0.6601706",
"0.6600411",
"0.65880376",
"0.65457416",
"0.65385765",
"0.6533269",
"0.6526997",
"0.64172775",
"0.6411281",
"0.6406562",
"0.6404257... | 0.0 | -1 |
Return (is positive, is negative). | def sign(constant):
if isinstance(constant, numbers.Number):
max_val = constant
min_val = constant
elif sp.issparse(constant):
max_val = constant.max()
min_val = constant.min()
else: # Convert to Numpy array.
mat = INTERFACES[np.ndarray].const_to_matrix(constant)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_negative(self, a):\n return a < 0",
"def sign(a):\n return (a > 0) - (a < 0)",
"def isnegative(x):\n if x < 0 :\n return True\n return False",
"def sign(a) :\n return (a>0) - (a<0)",
"def is_Negative(self):\n return self.signature() < 0",
"def positive_only... | [
"0.774261",
"0.7723657",
"0.7689608",
"0.7508066",
"0.7448095",
"0.74278224",
"0.74278224",
"0.74278224",
"0.7404295",
"0.7345145",
"0.7188604",
"0.7182966",
"0.7171951",
"0.71586525",
"0.7152506",
"0.71260065",
"0.71130836",
"0.70752656",
"0.7061648",
"0.70083034",
"0.695955... | 0.0 | -1 |
Return (is real, is imaginary). | def is_complex(constant, tol: float = 1e-5) -> bool:
complex_type = np.iscomplexobj(constant)
if not complex_type:
return True, False
if isinstance(constant, numbers.Number):
real_max = np.abs(np.real(constant))
imag_max = np.abs(np.imag(constant))
elif sp.issparse(constant):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_imaginary(self):\r\n return self._real.is_zero()",
"def is_real(self):\r\n return self._imag.is_zero()",
"def is_imaginary(self) -> bool:\n return self < 0",
"def imag(z):",
"def complex(real, imag):",
"def complex(real=0.0, imag=0.0):\n if imag == 0.0 and real == 0.0:\n ... | [
"0.782439",
"0.7584804",
"0.7500016",
"0.6933671",
"0.6915799",
"0.6833551",
"0.67918944",
"0.6694675",
"0.6663298",
"0.66070265",
"0.6590156",
"0.65633804",
"0.6449115",
"0.6337711",
"0.6312694",
"0.62896824",
"0.62289053",
"0.6220184",
"0.617657",
"0.61523724",
"0.6152128",... | 0.5690715 | 43 |
Check if a matrix is Hermitian and/or symmetric. | def is_hermitian(constant) -> bool:
complex_type = np.iscomplexobj(constant)
if complex_type:
# TODO catch complex symmetric but not Hermitian?
is_symm = False
if sp.issparse(constant):
is_herm = is_sparse_symmetric(constant, complex=True)
else:
is_herm = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_Hermitian(q_1: Qs) -> bool:\n\n hc = Hermitian_conj(q_1, q_1.rows, q_1.columns)\n\n return equals(q_1, hc)",
"def is_symmetric(mat):\n return np.allclose(mat.T, mat)",
"def IsHermitian(self):\n \n Hermitian=True\n for Ind in self.IndList():\n Q=tuple(-x for x in ... | [
"0.7288421",
"0.70511174",
"0.695801",
"0.660251",
"0.6573264",
"0.6567614",
"0.6554783",
"0.6513599",
"0.65056306",
"0.64851743",
"0.64565355",
"0.63981193",
"0.6385611",
"0.63054913",
"0.62993294",
"0.62919945",
"0.6259792",
"0.6143758",
"0.6118125",
"0.6030024",
"0.6024043... | 0.71756566 | 1 |
Check if a sparse matrix is symmetric | def is_sparse_symmetric(m, complex: bool = False) -> bool:
# https://mail.scipy.org/pipermail/scipy-dev/2014-October/020101.html
if m.shape[0] != m.shape[1]:
raise ValueError('m must be a square matrix')
if not isinstance(m, sp.coo_matrix):
m = sp.coo_matrix(m)
r, c, v = m.row, m.col, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def symmetric(matrix):\n return sp.allclose(matrix, matrix.T)",
"def is_symmetric(mat):\n return np.allclose(mat.T, mat)",
"def is_symmetric(mat, eps=None):\n if eps is None:\n eps = np.finfo(mat.dtype).eps\n\n assert mat.ndim == 2\n if mat.shape[0] != mat.shape[1]:\n return False\... | [
"0.8109215",
"0.7986687",
"0.75691277",
"0.7378022",
"0.71965635",
"0.69735336",
"0.6926111",
"0.68735796",
"0.68685687",
"0.68559587",
"0.6809457",
"0.6783302",
"0.66975164",
"0.6593864",
"0.6587962",
"0.65538776",
"0.64825404",
"0.6459463",
"0.6381787",
"0.63341165",
"0.632... | 0.7317553 | 4 |
Get total current value. | def get_total(df):
last_milestone_id = df[df.cmd.notnull()].tail(1).index.get_values()[0]
total = df[last_milestone_id:].value.sum()
return total | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetTotal(self):\n return(self.total)",
"def total(self):\n\t\treturn self._total",
"def total(self) -> float:\n return self._total",
"def total_value(self):\n return self.parent.child_total_value[self.action]",
"def total(self):\n if self.dynamic:\n self._update_d... | [
"0.82439566",
"0.8206046",
"0.814501",
"0.7962158",
"0.7755605",
"0.77370954",
"0.7563143",
"0.75528264",
"0.75345725",
"0.7509995",
"0.74133193",
"0.74117213",
"0.73834187",
"0.7374968",
"0.73463064",
"0.7320118",
"0.7301672",
"0.72930855",
"0.72901803",
"0.7275583",
"0.7254... | 0.0 | -1 |
Walks through the full state trie, yielding one missing node hash/prefix at a time. The yielded node info is wrapped in a TrackedRequest. The hash is marked as active until it is explicitly marked for review again. The hash/prefix will be marked for review asking a peer for the data. Will exit when all known node hashe... | async def _missing_trie_hashes(self) -> AsyncIterator[TrackedRequest]:
# For each account, when we have asked for all known storage and bytecode
# hashes, but some are still not present, we "pause" the account so we can look
# for neighboring nodes.
# This is a list of paused account... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _request_tracking_trie_items(\n self,\n request_tracker: TrieNodeRequestTracker,\n root_hash: Hash32) -> AsyncIterator[Tuple[Nibbles, Nibbles, bytes]]:\n if self._next_trie_root_hash is None:\n # We haven't started beam syncing, so don't know which root ... | [
"0.6850051",
"0.6614492",
"0.5646459",
"0.5422282",
"0.53472066",
"0.5297117",
"0.52896756",
"0.5159195",
"0.50123775",
"0.4973791",
"0.49718073",
"0.4961415",
"0.49293295",
"0.49292937",
"0.4928424",
"0.4927427",
"0.49176684",
"0.4904762",
"0.48756814",
"0.4864487",
"0.48493... | 0.7028946 | 0 |
Walk through the supplied trie, yielding the request tracker and node request for any missing trie nodes. | async def _request_tracking_trie_items(
self,
request_tracker: TrieNodeRequestTracker,
root_hash: Hash32) -> AsyncIterator[Tuple[Nibbles, Nibbles, bytes]]:
if self._next_trie_root_hash is None:
# We haven't started beam syncing, so don't know which root to start a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _missing_trie_hashes(self) -> AsyncIterator[TrackedRequest]:\n # For each account, when we have asked for all known storage and bytecode\n # hashes, but some are still not present, we \"pause\" the account so we can look\n # for neighboring nodes.\n # This is a list of pau... | [
"0.6288311",
"0.56712145",
"0.56443197",
"0.5567986",
"0.55481374",
"0.54169506",
"0.5246231",
"0.5213265",
"0.51985264",
"0.51985264",
"0.51985264",
"0.51985264",
"0.5185277",
"0.5173819",
"0.5107165",
"0.50870496",
"0.50870496",
"0.50827366",
"0.50448364",
"0.50392336",
"0.... | 0.6903136 | 0 |
Walks through the storage trie at the given root, yielding one missing storage node hash/prefix at a time. The yielded node info is wrapped in a ``TrackedRequest``. The hash is marked as active until it is explicitly marked for review again. The hash/prefix will be marked for review asking a peer for the data. Will exi... | async def _missing_storage_hashes(
self,
address_hash_nibbles: Nibbles,
storage_root: Hash32,
starting_main_root: Hash32) -> AsyncIterator[TrackedRequest]:
if storage_root == BLANK_NODE_HASH:
# Nothing to do if the storage has an empty root
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _request_tracking_trie_items(\n self,\n request_tracker: TrieNodeRequestTracker,\n root_hash: Hash32) -> AsyncIterator[Tuple[Nibbles, Nibbles, bytes]]:\n if self._next_trie_root_hash is None:\n # We haven't started beam syncing, so don't know which root ... | [
"0.70497036",
"0.6926985",
"0.5630191",
"0.48730353",
"0.48023686",
"0.47926912",
"0.4764393",
"0.46911123",
"0.4685286",
"0.4670354",
"0.46662426",
"0.4628357",
"0.46207827",
"0.45691854",
"0.45436504",
"0.45341483",
"0.44921196",
"0.4481057",
"0.44659668",
"0.4446959",
"0.4... | 0.766844 | 0 |
Checks if this bytecode is missing. If so, yield it and then exit. If not, then exit immediately. This may seem like overkill, and it is right now. But... Code merkelization is coming (theoretically), and the other account and storage trie iterators work similarly to this, so in some ways it's easier to do this "overge... | async def _missing_bytecode_hashes(
self,
address_hash_nibbles: Nibbles,
code_hash: Hash32,
starting_main_root: Hash32) -> AsyncIterator[TrackedRequest]:
if code_hash == EMPTY_SHA3:
# Nothing to do if the bytecode is for the empty hash
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disable_bytecode_generation():\n sentinel, sys.dont_write_bytecode = sys.dont_write_bytecode, True\n\n try:\n yield\n finally:\n sys.dont_write_bytecode = sentinel",
"async def _missing_trie_hashes(self) -> AsyncIterator[TrackedRequest]:\n # For each account, when we have asked ... | [
"0.5561266",
"0.5535464",
"0.5518014",
"0.49592614",
"0.4936246",
"0.4916298",
"0.48616886",
"0.470336",
"0.46492574",
"0.4646029",
"0.46459916",
"0.46368012",
"0.4590937",
"0.45884967",
"0.4579382",
"0.4562117",
"0.45618558",
"0.45422032",
"0.4526873",
"0.4470122",
"0.446246... | 0.713805 | 0 |
Estimate the completed fraction of the trie that is contiguous with the current index (which rotates every 32 blocks) It will be probably be quite noticeable that it will get "stuck" when downloading a lot of storage, because we'll have to blow it up to more than a percentage to see any significant change within 32 blo... | def _contiguous_accounts_complete_fraction(self) -> float:
starting_index = bytes_to_nibbles(self._next_trie_root_hash)
unknown_prefixes = self._account_tracker._trie_fog._unexplored_prefixes
if len(unknown_prefixes) == 0:
return 1
# find the nearest unknown prefix (typicall... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fraction_completed(self):\n return sum(self._chunk_done.values()) / len(self.chunks)",
"def get_utilization(self):\n child_prefixes = Prefix.objects.filter(prefix__net_contained_or_equal=str(self.prefix))\n # Remove overlapping prefixes from list of children\n networks = cidr_merg... | [
"0.57871044",
"0.57394934",
"0.5700969",
"0.557595",
"0.55153626",
"0.5491407",
"0.54715765",
"0.54007584",
"0.53748786",
"0.5336496",
"0.5328934",
"0.5310399",
"0.5259188",
"0.52554494",
"0.5247512",
"0.5241603",
"0.5217785",
"0.51893973",
"0.51840824",
"0.5177834",
"0.51671... | 0.764008 | 0 |
Stop iterating this node, until mark_for_review() is called | def pause_review(self, prefix: Nibbles) -> None:
self._active_prefixes.add(prefix) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _review_printer(self):\n cont = input(\"Read a review? (y/n) \")\n if cont == 'y':\n review_count = len(self.user_reviews)\n for i in range(review_count):\n # Cycles through all reviews one at a time (amount is chosen by user)\n print('\\n' + se... | [
"0.55926895",
"0.5364128",
"0.5353215",
"0.5327375",
"0.5236763",
"0.5153191",
"0.5037302",
"0.5021179",
"0.5010047",
"0.49338165",
"0.49248472",
"0.49155876",
"0.49141592",
"0.48874277",
"0.4864139",
"0.4858734",
"0.48342335",
"0.4833316",
"0.48259443",
"0.48172835",
"0.4799... | 0.0 | -1 |
Return the Trie Fog that can be searched, ignoring any nodes that are currently being requested. | def _get_eligible_fog(self) -> fog.HexaryTrieFog:
return self._trie_fog.mark_all_complete(self._active_prefixes) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def empty_trie():\n trie = Trie()\n return trie",
"def empty_trie():\n from trie import Trie\n trie = Trie()\n return trie",
"def traversal_test_trie():\n from trie import Trie\n trie = Trie()\n trie.insert('alpha')\n trie.insert('alpaca')\n trie.insert('boy')\n return trie",
... | [
"0.5776142",
"0.57360816",
"0.5326462",
"0.5315044",
"0.5267867",
"0.5225813",
"0.51331353",
"0.5095872",
"0.50827706",
"0.49944326",
"0.49880475",
"0.496863",
"0.48768044",
"0.4836348",
"0.48069534",
"0.4800665",
"0.47692093",
"0.47494227",
"0.47216982",
"0.47108996",
"0.469... | 0.7354035 | 0 |
Return title + episode (if series) | def inclusive_title(self):
return self.title + (" %s" % (self.episode_to_string(self.latest_season, self.latest_episode),) if self.is_series() else "") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def episode_title_for_tvdb(self):\n \n # strip out the year from the episode title:\n return \"Episode %d\"%self.episode_number[1]",
"def episode_title_for_tvdb(self):\n return self.episode_title",
"def episode_title_for_tvdb(self):\n \n # strip out the year from the e... | [
"0.74555385",
"0.7378745",
"0.6963783",
"0.68400466",
"0.66249967",
"0.6508349",
"0.64518964",
"0.6446037",
"0.6445582",
"0.6437754",
"0.6297738",
"0.62690187",
"0.6210943",
"0.6200764",
"0.61216825",
"0.6120273",
"0.611263",
"0.59974575",
"0.5988067",
"0.5951355",
"0.5944540... | 0.7791267 | 0 |
Predicts cluster basing on a data row and the model. | def som_predict(x, som) -> int:
result = som.winner(np.array(x))
return 10 * result[0] + result[1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_cluster(self, inputs):\n if not self.trained:\n if self.verbose:\n print(\"KMeans Model Class - Predict Cluster Function: No trained model\")\n return -1\n\n\n return self.model.predict(inputs)",
"def predict(toPredict=None):\n\tif not toPredict:\n\t... | [
"0.7522711",
"0.7326191",
"0.7257883",
"0.70320976",
"0.65632576",
"0.6549994",
"0.6549688",
"0.6518247",
"0.6481188",
"0.6445282",
"0.6443695",
"0.64254546",
"0.6385586",
"0.6377753",
"0.6368531",
"0.6351673",
"0.63453573",
"0.63428134",
"0.6336442",
"0.6334855",
"0.6315561"... | 0.0 | -1 |
Trains selforganizing map and returns train and test datasets with predicted clusters. | def train_som(som_width: int, som_height: int, df: pd.core.frame.DataFrame, df_train: pd.core.frame.DataFrame,
df_test: pd.core.frame.DataFrame, df_train_columns: pd.core.frame.DataFrame, n_iter: int, sigma=0.3,
learning_rate=0.01):
som = MiniSom(som_width, som_height, df_train.shape[1]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_train(self, dataset):\n pd_dataset = pandas.read_csv('../../data/Ragni2016.csv')\n pe = principleextractor.PrincipleExtractor()\n # NOTE this does not use CCOBRA's dataset; if different dataset is to be used, must be specified here and\n # not in the .json; or with argument give... | [
"0.65929526",
"0.61541826",
"0.6041843",
"0.59890664",
"0.5949455",
"0.5890738",
"0.58586735",
"0.5857667",
"0.5801546",
"0.57741946",
"0.5761678",
"0.5756762",
"0.575235",
"0.57209086",
"0.57159173",
"0.569669",
"0.5683529",
"0.5674185",
"0.5626972",
"0.5618207",
"0.56169873... | 0.0 | -1 |
Returns dataframe with mean profit per cluster basing on a df given as an argument | def get_profit_per_cluster(df: pd.core.frame.DataFrame) -> pd.core.frame.DataFrame:
return pd.DataFrame(df.groupby(by='cluster')['profit'].mean(), columns=['profit']).reset_index() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(df_profit_per_cluster_train) >= 3, \"Algorithm, returned less than 3 clusters.\"\n\n df_profit_per_cluster = df_profit_per_clus... | [
"0.77887636",
"0.71788836",
"0.68467784",
"0.64547867",
"0.62752557",
"0.62094164",
"0.6097976",
"0.6032077",
"0.59859556",
"0.5968796",
"0.5952526",
"0.5906807",
"0.59013987",
"0.58965117",
"0.58917665",
"0.5887675",
"0.5864871",
"0.5808137",
"0.5738972",
"0.5717941",
"0.564... | 0.87321883 | 0 |
Basing on a dataframe given as an argument, returns mean profit per class (buy, sell) in training dataset. sort dataframe descending by profit marks 1/3 of clusters with the highest profit as buy marks 1/3 of clusters with the lowest profit as sell if data contains less than 3 different clusters returns AssertionError | def get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:
# if condition returns False, AssertionError is raised:
assert len(df_profit_per_cluster_train) >= 3, "Algorithm, returned less than 3 clusters."
df_profit_per_cluster = df_profit_per_cluster_train.s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test: pd.core.frame.DataFrame,\n buy_clusters_list: List[int], sell_clusters_list: List[int]) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(buy_clusters_list) != 0 and... | [
"0.72233945",
"0.6792338",
"0.6017771",
"0.58476025",
"0.57573664",
"0.5649134",
"0.56137496",
"0.5605749",
"0.56018263",
"0.55858415",
"0.55482686",
"0.55418605",
"0.5532151",
"0.551682",
"0.5425047",
"0.54250115",
"0.5417848",
"0.5410822",
"0.5366402",
"0.53150505",
"0.5294... | 0.78250796 | 0 |
Basing on a dataframe given as an argument, and list of buy and sell clusters returns mean profit per class (buy, sell) in testing dataset. | def get_mean_profit_per_class_from_test_df(df_profit_per_cluster_test: pd.core.frame.DataFrame,
buy_clusters_list: List[int], sell_clusters_list: List[int]) -> tuple:
# if condition returns False, AssertionError is raised:
assert len(buy_clusters_list) != 0 and len(sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_mean_profit_per_class_from_train_df(df_profit_per_cluster_train: pd.core.frame.DataFrame) -> tuple:\n # if condition returns False, AssertionError is raised:\n assert len(df_profit_per_cluster_train) >= 3, \"Algorithm, returned less than 3 clusters.\"\n\n df_profit_per_cluster = df_profit_per_clus... | [
"0.8185011",
"0.7136002",
"0.5966785",
"0.59034175",
"0.58183724",
"0.5765148",
"0.5717098",
"0.56850725",
"0.56474286",
"0.56181526",
"0.5601236",
"0.557191",
"0.55662805",
"0.5527561",
"0.55179936",
"0.55108774",
"0.54241854",
"0.5415164",
"0.5412711",
"0.5410539",
"0.54015... | 0.8361798 | 0 |
Used for creating a final strategy (not for testing) reads preprocessed split into training and testing sets data train som model calculates mean profit per cluster in training dataset gets list of sell and buy clusters | def create_final_strategy(filename: str, columns_list: List[str], som_width=Config.som_width,
som_height=Config.som_height, n_iter=Config.n_iter, sigma=Config.sigma,
learning_rate=Config.learning_rate) -> tuple:
print(
f'Creating final strategy for parame... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main_predefined_split():\n\n average_performance = []\n fold_num = 'predefined'\n output_file_folder = \"output/{}\".format(args.experiment_name)\n output_file_name = \"{}/lnnel_{}.csv\".format(output_file_folder, fold_num)\n Path(output_file_folder).mkdir(parents=True, exist_ok=True)\n args.... | [
"0.67675084",
"0.6755315",
"0.673634",
"0.67276907",
"0.67021465",
"0.66885126",
"0.6578545",
"0.65512574",
"0.65313745",
"0.65287274",
"0.6499436",
"0.64882433",
"0.64505625",
"0.6448712",
"0.6448493",
"0.64040166",
"0.6400989",
"0.63855517",
"0.6363851",
"0.63565266",
"0.63... | 0.62798804 | 31 |
Creates strategy which can be used in testing part of the script. reads preprocessed split into training and testing sets data train som model calculates mean profit per cluster in training and testing dataset gets mean profits | def create_strategy(filename: str, columns_list: List[str], som_width: int, som_height: int, n_iter: int, sigma=0.3,
learning_rate=0.01) -> tuple:
# get prepared data
df, df_prepared, df_train, df_test, df_train_columns = get_data(filename, columns_list)
# train som
final_df_train, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_train_test(option, transform, params, split=0.2):\r\n clip_im_dir = option.clip_im_dir\r\n matting_dir = option.matting_dir\r\n csv_path = option.csv_path\r\n \r\n print(\"create datasets\")\r\n \r\n \r\n data_df = pd.read_csv(csv_path)\r\n # data_df = MergeDataframe(clip_i... | [
"0.67197025",
"0.6372317",
"0.6326024",
"0.62784594",
"0.62007445",
"0.6187098",
"0.61727315",
"0.61609745",
"0.6150832",
"0.61274564",
"0.6109672",
"0.60908484",
"0.60526675",
"0.60400504",
"0.5990867",
"0.59906036",
"0.59859765",
"0.5970628",
"0.5950032",
"0.5942936",
"0.59... | 0.6798001 | 0 |
Returns parameters which should be used in one iteration of the testing process. | def set_model_parameters(test_type: str, parameter_value: float):
# assigning default parameters for the model
som_width = Config.som_width
som_height = Config.som_height
n_iter = Config.n_iter
sigma = Config.sigma
learning_rate = Config.learning_rate
# assign testing parameter to the model... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_test_params(cls, parameter_set=\"default\"):\n params1 = {\n \"n_clusters\": 3,\n \"n_init\": 2,\n \"max_iter\": 2,\n \"tol\": 1e-3,\n \"verbose\": False,\n \"random_state\": 2,\n }\n params2 = {\n \"n_cluster... | [
"0.72552997",
"0.7055899",
"0.7055899",
"0.7009616",
"0.69649035",
"0.6943783",
"0.68921715",
"0.68921447",
"0.68385094",
"0.6832389",
"0.6796779",
"0.6747082",
"0.6738572",
"0.6733773",
"0.6733502",
"0.6733482",
"0.6692859",
"0.6686844",
"0.6658831",
"0.6651606",
"0.6640636"... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.