Project: 009_Brain_Bandit_A_Biologically_Grounded_Neural_Networ | Function: decide_simulation_multi_dim (iclr)

system: You are an expert Python programmer implementing algorithms from scientific papers.
Complete the masked function based on the algorithm description.
Follow Python best practices and maintain consistent code style.
Return **only** the complete Python function code.

user: Complete this Python function:

**DESCRIPTION:** Core BBN neural dynamics simulation implementing the stochastic differential equations governing neural activity for exploration-exploitation decision making

**KEY TERMS:** {
  "neuro_state": "x (neural state vector)",
  "I_mean": "Iᵢ (mean input current)",
  "I_std": "uncertainty bias term",
  "self.rs": "τ (time constant)",
  "self.w": "wᵢ (synaptic weights)",
  "self.bi": "bᵢ (bias current)",
  "all_effects": "Σⱼwⱼσ(xⱼ) (total synaptic input)"
}

**CONTEXT CODE:**             # plotstandard
            plt.xlabel('X')
            plt.ylabel('Y')
            plt.show()

    def plot_ratio(self):

        neural_history_copy = np.array(self.neuron_comp_history).copy()
        for dim in range(self.dim):
            sns.distplot(neural_history_copy[:, dim],bins=100, label=f"dim={dim}")
        plt.legend()
        plt.show()

    def plot_neural_record(self):
        neural_history_copy = np.array(self.neuron_comp_history).copy().T
        for dim in range(self.dim):
            plt.plot(np.arange(len(neural_history_copy[dim])), neural_history_copy[dim], label=f"dim={dim}")
        plt.legend()
        plt.show()

    def get_choice_probability(self,dim):
        neural_history_copy = np.array(self.neuron_comp_history).copy()
        choice_list = np.argmax(neural_history_copy,axis=-1)
        return len(choice_list[choice_list==dim]) / len(choice_list)


    def decide_simulation(self, r1_mean, r2_mean, r1_std, r2_std, save_history=False, init=False):
        r1_mean = r1_mean*self.w_avg_comp
        r2_mean = r2_mean*self.w_avg_comp
        self.neural_inputs = [r1_mean, r2_mean]
        # print(r2_mean)
        offset = (r1_mean + r2_mean) / 2
        if init:
            neuro_state = np.array((-self.w * self.sig(np.zeros_like(self.n)) + self.bi) / self.rs)
        else:
            neuro_state = self.neuron_comp_history[-1].copy()
        for _ in range(self.step):

            all_effects = np.sum(self.w * self.sig(neuro_state))
            I_mean = np.array([r1_mean-offset, r2_mean-offset])
            I_std = np.array([r1_std*self.w_std_comp, r2_std*self.w_std_comp])
            neuro_state += (self.rs * (-neuro_state)+(-(all_effects - self.w * self.sig(neuro_state)) +
                                                      self.bi + I_mean))*self.dt + np.sqrt(self.dt)*np.random.normal(0,1,self.dim)*np.sqrt(self.nsf**2+I_std**2)
            neuro_state[neuro_state < 0] = 0.
            if save_history:
                self.neuron_comp_history.append(neuro_state.copy())

        self.last_act = np.argmax(neuro_state)
        self.neuro_state = neuro_state.copy()
        return np.argmax(neuro_state)
    def decide_simulation_multi_dim(self, r_mean, r_std, save_history=False, init=False):
        raise NotImplementedError("Function implementation has been masked for testing")
    def theory_calculation(self,r1_mean, r2_mean, r1_std, r2_std ):

        raise NotImplementedError("Function implementation has been masked for testing")
if __name__ == '__main__':



    dim = 2
    varargin = {
        'step': 200000,  # how many steps to run the brain circuit before executing the next movement
        'tau': np.ones(dim),  # decay time constant
        'weights_in': np.ones(dim) * 1.,  # input weights
        'rs': np.ones(dim) * .5,  #
        'w': np.ones(dim) * 4,  # weight of mutual inhibition
        'k': 7. * np.ones(dim),  # sigmoid center
        'n': 1.5 * np.ones(dim),  # sigmoid slope
        'bi': np.ones(dim) * 6.25,  # baseline production
        'dt': 0.4,  # size of timesteps
        'nsf': 0.,  # noise level
        'w_avg_comp': 1. ,
        'w_std_comp': 1.
    }
    # net = Lyapunov_Worm_Deconstruction(varargin=varargin, dim=dim)
    #
    # r1 = np.random.normal(loc=0, scale=2, size=100000)
    # r2 = np.random.normal(loc=0, scale=0.5, size=100000)
    # # r3 = np.random.normal(loc=2, scale=np.sqrt(10), size=100000)
    # history = []
    # for i in range(dim):
    #
    #     if i == 0 :
    #         history = eval(f"r{i+1}")[np.newaxis, :]
    #     else :
    #         history = np.concatenate([history,eval(f"r{i+1}")[np.newaxis, :]])
    #
    # for i in tqdm(range(1)):
    #     choice = net.decide(history,save_history=True, init=True)
    #
    # plt.figure(figsize=(30, 10))
    # net.plot_neural_record()
    # net.plot_ratio()
    # net.plot_energy()
    # r = net.get_choice_probability(0)
    # print(r)
    # r = net.get_choice_probability(dim-1)
    # print(r)
    # a = np.array(net.neural_inputs)
    # print(np.mean(a,axis=0))
    net = Lyapunov_Worm_Deconstruction(varargin=varargin, dim=dim)
    net.decide_simulation(0., 0., 2., 0.5, save_history=True, init=True)
    p1_simulation = net.get_choice_probability(1)
    print(p1_simulation)
    net.plot_energy()


    # plt.figure(figsize=(30,10))
    # std_history = np.array(net.neuron_std_history)[:,0]
    # avg_history = np.array(net.neuron_avg_history)[:,0]
    # sensory_history = np.array(net.neuron_sensory_history)[:,0]
    # input_history = np.array(net.neural_inputs)[:,0]
    # print(np.mean(input_history))
    # plt.plot(sensory_history, label='sensory')
    # plt.plot(std_history,label='std')
    # plt.plot(input_history,label='input')
    # plt.plot(avg_history,label='avg')
    # plt.legend()
    # plt.show()
    # fig = plt.figure(dpi=128, figsize=(8, 8))
    # ax = fig.add_subplot(111, projection='3d')
    # ax.scatter(y[0], y[1],y[2], s=1.3, marker="o")
    # plt.show()

    """
        varargin = {
        'step_num': 400,  # how many steps to run the brain circuit before executing the next movement
        'tau': np.ones(dim),  # decay time constant
        'weights_in': np.ones(dim) * 1.,  # input weights
        'rs': np.ones(dim) * .5,  #
        'w': np.ones(dim) * 4,  # weight of mutual inhibition
        'k': 7. * np.ones(dim),  # sigmoid center
        'n': 1.5 * np.ones(dim),  # sigmoid slope
        'bi': np.ones(dim) * 6.75,  # baseline production
        'dt': 0.4,  # size of timesteps
        'nsf': 0.3,  # noise level
        'w_avg_comp': 1. / 5,
        'w_std_comp ': 1 / 4 * 3.
    }
    """




Complete the function implementation replacing "raise NotImplementedError".