#!/usr/bin/env python

# -*- coding: utf-8 -*-

# @Time : 12/8/2018 6:54 PM

# @Author : chinshin

# @FileName: train_ddi.py

import os

import sys

import csv

import copy

import pickle

import random

import chainer

import logging

import numpy as np

from chainer.datasets import split_dataset_random

from chainer import cuda

from chainer import functions as F

from chainer import optimizers

from chainer import training

from chainer import Variable

from chainer.iterators import SerialIterator

from chainer.training import extensions as E

from chainer.training import triggers

from sklearn.preprocessing import StandardScaler

from argparse import ArgumentParser

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from os.path import dirname, abspath

ROOT_PATH = dirname(dirname(dirname(abspath(__file__))))

sys.path.insert(0, ROOT_PATH)

from utils import load_csv, index2id

from parsers import CSVFileParserForPair

from chainer_chemistry.dataset.preprocessors import preprocess_method_dict

from chainer_chemistry.dataset.parsers import CSVFileParser

from chainer_chemistry.dataset.converters import concat_mols

from chainer_chemistry.datasets import NumpyTupleDataset

from chainer_chemistry.training.extensions import ROCAUCEvaluator, PRCAUCEvaluator, PrecisionEvaluator, RecallEvaluator, F1Evaluator, AccuracyEvaluator

from chainer_chemistry.models import MLP, NFP, GGNN, SchNet, WeaveNet, RSGCN, Regressor, Classifier, Cosine

logging.basicConfig(format='%(asctime)s: %(filename)s: %(funcName)s: %(lineno)d: %(message)s', level=logging.INFO)

global_seed = 2018

random.seed(global_seed)

class GraphConvPredictorForPair(chainer.Chain):

return F.sigmoid(x)

# def set_up_predictor(method, n_unit, conv_layers, class_num):

# """Sets up the graph convolution network predictor.

#

# Args:

# method: Method name. Currently, the supported ones are `nfp`, `ggnn`,

# `schnet`, `weavenet` and `rsgcn`.

# n_unit: Number of hidden units.

# conv_layers: Number of convolutional layers for the graph convolution

# network.

# class_num: Number of output classes.

#

# Returns:

# An instance of the selected predictor.

# """

#

# mlp = MLP(out_dim=class_num, hidden_dim=n_unit)

#

# if method == 'nfp':

# print('Training an NFP predictor...')

# nfp = NFP(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers)

# predictor = GraphConvPredictorForPair(nfp, mlp)

# elif method == 'ggnn':

# print('Training a GGNN predictor...')

# ggnn = GGNN(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers)

# predictor = GraphConvPredictorForPair(ggnn, mlp)

# elif method == 'schnet':

# print('Training an SchNet predictor...')

# schnet = SchNet(out_dim=class_num, hidden_dim=n_unit,

# n_layers=conv_layers)

# predictor = GraphConvPredictorForPair(schnet, None)

# elif method == 'weavenet':

# print('Training a WeaveNet predictor...')

# n_atom = 20

# n_sub_layer = 1

# weave_channels = [50] * conv_layers

#

# weavenet = WeaveNet(weave_channels=weave_channels, hidden_dim=n_unit,

# n_sub_layer=n_sub_layer, n_atom=n_atom)

# predictor = GraphConvPredictorForPair(weavenet, mlp)

# elif method == 'rsgcn':

# print('Training an RSGCN predictor...')

# rsgcn = RSGCN(out_dim=n_unit, hidden_dim=n_unit, n_layers=conv_layers)

# predictor = GraphConvPredictorForPair(rsgcn, mlp)

# else:

# raise ValueError('[ERROR] Invalid method: {}'.format(method))

# return predictor

def set_up_predictor(method, fp_hidden_dim, fp_out_dim, conv_layers, concat_hidden, fp_dropout_rate, net_hidden_dims, class_num, sim_method='mlp'):

return predictor

def parse_arguments():

return parser.parse_args()

def main():

classifier.save_pickle(model_path, protocol=args.protocol)

if __name__ == '__main__':

logging.info(ROOT_PATH)

main()