<?xml version="1.0" encoding="UTF-8"?>
 <rdf:RDF xmlns="http://purl.org/rss/1.0/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://web.resource.org/cc/" xmlns:syn="http://purl.org/rss/1.0/modules/syndication/" xmlns:admin="http://webns.net/mvcb/">
  <channel rdf:about="http://pinboard.in">
    <title>Pinboard (Vaguery)</title>
    <link>https://pinboard.in/u:Vaguery/public/</link>
    <description>recent bookmarks from Vaguery</description>
    <items>
      <rdf:Seq>	<rdf:li rdf:resource="https://gist.github.com/rxwei/30ba75ce092ab3b0dce4bde1fc2c9f1d"/>
	<rdf:li rdf:resource="http://pharo.gforge.inria.fr/PBE1/PBE1ch10.html"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.08359"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.08004"/>
	<rdf:li rdf:resource="https://scholar.google.com/scholar?q=jensen+cohen+multiple+comparisons"/>
	<rdf:li rdf:resource="https://github.com/aria42/flare"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1703.00607"/>
	<rdf:li rdf:resource="https://blog.acolyer.org/2018/02/22/dynamic-word-embeddings-for-evolving-semantic-discovery/"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1802.04196"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.04851"/>
	<rdf:li rdf:resource="https://kubernetes.io/docs/tasks/job/fine-parallel-processing-work-queue/"/>
	<rdf:li rdf:resource="https://www.terraform.io/intro/getting-started/variables.html"/>
	<rdf:li rdf:resource="http://www.timescale.com/how-it-works"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1710.01410"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1703.01220"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.04524"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1610.01369"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1701.05290"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.07116"/>
	<rdf:li rdf:resource="http://dragan.rocks/articles/17/Clojure-Numerics-2-General-Linear-Systems-and-LU-Factorization"/>
	<rdf:li rdf:resource="https://github.com/hswick/jutsu.ai"/>
	<rdf:li rdf:resource="https://en.wikipedia.org/wiki/Abstract_simplicial_complex"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1611.04766"/>
	<rdf:li rdf:resource="https://research.googleblog.com/2017/04/federated-learning-collaborative.html"/>
	<rdf:li rdf:resource="https://github.com/abscondment/clj-kdtree"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1208.3663"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1608.05347"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1603.08812"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1611.09528"/>
	<rdf:li rdf:resource="http://biorxiv.org/content/early/2016/07/22/065243?rss=1%2522"/>
	<rdf:li rdf:resource="https://api.slack.com/community"/>
	<rdf:li rdf:resource="http://sqlkorma.com/"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1502.02389"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1407.0900"/>
	<rdf:li rdf:resource="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedCreateTables.html"/>
	<rdf:li rdf:resource="http://scottsievert.github.io/swix/"/>
	<rdf:li rdf:resource="https://swift.versify-app.com/post/usehnl/"/>
	<rdf:li rdf:resource="https://developer.apple.com/swift/blog/?id=6"/>
	<rdf:li rdf:resource="https://developer.apple.com/library/mac/documentation/Accelerate/Reference/AccelerateFWRef/_index.html#//apple_ref/doc/uid/TP40009465"/>
	<rdf:li rdf:resource="http://bl.ocks.org/mbostock/7882658"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1205.4265"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1309.6392"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1301.7738"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1303.7032"/>
	<rdf:li rdf:resource="http://numericjs.com/"/>
	<rdf:li rdf:resource="http://www.scipirate.com/2012/11/finding-meaningful-clusters-in-phylogenetic-trees-or-other-hierarchical-clusterings/"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1207.4598"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1207.1253"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1206.3552"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1206.3555"/>
	<rdf:li rdf:resource="http://geneura.wordpress.com/2012/04/15/pool-based-evolutionary-algorithm-presented-in-evostar-2012/"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1201.6583"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1201.5568"/>
	<rdf:li rdf:resource="http://www.nsl.com/k/xy/xy.htm"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1109.1275"/>
	<rdf:li rdf:resource="http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Strings/introStrings.html#//apple_ref/doc/uid/10000035i"/>
	<rdf:li rdf:resource="http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html#//apple_ref/doc/uid/TP40008048-CH102"/>
	<rdf:li rdf:resource="http://parsekit.com/"/>
	<rdf:li rdf:resource="http://stackoverflow.com/questions/6296758/integrating-bison-flex-yacc-into-xcode"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1108.4220"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1106.1821"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1106.1816"/>
	<rdf:li rdf:resource="http://www.latrobe.edu.au/philosophy/phimvt/joy.html"/>
	<rdf:li rdf:resource="http://tunes.org/~iepos/joy.html"/>
	<rdf:li rdf:resource="http://www.jstree.com/"/>
	<rdf:li rdf:resource="http://www.miller-mccune.com/culture-society/triumph-of-the-cyborg-composer-8507/"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/0807.1271"/>
	<rdf:li rdf:resource="http://opencv.willowgarage.com/wiki/"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1007.5475"/>
	<rdf:li rdf:resource="http://www.rubyflow.com/items/4256?utm_source=feedburner&amp;utm_medium=feed&amp;utm_campaign=Feed%3A+Rubyflow+(RubyFlow)"/>
      </rdf:Seq>
    </items>
  </channel><item rdf:about="https://gist.github.com/rxwei/30ba75ce092ab3b0dce4bde1fc2c9f1d">
    <title>First-Class Automatic Differentiation in Swift: A Manifesto</title>
    <dc:date>2018-10-22T13:11:37+00:00</dc:date>
    <link>https://gist.github.com/rxwei/30ba75ce092ab3b0dce4bde1fc2c9f1d</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[First-Class Automatic Differentiation in Swift: A Manifesto]]></description>
<dc:subject>swift programming-language nudge to-watch representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b60941881f0e/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:swift"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-watch"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://pharo.gforge.inria.fr/PBE1/PBE1ch10.html">
    <title>9 Collections</title>
    <dc:date>2018-10-19T12:01:29+00:00</dc:date>
    <link>http://pharo.gforge.inria.fr/PBE1/PBE1ch10.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The collection classes form a loosely-defined group of general-purpose subclasses of Collection and Stream. The group of classes that appears in the “Blue Book” 1 contains 17 subclasses of Collection and 9 subclasses of Stream, for a total of 28 classes, and had already been redesigned several times before the Smalltalk-80 system was released. This group of classes is often considered to be a paradigmatic example of object-oriented design.

]]></description>
<dc:subject>languages Smalltalk classes computer-science nudge consider:robustness to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2e710e87a4f2/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:languages"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Smalltalk"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:classes"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:robustness"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.08359">
    <title>[1709.08359] On the expressive power of query languages for matrices</title>
    <dc:date>2018-03-19T09:47:39+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.08359</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We investigate the expressive power of 𝖬𝖠𝖳𝖫𝖠𝖭𝖦, a formal language for matrix manipulation based on common matrix operations and linear algebra. The language can be extended with the operation 𝗂𝗇𝗏 of inverting a matrix. In 𝖬𝖠𝖳𝖫𝖠𝖭𝖦+𝗂𝗇𝗏 we can compute the transitive closure of directed graphs, whereas we show that this is not possible without inversion. Indeed we show that the basic language can be simulated in the relational algebra with arithmetic operations, grouping, and summation. We also consider an operation 𝖾𝗂𝗀𝖾𝗇 for diagonalizing a matrix, which is defined so that different eigenvectors returned for a same eigenvalue are orthogonal. We show that 𝗂𝗇𝗏 can be expressed in 𝖬𝖠𝖳𝖫𝖠𝖭𝖦+𝖾𝗂𝗀𝖾𝗇. We put forward the open question whether there are boolean queries about matrices, or generic queries about graphs, expressible in 𝖬𝖠𝖳𝖫𝖠𝖭𝖦+𝖾𝗂𝗀𝖾𝗇 but not in 𝖬𝖠𝖳𝖫𝖠𝖭𝖦+𝗂𝗇𝗏. The evaluation problem for 𝖬𝖠𝖳𝖫𝖠𝖭𝖦+𝖾𝗂𝗀𝖾𝗇 is shown to be complete for the complexity class ∃R.]]></description>
