Does it support Metal?

[mcguu]

Does it support running on ios? with Metal not OpenCL and CUDA?

I want to run it on IOS on the mac and the iphones.

if it do not support can you tell me where is its apis which I can re-write it?

[lightvector]

Only OpenCL and CUDA have implementations right now. If you'd interested in doing the work to write another backend, that would be cool. Be warned that normally this is quite a lot of work - GPU code is tricky.

Basically you have to implement this interface:
https://github.com/lightvector/KataGo/blob/master/cpp/neuralnet/nninterface.h

You can look at cudabackend.cpp and openclbackend.cpp for the existing implementations.

[mcguu]

I think it is better to get it work on ios with opencl first right?

to run it in ios I should compile it to .a or .so library.
but it is running with command not apis

so I have to change the apis that can be called with other procedure.

I can not a c++ programmer it is really difficult for me

thank you

[lightvector]

I don't understand what you mean. KataGo is an application/program/executable. It's not a library, so it doesn't make sense right now to compile to a library format.

[mcguu]

I want to run it on ios(iphone) and mac.
So I have to compile it to a library which can be called by swift on ios right? otherwise how to run is on ios system?

[lightvector]

Is ios unable to run executables? That seems weird, but if so, then I apparently don't understand much about ios. (Which, I don't, I've never written code specifically targeting ios).

I'm told that at least for desktops KataGo right now does work as an executable that can be installed via homebrew.

[mcguu]

In mac it can run executables.but In iPhone it can not .

you can only install an APP via app store which is publish to a .ipa file and upload to the AppStore.

So I have to compile it to a .a or .so library that can be called by swift language.

[alreadydone]

related: #124

[mcguu]

@lightvector I wonder if there is any chance you can give a map(structure) for the code for the calling of the backend then I will not have to read it again and again.

for example .how the procedure call the openclbackend?
which methods it will use?

[lightvector]

The backend will be used pretty much the way it's commented in nninterface.h.

globalInitialize
  loadModelFile (one or more of these)
    createComputeContext (one or more of these)
       createComputeHandle, createInputBuffers (one or more of each of these)
         get*Inplace, get*Len (will be called to get buffers and to write input data into them)
         getOutput (will be called to compute the neural net output)
       freeComputeHandle, freeInputBuffers (free everything created earlier by createComputeHandle, createInputBuffers)
    freeComputeContext (free everything created earlier by createComputeContext)
  freeLoadedModel (free everything loaded earlier by loadModelFile)
globalCleanup

Not every backend necessarily has to do anything on any of these steps - for example some backends may fail to have the notion of a "context", or they may have nothing to do on "globalInitialize", etc. This is just a framework where a backend should fill in everything it needs in order to make it possible for itself to run, sometimes the implementation may be an empty function.

[mcguu]

I think I have to give up it .

since it is too difficult for me.

and can you tell me how to use just the file you trained it?
g170-b40c256x2-s3708042240-d967973220
How to get information from the file? I have the inputs of the two players and get the rate of it?

I mean I do not want to train but just to use the file you trained.

[lightvector]

If you can't compile and run KataGo itself, that's also going to be a lot of work. That's a binary file with a large number of floating point values, specifying the parameters for a variety of convolutional layers organized in residual blocks, a few matrix multiplications, and some scalings and bias terms, along with global pooling layers. You'd basically have to write a whole implementation of the computation of the same thing that the GPU implementations right now do.

If you can run Tensorflow, you can find a Tensorflow version of the weights here: https://d3dndmfyhecmj0.cloudfront.net/g170/neuralnets/index.html - unzip the .zip file and look at the saved_model directory - that's a Tensorflow SavedModel https://www.tensorflow.org/guide/saved_model - and the model is here: https://github.com/lightvector/KataGo/blob/master/python/model.py . Note that the SavedModel will be under a Tensorflow name_scope of "swa_model" due to the way that it is saved using stochastic weight averaging.

An example of usage is here: https://github.com/lightvector/KataGo/blob/master/python/play.py that implements a very simple gtp engine that uses only raw neural net evaluations (no MCTS) along with lots of graphical visualizations. Note that I am NOT confident that this code still works, since it hasn't been maintained and kept up to date, but with minor modifications and fixes it can probably be brought up to date (and you can ignore/delete most of the code relating to graphics if you don't care about it).

There's no way around having to do quite a bit of work though. Writing a GPU implementation of a neural net, or even hooking a model up with a pre-existing GPU library, is always a lot of work. (It's a bit of a shame that apple has been wanting to break compatibility with OpenCL - it's like https://xkcd.com/927/ all over again).

[mcguu]

Thank you for your reply. I have read information about the model.py and tensor-flow.

There is a input parameters and output parameters and prediction pipeline,right?

If know these the I can write tensor flow myself.