Search is not available for this dataset
text stringlengths 75 104k |
|---|
def dagify_min_edge(g):
"""Input a graph and output a DAG.
The heuristic is to reverse the edge with the lowest score of the cycle
if possible, else remove it.
Args:
g (networkx.DiGraph): Graph to modify to output a DAG
Returns:
networkx.DiGraph: DAG made out of the input graph.
... |
def weighted_mean_and_std(values, weights):
"""
Returns the weighted average and standard deviation.
values, weights -- numpy ndarrays with the same shape.
"""
average = np.average(values, weights=weights, axis=0)
variance = np.dot(weights, (values - average) ** 2) / weights.sum() # Fast and n... |
def GNN_instance(x, idx=0, device=None, nh=20, **kwargs):
"""Run an instance of GNN, testing causal direction.
:param m: data corresponding to the config : (N, 2) data, [:, 0] cause and [:, 1] effect
:param pair_idx: print purposes
:param run: numner of the run (for GPU dispatch)
:param device: dev... |
def forward(self, x):
"""Pass data through the net structure.
:param x: input data: shape (:,1)
:type x: torch.Variable
:return: output of the shallow net
:rtype: torch.Variable
"""
self.noise.normal_()
return self.layers(th.cat([x, self.noise], 1)) |
def run(self, x, y, lr=0.01, train_epochs=1000, test_epochs=1000, idx=0, verbose=None, **kwargs):
"""Run the GNN on a pair x,y of FloatTensor data."""
verbose = SETTINGS.get_default(verbose=verbose)
optim = th.optim.Adam(self.parameters(), lr=lr)
running_loss = 0
teloss = 0
... |
def predict_proba(self, a, b, nb_runs=6, nb_jobs=None, gpu=None,
idx=0, verbose=None, ttest_threshold=0.01,
nb_max_runs=16, train_epochs=1000, test_epochs=1000):
"""Run multiple times GNN to estimate the causal direction.
Args:
a (np.ndarray): Var... |
def init_variables(self, verbose=False):
"""Redefine the causes of the graph."""
# Resetting adjacency matrix
for i in range(self.nodes):
for j in np.random.choice(range(self.nodes),
np.random.randint(
0,... |
def generate(self, nb_steps=100, averaging=50, rescale=True):
"""Generate data from an FCM containing cycles."""
if self.cfunctions is None:
self.init_variables()
new_df = pd.DataFrame()
causes = [[c for c in np.nonzero(self.adjacency_matrix[:, j])[0]]
for j... |
def create_graph_from_data(self, data, **kwargs):
"""Apply causal discovery on observational data using CAM.
Args:
data (pandas.DataFrame): DataFrame containing the data
Returns:
networkx.DiGraph: Solution given by the CAM algorithm.
"""
# Building setup... |
def predict_features(self, df_features, df_target, idx=0, **kwargs):
"""For one variable, predict its neighbouring nodes.
Args:
df_features (pandas.DataFrame):
df_target (pandas.Series):
idx (int): (optional) for printing purposes
kwargs (dict): additiona... |
def predict_features(self, df_features, df_target, idx=0, C=.1, **kwargs):
"""For one variable, predict its neighbouring nodes.
Args:
df_features (pandas.DataFrame):
df_target (pandas.Series):
idx (int): (optional) for printing purposes
kwargs (dict): add... |
def predict_features(self, df_features, df_target, idx=0, **kwargs):
"""For one variable, predict its neighbouring nodes.
Args:
df_features (pandas.DataFrame):
df_target (pandas.Series):
idx (int): (optional) for printing purposes
kwargs (dict): additiona... |
def predict_features(self, df_features, df_target, idx=0, **kwargs):
"""For one variable, predict its neighbouring nodes.
Args:
df_features (pandas.DataFrame):
df_target (pandas.Series):
idx (int): (optional) for printing purposes
kwargs (dict): additiona... |
def predict_features(self, df_features, df_target, idx=0, **kwargs):
"""For one variable, predict its neighbouring nodes.
Args:
df_features (pandas.DataFrame):
df_target (pandas.Series):
idx (int): (optional) for printing purposes
kwargs (dict): additiona... |
def forward(self, x):
"""Passing data through the network.
:param x: 2d tensor containing both (x,y) Variables
:return: output of the net
"""
features = self.conv(x).mean(dim=2)
return self.dense(features) |
def fit(self, x_tr, y_tr, epochs=50, batchsize=32,
learning_rate=0.01, verbose=None, device=None):
"""Fit the NCC model.
Args:
x_tr (pd.DataFrame): CEPC format dataframe containing the pairs
y_tr (pd.DataFrame or np.ndarray): labels associated to the pairs
... |
def predict_proba(self, a, b, device=None):
"""Infer causal directions using the trained NCC pairwise model.
Args:
a (numpy.ndarray): Variable 1
b (numpy.ndarray): Variable 2
device (str): Device to run the algorithm on (defaults to ``cdt.SETTINGS.default_device``)
... |
def predict_dataset(self, df, device=None, verbose=None):
"""
Args:
x_tr (pd.DataFrame): CEPC format dataframe containing the pairs
y_tr (pd.DataFrame or np.ndarray): labels associated to the pairs
epochs (int): number of train epochs
learning rate (float)... |
def phrase_to_filename(self, phrase):
"""Convert phrase to normilized file name."""
# remove non-word characters
name = re.sub(r"[^\w\s\.]", '', phrase.strip().lower())
# replace whitespace with underscores
name = re.sub(r"\s+", '_', name)
return name + '.png' |
def seed_url(self):
"""A URL that can be used to open the page.
The URL is formatted from :py:attr:`URL_TEMPLATE`, which is then
appended to :py:attr:`base_url` unless the template results in an
absolute URL.
:return: URL that can be used to open the page.
:rtype: str
... |
def open(self):
"""Open the page.
Navigates to :py:attr:`seed_url` and calls :py:func:`wait_for_page_to_load`.
:return: The current page object.
:rtype: :py:class:`Page`
:raises: UsageError
"""
if self.seed_url:
self.driver_adapter.open(self.seed_ur... |
def wait_for_page_to_load(self):
"""Wait for the page to load."""
self.wait.until(lambda _: self.loaded)
self.pm.hook.pypom_after_wait_for_page_to_load(page=self)
return self |
def register():
""" Register the Selenium specific driver implementation.
This register call is performed by the init module if
selenium is available.
"""
registerDriver(
ISelenium,
Selenium,
class_implements=[
Firefox,
Chrome,
Ie,... |
def root(self):
"""Root element for the page region.
Page regions should define a root element either by passing this on
instantiation or by defining a :py:attr:`_root_locator` attribute. To
reduce the chances of hitting :py:class:`~selenium.common.exceptions.StaleElementReferenceExcept... |
def wait_for_region_to_load(self):
"""Wait for the page region to load."""
self.wait.until(lambda _: self.loaded)
self.pm.hook.pypom_after_wait_for_region_to_load(region=self)
return self |
def find_element(self, strategy, locator):
"""Finds an element on the page.
:param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.
:param locator: Location of target element.
:type strategy: st... |
def find_elements(self, strategy, locator):
"""Finds elements on the page.
:param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.
:param locator: Location of target elements.
:type strategy: st... |
def is_element_present(self, strategy, locator):
"""Checks whether an element is present.
:param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.
:param locator: Location of target element.
:typ... |
def is_element_displayed(self, strategy, locator):
"""Checks whether an element is displayed.
:param strategy: Location strategy to use. See :py:class:`~selenium.webdriver.common.by.By` or :py:attr:`~pypom.splinter_driver.ALLOWED_STRATEGIES`.
:param locator: Location of target element.
... |
def registerDriver(iface, driver, class_implements=[]):
""" Register driver adapter used by page object"""
for class_item in class_implements:
classImplements(class_item, iface)
component.provideAdapter(factory=driver, adapts=[iface], provides=IDriver) |
def isHcl(s):
'''
Detects whether a string is JSON or HCL
:param s: String that may contain HCL or JSON
:returns: True if HCL, False if JSON, raises ValueError
if neither
'''
for c in s:
if c.isspace():
continue
if c ==... |
def loads(s):
'''
Deserializes a string and converts it to a dictionary. The contents
of the string must either be JSON or HCL.
:returns: Dictionary
'''
s = u(s)
if isHcl(s):
return HclParser().parse(s)
else:
return json.loads(s) |
def t_hexnumber(self, t):
r'-?0[xX][0-9a-fA-F]+'
t.value = int(t.value, base=16)
t.type = 'NUMBER'
return t |
def t_intnumber(self, t):
r'-?\d+'
t.value = int(t.value)
t.type = 'NUMBER'
return t |
def t_string(self, t):
# Start of a string
r'\"'
# abs_start is the absolute start of the string. We use this at the end
# to know how many new lines we've consumed
t.lexer.abs_start = t.lexer.lexpos
# rel_pos is the begining of the unconsumed part of the string. It will
... |
def t_string_escapedchar(self, t):
# If a quote or backslash is escaped, build up the string by ignoring
# the escape character. Should this be done for other characters?
r'(?<=\\)(\"|\\)'
t.lexer.string_value += (
t.lexer.lexdata[t.lexer.rel_pos : t.lexer.lexpos - 2] + t.val... |
def t_string_STRING(self, t):
# End of the string
r'\"'
t.value = (
t.lexer.string_value + t.lexer.lexdata[t.lexer.rel_pos : t.lexer.lexpos - 1]
)
t.lexer.lineno += t.lexer.lexdata[t.lexer.abs_start : t.lexer.lexpos - 1].count(
'\n'
)
t.lex... |
def t_stringdollar_rbrace(self, t):
r'\}'
t.lexer.braces -= 1
if t.lexer.braces == 0:
# End of the dollar brace, back to the rest of the string
t.lexer.begin('string') |
def t_tabbedheredoc(self, t):
r'<<-\S+\r?\n'
t.lexer.is_tabbed = True
self._init_heredoc(t)
t.lexer.begin('tabbedheredoc') |
def t_heredoc(self, t):
r'<<\S+\r?\n'
t.lexer.is_tabbed = False
self._init_heredoc(t)
t.lexer.begin('heredoc') |
def objectlist_flat(self, lt, replace):
'''
Similar to the dict constructor, but handles dups
HCL is unclear on what one should do when duplicate keys are
encountered. These comments aren't clear either:
from decoder.go: if we're at the r... |
def p_top(self, p):
"top : objectlist"
if DEBUG:
self.print_p(p)
p[0] = self.objectlist_flat(p[1], True) |
def p_objectlist_1(self, p):
"objectlist : objectlist objectitem"
if DEBUG:
self.print_p(p)
p[0] = p[1] + [p[2]] |
def p_objectlist_2(self, p):
"objectlist : objectlist COMMA objectitem"
if DEBUG:
self.print_p(p)
p[0] = p[1] + [p[3]] |
def p_object_0(self, p):
"object : LEFTBRACE objectlist RIGHTBRACE"
if DEBUG:
self.print_p(p)
p[0] = self.objectlist_flat(p[2], False) |
def p_object_1(self, p):
"object : LEFTBRACE objectlist COMMA RIGHTBRACE"
if DEBUG:
self.print_p(p)
p[0] = self.objectlist_flat(p[2], False) |
def p_objectitem_0(self, p):
'''
objectitem : objectkey EQUAL number
| objectkey EQUAL BOOL
| objectkey EQUAL STRING
| objectkey EQUAL object
| objectkey EQUAL list
'''
if DEBUG:
self.print_p(p)
... |
def p_block_0(self, p):
"block : blockId object"
if DEBUG:
self.print_p(p)
p[0] = (p[1], p[2]) |
def p_block_1(self, p):
"block : blockId block"
if DEBUG:
self.print_p(p)
p[0] = (p[1], {p[2][0]: p[2][1]}) |
def p_listitems_1(self, p):
"listitems : listitems COMMA listitem"
if DEBUG:
self.print_p(p)
p[0] = p[1] + [p[3]] |
def p_number_1(self, p):
"number : float"
if DEBUG:
self.print_p(p)
p[0] = float(p[1]) |
def p_number_2(self, p):
"number : int exp"
if DEBUG:
self.print_p(p)
p[0] = float("{0}{1}".format(p[1], p[2])) |
def p_number_3(self, p):
"number : float exp"
if DEBUG:
self.print_p(p)
p[0] = float("{0}{1}".format(p[1], p[2])) |
def p_exp_0(self, p):
"exp : EPLUS NUMBER"
if DEBUG:
self.print_p(p)
p[0] = "e{0}".format(p[2]) |
def p_exp_1(self, p):
"exp : EMINUS NUMBER"
if DEBUG:
self.print_p(p)
p[0] = "e-{0}".format(p[2]) |
def _pre_install():
'''Initialize the parse table at install time'''
# Generate the parsetab.dat file at setup time
dat = join(setup_dir, 'src', 'hcl', 'parsetab.dat')
if exists(dat):
os.unlink(dat)
sys.path.insert(0, join(setup_dir, 'src'))
import hcl
from hcl.parser import HclPa... |
def append(self, linenumber, raw_text, cells):
"""Add another row of data from a test suite"""
self.rows.append(Row(linenumber, raw_text, cells)) |
def steps(self):
"""Return a list of steps (statements that are not settings or comments)"""
steps = []
for statement in self.statements:
if ((not statement.is_comment()) and
(not statement.is_setting())):
steps.append(statement)
return steps |
def is_comment(self):
'''Return True if the first non-empty cell starts with "#"'''
for cell in self[:]:
if cell == "":
continue
# this is the first non-empty cell. Check whether it is
# a comment or not.
if cell.lstrip().startswith("#"):... |
def RobotFactory(path, parent=None):
'''Return an instance of SuiteFile, ResourceFile, SuiteFolder
Exactly which is returned depends on whether it's a file or
folder, and if a file, the contents of the file. If there is a
testcase table, this will return an instance of SuiteFile,
otherwise it will ... |
def walk(self, *types):
'''
Iterator which visits all suites and suite files,
yielding test cases and keywords
'''
requested = types if len(types) > 0 else [SuiteFile, ResourceFile, SuiteFolder, Testcase, Keyword]
for thing in self.robot_files:
if thing.__cla... |
def robot_files(self):
'''Return a list of all folders, and test suite files (.txt, .robot)
'''
result = []
for name in os.listdir(self.path):
fullpath = os.path.join(self.path, name)
if os.path.isdir(fullpath):
result.append(RobotFactory(fullpath,... |
def walk(self, *types):
'''
Iterator which can return all test cases and/or keywords
You can specify with objects to return as parameters; if
no parameters are given, both tests and keywords will
be returned.
For example, to get only test cases, you could call it
... |
def _load(self, path):
'''
The general idea is to do a quick parse, creating a list of
tables. Each table is nothing more than a list of rows, with
each row being a list of cells. Additional parsing such as
combining rows into statements is done on demand. This first
pas... |
def type(self):
'''Return 'suite' or 'resource' or None
This will return 'suite' if a testcase table is found;
It will return 'resource' if at least one robot table
is found. If no tables are found it will return None
'''
robot_tables = [table for table in self.tables i... |
def keywords(self):
'''Generator which returns all keywords in the suite'''
for table in self.tables:
if isinstance(table, KeywordTable):
for keyword in table.keywords:
yield keyword |
def dump(self):
'''Regurgitate the tables and rows'''
for table in self.tables:
print("*** %s ***" % table.name)
table.dump() |
def settings(self):
'''Generator which returns all of the statements in all of the settings tables'''
for table in self.tables:
if isinstance(table, SettingTable):
for statement in table.statements:
yield statement |
def variables(self):
'''Generator which returns all of the statements in all of the variables tables'''
for table in self.tables:
if isinstance(table, VariableTable):
# FIXME: settings have statements, variables have rows WTF? :-(
for statement in table.rows:
... |
def statements(self):
'''Return a list of statements
This is done by joining together any rows that
have continuations
'''
# FIXME: no need to do this every time; we should cache the
# result
if len(self.rows) == 0:
return []
current_statemen... |
def append(self, row):
'''
The idea is, we recognize when we have a new testcase by
checking the first cell. If it's not empty and not a comment,
we have a new test case.
'''
if len(row) == 0:
# blank line. Should we throw it away, or append a BlankLine ob... |
def report(self, obj, message, linenum, char_offset=0):
"""Report an error or warning"""
self.controller.report(linenumber=linenum, filename=obj.path,
severity=self.severity, message=message,
rulename = self.__class__.__name__,
... |
def doc(self):
'''Algorithm from https://www.python.org/dev/peps/pep-0257/'''
if not self.__doc__:
return ""
lines = self.__doc__.expandtabs().splitlines()
# Determine minimum indentation (first line doesn't count):
indent = sys.maxsize
for line in lines[1:]... |
def run(self, args):
"""Parse command line arguments, and run rflint"""
self.args = self.parse_and_process_args(args)
if self.args.version:
print(__version__)
return 0
if self.args.rulefile:
for filename in self.args.rulefile:
... |
def list_rules(self):
"""Print a list of all rules"""
for rule in sorted(self.all_rules, key=lambda rule: rule.name):
print(rule)
if self.args.verbose:
for line in rule.doc.split("\n"):
print(" ", line) |
def report(self, linenumber, filename, severity, message, rulename, char):
"""Report a rule violation"""
if self._print_filename is not None:
# we print the filename only once. self._print_filename
# will get reset each time a new file is processed.
print("+ " + self... |
def _get_rules(self, cls):
"""Returns a list of rules of a given class
Rules are treated as singletons - we only instantiate each
rule once.
"""
result = []
for rule_class in cls.__subclasses__():
rule_name = rule_class.__name__.lower()
... |
def _load_rule_file(self, filename):
"""Import the given rule file"""
if not (os.path.exists(filename)):
sys.stderr.write("rflint: %s: No such file or directory\n" % filename)
return
try:
basename = os.path.basename(filename)
(name, ext) = os.path.... |
def parse_and_process_args(self, args):
"""Handle the parsing of command line arguments."""
parser = argparse.ArgumentParser(
prog="python -m rflint",
description="A style checker for robot framework plain text files.",
formatter_class=argparse.RawDescriptionHelpForm... |
def from_resolver(cls, spec_resolver):
"""Creates a customized Draft4ExtendedValidator.
:param spec_resolver: resolver for the spec
:type resolver: :class:`jsonschema.RefResolver`
"""
spec_validators = cls._get_spec_validators(spec_resolver)
return validators.extend(Draf... |
def create(self, spec_resolver):
"""Creates json documents validator from spec resolver.
:param spec_resolver: reference resolver.
:return: RefResolver for spec with cached remote $refs used during
validation.
:rtype: :class:`jsonschema.RefResolver`
"""
valid... |
def construct_mapping(self, node, deep=False):
"""While yaml supports integer keys, these are not valid in
json, and will break jsonschema. This method coerces all keys
to strings.
"""
mapping = super(ExtendedSafeConstructor, self).construct_mapping(
node, deep)
... |
def read_yaml_file(path, loader=ExtendedSafeLoader):
"""Open a file, read it and return its contents."""
with open(path) as fh:
return load(fh, loader) |
def from_spec_resolver(cls, spec_resolver):
"""Creates validators generator for the spec resolver.
:param spec_resolver: resolver for the spec
:type instance_resolver: :class:`jsonschema.RefResolver`
"""
deref = DerefValidatorDecorator(spec_resolver)
for key, validator_c... |
def grade(grader_data,submission):
"""
Grades a specified submission using specified models
grader_data - A dictionary:
{
'model' : trained model,
'extractor' : trained feature extractor,
'prompt' : prompt for the question,
'algorithm' : algorithm for the question,
}
... |
def grade_generic(grader_data, numeric_features, textual_features):
"""
Grades a set of numeric and textual features using a generic model
grader_data -- dictionary containing:
{
'algorithm' - Type of algorithm to use to score
}
numeric_features - list of numeric features to predict on
... |
def get_confidence_value(algorithm,model,grader_feats,score, scores):
"""
Determines a confidence in a certain score, given proper input parameters
algorithm- from util_functions.AlgorithmTypes
model - a trained model
grader_feats - a row of features used by the model for classification/regression
... |
def create_model_path(model_path):
"""
Creates a path to model files
model_path - string
"""
if not model_path.startswith("/") and not model_path.startswith("models/"):
model_path="/" + model_path
if not model_path.startswith("models"):
model_path = "models" + model_path
if n... |
def sub_chars(string):
"""
Strips illegal characters from a string. Used to sanitize input essays.
Removes all non-punctuation, digit, or letter characters.
Returns sanitized string.
string - string
"""
#Define replacement patterns
sub_pat = r"[^A-Za-z\.\?!,';:]"
char_pat = r"\."
... |
def spell_correct(string):
"""
Uses aspell to spell correct an input string.
Requires aspell to be installed and added to the path.
Returns the spell corrected string if aspell is found, original string if not.
string - string
"""
# Create a temp file so that aspell could be used
# By d... |
def ngrams(tokens, min_n, max_n):
"""
Generates ngrams(word sequences of fixed length) from an input token sequence.
tokens is a list of words.
min_n is the minimum length of an ngram to return.
max_n is the maximum length of an ngram to return.
returns a list of ngrams (words separated by a spa... |
def f7(seq):
"""
Makes a list unique
"""
seen = set()
seen_add = seen.add
return [x for x in seq if x not in seen and not seen_add(x)] |
def count_list(the_list):
"""
Generates a count of the number of times each unique item appears in a list
"""
count = the_list.count
result = [(item, count(item)) for item in set(the_list)]
result.sort()
return result |
def regenerate_good_tokens(string):
"""
Given an input string, part of speech tags the string, then generates a list of
ngrams that appear in the string.
Used to define grammatically correct part of speech tag sequences.
Returns a list of part of speech tag sequences.
"""
toks = nltk.word_to... |
def get_vocab(text, score, max_feats=750, max_feats2=200):
"""
Uses a fisher test to find words that are significant in that they separate
high scoring essays from low scoring essays.
text is a list of input essays.
score is a list of scores, with score[n] corresponding to text[n]
max_feats is t... |
def edit_distance(s1, s2):
"""
Calculates string edit distance between string 1 and string 2.
Deletion, insertion, substitution, and transposition all increase edit distance.
"""
d = {}
lenstr1 = len(s1)
lenstr2 = len(s2)
for i in xrange(-1, lenstr1 + 1):
d[(i, -1)] = i + 1
f... |
def gen_cv_preds(clf, arr, sel_score, num_chunks=3):
"""
Generates cross validated predictions using an input classifier and data.
clf is a classifier that implements that implements the fit and predict methods.
arr is the input data array (X)
sel_score is the target list (y). y[n] corresponds to X... |
def gen_model(clf, arr, sel_score):
"""
Fits a classifier to data and a target score
clf is an input classifier that implements the fit method.
arr is a data array(X)
sel_score is the target list (y) where y[n] corresponds to X[n,:]
sim_fit is not a useful return value. Instead the clf is the u... |
def gen_preds(clf, arr):
"""
Generates predictions on a novel data array using a fit classifier
clf is a classifier that has already been fit
arr is a data array identical in dimension to the array clf was trained on
Returns the array of predictions.
"""
if(hasattr(clf, "predict_proba")):
... |
def calc_list_average(l):
"""
Calculates the average value of a list of numbers
Returns a float
"""
total = 0.0
for value in l:
total += value
return total / len(l) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.