soumyasd

Rust in Large Organizations

Initially taken by Niko Matsakis and lightly edited by Ryan Levick

Agenda

Introductions
Cargo inside large build systems
FFI
Foundations and financial support

These instructions will explain how to install tensorflow on mac with cuda enabled GPU suport. I assume you know what tensorflow is and why you would want to have a deep learning framework running on your computer.

Prerequisites

Make sure to update your homebrew formulas

brew update

These links no longer work. Springer have pulled the free plug.

Graduate texts in mathematics

duplicates = multiple editions

A Classical Introduction to Modern Number Theory, Kenneth Ireland Michael Rosen

Category theory jargon cheat sheet

A primer/refresher on the category theory concepts that most commonly crop up in conversations about Scala or FP. (Because it's embarassing when I forget this stuff!)

I'll be assuming Scalaz imports in code samples, and some of the code may be pseudo-Scala.

Functor

A functor is something that supports map.

`Actor` Queue Notes

The first thing to understand is that the head field inside of scalaz.concurrent.Actor is not the "head" of the message queue in any traditional sense of the word. A better description would be "last". The there are no pointers to the head of the queue, which one of the very clever things about this implementation.

Empty Actor

Consider the case where the actor has no outstanding messages. This new message will go into the following code:

 def !(a: A): Unit = {

	package main

	import (
	"context"
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"

	import math
	import random

	def get_random_neighbour(state):
	neighbour = [house[:] for house in state] # Deep copy

	i, j = random.sample(xrange(5), 2)
	attr_idx = random.randint(0, 4)

	neighbour[i][attr_idx], neighbour[j][attr_idx] = neighbour[j][attr_idx], neighbour[i][attr_idx]

	"""
	Possibly correct implementation of an all conv neural network using a single residual module

	This code was written for instruction purposes and no attempt to get the best results were made.

	References:
	Deep Residual Learning for Image Recognition: http://arxiv.org/pdf/1512.03385v1.pdf
	STRIVING FOR SIMPLICITY, THE ALL CONVOLUTIONAL NET: http://arxiv.org/pdf/1412.6806v3.pdf

	A video walking through the code and main ideas: https://youtu.be/-N_zlfKo4Ec

	# Time Series Testing
	import keras.callbacks
	from keras.models import Sequential
	from keras.layers.core import Dense, Activation, Dense, Dropout
	from keras.layers.recurrent import LSTM

	# Call back to capture losses
	class LossHistory(keras.callbacks.Callback):
	def on_train_begin(self, logs={}):
	self.losses = []

	import java.io.File

	import akka.actor._
	import akka.routing.{Routee, RemoveRoutee, ActorRefRoutee, AddRoutee}
	import akka.stream.actor.ActorPublisher
	import org.akkamon.core.ActorStack
	import org.akkamon.core.instruments.CounterTrait
	import play.api.libs.json.Json
	import scala.annotation.tailrec
	import scala.concurrent.duration._