_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q267100 | assert_satisfies | test | def assert_satisfies(v, cond, message=None):
"""
Assert that variable satisfies the provided condition.
:param v: variable to check. Its value is only used for error reporting.
:param bool cond: condition that must be satisfied. Should be somehow related to the variable ``v``.
:param message: messa... | python | {
"resource": ""
} |
q267101 | _retrieve_assert_arguments | test | def _retrieve_assert_arguments():
"""
Magic variable name retrieval.
This function is designed as a helper for assert_is_type() function. Typically such assertion is used like this::
assert_is_type(num_threads, int)
If the variable `num_threads` turns out to be non-integer, we would like to r... | python | {
"resource": ""
} |
q267102 | _check_type | test | def _check_type(var, vtype):
"""
Return True if the variable is of the specified type, and False otherwise.
:param var: variable to check
:param vtype: expected variable's type
"""
if vtype is None:
return var is None
if isinstance(vtype, _primitive_type):
return var == vtyp... | python | {
"resource": ""
} |
q267103 | _get_type_name | test | def _get_type_name(vtype, dump=None):
"""
Return the name of the provided type.
_get_type_name(int) == "integer"
_get_type_name(str) == "string"
_get_type_name(tuple) == "tuple"
_get_type_name(Exception) == "Exception"
_get_type_name(U(int, float, bool)) == "integer|floa... | python | {
"resource": ""
} |
q267104 | _get_lambda_source_code | test | def _get_lambda_source_code(lambda_fn, src):
"""Attempt to find the source code of the ``lambda_fn`` within the string ``src``."""
def gen_lambdas():
def gen():
yield src + "\n"
g = gen()
step = 0
tokens = []
for tok in tokenize.generate_tokens(getattr(g, "ne... | python | {
"resource": ""
} |
q267105 | NOT.check | test | def check(self, var):
"""Return True if the variable does not match any of the types, and False otherwise."""
return not any(_check_type(var, tt) for tt in self._types) | python | {
"resource": ""
} |
q267106 | Enum.check | test | def check(self, var):
"""Check whether the provided value is a valid enum constant."""
if not isinstance(var, _str_type): return False
return _enum_mangle(var) in self._consts | python | {
"resource": ""
} |
q267107 | H2OConfigReader.get_config | test | def get_config():
"""Retrieve the config as a dictionary of key-value pairs."""
self = H2OConfigReader._get_instance()
if not self._config_loaded:
self._read_config()
return self._config | python | {
"resource": ""
} |
q267108 | H2OConfigReader._read_config | test | def _read_config(self):
"""Find and parse config file, storing all variables in ``self._config``."""
self._config_loaded = True
conf = []
for f in self._candidate_log_files():
if os.path.isfile(f):
self._logger.info("Reading config file %s" % f)
... | python | {
"resource": ""
} |
q267109 | H2OConfigReader._candidate_log_files | test | def _candidate_log_files():
"""Return possible locations for the .h2oconfig file, one at a time."""
# Search for .h2oconfig in the current directory and all parent directories
relpath = ".h2oconfig"
prevpath = None
while True:
abspath = os.path.abspath(relpath)
... | python | {
"resource": ""
} |
q267110 | ProgressBar.execute | test | def execute(self, progress_fn, print_verbose_info=None):
"""
Start the progress bar, and return only when the progress reaches 100%.
:param progress_fn: the executor function (or a generator). This function should take no arguments
and return either a single number -- the current pr... | python | {
"resource": ""
} |
q267111 | ProgressBar._store_model_progress | test | def _store_model_progress(self, res, now):
"""
Save the current model progress into ``self._progress_data``, and update ``self._next_poll_time``.
:param res: tuple (progress level, poll delay).
:param now: current timestamp.
"""
raw_progress, delay = res
raw_prog... | python | {
"resource": ""
} |
q267112 | ProgressBar._recalculate_model_parameters | test | def _recalculate_model_parameters(self, now):
"""Compute t0, x0, v0, ve."""
time_until_end = self._estimate_progress_completion_time(now) - now
assert time_until_end >= 0, "Estimated progress completion cannot be in the past."
x_real = self._get_real_progress()
if x_real == 1:
... | python | {
"resource": ""
} |
q267113 | ProgressBar._estimate_progress_completion_time | test | def _estimate_progress_completion_time(self, now):
"""
Estimate the moment when the underlying process is expected to reach completion.
This function should only return future times. Also this function is not allowed to return time moments less
than self._next_poll_time if the actual pr... | python | {
"resource": ""
} |
q267114 | ProgressBar._guess_next_poll_interval | test | def _guess_next_poll_interval(self):
"""
Determine when to query the progress status next.
This function is used if the external progress function did not return time interval for when it should be
queried next.
"""
time_elapsed = self._progress_data[-1][0] - self._progr... | python | {
"resource": ""
} |
q267115 | ProgressBar._compute_progress_at_time | test | def _compute_progress_at_time(self, t):
"""
Calculate the modelled progress state for the given time moment.
:returns: tuple (x, v) of the progress level and progress speed.
"""
t0, x0, v0, ve = self._t0, self._x0, self._v0, self._ve
z = (v0 - ve) * math.exp(-self.BETA *... | python | {
"resource": ""
} |
q267116 | ProgressBar._get_time_at_progress | test | def _get_time_at_progress(self, x_target):
"""
Return the projected time when progress level `x_target` will be reached.
Since the underlying progress model is nonlinear, we need to do use Newton method to find a numerical solution
to the equation x(t) = x_target.
"""
t,... | python | {
"resource": ""
} |
q267117 | ProgressBar._draw | test | def _draw(self, txt, final=False):
"""Print the rendered string to the stdout."""
if not self._file_mode:
# If the user presses Ctrl+C this ensures we still start writing from the beginning of the line
sys.stdout.write("\r")
sys.stdout.write(txt)
if final and not ... | python | {
"resource": ""
} |
q267118 | _ProgressBarCompoundWidget._compute_widget_sizes | test | def _compute_widget_sizes(self):
"""Initial rendering stage, done in order to compute widths of all widgets."""
wl = [0] * len(self._widgets)
flex_count = 0
# First render all non-flexible widgets
for i, widget in enumerate(self._widgets):
if isinstance(widget, Progr... | python | {
"resource": ""
} |
q267119 | _ProgressBarCompoundWidget._get_terminal_size | test | def _get_terminal_size():
"""Find current STDOUT's width, in characters."""
# If output is not terminal but a regular file, assume 100 chars width
if not sys.stdout.isatty():
return 80
# Otherwise, first try getting the dimensions from shell command `stty`:
try:
... | python | {
"resource": ""
} |
q267120 | PBWBar.set_encoding | test | def set_encoding(self, encoding):
"""Inform the widget about the encoding of the underlying character stream."""
self._bar_ends = "[]"
self._bar_symbols = "#"
if not encoding: return
s1 = "\u258F\u258E\u258D\u258C\u258B\u258A\u2589\u2588"
s2 = "\u258C\u2588"
s3 = ... | python | {
"resource": ""
} |
q267121 | TargetEncoder.fit | test | def fit(self, frame = None):
"""
Returns encoding map as an object that maps 'column_name' -> 'frame_with_encoding_map_for_this_column_name'
:param frame frame: An H2OFrame object with which to create the target encoding map
"""
self._teColumns = list(map(lambda i: frame.names[i... | python | {
"resource": ""
} |
q267122 | H2OFrame.get_frame | test | def get_frame(frame_id, rows=10, rows_offset=0, cols=-1, full_cols=-1, cols_offset=0, light=False):
"""
Retrieve an existing H2OFrame from the H2O cluster using the frame's id.
:param str frame_id: id of the frame to retrieve
:param int rows: number of rows to fetch for preview (10 by d... | python | {
"resource": ""
} |
q267123 | H2OFrame.refresh | test | def refresh(self):
"""Reload frame information from the backend H2O server."""
self._ex._cache.flush()
self._frame(fill_cache=True) | python | {
"resource": ""
} |
q267124 | H2OFrame.type | test | def type(self, col):
"""
The type for the given column.
:param col: either a name, or an index of the column to look up
:returns: type of the column, one of: ``str``, ``int``, ``real``, ``enum``, ``time``, ``bool``.
:raises H2OValueError: if such column does not exist in the fra... | python | {
"resource": ""
} |
q267125 | H2OFrame.columns_by_type | test | def columns_by_type(self, coltype="numeric"):
"""
Extract columns of the specified type from the frame.
:param str coltype: A character string indicating which column type to filter by. This must be
one of the following:
- ``"numeric"`` - Numeric, but not categoric... | python | {
"resource": ""
} |
q267126 | H2OFrame.summary | test | def summary(self, return_data=False):
"""
Display summary information about the frame.
Summary includes min/mean/max/sigma and other rollup data.
:param bool return_data: Return a dictionary of the summary output
"""
if not self._has_content():
print("This H... | python | {
"resource": ""
} |
q267127 | H2OFrame.describe | test | def describe(self, chunk_summary=False):
"""
Generate an in-depth description of this H2OFrame.
This will print to the console the dimensions of the frame; names/types/summary statistics for each column;
and finally first ten rows of the frame.
:param bool chunk_summary: Retrie... | python | {
"resource": ""
} |
q267128 | H2OFrame.head | test | def head(self, rows=10, cols=200):
"""
Return the first ``rows`` and ``cols`` of the frame as a new H2OFrame.
:param int rows: maximum number of rows to return
:param int cols: maximum number of columns to return
:returns: a new H2OFrame cut from the top left corner of the curre... | python | {
"resource": ""
} |
q267129 | H2OFrame.mult | test | def mult(self, matrix):
"""
Multiply this frame, viewed as a matrix, by another matrix.
:param matrix: another frame that you want to multiply the current frame by; must be compatible with the
current frame (i.e. its number of rows must be the same as number of columns in the curren... | python | {
"resource": ""
} |
q267130 | H2OFrame.levels | test | def levels(self):
"""
Get the factor levels.
:returns: A list of lists, one list per column, of levels.
"""
lol = H2OFrame._expr(expr=ExprNode("levels", self)).as_data_frame(False)
lol.pop(0) # Remove column headers
lol = list(zip(*lol))
return [[ll for ... | python | {
"resource": ""
} |
q267131 | H2OFrame.nlevels | test | def nlevels(self):
"""
Get the number of factor levels for each categorical column.
:returns: A list of the number of levels per column.
"""
levels = self.levels()
return [len(l) for l in levels] if levels else 0 | python | {
"resource": ""
} |
q267132 | H2OFrame.set_level | test | def set_level(self, level):
"""
A method to set all column values to one of the levels.
:param str level: The level at which the column will be set (a string)
:returns: H2OFrame with entries set to the desired level.
"""
return H2OFrame._expr(expr=ExprNode("setLevel", s... | python | {
"resource": ""
} |
q267133 | H2OFrame.set_levels | test | def set_levels(self, levels):
"""
Replace the levels of a categorical column.
New levels must be aligned with the old domain. This call has copy-on-write semantics.
:param List[str] levels: A list of strings specifying the new levels. The number of new
levels must match the... | python | {
"resource": ""
} |
q267134 | H2OFrame.rename | test | def rename(self, columns=None):
"""
Change names of columns in the frame.
Dict key is an index or name of the column whose name is to be set.
Dict value is the new name of the column.
:param columns: dict-like transformations to apply to the column names
"""
ass... | python | {
"resource": ""
} |
q267135 | H2OFrame.set_names | test | def set_names(self, names):
"""
Change names of all columns in the frame.
:param List[str] names: The list of new names for every column in the frame.
"""
assert_is_type(names, [str])
assert_satisfies(names, len(names) == self.ncol)
self._ex = ExprNode("colnames=... | python | {
"resource": ""
} |
q267136 | H2OFrame.set_name | test | def set_name(self, col=None, name=None):
"""
Set a new name for a column.
:param col: index or name of the column whose name is to be set; may be skipped for 1-column frames
:param name: the new name of the column
"""
assert_is_type(col, None, int, str)
assert_is... | python | {
"resource": ""
} |
q267137 | H2OFrame.isin | test | def isin(self, item):
"""
Test whether elements of an H2OFrame are contained in the ``item``.
:param items: An item or a list of items to compare the H2OFrame against.
:returns: An H2OFrame of 0s and 1s showing whether each element in the original H2OFrame is contained in item.
... | python | {
"resource": ""
} |
q267138 | H2OFrame.modulo_kfold_column | test | def modulo_kfold_column(self, n_folds=3):
"""
Build a fold assignments column for cross-validation.
Rows are assigned a fold according to the current row number modulo ``n_folds``.
:param int n_folds: An integer specifying the number of validation sets to split the training data into.
... | python | {
"resource": ""
} |
q267139 | H2OFrame.stratified_kfold_column | test | def stratified_kfold_column(self, n_folds=3, seed=-1):
"""
Build a fold assignment column with the constraint that each fold has the same class
distribution as the fold column.
:param int n_folds: The number of folds to build.
:param int seed: A seed for the random number genera... | python | {
"resource": ""
} |
q267140 | H2OFrame.structure | test | def structure(self):
"""Compactly display the internal structure of an H2OFrame."""
df = self.as_data_frame(use_pandas=False)
cn = df.pop(0)
nr = self.nrow
nc = self.ncol
width = max([len(c) for c in cn])
isfactor = self.isfactor()
numlevels = self.nlevels... | python | {
"resource": ""
} |
q267141 | H2OFrame.as_data_frame | test | def as_data_frame(self, use_pandas=True, header=True):
"""
Obtain the dataset as a python-local object.
:param bool use_pandas: If True (default) then return the H2OFrame as a pandas DataFrame (requires that the
``pandas`` library was installed). If False, then return the contents o... | python | {
"resource": ""
} |
q267142 | H2OFrame.pop | test | def pop(self, i):
"""
Pop a column from the H2OFrame at index i.
:param i: The index (int) or name (str) of the column to pop.
:returns: an H2OFrame containing the column dropped from the current frame; the current frame is modified
in-place and loses the column.
"""... | python | {
"resource": ""
} |
q267143 | H2OFrame.quantile | test | def quantile(self, prob=None, combine_method="interpolate", weights_column=None):
"""
Compute quantiles.
:param List[float] prob: list of probabilities for which quantiles should be computed.
:param str combine_method: for even samples this setting determines how to combine quantiles. T... | python | {
"resource": ""
} |
q267144 | H2OFrame.concat | test | def concat(self, frames, axis=1):
"""
Append multiple H2OFrames to this frame, column-wise or row-wise.
:param List[H2OFrame] frames: list of frames that should be appended to the current frame.
:param int axis: if 1 then append column-wise (default), if 0 then append row-wise.
... | python | {
"resource": ""
} |
q267145 | H2OFrame.cbind | test | def cbind(self, data):
"""
Append data to this frame column-wise.
:param H2OFrame data: append columns of frame ``data`` to the current frame. You can also cbind a number,
in which case it will get converted into a constant column.
:returns: new H2OFrame with all frames in ... | python | {
"resource": ""
} |
q267146 | H2OFrame.rbind | test | def rbind(self, data):
"""
Append data to this frame row-wise.
:param data: an H2OFrame or a list of H2OFrame's to be combined with current frame row-wise.
:returns: this H2OFrame with all frames in data appended row-wise.
"""
assert_is_type(data, H2OFrame, [H2OFrame])
... | python | {
"resource": ""
} |
q267147 | H2OFrame.split_frame | test | def split_frame(self, ratios=None, destination_frames=None, seed=None):
"""
Split a frame into distinct subsets of size determined by the given ratios.
The number of subsets is always 1 more than the number of ratios given. Note that
this does not give an exact split. H2O is designed to... | python | {
"resource": ""
} |
q267148 | H2OFrame.group_by | test | def group_by(self, by):
"""
Return a new ``GroupBy`` object using this frame and the desired grouping columns.
The returned groups are sorted by the natural group-by column sort.
:param by: The columns to group on (either a single column name, or a list of column names, or
... | python | {
"resource": ""
} |
q267149 | H2OFrame.fillna | test | def fillna(self,method="forward",axis=0,maxlen=1):
"""
Return a new Frame that fills NA along a given axis and along a given direction with a maximum fill length
:param method: ``"forward"`` or ``"backward"``
:param axis: 0 for columnar-wise or 1 for row-wise fill
:param maxlen... | python | {
"resource": ""
} |
q267150 | H2OFrame.impute | test | def impute(self, column=-1, method="mean", combine_method="interpolate", by=None, group_by_frame=None, values=None):
"""
Impute missing values into the frame, modifying it in-place.
:param int column: Index of the column to impute, or -1 to impute the entire frame.
:param str method: Th... | python | {
"resource": ""
} |
q267151 | H2OFrame.merge | test | def merge(self, other, all_x=False, all_y=False, by_x=None, by_y=None, method="auto"):
"""
Merge two datasets based on common column names. We do not support all_x=True and all_y=True.
Only one can be True or none is True. The default merge method is auto and it will default to the
rad... | python | {
"resource": ""
} |
q267152 | H2OFrame.relevel | test | def relevel(self, y):
"""
Reorder levels of an H2O factor for one single column of a H2O frame
The levels of a factor are reordered such that the reference level is at level 0, all remaining levels are
moved down as needed.
:param str y: The reference level
:returns: Ne... | python | {
"resource": ""
} |
q267153 | H2OFrame.insert_missing_values | test | def insert_missing_values(self, fraction=0.1, seed=None):
"""
Insert missing values into the current frame, modifying it in-place.
Randomly replaces a user-specified fraction of entries in a H2O dataset with missing
values.
:param float fraction: A number between 0 and 1 indica... | python | {
"resource": ""
} |
q267154 | H2OFrame.var | test | def var(self, y=None, na_rm=False, use=None):
"""
Compute the variance-covariance matrix of one or two H2OFrames.
:param H2OFrame y: If this parameter is given, then a covariance matrix between the columns of the target
frame and the columns of ``y`` is computed. If this parameter ... | python | {
"resource": ""
} |
q267155 | H2OFrame.cor | test | def cor(self, y=None, na_rm=False, use=None):
"""
Compute the correlation matrix of one or two H2OFrames.
:param H2OFrame y: If this parameter is provided, then compute correlation between the columns of ``y``
and the columns of the current frame. If this parameter is not given, the... | python | {
"resource": ""
} |
q267156 | H2OFrame.distance | test | def distance(self, y, measure=None):
"""
Compute a pairwise distance measure between all rows of two numeric H2OFrames.
:param H2OFrame y: Frame containing queries (small)
:param str use: A string indicating what distance measure to use. Must be one of:
- ``"l1"``: A... | python | {
"resource": ""
} |
q267157 | H2OFrame.asfactor | test | def asfactor(self):
"""
Convert columns in the current frame to categoricals.
:returns: new H2OFrame with columns of the "enum" type.
"""
for colname in self.names:
t = self.types[colname]
if t not in {"bool", "int", "string", "enum"}:
rai... | python | {
"resource": ""
} |
q267158 | H2OFrame.strsplit | test | def strsplit(self, pattern):
"""
Split the strings in the target column on the given regular expression pattern.
:param str pattern: The split pattern.
:returns: H2OFrame containing columns of the split strings.
"""
fr = H2OFrame._expr(expr=ExprNode("strsplit", self, pat... | python | {
"resource": ""
} |
q267159 | H2OFrame.countmatches | test | def countmatches(self, pattern):
"""
For each string in the frame, count the occurrences of the provided pattern. If countmathces is applied to
a frame, all columns of the frame must be type string, otherwise, the returned frame will contain errors.
The pattern here is a plain string, ... | python | {
"resource": ""
} |
q267160 | H2OFrame.substring | test | def substring(self, start_index, end_index=None):
"""
For each string, return a new string that is a substring of the original string.
If end_index is not specified, then the substring extends to the end of the original string. If the start_index
is longer than the length of the string,... | python | {
"resource": ""
} |
q267161 | H2OFrame.lstrip | test | def lstrip(self, set=" "):
"""
Return a copy of the column with leading characters removed.
The set argument is a string specifying the set of characters to be removed.
If omitted, the set argument defaults to removing whitespace.
:param character set: The set of characters to ... | python | {
"resource": ""
} |
q267162 | H2OFrame.entropy | test | def entropy(self):
"""
For each string compute its Shannon entropy, if the string is empty the entropy is 0.
:returns: an H2OFrame of Shannon entropies.
"""
fr = H2OFrame._expr(expr=ExprNode("entropy", self))
fr._ex._cache.nrows = self.nrow
fr._ex._cache.ncol = s... | python | {
"resource": ""
} |
q267163 | H2OFrame.num_valid_substrings | test | def num_valid_substrings(self, path_to_words):
"""
For each string, find the count of all possible substrings with 2 characters or more that are contained in
the line-separated text file whose path is given.
:param str path_to_words: Path to file that contains a line-separated list of s... | python | {
"resource": ""
} |
q267164 | H2OFrame.table | test | def table(self, data2=None, dense=True):
"""
Compute the counts of values appearing in a column, or co-occurence counts between two columns.
:param H2OFrame data2: An optional single column to aggregate counts by.
:param bool dense: If True (default) then use dense representation, which... | python | {
"resource": ""
} |
q267165 | H2OFrame.hist | test | def hist(self, breaks="sturges", plot=True, **kwargs):
"""
Compute a histogram over a numeric column.
:param breaks: Can be one of ``"sturges"``, ``"rice"``, ``"sqrt"``, ``"doane"``, ``"fd"``, ``"scott"``;
or a single number for the number of breaks; or a list containing the split p... | python | {
"resource": ""
} |
q267166 | H2OFrame.isax | test | def isax(self, num_words, max_cardinality, optimize_card=False, **kwargs):
"""
Compute the iSAX index for DataFrame which is assumed to be numeric time series data.
References:
- http://www.cs.ucr.edu/~eamonn/SAX.pdf
- http://www.cs.ucr.edu/~eamonn/iSAX_2.0.pdf
... | python | {
"resource": ""
} |
q267167 | H2OFrame.sub | test | def sub(self, pattern, replacement, ignore_case=False):
"""
Substitute the first occurrence of pattern in a string with replacement.
:param str pattern: A regular expression.
:param str replacement: A replacement string.
:param bool ignore_case: If True then pattern will match c... | python | {
"resource": ""
} |
q267168 | H2OFrame.toupper | test | def toupper(self):
"""
Translate characters from lower to upper case for a particular column.
:returns: new H2OFrame with all strings in the current frame converted to the uppercase.
"""
return H2OFrame._expr(expr=ExprNode("toupper", self), cache=self._ex._cache) | python | {
"resource": ""
} |
q267169 | H2OFrame.grep | test | def grep(self,pattern, ignore_case = False, invert = False, output_logical = False):
"""
Searches for matches to argument `pattern` within each element
of a string column.
Default behavior is to return indices of the elements matching the pattern. Parameter
`output_logical` can ... | python | {
"resource": ""
} |
q267170 | H2OFrame.na_omit | test | def na_omit(self):
"""
Remove rows with NAs from the H2OFrame.
:returns: new H2OFrame with all rows from the original frame containing any NAs removed.
"""
fr = H2OFrame._expr(expr=ExprNode("na.omit", self), cache=self._ex._cache)
fr._ex._cache.nrows = -1
return ... | python | {
"resource": ""
} |
q267171 | H2OFrame.difflag1 | test | def difflag1(self):
"""
Conduct a diff-1 transform on a numeric frame column.
:returns: an H2OFrame where each element is equal to the corresponding element in the source
frame minus the previous-row element in the same frame.
"""
if self.ncols > 1:
raise... | python | {
"resource": ""
} |
q267172 | H2OFrame.isna | test | def isna(self):
"""
For each element in an H2OFrame, determine if it is NA or not.
:returns: an H2OFrame of 1s and 0s, where 1s mean the values were NAs.
"""
fr = H2OFrame._expr(expr=ExprNode("is.na", self))
fr._ex._cache.nrows = self._ex._cache.nrows
fr._ex._cac... | python | {
"resource": ""
} |
q267173 | H2OFrame.minute | test | def minute(self):
"""
Extract the "minute" part from a date column.
:returns: a single-column H2OFrame containing the "minute" part from the source frame.
"""
fr = H2OFrame._expr(expr=ExprNode("minute", self), cache=self._ex._cache)
if fr._ex._cache.types_valid():
... | python | {
"resource": ""
} |
q267174 | H2OFrame.runif | test | def runif(self, seed=None):
"""
Generate a column of random numbers drawn from a uniform distribution [0,1) and
having the same data layout as the source frame.
:param int seed: seed for the random number generator.
:returns: Single-column H2OFrame filled with doubles sampled u... | python | {
"resource": ""
} |
q267175 | H2OFrame.stratified_split | test | def stratified_split(self, test_frac=0.2, seed=-1):
"""
Construct a column that can be used to perform a random stratified split.
:param float test_frac: The fraction of rows that will belong to the "test".
:param int seed: The seed for the random number generator.
:returns: an... | python | {
"resource": ""
} |
q267176 | H2OFrame.cut | test | def cut(self, breaks, labels=None, include_lowest=False, right=True, dig_lab=3):
"""
Cut a numeric vector into categorical "buckets".
This method is only applicable to a single-column numeric frame.
:param List[float] breaks: The cut points in the numeric vector.
:param List[st... | python | {
"resource": ""
} |
q267177 | H2OFrame.idxmax | test | def idxmax(self,skipna=True, axis=0):
"""
Get the index of the max value in a column or row
:param bool skipna: If True (default), then NAs are ignored during the search. Otherwise presence
of NAs renders the entire result NA.
:param int axis: Direction of finding the max in... | python | {
"resource": ""
} |
q267178 | H2OFrame.apply | test | def apply(self, fun=None, axis=0):
"""
Apply a lambda expression to an H2OFrame.
:param fun: a lambda expression to be applied per row or per column.
:param axis: 0 = apply to each column; 1 = apply to each row
:returns: a new H2OFrame with the results of applying ``fun`` to the... | python | {
"resource": ""
} |
q267179 | parse_text | test | def parse_text(text):
"""Parse code from a string of text."""
assert isinstance(text, _str_type), "`text` parameter should be a string, got %r" % type(text)
gen = iter(text.splitlines(True)) # True = keep newlines
readline = gen.next if hasattr(gen, "next") else gen.__next__
return Code(_tokenize(r... | python | {
"resource": ""
} |
q267180 | parse_file | test | def parse_file(filename):
"""Parse the provided file, and return Code object."""
assert isinstance(filename, _str_type), "`filename` parameter should be a string, got %r" % type(filename)
with open(filename, "rt", encoding="utf-8") as f:
return Code(_tokenize(f.readline)) | python | {
"resource": ""
} |
q267181 | Token.move | test | def move(self, drow, dcol=0):
"""Move the token by `drow` rows and `dcol` columns."""
self._start_row += drow
self._start_col += dcol
self._end_row += drow
self._end_col += dcol | python | {
"resource": ""
} |
q267182 | ParsedBase.unparse | test | def unparse(self):
"""Convert the parsed representation back into the source code."""
ut = Untokenizer(start_row=self._tokens[0].start_row)
self._unparse(ut)
return ut.result() | python | {
"resource": ""
} |
q267183 | H2OClusteringModel.size | test | def size(self, train=False, valid=False, xval=False):
"""
Get the sizes of each cluster.
If all are False (default), then return the training metric value.
If more than one options is set to True, then return a dictionary of metrics where
the keys are "train", "valid", and "xval... | python | {
"resource": ""
} |
q267184 | H2OClusteringModel.centers | test | def centers(self):
"""The centers for the KMeans model."""
o = self._model_json["output"]
cvals = o["centers"].cell_values
centers = [list(cval[1:]) for cval in cvals]
return centers | python | {
"resource": ""
} |
q267185 | H2OClusteringModel.centers_std | test | def centers_std(self):
"""The standardized centers for the kmeans model."""
o = self._model_json["output"]
cvals = o["centers_std"].cell_values
centers_std = [list(cval[1:]) for cval in cvals]
centers_std = [list(x) for x in zip(*centers_std)]
return centers_std | python | {
"resource": ""
} |
q267186 | connect | test | def connect(server=None, url=None, ip=None, port=None, https=None, verify_ssl_certificates=None, auth=None,
proxy=None, cookies=None, verbose=True, config=None):
"""
Connect to an existing H2O server, remote or local.
There are two ways to connect to a server: either pass a `server` parameter c... | python | {
"resource": ""
} |
q267187 | api | test | def api(endpoint, data=None, json=None, filename=None, save_to=None):
"""
Perform a REST API request to a previously connected server.
This function is mostly for internal purposes, but may occasionally be useful for direct access to
the backend H2O server. It has same parameters as :meth:`H2OConnectio... | python | {
"resource": ""
} |
q267188 | version_check | test | def version_check():
"""Used to verify that h2o-python module and the H2O server are compatible with each other."""
from .__init__ import __version__ as ver_pkg
ci = h2oconn.cluster
if not ci:
raise H2OConnectionError("Connection not initialized. Did you run h2o.connect()?")
ver_h2o = ci.ver... | python | {
"resource": ""
} |
q267189 | lazy_import | test | def lazy_import(path, pattern=None):
"""
Import a single file or collection of files.
:param path: A path to a data file (remote or local).
:param pattern: Character string containing a regular expression to match file(s) in the folder.
:returns: either a :class:`H2OFrame` with the content of the p... | python | {
"resource": ""
} |
q267190 | upload_file | test | def upload_file(path, destination_frame=None, header=0, sep=None, col_names=None, col_types=None,
na_strings=None, skipped_columns=None):
"""
Upload a dataset from the provided local path to the H2O cluster.
Does a single-threaded push to H2O. Also see :meth:`import_file`.
:param path:... | python | {
"resource": ""
} |
q267191 | import_file | test | def import_file(path=None, destination_frame=None, parse=True, header=0, sep=None, col_names=None, col_types=None,
na_strings=None, pattern=None, skipped_columns=None, custom_non_data_line_markers = None):
"""
Import a dataset that is already on the cluster.
The path to the data must be a v... | python | {
"resource": ""
} |
q267192 | import_hive_table | test | def import_hive_table(database=None, table=None, partitions=None, allow_multi_format=False):
"""
Import Hive table to H2OFrame in memory.
Make sure to start H2O with Hive on classpath. Uses hive-site.xml on classpath to connect to Hive.
:param database: Name of Hive database (default database will be ... | python | {
"resource": ""
} |
q267193 | import_sql_table | test | def import_sql_table(connection_url, table, username, password, columns=None, optimize=True, fetch_mode=None):
"""
Import SQL table to H2OFrame in memory.
Assumes that the SQL table is not being updated and is stable.
Runs multiple SELECT SQL queries concurrently for parallel ingestion.
Be sure to ... | python | {
"resource": ""
} |
q267194 | import_sql_select | test | def import_sql_select(connection_url, select_query, username, password, optimize=True,
use_temp_table=None, temp_table_name=None, fetch_mode=None):
"""
Import the SQL table that is the result of the specified SQL query to H2OFrame in memory.
Creates a temporary SQL table from the spe... | python | {
"resource": ""
} |
q267195 | parse_raw | test | def parse_raw(setup, id=None, first_line_is_header=0):
"""
Parse dataset using the parse setup structure.
:param setup: Result of ``h2o.parse_setup()``
:param id: an id for the frame.
:param first_line_is_header: -1, 0, 1 if the first line is to be used as the header
:returns: an :class:`H2OFr... | python | {
"resource": ""
} |
q267196 | deep_copy | test | def deep_copy(data, xid):
"""
Create a deep clone of the frame ``data``.
:param data: an H2OFrame to be cloned
:param xid: (internal) id to be assigned to the new frame.
:returns: new :class:`H2OFrame` which is the clone of the passed frame.
"""
assert_is_type(data, H2OFrame)
assert_is_... | python | {
"resource": ""
} |
q267197 | get_model | test | def get_model(model_id):
"""
Load a model from the server.
:param model_id: The model identification in H2O
:returns: Model object, a subclass of H2OEstimator
"""
assert_is_type(model_id, str)
model_json = api("GET /3/Models/%s" % model_id)["models"][0]
algo = model_json["algo"]
if... | python | {
"resource": ""
} |
q267198 | get_grid | test | def get_grid(grid_id):
"""
Return the specified grid.
:param grid_id: The grid identification in h2o
:returns: an :class:`H2OGridSearch` instance.
"""
assert_is_type(grid_id, str)
grid_json = api("GET /99/Grids/%s" % grid_id)
models = [get_model(key["name"]) for key in grid_json["model... | python | {
"resource": ""
} |
q267199 | get_frame | test | def get_frame(frame_id, **kwargs):
"""
Obtain a handle to the frame in H2O with the frame_id key.
:param str frame_id: id of the frame to retrieve.
:returns: an :class:`H2OFrame` object
"""
assert_is_type(frame_id, str)
return H2OFrame.get_frame(frame_id, **kwargs) | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.