<dc:subject>matrices programming-language representation rather-interesting nudge consider:representation to--do</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c47e8c81a71d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:matrices"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to--do"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.08004">
    <title>[1709.08004] Slow-scale split-step tau-leap method for stiff stochastic chemical systems</title>
    <dc:date>2018-02-27T12:32:49+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.08004</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Tau-leaping is a family of algorithms for the approximate simulation of discrete state continuous time Markov chains. The motivation for the development of such methods can be found, for instance, in the fields of chemical kinetics and systems biology. It is well known that the dynamical behavior of biochemical systems is often intrinsically stiff representing a serious challenge for their numerical approximation. The naive extension of stiff deterministic solvers to stochastic integration usually yields numerical solutions with either impractically large relaxation times or incorrectly resolved covariance. In this paper, we propose a novel splitting heuristic which allows to resolve these issues. The proposed numerical integrator takes advantage of the special structure of the linear systems with explicitly available equations for the mean and the covariance which we use to calibrate the parameters of the scheme. It is shown that the method is able to reproduce the exact mean and variance of the linear scalar test equation and has very good accuracy for the arbitrarily stiff systems at least in linear case. The numerical examples for both linear and nonlinear systems are also provided and the obtained results confirm the efficiency of the considered splitting approach.
]]></description>
<dc:subject>numerical-methods diffy-Qs approximation systems-biology algorithms to-write-about consider:representation rather-interesting nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:9397b3705f3b/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:numerical-methods"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:diffy-Qs"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:approximation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:systems-biology"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://scholar.google.com/scholar?q=jensen+cohen+multiple+comparisons">
    <title>&quot;Multiple comparisons in induction algorithms&quot; - Google Scholar</title>
    <dc:date>2018-02-27T11:33:53+00:00</dc:date>
    <link>https://scholar.google.com/scholar?q=jensen+cohen+multiple+comparisons</link>
    <dc:creator>Vaguery</dc:creator><dc:subject>machine-learning statistics modeling performance-measure consider:lexicase to-write-about nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:d053061a5882/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:statistics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:modeling"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-measure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:lexicase"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://github.com/aria42/flare">
    <title>aria42/flare: Dynamic Tensor Graph library in Clojure (think PyTorch, DynNet, etc.)</title>
    <dc:date>2018-02-27T00:54:25+00:00</dc:date>
    <link>https://github.com/aria42/flare</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[A Clojure library for dynamic neural nets (e.g., PyTorch, DynNet). Mostly for learning purposes, but totally usable and pretty performant (see Performance below). See introductory blog post here. Current features:

]]></description>
<dc:subject>Clojure neural-networks nudge integrate-as-primitives</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:7d9a06f145b0/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Clojure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:integrate-as-primitives"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1703.00607">
    <title>[1703.00607] Dynamic Word Embeddings for Evolving Semantic Discovery</title>
    <dc:date>2018-02-25T12:48:56+00:00</dc:date>
    <link>https://arxiv.org/abs/1703.00607</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Word evolution refers to the changing meanings and associations of words throughout time, as a byproduct of human language evolution. By studying word evolution, we can infer social trends and language constructs over different periods of human history. However, traditional techniques such as word representation learning do not adequately capture the evolving language structure and vocabulary. In this paper, we develop a dynamic statistical model to learn time-aware word vector representation. We propose a model that simultaneously learns time-aware embeddings and solves the resulting "alignment problem". This model is trained on a crawled NYTimes dataset. Additionally, we develop multiple intuitive evaluation strategies of temporal word embeddings. Our qualitative and quantitative tests indicate that our method not only reliably captures this evolution over time, but also consistently outperforms state-of-the-art temporal embedding approaches on both semantic accuracy and alignment quality.
]]></description>
<dc:subject>time-series digital-humanities natural-language-processing representation nudge to-write-about to-do</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b5cbb8b64478/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:time-series"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:digital-humanities"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:natural-language-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-do"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://blog.acolyer.org/2018/02/22/dynamic-word-embeddings-for-evolving-semantic-discovery/">
    <title>Dynamic word embeddings for evolving semantic discovery | the morning paper</title>
    <dc:date>2018-02-25T12:48:19+00:00</dc:date>
    <link>https://blog.acolyer.org/2018/02/22/dynamic-word-embeddings-for-evolving-semantic-discovery/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Prior approaches to solving this problem first use independent learning as per our straw man, and then post process the embeddings in an alignment phase to try and match them up. But Yao et al. have found a way to learn temporal embeddings in all time slices concurrently, doing away with the need for a separate alignment phase. The experimental results suggests that this yields better outcomes that the prior two-step methods, and the approach is also robust against data sparsity (it will tolerate time slices where some words are rarely present or even missing).

]]></description>
<dc:subject>digital-humanities time-series rather-interesting to-write-about natural-language-processing representation nudge consider:generalization</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b88776ab53ba/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:digital-humanities"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:time-series"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:natural-language-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:generalization"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1802.04196">
    <title>[1802.04196] Universal quantum computing and three-manifolds</title>
    <dc:date>2018-02-25T12:13:31+00:00</dc:date>
    <link>https://arxiv.org/abs/1802.04196</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[A single qubit may be represented on the Bloch sphere or similarly on the 3-sphere S3. Our goal is to dress this correspondence by converting the language of universal quantum computing (uqc) to that of 3-manifolds. A magic state and the Pauli group acting on it define a model of uqc as a POVM that one recognizes to be a 3-manifold M3. E. g., the d-dimensional POVMs defined from subgroups of finite index of the modular group PSL(2,ℤ) correspond to d-fold M3- coverings over the trefoil knot. In this paper, one also investigates quantum information on a few \lq universal' knots and links such as the figure-of-eight knot, the Whitehead link and Borromean rings, making use of the catalog of platonic manifolds available on SnapPy. Further connections between POVMs based uqc and M3's obtained from Dehn fillings are explored.]]></description>
<dc:subject>quantums quantum-computing representation rather-interesting to-write-about nudge consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:d1ab9a832050/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:quantums"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:quantum-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.04851">
    <title>[1709.04851] Factor Analysis of Interval Data</title>
    <dc:date>2018-02-25T11:28:46+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.04851</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This paper presents a factor analysis model for symbolic data, focusing on the particular case of interval-valued variables. The proposed method describes the correlation structure among the measured interval-valued variables in terms of a few underlying, but unobservable, uncorrelated interval-valued variables, called \textit{common factors}. Uniform and Triangular distributions are considered within each observed interval. We obtain the corresponding sample mean, variance and covariance assuming a general Triangular distribution. 
In our proposal, factors are extracted either by Principal Component or by Principal Axis Factoring, performed on the interval-valued variables correlation matrix. To estimate the values of the common factors, usually called \textit{factor scores}, two approaches are considered, which are inspired in methods for real-valued data: the Bartlett and the Anderson-Rubin methods. In both cases, the estimated values are obtained solving an optimization problem that minimizes a function of the weighted squared Mallows distance between quantile functions. Explicit expressions for the quantile function and the squared Mallows distance are derived assuming a general Triangular distribution. 
The applicability of the method is illustrated using two sets of data: temperature and precipitation in cities of the United States of America between the years 1971 and 2000 and measures of car characteristics of different makes and models. Moreover, the method is evaluated on synthetic data with predefined correlation structures.
]]></description>
<dc:subject>representation statistics algorithms rather-interesting to-write-about nudge consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c957e4ac9639/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:statistics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://kubernetes.io/docs/tasks/job/fine-parallel-processing-work-queue/">
    <title>Fine Parallel Processing Using a Work Queue | Kubernetes</title>
    <dc:date>2018-02-05T02:39:38+00:00</dc:date>
    <link>https://kubernetes.io/docs/tasks/job/fine-parallel-processing-work-queue/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this example, we will run a Kubernetes Job with multiple parallel worker processes. You may want to be familiar with the basic, non-parallel, use of Job first.
In this example, as each pod is created, it picks up one unit of work from a task queue, processes it, and repeats until the end of the queue is reached.]]></description>
<dc:subject>kubernetes architecture distributed-processing to-learn nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:511f4d2fb4b0/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:kubernetes"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-learn"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.terraform.io/intro/getting-started/variables.html">
    <title>Input Variables - Terraform by HashiCorp</title>
    <dc:date>2018-02-04T21:05:18+00:00</dc:date>
    <link>https://www.terraform.io/intro/getting-started/variables.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[You now have enough Terraform knowledge to create useful configurations, but we're still hard-coding access keys, AMIs, etc. To become truly shareable and version controlled, we need to parameterize the configurations. This page introduces input variables as a way to do this.

]]></description>
<dc:subject>terraform cloud-computing documentation to-understand setup nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:0a6c88fa48c5/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:terraform"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cloud-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:documentation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:setup"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.timescale.com/how-it-works">
    <title>Timescale | How-it-works</title>
    <dc:date>2018-01-25T11:49:34+00:00</dc:date>
    <link>http://www.timescale.com/how-it-works</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Time-series data is largely immutable. Writes primarily occur as new appends to recent time intervals, not as updates to existing rows. Both read and write workloads have a natural partitioning across both time and space.]]></description>
<dc:subject>via:arsyed time-series software-development database to-understand nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:670e7cf867be/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:arsyed"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:time-series"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:database"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1710.01410">
    <title>[1710.01410] Learning Registered Point Processes from Idiosyncratic Observations</title>
    <dc:date>2017-11-09T11:31:43+00:00</dc:date>
    <link>https://arxiv.org/abs/1710.01410</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[A parametric point process model is developed, with modeling based on the assumption that sequential observations often share latent phenomena, while also possessing idiosyncratic effects. An alternating optimization method is proposed to learn a "registered" point process that accounts for shared structure, as well as "warping" functions that characterize idiosyncratic aspects of each observed sequence. Under reasonable constraints, in each iteration we update the sample-specific warping functions by solving a set of constrained nonlinear programming problems in parallel, and update the model by maximum likelihood estimation. The justifiability, complexity and robustness of the proposed method are investigated in detail. Experiments on both synthetic and real-world data demonstrate that the method yields explainable point process models, achieving encouraging results compared to state-of-the-art methods.]]></description>
