Training a basic neural net on multiple GPUs. Training data taken from https://www.kaggle.com/keplersmachines/kepler-labelled-time-series-data.

Exoplanets_keras.py

import tensorflow as tf
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers



train_data = np.genfromtxt('exoTrain.csv',skip_header=1,delimiter=',')

in_data = train_data[:,1:]
out_data = np.zeros((in_data.shape[0],2))
out_data[np.arange(in_data.shape[0]),train_data[:,0].astype(np.int32)-1] = 1.

in_shape = 3197
out_shape = 2
layer_size = 8000


strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
    model = keras.Sequential([
            layers.Dense(in_shape,activation='relu'),
            layers.Dense(layer_size,activation='relu'),
            layers.Dense(layer_size,activation='relu'),
            layers.Dense(layer_size,activation='relu'),
            layers.Dense(layer_size,activation='relu'),
            layers.Dense(layer_size,activation='relu'),
            layers.Dense(layer_size,activation='relu'),
            layers.Dense(out_shape,activation='softmax')
    ])
    model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.01),
              loss=keras.losses.BinaryCrossentropy())
    
    model.fit(in_data,out_data,
          batch_size=256,
          epochs=40)

Exoplanets_pytorch.py

import torch
import torch.nn as nn
import pandas as pd


class Dataset(torch.utils.data.Dataset):
    
    def __init__(self,path):
        self.data = pd.read_csv(path)
        
    def __len__(self):
        return self.data.shape[0]
    
    def __getitem__(self,index):
        x = torch.tensor(self.data.iloc[index,1:],dtype=torch.float)
        y = torch.tensor(self.data.iloc[index,0],dtype=torch.long).to('cuda')
        return x,y
    
# Parameters
params = {'batch_size': 128,
          'shuffle': True}


train_data = Dataset('exoTrain.csv')
training_generator = torch.utils.data.DataLoader(train_data, **params)
in_shape = 3197
out_shape = 2
layer_size = 8000

model = nn.Sequential(
        nn.Linear(in_shape, layer_size),
        nn.ReLU(),
        nn.Linear(layer_size, layer_size),
        nn.ReLU(),
        nn.Linear(layer_size, layer_size),keplersmachines/kepler-labelled-time-series-data
        nn.ReLU(),
        nn.Linear(layer_size, layer_size),
        nn.ReLU(),
        nn.Linear(layer_size, layer_size),
        nn.ReLU(),
        nn.Linear(layer_size, layer_size),
        nn.ReLU(),
        nn.Linear(layer_size,out_shape),
        nn.Softmax(dim=1)
      )

model = nn.DataParallel(model)



loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())



device = torch.device('cuda')
model.to(device)



for epoch in range(40):
    for i,(x,y) in enumerate(training_generator):
        prediction = model(x)
        loss = loss_fn(prediction,y)
        if i%1 == 0:
            print(i,loss.item())

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()