Ultra-Simple Security for ML

Demoloch provides tools for securing machine learning models and the data they learn from, ranging from intuitive APIs to UIs that require minimal knowledge.

DeMoloch
DeMoloch

What is DeMoloch?

The need for security in machine learning applications is becoming readily apparent. The field of Machine learning is experiencing a similar epiphany as computer manufacturers in the early days of widespread computer viruses.

Certain data types like Medical records can go for $200-$450 a piece on the black market. Meanwhile machine learning researchers are finding out just how easily the machine learning models that companies rely on can be broken by adversarial attacks. Data Scientists are now faced with a conundrum: How to train AI algorithms on data without exposing the data to thieves, or exposing the inner workings of their AI to hackers that want to exploit them.

The solution to this is to make these safety tools easier to use. DeMoloch is a dependency-agnostic IDE/workflow-tester that allows developers to implement even experimental privacy algorithms for machine learning. Enforcing data and AI security should not require a PhD to do properly.

DeMoloch
DeMoloch
User Friendly Design

User Friendly Design

We're building an intuitive interface for people with little CLI experience (or perhaps even none at all) so they can use it on either Windows, Mac, or Linux.

Bleeding-Edge Tech

Cutting Edges Tech

Demoloch integrates the best machine learning privacy research out of organizations like Google DeepMind and Microsoft Research, and abstracts them in a way that let’s anyone, not just the original researchers, use them

Adaptable & Customizable

Adaptable & Customizable

APIs for a variety of frameworks and languages are available, but it is not it's own token. We are not doing a token sale, rather we want to create a tool that all organizations (established, startup, centralized, decentralized) handling large amount of data can use.

Mission Driven

Mission Driven

The Cambridge Analytica Scandal revealed to the world how dangerous misused data could be. We put together DeMoloch because we recognize that this isn’t even a drop in the bucket compared to the true risks of unsecured data and non-private AI.

Flexible & Multipurpose

Flexible & Multipurpose

DeMoloch can ingest many types of data schemas, both through the use of "universal schemas" (which can be easily applied to Social Media Data), as well as tools for automatically adapting to unconventional schemas (which can easily be applied to Academic Research Data)

Multiple Security Layers

Multiple Security Layers

Multiple components of the stack, from the use of Metamodels, to homomorphic encryption, to the use of federated machine learning, are designed to both protect data from abuse by 3rd parties, as well as reduce the Moral Hazard from centralization

DeMoloch

Industries and Applications

Encrypted NLP

Encrypted NLP

Simple ways to gain insights from text and speech data, without users worrying about compromised privacy

Clinical Research

Clinical Research

Opens door for learning from patient data while said data remains hidden and anonymous

Biosecurity

Biosecurity

Differential privacy for databases of gene sequences, which can be extended to flag potentially dangerous submissions to manufacturers

Academic Research

Academic Research

Connecting Scientific Researchers with experienced industry data scientists

Cooperation across organizations

Cooperation across organizations

Allows organizations to pool data and resources for new discoveries (e.g., drug discovery, aging research)

Commercial ML

Commercial ML

Companies can leverage talent without exposing sensitive IP

DeMoloch

Simple to use for both analysts and researchers...

DeMoloch

...and developers

Combine with any Machine learning framework you want, in multiple languages and the terminal. Compile models and private datasets that you can serve.

~ Source Code

import demoloch as dem
import tensorflow as tf
 
model = tf.keras.load_model('../transformer.h5')
data = dem.loader( 'hamlet_encodings.npz')
wrap = dem.KerasModelWrapper(model)
results = dem.Harden.FastGradientMethod(wrap, data)
 
print(results)

~ Source Code

import demoloch as dem
import torch.onnx
import torchvision
 
model = onnx.load("../transfromer.onnx")
data = dem.loader( 'hamlet_encodings.npz')
wrap = dem.OnnxModelWrapper(model)
results = dem.Harden.FastGradientMethod(wrap, data)
 
print(results)

~ Source Code

import {Data} from 'hamlet_encodings.npz';
import * as model from '../transformer.h5';
import * as dem from 'demoloch';
 
let data;
 
async function load() {
   data = new DataFrom();
   await data.load();
}
 
async function hardenFGSM() {
  await load();
  dem.isTraining();
  await model.train(data, dem.trainingLog);
  dem.showHardenResults(batch, predictions, labels);
}

~ Source Code

POST http://api.demoloch.com/harden?key=YOURAPIKEY&jobID=APIJOBREF
inputs: {
  modelpath: "../transformer.h5",
  attack: "FGSM_HARDEN",
  dataset: "hamlet_encodings.npz"
}

~ Source Code

$ echo $EDITOR
vim
$ demoloch --modify FGSM_HARDEN \
  --path '../transformer.h5' \
  --data 'hamlet_encodings.npz'

~ Source Code

package main
 
import (
    "fmt"
    "Strings"
    tf "github.com/tensorflow/tensorflow/tensorflow/go"
    dem "demoloch.com/demoloch/go"
)
 
func main() {
    model, err := dem.LoadTFModel("../transformer.h5", []string{"serve"}, nil)
    defer model.Session.Close()
    tensor, terr := LoadTensor("hamlet_encodings.npz", []string{"npz"}) //replace this with your own data
    if terr != nil {
        fmt.Printf("Error creating input tensor: %s\n", terr.Error())
        return
    }
    result, runErr := dem.AttackHarden(model, tensor, []string{"FGSM_HARDEN"}
    fmt.Printf("Performance of model against attack is  %v \n", result[0].Value())
}
DeMoloch

Our Advisors/Mentors

Daniel Gross

Daniel Gross

DeMoloch was an early winner of the Pioneer Tournament, an online competition with 1000s of competitors, where the top 5 received grants, compute-resources, and mentorship. Since then, Daniel Gross has provided invaluable advice on both innovation and business strategy. After co-founding Cue in 2011 and selling it to Apple in 2013, Gross led machine learning teams until joining Y Combinator as a partner in 2017. In 2019, Daniel Gross founded Pioneer, a program designed to find promising early-stage projects around the world. Daniel Gross has been on the Forbes "30 Under 30" and Business Insider's "25 under 25" lists.

Andrew Trask

Andrew Trask

Several team members were also part of the OpenMined community, an open-source library for private machine learning created by Andrew Trask. Andrew has made great strides in growing the OpenMined community (which recently celebrated it's 1000th Github star after existing for only 1 year). Part of the Purpose of DeMoloch is to provide resources to developers and researchers and mathematicians devising ways of improving and implementing such libraries (including but not limited to OpenMined), as well as taking care of tasks like helping organizations set up and connect to distributed ML model marketplaces.

Have questions or want to join the private beta?

Get in Touch