def random_sample()

in nasrec/base_searcher.py [0:0]

• 125 lines of code
• 9 McCabe index (conditional complexity)

    def random_sample(self):
        vec_configs, vecs = [], []
        for b_id in range(self.num_blocks):
            # macro random search
            block_type_vec = np.random.multinomial(
                1, [1.0 / self.num_block_type] * self.num_block_type
            )
            block_type_id = np.argmax(block_type_vec)
            dense_feat_vec = np.random.binomial(1, 0.5, self.num_dense_feat)
            sparse_feat_vec = np.random.binomial(1, 0.5, self.num_sparse_feat)
            skip_connection_vec = np.random.binomial(1, 0.5, self.num_blocks)
            skip_connection_vec[b_id:] = 0  # cannot connect with later block
            vec_config = {
                "block_type": block_type_id,
                "dense_feat": dense_feat_vec,
                "sparse_feat": sparse_feat_vec,
                "skip_connect": skip_connection_vec,
            }

            # micro random search
            mlp_dense_vec, mlp_emb_vec, cin_vec, att_vec = (
                np.array([]),
                np.array([]),
                np.array([]),
                np.array([]),
            )
            if config.MicroSearchSpaceType.MICRO_MLP in self.micro_space_types:
                if (
                    b_config.ExtendedBlockType.MLP_DENSE
                    in self.controller_option.block_types
                ):
                    mlp_dense_vec = np.argmax(
                        np.random.multinomial(
                            1,
                            [1.0 / len(self.micro_mlp_option.arc)]
                            * len(self.micro_mlp_option.arc),
                        )
                    )
                    vec_config["mlp_dense"] = mlp_dense_vec
                    mlp_dense_vec = np.array([mlp_dense_vec])
                if (
                    b_config.ExtendedBlockType.MLP_EMB
                    in self.controller_option.block_types
                ):
                    mlp_emb_vec = np.argmax(
                        np.random.multinomial(
                            1,
                            [1.0 / len(self.micro_mlp_option.arc)]
                            * len(self.micro_mlp_option.arc),
                        )
                    )
                    vec_config["mlp_emb"] = mlp_emb_vec
                    mlp_emb_vec = np.array([mlp_emb_vec])
            if config.MicroSearchSpaceType.MICRO_CIN in self.micro_space_types:
                if b_config.ExtendedBlockType.CIN in self.controller_option.block_types:
                    cin_width = np.argmax(
                        np.random.multinomial(
                            1,
                            [1.0 / len(self.micro_cin_option.arc)]
                            * len(self.micro_cin_option.arc),
                        )
                    )
                    cin_depth = np.argmax(
                        np.random.multinomial(
                            1,
                            [1.0 / len(self.micro_cin_option.num_of_layers)]
                            * len(self.micro_cin_option.num_of_layers),
                        )
                    )
                    cin_vec = np.array([cin_width, cin_depth])
                    vec_config["cin"] = {"width": cin_width, "depth": cin_depth}
            if config.MicroSearchSpaceType.MICRO_ATTENTION in self.micro_space_types:
                if (
                    b_config.ExtendedBlockType.ATTENTION
                    in self.controller_option.block_types
                ):
                    att_head = np.argmax(
                        np.random.multinomial(
                            1,
                            [1.0 / self.att_num_tokens["head"]]
                            * self.att_num_tokens["head"],
                        )
                    )
                    att_layer = np.argmax(
                        np.random.multinomial(
                            1,
                            [1.0 / self.att_num_tokens["layer"]]
                            * self.att_num_tokens["layer"],
                        )
                    )
                    att_emb_dim = np.argmax(
                        np.random.multinomial(
                            1,
                            [1.0 / self.att_num_tokens["emb"]]
                            * self.att_num_tokens["emb"],
                        )
                    )
                    att_dropout_prob = np.argmax(
                        np.random.multinomial(
                            1,
                            [1.0 / self.att_num_tokens["drop"]]
                            * self.att_num_tokens["drop"],
                        )
                    )
                    att_vec = np.array(
                        [att_head, att_layer, att_emb_dim, att_dropout_prob]
                    )
                    vec_config["attention"] = {
                        "head": att_head,
                        "layer": att_layer,
                        "emb": att_emb_dim,
                        "drop": att_dropout_prob,
                    }
            block_vec = np.concatenate(
                [
                    block_type_vec,
                    dense_feat_vec,
                    sparse_feat_vec,
                    skip_connection_vec,
                    mlp_dense_vec,
                    mlp_emb_vec,
                    cin_vec,
                    att_vec,
                ]
            )
            vecs.append(block_vec)
            vec_configs.append(vec_config)

        # cat the config of a architecture to one vector
        return vecs, vec_configs