
import project 

import numpy as np
import torch

project.notebook()


records = project.sql_query(""" 
    SELECT vector, category FROM talks
    WHERE  vector IS NOT NULL
    ORDER BY slug ASC;
""")

(x, y), (z, t)                       \
    = train_set, test_set            \
    = splits                         \
    = project.split_in_sets( records )

project.describe_sets(splits)

train_set  =>  (0, 1376) (1, 1572) (2, 1052) 
test_set   =>  (0,  243) (1,  275) (2,  192)


class Network(torch.nn.Module): 
    
    def __init__(self):
        super().__init__()
        
        self.cnv1 = torch.nn.Conv1d(  1,  5, kernel_size=3 )
        self.cnv2 = torch.nn.Conv1d(  5, 10, kernel_size=3 )
        self.cnv3 = torch.nn.Conv1d( 10, 20, kernel_size=3 )
        self.cnv4 = torch.nn.Conv1d( 20, 30, kernel_size=3 )
        self.cnv5 = torch.nn.Conv1d( 30, 40, kernel_size=3 )
        
        self.bn1  = torch.nn.BatchNorm1d(  5 )
        self.bn2  = torch.nn.BatchNorm1d( 10 )
        self.bn3  = torch.nn.BatchNorm1d( 20 )
        self.bn4  = torch.nn.BatchNorm1d( 30 )
        self.bn5  = torch.nn.BatchNorm1d( 40 )
        
        self.pool = torch.nn.MaxPool1d( kernel_size=2 )
        self.drop = torch.nn.Dropout( p=0.25 )
        
        self.fc1  = torch.nn.Linear(  480, 200 )
        self.fc2  = torch.nn.Linear(  200, 100 )
        self.fc3  = torch.nn.Linear(  100,  50 )
        self.fc4  = torch.nn.Linear(   50,  10 )
        self.fc5  = torch.nn.Linear(   10,   3 )
    
    def forward(self, x):
        
        x = x.reshape(1, 1, 300)
        
        x = self.cnv1(x)
        x = self.bn1(x)
        x = torch.nn.functional.relu( x )
        x = self.pool(x)
        
        x = self.cnv2(x)
        x = self.bn2(x)
        x = torch.nn.functional.relu( x )
        x = self.pool(x)
        
        x = self.cnv3(x)
        x = self.bn3(x)
        x = torch.nn.functional.relu( x )
        x = self.pool(x)
        
        x = self.cnv4(x)
        x = self.bn4(x)
        x = torch.nn.functional.relu( x )
        x = self.pool(x)
        
        x = self.drop(x)
        
        x = x.reshape(x.shape[0], -1)
        
        x = torch.nn.functional.relu( self.fc1(x) )
        x = torch.nn.functional.relu( self.fc2(x) )
        x = torch.nn.functional.relu( self.fc3(x) )
        x = torch.nn.functional.gelu( self.fc4(x) )
        x = self.fc5(x)
        
        return x

model = Network()
print(model)

criterion = torch.nn.CrossEntropyLoss(
    weight=project.class_weights(y, as_type='tensor')
)

optimizer = torch.optim.AdamW (
    model.parameters(),
    lr=.001, eps=1e-08, weight_decay=.02
)

performance = project.train_nn ( model, x, y, criterion,optimizer, epochs=25, li=800 )
results     = project.test_nn  ( model, z, t )

t, p, (accuracy,precision,recall), rl = results

project.plot_train(performance)

Network(
  (cnv1): Conv1d(1, 5, kernel_size=(3,), stride=(1,))
  (cnv2): Conv1d(5, 10, kernel_size=(3,), stride=(1,))
  (cnv3): Conv1d(10, 20, kernel_size=(3,), stride=(1,))
  (cnv4): Conv1d(20, 30, kernel_size=(3,), stride=(1,))
  (cnv5): Conv1d(30, 40, kernel_size=(3,), stride=(1,))
  (bn1): BatchNorm1d(5, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (bn2): BatchNorm1d(10, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (bn3): BatchNorm1d(20, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (bn4): BatchNorm1d(30, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (bn5): BatchNorm1d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (pool): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (drop): Dropout(p=0.25, inplace=False)
  (fc1): Linear(in_features=480, out_features=200, bias=True)
  (fc2): Linear(in_features=200, out_features=100, bias=True)
  (fc3): Linear(in_features=100, out_features=50, bias=True)
  (fc4): Linear(in_features=50, out_features=10, bias=True)
  (fc5): Linear(in_features=10, out_features=3, bias=True)
)
AdamW (
Parameter Group 0
    amsgrad: False
    betas: (0.9, 0.999)
    eps: 1e-08
    lr: 0.001
    weight_decay: 0.02
)
CrossEntropyLoss()

TRAINING

  0%|          | 0/4000 [00:00<?, ?it/s]

loss  800:  1.041
loss 1600:  0.946
loss 2400:  0.911
loss 3200:  0.849
loss 4000:  0.840

  0%|          | 0/4000 [00:00<?, ?it/s]

loss  800:  0.793
loss 1600:  0.759
loss 2400:  0.788
loss 3200:  0.757
loss 4000:  0.750

  0%|          | 0/4000 [00:00<?, ?it/s]

loss  800:  0.712
loss 1600:  0.698
loss 2400:  0.753
loss 3200:  0.703
loss 4000:  0.721

  0%|          | 0/4000 [00:00<?, ?it/s]

loss  800:  0.695
loss 1600:  0.664
loss 2400:  0.739
loss 3200:  0.681
loss 4000:  0.673

  0%|          | 0/4000 [00:00<?, ?it/s]

Convolutional Neural Network in PyTorch¶