Shortestpath with node2vec

Requirement library

1. Numpy (pip install numpy)

2. Graph (pip install graphs)
3. Tqdm (pip install tqdm)
4. Src (pip install src)
5. Networkx

BFS dan DFS

BFS adalah singkatan dari "Breadth-First Search" (Pencarian Lebar). BFS adalah salah satu algoritma
yang digunakan dalam pemrograman dan teori graf untuk melakukan pencarian atau traversal
(penelusuran) pada struktur data graf.

BFS beroperasi dengan mengunjungi simpul (node) pada tingkat atau kedalaman tertentu sebelum
melanjutkan ke simpul-simpul yang berada pada tingkat atau kedalaman berikutnya. Dalam BFS,
pencarian dimulai dari akhir awal (start node), kemudian semua akhirat yang terhubung langsung ke
akhir awal dikunjungi terlebih dahulu. Setelah itu, simpul-simpul tersebut diberi label "terlihat"
(dikunjungi) dan dimasukkan ke dalam antrian. Proses ini diulangi untuk semua simpul yang ada
dalam antrian, sehingga menghasilkan penjelajahan secara "lebar" dari simpul-simpul graf.

Sedangkan DFS adalah singkatan dari "Depth-First Search" (Pencarian Kedalaman). DFS adalah salah
satu algoritma yang digunakan dalam pemrograman dan teori graf untuk melakukan pencarian atau
traversal (penelusuran) pada struktur data graf.

DFS bekerja dengan penjelajahan secara mendalam ke simpul-simpul yang terhubung langsung
dengan simpul awal (start node) terlebih dahulu. Jika masih ada simpul yang belum dikunjungi pada
jalur yang sedang dijelajahi, maka simpul tersebut menjadi prioritas dan dilakukan penjelajahan lebih
dalam ke simpul-simpul yang terhubung langsung dengan simpul tersebut. Proses ini dilakukan
secara rekursif atau menggunakan tumpukan (stack).

DFS akan terus bergerak ke simpul berikutnya hingga mencapai simpul akhir atau tidak ada lagi
simpul yang dapat dijangkau dari simpul yang sedang diperiksa. Jika tidak ada simpul yang belum
dikunjungi pada jalur saat ini, maka kembalilah ke simpul sebelumnya dan coba jalur lain yang belum
dijelajahi.

DFS biasanya digunakan untuk mencari jalur atau rute di graf, seperti mencari jalur terpendek atau
mencari siklus. Selain itu, DFS juga berguna dalam menemukan komponen yang terhubung dalam
grafik, pencarian dalam pohon (tree traversal), dan banyak aplikasi lainnya.

Perbedaan utama antara BFS dan DFS adalah cara penjelajahan simpul. Penelusuran BFS unik secara
lebar, sedangkan penelusuran DFS unik secara mendalam.
 1. Import data

import networkx as nx
import numpy as np
from tqdm.auto import tqdm
import pickle
import time

np.random.seed(999)
edgelist_path = '../data/'socfb-American75'.edgelist'
graph = nx.read_edgelist(edgelist_path, nodetype=int)

nodes = list(graph.nodes)  # [int(i) for i in list(graph.nodes)]

landmarks = np.random.randint(1, len(nodes), 150)

distance_map = {}
distances = np.zeros((len(nodes), ))

for landmark in tqdm(landmarks):

    distances[:] = np.inf
    node_dists = nx.shortest_path_length(graph, landmark)
    for key, value in node_dists.items():
        distances[key-1] = value  # since node labels start from 1.
    distance_map[landmark] = distances.copy()  # copy because array is
re-init on loop start

save_path = '../outputs/distance_map_'+graph_name+'_'+str(time.time())
+'.pickle'
pickle.dump(distance_map, open(save_path, 'wb'))
print('distance_map saved at', save_path)

2. embedding jarak yang berpasangan

"""
for each distance get the corresponding node embeddings and combine by
averaging them.
this cell has a bug which causes emd_dist_pair to store some duplicate
items. These duplicates are dropped later.
"""
from tqdm.auto import tqdm

emd_dist_pair = []
for landmark in tqdm(list(distance_map.keys())):
    node_distances = distance_map[landmark]
    emd_dist_pair.extend([((emd_map[node]+emd_map[landmark])/2,
distance) for node, distance in enumerate(node_distances, 1) if node !=
landmark and distance != np.inf])

print('length of embedding-distance pairs', len(emd_dist_pair))

3. split file

from sklearn.model_selection import train_test_split

import torch

