aerosandbox.modeling ==================== .. py:module:: aerosandbox.modeling Submodules ---------- .. toctree:: :maxdepth: 1 /autoapi/aerosandbox/modeling/black_box/index /autoapi/aerosandbox/modeling/fitting/index /autoapi/aerosandbox/modeling/interpolation/index /autoapi/aerosandbox/modeling/interpolation_unstructured/index /autoapi/aerosandbox/modeling/splines/index /autoapi/aerosandbox/modeling/surrogate_model/index Classes ------- .. autoapisummary:: aerosandbox.modeling.FittedModel aerosandbox.modeling.InterpolatedModel aerosandbox.modeling.UnstructuredInterpolatedModel Functions --------- .. autoapisummary:: aerosandbox.modeling.black_box Package Contents ---------------- .. py:class:: FittedModel(model, x_data, y_data, parameter_guesses, parameter_bounds = None, residual_norm_type = 'L2', fit_type = 'best', weights = None, put_residuals_in_logspace = False, verbose=True) Bases: :py:obj:`aerosandbox.modeling.surrogate_model.SurrogateModel` A model that is fitted to data. Maps from R^N -> R^1. You can evaluate this model at a given point by calling it just like a function, e.g.: >>> my_fitted_model = FittedModel(...) # See FittedModel.__init__ docstring for syntax >>> y = my_fitted_model(x) The input to the model (`x` in the example above) is of the type: * in the general N-dimensional case, a dictionary where: keys are variable names and values are float/array * in the case of a 1-dimensional input (R^1 -> R^1), a float/array. If you're not sure what the input type of `my_fitted_model` should be, just do: >>> print(my_fitted_model) # Displays the valid input type to the model The output of the model (`y` in the example above) is always a float or array. See the docstring __init__ method of FittedModel for more details of how to instantiate and use FittedModel. One might have expected a fitted model to be a literal Python function rather than a Python class - the benefit of having FittedModel as a class rather than a function is that you can easily save (pickle) classes including data (e.g. parameters, x_data, y_data), but you can't do that with functions. And, because the FittedModel class has a __call__ method, you can basically still just think of it like a function. .. py:attribute:: model .. py:attribute:: x_data .. py:attribute:: y_data .. py:attribute:: parameters .. py:attribute:: parameter_guesses .. py:attribute:: parameter_bounds :value: None .. py:attribute:: residual_norm_type :value: 'L2' .. py:attribute:: fit_type :value: 'best' .. py:attribute:: weights .. py:attribute:: put_residuals_in_logspace :value: False .. py:method:: __call__(x) Evaluates the surrogate model at some given input x. The input `x` is of the type: * in the general N-dimensional case, a dictionary where keys are variable names and values are float/array. * in the case of a 1-dimensional input (R^1 -> R^2), a float/array. .. py:method:: goodness_of_fit(type='R^2') Returns a metric of the goodness of the fit. :param type: Type of metric to use for goodness of fit. One of: * "R^2": The coefficient of determination. Strictly speaking only mathematically rigorous to use this for linear fits. https://en.wikipedia.org/wiki/Coefficient_of_determination * "mean_absolute_error" or "mae" or "L1": The mean absolute error of the fit. * "root_mean_squared_error" or "rms" or "L2": The root mean squared error of the fit. * "max_absolute_error" or "Linf": The maximum deviation of the fit from any of the data points. Returns: The metric of the goodness of the fit. .. py:class:: InterpolatedModel(x_data_coordinates, y_data_structured, method = 'bspline', fill_value=np.nan) Bases: :py:obj:`aerosandbox.modeling.surrogate_model.SurrogateModel` A model that is interpolated to structured (i.e., gridded) N-dimensional data. Maps from R^N -> R^1. You can evaluate this model at a given point by calling it just like a function, e.g.: >>> y = my_interpolated_model(x) The input to the model (`x` in the example above) is of the type: * in the general N-dimensional case, a dictionary where: keys are variable names and values are float/array * in the case of a 1-dimensional input (R^1 -> R^1), it can optionally just be a float/array. If you're not sure what the input type of `my_interpolated_model` should be, just do: >>> print(my_interpolated_model) # Displays the valid input type to the model The output of the model (`y` in the example above) is always a float or array. See the docstring __init__ method of InterpolatedModel for more details of how to instantiate and use InterpolatedModel. One might have expected a interpolated model to be a literal Python function rather than a Python class - the benefit of having InterpolatedModel as a class rather than a function is that you can easily save (pickle) classes including data (e.g. parameters, x_data, y_data), but you can't do that with functions. And, because the InterpolatedModel class has a __call__ method, you can basically still just think of it like a function. .. py:attribute:: x_data_coordinates .. py:attribute:: x_data_coordinates_values .. py:attribute:: y_data_structured .. py:attribute:: method :value: 'bspline' .. py:attribute:: fill_value .. py:attribute:: x_data .. py:attribute:: y_data .. py:method:: __call__(x) Evaluates the surrogate model at some given input x. The input `x` is of the type: * in the general N-dimensional case, a dictionary where keys are variable names and values are float/array. * in the case of a 1-dimensional input (R^1 -> R^2), a float/array. .. py:class:: UnstructuredInterpolatedModel(x_data, y_data, x_data_resample = 10, resampling_interpolator = interpolate.RBFInterpolator, resampling_interpolator_kwargs = None, fill_value=np.nan, interpolated_model_kwargs = None) Bases: :py:obj:`aerosandbox.modeling.interpolation.InterpolatedModel` A model that is interpolated to unstructured (i.e., point cloud) N-dimensional data. Maps from R^N -> R^1. You can evaluate this model at a given point by calling it just like a function, e.g.: >>> y = my_interpolated_model(x) The input to the model (`x` in the example above) is of the type: * in the general N-dimensional case, a dictionary where: keys are variable names and values are float/array * in the case of a 1-dimensional input (R^1 -> R^1), it can optionally just be a float/array. If you're not sure what the input type of `my_interpolated_model` should be, just do: >>> print(my_interpolated_model) # Displays the valid input type to the model The output of the model (`y` in the example above) is always a float or array. See the docstring __init__ method of InterpolatedModel for more details of how to instantiate and use UnstructuredInterpolatedModel. .. py:attribute:: x_data_raw_unstructured .. py:attribute:: y_data_raw .. py:function:: black_box(function, n_in = None, n_out = 1, fd_method = 'central', fd_step = None, fd_step_iter = None) Wraps a function as a black box, allowing it to be used in AeroSandbox / CasADi optimization problems. Obtains gradients via finite differences. Assumes that the function's Jacobian is fully dense, always. :param function: :param n_in: :param n_out: :param fd_method: One of: - 'forward' - 'backward' - 'central' - 'smoothed' Returns: