GGRNet/model.jl at master · paperai/GGRNet · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
using Random

mutable struct Model
    config
    transformer
    nn
end

function Model(config::Dict)
    # filename = config["train_file"]
    # data = readdata(filename[1:end-4] * ".sdf")
    filename = ".data/gdb9.sdf"
    data = readdata(filename)
    n = length(data)
    r = randperm(n)
    # m = trunc(Int, n*0.1)
    m = 10000
    devdata = data[r[1:m]]
    testdata = data[r[m+1:2m]]
    traindata = data[r[2m+1:7m]]
    # traindata = data[r[2m+1:end]]

    train_y = map(x -> x.y, traindata)
    transformer = Standardizer(train_y)
    trans_y = transformer(map(x -> x.y, data))
    for i = 1:length(data)
        data[i].y = trans_y[i]
    end

    nn = NN()
    @info "# Train:\t$(length(traindata))"
    @info "# Dev:\t$(length(devdata))"
    @info "# Test:\t$(length(testdata))"
    m = Model(config, transformer, nn)
    train!(m, traindata, devdata, testdata)
    m
end

function train!(model::Model, traindata, devdata, testdata)
    config = model.config
    opt = SGD(clip=10.0)
    # lr = config["learning_rate"]
    lr = 0.01
    nn = todevice(model.nn)
    batchsize = config["batchsize"]
    # batchsize = 20
    mindev, mintest = typemax(Float64), typemax(Float64)

    nepochs = config["nepochs"]
    for epoch = 1:100
        println("Epoch:\t$epoch")
        opt.rate = lr / (1 + 0.01*(epoch-1))

        loss = minimize!(nn, traindata, opt, batchsize=batchsize, shuffle=true)
        loss /= length(traindata)
        println("Loss:\t$loss")

        println("-----Test data-----")
        res = evaluate(nn, testdata, batchsize=50)
        testscore = mae(res, model.transformer)
        # writefile("pred.txt", res, model.transformer)
        println("-----Dev data-----")
        res = evaluate(nn, devdata, batchsize=50)
        devscore = mae(res, model.transformer)
        if devscore <= mindev
            mindev = devscore
            mintest = testscore
        end
        println("-----Final test-----")
        println("Dev: $mindev")
        println("Test: $mintest")
        println()
    end
end

function mae(data::Vector, trans)
    data1 = collect(Iterators.flatten(map(x -> vec(x[1]), data)))
    data1 = reshape(data1, 1, length(data1))
    data1 = inverse(trans, data1)
    data2 = collect(Iterators.flatten(map(x -> vec(x[2]), data)))
    data2 = reshape(data2, 1, length(data2))
    data2 = inverse(trans, data2)
    data = abs.(data1 - data2)
    score = sum(data) / length(data)
    println("MAE:\t$score")
    score
end

function writefile(filename::String, data::Vector, trans)
    data1 = collect(Iterators.flatten(map(x -> vec(x[1]), data)))
    data1 = inverse(trans, data1)
    data2 = collect(Iterators.flatten(map(x -> vec(x[2]), data)))
    data2 = inverse(trans, data2)
    open(filename,"w") do io
        for (y,z) in zip(data1,data2)
            println(io, "$y\t$z")
        end
    end
end