<dc:subject>modeling-is-not-mathematics rather-interesting representation machine-learning algorithms nudge nudge-targets consider:representation consider:performance-measures</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:abf608834ad9/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:modeling-is-not-mathematics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:performance-measures"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1703.01220">
    <title>[1703.01220] Denoising Adversarial Autoencoders</title>
    <dc:date>2017-11-06T12:23:28+00:00</dc:date>
    <link>https://arxiv.org/abs/1703.01220</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Unsupervised learning is of growing interest because it unlocks the potential held in vast amounts of unlabelled data to learn useful representations for inference. Autoencoders, a form of generative model, may be trained by learning to reconstruct unlabelled input data from a latent representation space. More robust representations may be produced by an autoencoder if it learns to recover clean input samples from corrupted ones. Representations may be further improved by introducing regularisation during training to shape the distribution of the encoded data in latent space. We suggest denoising adversarial autoencoders, which combine denoising and regularisation, shaping the distribution of latent space using adversarial training. We introduce a novel analysis that shows how denoising may be incorporated into the training and sampling of adversarial autoencoders. Experiments are performed to assess the contributions that denoising makes to the learning of representations for classification and sample synthesis. Our results suggest that autoencoders trained using a denoising criterion achieve higher classification performance, and can synthesise samples that are more consistent with the input data than those trained without a corruption process.]]></description>
<dc:subject>unsupervised-learning machine-learning algorithms rather-interesting deep-learning to-write-about to-learn nudge consider:GP-applications</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1e3cb3323a0f/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:unsupervised-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:deep-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-learn"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:GP-applications"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.04524">
    <title>[1709.04524] Workflow Complexity for Collaborative Interactions: Where are the Metrics? -- A Challenge</title>
    <dc:date>2017-10-09T11:16:49+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.04524</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper, we introduce the problem of denoting and deriving the complexity of workflows (plans, schedules) in collaborative, planner-assisted settings where humans and agents are trying to jointly solve a task. The interactions -- and hence the workflows that connect the human and the agents -- may differ according to the domain and the kind of agents. We adapt insights from prior work in human-agent teaming and workflow analysis to suggest metrics for workflow complexity. The main motivation behind this work is to highlight metrics for human comprehensibility of plans and schedules. The planning community has seen its fair share of work on the synthesis of plans that take diversity into account -- what value do such plans hold if their generation is not guided at least in part by metrics that reflect the ease of engaging with and using those plans?
]]></description>
<dc:subject>computational-complexity performance-measure to-understand what-gets-measured-gets-fudged nudge to-write-about engineering-design philosophy-of-engineering machine-learning artificial-intelligence</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:5c15d954a5f1/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-measure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:what-gets-measured-gets-fudged"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:philosophy-of-engineering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:artificial-intelligence"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1610.01369">
    <title>[1610.01369] Self-referential Functions</title>
    <dc:date>2017-10-05T10:19:44+00:00</dc:date>
    <link>https://arxiv.org/abs/1610.01369</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We introduce the concept of fractels for functions and discuss their analytic and algebraic properties. We also consider the representation of polynomials and analytic functions using fractels, and the consequences of these representations in numerical analysis.
]]></description>
<dc:subject>fractals algebra representation dynamical-systems to-understand define-your-terms to-write-about nudge consider:fractel-type-in-Klapaucius</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:fbe0d9e4fc6d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:fractals"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algebra"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:dynamical-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:define-your-terms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:fractel-type-in-Klapaucius"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1701.05290">
    <title>[1701.05290] Range-efficient consistent sampling and locality-sensitive hashing for polygons</title>
    <dc:date>2017-09-29T16:02:29+00:00</dc:date>
    <link>https://arxiv.org/abs/1701.05290</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Locality-sensitive hashing (LSH) is a fundamental technique for similarity search and similarity estimation in high-dimensional spaces. The basic idea is that similar objects should produce hash collisions with probability significantly larger than objects with low similarity. We consider LSH for objects that can be represented as point sets in either one or two dimensions. To make the point sets finite size we consider the subset of points on a grid. Directly applying LSH (e.g. min-wise hashing) to these point sets would require time proportional to the number of points. We seek to achieve time that is much lower than direct approaches. 
Technically, we introduce new primitives for range-efficient consistent sampling (of independent interest), and show how to turn such samples into LSH values. Another application of our technique is a data structure for quickly estimating the size of the intersection or union of a set of preprocessed polygons. Curiously, our consistent sampling method uses transformation to a geometric problem.]]></description>
<dc:subject>rather-interesting approximation representation to-understand nudge consider:for-behavior-classification to-write-about computational-geometry</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1a04937a0639/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:approximation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:for-behavior-classification"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-geometry"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.07116">
    <title>[1709.07116] Variational Memory Addressing in Generative Models</title>
    <dc:date>2017-09-29T13:39:52+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.07116</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Aiming to augment generative models with external memory, we interpret the output of a memory module with stochastic addressing as a conditional mixture distribution, where a read operation corresponds to sampling a discrete memory address and retrieving the corresponding content from memory. This perspective allows us to apply variational inference to memory addressing, which enables effective training of the memory module by using the target information to guide memory lookups. Stochastic addressing is particularly well-suited for generative models as it naturally encourages multimodality which is a prominent aspect of most high-dimensional datasets. Treating the chosen address as a latent variable also allows us to quantify the amount of information gained with a memory lookup and measure the contribution of the memory module to the generative process. To illustrate the advantages of this approach we incorporate it into a variational autoencoder and apply the resulting model to the task of generative few-shot learning. The intuition behind this architecture is that the memory module can pick a relevant template from memory and the continuous part of the model can concentrate on modeling remaining variations. We demonstrate empirically that our model is able to identify and access the relevant memory contents even with hundreds of unseen Omniglot characters in memory
]]></description>
<dc:subject>machine-learning memory algorithms rather-interesting nudge consider:architecture consider:data-fusion</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:5c01013043bc/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:memory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:data-fusion"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://dragan.rocks/articles/17/Clojure-Numerics-2-General-Linear-Systems-and-LU-Factorization">
    <title>Clojure Numerics, Part 2 - General Linear Systems and LU Factorization</title>
    <dc:date>2017-09-19T11:54:24+00:00</dc:date>
    <link>http://dragan.rocks/articles/17/Clojure-Numerics-2-General-Linear-Systems-and-LU-Factorization</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Solving systems of linear equations is a staple food of linear algebra. It can be applied as a part of many machine learning tasks, although it is not always obvious to spot the opportunity. Here, we explore how triangular systems are the foundation that we need to internalize well. We concentrate on computational details, and transformations of general systems to triangular systems . Neanderthal offers many functions to help us in this quest.
]]></description>
<dc:subject>Clojure linear-algebra library nudge Klapaucius-library to-do</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:f8fe3d619d46/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Clojure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:linear-algebra"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Klapaucius-library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-do"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://github.com/hswick/jutsu.ai">
    <title>hswick/jutsu.ai: Clojure wrapper for deeplearning4j</title>
    <dc:date>2017-09-19T11:38:44+00:00</dc:date>
    <link>https://github.com/hswick/jutsu.ai</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Clojure wrapper for deeplearning4j with some added syntactic sugar.

What if I told you that you could do machine learning on the JVM without wanting to cry or set your hair on fire? The goal of this library is to be the most syntactically elegant machine learning library for Clojure/Java ecosystem. jutsu.ai uses Clojure specific code idioms, like Data as Code, to create an aesthetic and declarative api.

The best of all, no more snakes!]]></description>
<dc:subject>deep-learning neural-networks Clojure library wrapper programming software-development to-understand nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2170d37cb102/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:deep-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Clojure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:wrapper"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://en.wikipedia.org/wiki/Abstract_simplicial_complex">
    <title>Abstract simplicial complex - Wikipedia</title>
    <dc:date>2017-06-03T11:23:57+00:00</dc:date>
    <link>https://en.wikipedia.org/wiki/Abstract_simplicial_complex</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In mathematics, an abstract simplicial complex is a purely combinatorial description of the geometric notion of a simplicial complex, consisting of a family of non-empty finite sets closed under the operation of taking non-empty subsets.[1] In the context of matroids and greedoids, abstract simplicial complexes are also called independence systems.[2]

]]></description>
<dc:subject>topology data-analysis data-structures nudge consider:adding-as-primitive hypergraphs to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:63bc99374ef1/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:topology"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-analysis"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-structures"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:adding-as-primitive"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:hypergraphs"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1611.04766">
    <title>[1611.04766] Differentiable Genetic Programming</title>
    <dc:date>2017-04-24T12:34:22+00:00</dc:date>
    <link>https://arxiv.org/abs/1611.04766</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We introduce the use of high order automatic differentiation, implemented via the algebra of truncated Taylor polynomials, in genetic programming. Using the Cartesian Genetic Programming encoding we obtain a high-order Taylor representation of the program output that is then used to back-propagate errors during learning. The resulting machine learning framework is called differentiable Cartesian Genetic Programming (dCGP). In the context of symbolic regression, dCGP offers a new approach to the long unsolved problem of constant representation in GP expressions. On several problems of increasing complexity we find that dCGP is able to find the exact form of the symbolic expression as well as the constants values. We also demonstrate the use of dCGP to solve a large class of differential equations and to find prime integrals of dynamical systems, presenting, in both cases, results that confirm the efficacy of our approach.
]]></description>
<dc:subject>genetic-programming algorithms rather-interesting to-write-about very-nice machine-learning symbolic-regression nudge do-this</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c7d80e34b065/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:genetic-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:very-nice"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:symbolic-regression"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:do-this"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://research.googleblog.com/2017/04/federated-learning-collaborative.html">
    <title>Research Blog: Federated Learning: Collaborative Machine Learning without Centralized Training Data</title>
    <dc:date>2017-04-17T11:19:38+00:00</dc:date>
    <link>https://research.googleblog.com/2017/04/federated-learning-collaborative.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[To make Federated Learning possible, we had to overcome many algorithmic and technical challenges. In a typical machine learning system, an optimization algorithm like Stochastic Gradient Descent (SGD) runs on a large dataset partitioned homogeneously across servers in the cloud. Such highly iterative algorithms require low-latency, high-throughput connections to the training data. But in the Federated Learning setting, the data is distributed across millions of devices in a highly uneven fashion. In addition, these devices have significantly higher-latency, lower-throughput connections and are only intermittently available for training.

