Overall Statistics Total Trades 48 Average Win 3.74% Average Loss -2.31% Compounding Annual Return 5.719% Drawdown 13.600% Expectancy 0.637 Net Profit 39.626% Sharpe Ratio 0.723 Loss Rate 38% Win Rate 62% Profit-Loss Ratio 1.62 Alpha 0.124 Beta -3.228 Annual Standard Deviation 0.082 Annual Variance 0.007 Information Ratio 0.478 Tracking Error 0.082 Treynor Ratio -0.018 Total Fees \$153.19
```import numpy as np
import torch
import torch.nn.functional as F

class PytorchNeuralNetworkAlgorithm(QCAlgorithm):

def Initialize(self):
self.SetStartDate(2013, 1, 1)  # Set Start Date
self.SetEndDate(2019, 1, 1) # Set End Date

self.SetCash(100000)  # Set Strategy Cash

self.symbols = [spy.Symbol] # using a list can extend to condition for multiple symbols

self.lookback = 30 # days of historical data (look back)

self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.AfterMarketOpen("SPY", 28), self.NetTrain) # train the NN

def NetTrain(self):
# Daily historical data is used to train the machine learning model
history = self.History(self.symbols, self.lookback + 1, Resolution.Daily)

# dicts that store prices for training
self.prices_x = {}
self.prices_y = {}

# dicts that store prices for sell and buy
self.sell_prices = {}

for symbol in self.symbols:
if not history.empty:
# x: preditors; y: response
self.prices_x[symbol] = list(history.loc[symbol.Value]['open'])[:-1]
self.prices_y[symbol] = list(history.loc[symbol.Value]['open'])[1:]

for symbol in self.symbols:
# if this symbol has historical data
if symbol in self.prices_x:

net = Net(n_feature=1, n_hidden=10, n_output=1)     # define the network
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
loss_func = torch.nn.MSELoss()  # this is for regression mean squared loss

for t in range(200):
# Get data and do preprocessing
x = torch.from_numpy(np.array(self.prices_x[symbol])).float()
y = torch.from_numpy(np.array(self.prices_y[symbol])).float()

# unsqueeze data (see pytorch doc for details)
x = x.unsqueeze(1)
y = y.unsqueeze(1)

prediction = net(x)     # input x and predict based on x

loss = loss_func(prediction, y)     # must be (1. nn output, 2. target)

self.sell_prices[symbol] = net(y)[-1] - np.std(y.data.numpy())

'''
Enter or exit positions based on relationship of the open price of the current bar and the prices defined by the machine learning model.
Liquidate if the open price is below the sell price and buy if the open price is above the buy price
'''
for holding in self.Portfolio.Values:
if self.CurrentSlice[holding.Symbol].Open < self.sell_prices[holding.Symbol] and holding.Invested:
self.Liquidate(holding.Symbol)

if self.CurrentSlice[holding.Symbol].Open > self.buy_prices[holding.Symbol] and not holding.Invested:
self.SetHoldings(holding.Symbol, 1 / len(self.symbols))

# class for Pytorch NN model
class Net(torch.nn.Module):
def __init__(self, n_feature, n_hidden, n_output):
super(Net, self).__init__()
self.hidden = torch.nn.Linear(n_feature, n_hidden)   # hidden layer
self.predict = torch.nn.Linear(n_hidden, n_output)   # output layer

def forward(self, x):
x = F.relu(self.hidden(x))      # activation function for hidden layer
x = self.predict(x)             # linear output
return x                        ```