🥮 mooncakes.io

    riantr/moonbit_dowhy/api does not have a README file

    Column

    source
    pub enum Column {
      Numeric(Array[Double])
      Discrete(Array[String])
    }

    The payload of a single column.

    Column::discrete

    source
    fn Column::discrete(values : Array[String]) -> Column

    A column of strings.

    The constructor lives in the package that defines the enum, because a variant whose payload is a mutable array cannot be built directly from another package.

    Column::numeric

    source
    fn Column::numeric(values : Array[Double]) -> Column

    A numeric column.

    The constructor lives in the package that defines the enum, because a variant whose payload is a mutable array cannot be built directly from another package.

    DataFrame

    source
    pub struct DataFrame {
      columns : Map[String, Column]
      order : Array[String]
      nrows : Int
    }

    A tabular data frame.

    DataFrame::column

    source
    fn DataFrame::column(self : DataFrame, name : String) -> Column?

    The raw payload of a column.

    DataFrame::column_names

    source
    fn DataFrame::column_names(self : DataFrame) -> Array[String]

    Column names in order.

    DataFrame::complete_rows

    source
    fn DataFrame::complete_rows(self : DataFrame) -> Array[Int]

    The rows of the frame that hold no missing value.

    A row is missing when one of the numeric columns of the frame holds a value that is not a number in it. A row of a column of strings is never missing.

    The rows are the indices of the frame, in order, so that the caller can take the rows of the frame and the rows of its columns with them.

    DataFrame::copy

    source
    fn DataFrame::copy(self : DataFrame) -> DataFrame

    A copy of the frame.

    The columns are copied as well, so the copy and the original do not share any state.

    DataFrame::design_matrix

    source
    fn DataFrame::design_matrix(self : DataFrame, names : Array[String]) -> 
    Matrix

    Build a design matrix from the given numeric columns, in order.

    DataFrame::discrete

    source
    fn DataFrame::discrete(self : DataFrame, name : String) -> Array[String]

    The string values of a column.

    Raises when the column is missing or not discrete.

    DataFrame::filter

    source
    fn DataFrame::filter(self : DataFrame, mask : Array[Bool]) -> DataFrame

    A frame restricted to the rows selected by the mask.

    DataFrame::from_numeric

    source
    fn DataFrame::from_numeric(order : Array[String], columns : Map[String, Array[Double]]) -> DataFrame

    Build a data frame whose columns are all numeric.

    The column order is the order of order.

    DataFrame::group_by

    source
    fn DataFrame::group_by(self : DataFrame, name : String) -> (Array[Double], Array[Array[Int]])

    Split the rows into groups keyed by the value of a numeric column.

    Returns the group keys in ascending order together with the row indices of every group.

    DataFrame::has_column

    source
    fn DataFrame::has_column(self : DataFrame, name : String) -> Bool

    Whether the frame contains the given column.

    DataFrame::has_missing_values

    source
    fn DataFrame::has_missing_values(self : DataFrame) -> Bool

    Whether the frame holds a value that is not a number.

    This is the predicate of the check the upstream assign_causal_mechanisms does before it assigns the mechanisms of a model: the upstream raises when the data holds missing values and its experimental flag is not set, and MoonBit cannot catch the stop of a function, so the check is available on its own.

    A column of strings cannot hold a missing value, so only the numeric columns of the frame are read.

    DataFrame::is_discrete

    source
    fn DataFrame::is_discrete(self : DataFrame, name : String) -> Bool

    Whether the given column holds discrete values.

    DataFrame::mask_eq

    source
    fn DataFrame::mask_eq(self : DataFrame, name : String, value : Double) -> Array[Bool]

    A mask that selects the rows whose column equals the given value.

    DataFrame::mask_ne

    source
    fn DataFrame::mask_ne(self : DataFrame, name : String, value : Double) -> Array[Bool]

    A mask that selects the rows whose column differs from the given value.

    DataFrame::mask_range

    source
    fn DataFrame::mask_range(self : DataFrame, name : String, lower : Double, upper : Double) -> Array[Bool]

    A mask that selects rows whose numeric column lies in [lower, upper].

    DataFrame::mean

    source
    fn DataFrame::mean(self : DataFrame, name : String) -> Double

    Mean of a numeric column.

    DataFrame::new

    source
    fn DataFrame::new(order : Array[String], columns : Map[String, Column]) -> DataFrame

    Build a data frame from an ordered list of column names and a map of columns.

    DataFrame::nrows

    source
    fn DataFrame::nrows(self : DataFrame) -> Int

    Number of rows.

    DataFrame::numeric

    source
    fn DataFrame::numeric(self : DataFrame, name : String) -> Array[Double]

    The numeric values of a column.

    Raises when the column is missing or not numeric.

    DataFrame::numeric_column_names

    source
    fn DataFrame::numeric_column_names(self : DataFrame) -> Array[String]

    The names of the numeric columns of the frame, in order.

    The estimators use it to pick the columns of a design matrix out of an encoded frame, whose discrete columns became numeric ones.

    DataFrame::of

    source
    fn DataFrame::of(name : String, values : Array[Double]) -> DataFrame

    Build a single column data frame.

    DataFrame::qcut

    source
    fn DataFrame::qcut(self : DataFrame, name : String, q : Int) -> Array[Double]

    Discretise a numeric column into quantile bins, like pandas.qcut.

    The returned column holds the bin index of every row; the bins are the q quantile groups of the values, so the indices run from 0 to q - 1. Rows whose value cannot be assigned (because of too few distinct values) get the bin of their own value.

    DataFrame::select

    source
    fn DataFrame::select(self : DataFrame, names : Array[String]) -> DataFrame

    A frame restricted to the given columns, in the given order.

    DataFrame::sum

    source
    fn DataFrame::sum(self : DataFrame, name : String) -> Double

    Sum of a numeric column.

    DataFrame::take_rows

    source
    fn DataFrame::take_rows(self : DataFrame, rows : Array[Int]) -> DataFrame

    A frame with the given rows, in the given order.

    The rows are given by their index in the frame. An index that is out of range is skipped, so a resample never reads past the end of a column.

    DataFrame::with_column

    source
    fn DataFrame::with_column(self : DataFrame, name : String, column : Column) -> DataFrame

    A frame with an extra (or replaced) column.

    The frame is copied first, so the frame the method is called on is left unchanged; a map is mutated in place and a shared one would change the other frame as well. The number of rows is recomputed, because the new column can be shorter than the frame it is added to.

    DataFrame::with_discrete

    source
    fn DataFrame::with_discrete(self : DataFrame, name : String, values : Array[String]) -> DataFrame

    A frame with an extra discrete column.

    DataFrame::with_numeric

    source
    fn DataFrame::with_numeric(self : DataFrame, name : String, values : Array[Double]) -> DataFrame

    A frame with an extra numeric column.

    Encoders

    source
    pub struct Encoders {
      drop_first : Bool
      encoders : Map[String, OneHotEncoder]
    }

    A registry of the one-hot encoders of a data set.

    This is the port of dowhy.utils.encoding.Encoders: every named set of variables gets its own encoder, so that the same variables are encoded the same way every time.

    Encoders::encode

    source
    fn Encoders::encode(self : Encoders, data : DataFrame, encoder_name : String) -> DataFrame

    Encode the discrete columns of a data frame.

    The encoder of the given name is created when it does not exist yet and is reused afterwards, so that the encoding of a column does not depend on the order the data arrives in.

    Encoders::names

    source
    fn Encoders::names(self : Encoders) -> Array[String]

    The names of the encoders the registry holds.

    Encoders::new

    source
    fn Encoders::new(drop_first : Bool) -> Encoders

    A registry of encoders.

    The first category of every column is dropped unless drop_first is false.

    Encoders::reset

    source
    fn Encoders::reset(self : Encoders) -> Unit

    Forget every encoder, so that the next encoding creates new ones.

    OneHotEncoder

    source
    pub struct OneHotEncoder {
      columns : Array[String]
      categories : Array[Array[String]]
      drop_first : Bool
    }

    The one-hot encoding of the discrete columns of a data frame.

    This is the port of dowhy.utils.encoding, which replaces pandas' get_dummies with sklearn.preprocessing.OneHotEncoder so that new data can be encoded with the encoder that was fitted on the old data, and the encodings stay consistent.

    The categories of a column are its distinct values in lexicographic order, which is what numpy.unique and the sorted categories of pandas produce, and the name of an encoded column is <column>_<category>.

    OneHotEncoder::categories_of

    source
    fn OneHotEncoder::categories_of(self : OneHotEncoder, column : String) -> Array[String]

    The categories of an encoded column, in lexicographic order.

    OneHotEncoder::encoded_columns

    source
    fn OneHotEncoder::encoded_columns(self : OneHotEncoder) -> Array[String]

    The names of the encoded columns.

    OneHotEncoder::fit

    source
    fn OneHotEncoder::fit(data : DataFrame, columns : Array[String], drop_first : Bool) -> OneHotEncoder

    The one-hot encoder of a data frame.

    This is the port of sklearn.preprocessing.OneHotEncoder as the upstream encoding helper uses it: the categories are learned from the data, and the encoder can then encode other data with the same categories.

    OneHotEncoder::get_feature_names_out

    source
    fn OneHotEncoder::get_feature_names_out(self : OneHotEncoder) -> Array[String]

    The names of the columns the encoder produces.

    The name of an encoded column is <column>_<category>, and the name of the first category of a column is missing when the encoder drops it.

    OneHotEncoder::transform

    source
    fn OneHotEncoder::transform(self : OneHotEncoder, data : DataFrame) -> DataFrame

    Encode a data frame with the encoder.

    The columns that are not encoded are kept, in the order they have in the data, and the encoded columns follow them. A value that the encoder has not seen is an error, exactly like it is for sklearn.

    discrete_columns

    source
    fn discrete_columns(data : DataFrame) -> Array[String]

    The names of the discrete columns of a data frame.

    one_hot_encode

    source
    fn one_hot_encode(data : DataFrame, columns : Array[String], drop_first : Bool) -> (DataFrame, OneHotEncoder)

    Encode the discrete columns of a data frame.

    The result is the encoded frame and the encoder that produced it, so that other data can be encoded with it.

    one_hot_encode_with

    source
    fn one_hot_encode_with(data : DataFrame, encoder : OneHotEncoder) -> DataFrame

    Encode a data frame with an encoder that was fitted on other data.

    Source Files