These bandwidth and latency limitations motivate our Federated Averaging algorithm, which can train deep networks using 10-100x less communication compared to a naively federated version of SGD. The key idea is to use the powerful processors in modern mobile devices to compute higher quality updates than simple gradient steps. Since it takes fewer iterations of high-quality updates to produce a good model, training can use much less communication. As upload speeds are typically much slower than download speeds, we also developed a novel way to reduce upload communication costs up to another 100x by compressing updates using random rotations and quantization. While these approaches are focused on training deep networks, we've also designed algorithms for high-dimensional sparse convex models which excel on problems like click-through-rate prediction.
]]></description>
<dc:subject>architecture federated-models machine-learning algorithms nudge consider:doing-this devops rather-interesting</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1cf1155e5e52/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:federated-models"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:doing-this"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:devops"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://github.com/abscondment/clj-kdtree">
    <title>abscondment/clj-kdtree: kd-trees in Clojure</title>
    <dc:date>2017-03-25T00:00:23+00:00</dc:date>
    <link>https://github.com/abscondment/clj-kdtree</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[A Kd-tree is a special type of binary tree that partitions points in a k-dimensional space. It can be used for efficient nearest-neighbor searches.

]]></description>
<dc:subject>Clojure programming library nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:88a01ccab655/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Clojure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1208.3663">
    <title>[1208.3663] Space-Time Trade-offs for Stack-Based Algorithms</title>
    <dc:date>2017-03-23T23:26:11+00:00</dc:date>
    <link>https://arxiv.org/abs/1208.3663</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In memory-constrained algorithms we have read-only access to the input, and the number of additional variables is limited. In this paper we introduce the compressed stack technique, a method that allows to transform algorithms whose space bottleneck is a stack into memory-constrained algorithms. Given an algorithm \alg\ that runs in O(n) time using Θ(n) variables, we can modify it so that it runs in O(n2/s) time using a workspace of O(s) variables (for any s∈o(logn)) or O(nlogn/logp) time using O(plogn/logp) variables (for any 2≤p≤n). We also show how the technique can be applied to solve various geometric problems, namely computing the convex hull of a simple polygon, a triangulation of a monotone polygon, the shortest path between two points inside a monotone polygon, 1-dimensional pyramid approximation of a 1-dimensional vector, and the visibility profile of a point inside a simple polygon. Our approach exceeds or matches the best-known results for these problems in constant-workspace models (when they exist), and gives the first trade-off between the size of the workspace and running time. To the best of our knowledge, this is the first general framework for obtaining memory-constrained algorithms.
]]></description>
<dc:subject>computational-complexity algorithms stacks to-understand computational-geometry nudge to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:6464b8d066a2/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:stacks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-geometry"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1608.05347">
    <title>[1608.05347] Probabilistic Data Analysis with Probabilistic Programming</title>
    <dc:date>2017-02-25T13:51:27+00:00</dc:date>
    <link>https://arxiv.org/abs/1608.05347</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Probabilistic techniques are central to data analysis, but different approaches can be difficult to apply, combine, and compare. This paper introduces composable generative population models (CGPMs), a computational abstraction that extends directed graphical models and can be used to describe and compose a broad class of probabilistic data analysis techniques. Examples include hierarchical Bayesian models, multivariate kernel methods, discriminative machine learning, clustering algorithms, dimensionality reduction, and arbitrary probabilistic programs. We also demonstrate the integration of CGPMs into BayesDB, a probabilistic programming platform that can express data analysis tasks using a modeling language and a structured query language. The practical value is illustrated in two ways. First, CGPMs are used in an analysis that identifies satellite data records which probably violate Kepler's Third Law, by composing causal probabilistic programs with non-parametric Bayes in under 50 lines of probabilistic code. Second, for several representative data analysis tasks, we report on lines of code and accuracy measurements of various CGPMs, plus comparisons with standard baseline solutions from Python and MATLAB libraries.
]]></description>
<dc:subject>probabilistic-programming programming-language representation rather-interesting consider:representation nudge simulation stochastic-systems</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:46391a9a2994/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:probabilistic-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:simulation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:stochastic-systems"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1603.08812">
    <title>[1603.08812] Reconstruction of evolved dynamic networks from degree correlations</title>
    <dc:date>2017-01-10T13:12:56+00:00</dc:date>
    <link>https://arxiv.org/abs/1603.08812</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We study the importance of local structural properties in networks which have been evolved for a power-law scaling in their Laplacian spectrum. To this end, the degree distribution, two-point degree correlations, and degree-dependent clustering are extracted from the evolved networks and used to construct random networks with the prescribed distributions. In the analysis of these reconstructed networks it turns out that the degree distribution alone is not sufficient to generate the spectral scaling and the degree-dependent clustering has only an indirect influence. The two-point correlations are found to be the dominant characteristic for the power-law scaling over a broader eigenvalue range.
]]></description>
<dc:subject>approximation graph-theory algorithms statistics nudge consider:looking-to-see feature-extraction</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:df22dd96ebf4/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:approximation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:graph-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:statistics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:looking-to-see"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:feature-extraction"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1611.09528">
    <title>[1611.09528] Flexible Scheduling of Distributed Analytic Applications</title>
    <dc:date>2016-12-23T12:51:51+00:00</dc:date>
    <link>https://arxiv.org/abs/1611.09528</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This work addresses the problem of scheduling user-defined analytic applications, which we define as high-level compositions of frameworks, their components, and the logic necessary to carry out work. The key idea in our application definition, is to distinguish classes of components, including rigid and elastic types: the first being required for an application to make progress, the latter contributing to reduced execution times. We show that the problem of scheduling such applications poses new challenges, which existing approaches address inefficiently. 
Thus, we present the design and evaluation of a novel, flexible heuristic to schedule analytic applications, that aims at high system responsiveness, by allocating resources efficiently. Our algorithm is evaluated using trace-driven simulations, with large-scale real system traces: our flexible scheduler outperforms a baseline approach across a variety of metrics, including application turnaround times, and resource allocation efficiency. 
We also present the design and evaluation of a full-fledged system, which we have called Zoe, that incorporates the ideas presented in this paper, and report concrete improvements in terms of efficiency and performance, with respect to prior generations of our system.
]]></description>
<dc:subject>distributed-processing queueing-theory planning software-development nudge consider:performance-measures to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:40cca5b3bd7d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:queueing-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:planning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:performance-measures"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://biorxiv.org/content/early/2016/07/22/065243?rss=1%2522">
    <title>Probabilistic adaptation in changing microbial environments | bioRxiv</title>
    <dc:date>2016-07-25T20:15:28+00:00</dc:date>
    <link>http://biorxiv.org/content/early/2016/07/22/065243?rss=1%2522</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Microbes growing in animal host environments face fluctuations that have elements of both randomness and predictability. In the mammalian gut, fluctuations in nutrient levels and other physiological parameters are structured by the animal host's behavior, diet, health and microbiota composition. Microbial cells that are able to anticipate these fluctuations by exploiting this structure would likely gain a fitness advantage, by adapting their internal state in advance. We propose that the problem of adaptive growth in these structured changing environments can be viewed as probabilistic inference. We analyze environments that are "meta-changing": where there are changes in the way the environment fluctuates, governed by a mechanism unobservable to cells. We develop a dynamic Bayesian model of these environments and show that a real-time inference algorithm (particle filtering) for this model can be used as a microbial growth strategy implementable in molecular circuits. The growth strategy suggested by our model outperforms heuristic strategies, and points to a class of algorithms that could support real-time probabilistic inference in natural or synthetic cellular circuits.

]]></description>
<dc:subject>systems-biology network-theory theoretical-biology evolutionary-biology dynamical-systems robustness rather-interesting nudge consider:looking-to-see</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c7237d5a9f55/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:systems-biology"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:network-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:theoretical-biology"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:evolutionary-biology"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:dynamical-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:robustness"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:looking-to-see"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://api.slack.com/community">
    <title>Slack API: Community Built Integrations | Slack</title>
    <dc:date>2016-02-17T00:33:21+00:00</dc:date>
    <link>https://api.slack.com/community</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Many members of the Slack community have been developing their own integrations and plugins for Slack. We'll be updating this list regularly, so check back often. If you've built your own Slack integration, please get in touch and we'll add it to this list.

]]></description>
<dc:subject>slack API web-applications nudge rather-interesting consider:monitor-bot consider:dashboard-bot</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b8a23b8ae0f3/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:slack"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:API"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:web-applications"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:monitor-bot"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:dashboard-bot"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://sqlkorma.com/">
    <title>sqlkorma</title>
    <dc:date>2016-02-09T18:03:20+00:00</dc:date>
    <link>http://sqlkorma.com/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Korma is a domain specific language for Clojure that takes the pain out of working with your favorite RDBMS. Built for speed and designed for flexibility, Korma provides a simple and intuitive interface to your data that won't leave a bad taste in your mouth.
]]></description>
<dc:subject>web-design Clojure to-understand software-development nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:9a1044449682/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:web-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Clojure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1502.02389">
    <title>[1502.02389] Patterns and Rewrite Rules for Systematic Code Generation (From High-Level Functional Patterns to High-Performance OpenCL Code)</title>
    <dc:date>2015-09-06T12:09:37+00:00</dc:date>
    <link>http://arxiv.org/abs/1502.02389</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Computing systems have become increasingly complex with the emergence of heterogeneous hardware combining multicore CPUs and GPUs. These parallel systems exhibit tremendous computational power at the cost of increased programming effort. This results in a tension between achieving performance and code portability. Code is either tuned using device-specific optimizations to achieve maximum performance or is written in a high-level language to achieve portability at the expense of performance. 