seed_random = 9999
np.random.seed(seed_random)
torch.backends.cudnn.deterministic = True
if torch.cuda.is_available():
    torch.cuda.manual_seed_all(seed_random)

x_train, x_test, y_train, y_test = train_test_split(x, y,

test_size=0.25, train_size=0.75, random_state=seed_random,
shuffle=True, stratify=y)
x_train, x_cv, y_train, y_cv = train_test_split(x_train, y_train,
test_size=0.2, train_size=0.8, random_state=seed_random, shuffle=True,
stratify=y_train)

print('shapes of train, validation, test data', x_train.shape,

y_train.shape, x_cv.shape, y_cv.shape, x_test.shape, y_test.shape)

4. normalisai data

from sklearn.preprocessing import MinMaxScaler

import pickle
from sklearn.preprocessing import StandardScaler

# TODO try standardization and no normalization also and compare result

scaler = StandardScaler()
# scaler = MinMaxScaler(feature_range=(0, 1))
x_train = scaler.fit_transform(x_train)
x_cv = scaler.transform(x_cv)
x_test = scaler.transform(x_test)

pickle.dump((x_train, y_train),
open('../outputs/train_xy_no_sampling_stdScale.pk', 'wb'))
pickle.dump((x_cv, y_cv),
open('../outputs/val_xy_no_sampling_stdScale.pk', 'wb'))
pickle.dump((x_test, y_test),
open('../outputs/test_xy_no_sampling_stdScale.pk', 'wb'))

5. Train NN

from imblearn.over_sampling import RandomOverSampler

from imblearn.under_sampling import ClusterCentroids, TomekLinks,
RandomUnderSampler
from imblearn.over_sampling import KMeansSMOTE, SMOTE

seed_random = 9999
# max_idx = np.argmax(counts)
# max_value = counts[max_idx]
# majority_class = values[max_idx]

x = int(counts[2]*0.7)
y = int(0.7 * x)

undersample_dict = {2:y, 3:x}

under_sampler = RandomUnderSampler(sampling_strategy=undersample_dict,
random_state=seed_random)  #  n_jobs=15,
x_train, y_train = under_sampler.fit_resample(x_train,
y_train.astype(np.int))
print('Frequency of distance values after undersampling',
np.unique(y_train, return_counts=True))

minority_samples = int(0.7*x)
oversample_dict = {1:minority_samples, 4:minority_samples,
5:minority_samples, 6:minority_samples, 7:minority_samples}
over_sampler = RandomOverSampler(sampling_strategy=oversample_dict,
random_state=seed_random)  # ,n_jobs=15, k_neighbors= 5
x_train, y_train = over_sampler.fit_resample(x_train,
y_train.astype(np.int))
print('Frequency of distance values after oversampling',
np.unique(y_train, return_counts=True))

pickle.dump((x_train, y_train),
open('../outputs/train_xy_combine_sampling.pk', 'wb'))

x_train.shape, y_train.shape

6. Pytorch Model

from torchsummary import summary

import sys
import io

torch.manual_seed(9999)
def get_model():
    """
    creates a PyTorch model. Change the 'params' dict above to
    modify the neural net configuration.
    """
    model = torch.nn.Sequential(
        torch.nn.Linear(params['input_size'],
params['hidden_units_1']),
        torch.nn.BatchNorm1d(params['hidden_units_1']),
        # torch.nn.Dropout(p=params['do_1']),
        torch.nn.ReLU(),
        torch.nn.Linear(params['hidden_units_1'],
params['hidden_units_2']),
        torch.nn.BatchNorm1d(params['hidden_units_2']),
        # torch.nn.Dropout(p=params['do_2']),
        torch.nn.ReLU(),
        torch.nn.Linear(params['hidden_units_2'],
params['hidden_units_3']),
        torch.nn.BatchNorm1d(params['hidden_units_3']),
        # torch.nn.Dropout(p=params['do_3']),
        torch.nn.ReLU(),
        torch.nn.Linear(params['hidden_units_3'],
params['output_size']),
        torch.nn.ReLU(),
        # torch.nn.Softplus(),
    )
    model.to(device)
    return model

def poisson_loss(y_pred, y_true):

    """
    Custom loss function for Poisson model.
    Equivalent Keras implementation for reference:
    K.mean(y_pred - y_true * math_ops.log(y_pred + K.epsilon()), axis=-
1)
    For output of shape (2,3) it return (2,) vector. Need to calculate
    mean of that too.
    """
    y_pred = torch.squeeze(y_pred)
    loss = torch.mean(y_pred - y_true * torch.log(y_pred+1e-7))
    return loss

