Anil Karaka syllogismos

Code used to obtain these results can be found at the url https://github.com/joschu/modular_rl, commit 50cdfdf375e69d86e3db6eb2ad0218ea6aebf371. The command line expression used for all the environments can be found in the text file below. Note that the same exact parameters and policies were used for all tasks, except for timesteps_per_batch, which was varied based on the difficulty of the task. The important parameters are:

gamma=0.995: discount
lam=0.97: see GAE paper for explanation
agent=TrpoAgent: name of the class, which specifies policy and value function architecture. In this case, we used two hidden layers of size 64, with tanh activations
cg_damping: multiple of the identity added for conjugate gradient

Introduction

At DICOM Grid, we recently made the decision to use Haskell for some of our newer projects, mostly small, independent web services. This isn't the first time I've had the opportunity to use Haskell at work - I had previously used Haskell to write tools to automate some processes like generation of documentation for TypeScript code - but this is the first time we will be deploying Haskell code into production.

Over the past few months, I have been working on two Haskell services:

A reimplementation of an existing socket.io service, previously written for NodeJS using TypeScript.
A new service, which would interact with third-party components using standard data formats from the medical industry.

I will write here mostly about the first project, since it is a self-contained project which provides a good example of the power of Haskell. Moreover, the proces

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

	import pandas as pd
	import dgl
	import os
	import torch

	class MovieLens(object):
	def __init__(self, directory):
	'''
	directory: path to movielens directory which should have the three
	files:

	from graphviz import Digraph
	import torch
	from torch.autograd import Variable, Function

	def iter_graph(root, callback):
	queue = [root]
	seen = set()
	while queue:
	fn = queue.pop()
	if fn in seen:

	'''
	A logistic regression example using the meta-graph checkpointing
	features of Tensorflow.

	Author: João Felipe Santos, based on code by Aymeric Damien
	(https://github.com/aymericdamien/TensorFlow-Examples/)
	'''

	from __future__ import print_function

	/**
	* Lodash mixins for combinatorics
	* by: wassname & visangela
	* url: https://gist.github.com/wassname/a882ac3981c8e18d2556/edit
	* lodash contrib issue: https://github.com/node4good/lodash-contrib/issues/47
	* lic: same as lodash
	* Inspired by python itertools: https://docs.python.org/2.7/library/itertools.html
	*
	* Usage:
	* permutations([0,1,2],2) // [[0,1],[0,2],[1,0],[1,2],[2,0],[2,1]]


	### for brand-new only
	sudo apt-get update
	sudo apt-get install htop
	sudo apt-get install build-essential

	wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh
	bash Miniconda3-latest-Linux-x86_64.sh
	rm Miniconda3-latest-Linux-x86_64.sh

	// change com.appname with your proper path and appname
	// build wtth Ctlr + F9 on Android Studio to generate the java classes from android annotated files

	buildscript {
	repositories {
	mavenCentral()
	}
	dependencies {
	classpath 'com.neenbedankt.gradle.plugins:android-apt:1.2+'
	}

	http://forums.aichallenge.org/viewtopic.php?f=17&t=1136

	We represent every program internally as an object tree,
	very much like a compiler internally represents a program
	after parsing and before generating executable code.

	A compiler manipulates these objects in order to optimize
	the code, we do it in order to randomly change the
	code (mutation) and to insert parts of one program
	into another (crossover).