Hello,
Firstly let me thank you so much for helping me, I really appreciate this.
I think by the sounds of your first comment I may have gotten confused on constructing a network as well as the loss function processes, it should look something like this
`
layer_name(neurons)
in(1)(dummy) ->
hidden1(32)some_activation ->
hidden2(32)some_activation ->
out(3)no_activation
`
I then want to (rather than classification errors/MSE etc.) at each loss, send the three numerical values output in the final layer to my fitness function.
The fitness function is testnetwork(out[0], out[1], out[2]) where the three parameters are the numerical values predicted by the network. It must receive only integers so that’s why I int(round(float(out[x]))) so the numerical outputs are rounded to the nearest 1 and cast as an int.
Fitness will return a float score between 0.0 and 100.0 where 100.0 is the best score possible and 0.0 is the worst. Because of this, my loss is:
loss = 100 - testnetwork(list[0], list[1], list[2])
Since 100-testnetwork will then give a value between 0.0 and 100.0 where 0.0 is the best (so loss can now be minimised to a good outcome)
What testnetwork(x,y,z) is actually doing in the background is training a deep dense neural network of x,y, and z neurons in hidden layers 1, 2 and 3. The goal thus is to try and find the best network to classify the dataset given to this second network, ie. the PyTorch Network is learning to search for the best configuration for the second network. (I have genetic and PSO algorithms that do this but I want to compare it to a double network approach to compare the approaches, for better or worse)
My mistake I think is that I misunderstand the structure and processes of Tensors, I initially thought the loss was simply a metric I could replace with ease to an arbitrary float but unfortunately not. I’m looking for a hacky solution to be able to do this where the metric is based on the multiple outputs of the network at each step and the outputs are evaluated by an external function.
Hope you can help
Thank you very much again! 
Jordan
EDIT: Upon experimentation with one Linear layer, I tried this as my loss:
loss = torch.mean((output - output.detach())+ftn)
Now, the weights change, but they go down no matter what happens, here’s the output from the console (note, coincidentally [1,2,0] and [1,1,0] have the same fitness, numbers should be bigger really, ergo the bigger steps in the optimiser)
1. 1.4133, 1.5719, 0.2245

2. ['1.4133', ' 1.5719', ' 0.2245']

3. testing: [1, 2, 0]

4. epoch:  0  loss:  55.2411003112793

5. 1.2133, 1.3719, 0.0245

6. ['1.2133', ' 1.3719', ' 0.0245']

7. testing: [1, 1, 0]

8. epoch:  1  loss:  55.2411003112793

9. 0.8133, 0.9719, -0.3755

10. ['0.8133', ' 0.9719', ' -0.3755']

11. testing: [1, 1, 0]

12. epoch:  2  loss:  55.2411003112793

13. 0.2133, 0.3719, -0.9755

14. ['0.2133', ' 0.3719', ' -0.9755']

15. epoch:  3  loss:  100.0

16. -0.5867, -0.4281, -1.7755

17. ['-0.5867', ' -0.4281', ' -1.7755']

18. epoch:  4  loss:  100.0

19. -1.5867, -1.4281, -2.7755

20. ['-1.5867', ' -1.4281', ' -2.7755']

21. epoch:  5  loss:  100.0

22. -2.7867, -2.6281, -3.9755

23. ['-2.7867', ' -2.6281', ' -3.9755']

24. epoch:  6  loss:  100.0

25. -4.1867, -4.0281, -5.3755

26. ['-4.1867', ' -4.0281', ' -5.3755']

27. epoch:  7  loss:  100.0

28. -5.7867, -5.6281, -6.9755

29. ['-5.7867', ' -5.6281', ' -6.9755']

30. epoch:  8  loss:  100.0

31. -7.5867, -7.4281, -8.7755

32. ['-7.5867', ' -7.4281', ' -8.7755']

33. epoch:  9  loss:  100.0