AI

人工智能#

graphistry['ai'] 提供了一套用于图和机器学习工作流程的实用工具，支持可选的GPU加速

特征化#

class graphistry.feature_utils.Embedding(df)#

基础类：object

生成与数据框索引对齐的给定维度的随机嵌入

Parameters:: df (数据框)

fit(n_dim)#

Parameters:: n_dim (int)

fit_transform(n_dim)#

Parameters:: n_dim (int)

transform(ids)#

Return type:: 数据框

class graphistry.feature_utils.FastEncoder(df, y=None, kind='nodes')#

基础类：object

fit(src=None, dst=None, *args, **kwargs)#

fit_transform(src=None, dst=None, *args, **kwargs)#

scale(X=None, y=None, return_pipeline=False, *args, **kwargs)#

通过args-kwargs在df和y上拟合新的缩放函数

Example:

from graphisty.features import SCALERS, SCALER_OPTIONS
print(SCALERS)
g = graphistry.nodes(df)
# set a scaling strategy for features and targets -- umap uses those and produces different results depending.
g2 = g.umap(use_scaler='standard', use_scaler_target=None)

# later if you want to scale new data, you can do so
X, y = g2.transform(df, df, scaled=False)  # unscaled transformer output
# now scale with new settings
X_scaled, y_scaled = g2.scale(X, y, use_scaler='minmax', use_scaler_target='kbins', n_bins=5)
# fit some other pipeline
clf.fit(X_scaled, y_scaled)

参数:

;X: pd.DataFrame of features
:y: pd.DataFrame of target features
:kind: str, one of 'nodes' or 'edges'
*args, **kwargs: passed to smart_scaler pipeline

returns:: 缩放后的 X, y

transform(df, ydf=None)#: 原始转换，无缩放。

transform_scaled(df, ydf=None, scaling_pipeline=None, scaling_pipeline_target=None)#

class graphistry.feature_utils.FastMLB(mlb, in_column, out_columns)#

基础类：object

fit(X, y=None)#

get_feature_names_in()#

get_feature_names_out()#

transform(df)#

class graphistry.feature_utils.FeatureMixin(*args, **kwargs)#

基础类：object

FeatureMixin 用于自动特征化节点和边的 DataFrames。子类 UMAPMixin 用于自动特征的 umap 处理。

用法：

g = graphistry.nodes(df, 'node_column')
g2 = g.featurize()

或者对于边，

g = graphistry.edges(df, 'src', 'dst')
g2 = g.featurize(kind='edges')

或者对节点和边都进行链式操作，

g = graphistry.edges(edf, 'src', 'dst').nodes(ndf, 'node_column')
g2 = g.featurize().featurize(kind='edges')

featurize(kind='nodes', X=None, y=None, use_scaler=None, use_scaler_target=None, cardinality_threshold=40, cardinality_threshold_target=400, n_topics=42, n_topics_target=12, multilabel=False, embedding=False, use_ngrams=False, ngram_range=(1, 3), max_df=0.2, min_df=3, min_words=4.5, model_name='paraphrase-MiniLM-L6-v2', impute=True, n_quantiles=100, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='uniform', similarity=None, categories='auto', keep_n_decimals=5, remove_node_column=True, inplace=False, feature_engine='auto', dbscan=False, min_dist=0.5, min_samples=1, memoize=True, verbose=False)#

对基础节点/边数据框的节点或边进行特征化。

Parameters:

kind (str) – 指定是对节点还是边进行特征化。边的特征化包括使用MultiLabelBinarizer的成对src-to-dst特征块，其他列的处理方式与节点的特征化相同。
X (List[str] | str | DataFrame | None) – 可选输入，默认为None。如果是符号，将根据类型对自身数据进行评估。如果为None，将对DataFrame的所有列进行特征化
y (List[str] | str | DataFrame | None) – 可选的目标列或显式的DataFrame，默认为None
use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None) – 选择哪种缩放器（并自动使用均值策略填补缺失值）来缩放数据。请参阅scikits-learn文档 https://scikit-learn.org/stable/modules/preprocessing.html 这里的‘standard’对应于scikits中的‘StandardScaler’。
use_scaler_target (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None) – 选择哪种缩放器来缩放目标
cardinality_threshold (int) – 跨列分类标签的基数阈值。如果值大于阈值，将在列上运行GapEncoder（主题模型）。如果低于阈值，将进行one-hot_encode。默认值为40。
cardinality_threshold_target (int) – 类似于cardinality_threshold，但用于目标特征。默认值设置较高（400），因为目标通常希望进行独热编码，但有时使用 GapEncoder（即设置较低的阈值）来创建回归目标可能是有用的，特别是当这些目标是文本/软类别并且在不同标签之间具有语义意义时。例如，假设一列有字段如 [‘申请欺诈’, ‘其他状态’, ‘丢失/被盗欺诈’, ‘调查欺诈’, …] GapEncoder会将‘欺诈’标签集中在一起。
n_topics (int) – 如果cardinality_thresholds饱和，则在GapEncoder中使用的主题数量。默认值为42，但一个好的经验法则是参考 Johnson-Lindenstrauss引理 https://en.wikipedia.org/wiki/Johnson%E2%80%93Lindenstrauss_lemma 或使用简化的随机游走估计 => n_topics_lower_bound ~ (pi/2) * (N-documents)**(1/4)
n_topics_target (int) – 如果目标的cardinality_thresholds_target达到饱和，则在GapEncoder中使用的主题数量。默认值为12。
min_words (float) – 设置一个阈值，决定在文本处理管道中考虑文本列时需要包含多少单词。如果你希望任何文本列绕过转换器，转而使用GapEncoder（主题建模），请将此值设置得非常高。设置为0则强制所有指定列作为文本进行编码（嵌入）。
model_name (str) – 使用的Sentence Transformer模型。默认的Paraphrase模型生成有用的向量，但编码时间较长。如果需要更快的编码，average_word_embeddings_komninos是有用的，并生成语义相关性较低的向量。请参阅sentence_transformer库（https://www.sbert.net/）以获取所有可用的模型。
multilabel (bool) – 如果为True，将编码由列表组成的单个目标列作为多标签输出。这仅适用于y=[‘a_single_col’]，默认为False
embedding (bool) – 如果为True，生成一个大小为n_topics的随机节点嵌入默认情况下为False。如果没有提供节点特征，将生成随机嵌入（例如，对于GNN模型）
use_ngrams (bool) – 如果为True，将文本列编码为TfIdf向量，默认情况下为False。
ngram_range (tuple) – 如果 use_ngrams=True，可以设置 ngram_range，例如：tuple = (1, 3)
max_df (float) – 如果 use_ngrams=True，设置词汇表中考虑的最大词频例如：max_df = 0.2,
min_df (int) – 如果 use_ngrams=True，设置词汇表中考虑的最小词频例如：min_df = 3 或 0.00001
categories (str | None) – Optional[str] 在 [“auto”, “k-means”, “most_frequent”] 中，决定在相似性编码中选择哪个类别，默认为 'auto'
impute (bool) – 是否填补缺失值，默认为 True
n_quantiles (int) – 如果 use_scaler = ‘quantile’, 设置分位数箱的大小。
output_distribution (str) – 如果 use_scaler = ‘quantile’, 可以返回分布为 [“normal”, “uniform”]
quantile_range – 如果 use_scaler = ‘robust’|’quantile’，设置分位数范围。
n_bins (int) – 在kbins离散化器中使用的箱数，默认为10
encode (str) – KBinsDiscretizer的编码方式，可以是 onehot, onehot-dense, ordinal，默认为‘ordinal’
strategy (str) – KBinsDiscretizer的策略，可以是 uniform, quantile, kmeans 之一，默认为 ‘quantile’
n_quantiles – 如果 use_scaler = “quantile”，设置分位数的数量，默认=100
output_distribution – 如果 use_scaler=”quantile”|”robust”，从 [“normal”, “uniform”] 中选择
dbscan (bool) – 是否运行DBSCAN，默认为False。
min_dist (float) – DBSCAN eps 参数，默认值为 0.5。
min_samples (int) – DBSCAN min_samples 参数，默认值为 5。
keep_n_decimals (int) – 保留的小数位数
remove_node_column (bool) – 是否移除节点列以便不进行特征化，默认为True。
inplace (bool) – 是否不返回新的graphistry实例，默认为False。
memoize (bool) – 是否在运行之间存储和重用结果，默认为 True。
similarity (str | None)
feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch', 'auto'])
verbose (bool)