We propose a novel approach that offers high-level programming, code portability and high-performance. It is based on algorithmic pattern composition coupled with a powerful, yet simple, set of rewrite rules. This enables systematic transformation and optimization of a high-level program into a low-level hardware specific representation which leads to high performance code. 
We test our design in practice by describing a subset of the OpenCL programming model with low-level patterns and by implementing a compiler which generates high performance OpenCL code. Our experiments show that we can systematically derive high-performance device-specific implementations from simple high-level algorithmic expressions. The performance of the generated OpenCL code is on par with highly tuned implementations for multicore CPUs and GPUs written by experts
]]></description>
<dc:subject>computer-science compilers nudge nudge-targets GPU rewriting-systems rather-interesting feasible</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:49d5376f4873/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:compilers"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:GPU"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rewriting-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:feasible"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1407.0900">
    <title>[1407.0900] Distance between subspaces of different dimensions</title>
    <dc:date>2015-04-11T13:36:01+00:00</dc:date>
    <link>http://arxiv.org/abs/1407.0900</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We resolve two problems regarding subspace distances that have arisen considerably often in applications: How could one define a notion of distance between (i) two linear subspaces of different dimensions, or (ii) two affine subspaces of the same dimension, in a way that generalizes the usual Grassmann distance between equidimensional linear subspaces? We show that (i) is the distance of a point to a Schubert variety, and (ii) is the distance in the Grassmannian of affine subspaces, both regarded as subvarieties in the Grassmannian. Combining (i) and (ii) yields a notion of distance between (iii) two affine subspaces of different dimensions. Aside from reducing to the usual Grassmann distance when the subspaces in (i) are equidimensional or when the affine subspaces in (ii) are linear subspaces, these distances are intrinsic and do not depend on any embedding. Furthermore, they may all be written down as concrete expressions involving principal angles and principal vectors, and are efficiently computable in numerical stable ways. We show that our results are largely independent of the Grassmann distance --- if desired, it may be substituted by any other common distance between subspaces. Central to our approach to these problem is a concrete algebraic geometric view of the Grassmannian that parallels the differential geometric perspective that is now well-established in applied and computational mathematics. A secondary goal of this article is to demonstrate that the basic algebraic geometry of Grassmannian can be just as accessible and useful to practitioners.
]]></description>
<dc:subject>mathematics geometry rather-interesting numerical-methods generalization algorithms use-for:domination-tournaments use-for:multiobjective-search nudge consider:rediscovery</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8beac427c279/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mathematics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:geometry"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:numerical-methods"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:generalization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:use-for:domination-tournaments"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:use-for:multiobjective-search"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:rediscovery"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedCreateTables.html">
    <title>Step 2: Create Example Tables - Amazon DynamoDB</title>
    <dc:date>2015-03-07T18:01:39+00:00</dc:date>
    <link>http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedCreateTables.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Suppose you want to store product information in DynamoDB. Each product you store has its own set of properties, and accordingly, you need to store different information about each of these products. DynamoDB is a NoSQL database: Except for a required common primary key, individual items in a table can have any number of attributes. This enables you to save all the product data in the same table. So you will create a ProductCatalog table that uses Id as the primary key and stores information for products such as books and bicycles in the table. Id is a numeric attribute and hash type primary key. After creating the table, in the next step you will write code to retrieve items from this table. Note that while you can retrieve an item, you cannot query the table. To query the table, the primary key must be of the hash and range type.

]]></description>
<dc:subject>Amazon nudge EC2 cloud-computing NoSQL database system-administration devops</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:5b56198c78c3/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Amazon"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:EC2"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cloud-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:NoSQL"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:database"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:system-administration"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:devops"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://scottsievert.github.io/swix/">
    <title>Swift Matrix and Machine Learning Library — swix 0.2 documentation</title>
    <dc:date>2015-02-08T13:53:11+00:00</dc:date>
    <link>http://scottsievert.github.io/swix/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Apple’s Swift is a high level language that’s asking for some numerical library to perform computation fast or at the very least easily. A way to have iOS run high-level code similar to Python or Matlab is something I’ve been waiting for, and am incredibly excited to see the results. This will make porting complex signal processing algorithms to C much easier. Porting from Python/MATLAB to C was (and is) a pain in the butt, and this library aims to make the conversion between a Python/Matlab algorithm and a mobile app simple.

]]></description>
<dc:subject>Swift swix library Accelerate-framework MacOS programming nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:22829da688f2/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Swift"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:swix"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Accelerate-framework"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:MacOS"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://swift.versify-app.com/post/usehnl/">
    <title>Swift + Linear Algebra By Example – Using the Accelerate Framework https://github.com/haginile/Sw... – Swift</title>
    <dc:date>2015-02-08T13:44:25+00:00</dc:date>
    <link>https://swift.versify-app.com/post/usehnl/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This post provides a concise tutorial on how you may use Apple's Accelerate framework with the Swift programming language to perform vector/matrix manipulations, including matrix transposes, dot products, matrix inversions, etc. A playground with these examples is available at github.com/haginile/SwiftA....

]]></description>
<dc:subject>Swift programming linear-algebra matrices library Accelerate-framework nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8006d8f6a4dd/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Swift"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:linear-algebra"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:matrices"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Accelerate-framework"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://developer.apple.com/swift/blog/?id=6">
    <title>Interacting with C Pointers - Swift Blog - Apple Developer</title>
    <dc:date>2015-02-08T13:42:46+00:00</dc:date>
    <link>https://developer.apple.com/swift/blog/?id=6</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Pointers are deeply intertwined with arrays in C, and Swift facilitates working with array-based C APIs by allowing Array to be used as a pointer argument. An immutable array value can be passed directly as a const pointer, and a mutable array can be passed as a non-const pointer argument using the & operator, just like an inout parameter. For instance, we can add two arrays a and b using the vDSP_vadd function from the Accelerate framework, writing the result to a third result array:

]]></description>
<dc:subject>Swift programming library nudge example Accelerate-framework</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:06b4feddb2a4/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Swift"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:example"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Accelerate-framework"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://developer.apple.com/library/mac/documentation/Accelerate/Reference/AccelerateFWRef/_index.html#//apple_ref/doc/uid/TP40009465">
    <title>Accelerate Framework Reference</title>
    <dc:date>2015-02-08T13:40:19+00:00</dc:date>
    <link>https://developer.apple.com/library/mac/documentation/Accelerate/Reference/AccelerateFWRef/_index.html#//apple_ref/doc/uid/TP40009465</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This document describes the Accelerate Framework, which contains C APIs for vector and matrix math, digital signal processing, large number handling, and image processing.

]]></description>
<dc:subject>nudge programming Swift big-integers algorithms library</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1fb7d961184a/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Swift"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:big-integers"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://bl.ocks.org/mbostock/7882658">
    <title>Cluster Force Layout IV</title>
    <dc:date>2014-05-06T12:09:36+00:00</dc:date>
    <link>http://bl.ocks.org/mbostock/7882658</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This variation of a clustered force layout uses D3’s circle-packing layout to initialize node positions.

]]></description>
<dc:subject>d3 javascript visualization layout clustering slurry nudge consider:UI user-interface interactivity genetic-programming</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:90a8b0d7e067/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:d3"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:javascript"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:visualization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:layout"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:clustering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:slurry"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:UI"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:user-interface"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:interactivity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:genetic-programming"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1205.4265">
    <title>[1205.4265] Quantifying synergistic mutual information</title>
    <dc:date>2014-04-19T07:58:02+00:00</dc:date>
    <link>http://arxiv.org/abs/1205.4265</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Quantifying cooperation or synergy among random variables in predicting a single target random variable is an important problem in many complex systems. We review three prior information-theoretic measures of synergy and introduce a novel synergy measure defined as the difference between the whole and the union of its parts. We apply all four measures against a suite of binary circuits to demonstrate that our measure alone quantifies the intuitive concept of synergy across all examples. We show that for our measure of synergy that independent predictors can have positive redundant information.
]]></description>
<dc:subject>information-theory statistics prediction models synergy learning-from-data nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8eeae2c1c345/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:information-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:statistics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:prediction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:models"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:synergy"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:learning-from-data"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1309.6392">
    <title>[1309.6392] Peeking Inside the Black Box: Visualizing Statistical Learning with Plots of Individual Conditional Expectation</title>
    <dc:date>2014-04-04T11:25:43+00:00</dc:date>
    <link>http://arxiv.org/abs/1309.6392</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This article presents Individual Conditional Expectation (ICE) plots, a tool for visualizing the model estimated by any supervised learning algorithm. Classical partial dependence plots (PDPs) help visualize the average partial relationship between the predicted response and one or more features. In the presence of substantial interaction effects, the partial response relationship can be heterogeneous. Thus, an average curve, such as the PDP, can obfuscate the complexity of the modeled relationship. Accordingly, ICE plots refine the partial dependence plot by graphing the functional relationship between the predicted response and the feature for individual observations. Specifically, ICE plots highlight the variation in the fitted values across the range of a covariate, suggesting where and to what extent heterogeneities might exist. In addition to providing a plotting suite for exploratory analysis, we include a visual test for additive structure in the data generating model. Through simulated examples and real data sets, we demonstrate how ICE plots can shed light on estimated models in ways PDPs cannot. Procedures outlined are available in the R package ICEbox.
]]></description>
<dc:subject>visualization algorithms machine-learning performance-measure instrumentation nudge similar-to:DataModeler</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:96b7020f7303/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:visualization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-measure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:instrumentation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:similar-to:DataModeler"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1301.7738">
    <title>[1301.7738] PyPLN: a Distributed Platform for Natural Language Processing</title>
    <dc:date>2013-04-26T22:38:00+00:00</dc:date>
    <link>http://arxiv.org/abs/1301.7738</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This paper presents a distributed platform for Natural Language Processing called PyPLN. PyPLN leverages a vast array of NLP and text processing open source tools, managing the distribution of the workload on a variety of configurations: from a single server to a cluster of linux servers. PyPLN is developed using Python 2.7.3 but makes it very easy to incorporate other softwares for specific tasks as long as a linux version is available. PyPLN facilitates analyses both at document and corpus level, simplifying management and publication of corpora and analytical results through an easy to use web interface. In the current (beta) release, it supports English and Portuguese languages with support to other languages planned for future releases. To support the Portuguese language PyPLN uses the PALAVRAS parser\citep{Bick2000}. Currently PyPLN offers the following features: Text extraction with encoding normalization (to UTF-8), part-of-speech tagging, token frequency, semantic annotation, n-gram extraction, word and sentence repertoire, and full-text search across corpora. The platform is licensed as GPL-v3.
]]></description>
<dc:subject>natural-language-processing library Python nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:dd48a2a4891c/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:natural-language-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Python"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1303.7032">
    <title>[1303.7032] A Massively Parallel Associative Memory Based on Sparse Neural Networks</title>
    <dc:date>2013-04-08T20:15:54+00:00</dc:date>
    <link>http://arxiv.org/abs/1303.7032</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Associative memories store content in such a way that the content can be later retrieved by presenting the memory with a small portion of the content, rather than presenting the memory with an address as in more traditional memories. Associative memories are used as building blocks for algorithms within database engines, anomaly detection systems, compression algorithms, and face recognition systems. The classical example of an associative memory is the Hopfield neural network. Recently, Gripon and Berrou have introduced an alternative construction which builds on ideas from the theory of error correcting codes and which greatly outperforms the Hopfield network in capacity, diversity, and efficiency. In this paper we implement a variation of the Gripon-Berrou associative memory on a general purpose graphical processing unit (GPU). The work of Gripon and Berrou proposes two retrieval rules, sum-of-sum and sum-of-max. The sum-of-sum rule uses only matrix-vector multiplication and is easily implemented on the GPU. The sum-of-max rule is much less straightforward to implement because it involves non-linear operations. However, the sum-of-max rule gives significantly better retrieval error rates. We propose a hybrid rule tailored for implementation on a GPU which achieves a 760-fold speedup without sacrificing any accuracy.]]></description>