model = get_model()

print('model loaded into device=', next(model.parameters()).device)

# this is just to capture model summary as string

old_stdout = sys.stdout
sys.stdout = buffer = io.StringIO()

summary(model, input_size=(params['input_size'], ))

sys.stdout = old_stdout
model_summary = buffer.getvalue()
print('model-summary\n', model_summary)
# later this 'model-summary' string can be written to tensorboard

lr_reduce_patience = 20
lr_reduce_factor = 0.1

loss_fn = poisson_loss
# optimizer = torch.optim.SGD(model.parameters(), lr=params['lr'],
momentum=0.9, dampening=0, weight_decay=0, nesterov=True)
optimizer = torch.optim.RMSprop(model.parameters(), lr=params['lr'],
alpha=0.99, eps=1e-08, weight_decay=0, momentum=0, centered=False)

if params['lr_sched'] == 'reduce_lr_plateau':
    lr_sched = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
mode='min', factor=lr_reduce_factor, patience=lr_reduce_patience,
verbose=True, threshold=0.00001, threshold_mode='rel', cooldown=0,
min_lr=1e-9, eps=1e-08)
elif params['lr_sched'] == 'clr':
    lr_sched = torch.optim.lr_scheduler.CyclicLR(optimizer,
params['min_lr'], params['max_lr'], step_size_up=8*len(train_dl),
step_size_down=None, mode=params['lr_sched_mode'], last_epoch=-1,
gamma=params['gamma'])

print('lr scheduler type:', lr_sched)

for param_group in optimizer.param_groups:
    print(param_group['lr'])

6.05 penyematan NN sederhana

wfw

import torch
from torch.utils import data as torch_data

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

print("device:", device)

trainset = torch_data.TensorDataset(torch.as_tensor(x_train,
dtype=torch.float, device=device),
torch.as_tensor(y_train, dtype=torch.float, device=device))
train_dl = torch_data.DataLoader(trainset,
batch_size=params['batch_size'], drop_last=True)

val_dl =
torch_data.DataLoader(torch_data.TensorDataset(torch.as_tensor(x_cv,
dtype=torch.float, device=device),
torch.as_tensor(y_cv, dtype=torch.float, device=device)),
batch_size=params['batch_size'], drop_last=True)
test_dl =
torch_data.DataLoader(torch_data.TensorDataset(torch.as_tensor(x_test,
dtype=torch.float, device=device),
torch.as_tensor(y_test, dtype=torch.float, device=device)),
batch_size=params['batch_size'], drop_last=True)

7. train

train

for epoch in range(start_epoch, start_epoch+params['epochs']):  # loop

over the dataset multiple times
    running_loss = 0.0
    stime = time.time()
   
    for i, data in enumerate(train_dl, 0):
        iter_count += 1
        # get the inputs; data is a list of [inputs, dist_true]
        model.train()
        inputs, dist_true = data[0], data[1]
        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize

        outputs = model(inputs)
        loss = loss_fn(outputs, dist_true)
       
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        last_loss = loss.item()

        if not isinstance(lr_sched,
torch.optim.lr_scheduler.ReduceLROnPlateau):
            lr_sched.step()

    val_loss = evaluate(model, val_dl)

    if isinstance(lr_sched,
torch.optim.lr_scheduler.ReduceLROnPlateau):
        lr_sched.step(val_loss)
    if val_loss < min_val_loss:
        min_val_loss = val_loss
        patience_counter = 0
        best_model = copy.deepcopy(model)
        print(epoch,"> Best val_loss model saved:", round(val_loss, 4))
    else:
        patience_counter += 1
    train_loss = running_loss/len(train_dl)
    train_losses.append(train_loss)
    val_losses.append(val_loss)
    if patience_counter > early_stop_patience:
        print("Early stopping at epoch {}. current val_loss
{}".format(epoch, val_loss))
        break

    if epoch % 10 == 0:
        torch.save(best_model.state_dict(),
checkpoint_path+'/model_cp.pt')
        torch.save(optimizer.state_dict(),
checkpoint_path+'/optim_cp.pt')
        torch.save(lr_sched.state_dict(),
checkpoint_path+'/sched_cp.pt')
        writer.add_text('checkpoint saved', 'at epoch='+str(epoch))
        print("epoch:{} -> train_loss={},val_loss={} - {}".
              format(epoch, round(train_loss, 5), round(val_loss, 5),
seconds_to_minutes(time.time()-stime)))

print('Finished Training')