Returns:

通过特征化过程设置了新属性的graphistry实例。

featurize_or_get_edges_dataframe_if_X_is_None(X=None, y=None, use_scaler=None, use_scaler_target=None, cardinality_threshold=40, cardinality_threshold_target=400, n_topics=42, n_topics_target=7, multilabel=False, use_ngrams=False, ngram_range=(1, 3), max_df=0.2, min_df=3, min_words=2.5, model_name='paraphrase-MiniLM-L6-v2', similarity=None, categories='auto', impute=True, n_quantiles=10, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='uniform', keep_n_decimals=5, feature_engine='pandas', reuse_if_existing=False, memoize=True, verbose=False)#

辅助方法获取边缘特征和目标矩阵，如果未指定X和y

Parameters:

X (List[str] | str | DataFrame | None) – 数据矩阵
y (List[str] | str | DataFrame | None) – 目标，默认为 None
use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
use_scaler_target (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
cardinality_threshold (int)
cardinality_threshold_target (int)
n_topics (int)
n_topics_target (int)
多标签 (布尔型)
use_ngrams (bool)
ngram_range (元组)
max_df (float)
min_df (int)
min_words (float)
model_name (str)
similarity (str | None)
分类 (字符串 | 无)
impute (bool)
n_quantiles (int)
output_distribution (str)
n_bins (int)
encode (str)
策略 (字符串)
keep_n_decimals (int)
feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch'])
memoize (bool)
verbose (bool)

Returns:

数据 X 和 y

Return type:

元组[数据框, 数据框 | 无, 对象]

featurize_or_get_nodes_dataframe_if_X_is_None(X=None, y=None, use_scaler=None, use_scaler_target=None, cardinality_threshold=40, cardinality_threshold_target=400, n_topics=42, n_topics_target=7, multilabel=False, embedding=False, use_ngrams=False, ngram_range=(1, 3), max_df=0.2, min_df=3, min_words=2.5, model_name='paraphrase-MiniLM-L6-v2', similarity=None, categories='auto', impute=True, n_quantiles=10, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='uniform', keep_n_decimals=5, remove_node_column=True, feature_engine='pandas', reuse_if_existing=False, memoize=True, verbose=False)#

辅助方法获取节点特征和目标矩阵，如果未指定X和y。如果指定了X和y，则将它们设置为_node_target和_node_target属性

Parameters:

X (列表[字符串] | 字符串 | 数据框 | 无)
y (列表[字符串] | 字符串 | 数据框 | 无)
use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
use_scaler_target (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
cardinality_threshold (int)
cardinality_threshold_target (int)
n_topics (int)
n_topics_target (int)
多标签 (布尔型)
embedding (bool)
use_ngrams (bool)
ngram_range (元组)
max_df (float)
min_df (int)
min_words (float)
model_name (str)
similarity (str | None)
分类 (字符串 | 无)
impute (bool)
n_quantiles (int)
output_distribution (str)
n_bins (int)
encode (str)
策略 (字符串)
keep_n_decimals (int)
remove_node_column (bool)
feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch'])
memoize (bool)
verbose (bool)

Return type:

元组[数据框, 数据框, 对象]

get_matrix(columns=None, kind='nodes', target=False)#

返回特征矩阵，如果指定了列，则返回仅包含名称中包含字符串column_part的列的矩阵。`X = g.get_matrix([‘feature1’, ‘feature2’])`将检索仅包含名称中包含字符串feature1或feature2的列的特征矩阵。最常用于主题建模，其中列名的形式为topic_0: descriptor，topic_1: descriptor等。可以检索原始数据框中的唯一列，或实际的主题特征，如[ip_part, shoes, preference_x, 等]。通过列或（顶部）感兴趣的特征从特征化图中检索特征的强大方法。

示例：

# get the full feature matrices
X = g.get_matrix()
y = g.get_matrix(target=True)

# get subset of features, or topics, given topic model encoding
X = g2.get_matrix(['172', 'percent'])
X.columns
    => ['ip_172.56.104.67', 'ip_172.58.129.252', 'item_percent']
# or in targets
y = g2.get_matrix(['total', 'percent'], target=True)
y.columns
    => ['basket_price_total', 'conversion_percent', 'CTR_percent', 'CVR_percent']

# not as useful for sbert features. 

Caveats:

如果你有一个列名是另一个列名的子字符串，你可能会得到意外的结果。

Args:

columns (Union[List, str]):: 列名列表或可能存在于特征矩阵列中的单个列名。如果为None，则返回原始特征矩阵
kind (str, optional):: 节点或边的特征。默认为‘nodes’。
target (bool, optional):: 如果为True，返回目标矩阵。默认为False。

Returns:

pd.DataFrame: 特征矩阵，仅包含名称中包含字符串 column_part 的列。

Parameters:

columns (列表 | 字符串 | 无)
kind (str)
目标 (布尔型)

Return type:

数据框

scale(df=None, y=None, kind='nodes', use_scaler=None, use_scaler_target=None, impute=True, n_quantiles=10, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='uniform', keep_n_decimals=5, return_scalers=False)#

使用与特征化步骤中相同的缩放器来缩放数据。

示例

g = graphistry.nodes(df)
X, y = g.featurize().scale(kind='nodes', use_scaler='robust', use_scaler_target='kbins', n_bins=3)

# or 
g = graphistry.nodes(df)
# set a scaling strategy for features and targets -- umap uses those and produces different results depending.
g2 = g.umap(use_scaler='standard', use_scaler_target=None)

# later if you want to scale new data, you can do so
X, y = g2.transform(df, df, scale=False)
X_scaled, y_scaled = g2.scale(X, y, use_scaler='minmax', use_scaler_target='kbins', n_bins=5)
# fit some other pipeline
clf.fit(X_scaled, y_scaled)

参数:

df:

pd.DataFrame，要转换的原始数据，如果为None，将使用特征化拟合中的数据

y:

pd.DataFrame，可选的目标数据

kind:

字符串，其中之一是 nodes, edges

use_scaler:

缩放变压器

use_scaler_target:

在目标上缩放变换器

impute:

布尔值，如果为True，将填补缺失值

n_quantiles:

int, 用于分位数缩放的分位数数量

output_distribution:

str, 其中之一为 normal, uniform, lognormal

quantile_range:

元组，用于分位数缩放的分位数范围

n_bins:

int, 用于KBinsDiscretizer的箱数

encode:

str, 其中之一为 ordinal, onehot, onehot-dense, binary

strategy:

str, 其中之一为 uniform, quantile, kmeans

keep_n_decimals:

int，缩放后保留的小数位数

return_scalers:

布尔值，如果为True，将返回用于缩放数据的缩放器

返回：

如果return_graph为False，则返回转换后的数据(X, y)；如果return_graph为True，则返回带有推断边的图；如果return_scalers为True，则返回(X, y, scaler, scaler_target)

Parameters:

df (DataFrame | None)
y (DataFrame | None)
kind (str)
use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
use_scaler_target (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
impute (bool)
n_quantiles (int)
output_distribution (str)
n_bins (int)
encode (str)
策略 (字符串)
keep_n_decimals (int)
return_scalers (bool)

transform(df, y=None, kind='nodes', min_dist='auto', n_neighbors=7, merge_policy=False, sample=None, return_graph=True, scaled=True, verbose=False)#

转换新数据并附加到现有图表，或返回数据框

参数:

df:

pd.DataFrame，要转换的原始数据

ydf:

pd.DataFrame, 可选的

kind:

str # 其中之一是 nodes, edges

return_graph:

布尔值，如果为True，将返回一个带有推断边的图。

merge_policy:

布尔值，如果为True，则通过最近邻将批次添加到现有图节点中。如果为False，则仅在批次中的节点之间推断边，默认为False

min_dist:

float，如果return_graph为True，将在NN搜索中使用此值，或使用'auto'推断一个合适的值。min_dist表示两个样本之间的最大距离，以便一个样本被视为另一个样本的邻域。

sample:

int, 如果 return_graph 为 True，将使用现有图的样本边来填充新图

n_neighbors:

int, 如果 return_graph 为 True，将在最近邻搜索中使用此值作为 n_neighbors

scaled:

布尔值，如果为True，将在特征化过程中使用数据集的缩放变换，默认为True

verbose:

布尔值，如果为True，将打印有关图构造的元数据，默认为False

返回：

X, y: pd.DataFrame, 如果 return_graph 为 False，则为转换后的数据如果 return_graph 为 True，则为带有推断边的 graphistry Plottable

Parameters:

df (数据框)
y (DataFrame | None)
kind (str)
min_dist (str | float | int)
n_neighbors (int)
merge_policy (bool)
sample (int | None)
return_graph (bool)
scaled (bool)
verbose (bool)

class graphistry.feature_utils.callThrough(x)#: 基础类：object

graphistry.feature_utils.check_if_textual_column(df, col, confidence=0.35, min_words=2.5)#

检查df的col列是否使用基本启发式方法为文本

Parameters:

df (DataFrame) – 数据框
col (str) – 列名
confidence (float) – 介于0和1之间的阈值浮点值。如果列 col 中有更多元素作为类型 str 的 confidence，它将传递到下一阶段的评估。默认值为0.35
min_words (float) – 平均最小字数阈值。如果col中的平均字数大于此值，则被视为文本。默认值为2.5

Returns:

布尔值，表示列是否为文本类型

Return type:

布尔

graphistry.feature_utils.concat_text(df, text_cols)#

graphistry.feature_utils.encode_edges(edf, src, dst, mlb, fit=False)#

边缘编码器 – 在边缘对上创建多标签二值化器。

Args:: edf (pd.DataFrame): 边缘数据框 src (string): 源列 dst (string): 目标列 mlb (sklearn): 多标签二值化器 fit (bool, 可选): 如果为真，则拟合多标签二值化器。默认为False。

Returns:: 元组: pd.DataFrame, multilabelBinarizer

graphistry.feature_utils.encode_multi_target(ydf, mlb=None)#

graphistry.feature_utils.encode_textual(df, min_words=2.5, model_name='paraphrase-MiniLM-L6-v2', use_ngrams=False, ngram_range=(1, 3), max_df=0.2, min_df=3)#

Parameters:

df (数据框)
min_words (float)
model_name (str)
use_ngrams (bool)
ngram_range (元组)
max_df (float)
min_df (int)

Return type:

元组[数据框, 列表, 任意类型]

graphistry.feature_utils.features_without_target(df, y=None)#

检查 y DataFrame 列名是否在 df 中，如果是，则从 df 中移除它

Parameters:

df (DataFrame) – 模型 DataFrame
y (List | str | DataFrame | None) – 目标 DataFrame

Returns:

模型和目标的DataFrames

Return type:

数据框

graphistry.feature_utils.find_bad_set_columns(df, bad_set=['[]'])#

查找那些如果不强制转换为字符串，将会破坏处理器的列。

Parameters:

df (DataFrame) – 数据框
bad_set (List) – 要查找的字符串列表。

Returns:

列表

graphistry.feature_utils.fit_pipeline(X, transformer, keep_n_decimals=5)#

帮助在转换器管道上拟合DataFrame。如果keep_n_digits不为0，则对结果矩阵X进行四舍五入，这有助于当转换器管道进行缩放或插补时，有时会引入小的负数，而像Hellinger这样的umap度量需要为正数 :param X: 要转换的DataFrame。 :param transformer: 用于拟合和转换的管道对象 :param keep_n_decimals: 在四舍五入转换数据中保留的小数位数

Parameters:

X (数据框)
keep_n_decimals (int)

Return type:

数据框

graphistry.feature_utils.get_cardinality_ratio(df)#

计算DataFrame中唯一值与总行数的比率

Parameters:: df (DataFrame) – 数据框

graphistry.feature_utils.get_dataframe_by_column_dtype(df, include=None, exclude=None)#

graphistry.feature_utils.get_matrix_by_column_part(X, column_part)#

通过列名中存在的列部分获取特征矩阵。

Parameters:

X (数据框)
column_part (str)

Return type:

数据框

graphistry.feature_utils.get_matrix_by_column_parts(X, column_parts)#

通过列名中存在的列部分列表获取特征矩阵。

Parameters:

X (数据框)
column_parts (列表 | 字符串 | 无)

Return type:

数据框

graphistry.feature_utils.get_numeric_transformers(ndf, y=None)#

graphistry.feature_utils.get_preprocessing_pipeline(use_scaler='robust', impute=True, n_quantiles=10, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='quantile')#

用于使用不同的缩放转换器对np.ndarray数据进行插值和缩放的辅助函数。

Parameters:

X – np.ndarray
impute (bool) – 是否进行填补
use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile']) – 选择缩放转换器
n_quantiles (int) – 如果 use_scaler = ‘quantile’, 设置分位数箱的大小。
output_distribution (str) – 如果 use_scaler = ‘quantile’, 可以返回分布为 [“normal”, “uniform”]
quantile_range – 如果 use_scaler = ‘robust’/’quantile’，设置分位数范围。
n_bins (int) – 在kbins离散化器中使用的箱数
encode (str) – KBinsDiscretizer的编码方式，可以是 onehot, onehot-dense, ordinal，默认为‘ordinal’
strategy (str) – KBinsDiscretizer的策略，可以是 uniform, quantile, kmeans 之一，默认为 ‘quantile’

Returns:

缩放后的数组，imputer实例或None，scaler实例或None

Return type:

任何

graphistry.feature_utils.get_text_preprocessor(ngram_range=(1, 3), max_df=0.2, min_df=3)#

graphistry.feature_utils.get_textual_columns(df, min_words=2.5)#

从df中收集它认为是文本的列。

Parameters:

df (DataFrame) – 数据框
min_words (float)

Returns:

列名列表

Return type:

列表

graphistry.feature_utils.group_columns_by_dtypes(df, verbose=True)#

Parameters:

df (数据框)
verbose (bool)

Return type:

字典

graphistry.feature_utils.identity(x)#

graphistry.feature_utils.impute_and_scale_df(df, use_scaler='robust', impute=True, n_quantiles=10, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='uniform', keep_n_decimals=5)#

Parameters:

df (数据框)
use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'])
impute (bool)
n_quantiles (int)
output_distribution (str)
n_bins (int)
encode (str)
策略 (字符串)
keep_n_decimals (int)

Return type:

元组[数据框, 任意]

graphistry.feature_utils.is_cudf_df(df)#

Parameters:: df (任意)
Return type:: 布尔

graphistry.feature_utils.is_cudf_s(s)#

Parameters:: s (任意)
Return type:: 布尔

graphistry.feature_utils.is_dataframe_all_numeric(df)#

Parameters:: df (数据框)
Return type:: 布尔

graphistry.feature_utils.make_array(X)#

graphistry.feature_utils.passthrough_df_cols(df, columns)#

graphistry.feature_utils.process_dirty_dataframes(ndf, y, cardinality_threshold=40, cardinality_threshold_target=400, n_topics=42, n_topics_target=7, similarity=None, categories='auto', multilabel=False, feature_engine='pandas')#

用于记录级别数据的Dirty_Cat编码器。将自动使用智能转换技巧将非均匀数据框转换为矩阵。

Parameters:

ndf (DataFrame) – 节点数据框
y (DataFrame | None) – 目标 DataFrame 或 series
cardinality_threshold (int) – 对于ndf列，低于此阈值时，编码器为OneHot，高于此阈值时，编码器为GapEncoder
cardinality_threshold_target (int) – 对于目标列，低于此阈值时，编码器为OneHot，高于此阈值时，编码器为GapEncoder
n_topics (int) – GapEncoder的主题数量，默认为42
similarity (str | None) – 可以是 'ngram', 'levenshtein-ratio', 'jaro', 或 'jaro-winkler'}) – 使用的成对字符串相似度类型。如果为 None 或 False，则使用 SuperVectorizer
n_topics_target (int)
分类 (字符串 | 无)
多标签 (布尔型)
feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch'])

Returns:

编码后的数据矩阵和目标（如果不是None），数据编码器，以及标签编码器。

Return type:

元组[数据框, 数据框 | 无, 任意, 任意]

graphistry.feature_utils.process_edge_dataframes(edf, y, src, dst, cardinality_threshold=40, cardinality_threshold_target=400, n_topics=42, n_topics_target=7, use_scaler=None, use_scaler_target=None, multilabel=False, use_ngrams=False, ngram_range=(1, 3), max_df=0.2, min_df=3, min_words=2.5, model_name='paraphrase-MiniLM-L6-v2', similarity=None, categories='auto', impute=True, n_quantiles=10, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='uniform', keep_n_decimals=5, feature_engine='pandas')#

自定义边记录编码器。使用MultiLabelBinarizer生成源/目标向量，然后处理文本或其他数据框，以编码edf中存在的任何其他数据，无论是文本还是非文本。

Parameters:

edf (DataFrame) – 边缘特征的pandas DataFrame
y (DataFrame) – 边缘标签的pandas DataFrame
src (str) – 在edf中选择的源列
dst (str) – 在edf中选择的目标列
use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None) – 缩放转换器
use_scaler_target' – 目标的缩放转换器
cardinality_threshold (int)
cardinality_threshold_target (int)
n_topics (int)
n_topics_target (int)
use_scaler_target (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
多标签 (布尔型)
use_ngrams (bool)
ngram_range (元组)
max_df (float)
min_df (int)
min_words (float)
model_name (str)
similarity (str | None)
分类 (字符串 | 无)
impute (bool)
n_quantiles (int)
output_distribution (str)
n_bins (int)
encode (str)
策略 (字符串)
keep_n_decimals (int)
feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch'])

Returns:

编码后的数据矩阵和目标（如果不是None），数据编码器，以及标签编码器。

Return type:

元组[数据框, 数据框, 数据框, 数据框, 列表[任意], 任意, 任意 | 无, 任意 | 无, 任意, 列表[字符串]]

graphistry.feature_utils.process_nodes_dataframes(df, y, cardinality_threshold=40, cardinality_threshold_target=400, n_topics=42, n_topics_target=7, use_scaler='robust', use_scaler_target='kbins', multilabel=False, embedding=False, use_ngrams=False, ngram_range=(1, 3), max_df=0.2, min_df=3, min_words=2.5, model_name='paraphrase-MiniLM-L6-v2', similarity=None, categories='auto', impute=True, n_quantiles=10, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='uniform', keep_n_decimals=5, feature_engine='pandas')#

自动深度学习嵌入/文本特征的ngrams，其余列由dirty_cat处理

Parameters:

df (DataFrame) – 数据的pandas DataFrame
y (DataFrame) – 目标的pandas DataFrame
n_topics (int) – Gap Encoder中的主题数量
n_topics_target (int) – Gap Encoder 中目标主题的数量
use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile']) – 缩放转换器
use_scaler_target (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile']) – 目标的缩放转换器
confidence – 介于0和1之间的数字，如果列中的总条目是字符串并且超过此相对阈值，则将传递列进行文本处理。
min_words (float) – 设置用于包含文本句子编码列的平均单词数的阈值。较低的值意味着列将被标记为文本并发送到句子编码器。设置为0以强制将命名列作为文本。
model_name (str) – SentenceTransformer 模型名称。可用的模型列表请参见 https://www.sbert.net/docs/pretrained_models. html#sentence-embedding-models
cardinality_threshold (int)
cardinality_threshold_target (int)
多标签 (布尔型)
embedding (bool)
use_ngrams (bool)
ngram_range (元组)
max_df (float)
min_df (int)
similarity (str | None)
分类 (字符串 | 无)
impute (bool)
n_quantiles (int)
output_distribution (str)
n_bins (int)
encode (str)
策略 (字符串)
keep_n_decimals (int)
feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch'])

Returns:

X_enc, y_enc, data_encoder, label_encoder, scaling_pipeline, scaling_pipeline_target, text_model, text_cols,

Return type:

元组[数据框, 任意, 数据框, 任意, 任意, 任意, 任意 | 无, 任意 | 无, 任意, 列表[字符串]]

graphistry.feature_utils.remove_internal_namespace_if_present(df)#

下面的一些转换会向DataFrame添加列，此方法在特征化之前移除它们如果在UMAP过程中添加了后缀，则不会删除

Parameters:: df (DataFrame) – 数据框
Returns:: 删除了保留命名空间中列的DataFrame

graphistry.feature_utils.remove_node_column_from_symbolic(X_symbolic, node)#

graphistry.feature_utils.resolve_X(df, X)#

Parameters:

df (DataFrame | None)
X (列表[字符串] | 字符串 | 数据框 | 无)

Return type:

数据框

graphistry.feature_utils.resolve_feature_engine(feature_engine)#

Parameters:: feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch', 'auto'])
Return type:: 字面量['none', 'pandas', 'dirty_cat', 'torch']

graphistry.feature_utils.resolve_scaler(use_scaler, feature_engine)#

Parameters:

use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch'])

Return type:

字面量['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile']

graphistry.feature_utils.resolve_scaler_target(use_scaler_target, feature_engine, multilabel)#

Parameters:

use_scaler_target (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'] | None)
feature_engine (Literal['none', 'pandas', 'dirty_cat', 'torch'])
多标签 (布尔型)

Return type:

字面量['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile']

graphistry.feature_utils.resolve_y(df, y)#

Parameters:

df (DataFrame | None)
y (列表[字符串] | 字符串 | 数据框 | 无)

Return type:

数据框

graphistry.feature_utils.reuse_featurization(g, memoize, metadata)#

Parameters:

g (Plottable)
memoize (bool)
元数据 (任意)

graphistry.feature_utils.safe_divide(a, b)#

graphistry.feature_utils.set_currency_to_float(df, col, return_float=True)#

Parameters:

df (数据框)
col (str)
return_float (bool)

graphistry.feature_utils.set_to_bool(df, col, value)#

Parameters:

df (数据框)
col (str)
值 (任意类型)

graphistry.feature_utils.set_to_datetime(df, cols, new_col)#

Parameters:

df (数据框)
cols (列表)
new_col (str)

graphistry.feature_utils.set_to_numeric(df, cols, fill_value=0.0)#

Parameters:

df (数据框)
cols (列表)
fill_value (float)

graphistry.feature_utils.smart_scaler(X_enc, y_enc, use_scaler, use_scaler_target, impute=True, n_quantiles=10, output_distribution='normal', quantile_range=(25, 75), n_bins=10, encode='ordinal', strategy='uniform', keep_n_decimals=5)#

Parameters:

use_scaler (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'])
use_scaler_target (Literal['none', 'kbins', 'standard', 'robust', 'minmax', 'quantile'])
impute (bool)
n_quantiles (int)
output_distribution (str)
n_bins (int)
encode (str)
策略 (字符串)
keep_n_decimals (int)

graphistry.feature_utils.transform(df, ydf, res, kind, src, dst)#

Parameters:

df (数据框)
ydf (数据框)
res (列表)
kind (str)

Return type:

元组[数据框, 数据框]

graphistry.feature_utils.transform_dirty(df, data_encoder, name='')#

Parameters:

df (数据框)
data_encoder (Any)
名称 (字符串)

Return type:

数据框

graphistry.feature_utils.transform_text(df, text_model, text_cols)#

Parameters:

df (数据框)
text_model (Any)
text_cols (列表 | 字符串)

Return type:

数据框

graphistry.feature_utils.where_is_currency_column(df, col)#

Parameters:

df (数据框)
col (str)

graphistry.feature_utils.FeatureEngine#: Literal['none', 'pandas', 'dirty_cat', 'torch', 'auto'] 的别名

graphistry.feature_utils.FeatureEngineConcrete#: Literal['none', 'pandas', 'dirty_cat', 'torch'] 的别名

UMAP#

class graphistry.umap_utils.UMAPMixin(*args, **kwargs)#

基础类：object

UMAP混入用于自动UMAP处理

filter_weighted_edges(scale=1.0, index_to_nodes_dict=None, inplace=False, kind='nodes')#

根据_weighted_edges_df（例如来自.umap()）过滤边

Parameters:

scale (float)
index_to_nodes_dict (Dict | None)
inplace (布尔值)
kind (str)

transform_umap(df, y=None, kind='nodes', min_dist='auto', n_neighbors=7, merge_policy=False, sample=None, return_graph=True, fit_umap_embedding=True, umap_transform_kwargs={})#

将数据转换为UMAP嵌入

Args:

df:: 要转换的Dataframe
y:: 目标列
kind:: 其中之一是节点或边
min_dist:: 用于在infer_graph中包含邻居的Epsilon
n_neighbors:: 用于上下文化的邻居数量
merge_policy:: 如果为True，则使用之前的图，将新批次添加到现有图的邻居中，有助于将新数据与现有图进行上下文关联。如果为False，sample则无关紧要。

样本：用于上下文化的现有图的邻居的样本数量——有助于使图更密集 return_graph：是否返回图或仅返回嵌入 fit_umap_embedding：是否从新数据的UMAP嵌入推断图，默认为True

Parameters:

df (数据框)
y (DataFrame | None)
kind (str)
min_dist (str | float | int)
n_neighbors (int)
merge_policy (bool)
sample (int | None)
return_graph (bool)
fit_umap_embedding (布尔值)
umap_transform_kwargs (Dict[str, Any])

Return type:

Tuple[DataFrame, DataFrame, DataFrame] | Plottable

umap(X=None, y=None, kind='nodes', scale=1.0, n_neighbors=12, min_dist=0.1, spread=0.5, local_connectivity=1, repulsion_strength=1, negative_sample_rate=5, n_components=2, metric='euclidean', suffix='', play=0, encode_position=True, encode_weight=True, dbscan=False, engine='auto', feature_engine='auto', inplace=False, memoize=True, umap_kwargs={}, umap_fit_kwargs={}, umap_transform_kwargs={}, **featurize_kwargs)#

UMAP 特征化的节点或边数据，或传入您自己的 X, y（可选）数据框值

示例

>>> import graphistry   
>>> g = graphistry.nodes(pd.DataFrame({'node': [0,1,2], 'data': [1,2,3], 'meta': ['a', 'b', 'c']}))
>>> g2 = g.umap(n_components=3, spread=1.0, min_dist=0.1, n_neighbors=12, negative_sample_rate=5, local_connectivity=1, repulsion_strength=1.0, metric='euclidean', suffix='', play=0, encode_position=True, encode_weight=True, dbscan=False, engine='auto', feature_engine='auto', inplace=False, memoize=True)
>>> g2.plot()

参数

X:

要么是一个特征的数据框ndarray，要么是要特征化的列名

y:

要么是一个目标的数据框ndarray，要么是要特征化的目标列名

kind:

nodes 或 edges 或 None。如果为 None，期望显式的 X, y（可选）矩阵，并且不会将它们与节点或边关联。如果提供了 X, y（可选），并且 kind = [nodes, edges]，它将把新矩阵关联到节点或边的属性。

scale:

用于修剪从UMAP获得的加权边DataFrame的乘法比例，范围在[0, ..)之间，高端表示保留所有边

n_neighbors:

UMAP 包含的最近邻居数量，用于 UMAP 连接性，数值越小布局越紧凑。最小值为 2

min_dist:

UMAP 浮点数介于 0 和 1 之间，较低的值会使布局更紧凑。

spread:

UMAP 值的分布用于放松

local_connectivity:

UMAP 连接参数

repulsion_strength:

UMAP 排斥强度

negative_sample_rate:

UMAP 负采样率

n_components:

UMAP投影中的组件数量，默认值为2

metric:

UMAP 度量标准，默认为 'euclidean'。详见 (UMAP-LEARN)[https://umap-learn.readthedocs.io/ en/latest/parameters.html] 文档以获取更多信息。

suffix:

可选的附加到umap的x、y属性的后缀。

play:

Graphistry 播放参数，默认值为 0，表示在聚类过程中网络演化的程度。0 保留原始的 UMAP 布局。

encode_weight:

如果为True，将从隐式UMAP设置新的edges_df，默认为True。

encode_position:

是否设置默认的绘图绑定 – 用于.plot()的umap中的x,y位置，默认为True

dbscan:

是否在UMAP嵌入上运行DBSCAN，默认为False。

engine:

选择用于计算UMAP的引擎：默认“auto”将使用cuML（如果可用），否则使用UMAP-LEARN。

feature_engine:

如何编码数据 (“none”, “auto”, “pandas”, “dirty_cat”, “torch”)

inplace:

bool = False，是否修改当前对象，默认为False。当为False时，返回一个新对象，适用于函数式编程中的链式调用。

memoize:

是否缓存此方法的结果，默认为True。

umap_kwargs:

可选的关键字参数传递给底层的UMAP库构造函数

umap_fit_kwargs:

可选的kwargs传递给底层的UMAP拟合方法，包括fit_transform的fit部分

umap_transform_kwargs:

可选的kwargs传递给底层的UMAP转换方法，包括fit_transform的转换部分

featurize_kwargs:

传递给 .featurize() 的可选 kwargs

Returns:

自身，属性设置为新数据

Parameters:

X (列表[字符串] | 字符串 | 数据框 | 无)
y (列表[字符串] | 字符串 | 数据框 | 无)
kind (str)
scale (float)
n_neighbors (int)
min_dist (float)
spread (float)
local_connectivity (int)
repulsion_strength (float)
negative_sample_rate (int)
n_components (int)
metric (str)
suffix (str)
play (int | None)
encode_position (bool)
encode_weight (bool)
dbscan (bool)
engine (Literal['cuml', 'umap_learn', 'auto'])
feature_engine (str)
inplace (布尔值)
memoize (bool)
umap_kwargs (Dict[str, Any])
umap_fit_kwargs (Dict[str, Any])
umap_transform_kwargs (Dict[str, Any])

umap_fit(X, y=None, umap_fit_kwargs={})#

Parameters:

X (数据框)
y (DataFrame | None)
umap_fit_kwargs (Dict[str, Any])

umap_lazy_init(res, n_neighbors=12, min_dist=0.1, spread=0.5, local_connectivity=1, repulsion_strength=1, negative_sample_rate=5, n_components=2, metric='euclidean', engine='auto', suffix='', umap_kwargs={}, umap_fit_kwargs={}, umap_transform_kwargs={})#

Parameters:

n_neighbors (int)
min_dist (float)
spread (float)
local_connectivity (int)
repulsion_strength (float)
negative_sample_rate (int)
n_components (int)
metric (str)
engine (Literal['cuml', 'umap_learn', 'auto'])
suffix (str)
umap_kwargs (Dict[str, Any])
umap_fit_kwargs (Dict[str, Any])
umap_transform_kwargs (Dict[str, Any])

graphistry.umap_utils.assert_imported()#

graphistry.umap_utils.assert_imported_cuml()#

graphistry.umap_utils.is_legacy_cuml()#

graphistry.umap_utils.make_safe_gpu_dataframes(X, y, engine)#

graphistry.umap_utils.prune_weighted_edges_df_and_relabel_nodes(wdf, scale=0.1, index_to_nodes_dict=None)#

修剪加权边DataFrame以返回高保真相似度分数。

Parameters:

wdf (DataFrame | Any) – 通过UMAP获得的加权边DataFrame
scale (float) – 较低的值意味着较少的边缘 > (最大值 - scale * 标准差)
index_to_nodes_dict (Dict | None) – 索引到节点名称的字典；如果提供，则重新映射源/目标值

Returns:

pd.DataFrame

Return type:

数据框

graphistry.umap_utils.resolve_umap_engine(engine)#

Parameters:: engine (Literal['cuml', 'umap_learn', 'auto'])
Return type:: 字面量[‘cuml’, ‘umap_learn’]

graphistry.umap_utils.reuse_umap(g, memoize, metadata)#

Parameters:

g (Plottable)
memoize (bool)
元数据 (任意)

graphistry.umap_utils.umap_graph_to_weighted_edges(umap_graph, engine, is_legacy, cfg=<module 'graphistry.constants' from '/home/docs/checkouts/readthedocs.org/user_builds/pygraphistry/checkouts/latest/graphistry/constants.py'>)#

Parameters:: engine (Literal['cuml', 'umap_learn'])

语义搜索#

class graphistry.text_utils.SearchToGraphMixin(*args, **kwargs)#

基础类：object

assert_features_line_up_with_nodes()#

assert_fitted()#

build_index(angular=False, n_trees=None)#

classmethod load_search_instance(savepath)#

save_search_instance(savepath)#

search(query, cols=None, thresh=5000, fuzzy=True, top_n=10)#

对节点进行自然语言查询，返回按相关性列“distance”排序的结果数据框。

如果节点数据尚未进行特征编码（并且给出了明确的边），运行自动特征工程：
g2 = g.featurize(kind='nodes', X=['text_col_1', ..],
min_words=0 # forces all named columns are textually encoded
)
如果边尚不存在，通过以下方式生成它们
g2 = g.umap(kind='nodes', X=['text_col_1', ..],
min_words=0 # forces all named columns are textually encoded
)
如果尚未构建索引，则在搜索时动态生成g2.build_index()。否则，可以设置g2.build_index()提前构建它。

Args:

query (str):: 自然语言查询。
cols (list or str, optional):: 如果fuzzy=False，选择要查询的列。默认为None，因为默认情况下fuzzy=True。
thresh (float, optional):: 距离阈值，从查询向量到返回结果的距离。默认值为5000，为了以防万一设置得较大，但可以低至10。
fuzzy (bool, optional):: 如果为True，则使用嵌入 + annoy索引进行召回，否则在给定的cols上进行字符串匹配默认为True。
top_n (int, optional):: 返回多少结果。默认为100。

Returns:

pd.DataFrame, vector_encoding_of_query: 与查询匹配的结果的排名有序数据框

如果fuzzy=True，则通过给定的transformer/ngrams模型对查询进行向量编码，否则为None

Parameters:

query (str)
thresh (浮点数)
fuzzy (bool)
top_n (int)

search_graph(query, scale=0.5, top_n=100, thresh=5000, broader=False, inplace=False)#

Input a natural language query and return a graph of results.

更多信息请参见帮助(g.search)

Args:

query (str):: 查询输入示例“编码最佳实践”
scale (float, optional):: 边权重阈值，默认为0.5。
top_n (int, optional):: 返回多少结果。默认为100。
thresh (float, optional):: 距离阈值，从查询向量到返回结果的距离。默认值为5000，为了以防万一可以设置得较大，但也可以低至10。
broader (bool, optional):: 如果为True，将检索通过边连接的实体，这些实体不一定在results_dataframe中冒泡。默认为False。
inplace (bool, optional):: 是否返回新实例（默认）或改变自身。默认为 False。

Returns:

graphistry 实例: g

Parameters:

query (str)
scale (float)
top_n (int)
thresh (浮点数)
更广泛 (布尔)
inplace (布尔值)

DBSCAN#

class graphistry.compute.cluster.ClusterMixin(*args, **kwargs)#

基础类：object

dbscan(min_dist=0.2, min_samples=1, cols=None, kind='nodes', fit_umap_embedding=True, target=False, verbose=False, engine_dbscan='sklearn', *args, **kwargs)#

DBSCAN clustering on cpu or gpu infered automatically. Adds a _dbscan column to nodes or edges.: 注意：g.transform_dbscan(..) 目前在GPU上不受支持。

示例：

g = graphistry.edges(edf, 'src', 'dst').nodes(ndf, 'node')

# cluster by UMAP embeddings
kind = 'nodes' | 'edges'
g2 = g.umap(kind=kind).dbscan(kind=kind)
print(g2._nodes['_dbscan']) | print(g2._edges['_dbscan'])

# dbscan in umap or featurize API
g2 = g.umap(dbscan=True, min_dist=1.2, min_samples=2, **kwargs)
# or, here dbscan is infered from features, not umap embeddings
g2 = g.featurize(dbscan=True, min_dist=1.2, min_samples=2, **kwargs)

# and via chaining,
g2 = g.umap().dbscan(min_dist=1.2, min_samples=2, **kwargs)

# cluster by feature embeddings
g2 = g.featurize().dbscan(**kwargs)

# cluster by a given set of feature column attributes, or with target=True
g2 = g.featurize().dbscan(cols=['ip_172', 'location', 'alert'], target=False, **kwargs)

# equivalent to above (ie, cols != None and umap=True will still use features dataframe, rather than UMAP embeddings)
g2 = g.umap().dbscan(cols=['ip_172', 'location', 'alert'], umap=True | False, **kwargs)

g2.plot() # color by `_dbscan` column

Useful:

使用UMAP的聚类标签丰富图表有助于通过颜色、大小等方式可视化图表中的聚类，以及评估每个聚类的指标，例如 graphistry/pygraphistry

Args:

min_dist float:: 两个样本之间的最大距离，以便它们被视为在同一邻域内。
kind str:: ‘节点’ 或 ‘边’
cols:: 用于聚类的列列表，假设g.featurize已经运行，这是一种按感兴趣片段切片特征或目标的好方法，例如 [‘ip_172’, ‘location’, ‘ssh’, ‘warnings’]
fit_umap_embedding bool:: 是否使用UMAP嵌入或特征数据框来聚类DBSCAN
min_samples:: 一个点被视为核心点的邻域中的样本数量。这包括点本身。
target:: 是否使用目标列作为聚类特征

Parameters:

min_dist (float)
min_samples (int)
cols (列表 | 字符串 | 无)
kind (str)
fit_umap_embedding (布尔值)
目标 (布尔型)
verbose (bool)
engine_dbscan (str)

transform_dbscan(df, y=None, min_dist='auto', infer_umap_embedding=False, sample=None, n_neighbors=None, kind='nodes', return_graph=True, verbose=False)#

将一个小批量数据框转换为包含新列‘_dbscan’的数据框，该列包含小批量上的DBSCAN聚类标签，并生成一个包含小批量和原始图的图，其中小批量与原始图之间的边是从umap嵌入或特征数据框推断出来的。图节点 | 边将根据‘_dbscan’列进行着色。

示例：

fit:
    g = graphistry.edges(edf, 'src', 'dst').nodes(ndf, 'node')
    g2 = g.featurize().dbscan()

predict:
::

    emb, X, _, ndf = g2.transform_dbscan(ndf, return_graph=False)
    # or
    g3 = g2.transform_dbscan(ndf, return_graph=True)
    g3.plot()

同样适用于umap：

fit:
    g = graphistry.edges(edf, 'src', 'dst').nodes(ndf, 'node')
    g2 = g.umap(X=.., y=..).dbscan()

predict:
::

    emb, X, y, ndf = g2.transform_dbscan(ndf, ndf, return_graph=False)
    # or
    g3 = g2.transform_dbscan(ndf, ndf, return_graph=True)
    g3.plot()

Args:

df:: 要转换的数据框
y:: 可选的标签数据框
min_dist:: 两个样本之间的最大距离，以便它们被视为在同一邻域内。较小的值将导致小批量数据和原始图之间的边较少。默认值为‘auto’，从新点到原始图的平均距离和标准差推断min_dist。
fit_umap_embedding:: 在推断小批次和原始图之间的边时，是否使用UMAP嵌入或特征数据框。默认值为False，使用特征数据框
sample:: 在推断小批量数据和原始图之间的边时要使用的样本数量，如果为None，则仅使用最接近小批量数据的点。如果大于0，则将在现有图中采样最接近的sample个点以引入更多边。默认值为None
kind:: ‘节点’ 或 ‘边’
return_graph:: 是否返回图形或（emb, X, y, 带有DBSCAN标签的minibatch df），默认为True 推断的图形仅支持kind=’nodes’。
verbose:: 是否打印进度，默认为 False

Parameters:

df (数据框)
y (DataFrame | None)
min_dist (float | str)
infer_umap_embedding (bool)
sample (int | None)
n_neighbors (int | None)
kind (str)
return_graph (bool)
verbose (bool)

graphistry.compute.cluster.dbscan_fit(g, dbscan, kind='nodes', cols=None, use_umap_embedding=True, target=False, verbose=False)#

Fits clustering on UMAP embeddings if umap is True, otherwise on the features dataframe

如果目标为True，则为目标数据框。

Args:

g:: 图形化图表
kind:: ‘节点’ 或 ‘边’
cols:: 用于聚类的列列表，假设已经运行了g.featurize
use_umap_embedding:: 是否使用UMAP嵌入或特征数据框进行聚类（默认值：True）

Parameters:

g (任意)
dbscan (Any)
kind (str)
cols (列表 | 字符串 | 无)
use_umap_embedding (bool)
目标 (布尔型)
verbose (bool)

graphistry.compute.cluster.dbscan_predict(X, model)#

DBSCAN 本身没有预测功能，所以我们在这里从 https://stackoverflow.com/questions/27822752/scikit-learn-predicting-new-points-with-dbscan 逆向工程了一个预测功能。

Parameters:

X (数据框)
模型 (任意)

graphistry.compute.cluster.get_model_matrix(g, kind, cols, umap, target)#

允许单个函数获取节点和边的模型矩阵，以及目标、嵌入和特征

Args:

g:: 图形化图表
kind:: ‘节点’ 或 ‘边’
cols:: 用于聚类的列列表，前提是已经运行了g.featurize
umap:: 是否使用UMAP嵌入或特征数据框
target:: 是否使用目标数据框或特征数据框

Returns:

pd.DataFrame: 给定输入的模型矩阵的数据框

Parameters:

kind (str)
cols (列表 | 字符串 | 无)

graphistry.compute.cluster.make_safe_gpu_dataframes(X, y, engine)#: 辅助方法，用于将数据框强制转换为正确的类型（pd 与 cudf）

graphistry.compute.cluster.resolve_cpu_gpu_engine(engine)#

Parameters:: engine (Literal['cuml', 'umap_learn', 'auto'])
Return type:: 字面量[‘cuml’, ‘umap_learn’]

RGCN#

class graphistry.networks.DotProductPredictor#

基础类：object

forward(graph, h)#

class graphistry.networks.GCN(in_feats, h_feats, num_classes)#

基础类：object

forward(g, in_feat)#

class graphistry.networks.HeteroClassifier(in_dim, hidden_dim, n_classes, rel_names)#

基础类：object

forward(g)#

class graphistry.networks.HeteroEmbed(num_nodes, num_rels, d, proto, node_features=None, device='cpu', reg=0.01)#

基础类：object

Parameters:

num_nodes (int)
num_rels (int)
d (整数)

loss(node_embedding, triplets, labels)#

score(node_embedding, triplets)#

class graphistry.networks.LinkPredModel(in_features, hidden_features, out_features)#

基础类：object

forward(g, x)#

class graphistry.networks.LinkPredModelMultiOutput(in_features, hidden_features, out_features, out_classes)#

基础类：object

embed(g, x)#

forward(g, x)#

class graphistry.networks.MLPPredictor(in_features, out_classes)#

基础类：object

也可以编写一个预测函数，使用MLP为每条边预测一个向量。这样的向量可以用于进一步的下游任务，例如作为分类分布的logits。

apply_edges(edges)#

forward(graph, h)#

class graphistry.networks.RGCN(in_feats, hid_feats, out_feats, rel_names)#

基础类：object

异构图，我们沿着所有边类型从邻居那里收集消息。您可以使用模块 dgl.nn.pytorch.HeteroGraphConv（在 MXNet 和 Tensorflow 中也可用）来执行在所有边类型上的消息传递，然后为每种边类型组合不同的图卷积模块。

:returns: 具有前向传递方法的torch模型，适用于以标准方式拟合模型

forward(graph, inputs)#

class graphistry.networks.RGCNEmbed(d, num_nodes, num_rels, hidden=None, device='cpu')#

基础类：object

forward(g, node_features=None)#

class graphistry.networks.SAGE(in_feats, hid_feats, out_feats)#

基础类：object

forward(graph, inputs)#

graphistry.networks.train_link_pred(model, G, epochs=100, use_cross_entropy_loss=False)#

异构图嵌入模块混合#

class graphistry.embed_utils.EmbedDistScore#

基础类：object

static DistMult(h, r, t)#

Parameters:

h (任意)
r (任意)
t (任意)

Return type:

任何

static RotatE(h, r, t)#

Parameters:

h (任意)
r (任意)
t (任意)

Return type:

任何

static TransE(h, r, t)#

Parameters:

h (任意)
r (任意)
t (任意)

Return type:

任何

class graphistry.embed_utils.HeterographEmbedModuleMixin#

基础类：object

embed(relation, proto='DistMult', embedding_dim=32, use_feat=False, X=None, epochs=2, batch_size=32, train_split=0.8, sample_size=1000, num_steps=50, lr=0.01, inplace=False, device='cpu', evaluate=True, *args, **kwargs)#

使用关系图卷积网络（RGCN）嵌入图，并返回一个新的graphistry图，其中嵌入作为节点属性。

参数#

relationstr: 用作节点之间关系的列
protoProtoSymbolic: 使用的度量标准，[‘TransE’, ‘RotateE’, ‘DistMult’] 或提供您自己的。默认为 ‘DistMult’。
embedding_dimint: 关系嵌入维度。默认为32
use_featbool: 是否对节点进行特征化，如果为False将在训练期间生成随机嵌入并对其进行形状调整。默认为True
XXSymbolic: 在节点数据框中要特征化的列。继承自graphistry.featurize()的参数。默认为None。
epochsint: 训练轮数。默认为2
batch_sizeint: batch_size。默认为32
train_splitUnion[float, int]: 训练百分比，介于0到1之间。默认为0.8。
sample_sizeint: 样本大小。默认为1000
num_stepsint: num_steps。默认为50
lrfloat: 学习率。默认为0.002
inplaceOptional[bool]: 原地
deviceOptional[str]: 加速器。默认为“cpu”
evaluatebool: 是否进行评估。默认为 False。

返回#

self : 图形实例

Parameters:

关系 (字符串)
proto (str | Callable[[Any, Any, Any], Any] | None)
embedding_dim (int)
use_feat (bool)
X (列表[字符串] | 字符串 | 数据框 | 无)
epochs (整数)
batch_size (int)
train_split (浮点数 | 整数)
sample_size (int)
num_steps (int)
lr (float)
inplace (bool | None)
设备 (字符串 | 无)
evaluate (bool)

Return type:

Plottable

predict_links(source=None, relation=None, destination=None, threshold=0.5, anomalous=False, retain_old_edges=False, return_dataframe=False)#

预测给定源、关系和目标的所有组合的链接。

参数#

source: list: 目标源节点。默认为None（全部）。
relation: list: 目标关系。默认为None（全部）。
destination: list: 目标目的地。默认为无（全部）。
thresholdOptional[float]: 概率阈值。默认为0.5
retain_old_edgesOptional[bool]: 将在预测图中包含旧边。默认为 False。
return_dataframeOptional[bool]: 将返回一个数据框而不是一个graphistry实例。默认为False。
anomalousOptional[False]: 将返回小于阈值的边或低置信度的边（异常）。

返回#

Graphistry Instance: 包含相应的源、关系、目标和分数列如果分数 >= 阈值则为异常，否则分数 <= 阈值，或者是一个数据框

Parameters:

source (列表 | 无)
关系 (列表 | 无)
目的地 (列表 | 无)
threshold (float | None)
异常的 (bool | None)
retain_old_edges (bool | None)
return_dataframe (bool | None)

Return type:

Plottable

predict_links_all(threshold=0.5, anomalous=False, retain_old_edges=False, return_dataframe=False)#

在整个图上根据阈值预测链接

参数#

thresholdOptional[float]: 概率阈值。默认为0.5
anomalousOptional[False]: 将返回小于阈值的边或低置信度的边（异常）。
retain_old_edgesOptional[bool]: 将在预测图中包含旧边。默认为 False。
return_dataframe: Optional[bool]: 将返回一个数据框而不是一个graphistry实例。默认为False。

返回#

Plottable: 包含所有预测/异常链接或数据框的graphistry图实例

Parameters:

threshold (float | None)
异常的 (bool | None)
retain_old_edges (bool | None)
return_dataframe (bool | None)

Return type:

Plottable

class graphistry.embed_utils.SubgraphIterator(g, sample_size=3000, num_steps=1000)#

基础类：object

Parameters:

sample_size (int)
num_steps (int)

graphistry.embed_utils.check_cudf()#

graphistry.embed_utils.log(msg)#

Parameters:: msg (str)
Return type:: 无

AI

目录

人工智能#

特征化#

UMAP#

语义搜索#

DBSCAN#

RGCN#

异构图嵌入模块混合#

参数#

返回#

参数#

返回#

参数#

返回#