<dc:subject>neural-networks emergent-design associative-memory learning-by-doing algorithms nudge-targets nudge reminds-me-of-that-dude-at-SFI</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:e0328dc88ecc/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:emergent-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:associative-memory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:learning-by-doing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:reminds-me-of-that-dude-at-SFI"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://numericjs.com/">
    <title>Numeric Javascript</title>
    <dc:date>2013-02-17T12:59:56+00:00</dc:date>
    <link>http://numericjs.com/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The Numeric Javascript library allows you to perform sophisticated numerical computations in pure javascript in the browser and elsewhere.
]]></description>
<dc:subject>javascript numerical-methods library nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8cf46e58d0ca/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:javascript"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:numerical-methods"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.scipirate.com/2012/11/finding-meaningful-clusters-in-phylogenetic-trees-or-other-hierarchical-clusterings/">
    <title>Finding meaningful clusters in phylogenetic trees (or other hierarchical clusterings).</title>
    <dc:date>2012-11-07T23:28:44+00:00</dc:date>
    <link>http://www.scipirate.com/2012/11/finding-meaningful-clusters-in-phylogenetic-trees-or-other-hierarchical-clusterings/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["The prolific Mattias Prosperi (9 publications in the first 9 months of 2012) has proposed a method for automatically partitioning phylogenetic trees of pathogens into transmission clusters. The intuition is that a group of pathogens represent a transmission cluster if their sequences are monophyletic and more closely related than those from two randomly selected individuals."]]></description>
<dc:subject>statistics clustering nudge performance-space-analysis</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:0d0a55010337/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:statistics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:clustering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-space-analysis"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1207.4598">
    <title>[1207.4598] Quick HyperVolume</title>
    <dc:date>2012-08-12T13:53:44+00:00</dc:date>
    <link>http://arxiv.org/abs/1207.4598</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["We present a new algorithm for calculating exact hypervolumes, QHV. Given a set of d-dimensional points this algorithm determines the hypervolume of the dominated space. This value is useful for comparing the performance of multiobjective optimizers, a subroutine in Multiobjective Evolutionary Algorithms (MOEAs). We analyze QHV both theoretically and experimentally. It achieves state of the art performance, compared with other exact hypervolume algorithms. Hence QHV is an important algorithm for MOEAs, it is fast and simple, even when considering a large number of objectives."]]></description>
<dc:subject>algorithms multiobjective-optimization computational-geometry nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:677a9996790b/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:multiobjective-optimization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-geometry"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1207.1253">
    <title>[1207.1253] Interpolating between Random Walks and Shortest Paths: a Path Functional Approach</title>
    <dc:date>2012-08-12T13:15:24+00:00</dc:date>
    <link>http://arxiv.org/abs/1207.1253</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["General models of network navigation must contain a deterministic or drift component, encouraging the agent to follow routes of least cost, as well as a random of diffusive component, enabling free wandering. This paper proposes a thermodynamic formalism involving two path functionals, namely an energy functional governing the drift and an entropy functional governing the diffusion. A freely adjustable parameter, the temperature, arbitrates between the conflicting objectives of minimising travel costs and maximising spatial exploration. The theory is illustrated on various graphs and various temperatures. The resulting optimal paths, together with presumably new associated edges and nodes centrality indices, are analytically and numerically investigated."]]></description>
<dc:subject>fitness-landscapes network-theory useful-parametrization exploration exploitation models-of-search nudge for-the-book</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:0569c825fce2/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:fitness-landscapes"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:network-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:useful-parametrization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:exploration"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:exploitation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:models-of-search"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:for-the-book"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1206.3552">
    <title>[1206.3552] A Classification for Community Discovery Methods in Complex Networks</title>
    <dc:date>2012-06-22T11:46:56+00:00</dc:date>
    <link>http://arxiv.org/abs/1206.3552</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["In the last few years many real-world networks have been found to show a so-called community structure organization. Much effort has been devoted in the literature to develop methods and algorithms that can efficiently highlight this hidden structure of the network, traditionally by partitioning the graph. Since network representation can be very complex and can contain different variants in the traditional graph model, each algorithm in the literature focuses on some of these properties and establishes, explicitly or implicitly, its own definition of community. According to this definition it then extracts the communities that are able to reflect only some of the features of real communities. The aim of this survey is to provide a manual for the community discovery problem. Given a meta definition of what a community in a social network is, our aim is to organize the main categories of community discovery based on their own definition of community. Given a desired definition of community and the features of a problem (size of network, direction of edges, multidimensionality, and so on) this review paper is designed to provide a set of approaches that researchers could focus on."]]></description>
<dc:subject>via:cshalizi graph-theory community classification algorithms nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:6ed8f7671083/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:cshalizi"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:graph-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:community"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:classification"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1206.3555">
    <title>[1206.3555] A Dynamic Programming Algorithm for Inference in Recursive Probabilistic Programs</title>
    <dc:date>2012-06-19T11:52:08+00:00</dc:date>
    <link>http://arxiv.org/abs/1206.3555</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["We describe a dynamic programming algorithm for computing the marginal distribution of discrete probabilistic programs. This algorithm takes a functional interpreter for an arbitrary probabilistic programming language and turns it into an efficient marginalizer. Because direct caching of sub-distributions is impossible in the presence of recursion, we build a graph of dependencies between sub-distributions. This factored sum-product network makes (potentially cyclic) dependencies between subproblems explicit, and corresponds to a system of equations for the marginal distribution. We solve these equations by fixed-point iteration in topological order. We illustrate this algorithm on examples used in teaching probabilistic models, computational cognitive science research, and game theory."]]></description>
