def fit( self, x, t=1, x_dot=None, forcing_input=None, initial_forcing_params=None, multiple_trajectories=False, unbias=True, quiet=False, ): if multiple_trajectories: x, x_dot = self.process_multiple_trajectories(x, t, x_dot) else: x = validate_input(x, t) if self.discrete_time: if x_dot is None: x_dot = x[1:] x = x[:-1] else: x_dot = validate_input(x) else: if x_dot is None: x_dot = self.differentiation_method(x, t) else: x_dot = validate_input(x_dot, t) # Drop rows where derivative isn't known x, x_dot = drop_nan_rows(x, x_dot) steps = [("features", self.feature_library), ("model", self.optimizer)] self.model = Pipeline(steps) action = "ignore" if quiet else "default" with warnings.catch_warnings(): warnings.filterwarnings(action, category=ConvergenceWarning) warnings.filterwarnings(action, category=LinAlgWarning) warnings.filterwarnings(action, category=UserWarning) self.model.fit( x, x_dot, model__forcing_input=forcing_input, model__initial_forcing_params=initial_forcing_params, ) self.n_input_features_ = self.model.steps[0][1].n_input_features_ self.n_output_features_ = self.model.steps[0][1].n_output_features_ if self.feature_names is None: feature_names = [] for i in range(self.n_input_features_): feature_names.append("x" + str(i)) self.feature_names = feature_names return self
def score( self, x, t=None, x_dot=None, u=None, multiple_trajectories=False, metric=r2_score, **metric_kws ): """ Returns a score for the time derivative prediction. Parameters ---------- x: array-like or list of array-like, shape (n_samples, n_input_features) Samples t: float, numpy array of shape [n_samples], or list of numpy arrays, optional \ (default None) Time step between samples or array of collection times. Optional, used to compute the time derivatives of the samples if x_dot is not provided. If None, the default time step ``t_default`` will be used. x_dot: array-like or list of array-like, shape (n_samples, n_input_features), \ optional (default None) Optional pre-computed derivatives of the samples. If provided, these values will be used to compute the score. If not provided, the time derivatives of the training data will be computed using the specified differentiation method. u: array-like or list of array-like, shape(n_samples, n_control_features), \ optional (default None) Control variables. If ``multiple_trajectories=True`` then u must be a list of control variable data from each trajectory. If the model was fit with control variables then u is not optional. multiple_trajectories: boolean, optional (default False) If True, x contains multiple trajectories and must be a list of data from each trajectory. If False, x is a single trajectory. metric: metric function, optional Metric function with which to score the prediction. Default is the coefficient of determination R^2. metric_kws: dict, optional Optional keyword arguments to pass to the metric function. Returns ------- score: float Metric function value for the model prediction of x_dot. """ if t is None: t = self.t_default if u is None or self.n_control_features_ == 0: if self.n_control_features_ > 0: raise TypeError( "Model was fit using control variables, so u is required" ) elif u is not None: warnings.warn( "Control variables u were ignored because control variables were" " not used when the model was fit" ) else: trim_last_point = self.discrete_time and (x_dot is None) u = validate_control_variables( x, u, multiple_trajectories=multiple_trajectories, trim_last_point=trim_last_point, ) if multiple_trajectories: x, x_dot = self._process_multiple_trajectories( x, t, x_dot, return_array=True ) else: x = validate_input(x, t) if x_dot is None: if self.discrete_time: x_dot = x[1:] x = x[:-1] else: x_dot = self.differentiation_method(x, t) if ndim(x_dot) == 1: x_dot = x_dot.reshape(-1, 1) # Append control variables if u is not None and self.n_control_features_ > 0: x = concatenate((x, u), axis=1) # Drop rows where derivative isn't known (usually endpoints) x, x_dot = drop_nan_rows(x, x_dot) x_dot_predict = self.model.predict(x) return metric(x_dot, x_dot_predict, **metric_kws)
def fit( self, x, t=None, x_dot=None, u=None, multiple_trajectories=False, unbias=True, quiet=False, ): """ Fit the SINDy model. Parameters ---------- x: array-like or list of array-like, shape (n_samples, n_input_features) Training data. If training data contains multiple trajectories, x should be a list containing data for each trajectory. Individual trajectories may contain different numbers of samples. t: float, numpy array of shape [n_samples], or list of numpy arrays, optional \ (default None) If t is a float, it specifies the timestep between each sample. If array-like, it specifies the time at which each sample was collected. In this case the values in t must be strictly increasing. In the case of multi-trajectory training data, t may also be a list of arrays containing the collection times for each individual trajectory. If None, the default time step ``t_default`` will be used. x_dot: array-like or list of array-like, shape (n_samples, n_input_features), \ optional (default None) Optional pre-computed derivatives of the training data. If not provided, the time derivatives of the training data will be computed using the specified differentiation method. If x_dot is provided, it must match the shape of the training data and these values will be used as the time derivatives. u: array-like or list of array-like, shape (n_samples, n_control_features), \ optional (default None) Control variables/inputs. Include this variable to use sparse identification for nonlinear dynamical systems for control (SINDYc). If training data contains multiple trajectories (i.e. if x is a list of array-like), then u should be a list containing control variable data for each trajectory. Individual trajectories may contain different numbers of samples. multiple_trajectories: boolean, optional, (default False) Whether or not the training data includes multiple trajectories. If True, the training data must be a list of arrays containing data for each trajectory. If False, the training data must be a single array. unbias: boolean, optional (default True) Whether to perform an extra step of unregularized linear regression to unbias the coefficients for the identified support. If the optimizer (``SINDy.optimizer``) applies any type of regularization, that regularization may bias coefficients toward particular values, improving the conditioning of the problem but harming the quality of the fit. Setting ``unbias=True`` enables an extra step wherein unregularized linear regression is applied, but only for the coefficients in the support identified by the optimizer. This helps to remove the bias introduced by regularization. quiet: boolean, optional (default False) Whether or not to suppress warnings during model fitting. Returns ------- self: returns an instance of self """ if t is None: t = self.t_default if u is None: self.n_control_features_ = 0 else: trim_last_point = self.discrete_time and (x_dot is None) u = validate_control_variables( x, u, multiple_trajectories=multiple_trajectories, trim_last_point=trim_last_point, ) self.n_control_features_ = u.shape[1] if multiple_trajectories: x, x_dot = self._process_multiple_trajectories(x, t, x_dot) else: x = validate_input(x, t) if self.discrete_time: if x_dot is None: x_dot = x[1:] x = x[:-1] else: x_dot = validate_input(x_dot) else: if x_dot is None: x_dot = self.differentiation_method(x, t) else: x_dot = validate_input(x_dot, t) # Append control variables if self.n_control_features_ > 0: x = concatenate((x, u), axis=1) # Drop rows where derivative isn't known x, x_dot = drop_nan_rows(x, x_dot) optimizer = SINDyOptimizer(self.optimizer, unbias=unbias) steps = [("features", self.feature_library), ("model", optimizer)] self.model = Pipeline(steps) action = "ignore" if quiet else "default" with warnings.catch_warnings(): warnings.filterwarnings(action, category=ConvergenceWarning) warnings.filterwarnings(action, category=LinAlgWarning) warnings.filterwarnings(action, category=UserWarning) self.model.fit(x, x_dot) self.n_input_features_ = self.model.steps[0][1].n_input_features_ self.n_output_features_ = self.model.steps[0][1].n_output_features_ if self.feature_names is None: feature_names = [] for i in range(self.n_input_features_ - self.n_control_features_): feature_names.append("x" + str(i)) for i in range(self.n_control_features_): feature_names.append("u" + str(i)) self.feature_names = feature_names return self
def score( self, x, t=1, x_dot=None, multiple_trajectories=False, metric=r2_score, **metric_kws ): """ Returns a score for the time derivative prediction. Parameters ---------- x: array-like or list of array-like, shape (n_samples, n_input_features) Samples t: float, numpy array of shape [n_samples], or list of numpy arrays, optional \ (default 1) Time step between samples or array of collection times. Optional, used to compute the time derivatives of the samples if x_dot is not provided. x_dot: array-like or list of array-like, shape (n_samples, n_input_features), \ optional Optional pre-computed derivatives of the samples. If provided, these values will be used to compute the score. If not provided, the time derivatives of the training data will be computed using the specified differentiation method. multiple_trajectories: boolean, optional (default False) If True, x contains multiple trajectories and must be a list of data from each trajectory. If False, x is a single trajectory. metric: metric function, optional Metric function with which to score the prediction. Default is the coefficient of determination R^2. metric_kws: dict, optional Optional keyword arguments to pass to the metric function. Returns ------- score: float Metric function value for the model prediction of x_dot. """ if multiple_trajectories: x, x_dot = self.process_multiple_trajectories( x, t, x_dot, return_array=True ) else: x = validate_input(x, t) if x_dot is None: if self.discrete_time: x_dot = x[1:] x = x[:-1] else: x_dot = self.differentiation_method(x, t) if ndim(x_dot) == 1: x_dot = x_dot.reshape(-1, 1) # Drop rows where derivative isn't known (usually endpoints) x, x_dot = drop_nan_rows(x, x_dot) x_dot_predict = self.model.predict(x) return metric(x_dot_predict, x_dot, **metric_kws)