爱可可-爱生活 fly51fly

How to recover lost Python source code if it's still resident in-memory

I screwed up using git ("git checkout --" on the wrong file) and managed to delete the code I had just written... but it was still running in a process in a docker container. Here's how I got it back, using https://pypi.python.org/pypi/pyrasite/ and https://pypi.python.org/pypi/uncompyle6

Attach a shell to the docker container

Install GDB (needed by pyrasite)

apt-get update && apt-get install gdb

Applied Functional Programming with Scala - Notes

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

Scoped Implicit Lifetimes

All things considered, our experience in Scala Native has shown that resource management in Scala is way harder than it should be. This gist presents a simple design pattern that makes it resource management absolutely hassle-free: scoped implicit lifetimes.

The main idea behind it is to encode resource lifetimes through a concept of an implicit scope. Scopes are necessary to acquire resources. They are responsible for disposal of the resources once the evaluation exits the

A Few Useful Things to Know about Machine Learning

The paper presents some key lessons and "folk wisdom" that machine learning researchers and practitioners have learnt from experience and which are hard to find in textbooks.

1. Learning = Representation + Evaluation + Optimization

All machine learning algorithms have three components:

Representation for a learner is the set if classifiers/functions that can be possibly learnt. This set is called hypothesis space. If a function is not in hypothesis space, it can not be learnt.
Evaluation function tells how good the machine learning model is.
Optimisation is the method to search for the most optimal learning model.

Understanding LSTMs

Japanese: qiita
Russian: Alex Sosn
Chinese: jianshu, csdn, csdn, Yangyu Chen

	"""Short and sweet LSTM implementation in Tensorflow.

	Motivation:
	When Tensorflow was released, adding RNNs was a bit of a hack - it required
	building separate graphs for every number of timesteps and was a bit obscure
	to use. Since then TF devs added things like `dynamic_rnn`, `scan` and `map_fn`.
	Currently the APIs are decent, but all the tutorials that I am aware of are not
	making the best use of the new APIs.

	Advantages of this implementation:

	# TensorFlow r0.10
	#
	# Building Graph
	#
	add_to_collection,tf.add_to_collection
	as_dtype,tf.as_dtype
	bytes,tf.bytes
	container,tf.container
	control_dependencies,tf.control_dependencies
	convert_to_tensor,tf.convert_to_tensor

	n <- 200
	m <- 40
	set.seed(1)
	x <- runif(n, -1, 1)
	library(rafalib)
	bigpar(2,2,mar=c(3,3,3,1))
	library(RColorBrewer)
	cols <- brewer.pal(11, "Spectral")[as.integer(cut(x, 11))]
	plot(x, rep(0,n), ylim=c(-1,1), yaxt="n", xlab="", ylab="",
	col=cols, pch=20, main="underlying data")