<dc:subject>recursion stochastic-programming simulation nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1910b30f024d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:recursion"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:stochastic-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:simulation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://geneura.wordpress.com/2012/04/15/pool-based-evolutionary-algorithm-presented-in-evostar-2012/">
    <title>Pool based evolutionary algorithm presented in EvoStar 2012 « GeNeura Team</title>
    <dc:date>2012-04-15T11:46:00+00:00</dc:date>
    <link>http://geneura.wordpress.com/2012/04/15/pool-based-evolutionary-algorithm-presented-in-evostar-2012/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["This is the first internationally published paper (it was previously published in a Spanish conference of a series that deals with a system, intended for volunteer computing, that uses a pool for implementing distributed evolutionary algorithms. The basic idea is that the population resides in a pool (implemented using CouchDB), with clients pulling individuals from the pool, doing stuff on them, and putting them back in the pool. The algorithm uses, as much as possible, CouchDB features (such as revisions and views) to achieve good performance. All the code (for this and, right now, for the next papers) is available as open-source code."]]></description>
<dc:subject>distributed-processing evolutionary-algorithms CouchDB nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:03e780dfc566/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:evolutionary-algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:CouchDB"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1201.6583">
    <title>[1201.6583] Empowerment for Continuous Agent-Environment Systems</title>
    <dc:date>2012-02-02T12:39:51+00:00</dc:date>
    <link>http://arxiv.org/abs/1201.6583</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["This paper develops generalizations of empowerment to continuous states. Empowerment is a recently introduced information-theoretic quantity motivated by hypotheses about the efficiency of the sensorimotor loop in biological organisms, but also from considerations stemming from curiosity-driven learning. Empowemerment measures, for agent-environment systems with stochastic transitions, how much influence an agent has on its environment, but only that influence that can be sensed by the agent sensors. It is an information-theoretic generalization of joint controllability (influence on environment) and observability (measurement by sensors) of the environment by the agent, both controllability and observability being usually defined in control theory as the dimensionality of the control/observation spaces.…"]]></description>
<dc:subject>agent-based emergent-design robotics engineering-design machine-learning empowerment nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:fb95c8f9f71f/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:agent-based"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:emergent-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:robotics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:empowerment"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1201.5568">
    <title>[1201.5568] Dynamic trees for streaming and massive data contexts</title>
    <dc:date>2012-01-30T21:11:20+00:00</dc:date>
    <link>http://arxiv.org/abs/1201.5568</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Data collection at a massive scale is becoming ubiquitous in a wide variety of settings, from vast offline databases to streaming real-time information. Learning algorithms deployed in such contexts must rely on single-pass inference, where the data history is never revisited. In streaming contexts, learning must also be temporally adaptive to remain up-to-date against unforeseen changes in the data generating mechanism. Although rapidly growing, the online Bayesian inference literature remains challenged by massive data and transient, evolving data streams. Non-parametric modelling techniques can prove particularly ill-suited, as the complexity of the model is allowed to increase with the sample size. In this work, we take steps to overcome these challenges by porting standard streaming techniques, like data discarding and downweighting, into a fully Bayesian framework via the use of informative priors and active learning heuristics. We showcase our methods by augmenting a modern non-parametric modelling framework, dynamic trees, and illustrate its performance on a number of practical examples. The end product is a powerful streaming regression and classification tool, whose performance compares favourably to the state-of-the-art."]]></description>
<dc:subject>data-analysis learning-from-data algorithms drinking-from-the-firehose nudge data-mining</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:3f6d28022889/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-analysis"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:learning-from-data"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:drinking-from-the-firehose"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-mining"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.nsl.com/k/xy/xy.htm">
    <title>The Concatenative Language XY</title>
    <dc:date>2012-01-11T21:35:32+00:00</dc:date>
    <link>http://www.nsl.com/k/xy/xy.htm</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[XY is a family of array-oriented, concatenative programming languages with first-class continuations. XY 1 has quotations, lists, functions, and patterns. XY 2 is flat. XY 0 has quotations and shuffle-symbols but dispenses with lists and patterns.

]]></description>
<dc:subject>programming esoterica stack-based nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:a7820df72ae2/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:esoterica"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:stack-based"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1109.1275">
    <title>[1109.1275] A Formal Verification Approach to the Design of Synthetic Gene Networks</title>
    <dc:date>2011-10-04T12:38:00+00:00</dc:date>
    <link>http://arxiv.org/abs/1109.1275</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["The design of genetic networks with specific functions is one of the major goals of synthetic biology. However, constructing biological devices that work "as required" remains challenging, while the cost of uncovering flawed designs experimentally is large. To address this issue, we propose a fully automated framework that allows the correctness of synthetic gene networks to be formally verified in silico from rich, high level functional specifications. 
Given a device, we automatically construct a mathematical model from experimental data characterizing the parts it is composed of. The specific model structure guarantees that all experimental observations are captured and allows us to construct finite abstractions through polyhedral operations. The correctness of the model with respect to temporal logic specifications can then be verified automatically using methods inspired by model checking. 
Overall, our procedure is conservative but it can filter through a large number of potential device designs and select few that satisfy the specification to be implemented and tested further experimentally. Illustrative examples of the application of our methods to the design of simple synthetic gene networks are included."]]></description>
<dc:subject>genetic-regulatory-networks bioinformatics biological-engineering design-automation emergent-design acceptance-testing performance-measure nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:e609dd245f20/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:genetic-regulatory-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:bioinformatics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:biological-engineering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design-automation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:emergent-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:acceptance-testing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-measure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Strings/introStrings.html#//apple_ref/doc/uid/10000035i">
    <title>String Programming Guide: Introduction to String Programming Guide for Cocoa</title>
    <dc:date>2011-09-02T22:31:12+00:00</dc:date>
    <link>http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Strings/introStrings.html#//apple_ref/doc/uid/10000035i</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[does what it says]]></description>
<dc:subject>programming objective-c library strings nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:783d4d87e35c/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:objective-c"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:strings"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html#//apple_ref/doc/uid/TP40008048-CH102">
    <title>Objective-C Runtime Programming Guide: Dynamic Method Resolution</title>
    <dc:date>2011-08-26T20:40:56+00:00</dc:date>
    <link>http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html#//apple_ref/doc/uid/TP40008048-CH102</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["…There are situations where you might want to provide an implementation of a method dynamically.…"]]></description>
<dc:subject>objective-c programming nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:79ad88d84157/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:objective-c"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://parsekit.com/">
    <title>ParseKit - Cocoa Objective-C Framework for parsing, tokenizing and language processing</title>
    <dc:date>2011-08-26T19:30:38+00:00</dc:date>
    <link>http://parsekit.com/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["ParseKit is a Mac OS X Framework written by Todd Ditchendorf in Objective-C 2.0 and released under the MIT Open Source License. ParseKit is suitable for use on Mac OS X Leopard, Snow Leopard or iPhone OS. ParseKit is an Objective-C implementation of the tools described in "Building Parsers with Java" by Steven John Metsker. ParseKit includes additional features beyond the designs from the book and also some changes to match common Cocoa/Objective-C conventions. These changes are relatively superficial, however, and Metsker's book is the best documentation available for ParseKit."]]></description>
<dc:subject>parsing objective-c framework xcode mac nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1142f1d68f83/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:parsing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:objective-c"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:framework"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:xcode"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mac"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://stackoverflow.com/questions/6296758/integrating-bison-flex-yacc-into-xcode">
    <title>objective c - Integrating Bison/Flex/Yacc into XCode - Stack Overflow</title>
    <dc:date>2011-08-26T19:28:38+00:00</dc:date>
    <link>http://stackoverflow.com/questions/6296758/integrating-bison-flex-yacc-into-xcode</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["In a nutshell, give your grammar files a .ym extension instead of .y. Xcode will then run Bison with the necessary magic to support Objective-C."]]></description>
<dc:subject>programming objective-c parsing nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:6801b54a9c23/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:objective-c"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:parsing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1108.4220">
    <title>[1108.4220] A Dynamical Systems Approach for Static Evaluation in Go</title>
    <dc:date>2011-08-25T13:22:52+00:00</dc:date>
    <link>http://arxiv.org/abs/1108.4220</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["In the paper arguments are given why the concept of static evaluation has the potential to be a useful extension to Monte Carlo tree search. A new concept of modeling static evaluation through a dynamical system is introduced and strengths and weaknesses are discussed. The general suitability of this approach is demonstrated."]]></description>
<dc:subject>representation-theory planning monte-carlo-models nudge algorithms</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:4c146f1ef8b6/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:planning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:monte-carlo-models"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1106.1821">
    <title>[1106.1821] Collective Intelligence, Data Routing and Braess' Paradox</title>
    <dc:date>2011-08-25T12:34:19+00:00</dc:date>
    <link>http://arxiv.org/abs/1106.1821</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["We consider the problem of designing the the utility functions of the utility-maximizing agents in a multi-agent system so that they work synergistically to maximize a global utility. The particular problem domain we explore is the control of network routing by placing agents on all the routers in the network. Conventional approaches to this task have the agents all use the Ideal Shortest Path routing Algorithm (ISPA). We demonstrate that in many cases, due to the side-effects of one agent's actions on another agent's performance, having agents use ISPA's is suboptimal as far as global aggregate cost is concerned, even when they are only used to route infinitesimally small amounts of traffic. The utility functions of the individual agents are not "aligned" with the global utility, intuitively speaking. As a particular example of this we present an instance of Braess' paradox in which adding new links to a network whose agents all use the ISPA results in a decrease in overall throughput. We also demonstrate that load-balancing, in which the agents' decisions are collectively made to optimize the global cost incurred by all traffic currently being routed, is suboptimal as far as global cost averaged across time is concerned. This is also due to 'side-effects', in this case of current routing decision on future traffic. The mathematics of Collective Intelligence (COIN) is concerned precisely with the issue of avoiding such deleterious side-effects in multi-agent systems, both over time and space. We present key concepts from that mathematics and use them to derive an algorithm whose ideal version should have better performance than that of having all agents use the ISPA, even in the infinitesimal limit. We present experiments verifying this, and also showing that a machine-learning-based version of this COIN algorithm in which costs are only imprecisely estimated via empirical means (a version potentially applicable in the real world) also outperforms the ISPA, despite having access to less information than does the ISPA. In particular, this COIN algorithm almost always avoids Braess' paradox."]]></description>
