Sets the learning mode.
776956
def _setLearningMode(self):
    
    for column in self.L4Columns:
      column.setParameter("learn", 0, True)
    for column in self.L6Columns:
      column.setParameter("learn", 0, True)

    for column in self.L2Columns:
      column.setParameter("learningMode", 0, True)
    for column in self.L5Columns:
      column.setParameter("learningMode", 0, True)
471696
private function setDefaultConfiguration(): void
    {
        $this->parameterBag->set('app.devmode', false);
        $this->parameterBag->set('container.dumper.inline_class_loader', true);

        $this->config->addPass($this->parameterBag);
    }
1217974
public void setOrtho() {
		matrixMode(MatrixMode.PROJECTION);
		resetMatrix();
		gl.glOrtho(0, this.width, 0, this.height, -1.0e10, 1.0e10);
		matrixMode(MatrixMode.MODELVIEW);
		resetMatrix();
	}
1051793
def set_enable(cls, target, enable=True):
        """"""

        interceptors = cls.get_annotations(target)

        for interceptor in interceptors:
            setattr(interceptor, Interceptor.ENABLE, enable)
696640
public synchronized void setMode(IndexerIoMode mode)
   {
      if (this.mode != mode)
      {
         log.info("Indexer io mode=" + mode);
         this.mode = mode;
         for (IndexerIoModeListener listener : listeners)
         {
            listener.onChangeMode(mode);
         }
      }
   }
1134341
private void setModelContext(InstancesHeader ih){
		//TODO possibly refactored
        if ((ih != null) && (ih.classIndex() < 0)) {
            throw new IllegalArgumentException(
                    "Context for a classifier must include a class to learn");
        }
        //TODO: check flag for checking whether training has started or not
        
        //model context is used to describe the model
		logger.trace("Model context: {}", ih.toString());
	}
815848
def on_train_end(self, **kwargs):
        ""
        if self.every=="improvement" and (self.learn.path/f'{self.learn.model_dir}/{self.name}.pth').is_file():
            self.learn.load(f'{self.name}', purge=False)
92426
public void setMode(String mode) {
        checkNotNull(mode, "mode should not be null");
        if (MODE_ASYNC.equals(mode) || MODE_SYNC.equals(mode)) {
            this.mode = mode;
        } else {
            throw new IllegalArgumentException("illegal mode: " + mode);
        }
    }
549447
public void setEnabled(boolean enabled) {
		super.setEnabled(enabled);

		if (dayChooser != null) {
			dayChooser.setEnabled(enabled);
			monthChooser.setEnabled(enabled);
			yearChooser.setEnabled(enabled);
		}
	}
296244
def initialize(self, training_info, model, environment, device):
        
        if self.trust_region:
            self.average_model = self.model_factory.instantiate(action_space=environment.action_space).to(device)
            self.average_model.load_state_dict(model.state_dict())
1364583
def do_setmode(self, arg):
        '''  '''
        op_modes = config.get_op_modes()
        if arg in op_modes:
            op_mode = op_modes[arg]
            op_mode.cmdloop()
        else:
            print("Error: unknown operational mode, please use 'help setmode'.")
722143
def learn(self, msg, learnas):
        """"""
        if not isinstance(learnas, types.StringTypes):
            raise SpamCError('The learnas option is invalid')
        if learnas.lower() == 'forget':
            resp = self.tell(msg, 'forget')
        else:
            resp = self.tell(msg, 'learn', learnas)
        return resp
1010234
def set_alarm_mode(self, mode):
        
        values = {"desired_state": {"alarm_mode": mode}}
        response = self.api_interface.set_device_state(self, values)
        self._update_state_from_response(response)
317102
public T setDeployMode(String mode) {
    checkNotNull(mode, "mode");
    builder.deployMode = mode;
    return self();
  }
1070505
def _train(self, trial):
        """"""

        assert trial.status == Trial.RUNNING, trial.status
        remote = trial.runner.train.remote()

        # Local Mode
        if isinstance(remote, dict):
            remote = _LocalWrapper(remote)

        self._running[remote] = trial
1225316
def set_initialize_mode(complexity=2):
        
        if complexity == 3:
            WinFile.initialize = WinFile.level3_initialize
            WinFile.init_mode = 3
        elif complexity == 2:
            WinFile.initialize = WinFile.level2_initialize
            WinFile.init_mode = 2
        elif complexity == 1:
            WinFile.initialize = WinFile.level1_initialize
            WinFile.init_mode = 1
        else:
            raise ValueError("complexity has to be 3, 2 or 1.")
953130
def set_operation_mode(self, mode):
        
        if mode == "off":
            desired_state = {"powered": False}
        else:
            desired_state = {"powered": True, "mode": mode}

        response = self.api_interface.set_device_state(self, {
            "desired_state": desired_state
        })

        self._update_state_from_response(response)