FlavorGraph

The DataReader class is responsible for reading raw text files, building a word-to-ID mapping (vocabulary), and preparing tables for sub-sampling and negative sampling.

When initialized, it performs the following:

1. Vocabulary Building: It reads the file specified by inputFileName and maps words that meet the min_count threshold to unique integer IDs.
2. Sub-sampling Table (initTableDiscards): It calculates a discard probability for each word based on its frequency to implement sub-sampling tricks.
3. Negative Sampling Table (initTableNegatives): It creates a large table of negative samples (NEGATIVE_TABLE_SIZE defaults to $10^8$) where word selection is weighted by their frequency raised to the power of 0.75.

Key attributes:

• word2id: Dictionary mapping words to integer IDs.
• id2word: Dictionary mapping integer IDs back to words.
• word_frequency: Dictionary mapping word IDs to their occurrence counts.
• discards: A NumPy array containing sub-sampling weights for each word ID.

from dataloader import DataReader

# min_count: minimum word occurrences to be included in vocabulary
# care_type: determines negative sampling behavior
# inputFileName: path to the raw text file
reader = DataReader(min_count=5, care_type=0, inputFileName='path/to/data.txt')

print(f"Vocabulary size: {reader.word_count}")

The Metapath2Vec class implements the Metapath2Vec algorithm to generate node embeddings from graph structures using metapath-based random walks.

Workflow:

1. Walker Generation: It uses MetaPathWalker to generate metapath walks. If a file matching the specified parameters already exists in args.input_path, it loads it; otherwise, it generates new walks and saves them.
2. Data Loading: It uses DataReader to process the walks based on args.min_count and args.care_type.
3. Training: It initializes a SkipGramModel (or SkipGramModelAux if args.CSP_train is enabled) and trains it using a DataLoader.
4. Output: The resulting embeddings are saved as a .pickle file.

Modes:

• Normal SkipGram: Standard embedding training.
• SkipGram with CSP: If args.CSP_train is set to True, it uses SkipGramModelAux which includes an auxiliary loss component controlled by args.CSP_coef.

from graph2vec import Metapath2Vec

# Assuming 'args' is a configured Namespace object containing:
# input_path, idx_metapath, which_metapath, num_walks, len_metapath, 
# min_count, care_type, window_size, batch_size, num_workers, dim, 
# iterations, initial_lr, CSP_train, CSP_coef, CSP_save, output_path, idx_embed

model = Metapath2Vec(args, graph)
model.train()

The MetaPathWalker class is used to generate walks through a graph based on specific metapath sequences. It supports both standard random walks and constrained metapath walks.

To use it, initialize the class with an args object (containing configuration like which_metapath, len_metapath, and input_path) and a networkx graph.

Key methods:

• generate_metapaths(args): Returns a list of metapath sequences based on the args.which_metapath flag. Supported flags include:
  • 'CHC': ['compound', 'ingredient+hub']
  • 'CHNHC': ['compound', 'ingredient+hub', 'ingredient+no_hub', 'ingredient+hub']
  • 'NHCHN': ['ingredient+no_hub', 'ingredient+hub', 'compound', 'ingredient+hub']
  • 'RandWalk': Enables standard random walks (sets self.rw = True).
• create_metapath_walks(args, num_walks, meta_paths): Iterates through the graph nodes to generate the requested number of walks for each provided metapath. The resulting walks are shuffled and saved to a text file following the naming pattern: {input_path}{idx_metapath}-metapath_{which_metapath}-num_walks_{num_walks}-len_metapath.txt.

from src.walkers import MetaPathWalker

# Assuming 'args' is a configured Namespace object and 'G' is a networkx graph
walker = MetaPathWalker(args, G)
metapaths = walker.generate_metapaths(args)
walker.create_metapath_walks(args, num_walks=10, meta_paths=metapaths)

The Node2Vec class implements a DeepWalk-style approach to generating node embeddings.

Workflow:

1. Walker Generation: It uses DeepWalker to create features/walks based on args.number_of_walks and args.walk_length.
2. Data Loading: It reads the generated walks using DataReader.
3. Training: It initializes a standard SkipGramModel and trains it over a specified number of args.iterations.
4. Output: Embeddings are saved to a .pickle file in the args.output_path.

Key Parameters:

• args.number_of_walks: Number of walks to perform.
• args.walk_length: Length of each walk.
• args.dim: Dimension of the resulting embeddings.

from graph2vec import Node2Vec

# Assuming 'args' is a configured Namespace object containing:
# input_path, idx_metapath, number_of_walks, walk_length, 
# min_count, care_type, window_size, batch_size, num_workers, 
# dim, initial_lr, iterations, output_path, idx_embed

model = Node2Vec(args, graph)
model.train()