<dc:subject>collective-intelligence search-algorithms figure-ground-error planning nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:a49efddcb62d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:collective-intelligence"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:search-algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:figure-ground-error"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:planning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1106.1816">
    <title>[1106.1816] Monitoring Teams by Overhearing: A Multi-Agent Plan-Recognition Approach</title>
    <dc:date>2011-08-25T11:21:30+00:00</dc:date>
    <link>http://arxiv.org/abs/1106.1816</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Recent years are seeing an increasing need for on-line monitoring of teams of cooperating agents, e.g., for visualization, or performance tracking. However, in monitoring deployed teams, we often cannot rely on the agents to always communicate their state to the monitoring system. This paper presents a non-intrusive approach to monitoring by 'overhearing', where the monitored team's state is inferred (via plan-recognition) from team-members' routine communications, exchanged as part of their coordinated task execution, and observed (overheard) by the monitoring system. Key challenges in this approach include the demanding run-time requirements of monitoring, the scarceness of observations (increasing monitoring uncertainty), and the need to scale-up monitoring to address potentially large teams. To address these, we present a set of complementary novel techniques, exploiting knowledge of the social structures and procedures in the monitored team: (i) an efficient probabilistic plan-recognition algorithm, well-suited for processing communications as observations; (ii) an approach to exploiting knowledge of the team's social behavior to predict future observations during execution (reducing monitoring uncertainty); and (iii) monitoring algorithms that trade expressivity for scalability, representing only certain useful monitoring hypotheses, but allowing for any number of agents and their different activities to be represented in a single coherent entity. We present an empirical evaluation of these techniques, in combination and apart, in monitoring a deployed team of agents, running on machines physically distributed across the country, and engaged in complex, dynamic task execution. We also compare the performance of these techniques to human expert and novice monitors, and show that the techniques presented are capable of monitoring at human-expert levels, despite the difficulty of the task."]]></description>
<dc:subject>emergent-design agent-based swarms coordination nudge</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1f1e603f62c5/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:emergent-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:agent-based"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:swarms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:coordination"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.latrobe.edu.au/philosophy/phimvt/joy.html">
    <title>Main page for the programming language JOY</title>
    <dc:date>2010-11-07T12:59:43+00:00</dc:date>
    <link>http://www.latrobe.edu.au/philosophy/phimvt/joy.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[a charming little language for GP, introduced to me by Maarten Keijzer "… Various introductions to Joy / Papers on Joy / The C sources and the Joy libraries…"
]]></description>
<dc:subject>joy-language programming LISP functional-programming nudge duck</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:90de4e49e749/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:joy-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:LISP"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:functional-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:duck"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://tunes.org/~iepos/joy.html">
    <title>The Theory of Concatenative Combinators</title>
    <dc:date>2010-11-07T11:52:25+00:00</dc:date>
    <link>http://tunes.org/~iepos/joy.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["This article attempts to outline, in informal terms, a new theory of combinators, related to the theory of Combinatory Logic pioneered by Moses Schonfinkel, Haskell Curry, and others in the 1930s. Although not essential, an understanding of the classical theory of combinators may be helpful (see the links at the bottom of this article for some introductory material to combinators)."
]]></description>
<dc:subject>nudge duck programming-language algorithms combinators mathematical-recreations bestiary</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:5989c921ecf2/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:duck"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:combinators"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:mathematical-recreations"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:bestiary"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.jstree.com/">
    <title>jsTree » Home</title>
    <dc:date>2010-10-12T19:43:59+00:00</dc:date>
    <link>http://www.jstree.com/</link>
    <dc:creator>Vaguery</dc:creator><dc:subject>user-interface jQuery library a-bit-small-to-be-a-stormtrooper nudge via:arthegall</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:4c224e17b543/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:user-interface"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:jQuery"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:a-bit-small-to-be-a-stormtrooper"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:arthegall"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.miller-mccune.com/culture-society/triumph-of-the-cyborg-composer-8507/">
    <title>Triumph of the Cyborg Composer | Miller-McCune Online</title>
    <dc:date>2010-09-05T12:44:06+00:00</dc:date>
    <link>http://www.miller-mccune.com/culture-society/triumph-of-the-cyborg-composer-8507/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[“Nobody’s original,” Cope says. “We are what we eat, and in music, we are what we hear. What we do is look through history and listen to music. Everybody copies from everybody. The skill is in how large a fragment you choose to copy and how elegantly you can put them together.”
]]></description>
<dc:subject>via:tsuomela creativity cultural-assumptions generative-art music composition nudge engineering-design aesthetic-norms</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:195f2d629e85/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:tsuomela"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:creativity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cultural-assumptions"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:generative-art"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:music"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:composition"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:aesthetic-norms"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/0807.1271">
    <title>[0807.1271] Semiparametric curve alignment and shift density estimation for biological data</title>
    <dc:date>2010-08-17T12:35:55+00:00</dc:date>
    <link>http://arxiv.org/abs/0807.1271</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Assume that we observe a large number of curves, all of them with identical, although unknown, shape, but with a different random shift. The objective is to estimate the individual time shifts and their distribution. Such an objective appears in several biological applications like neuroscience or ECG signal processing, in which the estimation of the distribution of the elapsed time between repetitive pulses with a possibly low signal-noise ratio, and without a knowledge of the pulse shape is of interest. We suggest an M-estimator leading to a three-stage algorithm: we split our data set in blocks, on which the estimation of the shifts is done by minimizing a cost criterion based on a functional of the periodogram; the estimated shifts are then plugged into a standard density estimator. We show that under mild regularity assumptions the density estimate converges weakly to the true shift distribution. The theory is applied both to simulations and to alignment of real ECG signals.…"
]]></description>
<dc:subject>data-analysis statistics algorithms heuristics exploratory-data-analysis nudge optimization classification time-series</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:65100c43f167/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-analysis"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:statistics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:heuristics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:exploratory-data-analysis"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:optimization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:classification"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:time-series"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://opencv.willowgarage.com/wiki/">
    <title>Welcome - OpenCV Wiki</title>
    <dc:date>2010-08-12T23:09:35+00:00</dc:date>
    <link>http://opencv.willowgarage.com/wiki/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["OpenCV (Open Source Computer Vision) is a library of programming functions for real time computer vision.

OpenCV is released under a BSD license, it is free for both academic and commercial use.
The library has >500 optimized algorithms (see figure below). It is used around the world, has >2M downloads and >40K people in the user group. Uses range from interactive art, to mine inspection, stitching maps on the web on through advanced robotics."
]]></description>
<dc:subject>image-processing computer-vision library open-source nudge scientific-computing</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:6164e8685951/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:image-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computer-vision"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:open-source"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:scientific-computing"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1007.5475">
    <title>[1007.5475] Balanced Combinations of Solutions in Multi-Objective Optimization</title>
    <dc:date>2010-08-03T13:12:37+00:00</dc:date>
    <link>http://arxiv.org/abs/1007.5475</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["For every list of integers x_1, ..., x_m there is some j such that x_1 + ... + x_j - x_{j+1} - ... - x_m \approx 0. So the list can be nearly balanced and for this we only need one alternation between addition and subtraction. But what if the x_i are k-dimensional integer vectors? Using results from topological degree theory we show that balancing is still possible, now with k alternations. 
This result is useful in multi-objective optimization, as it allows a polynomial-time computable balance of two alternatives with conflicting costs. The application to two multi-objective optimization problems yields the following results: 
- A randomized 1/2-approximation for multi-objective maximum asymmetric traveling salesman, which improves and simplifies the best known approximation for this problem. 
- A deterministic 1/2-approximation for multi-objective maximum weighted satisfiability."
]]></description>
<dc:subject>multiobjective-optimization operations-research nudge algorithms</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:329204f6f1e4/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:multiobjective-optimization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:operations-research"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.rubyflow.com/items/4256?utm_source=feedburner&amp;utm_medium=feed&amp;utm_campaign=Feed%3A+Rubyflow+(RubyFlow)">
    <title>Unveil.js is a data exploration and visualization toolkit that utilizes data-driven software design. : RubyFlow</title>
    <dc:date>2010-07-28T13:04:21+00:00</dc:date>
    <link>http://www.rubyflow.com/items/4256?utm_source=feedburner&amp;utm_medium=feed&amp;utm_campaign=Feed%3A+Rubyflow+(RubyFlow)</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["It features generic data abstraction through Collections, a Visualization API allowing the creation of pluggable visualizations, and a Scene Graph implementation on top of HTML 5 Canvas. See the GitHub project, the documentation, and an example."
]]></description>
<dc:subject>visualization javascript library exploratory-data-analysis data-driven nudge</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:607c50e0770c/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:visualization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:javascript"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:exploratory-data-analysis"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-driven"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
</rdf:RDF>