Deep Learning Libraries for C++ and OpenGL

Check out OpenCV. There is http://answers.OpenCV.org​ for asking questions. perhaps I’ll see you there, my username is sjhalayka. The person that you really need to get in touch with is berak! he’s a CNN god.

The easiest way to do calculations on the GPU is to use a compute shader. That requires OpenGL 4.3, which is like a decade old… lots of new computers support 4.5 or 4.6. A somewhat simple demonstration of a computer shader can be found at https://github.com/sjhalayka/qjs_compute_shader

@taby Thanks for posting this. But my question was about Deep Learning and not about shaders. If you know anything about that please feel free to reply.

David_Barel said:

@taby Thanks for posting this. But my question was about Deep Learning and not about shaders. If you know anything about that please feel free to reply.

“Shader” is a term applied to many jobs done on the GPU. For instance a vertex shader doesn't actually shade anything, it transforms vertexes. Likewise a compute shader is used for general parallel computations on the GPU, so to the extent that these kinds of computations are advantageous in deep learning (which I know nothing about) it would be useful to use a compute shader. I think the fact that you brought up OpenGL and C++ together with Deep Learning implied to some of us that that's the direction you were going with this. Perhaps you just meant OpenGL will be used in the user interface.

Yeah, there are a lot of parallelizable functionality in a neural network… namely the getting and setting of network weights. Seriously though, go talk to berak.

come to think of it… if I implemented a standard feedforward back-propagation artificial neural network in OpenGL for you, would that be a good enough start, until you talk to berak about CNNs and stuff. It would be a noisy image classifier, so that way there’s a lot of neurons in the input and hidden layer(s), to really test how fast your GPU is.

David_Barel said:
I am looking to develop an AI entity using OpenGL and C++.

Gnollrunner said:
Perhaps you just meant OpenGL will be used in the user interface.

David_Barel said:
I was wondering if it is possible to use Python with OpenGL.

Qt is one of the simplest way to combine GUI (user interface) and OpenGL in one window. I prefer to use Qt C++ but you can use PyQt5. Just google text and video tutorials. Qt has a simple wrapper around of OpenGL to simplify of programming. It is very easy with Qt C++ to build your application on any OS like Windows, macOS, Linux, Android and iOS. For example, see how it is simple to get a shader program by five lines of code:

    m_program.create();
    m_program.addShaderFromSourceFile(QOpenGLShader::Vertex, ":/Shaders/vertexShader.glsl");
    m_program.addShaderFromSourceFile(QOpenGLShader::Fragment, ":/Shaders/fragmentShader.glsl");
    m_program.link();
    m_program.bind();

If you need a simple example I can show you. Open this project in Qt Creator IDE: SetRectangleColorWithMouse_OpenGL33Qt5Cpp.zip (95 KB). It sets colors of rectangle by mouse pressing. I wrote it special for you from scratch for practice. Make more practice to study something.

Scene.h

#ifndef SCENE_H
#define SCENE_H

#include <QOpenGLWidget>
#include <QOpenGLShaderProgram>
#include <QOpenGLBuffer>

class Scene : public QOpenGLWidget
{
    Q_OBJECT
public:
    explicit Scene(QWidget *parent = nullptr);

public slots:
    void setRedColor();
    void setGreenColor();
    void setBlueColor();

private:
    QOpenGLShaderProgram m_program;
    QOpenGLBuffer m_vertPosBuffer;
    int m_uColorLocation;

    void initializeGL() override;
    void paintGL() override;
    void resizeGL(int w, int h) override;
};

#endif // SCENE_H

Scene.cpp

#include "Scene.h"

Scene::Scene(QWidget *parent) : QOpenGLWidget(parent)
{

}

void Scene::initializeGL()
{
    glClearColor(0.1f, 0.1f, 0.1f, 1.f);

    m_program.create();
    m_program.addShaderFromSourceFile(QOpenGLShader::Vertex, ":/Shaders/vertexShader.glsl");
    m_program.addShaderFromSourceFile(QOpenGLShader::Fragment, ":/Shaders/fragmentShader.glsl");
    m_program.link();
    m_program.bind();

    float vertPositions[] = {
        -0.75, -0.5f, 0.f,
        0.75, -0.5f, 0.f,
        -0.75, 0.5f, 0.f,
        0.75f, 0.5f, 0.f
    };
    m_vertPosBuffer.create();
    m_vertPosBuffer.bind();
    m_vertPosBuffer.allocate(vertPositions, sizeof(vertPositions));
    m_program.setAttributeBuffer(0, GL_FLOAT, 0, 3);
    m_program.enableAttributeArray(0);

    m_program.bind();
    m_uColorLocation = m_program.uniformLocation("uColor");
    m_program.setUniformValue(m_uColorLocation, QVector4D(1, 0, 0, 1));
}

void Scene::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

void Scene::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}

void Scene::setRedColor()
{
    m_program.bind();
    m_program.setUniformValue(m_uColorLocation, QVector4D(1, 0, 0, 1));
    update();
}

void Scene::setGreenColor()
{
    m_program.bind();
    m_program.setUniformValue(m_uColorLocation, QVector4D(0, 1, 0, 1));
    update();
}

void Scene::setBlueColor()
{
    m_program.bind();
    m_program.setUniformValue(m_uColorLocation, QVector4D(0, 0, 1, 1));
    update();
}

Widget.cpp

#include "Widget.h"
#include "ui_Widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
//    ui->sceneWidget->setSizePolicy(QSizePolicy::Policy::Preferred, QSizePolicy::Maximum);

    connect(ui->btnSetRed, &QPushButton::clicked, ui->sceneWidget, &Scene::setRedColor);
    connect(ui->btnSetGreen, &QPushButton::clicked, ui->sceneWidget, &Scene::setGreenColor);
    connect(ui->btnSetBlue, &QPushButton::clicked, ui->sceneWidget, &Scene::setBlueColor);
}

Widget::~Widget()
{
    delete ui;
}

vertexShader.glsl

#version 330 core

layout(location = 0) in vec3 aPosition;

void main()
{
    gl_Position = vec4(aPosition, 1.0);
}

fragmentShader.glsl

#version 330 core

uniform vec4 uColor;
out vec4 fragColor;

void main()
{
    fragColor = uColor;
}