DEV Community: Marco Steinke

Brief summary of ChatGPT

Marco Steinke — Tue, 20 Dec 2022 15:04:33 +0000

This content is part of my collection of Machine Learning resources. Check out my repository https://www.github.com/MarcoSteinke/Machine-Learning-Resources and leave a star, if you like my collection of resources on Machine Learning and Artificial Intelligence

ChatGPT:

ChatGPT is a ChatBot which is powered by artificial
intelligence and was created by OpenAI.
It is still considered as a prototype and was released in the november of 2022.

Training Methods:

RLHF (Reinforcement Learning from Human Feedback
Proximal Policy Optimization (also reinforcement learning)

I/O:

For the input and output ChatGPT uses GPT 3.5 which is another AI model. GPT is short for
Generative Pre-Trained-Transformer and GPT is an improved version of OpenAI's GPT-3.

Protection against wrong and adversial answers

Before ChatGPT was developed, OpenAI learned a lot from their research on GPT and Codex, another model of OpenAI.
Thus, ChatGPT includes various mechanism which try to protect ChatGPT against wrong and adversial answers.
Since this is a really hard job, ChatGPT already does a good job on this, but still has to get a lot of improvements.

ChatGPT will continuously be improved by human input and feedback.

Training Data:

The training data of ChatGPT consists of texts which were created by humans. This has the purpose of training ChatGPT to
communicate with its users in a natural way. Thus, it uses texts from:

forums
social Media
blogs
books
spoken language

Problems with human input:

In the early stages of the training users did prefer long answers, which resulted in CHATGPT answering with longer texts.
Algorithmic bias: The training data can cause the model to give biased answers, for example it can interpret the word "CEO" as a succesful white male person

Applications:

The model has the purpose of serving a tool for natural conversation with an AI to inform the human about expressions, definitions, concepts of various areas of the human life.
For example ChatGPT understands all common human languages and can translate between them.
It can also be used to generate text templates, which can then be improved by the human.
ChatGPT is also able to explain complex contexts in simple language and can present a brief overview of certain topics.
If you ask ChatGPT about "Scaling of Software" it will define what Scaling is and will also name different methods of scaling. The users can then answer and pick one of the named methods to step one step deeper into this topic and receive an overview of this certain subtopic.
Thus, complex information could get available for a broader audience by using ChatGPT's simpler explanations.

Another powerful ability of ChatGPT is the generation and explanation of sourcecode and configurations. Using ChatGPT developers are able to generate code for all common programming languages. This does even work for frameworks like Unity or ThreeJS. ChatGPT also explains every piece of code and provides information about the performance of the generated code and how it can bei improved.

Critique:

ChatGPT can in one answer provide a correct and high quality formulation and in the next answer it could provide something completely stupid or wrong, as described by AI expert Gary Marcus. Thus, users always have to remind that the answers of ChatGPT always require verifications, before using them in a serious situation.
Another problem has to do with scientific or very complex backgrounds. In these ChatGPT offers well-written and long answers, which are actually completely wrong in some contexts. This was tested by the physicist Teresa Kubacka by asking ChatGPT about her doctoral thesis in physics.
The german blog author Sascha Lobo is fascinated by ChatGPT, but also fears a huge wave of spam on the internet, which was generated by ChatGPT. This problem forced Reddit to ban content which was generated using ChatGPT.

Sources:

Learning from Human Preferences. OpenAI, 13. Juni 2017, abgerufen am 11. Dezember 2022 (englisch).
Paul Christiano, Jan Leike, Tom B. Brown, Miljan Martic, Shane Legg, Dario Amodei: Deep reinforcement learning from human preferences. 13. Juli 2017, doi:10.48550/arxiv.1706.03741.
Proximal Policy Optimization. OpenAI, 20. Juli 2017, abgerufen am 9. Dezember 2022 (englisch).
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, Oleg Klimov: Proximal Policy Optimization Algorithms. 28. August 2017, doi:10.48550/arxiv.1707.06347.
ChatGPT: The Ultimate Tool for Natural Language Processing and Text Generation. Abgerufen am 16. Dezember 2022 (englisch).
OpenAI: ChatGPT: Optimizing Language Models for Dialogue (englisch) 30. November 2022. Abgerufen am 5. Dezember 2022.
Murphy Kelly: This AI chatbot is dominating social media with its frighteningly good essays (englisch) In: CNN. 5. Dezember 2022. Abgerufen am 5. Dezember 2022.
Eike Kühl: ChatGPT: Gut erfunden ist halb geglaubt. In: zeit.de. 6. Dezember 2022, abgerufen am 10. Dezember 2022.
ChatGPT is a new AI chatbot that can find mistakes in your code or write a story for you. In: Business Insider. Abgerufen am 9. Dezember 2022.
Sophia Schmid: ChatGPT - Überblick zum neuen Tool von OpenAI. In: neuroflash. 5. Dezember 2022, abgerufen am 17. Dezember 2022 (deutsch).
Sophia Schmid: Wo kommt ChatGPT am besten zur Anwendung? In: neuroflash. 12. Dezember 2022, abgerufen am 17. Dezember 2022 (deutsch).
ChatGPT. In: OpenAI. OpenAI, 30. November 2022, abgerufen am 9. Dezember 2022 (englisch).
Michael Moorstedt: Künstliche Intelligenz Chat GPT beantwortet Fragen verblüffend klug. In: sueddeutsche.de. 4. Dezember 2022, abgerufen am 10. Dezember 2022.
Jakob Jung: Stack Overflow verbannt OpenAI ChatGPT. In: ZDnet.de. 7. Dezember 2022, abgerufen am 10. Dezember 2022.
Sascha Lobo: Das Ende der irrelevanten künstlichen Intelligenz. In: Der Spiegel (online). 7. Dezember 2022, abgerufen am 10. Dezember 2022.
https://twitter.com/paniterka_ch/status/1599893718214901760. Abgerufen am 17. Dezember 2022.
https://twitter.com/paniterka_ch/status/1599893839367483392. Abgerufen am 17. Dezember 2022.
Datenwissenschaftlerin aus Zürich warnt vor ChatGPT und den bösen Folgen. Abgerufen am 17. Dezember 2022 (Schweizer Hochdeutsch).
ChatGPT — Release Notes. 15. Dezember 2022, abgerufen am 18. Dezember 2022 (englisch).

Text Prediction using Bigrams and Markov Models

Marco Steinke — Fri, 26 Nov 2021 12:36:16 +0000

1. Introduction:

For the implementation of text prediction I am using the concept of Markov Models, which allows me to calculate the probabilities of consecutively events. I will first explain what a Markov Model is.

2. Hidden Markov Model:

To explain a Markov Model it is important to start by understanding what a Markov Chain is.

2.1 Markov-Chain

A Markov Chain is a stochastic model, which models a sequence of random variables. It is assumed that states in the future only depend on a limited amount of previous states (Markov Adoption)

Let q1, q2, …, qn be a series of states. With the Markov Adoption you can assume:

markovchain

So instead of spectating the probabilities of all previous states of the series, you may only spectate the previous state and end up with the same result.

3. Text prediction:

After introducing the idea of hidden Markov models and Markov chains I can now proceed and presentate the appliance of this concept.

3.1 N-grams:

Let the next sentence be the ongoing example for this section.

"On a rainy day please carry an umbrella."

Following the idea of Markov chains, you are interested in the following probabilities:

P( a | On )
P( rainy | a )
P( day | rainy )
P( please | day )
P( carry | please )
P( an | carry )
P( umbrella | an )

Therefore you will have to understand the structure of each probability:

P(day, rainy) defines the probability of the word "day" following the word "rainy" in a given input. You can use the following synonyms:

P(day,rainy) → next = day, previous = rainy.

To get this probability, you will have to count the amount of the value of previous in the given input and then count how often the value of next is following the value of previous in the given input.

The quotient of them gives you the probability as follows:

P(next, previous = (|next| / |previous|).

This will get clear using the following quote:

"To be or not to be"

What is the probability P(be, to) ?

Ignoring the casing of the words (you could format all words to lowercase beforehand) you will find "to" being 2 times in the given input and "be" being following "to" 2 times, so you get the probability P(be, to) = 2/2 = 1.

Following this scheme you can now calculate the probabilites for all pairs of words.

If you use this type of probabilities where exactly two words are required to calculate a probability, then you are using Bigrams or 2-grams.

You can generalize this idea by defining N-grams, where a N-gram is the probability which you can again find in the Markov chain:

markovchain
In the text example, you would find a probability such as:

P(be, To be or not to) = 1

where your next-value is a single word and the previous-value is a sequence of words with the length n-1.

3.2 Application of N-grams to text prediction:

Now to predict text you will need the following components:

3.2.1 Input:

You will need any sort of textarea or predefined string (for texts it may be a multiline string or a list). This input has to be processed and stored, such that any algorithm can iterate through the result and built bigrams or N-grams from it.

In this implementation I read the input from a textarea and defined an array of separators.

static SEPARATORS = ['.', ',', '!', '?', '', "\n"];
Those separators will be used to determine when a sentence or paragraph is ending and there shall not be instantiated a bigram from the input at the given location.

Example:
"One apple please. I also want a bag."

This would lead to the construction of the bigram (I, please) with P(I | please), which is not really included in the given input.

To avoid such wrong bigrams I am checking each word for not being a separator.

After checking for separators you can iterate through the text and process the input:

static formatInput(input) {
        // (1)
        Bigram.input = [];

        Bigram.input = input
            .replaceAll("^", "$")
            .replaceAll(", ", ",")
            .replaceAll(". ", ".")
            .replaceAll("! ", "!")
            .replaceAll("? ", "?")
            .replaceAll(",", "^,^")
            .replaceAll(".", "^.^")
            .replaceAll("!", "^!^")
            .replaceAll("?", "^?^")
            .replaceAll("\n ", "\n")
            .replaceAll("\n", "^\n^")
            .replaceAll(" ", "^")
            .split("^");

        // (2)
        let i = 1;
        while(i < Bigram.input.length) {
            if(Bigram.isSeparator(Bigram.input[Bigram.input.length - 1])) {
                Bigram.input.pop();
            }
            i++;
        }
    }

In the first part of the method (1) I am replacing all separators with spaces around them with the exact same separator, but without spaces. Then I replace the separator with "^^" around it, so I can later split the input and remain the separators in my processed data.

Afterwards I am checking the end of the data for a separator (2), because I do not want to have any unexpected behaviour of my algorithm when coming to the end, where a separator is the last piece of input and no other word is following it.

This would result in the following:

Input: "To be, or not to be."

Output (1):

["to", "be", ",", "or", "not", "to", "be", "."]

And after (2) has finished, it would return:

Output (2):

["to", "be", ",", "or", "not", "to", "be"]

So now I received the input as list with the remaining separators inside of the text, but not the unnecessary separator at the end of the input.

3.2.2 Successors and the input:

To construct bigrams from the input, I first wanted to count each word and store the amount in a map. The map would have looked like:

const wordCountMap = new Map();
wordCountMap.set("One", 3);

This would map each word to its amount.

But with this concept I looked into the future of the implementation and realized I throw away a very important information when only storing the amount of each word.

BECAUSE: I would still have to iterate through the processed input over and over again to check each word for its successor.
This led me to the idea of replacing my original problem by a equivalent algorithmic problem, which only requires numbers and no information about the words.

Problem of successing indices:
Given two sets of integers, find the amount of integers from the first set which are numerically successors of any integers from the second set.

Example: Given A = {4, 11, 19, 27} and B = {5, 20}

You would iterate through A and for each integer from A, you would look if there is any integer in B which is an successor of the current integer from A. If yes, increment a counter and continue with the next integer from A, if no, directly continue with the next integer from A.

In this case it would lead to a counter of 2, because B[0] = 5 = 4 + 1 = A[0] + 1 and B[1] = 20 = 19 + 1 = A[2] + 1.

If you now divide this counter by the size (cardinality) of A, you now would get the probability of B including a successor of an integer from A.

This numerical problem can now be represented by using the location (index) of words in a text (list).

3.2.3 Constructing Bigrams:

To construct bigrams you would have iterate through the list and in each iteration step look at the current value of the iterator and its successor, or to talk in code:

    static generateBigrams() {
    let existingBigramHashes = [];
    Bigram.bigrams = [];
    if(Bigram.hasWordsCounted()) {

    for(let i = 0; i < Bigram.input.length - 1; i++) {
        if(!(Bigram.SEPARATORS.includes(Bigram.input[i+1]) || Bigram.SEPARATORS.includes(Bigram.input[i]))) {
            if(!existingBigramHashes.includes(Bigram.input[i+1] + Bigram.input[i])) {
                Bigram.bigrams.push(new Bigram(Bigram.input[i+1], Bigram.input[i]));
                existingBigramHashes.push(Bigram.input[i+1] + Bigram.input[i]);
            }
        }
    }

}

This piece of code basically looks at Bigram.input[i] and Bigram.input[i+1] and constructs a bigram from it, using the following constructor:

constructor(next, previous) {
    this.next = next;
    this.previous = previous;
    // Will be explained later !
    this.findProbability();
}

It also checks for duplicate bigrams by comparing the current input[i] and input[i+1] to the ones from all previously constructed bigrams. Lastly it checks for bigrams to not include any of the separators.

Now after bigrams are constructed, there will only be the task of computing the probabilities for all bigrams.

3.2.4 Computing the probabilities (or solving the index successor problem):

At this point you already know instead of counting the amount of the previous word of a bigram and then iterate through the text and count how often the next word of a bigram is following the previous one, you can also solve the already defined index successor problem.

Now instead of counting the words I want to map each word to the indices at which the word occurs in the input:

static countWords() {
    Bigram.wordCountMap.clear();
    let i = 0;
    if(Bigram.hasInput() && Bigram.isFormatted()) {
        Bigram.input.forEach(
            (word) => {
                if(!Bigram.wordCountMap.has(word)) {
                    Bigram.wordCountMap.set(word, [i++]);
                } else {
                    let tmpArr = Bigram.wordCountMap.get(word);
                    tmpArr.push(i++);
                    Bigram.wordCountMap.set(word, tmpArr);
                }
            }
        )
    }
}

In general, this method iterates through the processed input and checks if a certain word is already stored in the map and then follows two different cases:

if the word is not in the map yet, put it in the map and store a list with the current position in the text as value.

if the word already is in the map, load the list from the map and add the current position to it.

Let the following be the input:

"One Ring to rule them all, One Ring to find them, One Ring to bring them all, and in the darkness bind them"

For the given input you would then receive the following map:

Map {'One' => Array(3), 'Ring' => Array(3), 'to' => Array(3), 'rule' => Array(1), 'them' => Array(4), …}
[[Entries]]
0: {"One" => Array(3)}
key: "One"
value: (3) [0, 7, 15]
1: {"Ring" => Array(3)}
key: "Ring"
value: (3) [1, 8, 16]
2: {"to" => Array(3)}
key: "to"
value: (3) [2, 9, 17]
3: {"rule" => Array(1)}
key: "rule"
value: [3]
4: {"them" => Array(4)}
key: "them"
value: (4) [4, 11, 19, 27]
5: {"all" => Array(2)}
key: "all"
value: (2) [5, 20]
6: {"find" => Array(1)}
key: "find"
value: [10]
8: {"bring" => Array(1)}
key: "bring"
value: [18]
9: {"and" => Array(1)}
key: "and"
value: [22]
10: {"in" => Array(1)}
key: "in"
value: [23]
11: {"the" => Array(1)}
key: "the"
value: [24]
12: {"darkness" => Array(1)}
key: "darkness"
value: [25]
13: {"bind" => Array(1)}
key: "bind"
value: [26]

And as you can see there is an array including the positions (indices) for each word of the input.

To calculate the probabilites for all bigrams, we now have to iterate through the list of all bigrams which were already constructed and run the algorithm which I have explained before on each bigram.

So for each bigram run:

 findProbability() {
    let sum = 0;
    Bigram.wordCountMap.get(this.previous).forEach(
        (index) => {
            if(Bigram.wordCountMap.get(this.next).includes(index+1)) {
                sum++;
            }
        }
    )

    this.probability = sum / Bigram.wordCountMap.get(this.previous).length;
}

This will, as already explained before, take the array of indices from the previous-value and then count in how many of the cases there is an successor in the indices array from the next-value for the current integer from the previous-value array.

The final result can be seen in the following probabilities:

P(Ring | One) = 1
P(to | Ring) = 1
P(rule | to) = 0.3333333333333333
P(them | rule) = 1
P(all | them) = 0.5
P(find | to) = 0.3333333333333333
P(them | find) = 1
P(bring | to) = 0.3333333333333333
P(them | bring) = 1
P(in | and) = 1
P(the | in) = 1
P(darkness | the) = 1
P(bind | darkness) = 1
P(them | bind) = 1'

You have now learned how to predict the probability of a word following another word by a given input.
In the next part you will see how all of this can be used to generate text by using those probabilities!

If you want to have a look at the actual implementation, feel free to look at the files included in this directory or to visit:

https://bestofcode.net/Applications/text-prediction !

Source-code can be found here: https://github.com/MarcoSteinke/Machine-Learning-Concepts/tree/main/implementation/1.%20text-prediction

Thank you :)

You are wasting resources by using classical surveillance

Marco Steinke — Wed, 24 Nov 2021 12:33:59 +0000

Greetings fellow developers on dev.to

1. Introduction

Today I am mentioning a topic why is neccessary when owning your own small business, or protecting your by using installing surveillance cameras.

The cameras which you install to protect your possession do mostly offer no more than a video source, which is persisted on any type of hard drive (in marketing they would say "secure data server") inside of your shop or home and will only be inspected if something happened.

Some more modern surveillance technologies do also offer motion detection.

Thus the motion detection may somehow be used to update the cameras orientation, as often seen in Action Movies. The camera may follow the motion by a certain degree thus the original field of view is still in sight but the motion can be captured too.

But don't you think the motion detection could be used better?

This and more will be the topic of this post and also of this series, which I create to also promote the GitHub project survAPI, which is under development to offer some more functionality to your existing surveillance and also give the ability of motion detection and a lot more to cheaper cameras, so you can configure which features your camera will be using.

2. Network cameras

There are a lot of different types of cameras.

Some examples are:

IP Security Camera
Analog MPX Security Camera
Analog MPX Wireless Security Camera
Wire-Free Security Camera Wiring
Wi-Fi Security Camera Wiring

All of them do have different architectures in capturing and persisting video material and survAPI tries to find a generalized interface to work with any type of camera as a middle-ware.

Problem:

This security software has to become a module in security networks which is located between the actual video input device and the DVR if the video input device is not wireless or NVR if the video input device is wireless.

An example would be the classical IP Security Camera:

In this system of an IP Security Camera you will find a cable which connects the NVR and the video input device by using power-over-ethernet (POE) technology to "provide both power and video transmission".

This setup leaves no space for an external software which directly controls the video input stream. This problem is architectural and has to be solved by this software to achieve the highest possible compatibility.

Solution:

1. Backwards Integration:

When using the Backwards Integration, the software should be run on a server which is directly connected to the DVR/NVR and will rewatch the video material recorded, filter unimportant video information and redirect it either to the DVR/NVR or to the server to reduce the amount of data saved.

2. Automated Video Analysis:

Using this method, the software is run on a server just as in the previous example. The software will then rewatch the video information received from the DVR/NVR and collect timestamps which flag video intervals in which target objects could be detected. You can then either keep your videos as they are or use the time stamps to remove unimportant sequences.

More solutions have to come, but at the moment there is no idea to manipulate the video input stream between the video input device and the DVR/NVR, which would be the ultimate use-case for this software, since video fragments in which nothing happened (no motion detected, also no objects) would not be persisted and the amount of produced video material would be much smaller than on usual surveillance systems.

3. Goal

And this is exactly what SurvAPI tries to achieve: Become a middle-ware which is able to directly read the input stream from a surveillance camera and only send them to the DVR/NVR if something "relevant" happens.

But what does "relevant" mean? Well, this is your decision. SurvAPI uses CocoSSD which is a Computer Vision Neural Network and trained to detection a list of different objects. SurvAPI will only step in if any of the personally chosen-objects (if configured) are detected in a certain surveillance camera. Otherwise no data will be persisted or if you still want to persist everything no timestamps will be saved to the database.

Thus you will receive a lot of control over how your surveillance does work and also a toolkit which enables to filter a lot of unneccessary data produced by the camera before or after persistence.

This will definitely reduce the cost of hard-drives since the server does persist less amount of data than on a regular setup.

SurvAPI will also enable you to use cheaper (regular) cameras, install them and since it attaches to the camera the AI tools offered by SurvAPI will then analyze the videos and you do not need to buy very expensive cameras to have those tools.

SurvAPI is also able to use the detected time stamps and video fragments for Data Analysis.

Why don't you use your surveillance to notify if a customer leaves of enters your store?

Why don't you use your surveillance to measure the distribution of customers visiting your store?

You could also use the surveillance to do long-term statistics and find out how the amount of customers develops or a long period.

Measure the effect of certain events and use the produced data for more reasons,

BUT DON'T WASTE SURVEILLANCE ONLY AS A RESOURCE OF SECURITY

ATTACH A MIDDLE-WARE AND MAKE MORE USE OF YOUR CAMERAS

4. Still work in progres

SurvAPI is still work in progress.

This post was only the first part of a longer series which will explain the development of SurvAPI step by step.

In the next part I will show the architecture and the UI of the current version of SurvAPI

There was a longer break on the project but the work will now be continued and you are free to check out the project using the following URL:

SurvAPI on GitHub

I would love to get ⭐️ on the project if you like the idea and if you are also interested in the future of this project.

I would also appreciate follows on my GitHub account MarcoSteinke on GitHub

Quick tool to check Covid-19 incidencies for German districts

Marco Steinke — Tue, 26 Oct 2021 09:45:34 +0000

Introduction

A very simple fetcher for COVID19 statistics offered by the Robert-Koch-Institut (RKI) in Germany. This tool was created, because in Germany you will have different restrictions in order to the current incidency of your district, since Germany released the "Coronanotstandverordnung", which allowed each individual state to release regional restrictions based on the local incidencies of the certain regions.

In the future the tool will be advanced by displaying the current restrictions and also proven facts and science results and also information about Covid-19 and the restrictions.

The page will also give information on why vaccination is important not only to yourself, but also to the society and also scientific information about the non-existence of long-term-consequences.

Usage:

To use this tool, you will only have to follow 2 (or if you want to share 3) steps and profit:

1️⃣ SELECT your district

2️⃣ CHECK the latest information about your surrounding

3️⃣ SHARE the information with your friends, family or coworkers

You will start at the landing page of the qovis tool. You can either choose your district or look at the Covid-19 statistics in Germany.

Germany Statistics:

In the Germany statistics you will find the current hotspots and safest districts in Germany. You will also find this information on every search page.

Autocomplete:

If you want to start searching for a district, qovis will support you with autocomplete in the search bar.

District Statistics:

After choosing your district, you will be redirected to a page where you can see a photo taken in the district you were looking for and you will also find the current incidency and amount of cases and also different statistics which are useful to find out the development of the numbers you were seeing.

Neighbouring districts:

After a district was selected you can directly go to the neighbouring districts by clicking them.

Sharing:

You can also share the current statistics page with your friends, family or coworkers by using the "Teilen" button.

Fully mobile responsive:

The website is also fully mobile responsive, so you can check current incidencies from everywhere.

If you read until this point, you are free to check out the tool. you can access it at https://qovis.steinke-it.com

I would really enjoy getting a ⭐️ on the tool's github repo if you enjoy this. You can find the repo here:

https://github.com/MarcoSteinke/qovis-RKI-statistics

If you want to know some background or technical details, feel free to comment on this post.

If you want a blog post on how I implemented this tool, please also tell me! I would love to write a post on how this tool was implemented.

MovingPoint-Lightweight-Java-2D-Game-Engine

Marco Steinke — Tue, 11 May 2021 14:02:39 +0000

Find repo here: https://github.com/MarcoSteinke/MovingPoint-Lightweight-Java-2D-Game-Engine

1 Beginner Friendly / Educational

I love programming and I also love teaching it to other persons, so the main goal of MovingPoint is to bring new motivated talents into programming. + A lot of people dream of creating their own games, MovingPoint gives them a first impression of Game Design + Even childs with basic Java skills could use this to create simple games like TicTacToe or Snake!

2 Operating System Independence

since MovingPoint is written in pure Java, you can run it on any Operating System

3 Hardware Independence

MovingPoint is lightweight, you do not need the latest hardware to build your games. + You also do not need to import all modules, only use the code which you need to build your project.

4 Use all Java libraries!

Yes it is true. You can run any libraries and connect them to MovingPoint + You are able to create Browsergames by running a Java Webapplication and importing MovingPoint. + Also usable to create Android Apps by using Android Studio!

5 Open source

Since I am coding for around 5 years and I tried out many different things, this is my first try on writing a Game Engine, so I want everybody to help me with the development. + You are able to use the Engine as you want to. Modify it, give me tips and together we can create a new experience of Game Design.

📷 survAPI Surveillance Camera Analysis

Marco Steinke — Tue, 11 May 2021 14:01:29 +0000

❓ Need surveillance, but low on server capacity?
💡 Train the camera to know when to record.

find my Repository here: https://github.com/MarcoSteinke/survAPI-Surveillance-Camera-Analysis

⚡ Introduction:

This implementation demonstrates a Security-Camera Software which was written in javascript and uses cocossd offered by ml5 to detect objects.

The application is secured using express-session and bcrypt. This way only authenticated users can access your surveillance and you are able to allow registrations and create new roles to control this system.

❓ Problem:

A business needs a security camera, but is low on server capacity. Thatswhy the business can not store videos 24/7.

💡 Solution:

Using Machine Learning, we can tell the camera when it has objects in view and use a lightweight backend to store the timestamps and also the type of objects which where detected.

Classification:

After detection, the software later classifies them as certain targets.

Persistence

If the classified object is one of the targets, it will be persisted in the database by giving information on its type and also adding a timestamp and date. Now we know when to start recording and stop after a predefined amount of time passed.

💪 Improvements over conventional Security Cameras:

installation is very easy and very customizable due to Open Source Technology
a clean webinterface makes your cameras accessible and configurable
detection of persons is a standard problem of Machine Learning and already has a very high precision
destroy video material in which nothing happens, you will only store critical/important moments

⭐ advance your security by getting additional information from your camera.

⭐ super simple setup.

⭐ modern dashboard and webpages to access the cameras.

⭐ combine any hardware with this software.

⭐ SurvAPI: The included surveillance API also offers all of the analysis tool to be called from other frameworks.

⭐ lightweight and fast.

⭐ optimized amount of video data.

⭐ Machine Learning used to detect certain targets.

⭐ predefine intervals to control data produced by the camera.

⭐ very simple database structure

⭐high security level by using bcrypt

🏛️ Architecture:
The project will be separated into the subsystems Camera, Surveillance, Database, Webviews where each subsystem exactly solves one of the given business problems.

To guarantee clean code, this project will profit from Domain Driven Design and from Self Contained System’s.

Camera:
The subsystem will fulfill the HARDWARE-part in this project. All types of cameras (which you find right below under Compatibility) will be connected via this subsystem. It defines a domain model which projects the real world properties of cameras into code and offers its configured cameras to all of the other subsystems. All of the input will run through this subsystem.

Surveillance:
The surveillance will process video material received from any video source, configured in the Camera subsystem. It makes use of ML5 and analyses the material based on the admins preferences. The analysis results will be persisted in the Database subsystem. It usually is not a separate subsystem, but for this project it will do best if the database can completely be substituted behind an interface which connects the Webviews and the Surveillance to it.

Database:
Use any type of database you want and store all of the analysis results. You can access the persisted data by using the Webviews or build your own UI to access it.

Webviews:
Basically a frontend which can be accessed from any webbrowser. You can configure the cameras, inspect detections in a nice way and get watch live material from your surveillance cameras.

AI powered surveillance

Marco Steinke — Fri, 26 Mar 2021 19:50:31 +0000

❓ Problem:
A business needs a security camera, but is low on server capacity. Thatswhy the business can not store videos 24/7.

💡 Solution:
Using Machine Learning, we can tell the camera when it has objects in view and use a lightweight backend to store the timestamps and also the type of objects which where detected.

https://github.com/MarcoSteinke/survAPI-Surveillance-Camera-Analysis

AI powered surveillance for businesses

Marco Steinke — Sun, 14 Mar 2021 16:23:14 +0000

❓ Problem:
A business needs a security camera, but is low on server capacity. Thatswhy the business can not store videos 24/7.

💡 Solution:
Using Machine Learning, we can tell the camera when it has objects in view and use a lightweight backend to store the timestamps and also the type of objects which where detected.

Find out more here: https://github.com/MarcoSteinke/survAPI-Surveillance-Camera-Analysis

AI-powered surveillance for businesses.

Marco Steinke — Tue, 09 Mar 2021 21:44:28 +0000

A business needs a security camera, but is low on server capacity. Thatswhy the business can not store videos 24/7.

💡 Solution:
Using Machine Learning, we can tell the camera when it has objects in view and use a lightweight backend to store the timestamps and also the type of objects which where detected.

URL: https://www.github.com/MarcoSteinke/Security-Cam