65 | Syft.js MNIST Example
66 |67 | This is a demo using 69 | syft.js from OpenMined 72 | to train MNIST model hosted on the PyGrid using local data and Federated 73 | Learning approach. The data never leaves the browser. Please open your 74 | Javascript console to see what's going on (instructions for 75 | Chrome 80 | and 81 | Firefox). 87 |
88 | 89 | 123 | 124 | 137 | 138 | 139 | -------------------------------------------------------------------------------- /src/types/computation-action.js: -------------------------------------------------------------------------------- 1 | import { unbufferize } from '../protobuf'; 2 | import PointerTensor from './pointer-tensor'; 3 | import { Placeholder, PlaceholderId } from './placeholder'; 4 | import * as tf from '@tensorflow/tfjs-core'; 5 | import { TorchParameter, TorchTensor } from './torch'; 6 | import { CANNOT_FIND_COMMAND, MISSING_VARIABLE } from '../_errors'; 7 | 8 | export class ComputationAction { 9 | constructor(command, target, args, kwargs, returnIds, returnPlaceholderIds) { 10 | this.command = command; 11 | this.target = target; 12 | this.args = args; 13 | this.kwargs = kwargs; 14 | this.returnIds = returnIds; 15 | this.returnPlaceholderIds = returnPlaceholderIds; 16 | } 17 | 18 | static unbufferize(worker, pb) { 19 | return new ComputationAction( 20 | pb.command, 21 | unbufferize(worker, pb[pb.target]), 22 | unbufferize(worker, pb.args), 23 | unbufferize(worker, pb.kwargs), 24 | unbufferize(worker, pb.return_ids), 25 | unbufferize(worker, pb.return_placeholder_ids) 26 | ); 27 | } 28 | 29 | async execute(scope) { 30 | // A helper function for helping us determine if all PointerTensors/Placeholders inside of "this.args" also exist as tensors inside of "objects" 31 | const haveValuesForAllArgs = args => { 32 | let enoughInfo = true; 33 | 34 | args.forEach(arg => { 35 | if ( 36 | (arg instanceof PointerTensor && !scope.has(arg.idAtLocation)) || 37 | (arg instanceof Placeholder && !scope.has(arg.id)) || 38 | (arg instanceof PlaceholderId && !scope.has(arg.id)) 39 | ) { 40 | enoughInfo = false; 41 | } 42 | }); 43 | 44 | return enoughInfo; 45 | }; 46 | 47 | const toTFTensor = tensor => { 48 | if (tensor instanceof tf.Tensor) { 49 | return tensor; 50 | } else if (tensor instanceof TorchTensor) { 51 | return tensor.toTfTensor(); 52 | } else if (tensor instanceof TorchParameter) { 53 | return tensor.tensor.toTfTensor(); 54 | } else if (typeof tensor === 'number') { 55 | return tensor; 56 | } 57 | return null; 58 | }; 59 | 60 | const getTensorByRef = reference => { 61 | let tensor = null; 62 | if (reference instanceof PlaceholderId) { 63 | tensor = scope.get(reference.id); 64 | } else if (reference instanceof Placeholder) { 65 | tensor = scope.get(reference.id); 66 | } else if (reference instanceof PointerTensor) { 67 | tensor = scope.get(reference.idAtLocation); 68 | } 69 | tensor = toTFTensor(tensor); 70 | return tensor; 71 | }; 72 | 73 | // A helper function for helping us get all operable tensors from PointerTensors inside of "this._args" 74 | const pullTensorsFromArgs = args => { 75 | const resolvedArgs = []; 76 | 77 | args.forEach(arg => { 78 | const tensorByRef = getTensorByRef(arg); 79 | if (tensorByRef) { 80 | resolvedArgs.push(toTFTensor(tensorByRef)); 81 | } else { 82 | // Try to convert to tensor. 83 | const tensor = toTFTensor(arg); 84 | if (tensor !== null) { 85 | resolvedArgs.push(toTFTensor(arg)); 86 | } else { 87 | // Keep as is. 88 | resolvedArgs.push(arg); 89 | } 90 | } 91 | }); 92 | 93 | return resolvedArgs; 94 | }; 95 | 96 | //worker.logger.log(`Given command: ${this.command}, converted command: ${command} + ${JSON.stringify(preArgs)} + ${JSON.stringify(postArgs)}`); 97 | 98 | const args = this.args; 99 | let self = null; 100 | 101 | if (this.target) { 102 | // resolve "self" if it's present 103 | self = getTensorByRef(this.target); 104 | if (!self) { 105 | throw new Error(MISSING_VARIABLE()); 106 | } 107 | } 108 | 109 | if (!haveValuesForAllArgs(args)) { 110 | throw new Error(MISSING_VARIABLE()); 111 | } 112 | 113 | const resolvedArgs = pullTensorsFromArgs(args); 114 | const functionName = this.command.split('.').pop(); 115 | 116 | if (self) { 117 | if (!(functionName in self)) { 118 | throw new Error(CANNOT_FIND_COMMAND(`tensor.${functionName}`)); 119 | } else { 120 | return self[functionName](...resolvedArgs); 121 | } 122 | } 123 | 124 | if (!(functionName in tf)) { 125 | throw new Error(CANNOT_FIND_COMMAND(functionName)); 126 | } else { 127 | return tf[functionName](...resolvedArgs, ...Object.values(this.kwargs)); 128 | } 129 | } 130 | } 131 | -------------------------------------------------------------------------------- /src/syft-webrtc.js: -------------------------------------------------------------------------------- 1 | /** 2 | * NOTE: This is temporary file to hold WebRTC code that needs to be refactored 3 | * during implementation of Protocols functionality in syft.js. 4 | * Do not use this file as it will be removed in the future. 5 | */ 6 | /* istanbul ignore file */ 7 | import { 8 | GET_PROTOCOL, 9 | SOCKET_STATUS, 10 | WEBRTC_INTERNAL_MESSAGE, 11 | WEBRTC_JOIN_ROOM, 12 | WEBRTC_PEER_CONFIG, 13 | WEBRTC_PEER_LEFT, 14 | WEBRTC_PEER_OPTIONS 15 | } from './_constants'; 16 | import { protobuf, unserialize } from './protobuf'; 17 | import Socket from './sockets'; 18 | import WebRTCClient from './webrtc'; 19 | 20 | export class SyftWebrtc { 21 | /* ----- SOCKET COMMUNICATION ----- */ 22 | // TODO refactor into grid client class 23 | 24 | // To create a socket connection internally and externally 25 | createSocketConnection(url) { 26 | if (!url) return; 27 | if (!this.verbose) { 28 | url = url.replace('ws://', 'wss://'); 29 | } 30 | // When a socket connection is opened... 31 | const onOpen = event => { 32 | this.observer.broadcast(SOCKET_STATUS, { 33 | connected: true, 34 | event 35 | }); 36 | }; 37 | 38 | // When a socket connection is closed... 39 | const onClose = event => { 40 | this.observer.broadcast(SOCKET_STATUS, { 41 | connected: false, 42 | event 43 | }); 44 | }; 45 | 46 | // When a socket message is received... 47 | const onMessage = event => { 48 | const { type, data } = event; 49 | 50 | if (type === GET_PROTOCOL) { 51 | if (data.error) { 52 | this.logger.log( 53 | 'There was an error getting the protocol you requested', 54 | data.error 55 | ); 56 | 57 | return data; 58 | } 59 | 60 | // Save our workerId if we don't already have it (also for the socket connection) 61 | this.workerId = data.worker.workerId; 62 | this.socket.workerId = this.workerId; 63 | 64 | // Save our scopeId if we don't already have it 65 | this.scopeId = data.worker.scopeId; 66 | 67 | // Save our role 68 | this.role = data.worker.role; 69 | 70 | // Save the other participant workerId's 71 | this.participants = data.participants; 72 | 73 | // Save the protocol and plan assignment after having Serde detail them 74 | let detailedProtocol; 75 | let detailedPlan; 76 | detailedProtocol = unserialize( 77 | null, 78 | data.protocol, 79 | protobuf.syft_proto.execution.v1.Protocol 80 | ); 81 | detailedPlan = unserialize( 82 | null, 83 | data.plan, 84 | protobuf.syft_proto.execution.v1.Plan 85 | ); 86 | 87 | this.protocol = detailedProtocol; 88 | this.plan = detailedPlan; 89 | 90 | return this.plan; 91 | } else if (type === WEBRTC_INTERNAL_MESSAGE) { 92 | this.rtc.receiveInternalMessage(data); 93 | } else if (type === WEBRTC_JOIN_ROOM) { 94 | this.rtc.receiveNewPeer(data); 95 | } else if (type === WEBRTC_PEER_LEFT) { 96 | this.rtc.removePeer(data.workerId); 97 | } 98 | }; 99 | 100 | this.socket = new Socket({ 101 | url, 102 | workerId: this.workerId, 103 | onOpen, 104 | onClose, 105 | onMessage 106 | }); 107 | } 108 | 109 | // To close the socket connection with the grid 110 | disconnectFromGrid() { 111 | this.socket.stop(); 112 | } 113 | 114 | /* ----- WEBRTC ----- */ 115 | 116 | // To create a socket connection internally and externally 117 | createWebRTCClient(peerConfig, peerOptions) { 118 | // If we don't have a socket sever, we can't create the WebRTCClient 119 | if (!this.socket) return; 120 | 121 | // The default STUN/TURN servers to use for NAT traversal 122 | if (!peerConfig) peerConfig = WEBRTC_PEER_CONFIG; 123 | 124 | // Some standard options for establishing peer connections 125 | if (!peerOptions) peerOptions = WEBRTC_PEER_OPTIONS; 126 | 127 | this.rtc = new WebRTCClient({ 128 | peerConfig, 129 | peerOptions, 130 | socket: this.socket 131 | }); 132 | 133 | const onDataMessage = data => { 134 | this.logger.log(`Data message is received from ${data.worker_id}`, data); 135 | }; 136 | this.rtc.on('message', onDataMessage); 137 | } 138 | 139 | connectToParticipants() { 140 | this.rtc.start(this.workerId, this.scopeId); 141 | } 142 | 143 | disconnectFromParticipants() { 144 | this.rtc.stop(); 145 | } 146 | 147 | sendToParticipants(data, to) { 148 | this.rtc.sendMessage(data, to); 149 | } 150 | } 151 | -------------------------------------------------------------------------------- /src/data-channel-message.js: -------------------------------------------------------------------------------- 1 | import EventObserver from './events'; 2 | import { WEBRTC_DATACHANNEL_CHUNK_SIZE } from './_constants'; 3 | 4 | export default class DataChannelMessage { 5 | static chunkHeaderSign = 0xff00; 6 | static chunkHeaderLength = 10; 7 | 8 | constructor({ data, id, worker_id }) { 9 | if (data === undefined) { 10 | this.data = new ArrayBuffer(0); 11 | } else if (typeof data === 'string') { 12 | this.data = new TextEncoder().encode(data).buffer; 13 | } else if (data instanceof ArrayBuffer) { 14 | this.data = data; 15 | } else { 16 | throw new Error('Message type is not supported'); 17 | } 18 | 19 | this.worker_id = worker_id; 20 | this.size = this.data.byteLength; 21 | this.dataChunks = []; 22 | this.id = id || Math.floor(Math.random() * 0xffffffff); 23 | this.observer = new EventObserver(); 24 | this.chunks = Math.ceil( 25 | this.size / 26 | (WEBRTC_DATACHANNEL_CHUNK_SIZE - DataChannelMessage.chunkHeaderLength) 27 | ); 28 | this.makeChunkHeader(0); 29 | } 30 | 31 | /** 32 | * Creates chunk header for given chunk index 33 | * @param {number} chunk Chunk index 34 | * @returns {ArrayBuffer} 35 | */ 36 | makeChunkHeader(chunk) { 37 | if (this.chunkHeader === undefined) { 38 | this.chunkHeader = new ArrayBuffer(DataChannelMessage.chunkHeaderLength); 39 | 40 | const view = new DataView(this.chunkHeader); 41 | 42 | view.setUint16(0, DataChannelMessage.chunkHeaderSign); 43 | view.setUint32(2, this.id); 44 | view.setUint16(6, this.chunks); 45 | view.setUint16(8, chunk); 46 | } else { 47 | const view = new DataView(this.chunkHeader); 48 | 49 | view.setUint16(8, chunk); 50 | } 51 | 52 | return this.chunkHeader; 53 | } 54 | 55 | once(event, func) { 56 | this.observer.subscribe(event, data => { 57 | this.observer.unsubscribe(event); 58 | 59 | func(data); 60 | }); 61 | } 62 | 63 | /** 64 | * Gets chunk info from header 65 | * @param {ArrayBuffer} buf 66 | */ 67 | static messageInfoFromBuf(buf) { 68 | let view; 69 | 70 | try { 71 | view = new DataView(buf); 72 | if (view.getUint16(0) !== DataChannelMessage.chunkHeaderSign) { 73 | return false; 74 | } 75 | } catch (e) { 76 | return false; 77 | } 78 | 79 | return { 80 | id: view.getUint32(2), 81 | chunks: view.getUint16(6), 82 | chunk: view.getUint16(8) 83 | }; 84 | } 85 | 86 | /** 87 | * Adds chunk for further assembly 88 | * @param {ArrayBuffer} buf 89 | */ 90 | addChunk(buf) { 91 | const info = DataChannelMessage.messageInfoFromBuf(buf); 92 | 93 | if (info === false) { 94 | throw new Error(`Is not a valid chunk`); 95 | } 96 | 97 | if (this.id !== info.id) { 98 | throw new Error( 99 | `Trying to add chunk from different message: ${this.id} != ${info.id}` 100 | ); 101 | } 102 | 103 | if (this.dataChunks[info.chunk] !== undefined) { 104 | throw new Error(`Duplicated chunk ${info.chunks} in message ${this.id}`); 105 | } 106 | 107 | this.dataChunks[info.chunk] = buf.slice( 108 | DataChannelMessage.chunkHeaderLength 109 | ); 110 | 111 | if (this.dataChunks.length === info.chunks) { 112 | this.assemble(); 113 | } 114 | } 115 | 116 | /** 117 | * Concatenate data pieces 118 | */ 119 | assemble() { 120 | let size = 0; 121 | 122 | for (let chunk of this.dataChunks) { 123 | size += chunk.byteLength; 124 | } 125 | 126 | const data = new Uint8Array(size); 127 | let offset = 0; 128 | 129 | for (let chunk of this.dataChunks) { 130 | data.set(new Uint8Array(chunk), offset); 131 | offset += chunk.byteLength; 132 | } 133 | 134 | this.chunks = this.dataChunks.length; 135 | this.size = size; 136 | this.data = data.buffer; 137 | 138 | // Clean up 139 | this.dataChunks = []; 140 | 141 | // Emit event when done 142 | this.observer.broadcast('ready', this); 143 | } 144 | 145 | /** 146 | * Slice a piece of message and add a header 147 | * @param {number} num 148 | * @returns {ArrayBuffer} 149 | */ 150 | getChunk(num) { 151 | const start = 152 | num * 153 | (WEBRTC_DATACHANNEL_CHUNK_SIZE - DataChannelMessage.chunkHeaderLength); 154 | const end = Math.min( 155 | start + 156 | WEBRTC_DATACHANNEL_CHUNK_SIZE - 157 | DataChannelMessage.chunkHeaderLength, 158 | this.size 159 | ); 160 | const chunk = new Uint8Array( 161 | DataChannelMessage.chunkHeaderLength + end - start 162 | ); 163 | const header = this.makeChunkHeader(num); 164 | 165 | chunk.set(new Uint8Array(header), 0); 166 | chunk.set( 167 | new Uint8Array(this.data.slice(start, end)), 168 | DataChannelMessage.chunkHeaderLength 169 | ); 170 | 171 | return chunk.buffer; 172 | } 173 | } 174 | -------------------------------------------------------------------------------- /test/sockets.test.js: -------------------------------------------------------------------------------- 1 | import { SOCKET_PING } from '../src/_constants'; 2 | import { WebSocket, Server } from 'mock-socket'; 3 | 4 | import Socket from '../src/sockets'; 5 | 6 | global.WebSocket = WebSocket; 7 | 8 | const url = 'ws://localhost:8080/'; 9 | 10 | // Create a promise that is resolved when the event is triggered. 11 | const makeEventPromise = (emitter, event) => { 12 | let resolver; 13 | 14 | const promise = new Promise(resolve => (resolver = resolve)); 15 | emitter.on(event, data => resolver(data)); 16 | 17 | return promise; 18 | }; 19 | 20 | describe('Sockets', () => { 21 | let mockServer; 22 | 23 | beforeEach(() => { 24 | mockServer = new Server(url); 25 | mockServer.connected = makeEventPromise(mockServer, 'connection'); 26 | }); 27 | 28 | afterEach(() => { 29 | mockServer.close(); 30 | }); 31 | 32 | test('sends keep-alive messages automatically', async () => { 33 | const keepAliveTimeout = 300, 34 | expectedMessagesCount = 3, 35 | messages = [], 36 | expectedTypes = []; 37 | 38 | // Creating a socket will open connection and start keep-alive pings. 39 | new Socket({ url, keepAliveTimeout }); 40 | 41 | const serverSocket = await mockServer.connected; 42 | 43 | serverSocket.on('message', message => messages.push(JSON.parse(message))); 44 | 45 | await new Promise(done => 46 | setTimeout( 47 | done, 48 | keepAliveTimeout * expectedMessagesCount + keepAliveTimeout / 2 49 | ) 50 | ); 51 | 52 | // One keep-alive message is sent right after connection, hence +1. 53 | expect(messages).toHaveLength(expectedMessagesCount + 1); 54 | 55 | for (let i = 0; i < expectedMessagesCount + 1; i++) { 56 | expectedTypes.push(SOCKET_PING); 57 | } 58 | 59 | expect(messages.map(message => message['type'])).toEqual(expectedTypes); 60 | }); 61 | 62 | test('triggers onOpen event', async () => { 63 | const onOpen = jest.fn(); 64 | 65 | new Socket({ url, onOpen }); 66 | 67 | await mockServer.connected; 68 | 69 | expect(onOpen).toHaveBeenCalledTimes(1); 70 | }); 71 | 72 | test('triggers onClose event', async () => { 73 | const closed = makeEventPromise(mockServer, 'close'), 74 | onClose = jest.fn(), 75 | mySocket = new Socket({ 76 | url, 77 | onClose 78 | }); 79 | 80 | await mockServer.connected; 81 | 82 | mySocket.stop(); 83 | 84 | await closed; 85 | 86 | expect(onClose).toHaveBeenCalledTimes(1); 87 | expect(mySocket.timerId).toBeNull(); 88 | }); 89 | 90 | test('sends data correctly', async () => { 91 | const testReqType = 'test', 92 | testReqData = { blob: 1 }, 93 | testResponse = { response: 'test' }, 94 | testworkerId = 'test-worker', 95 | mySocket = new Socket({ 96 | workerId: testworkerId, 97 | url, 98 | onMessage: data => data 99 | }); 100 | 101 | const serverSocket = await mockServer.connected; 102 | 103 | // Skip first keep-alive message. 104 | await makeEventPromise(serverSocket, 'message'); 105 | 106 | const responsePromise = mySocket.send(testReqType, testReqData); 107 | const message = await makeEventPromise(serverSocket, 'message'); 108 | 109 | serverSocket.send(JSON.stringify(testResponse)); 110 | 111 | const response = await responsePromise; 112 | 113 | expect(JSON.parse(message)).toEqual({ 114 | type: testReqType, 115 | data: testReqData 116 | }); 117 | expect(response).toEqual(testResponse); 118 | }); 119 | 120 | test('returns error when .send() fails', async () => { 121 | const mySocket = new Socket({ 122 | url, 123 | onMessage: data => data 124 | }); 125 | 126 | const serverSocket = await mockServer.connected; 127 | 128 | // Skip first keep-alive message. 129 | await makeEventPromise(serverSocket, 'message'); 130 | 131 | const responsePromise = mySocket.send('test', {}); 132 | 133 | mockServer.simulate('error'); 134 | 135 | expect.assertions(1); 136 | 137 | try { 138 | await responsePromise; 139 | } catch (e) { 140 | expect(e).toBeDefined(); 141 | } 142 | }); 143 | 144 | test('disconnects from server after .stop()', async () => { 145 | const mySocket = new Socket({ 146 | url 147 | }); 148 | 149 | await mockServer.connected; 150 | 151 | expect(mockServer.clients()).toHaveLength(1); 152 | 153 | mySocket.stop(); 154 | 155 | await new Promise(done => setTimeout(done, 100)); 156 | 157 | expect(mockServer.clients()).toHaveLength(0); 158 | }); 159 | 160 | test('triggers onMessage event', async () => { 161 | const testResponse = { response: 'test' }, 162 | testworkerId = 'test-worker', 163 | onMessage = jest.fn(message => message), 164 | mySocket = new Socket({ 165 | workerId: testworkerId, 166 | url, 167 | onMessage: onMessage 168 | }); 169 | 170 | const serverSocket = await mockServer.connected; 171 | 172 | // Skip first keep-alive message. 173 | await makeEventPromise(serverSocket, 'message'); 174 | 175 | serverSocket.on('message', () => { 176 | serverSocket.send(JSON.stringify(testResponse)); 177 | }); 178 | 179 | await mySocket.send('test1', {}); 180 | await mySocket.send('test2', {}); 181 | 182 | expect(onMessage).toHaveBeenCalledTimes(2); 183 | expect(onMessage).toHaveBeenLastCalledWith(testResponse); 184 | }); 185 | }); 186 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ### Changelog 2 | 3 | All notable changes to this project will be documented in this file. Dates are displayed in UTC. 4 | 5 | Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog). 6 | 7 | #### [v1.5.0](https://github.com/OpenMined/syft.js/compare/v1.4.4...v1.5.0) 8 | 9 | > 25 July 2019 10 | 11 | - Major refactor to build and testing systems [`#42`](https://github.com/OpenMined/syft.js/pull/42) 12 | - Upgrading the project to a modern development workflow [`b584677`](https://github.com/OpenMined/syft.js/commit/b584677fe1530e8114463f577dc4e5e0e51432f5) 13 | - Upgrading tensorflow [`977ef41`](https://github.com/OpenMined/syft.js/commit/977ef41c929d1bbb9dab5f956c497d128b7d0ff7) 14 | - Generating autochangelog [`ffed4a2`](https://github.com/OpenMined/syft.js/commit/ffed4a2dcc1647d37ef2f3acc9734592db835b09) 15 | 16 | #### [v1.4.4](https://github.com/OpenMined/syft.js/compare/v1.4.3...v1.4.4) 17 | 18 | > 17 October 2018 19 | 20 | - Adding a result_id to operations [`a38af02`](https://github.com/OpenMined/syft.js/commit/a38af02a9b3897ef2172296a1755bf1e2a2626e0) 21 | 22 | #### [v1.4.3](https://github.com/OpenMined/syft.js/compare/v1.4.2...v1.4.3) 23 | 24 | > 14 October 2018 25 | 26 | - GitBook: [1.4.2] 5 pages modified [`#41`](https://github.com/OpenMined/syft.js/pull/41) 27 | - GitBook: [master] 4 pages modified [`522e928`](https://github.com/OpenMined/syft.js/commit/522e9282d8df5f65aaee7dc4dafe3d28c15f10fd) 28 | - Delete api-documentation.md [`625a623`](https://github.com/OpenMined/syft.js/commit/625a6232edcc81cd5acbc1e4cce3f569fcff3152) 29 | - Delete guide.md [`5982dbd`](https://github.com/OpenMined/syft.js/commit/5982dbde60aebe2afac6b263cfdfea1973bde4e5) 30 | 31 | #### v1.4.2 32 | 33 | > 14 October 2018 34 | 35 | - Tensor removal issue [`#40`](https://github.com/OpenMined/syft.js/pull/40) 36 | - TensorFlow bundling [`#38`](https://github.com/OpenMined/syft.js/pull/38) 37 | - Improve build system [`#35`](https://github.com/OpenMined/syft.js/pull/35) 38 | - Add tensorflow [`#31`](https://github.com/OpenMined/syft.js/pull/31) 39 | - Add tensorflow [`#29`](https://github.com/OpenMined/syft.js/pull/29) 40 | - added preliminary websocket support [`#22`](https://github.com/OpenMined/syft.js/pull/22) 41 | - Travis Support for Unit Tests [`#24`](https://github.com/OpenMined/syft.js/pull/24) 42 | - FloatTensor add test [`#23`](https://github.com/OpenMined/syft.js/pull/23) 43 | - created a node server [`#19`](https://github.com/OpenMined/syft.js/pull/19) 44 | - adding demo folder's primitives. [`#20`](https://github.com/OpenMined/syft.js/pull/20) 45 | - Unit Testing Suite [`#21`](https://github.com/OpenMined/syft.js/pull/21) 46 | - Rollup [`#18`](https://github.com/OpenMined/syft.js/pull/18) 47 | - A cleaned up version of examples to keep things organized [`#17`](https://github.com/OpenMined/syft.js/pull/17) 48 | - Add gpu.js as a dependency [`#16`](https://github.com/OpenMined/syft.js/pull/16) 49 | - added js to parse json and create a js object [`#15`](https://github.com/OpenMined/syft.js/pull/15) 50 | - Initial commit, got babel and prettier running [`#5`](https://github.com/OpenMined/syft.js/pull/5) 51 | - Create README.md [`#4`](https://github.com/OpenMined/syft.js/pull/4) 52 | - Master [`#3`](https://github.com/OpenMined/syft.js/pull/3) 53 | - Corrected 'Resources' links [`#1`](https://github.com/OpenMined/syft.js/pull/1) 54 | - Closes #39 [`#39`](https://github.com/OpenMined/syft.js/issues/39) 55 | - Adding a Webpack example [`#36`](https://github.com/OpenMined/syft.js/issues/36) 56 | - Closes #32 by adding sourcemaps and minification [`#32`](https://github.com/OpenMined/syft.js/issues/32) 57 | - clean up plus docs 1 [`b28f7a1`](https://github.com/OpenMined/syft.js/commit/b28f7a15a051ae6c15ccf523e6df8bb0fcbbd0ae) 58 | - re-init [`4936d3f`](https://github.com/OpenMined/syft.js/commit/4936d3ffd2a01da2432f758723df72a9853a7f33) 59 | - Docs [`5be80be`](https://github.com/OpenMined/syft.js/commit/5be80be0c45b79a45990f53f1b2bbd12ad7e2f49) 60 | 61 | #### [v0.0.1-1](https://github.com/OpenMined/syft.js/compare/v1.5.0...v0.0.1-1) 62 | 63 | > 29 December 2019 64 | 65 | - Update serde, fix with-node example [`#71`](https://github.com/OpenMined/syft.js/pull/71) 66 | - Revert merge conflict issues [`#69`](https://github.com/OpenMined/syft.js/pull/69) 67 | - Changing terminology from user to worker [`#68`](https://github.com/OpenMined/syft.js/pull/68) 68 | - TS type defs, closes #57 [`#67`](https://github.com/OpenMined/syft.js/pull/67) 69 | - Fix specific case in string serde [`#58`](https://github.com/OpenMined/syft.js/pull/58) 70 | - Closes #55 [`#56`](https://github.com/OpenMined/syft.js/pull/56) 71 | - Grid syft [`#54`](https://github.com/OpenMined/syft.js/pull/54) 72 | - Add unit tests for webrtc.js [`#52`](https://github.com/OpenMined/syft.js/pull/52) 73 | - Remove unused variables in socket.test.js [`#51`](https://github.com/OpenMined/syft.js/pull/51) 74 | - Add sockets.js tests and minor fixes [`#50`](https://github.com/OpenMined/syft.js/pull/50) 75 | - Adding Serde to syft.js [`#43`](https://github.com/OpenMined/syft.js/pull/43) 76 | - Merge pull request #67 from tisd/ts-type-defs [`#57`](https://github.com/OpenMined/syft.js/issues/57) 77 | - Merge pull request #56 from OpenMined/issue-55 [`#55`](https://github.com/OpenMined/syft.js/issues/55) 78 | - Closes #55 [`#55`](https://github.com/OpenMined/syft.js/issues/55) 79 | - Closes #53 [`#53`](https://github.com/OpenMined/syft.js/issues/53) 80 | - Working on with-grid watching issues [`c63ce1f`](https://github.com/OpenMined/syft.js/commit/c63ce1f8ff4c5eafe2c2862e359f6f3ad1164237) 81 | - Reverting back to NPM [`b1e8d39`](https://github.com/OpenMined/syft.js/commit/b1e8d390a851a21e4ec4d59ae80b3914f59915b9) 82 | - Switching back to NPM [`34f583e`](https://github.com/OpenMined/syft.js/commit/34f583e4ddc3cd46e61e34849bacc34bc5176a03) 83 | -------------------------------------------------------------------------------- /test/protobuf.test.js: -------------------------------------------------------------------------------- 1 | import { protobuf, unserialize, getPbId, serialize } from '../src/protobuf'; 2 | import { ObjectMessage } from '../src/types/message'; 3 | import Protocol from '../src/types/protocol'; 4 | import { Plan } from '../src/types/plan'; 5 | import { State } from '../src/types/state'; 6 | import { MNIST_PLAN, MNIST_MODEL_PARAMS, PROTOCOL } from './data/dummy'; 7 | import { TorchTensor } from '../src/types/torch'; 8 | import * as tf from '@tensorflow/tfjs-core'; 9 | import { Placeholder } from '../src/types/placeholder'; 10 | 11 | describe('Protobuf', () => { 12 | test('can unserialize an ObjectMessage', () => { 13 | const obj = unserialize( 14 | null, 15 | 'CjcKBwi91JDfnQISKgoECgICAxIHZmxvYXQzMrIBGAAAgD8AAABAAABAQAAAgEAAAKBAMzPDQEAE', 16 | protobuf.syft_proto.messaging.v1.ObjectMessage 17 | ); 18 | expect(obj).toBeInstanceOf(ObjectMessage); 19 | }); 20 | 21 | test('can unserialize a Protocol', () => { 22 | const protocol = unserialize( 23 | null, 24 | PROTOCOL, 25 | protobuf.syft_proto.execution.v1.Protocol 26 | ); 27 | expect(protocol).toBeInstanceOf(Protocol); 28 | }); 29 | 30 | test('can unserialize a Plan', () => { 31 | const plan = unserialize( 32 | null, 33 | MNIST_PLAN, 34 | protobuf.syft_proto.execution.v1.Plan 35 | ); 36 | expect(plan).toBeInstanceOf(Plan); 37 | }); 38 | 39 | test('can unserialize a State', () => { 40 | const state = unserialize( 41 | null, 42 | MNIST_MODEL_PARAMS, 43 | protobuf.syft_proto.execution.v1.State 44 | ); 45 | expect(state).toBeInstanceOf(State); 46 | }); 47 | 48 | test('can serialize a State', async () => { 49 | const placeholders = [ 50 | new Placeholder('123', ['tag1', 'tag2'], 'placeholder') 51 | ]; 52 | const tensors = [ 53 | await TorchTensor.fromTfTensor( 54 | tf.tensor([ 55 | [1.1, 2.2], 56 | [3.3, 4.4] 57 | ]) 58 | ) 59 | ]; 60 | const state = new State(placeholders, tensors); 61 | const serialized = serialize(null, state); 62 | 63 | // unserialize back to check 64 | const unserState = unserialize( 65 | null, 66 | serialized, 67 | protobuf.syft_proto.execution.v1.State 68 | ); 69 | expect(unserState).toBeInstanceOf(State); 70 | expect(unserState.id).toStrictEqual(state.id); 71 | expect(unserState.placeholders).toStrictEqual(placeholders); 72 | expect( 73 | tf 74 | .equal(unserState.tensors[0].toTfTensor(), tensors[0].toTfTensor()) 75 | .all() 76 | .dataSync()[0] 77 | ).toBe(1); 78 | }); 79 | 80 | test('can serialize TorchTensor', async () => { 81 | const tensor = tf.tensor([ 82 | [1.1, 2.2], 83 | [3.3, 4.4] 84 | ]); 85 | const torchTensor = await TorchTensor.fromTfTensor(tensor); 86 | torchTensor.tags = ['tag1', 'tag2']; 87 | torchTensor.description = 'description of tensor'; 88 | 89 | // serialize 90 | const bin = serialize(null, torchTensor); 91 | expect(bin).toBeInstanceOf(ArrayBuffer); 92 | 93 | // check unserialized matches to original 94 | const unserTorchTensor = unserialize( 95 | null, 96 | bin, 97 | protobuf.syft_proto.types.torch.v1.TorchTensor 98 | ); 99 | expect(unserTorchTensor.shape).toStrictEqual(torchTensor.shape); 100 | expect(unserTorchTensor.dtype).toStrictEqual(torchTensor.dtype); 101 | expect(unserTorchTensor.contents).toStrictEqual(torchTensor.contents); 102 | // resulting TF tensors are equal 103 | expect( 104 | tf 105 | .equal(unserTorchTensor.toTfTensor(), tensor) 106 | .all() 107 | .dataSync()[0] 108 | ).toBe(1); 109 | expect(unserTorchTensor.tags).toStrictEqual(torchTensor.tags); 110 | expect(unserTorchTensor.description).toStrictEqual(torchTensor.description); 111 | }); 112 | 113 | test('can serialize TorchTensor', async () => { 114 | const tensor = tf.tensor([ 115 | [1.1, 2.2], 116 | [3.3, 4.4] 117 | ]); 118 | const torchTensor = await TorchTensor.fromTfTensor(tensor); 119 | torchTensor.tags = ['tag1', 'tag2']; 120 | torchTensor.description = 'description of tensor'; 121 | 122 | // serialize 123 | const bin = serialize(null, torchTensor); 124 | expect(bin).toBeInstanceOf(ArrayBuffer); 125 | 126 | // check unserialized matches to original 127 | const unserTorchTensor = unserialize( 128 | null, 129 | bin, 130 | protobuf.syft_proto.types.torch.v1.TorchTensor 131 | ); 132 | expect(unserTorchTensor.shape).toStrictEqual(torchTensor.shape); 133 | expect(unserTorchTensor.dtype).toStrictEqual(torchTensor.dtype); 134 | expect(unserTorchTensor.contents).toStrictEqual(torchTensor.contents); 135 | // resulting TF tensors are equal 136 | expect( 137 | tf 138 | .equal(unserTorchTensor.toTfTensor(), tensor) 139 | .all() 140 | .dataSync()[0] 141 | ).toBe(1); 142 | expect(unserTorchTensor.tags).toStrictEqual(torchTensor.tags); 143 | expect(unserTorchTensor.description).toStrictEqual(torchTensor.description); 144 | }); 145 | 146 | test('gets id from types.syft.Id', () => { 147 | const protocolWithIntId = protobuf.syft_proto.execution.v1.Protocol.fromObject( 148 | { 149 | id: { 150 | id_int: 123 151 | } 152 | } 153 | ); 154 | const protocolWithStrId = protobuf.syft_proto.execution.v1.Protocol.fromObject( 155 | { 156 | id: { 157 | id_str: '321' 158 | } 159 | } 160 | ); 161 | expect(getPbId(protocolWithIntId.id)).toBe('123'); 162 | expect(getPbId(protocolWithStrId.id)).toBe('321'); 163 | }); 164 | }); 165 | -------------------------------------------------------------------------------- /examples/mnist/mnist.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @license 3 | * Copyright 2018 Google LLC. All Rights Reserved. 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | * ============================================================================= 16 | */ 17 | 18 | import * as tf from '@tensorflow/tfjs-core'; 19 | 20 | export const IMAGE_H = 28; 21 | export const IMAGE_W = 28; 22 | const IMAGE_SIZE = IMAGE_H * IMAGE_W; 23 | const NUM_CLASSES = 10; 24 | const NUM_DATASET_ELEMENTS = 65000; 25 | 26 | const NUM_TRAIN_ELEMENTS = 55000; 27 | const NUM_TEST_ELEMENTS = NUM_DATASET_ELEMENTS - NUM_TRAIN_ELEMENTS; 28 | 29 | const MNIST_IMAGES_SPRITE_PATH = 30 | 'https://storage.googleapis.com/learnjs-data/model-builder/mnist_images.png'; 31 | const MNIST_LABELS_PATH = 32 | 'https://storage.googleapis.com/learnjs-data/model-builder/mnist_labels_uint8'; 33 | 34 | /** 35 | * A class that fetches the sprited MNIST dataset and provide data as 36 | * tf.Tensors. 37 | */ 38 | export class MnistData { 39 | constructor() {} 40 | 41 | async load() { 42 | // Make a request for the MNIST sprited image. 43 | const img = new Image(); 44 | const canvas = document.createElement('canvas'); 45 | const ctx = canvas.getContext('2d'); 46 | const imgRequest = new Promise((resolve, reject) => { 47 | img.crossOrigin = ''; 48 | img.onload = () => { 49 | img.width = img.naturalWidth; 50 | img.height = img.naturalHeight; 51 | 52 | const datasetBytesBuffer = new ArrayBuffer( 53 | NUM_DATASET_ELEMENTS * IMAGE_SIZE * 4 54 | ); 55 | 56 | const chunkSize = 5000; 57 | canvas.width = img.width; 58 | canvas.height = chunkSize; 59 | 60 | for (let i = 0; i < NUM_DATASET_ELEMENTS / chunkSize; i++) { 61 | const datasetBytesView = new Float32Array( 62 | datasetBytesBuffer, 63 | i * IMAGE_SIZE * chunkSize * 4, 64 | IMAGE_SIZE * chunkSize 65 | ); 66 | ctx.drawImage( 67 | img, 68 | 0, 69 | i * chunkSize, 70 | img.width, 71 | chunkSize, 72 | 0, 73 | 0, 74 | img.width, 75 | chunkSize 76 | ); 77 | 78 | const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height); 79 | 80 | for (let j = 0; j < imageData.data.length / 4; j++) { 81 | // All channels hold an equal value since the image is grayscale, so 82 | // just read the red channel. 83 | datasetBytesView[j] = imageData.data[j * 4] / 255; 84 | } 85 | } 86 | this.datasetImages = new Float32Array(datasetBytesBuffer); 87 | 88 | resolve(); 89 | }; 90 | img.src = MNIST_IMAGES_SPRITE_PATH; 91 | }); 92 | 93 | const labelsRequest = fetch(MNIST_LABELS_PATH); 94 | const [imgResponse, labelsResponse] = await Promise.all([ 95 | imgRequest, 96 | labelsRequest 97 | ]); 98 | 99 | this.datasetLabels = new Uint8Array(await labelsResponse.arrayBuffer()); 100 | 101 | // Slice the the images and labels into train and test sets. 102 | this.trainImages = this.datasetImages.slice( 103 | 0, 104 | IMAGE_SIZE * NUM_TRAIN_ELEMENTS 105 | ); 106 | this.testImages = this.datasetImages.slice(IMAGE_SIZE * NUM_TRAIN_ELEMENTS); 107 | this.trainLabels = this.datasetLabels.slice( 108 | 0, 109 | NUM_CLASSES * NUM_TRAIN_ELEMENTS 110 | ); 111 | this.testLabels = this.datasetLabels.slice( 112 | NUM_CLASSES * NUM_TRAIN_ELEMENTS 113 | ); 114 | } 115 | 116 | /** 117 | * Get all training data as a data tensor and a labels tensor. 118 | * 119 | * @returns 120 | * xs: The data tensor, of shape `[numTrainExamples, 784]`. 121 | * labels: The one-hot encoded labels tensor, of shape 122 | * `[numTrainExamples, 10]`. 123 | */ 124 | getTrainData() { 125 | const xs = tf.tensor2d(this.trainImages, [ 126 | this.trainImages.length / IMAGE_SIZE, 127 | IMAGE_H * IMAGE_W 128 | ]); 129 | const labels = tf.tensor2d(this.trainLabels, [ 130 | this.trainLabels.length / NUM_CLASSES, 131 | NUM_CLASSES 132 | ]); 133 | return { xs, labels }; 134 | } 135 | 136 | /** 137 | * Get all test data as a data tensor a a labels tensor. 138 | * 139 | * @param {number} numExamples Optional number of examples to get. If not 140 | * provided, 141 | * all test examples will be returned. 142 | * @returns 143 | * xs: The data tensor, of shape `[numTestExamples, 784]`. 144 | * labels: The one-hot encoded labels tensor, of shape 145 | * `[numTestExamples, 10]`. 146 | */ 147 | getTestData(numExamples = NUM_TEST_ELEMENTS) { 148 | let xs = tf.tensor2d(this.testImages, [ 149 | this.testImages.length / IMAGE_SIZE, 150 | IMAGE_H * IMAGE_W 151 | ]); 152 | let labels = tf.tensor2d(this.testLabels, [ 153 | this.testLabels.length / NUM_CLASSES, 154 | NUM_CLASSES 155 | ]); 156 | 157 | if (numExamples != null) { 158 | xs = xs.slice([0, 0, 0, 0], [numExamples, IMAGE_H * IMAGE_W]); 159 | labels = labels.slice([0, 0], [numExamples, NUM_CLASSES]); 160 | } 161 | return { xs, labels }; 162 | } 163 | } 164 | -------------------------------------------------------------------------------- /examples/multi-armed-bandit/index.js: -------------------------------------------------------------------------------- 1 | import React from 'react'; 2 | import { render } from 'react-dom'; 3 | import * as tf from '@tensorflow/tfjs-core'; 4 | import { Syft } from '@openmined/syft.js'; 5 | 6 | import App from './app.js'; 7 | 8 | // Define grid connection parameters 9 | const url = 'ws://localhost:5000'; 10 | const modelName = 'bandit'; 11 | const modelVersion = '1.0.0'; 12 | const shouldRepeat = false; 13 | 14 | // Pick random values f.or the layout 15 | const pickValue = p => p[Math.floor(Math.random() * p.length)]; 16 | 17 | // 24 possible configurations 18 | const appConfigPossibilities = { 19 | heroBackground: ['black', 'gradient'], 20 | buttonPosition: ['hero', 'vision'], 21 | buttonIcon: ['arrow', 'user', 'code'], 22 | buttonColor: ['blue', 'white'] 23 | }; 24 | 25 | // Final configuration for the app 26 | const appConfig = { 27 | heroBackground: pickValue(appConfigPossibilities.heroBackground), 28 | buttonPosition: pickValue(appConfigPossibilities.buttonPosition), 29 | buttonIcon: pickValue(appConfigPossibilities.buttonIcon), 30 | buttonColor: pickValue(appConfigPossibilities.buttonColor) 31 | }; 32 | 33 | // Set up an event listener for the button when it's clicked 34 | // TODO: @maddie - Submit the diff for a positive button click here... 35 | const onButtonClick = () => { 36 | console.log( 37 | 'Clicked the button! Send a positive result for config', 38 | appConfig 39 | ); 40 | }; 41 | 42 | // Start React 43 | render( 44 |' + cont.innerHTML; 172 | }; 173 | 174 | /** 175 | * Initializes loss & accuracy plots. 176 | */ 177 | const setFLUI = () => { 178 | Plotly.newPlot( 179 | 'loss_graph', 180 | [{ y: [], mode: 'lines', line: { color: '#80CAF6' } }], 181 | { title: 'Train Loss', showlegend: false }, 182 | { staticPlot: true } 183 | ); 184 | 185 | Plotly.newPlot( 186 | 'acc_graph', 187 | [{ y: [], mode: 'lines', line: { color: '#80CAF6' } }], 188 | { title: 'Train Accuracy', showlegend: false }, 189 | { staticPlot: true } 190 | ); 191 | 192 | document.getElementById('fl-training').style.display = 'table'; 193 | }; 194 | 195 | /** 196 | * Updates graphs after each batch. 197 | * @param epoch 198 | * @param batch 199 | * @param accuracy 200 | * @param loss 201 | * @returns {Promise
68 | 
69 |
75 | );
76 | };
77 |
78 | const Vision = ({ button }) => {
79 | const title = 'Vision & Mission';
80 | const description = `
81 | {title}
70 |71 | {description} 72 |
73 | {button && button} 74 |Industry standard tools for artificial intelligence have been designed with several assumptions: data is centralized into a single compute cluster, the cluster exists in a secure cloud, and the resulting models will be owned by a central authority. We envision a world in which we are not restricted to this scenario - a world in which AI tools treat privacy, security, and multi-owner governance as first class citizens.
82 |With OpenMined, an AI model can be governed by multiple owners and trained securely on an unseen, distributed dataset.
83 |The mission of the OpenMined community is to create an accessible ecosystem of tools for private, secure, multi-owner governed AI. We do this by extending popular libraries like TensorFlow and PyTorch with advanced techniques in cryptography and private machine learning.
84 | `; 85 | 86 | const styles = { 87 | container: { 88 | padding: 40, 89 | maxWidth: 960, 90 | width: '90%', 91 | margin: '0 auto' 92 | } 93 | }; 94 | 95 | return ( 96 |
97 |
104 | );
105 | };
106 |
107 | const Button = ({ background, icon, onClick }) => (
108 |
141 | );
142 |
143 | const Footer = () => {
144 | const styles = {
145 | wrapper: {
146 | background: '#333',
147 | padding: 40
148 | },
149 | container: {
150 | display: 'flex',
151 | justifyContent: 'space-between',
152 | width: 940,
153 | margin: '0 auto'
154 | },
155 | logo: {
156 | width: 200,
157 | height: 'auto'
158 | },
159 | social: {
160 | display: 'flex',
161 | alignItems: 'center'
162 | },
163 | socialIcon: {
164 | color: 'rgba(255, 255, 255, 0.5)',
165 | transition: 'color 0.2s ease-in-out',
166 | fontSize: 24,
167 | marginLeft: 20,
168 | '&:hover': {
169 | color: '#FFF'
170 | }
171 | }
172 | };
173 | return (
174 | {title}
98 | 102 | {button && button} 103 |
175 |
209 | );
210 | };
211 |
212 | export default ({ config, onButtonClick, start }) => {
213 | useEffect(() => {
214 | start();
215 | }, []);
216 |
217 | const button = (
218 |
223 | );
224 |
225 | return (
226 |
176 | 
177 |
207 |
208 |
233 |
240 | );
241 | };
242 |
--------------------------------------------------------------------------------
/src/job.js:
--------------------------------------------------------------------------------
1 | import EventObserver from './events';
2 | import { protobuf, unserialize } from './protobuf';
3 | import { CYCLE_STATUS_ACCEPTED, CYCLE_STATUS_REJECTED } from './_constants';
4 | import { GRID_UNKNOWN_CYCLE_STATUS, PLAN_LOAD_FAILED } from './_errors';
5 | import SyftModel from './syft-model';
6 | import Logger from './logger';
7 |
8 | /**
9 | * Job represents a single training cycle done by the client.
10 | *
11 | * @property {Object.