<?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://arxiv.org/abs/2504.08106"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2212.04320"/>
	<rdf:li rdf:resource="https://www.amazingcto.com/postgres-for-everything/"/>
	<rdf:li rdf:resource="https://www.youtube.com/watch?v=EIISnE3GPJk"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2111.02607"/>
	<rdf:li rdf:resource="https://www.messynessychic.com/2022/04/12/how-america-became-enamoured-with-octagon-houses/"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2109.07683"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1906.04358"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2011.02712"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/2012.09229"/>
	<rdf:li rdf:resource="https://www.jeremydaly.com/serverless-microservice-patterns-for-aws/"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1902.10486"/>
	<rdf:li rdf:resource="https://cloud.google.com/blog/products/application-development/api-design-why-you-should-use-links-not-keys-to-represent-relationships-in-apis"/>
	<rdf:li rdf:resource="https://www.mnot.net/blog/2019/10/13/h2_api_multiplexing"/>
	<rdf:li rdf:resource="https://link.springer.com/article/10.1007/s00004-012-0127-3"/>
	<rdf:li rdf:resource="https://link.springer.com/journal/volumesAndIssues/4"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1808.09357"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1803.09574"/>
	<rdf:li rdf:resource="https://kubernetes.io/docs/tasks/job/fine-parallel-processing-work-queue/"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1801.05895"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.07056"/>
	<rdf:li rdf:resource="https://colah.github.io/posts/2015-08-Understanding-LSTMs/"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.06309"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1702.08835"/>
	<rdf:li rdf:resource="https://blog.intercom.com/why-cards-are-the-future-of-the-web/"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1709.05769"/>
	<rdf:li rdf:resource="https://mitpress.mit.edu/books/architectural-intelligence"/>
	<rdf:li rdf:resource="https://www.youtube.com/watch?v=rMd6-IS3cmU&amp;app=desktop"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1608.06993"/>
	<rdf:li rdf:resource="https://research.googleblog.com/2017/04/federated-learning-collaborative.html"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1704.00764"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1611.03530"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1611.02163"/>
	<rdf:li rdf:resource="https://martinfowler.com/articles/serverless.html"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1506.02640"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1506.08448"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1610.01945"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1610.01588"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1605.06431"/>
	<rdf:li rdf:resource="https://arxiv.org/abs/1610.08613"/>
	<rdf:li rdf:resource="http://www.asimovinstitute.org/neural-network-zoo/"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1505.05972"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1606.02492"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1506.04834"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1501.04870"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1507.06228"/>
	<rdf:li rdf:resource="https://vimeo.com/131823232"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1506.03134"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1503.02368"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1407.6470"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1411.5127"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1408.2874"/>
	<rdf:li rdf:resource="http://biorxiv.org/content/early/2014/10/08/010124"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1408.1245"/>
	<rdf:li rdf:resource="http://www.metropolismag.com/Point-of-View/January-2014/In-Photos-Eero-Saarinens-Bell-Labs/"/>
	<rdf:li rdf:resource="http://think-info.com/2013/06/27/author-experience/"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1304.7118"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1302.1554"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1211.5842"/>
	<rdf:li rdf:resource="http://arxiv.org/abs/1105.0322"/>
	<rdf:li rdf:resource="https://github.com/celluloid/celluloid"/>
	<rdf:li rdf:resource="http://www.archiparlour.org/worklifework-balance/"/>
	<rdf:li rdf:resource="http://caines.ca/blog/programming/the-sun-is-setting-on-rails-style-mvc-frameworks/"/>
	<rdf:li rdf:resource="http://faye.jcoglan.com/"/>
	<rdf:li rdf:resource="http://www.worldchanging.com/archives/011242.html?utm_source=feedburner&amp;utm_medium=feed&amp;utm_campaign=Feed%3A+worldchanging_fulltext+(WorldChanging.com+Full+Text)"/>
	<rdf:li rdf:resource="http://malvasiabianca.org/archives/2010/04/christopher-alexanders-fort-mason-bench/"/>
	<rdf:li rdf:resource="http://robots.thoughtbot.com/post/443934722/redis-data-cheeseburgers#disqus_thread"/>
	<rdf:li rdf:resource="http://code.google.com/apis/sketchup/"/>
	<rdf:li rdf:resource="http://wonderfullyflawed.com/2009/07/02/get-your-api-right/"/>
	<rdf:li rdf:resource="https://www.cloudkick.com/blog/2010/mar/02/4_months_with_cassandra/"/>
      </rdf:Seq>
    </items>
  </channel><item rdf:about="https://arxiv.org/abs/2504.08106">
    <title>[2504.08106] A Case Study on Evaluating Genetic Algorithms for Early Building Design Optimization: Comparison with Random and Grid Searches</title>
    <dc:date>2025-08-17T12:55:43+00:00</dc:date>
    <link>https://arxiv.org/abs/2504.08106</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In early-stage architectural design, optimization algorithms are essential for efficiently exploring large and complex design spaces under tight computational constraints. While prior research has benchmarked various optimization methods, their findings often lack generalizability to real-world, domain-specific problems, particularly in early building design optimization for energy performance. This study evaluates the effectiveness of Genetic Algorithms (GAs) for early design optimization, focusing on their ability to find near-optimal solutions within limited timeframes. Using a constrained case study, we compare a simple GA to two baseline methods, Random Search (RS) and Grid Search (GS), with each algorithm tested 10 times to enhance the reliability of the conclusions. Our findings show that while RS may miss optimal solutions due to its stochastic nature, it was unexpectedly effective under tight computational limits. Despite being more systematic, GS was outperformed by RS, likely due to the irregular design search space. This suggests that, under strict computational constraints, lightweight methods like RS can sometimes outperform more complex approaches like GA. As this study is limited to a single case under specific constraints, future research should investigate a broader range of design scenarios and computational settings to validate and generalize the findings. Additionally, the potential of Random Search or hybrid optimization methods should be further investigated, particularly in contexts with strict computational limitations.
]]></description>
<dc:subject>engineering-design genetic-algorithm horse-races no-free-lunch to-write-about object-lessons architecture</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:43ecf2102fe1/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:genetic-algorithm"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:horse-races"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:no-free-lunch"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:object-lessons"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2212.04320">
    <title>[2212.04320] A 65nm 8b-Activation 8b-Weight SRAM-Based Charge-Domain Computing-in-Memory Macro Using A Fully-Parallel Analog Adder Network and A Single-ADC Interface</title>
    <dc:date>2024-11-01T19:14:15+00:00</dc:date>
    <link>https://arxiv.org/abs/2212.04320</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Performing data-intensive tasks in the von Neumann architecture is challenging to achieve both high performance and power efficiency due to the memory wall bottleneck. Computing-in-memory (CiM) is a promising mitigation approach by enabling parallel in-situ multiply-accumulate (MAC) operations within the memory with support from the peripheral interface and datapath. SRAM-based charge-domain CiM (CD-CiM) has shown its potential of enhanced power efficiency and computing accuracy. However, existing SRAM-based CD-CiM faces scaling challenges to meet the throughput requirement of high-performance multi-bit-quantization applications. This paper presents an SRAM-based high-throughput ReLU-optimized CD-CiM macro. It is capable of completing MAC and ReLU of two signed 8b vectors in one CiM cycle with only one A/D conversion. Along with non-linearity compensation for the analog computing and A/D conversion interfaces, this work achieves 51.2GOPS throughput and 10.3TOPS/W energy efficiency, while showing 88.6% accuracy in the CIFAR-10 dataset.
]]></description>
<dc:subject>algorithms computer-science architecture to-understand unconventional-computing acceleration computational-complexity consider:genetic-programming</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c7c2b27eeb14/</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:computer-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:unconventional-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:acceleration"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:computational-complexity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:genetic-programming"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.amazingcto.com/postgres-for-everything/">
    <title>Just Use Postgres for Everything | Amazing CTO</title>
    <dc:date>2024-08-14T20:05:39+00:00</dc:date>
    <link>https://www.amazingcto.com/postgres-for-everything/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[TLDR; just Postgres for everything.

]]></description>
<dc:subject>via:several software-development-is-not-programming architecture databases Postgres statefulness</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:d82432b288ff/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:several"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development-is-not-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:databases"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Postgres"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:statefulness"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.youtube.com/watch?v=EIISnE3GPJk">
    <title>We Have to Reimagine Our World | Architect Indy Johar | Louisiana Channel - YouTube</title>
    <dc:date>2024-05-18T00:16:06+00:00</dc:date>
    <link>https://www.youtube.com/watch?v=EIISnE3GPJk</link>
    <dc:creator>Vaguery</dc:creator><dc:subject>decentralization architecture design many-to-many-contracts rather-interesting via:? collaboration rethinking</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:067a11626477/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:decentralization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:many-to-many-contracts"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:?"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:collaboration"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rethinking"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2111.02607">
    <title>[2111.02607] Constrained Form-Finding of Tension-Compression Structures using Automatic Differentiation</title>
    <dc:date>2023-09-09T22:43:50+00:00</dc:date>
    <link>https://arxiv.org/abs/2111.02607</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This paper proposes a computational approach to form-find pin-jointed, bar structures subjected to combinations of tension and compression forces. The generated equilibrium states can meet force and geometric constraints via gradient-based optimization. We achieve this by extending the combinatorial equilibrium modeling (CEM) framework in three important ways. First, we introduce a new topological object, the auxiliary trail, to expand the range of structures that can be form-found with the framework. Then, we leverage automatic differentiation (AD) to obtain an exact value of the gradient of the sequential and iterative calculations of the CEM form-finding algorithm, instead of a numerical approximation. Finally, we encapsulate our research developments into an open-source design tool written in Python that is usable across different CAD platforms and operating systems. After studying four different structures -- a self-stressed planar tensegrity, a tree canopy, a curved bridge, and a spiral staircase -- we demonstrate that our approach enables the solution of constrained form-finding problems on a diverse range of structures more efficiently than in previous work.
]]></description>
<dc:subject>numerical-methods structural-engineering rather-interesting generative-models structure architecture inverse-problems to-understand to-write-about consider:benchmarks</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c2c1ce6f5115/</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:structural-engineering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:generative-models"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:structure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:inverse-problems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:benchmarks"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.messynessychic.com/2022/04/12/how-america-became-enamoured-with-octagon-houses/">
    <title>How America Became Enamoured with Octagon Houses</title>
    <dc:date>2022-10-24T10:39:13+00:00</dc:date>
    <link>https://www.messynessychic.com/2022/04/12/how-america-became-enamoured-with-octagon-houses/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Explore America’s small towns, and you might be lucky to stumble across a peculiarly shaped house that stands out from its surrounding neighbours by virtue of having eight facades. Back in the middle of the 19th century, there were once thousands of these ‘octagonal’ houses all over America when they were the height of fashion, but today only a handful remain. These unusual eight sided homes are the surviving relics of an 1850s architectural craze dreamt up by one man.]]></description>
<dc:subject>architecture Americana rather-interesting saw-one-recently</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:dcc5d166564d/</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:Americana"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:saw-one-recently"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2109.07683">
    <title>[2109.07683] Intuitive and Efficient Roof Modeling for Reconstruction and Synthesis</title>
    <dc:date>2022-01-27T11:43:08+00:00</dc:date>
    <link>https://arxiv.org/abs/2109.07683</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We propose a novel and flexible roof modeling approach that can be used for constructing planar 3D polygon roof meshes. Our method uses a graph structure to encode roof topology and enforces the roof validity by optimizing a simple but effective planarity metric we propose. This approach is significantly more efficient than using general purpose 3D modeling tools such as 3ds Max or SketchUp, and more powerful and expressive than specialized tools such as the straight skeleton. Our optimization-based formulation is also flexible and can accommodate different styles and user preferences for roof modeling. We showcase two applications. The first application is an interactive roof editing framework that can be used for roof design or roof reconstruction from aerial images. We highlight the efficiency and generality of our approach by constructing a mesh-image paired dataset consisting of 2539 roofs. Our second application is a generative model to synthesize new roof meshes from scratch. We use our novel dataset to combine machine learning and our roof optimization techniques, by using transformers and graph convolutional networks to model roof topology, and our roof optimization methods to enforce the planarity constraint.
]]></description>
<dc:subject>generative-models architecture image-processing rather-interesting algorithms to-write-about consider:similar-for-typography</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2ea2c5698a2a/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:generative-models"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:image-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<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:similar-for-typography"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1906.04358">
    <title>[1906.04358] Weight Agnostic Neural Networks</title>
    <dc:date>2021-07-16T10:24:50+00:00</dc:date>
    <link>https://arxiv.org/abs/1906.04358</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Not all neural network architectures are created equal, some perform much better than others for certain tasks. But how important are the weight parameters of a neural network compared to its architecture? In this work, we question to what extent neural network architectures alone, without learning any weight parameters, can encode solutions for a given task. We propose a search method for neural network architectures that can already perform a task without any explicit weight training. To evaluate these networks, we populate the connections with a single shared weight parameter sampled from a uniform random distribution, and measure the expected performance. We demonstrate that our method can find minimal neural network architectures that can perform several reinforcement learning tasks without weight training. On a supervised learning domain, we find network architectures that achieve much higher than chance accuracy on MNIST using random weights. Interactive version of this paper at this https URL
]]></description>
<dc:subject>neural-networks machine-learning performance-measure rather-interesting implicit-objective architecture m algorithms</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:d2874aa61939/</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:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-measure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:implicit-objective"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:m"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2011.02712">
    <title>[2011.02712] Architecture Agnostic Neural Networks</title>
    <dc:date>2021-05-22T23:09:08+00:00</dc:date>
    <link>https://arxiv.org/abs/2011.02712</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper, we explore an alternate method for synthesizing neural network architectures, inspired by the brain's stochastic synaptic pruning. During a person's lifetime, numerous distinct neuronal architectures are responsible for performing the same tasks. This indicates that biological neural networks are, to some degree, architecture agnostic. However, artificial networks rely on their fine-tuned weights and hand-crafted architectures for their remarkable performance. This contrast begs the question: Can we build artificial architecture agnostic neural networks? To ground this study we utilize sparse, binary neural networks that parallel the brain's circuits. Within this sparse, binary paradigm we sample many binary architectures to create families of architecture agnostic neural networks not trained via backpropagation. These high-performing network families share the same sparsity, distribution of binary weights, and succeed in both static and dynamic tasks. In summation, we create an architecture manifold search procedure to discover families or architecture agnostic neural networks.
]]></description>
<dc:subject>neural-networks architecture self-organization algorithms to-understand rather-interesting compare:GANNs consider:visualization machine-learning</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:9d1c301e311e/</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:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:self-organization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:compare:GANNs"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:visualization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/2012.09229">
    <title>[2012.09229] Tag-based Genetic Regulation for Genetic Programming</title>
    <dc:date>2021-03-27T11:08:03+00:00</dc:date>
    <link>https://arxiv.org/abs/2012.09229</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We introduce and experimentally demonstrate tag-based genetic regulation, a new genetic programming (GP) technique that allows evolving programs to dynamically adjust which code modules to express. Tags are evolvable labels that provide a flexible mechanism for referring to code modules. Tag-based genetic regulation extends existing tag-based naming schemes to allow programs to "promote" and "repress" code modules. This extension allows evolution to structure a program as a gene regulatory network where program modules are regulated based on instruction executions. We demonstrate the functionality of tag-based regulation on a range of program synthesis problems. We find that tag-based regulation improves problem-solving performance on context-dependent problems; that is, problems where programs must adjust how they respond to current inputs based on prior inputs (i.e., current context). We also observe that our implementation of tag-based genetic regulation can impede adaptive evolution when expected outputs are not context-dependent (i.e., the correct response to a particular input remains static over time). Tag-based genetic regulation broadens our repertoire of techniques for evolving more dynamic genetic programs and can easily be incorporated into existing tag-enabled GP systems.
]]></description>
<dc:subject>genetic-programming distributed-processing hey-I-know-this-guy dynamical-systems architecture to-write-about consider:ReQ-similarity</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1383bae9e8e8/</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:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:hey-I-know-this-guy"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:dynamical-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:ReQ-similarity"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.jeremydaly.com/serverless-microservice-patterns-for-aws/">
    <title>Serverless Microservice Patterns for AWS - Jeremy Daly</title>
    <dc:date>2021-03-25T20:51:25+00:00</dc:date>
    <link>https://www.jeremydaly.com/serverless-microservice-patterns-for-aws/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[I’m a huge fan of building microservices with serverless systems. Serverless gives us the power to focus on just the code and our data without worrying about the maintenance and configuration of the underlying compute resources. Cloud providers (like AWS), also give us a huge number of managed services that we can stitch together to create incredibly powerful, and massively scalable serverless microservices.

I’ve read a lot of posts that mention serverless microservices, but they often don’t go into much detail. I feel like that can leave people confused and make it harder for them to implement their own solutions. Since I work with serverless microservices all the time, I figured I’d compile a list of design patterns and how to implement them in AWS. I came up with 19 of them, though I’m sure there are plenty more.

In this post we’ll look at all 19 in detail so that you can use them as templates to start designing your own serverless microservices.

]]></description>
<dc:subject>serverless cloud-computing architecture design-patterns rather-interesting devops to-understand software-development-is-not-programming</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:82da0f8526c4/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:serverless"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cloud-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design-patterns"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:devops"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development-is-not-programming"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1902.10486">
    <title>[1902.10486] On Tiny Episodic Memories in Continual Learning</title>
    <dc:date>2020-07-22T11:22:35+00:00</dc:date>
    <link>https://arxiv.org/abs/1902.10486</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In continual learning (CL), an agent learns from a stream of tasks leveraging prior experience to transfer knowledge to future tasks. It is an ideal framework to decrease the amount of supervision in the existing learning algorithms. But for a successful knowledge transfer, the learner needs to remember how to perform previous tasks. One way to endow the learner the ability to perform tasks seen in the past is to store a small memory, dubbed episodic memory, that stores few examples from previous tasks and then to replay these examples when training for future tasks. In this work, we empirically analyze the effectiveness of a very small episodic memory in a CL setup where each training example is only seen once. Surprisingly, across four rather different supervised learning benchmarks adapted to CL, a very simple baseline, that jointly trains on both examples from the current task as well as examples stored in the episodic memory, significantly outperforms specifically designed CL approaches with and without episodic memory. Interestingly, we find that repetitive training on even tiny memories of past tasks does not harm generalization, on the contrary, it improves it, with gains between 7\% and 17\% when the memory is populated with a single example per class.
]]></description>
<dc:subject>machine-learning architecture dynamics learning-by-doing episodic-memory to-write-about to-simulate consider:ReQ consider:online-learning</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:7403b9d78c77/</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:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:dynamics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:learning-by-doing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:episodic-memory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-simulate"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:ReQ"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:online-learning"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://cloud.google.com/blog/products/application-development/api-design-why-you-should-use-links-not-keys-to-represent-relationships-in-apis">
    <title>API design: Why you should use links, not keys, to represent relationships in APIs | Google Cloud Blog</title>
    <dc:date>2020-01-19T01:38:26+00:00</dc:date>
    <link>https://cloud.google.com/blog/products/application-development/api-design-why-you-should-use-links-not-keys-to-represent-relationships-in-apis</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Caveats
Here are some things you should think about before using links.
Many API implementations have reverse proxies in front of them for security, load-balancing, and other reasons. Some proxies like to rewrite URLs. When an API uses foreign keys to represent relationships, the only URL that has to be rewritten by a proxy is the main URL of the request. In HTTP, that URL is split between the address line (the first header line) and the host header.
]]></description>
<dc:subject>API software-development-is-not-programming URLs rather-interesting database architecture data-driven-apps</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:f65ec285e325/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:API"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development-is-not-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:URLs"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:database"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-driven-apps"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.mnot.net/blog/2019/10/13/h2_api_multiplexing">
    <title>mnot’s blog: How Multiplexing Changes Your HTTP APIs</title>
    <dc:date>2019-11-23T13:19:41+00:00</dc:date>
    <link>https://www.mnot.net/blog/2019/10/13/h2_api_multiplexing</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The above is probably not news to most, but I suspect the implications for API design aren’t fully apparent. On the wire, HTTP/2 (and soon, HTTP/3) allows you to express a large number of requests in a very compact way.

]]></description>
<dc:subject>web-design http software-development-is-not-programming to-understand to-use API architecture</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:07d9601b2816/</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:http"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development-is-not-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-use"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:API"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://link.springer.com/article/10.1007/s00004-012-0127-3">
    <title>Descriptive Geometry: From its Past to its Future | SpringerLink</title>
    <dc:date>2019-10-19T13:47:52+00:00</dc:date>
    <link>https://link.springer.com/article/10.1007/s00004-012-0127-3</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Descriptive geometry is the science that Gaspard Monge systematized in 1794 and that was widely developed in Europe, up until the first decades of the twentieth century. The main purpose of this science is the certain and accurate representation of three-dimensional shapes on the twodimensional support of the drawing, while its chief application is the study of geometric shapes and their characteristics, in graphic and visual form. We can therefore understand how descriptive geometry has been, on the one hand, the object of theoretical studies, and, on the other, an essential tool for designers, engineers and architects. Nevertheless, at the end of the last century, the availability of electronic machines capable of representing threedimensional shapes has produced an epochal change, because designers have adopted the new digital techniques almost exclusively. The purpose of this paper is to show how it is possible to give new life to the ancient science of representation and, at the same time, to endow CAD with the dignity of the history that precedes it.

]]></description>
<dc:subject>representation architecture history-of-engineering philosophy-of-engineering planning user-experience rather-interesting to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1d3a200e581a/</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:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:history-of-engineering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:philosophy-of-engineering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:planning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:user-experience"/>
	<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:Bag></taxo:topics>
</item>
<item rdf:about="https://link.springer.com/journal/volumesAndIssues/4">
    <title>Nexus Network Journal - All Volumes &amp; Issues - Springer</title>
    <dc:date>2019-10-14T12:07:05+00:00</dc:date>
    <link>https://link.springer.com/journal/volumesAndIssues/4</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Nexus Network Journal
Architecture and Mathematics]]></description>
<dc:subject>history-of-mathematics architecture geometry rather-interesting cannot-read to-browse</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:73261551888a/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:history-of-mathematics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<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:cannot-read"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-browse"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1808.09357">
    <title>[1808.09357] Rational Recurrences</title>
    <dc:date>2018-12-09T11:03:39+00:00</dc:date>
    <link>https://arxiv.org/abs/1808.09357</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Despite the tremendous empirical success of neural models in natural language processing, many of them lack the strong intuitions that accompany classical machine learning approaches. Recently, connections have been shown between convolutional neural networks (CNNs) and weighted finite state automata (WFSAs), leading to new interpretations and insights. In this work, we show that some recurrent neural networks also share this connection to WFSAs. We characterize this connection formally, defining rational recurrences to be recurrent hidden state update functions that can be written as the Forward calculation of a finite set of WFSAs. We show that several recent neural models use rational recurrences. Our analysis provides a fresh view of these models and facilitates devising new neural architectures that draw inspiration from WFSAs. We present one such model, which performs better than two recent baselines on language modeling and text classification. Our results demonstrate that transferring intuitions from classical models like WFSAs can be an effective approach to designing and understanding neural models.
]]></description>
<dc:subject>automata representation neural-networks recurrent-networks architecture rather-interesting ReQ to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b0f458c104f5/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:automata"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:recurrent-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ReQ"/>
	<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/1803.09574">
    <title>[1803.09574] Long short-term memory and Learning-to-learn in networks of spiking neurons</title>
    <dc:date>2018-04-02T11:08:55+00:00</dc:date>
    <link>https://arxiv.org/abs/1803.09574</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Networks of spiking neurons (SNNs) are frequently studied as models for networks of neurons in the brain, but also as paradigm for novel energy efficient computing hardware. In principle they are especially suitable for computations in the temporal domain, such as speech processing, because their computations are carried out via events in time and space. But so far they have been lacking the capability to preserve information for longer time spans during a computation, until it is updated or needed - like a register of a digital computer. This function is provided to artificial neural networks through Long Short-Term Memory (LSTM) units. We show here that SNNs attain similar capabilities if one includes adapting neurons in the network. Adaptation denotes an increase of the firing threshold of a neuron after preceding firing. A substantial fraction of neurons in the neocortex of rodents and humans has been found to be adapting. It turns out that if adapting neurons are integrated in a suitable manner into the architecture of SNNs, the performance of these enhanced SNNs, which we call LSNNs, for computation in the temporal domain approaches that of artificial neural networks with LSTM-units. In addition, the computing and learning capabilities of LSNNs can be substantially enhanced through learning-to-learn (L2L) methods from machine learning, that have so far been applied primarily to LSTM networks and apparently never to SSNs. 
This preliminary report on arXiv will be replaced by a more detailed version in about a month.
]]></description>
<dc:subject>neural-networks biological-engineering dynamical-systems rather-interesting architecture machine-learning simulation learning-by-watching to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:6129c08dde6e/</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:biological-engineering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:dynamical-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:simulation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:learning-by-watching"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</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://arxiv.org/abs/1801.05895">
    <title>[1801.05895] Sparsely Connected Convolutional Networks</title>
    <dc:date>2018-01-20T13:18:45+00:00</dc:date>
    <link>https://arxiv.org/abs/1801.05895</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Residual learning with skip connections permits training ultra-deep neural networks and obtains superb performance. Building in this direction, DenseNets proposed a dense connection structure where each layer is directly connected to all of its predecessors. The densely connected structure leads to better information flow and feature reuse. However, the overly dense skip connections also bring about the problems of potential risk of overfitting, parameter redundancy and large memory consumption. In this work, we analyze the feature aggregation patterns of ResNets and DenseNets under a uniform aggregation view framework. We show that both structures densely gather features from previous layers in the network but combine them in their respective ways: summation (ResNets) or concatenation (DenseNets). We compare the strengths and drawbacks of these two aggregation methods and analyze their potential effects on the networks' performance. Based on our analysis, we propose a new structure named SparseNets which achieves better performance with fewer parameters than DenseNets and ResNets.
]]></description>
<dc:subject>neural-networks binge-purge-cycles architecture algorithms machine-learning representation to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:913cf4defe54/</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:binge-purge-cycles"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<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:representation"/>
	<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.07056">
    <title>[1709.07056] Magnetic Compasses and Chinese Architectures</title>
    <dc:date>2018-01-15T11:41:07+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.07056</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper, we are discussing the effect of the use of magnetic compasses on the orientation of ancient Chinese architectonical complexes. As Czech researchers proposed in 2011, assuming these complexes ideally oriented by the ancient architects along north-south direction, in the case that the surveys were made by means of magnetic compasses, we can find the axes of the complexes deviating from the cardinal direction, according to the local magnetic declination that existed at the time the structures were built. Following this idea, here we discuss some examples of possible alignments obtained by means of magnetic compasses, concluding that the Chinese surveyors adopted, during the Ming dynasty, a method based on the magnetic compasses. The architects of the antecedent Yuan Dynasty probably used an astronomical method.
]]></description>
<dc:subject>history-of-science nanohistory rather-interesting to-write-about architecture</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:987cfc5dc84f/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:history-of-science"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nanohistory"/>
	<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:architecture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://colah.github.io/posts/2015-08-Understanding-LSTMs/">
    <title>Understanding LSTM Networks -- colah's blog</title>
    <dc:date>2017-11-12T12:28:08+00:00</dc:date>
    <link>https://colah.github.io/posts/2015-08-Understanding-LSTMs/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Humans don’t start their thinking from scratch every second. As you read this essay, you understand each word based on your understanding of previous words. You don’t throw everything away and start thinking from scratch again. Your thoughts have persistence.

Traditional neural networks can’t do this, and it seems like a major shortcoming. For example, imagine you want to classify what kind of event is happening at every point in a movie. It’s unclear how a traditional neural network could use its reasoning about previous events in the film to inform later ones.]]></description>
<dc:subject>recurrent-neural-nets machine-learning architecture dynamical-systems explainer</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:9ae017ce6ada/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:recurrent-neural-nets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:dynamical-systems"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:explainer"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.06309">
    <title>[1709.06309] Aspect-Based Relational Sentiment Analysis Using a Stacked Neural Network Architecture</title>
    <dc:date>2017-09-29T13:38:27+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.06309</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Sentiment analysis can be regarded as a relation extraction problem in which the sentiment of some opinion holder towards a certain aspect of a product, theme or event needs to be extracted. We present a novel neural architecture for sentiment analysis as a relation extraction problem that addresses this problem by dividing it into three subtasks: i) identification of aspect and opinion terms, ii) labeling of opinion terms with a sentiment, and iii) extraction of relations between opinion terms and aspect terms. For each subtask, we propose a neural network based component and combine all of them into a complete system for relational sentiment analysis. The component for aspect and opinion term extraction is a hybrid architecture consisting of a recurrent neural network stacked on top of a convolutional neural network. This approach outperforms a standard convolutional deep neural architecture as well as a recurrent network architecture and performs competitively compared to other methods on two datasets of annotated customer reviews. To extract sentiments for individual opinion terms, we propose a recurrent architecture in combination with word distance features and achieve promising results, outperforming a majority baseline by 18% accuracy and providing the first results for the USAGE dataset. Our relation extraction component outperforms the current state-of-the-art in aspect-opinion relation extraction by 15% F-Measure.
]]></description>
<dc:subject>sentiment-analysis natural-language-processing deep-learning neural-networks machine-learning architecture nudge-targets consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:ed09c9f5797d/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:sentiment-analysis"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:natural-language-processing"/>
	<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:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<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:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1702.08835">
    <title>[1702.08835] Deep Forest: Towards An Alternative to Deep Neural Networks</title>
    <dc:date>2017-09-27T11:50:37+00:00</dc:date>
    <link>https://arxiv.org/abs/1702.08835</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper, we propose gcForest, a decision tree ensemble approach with performance highly competitive to deep neural networks. In contrast to deep neural networks which require great effort in hyper-parameter tuning, gcForest is much easier to train. Actually, even when gcForest is applied to different data from different domains, excellent performance can be achieved by almost same settings of hyper-parameters. The training process of gcForest is efficient and scalable. In our experiments its training time running on a PC is comparable to that of deep neural networks running with GPU facilities, and the efficiency advantage may be more apparent because gcForest is naturally apt to parallel implementation. Furthermore, in contrast to deep neural networks which require large-scale training data, gcForest can work well even when there are only small-scale training data. Moreover, as a tree-based approach, gcForest should be easier for theoretical analysis than deep neural networks.
]]></description>
<dc:subject>via:jason-moore machine-learning architecture metaheuristics to-write-about design-patterns</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:28918ffce86f/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:jason-moore"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:metaheuristics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design-patterns"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://blog.intercom.com/why-cards-are-the-future-of-the-web/">
    <title>Why cards are the future of the web - Inside Intercom</title>
    <dc:date>2017-09-26T14:52:41+00:00</dc:date>
    <link>https://blog.intercom.com/why-cards-are-the-future-of-the-web/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We are currently witnessing a re-architecture of the web, away from pages and destinations, towards completely personalised experiences built on an aggregation of many individual pieces of content. Content being broken down into individual components and re-aggregated is the result of the rise of mobile technologies, billions of screens of all shapes and sizes, and unprecedented access to data from all kinds of sources through APIs and SDKs. This is driving the web away from many pages of content linked together, towards individual pieces of content aggregated together into one experience.

]]></description>
<dc:subject>web-design HTML architecture usability to-learn</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:227b2f58f485/</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:HTML"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:usability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-learn"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1709.05769">
    <title>[1709.05769] Where to Focus: Deep Attention-based Spatially Recurrent Bilinear Networks for Fine-Grained Visual Recognition</title>
    <dc:date>2017-09-26T12:23:52+00:00</dc:date>
    <link>https://arxiv.org/abs/1709.05769</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Fine-grained visual recognition typically depends on modeling subtle difference from object parts. However, these parts often exhibit dramatic visual variations such as occlusions, viewpoints, and spatial transformations, making it hard to detect. In this paper, we present a novel attention-based model to automatically, selectively and accurately focus on critical object regions with higher importance against appearance variations. Given an image, two different Convolutional Neural Networks (CNNs) are constructed, where the outputs of two CNNs are correlated through bilinear pooling to simultaneously focus on discriminative regions and extract relevant features. To capture spatial distributions among the local regions with visual attention, soft attention based spatial Long-Short Term Memory units (LSTMs) are incorporated to realize spatially recurrent yet visually selective over local input patterns. All the above intuitions equip our network with the following novel model: two-stream CNN layers, bilinear pooling layer, spatial recurrent layer with location attention are jointly trained via an end-to-end fashion to serve as the part detector and feature extractor, whereby relevant features are localized and extracted attentively. We show the significance of our network against two well-known visual recognition tasks: fine-grained image classification and person re-identification.
]]></description>
<dc:subject>image-processing neural-networks attention feature-extraction deep-learning architecture constraint-satisfaction nudge-targets consider:feature-discovery consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:bea722cbe7d7/</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:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:attention"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:feature-extraction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:deep-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:constraint-satisfaction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:feature-discovery"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://mitpress.mit.edu/books/architectural-intelligence">
    <title>Architectural Intelligence | The MIT Press</title>
    <dc:date>2017-09-23T12:11:56+00:00</dc:date>
    <link>https://mitpress.mit.edu/books/architectural-intelligence</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In Architectural Intelligence, Molly Wright Steenson explores the work of four architects in the 1960s and 1970s who incorporated elements of interactivity into their work. Christopher Alexander, Richard Saul Wurman, Cedric Price, and Nicholas Negroponte and the MIT Architecture Machine Group all incorporated technologies—including cybernetics and artificial intelligence—into their work and influenced digital design practices from the late 1980s to the present day.

Alexander, long before his famous 1977 book A Pattern Language, used computation and structure to visualize design problems; Wurman popularized the notion of “information architecture”; Price designed some of the first intelligent buildings; and Negroponte experimented with the ways people experience artificial intelligence, even at architectural scale. Steenson investigates how these architects pushed the boundaries of architecture—and how their technological experiments pushed the boundaries of technology. What did computational, cybernetic, and artificial intelligence researchers have to gain by engaging with architects and architectural problems? And what was this new space that emerged within these collaborations? At times, Steenson writes, the architects in this book characterized themselves as anti-architects and their work as anti-architecture. The projects Steenson examines mostly did not result in constructed buildings, but rather in design processes and tools, computer programs, interfaces, digital environments. Alexander, Wurman, Price, and Negroponte laid the foundation for many of our contemporary interactive practices, from information architecture to interaction design, from machine learning to smart cities.

]]></description>
<dc:subject>via:? architecture patterns internet history engineering-criticism to-read rather-interesting software-development-is-not-programming</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8b409a520005/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:?"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:patterns"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:internet"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:history"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-criticism"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-read"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development-is-not-programming"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.youtube.com/watch?v=rMd6-IS3cmU&amp;app=desktop">
    <title>We Have Never Been Neutral: Search, Discovery, and the Politics of Access - YouTube</title>
    <dc:date>2017-08-08T19:20:43+00:00</dc:date>
    <link>https://www.youtube.com/watch?v=rMd6-IS3cmU&amp;app=desktop</link>
    <dc:creator>Vaguery</dc:creator><dc:subject>via:mymarkup libraries colonialism architecture to-watch to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:eee35f5a9743/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:mymarkup"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:libraries"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:colonialism"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-watch"/>
	<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.06993">
    <title>[1608.06993] Densely Connected Convolutional Networks</title>
    <dc:date>2017-07-24T10:56:54+00:00</dc:date>
    <link>https://arxiv.org/abs/1608.06993</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Recent work has shown that convolutional networks can be substantially deeper, more accurate, and efficient to train if they contain shorter connections between layers close to the input and those close to the output. In this paper, we embrace this observation and introduce the Dense Convolutional Network (DenseNet), which connects each layer to every other layer in a feed-forward fashion. Whereas traditional convolutional networks with L layers have L connections - one between each layer and its subsequent layer - our network has L(L+1)/2 direct connections. For each layer, the feature-maps of all preceding layers are used as inputs, and its own feature-maps are used as inputs into all subsequent layers. DenseNets have several compelling advantages: they alleviate the vanishing-gradient problem, strengthen feature propagation, encourage feature reuse, and substantially reduce the number of parameters. We evaluate our proposed architecture on four highly competitive object recognition benchmark tasks (CIFAR-10, CIFAR-100, SVHN, and ImageNet). DenseNets obtain significant improvements over the state-of-the-art on most of them, whilst requiring less memory and computation to achieve high performance. Code and models are available at this https URL .
]]></description>
<dc:subject>machine-learning neural-networks architecture not-surprising to-write-about representation readability nonlinear-dynamics</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:909acfc09c97/</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:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:not-surprising"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:readability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nonlinear-dynamics"/>
</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://arxiv.org/abs/1704.00764">
    <title>[1704.00764] A Genetic Programming Approach to Designing Convolutional Neural Network Architectures</title>
    <dc:date>2017-04-10T09:52:20+00:00</dc:date>
    <link>https://arxiv.org/abs/1704.00764</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The convolutional neural network (CNN), which is one of the deep learning models, has seen much success in a variety of computer vision tasks. However, designing CNN architectures still requires expert knowledge and a lot of trial and error. In this paper, we attempt to automatically construct CNN architectures for an image classification task based on Cartesian genetic programming (CGP). In our method, we adopt highly functional modules, such as convolutional blocks and tensor concatenation, as the node functions in CGP. The CNN structure and connectivity represented by the CGP encoding method are optimized to maximize the validation accuracy. To evaluate the proposed method, we constructed a CNN architecture for the image classification task with the CIFAR-10 dataset. The experimental result shows that the proposed method can be used to automatically find the competitive CNN architecture compared with state-of-the-art models.
]]></description>
<dc:subject>genetic-programming neural-networks architecture cartesian-GP rather-interesting engineering-design nudge-targets consider:looking-to-see algorithms</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b8333026048a/</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:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cartesian-GP"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:looking-to-see"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1611.03530">
    <title>[1611.03530] Understanding deep learning requires rethinking generalization</title>
    <dc:date>2017-03-09T11:46:19+00:00</dc:date>
    <link>https://arxiv.org/abs/1611.03530</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Despite their massive size, successful deep artificial neural networks can exhibit a remarkably small difference between training and test performance. Conventional wisdom attributes small generalization error either to properties of the model family, or to the regularization techniques used during training. 
Through extensive systematic experiments, we show how these traditional approaches fail to explain why large neural networks generalize well in practice. Specifically, our experiments establish that state-of-the-art convolutional networks for image classification trained with stochastic gradient methods easily fit a random labeling of the training data. This phenomenon is qualitatively unaffected by explicit regularization, and occurs even if we replace the true images by completely unstructured random noise. We corroborate these experimental findings with a theoretical construction showing that simple depth two neural networks already have perfect finite sample expressivity as soon as the number of parameters exceeds the number of data points as it usually does in practice. 
We interpret our experimental findings by comparison with traditional models.
]]></description>
<dc:subject>deep-learning generalization benchmarking rather-interesting information-theory architecture define-your-terms machine-learning consider:looking-at-GP-models</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:5ea3a63f92f0/</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:generalization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:benchmarking"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:information-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:define-your-terms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:looking-at-GP-models"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1611.02163">
    <title>[1611.02163] Unrolled Generative Adversarial Networks</title>
    <dc:date>2017-03-08T12:54:20+00:00</dc:date>
    <link>https://arxiv.org/abs/1611.02163</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We introduce a method to stabilize Generative Adversarial Networks (GANs) by defining the generator objective with respect to an unrolled optimization of the discriminator. This allows training to be adjusted between using the optimal discriminator in the generator's objective, which is ideal but infeasible in practice, and using the current value of the discriminator, which is often unstable and leads to poor solutions. We show how this technique solves the common problem of mode collapse, stabilizes training of GANs with complex recurrent generators, and increases diversity and coverage of the data distribution by the generator.
]]></description>
<dc:subject>deep-learning neural-networks exploration-vs-exploitation architecture performance-measure to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c30ce753eb51/</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:exploration-vs-exploitation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-measure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://martinfowler.com/articles/serverless.html">
    <title>Serverless Architectures</title>
    <dc:date>2017-02-15T13:15:04+00:00</dc:date>
    <link>https://martinfowler.com/articles/serverless.html</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Serverless architectures refer to applications that significantly depend on third-party services (knows as Backend as a Service or "BaaS") or on custom code that's run in ephemeral containers (Function as a Service or "FaaS"), the best known vendor host of which currently is AWS Lambda. By using these ideas, and by moving much behavior to the front end, such architectures remove the need for the traditional 'always on' server system sitting behind an application. Depending on the circumstances, such systems can significantly reduce operational cost and complexity at a cost of vendor dependencies and (at the moment) immaturity of supporting services.

]]></description>
<dc:subject>serverless architecture software-development software-development-is-not-programming cloud-computing</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8f4acf99c58a/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:serverless"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development-is-not-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cloud-computing"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1506.02640">
    <title>[1506.02640] You Only Look Once: Unified, Real-Time Object Detection</title>
    <dc:date>2017-02-07T11:25:35+00:00</dc:date>
    <link>https://arxiv.org/abs/1506.02640</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We present YOLO, a new approach to object detection. Prior work on object detection repurposes classifiers to perform detection. Instead, we frame object detection as a regression problem to spatially separated bounding boxes and associated class probabilities. A single neural network predicts bounding boxes and class probabilities directly from full images in one evaluation. Since the whole detection pipeline is a single network, it can be optimized end-to-end directly on detection performance. 
Our unified architecture is extremely fast. Our base YOLO model processes images in real-time at 45 frames per second. A smaller version of the network, Fast YOLO, processes an astounding 155 frames per second while still achieving double the mAP of other real-time detectors. Compared to state-of-the-art detection systems, YOLO makes more localization errors but is far less likely to predict false detections where nothing exists. Finally, YOLO learns very general representations of objects. It outperforms all other detection methods, including DPM and R-CNN, by a wide margin when generalizing from natural images to artwork on both the Picasso Dataset and the People-Art Dataset.
]]></description>
<dc:subject>machine-learning image-segmentation architecture algorithms nudge-targets consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:01f50d04ffd4/</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:image-segmentation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<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:consider:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1506.08448">
    <title>[1506.08448] Neural Simpletrons - Minimalistic Directed Generative Networks for Learning with Few Labels</title>
    <dc:date>2016-11-27T23:32:13+00:00</dc:date>
    <link>https://arxiv.org/abs/1506.08448</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Classifiers for the semi-supervised setting often combine strong supervised models with additional learning objectives to make use of unlabeled data. This results in powerful though very complex models that are hard to train and that demand additional labels for optimal parameter tuning, which are often not given when labeled data is very sparse. We here study a minimalistic multi-layer generative neural network for semi-supervised learning in a form and setting as similar to standard discriminative networks as possible. Based on normalized Poisson mixtures, we derive compact and local learning and neural activation rules. Learning and inference in the network can be scaled using standard deep learning tools for parallelized GPU implementation. With the single objective of likelihood optimization, both labeled and unlabeled data are naturally incorporated into learning. Empirical evaluations on standard benchmarks show, that for datasets with few labels the derived minimalistic network improves on all classical deep learning approaches and is competitive with their recent variants without the need of additional labels for parameter tuning. Furthermore, we find that the studied network is the best performing monolithic (`non-hybrid') system for few labels, and that it can be applied in the limit of very few labels, where no other system has been reported to operate so far.
]]></description>
<dc:subject>neural-networks classification machine-learning algorithms representation architecture to-understand to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:41148a1952dd/</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:classification"/>
	<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:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<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/1610.01945">
    <title>[1610.01945] Connecting Generative Adversarial Networks and Actor-Critic Methods</title>
    <dc:date>2016-11-20T13:24:55+00:00</dc:date>
    <link>https://arxiv.org/abs/1610.01945</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Both generative adversarial networks (GAN) in unsupervised learning and actor-critic methods in reinforcement learning (RL) have gained a reputation for being difficult to optimize. Practitioners in both fields have amassed a large number of strategies to mitigate these instabilities and improve training. Here we show that GANs can be viewed as actor-critic methods in an environment where the actor cannot affect the reward. We review the strategies for stabilizing training for each class of models, both those that generalize between the two and those that are particular to that model. We also review a number of extensions to GANs and RL algorithms with even more complicated information flow. We hope that by highlighting this formal connection we will encourage both GAN and RL communities to develop general, scalable, and stable algorithms for multilevel optimization with deep networks, and to draw inspiration across communities.
]]></description>
<dc:subject>generative-models deep-learning neural-networks machine-learning architecture nudge-targets consider:architecture</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2bf6945172e9/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:generative-models"/>
	<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:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:architecture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://arxiv.org/abs/1610.01588">
    <title>[1610.01588] Neural Structural Correspondence Learning for Domain Adaptation</title>
    <dc:date>2016-11-05T11:52:22+00:00</dc:date>
    <link>https://arxiv.org/abs/1610.01588</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Domain adaptation, adapting models from domains rich in labeled training data to domains poor in such data, is a fundamental NLP challenge. We introduce a neural network model that marries together ideas from two prominent strands of research on domain adaptation through representation learning: structural correspondence learning (SCL, (Blitzer et al., 2006)) and autoencoder neural networks. Particularly, our model is a three-layer neural network that learns to encode the nonpivot features of an input example into a low-dimensional representation, so that the existence of pivot features (features that are prominent in both domains and convey useful information for the NLP task) in the example can be decoded from that representation. The low-dimensional representation is then employed in a learning algorithm for the task. Moreover, we show how to inject pre-trained word embeddings into our model in order to improve generalization across examples with similar pivot features. On the task of cross-domain product sentiment classification (Blitzer et al., 2007), consisting of 12 domain pairs, our model outperforms both the SCL and the marginalized stacked denoising autoencoder (MSDA, (Chen et al., 2012)) methods by 3.77% and 2.17% respectively, on average across domain pairs.
]]></description>
<dc:subject>neural-networks machine-learning multitask-learning feature-extraction architecture to-understand to-write-about nudge-targets consider:performance-measures</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:9111c427e24a/</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:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:multitask-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:feature-extraction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-write-about"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<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/1605.06431">
    <title>[1605.06431] Residual Networks Behave Like Ensembles of Relatively Shallow Networks</title>
    <dc:date>2016-10-31T13:03:55+00:00</dc:date>
    <link>https://arxiv.org/abs/1605.06431</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this work we propose a novel interpretation of residual networks showing that they can be seen as a collection of many paths of differing length. Moreover, residual networks seem to enable very deep networks by leveraging only the short paths during training. To support this observation, we rewrite residual networks as an explicit collection of paths. Unlike traditional models, paths through residual networks vary in length. Further, a lesion study reveals that these paths show ensemble-like behavior in the sense that they do not strongly depend on each other. Finally, and most surprising, most paths are shorter than one might expect, and only the short paths are needed during training, as longer paths do not contribute any gradient. For example, most of the gradient in a residual network with 110 layers comes from paths that are only 10-34 layers deep. Our results reveal one of the key characteristics that seem to enable the training of very deep networks: Residual networks avoid the vanishing gradient problem by introducing short paths which can carry gradient throughout the extent of very deep networks.
]]></description>
<dc:subject>deep-learning image-processing rather-interesting neural-networks architecture to-understand to-write-about</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:191b1fd32463/</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:image-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
	<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/1610.08613">
    <title>[1610.08613] Can Active Memory Replace Attention?</title>
    <dc:date>2016-10-31T11:25:58+00:00</dc:date>
    <link>https://arxiv.org/abs/1610.08613</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Several mechanisms to focus attention of a neural network on selected parts of its input or memory have been used successfully in deep learning models in recent years. Attention has improved image classification, image captioning, speech recognition, generative models, and learning algorithmic tasks, but it had probably the largest impact on neural machine translation. 
Recently, similar improvements have been obtained using alternative mechanisms that do not focus on a single part of a memory but operate on all of it in parallel, in a uniform way. Such mechanism, which we call active memory, improved over attention in algorithmic tasks, image processing, and in generative modelling. 
So far, however, active memory has not improved over attention for most natural language processing tasks, in particular for machine translation. We analyze this shortcoming in this paper and propose an extended model of active memory that matches existing attention models on neural machine translation and generalizes better to longer sentences. We investigate this model and explain why previous active memory models did not succeed. Finally, we discuss when active memory brings most benefits and where attention can be a better choice.
]]></description>
<dc:subject>machine-learning neural-networks architecture algorithms active-learning nudge-targets consider:architecture consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:c9516a3ef2af/</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:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:active-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.asimovinstitute.org/neural-network-zoo/">
    <title>The Neural Network Zoo - The Asimov Institute</title>
    <dc:date>2016-09-16T14:25:14+00:00</dc:date>
    <link>http://www.asimovinstitute.org/neural-network-zoo/</link>
    <dc:creator>Vaguery</dc:creator><dc:subject>via:various neural-networks architecture taxonomy machine-learning rather-interesting to-do-for-GP</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:0664c9cd4ad6/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:various"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:taxonomy"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-do-for-GP"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1505.05972">
    <title>[1505.05972] Instant Learning: Parallel Deep Neural Networks and Convolutional Bootstrapping</title>
    <dc:date>2016-08-09T11:40:32+00:00</dc:date>
    <link>http://arxiv.org/abs/1505.05972</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Although deep neural networks (DNN) are able to scale with direct advances in computational power (e.g., memory and processing speed), they are not well suited to exploit the recent trends for parallel architectures. In particular, gradient descent is a sequential process and the resulting serial dependencies mean that DNN training cannot be parallelized effectively. Here, we show that a DNN may be replicated over a massive parallel architecture and used to provide a cumulative sampling of local solution space which results in rapid and robust learning. We introduce a complimentary convolutional bootstrapping approach that enhances performance of the parallel architecture further. Our parallelized convolutional bootstrapping DNN out-performs an identical fully-trained traditional DNN after only a single iteration of training.
]]></description>
<dc:subject>parallel deep-learning algorithms distributed-processing architecture machine-learning</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:19f2193ffacb/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:parallel"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:deep-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1606.02492">
    <title>[1606.02492] Convolutional Neural Fabrics</title>
    <dc:date>2016-07-02T11:34:47+00:00</dc:date>
    <link>http://arxiv.org/abs/1606.02492</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Despite the success of convolutional neural networks, selecting the optimal architecture for a given task remains an open problem. Instead of aiming to select a single optimal architecture, we propose a "fabric" that embeds an exponentially large number of CNN architectures. The fabric consists of a 3D trellis that connects response maps at different layers, scales, and channels with a sparse homogeneous local connectivity pattern. The only hyper-parameters of the model (nr. of channels and layers) are not critical for performance. While individual CNN architectures can be recovered as paths in the trellis, the trellis can in addition ensemble all embedded architectures together, sharing their weights where their paths overlap. The trellis parameters can be learned using standard methods based on back-propagation, at a cost that scales linearly in the fabric size. We present benchmark results competitive with the state of the art for image classification on MNIST and CIFAR10, and for semantic segmentation on the Part Labels dataset.
]]></description>
<dc:subject>deep-learning neural-networks classification algorithms more-is-better architecture rather-interesting nudge-targets consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:fb8aa0948969/</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:classification"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:more-is-better"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<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:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1506.04834">
    <title>[1506.04834] Tree-structured composition in neural networks without tree-structured architectures</title>
    <dc:date>2016-03-26T11:59:25+00:00</dc:date>
    <link>http://arxiv.org/abs/1506.04834</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Tree-structured neural networks encode a particular tree geometry for a sentence in the network design. However, these models have at best only slightly outperformed simpler sequence-based models. We hypothesize that neural sequence models like LSTMs are in fact able to discover and implicitly use recursive compositional structure, at least for tasks with clear cues to that structure in the data. We demonstrate this possibility using an artificial data task for which recursive compositional structure is crucial, and find an LSTM-based sequence model can indeed learn to exploit the underlying tree structure. However, its performance consistently lags behind that of tree models, even on large training sets, suggesting that tree-structured models are more effective at exploiting recursive structure.
]]></description>
<dc:subject>natural-language-processing neural-networks representation architecture machine-learning horse-races nudge-targets</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:e3b43f069942/</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:neural-networks"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:horse-races"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1501.04870">
    <title>[1501.04870] Scalable Multi-Output Label Prediction: From Classifier Chains to Classifier Trellises</title>
    <dc:date>2015-12-28T14:12:28+00:00</dc:date>
    <link>http://arxiv.org/abs/1501.04870</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Multi-output inference tasks, such as multi-label classification, have become increasingly important in recent years. A popular method for multi-label classification is classifier chains, in which the predictions of individual classifiers are cascaded along a chain, thus taking into account inter-label dependencies and improving the overall performance. Several varieties of classifier chain methods have been introduced, and many of them perform very competitively across a wide range of benchmark datasets. However, scalability limitations become apparent on larger datasets when modeling a fully-cascaded chain. In particular, the methods' strategies for discovering and modeling a good chain structure constitutes a mayor computational bottleneck. In this paper, we present the classifier trellis (CT) method for scalable multi-label classification. We compare CT with several recently proposed classifier chain methods to show that it occupies an important niche: it is highly competitive on standard multi-label problems, yet it can also scale up to thousands or even tens of thousands of labels.
]]></description>
<dc:subject>machine-learning multiclass-learning architecture representation rather-interesting algorithms nudge-targets consider:representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8872bd949dde/</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:multiclass-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<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:algorithms"/>
	<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:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1507.06228">
    <title>[1507.06228] Training Very Deep Networks</title>
    <dc:date>2015-08-02T21:00:24+00:00</dc:date>
    <link>http://arxiv.org/abs/1507.06228</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Theoretical and empirical evidence indicates that the depth of neural networks is crucial for their success. However, training becomes more difficult as depth increases, and training of very deep networks remains an open problem. Here we introduce a new architecture designed to overcome this. Our so-called highway networks allow unimpeded information flow across many layers on information highways. They are inspired by Long Short-Term Memory recurrent networks and use adaptive gating units to regulate the information flow. Even with hundreds of layers, highway networks can be trained directly through simple gradient descent. This enables the study of extremely deep and efficient architectures.
]]></description>
<dc:subject>deep-learning horse-races architecture rather-interesting neural-networks algorithms nudge-targets network-theory performance-measure</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:ef49d9b12997/</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:horse-races"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:neural-networks"/>
	<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:network-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:performance-measure"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://vimeo.com/131823232">
    <title>AADRL Spyropoulos Design Lab on Vimeo</title>
    <dc:date>2015-06-27T14:32:14+00:00</dc:date>
    <link>https://vimeo.com/131823232</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Research from the AADRL Spyropoulos Design Lab exploring an architecture that is self-aware, self-structured and self-assembles. The research explores high population of mobility agents that evolve an architecture that moves beyond the fixed and finite towards a behavioural model of interactive human and machine ecologies."]]></description>
<dc:subject>theodorespyropoulos 2015 architecture self-assembling self-aware robotics video via:robertogreco self-organization emergent-design biological-engineering</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:7ee083454fda/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:theodorespyropoulos"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:2015"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:self-assembling"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:self-aware"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:robotics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:video"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:robertogreco"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:self-organization"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:emergent-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:biological-engineering"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1506.03134">
    <title>[1506.03134] Pointer Networks</title>
    <dc:date>2015-06-13T21:46:36+00:00</dc:date>
    <link>http://arxiv.org/abs/1506.03134</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We introduce a new neural architecture to learn the conditional probability of an output sequence with elements that are discrete tokens corresponding to positions in an input sequence. Such problems cannot be trivially addressed by existent approaches such as sequence-to-sequence and Neural Turing Machines, because the number of target classes in each step of the output depends on the length of the input, which is variable. Problems such as sorting variable sized sequences, and various combinatorial optimization problems belong to this class. Our model solves the problem of variable size output dictionaries using a recently proposed mechanism of neural attention. It differs from the previous attention attempts in that, instead of using attention to blend hidden units of an encoder to a context vector at each decoder step, it uses attention as a pointer to select a member of the input sequence as the output. We call this architecture a Pointer Net (Ptr-Net). We show Ptr-Nets can be used to learn approximate solutions to three challenging geometric problems -- finding planar convex hulls, computing Delaunay triangulations, and the planar Travelling Salesman Problem -- using training examples alone. Ptr-Nets not only improve over sequence-to-sequence with input attention, but also allow us to generalize to variable size output dictionaries. We show that the learnt models generalize beyond the maximum lengths they were trained on. We hope our results on these tasks will encourage a broader exploration of neural learning for discrete problems.
]]></description>
<dc:subject>neural-networks machine-learning architecture rather-interesting combinatorics nudge-targets representation</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:90f54044e81d/</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:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:combinatorics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:representation"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1503.02368">
    <title>[1503.02368] EmptyHeaded: Boolean Algebra Based Graph Processing</title>
    <dc:date>2015-05-31T11:41:39+00:00</dc:date>
    <link>http://arxiv.org/abs/1503.02368</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[We present a graph pattern engine, EmptyHeaded, that uses recent algorithmic advances in join processing to compile patterns into Boolean algebra operations that exploit SIMD parallelism. The EmptyHeaded engine demonstrates that treating graph patterns as a general join processing problem can compete with and often outperform both specialized approaches and existing OLAP systems on graph queries. The core Boolean algebra operation performed in EmptyHeaded is set intersection. Extracting SIMD parallelism during set intersections on graph data is challenging because graph data can be skewed in several different ways. Our contributions are a demonstration of this new type of engine with Boolean algebra at its core, an exploration of set intersection representations and algorithms for set intersections that are optimized for skew. We demonstrate that EmptyHeaded outperforms specialized graph engines by over an order of magnitude and relational systems by over two orders of magnitude. Our results suggest that this new style of engine is a promising new direction for future graph engines and accelerators.
]]></description>
<dc:subject>database data-structures algorithms architecture graph-theory rather-interesting set-theory</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:da01f2d167a4/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:database"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-structures"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:graph-theory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:set-theory"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1407.6470">
    <title>[1407.6470] New Trends in Parallel and Distributed Simulation: from Many-Cores to Cloud Computing</title>
    <dc:date>2015-03-15T12:36:10+00:00</dc:date>
    <link>http://arxiv.org/abs/1407.6470</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Recent advances in computing architectures and networking are bringing parallel computing systems to the masses so increasing the number of potential users of these kinds of systems. In particular, two important technological evolutions are happening at the ends of the computing spectrum: at the "small" scale, processors now include an increasing number of independent execution units (cores), at the point that a mere CPU can be considered a parallel shared-memory computer; at the "large" scale, the Cloud Computing paradigm allows applications to scale by offering resources from a large pool on a pay-as-you-go model. Multi-core processors and Clouds both require applications to be suitably modified to take advantage of the features they provide. In this paper, we analyze the state of the art of parallel and distributed simulation techniques, and assess their applicability to multi-core architectures or Clouds. It turns out that most of the current approaches exhibit limitations in terms of usability and adaptivity which may hinder their application to these new computing architectures. We propose an adaptive simulation mechanism, based on the multi-agent system paradigm, to partially address some of those limitations. While it is unlikely that a single approach will work well on both settings above, we argue that the proposed adaptive mechanism has useful features which make it attractive both in a multi-core processor and in a Cloud system. These features include the ability to reduce communication costs by migrating simulation components, and the support for adding (or removing) nodes to the execution architecture at runtime. We will also show that, with the help of an additional support layer, parallel and distributed simulations can be executed on top of unreliable resources.
]]></description>
<dc:subject>parallel cloud-computing algorithms agent-based architecture to-understand</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:d9f496c6fed8/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:parallel"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cloud-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:agent-based"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:to-understand"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1411.5127">
    <title>[1411.5127] PivotCompress: Compression by Sorting</title>
    <dc:date>2015-01-19T11:40:47+00:00</dc:date>
    <link>http://arxiv.org/abs/1411.5127</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Sorted data is usually easier to compress than unsorted permutations of the same data. This motivates a simple compression scheme: specify the sorted permutation of the data along with a representation of the sorted data compressed recursively. The sorted permutation can be specified by recording the decisions made by quicksort. If the size of the data is known, then the quicksort decisions describe the data at a rate that is nearly as efficient as the minimal prefix-free code for the distribution, which is bounded by the entropy of the distribution. This is possible even though the distribution is unknown ahead of time. Used in this way, quicksort acts as a universal code in that it is asymptotically optimal for any stationary source. The Shannon entropy is a lower bound when describing stochastic, independent symbols. However, it is possible to encode non-uniform, finite strings below the entropy of the sample distribution by also encoding symbol counts because the values in the sequence are no longer independent once the counts are known. The key insight is that sparse quicksort comparison vectors can also be compressed to achieve an even lower rate when data is highly non-uniform while incurring only a modest penalty when data is random.
]]></description>
<dc:subject>compression sorting compressed-sensing (?) algorithms data-structures nudge-targets rather-interesting architecture consider:robustness</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:adfd1295bfd5/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:compression"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:sorting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:compressed-sensing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:(?)"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data-structures"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:robustness"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1408.2874">
    <title>[1408.2874] Urban DNA for cities evolutions. Cities as physical expression of dynamic equilibriums between competitive and cooperative forces</title>
    <dc:date>2014-11-08T13:08:55+00:00</dc:date>
    <link>http://arxiv.org/abs/1408.2874</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Cities are physical manifestations of our competitive and cooperative behaviours. The tension between these two forces generates dynamic equilibriums whose material expressions are cities and their evolutions. In a Darwinian cooperative view, as Darwinism does not involve only competition, the public benefit obtained by cooperation, return in terms of private benefit too. An urban genetic code is proposed, according to which cities emerge connecting nature and urbanity, and as sum of multiuse, independent micro-areas, each one with its centrality, job locations, parks and daily shops-services and amenities. This mechanism, called Isobenefit Urbanism, is not static and pre-designed, but allows infinitely dynamic changes and expansions. Rather than describing The ideal city, which doesn't exist outside our own minds, Isobenefit Urbanism describes what a city should avoid to be in order to not become an unideal city. Its six principles are the urban DNA which does not give predetermined forms but indications to follow according to contexts and times.
]]></description>
<dc:subject>urban-planning architecture deep-reading rather-interesting rather-odd criticism public-policy feature-extraction men-on-horses-pass-this-place-recently</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:83ef56818580/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:urban-planning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:deep-reading"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rather-odd"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:criticism"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:public-policy"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:feature-extraction"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:men-on-horses-pass-this-place-recently"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://biorxiv.org/content/early/2014/10/08/010124">
    <title>State-dependent information processing in gene regulatory networks | bioRxiv</title>
    <dc:date>2014-10-16T12:31:22+00:00</dc:date>
    <link>http://biorxiv.org/content/early/2014/10/08/010124</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Single cells have the potential and the necessity to process the information they receive from their environment. In particular, they commonly need to process temporal information obtained simultaneously from multiple inputs. In addition, response to multiple temporally ordered inputs is evolvable under laboratory conditions, suggesting that genetic networks are constructed to enable organisms to integrate novel information over time. However, the logic used by cellular regulatory networks to perform such complex information processing tasks is not understood. Here we show that gene regulatory networks are consistent with a computation paradigm known as reservoir computing (RC), and that this network structure enables single cells to process temporal information. A core subnetwork of genes (the reservoir) encodes and classifies complex time-varying information in a state-dependent manner. Because the state of the reservoir can then be decoded by a single layer of readout genes, allowing cells to process temporal information and efficiently learn new complex environmental conditions. In support of claim, we analyzed transcription factor networks from a variety of organisms, and found that their topology is compatible with RC. We identified the reservoir cores of the regulatory networks, and tested them using the memory-demanding NARMA prediction task, used as a standard benchmark for RC systems in machine learning. Our results show that the gene regulatory networks perform, and significantly better than other, more constrained topologies reported to work as RC. Interestingly, we find that, in real biological subnetworks, the information processing capacity of of the subnetwork is not strongly dependent on on the number of genes that receive input from the environment. Therefore, reservoir computing is an efficient way to for cells to process information without needing to increase the number of genes or the structure of the network. This is in contrast to other network configurations.

]]></description>
<dc:subject>network-theory theoretical-biology architecture makes-me-worry-about-adaptationism collective-intelligence nudge-targets consider:stress-testing</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2c1b2a5e991d/</dc:identifier>
<taxo:topics><rdf:Bag>	<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:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:makes-me-worry-about-adaptationism"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:collective-intelligence"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:consider:stress-testing"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1408.1245">
    <title>[1408.1245] Racing to Learn: Statistical Inference and Learning in a Single Spiking Neuron</title>
    <dc:date>2014-09-05T12:18:26+00:00</dc:date>
    <link>http://arxiv.org/abs/1408.1245</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[This paper describes the Synapto-dendritic Kernel Adapting Neuron (SKAN), a simple spiking neuron model that performs statistical inference and unsupervised learning of spatiotemporal spike patterns. SKAN is the first proposed neuron model to investigate the effects of dynamic synapto-dendritic kernels and demonstrate their computational power even at the single neuron scale. The rule set defining the neuron is simple: there are no complex mathematical operations such as normalization, exponentiation or even multiplication. The functionalities of SKAN emerge from the real-time interaction of simple additive and binary processes. Like a biological neuron, SKAN is robust to signal and parameter noise, and can utilize both in its operations. At the network scale neurons are locked in a race with each other with the fastest neuron to spike effectively hiding its learnt pattern from its neighbors. This use of time as a parameter is central and means that a SKAN network utilizes a minimal connectivity that scales linearly with the number of neurons. The robustness to noise, low connectivity requirements, high speed and simple building blocks not only make SKAN an interesting neuron model in computational neuroscience, but also make it ideal for implementation in digital and analog neuromorphic systems which is demonstrated through an implementation in a field programmable gate array (FPGA).
]]></description>
<dc:subject>neural-networks architecture spiking-neurons signal-processing machine-learning simplicity quite-interesting nudge-targets parametrization</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:2769799050b2/</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:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:spiking-neurons"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:signal-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:simplicity"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:quite-interesting"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:parametrization"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.metropolismag.com/Point-of-View/January-2014/In-Photos-Eero-Saarinens-Bell-Labs/">
    <title>Eero Saarinen's Bell Labs, Now Devoid of Life - Point of View - January 2014</title>
    <dc:date>2014-01-17T14:54:16+00:00</dc:date>
    <link>http://www.metropolismag.com/Point-of-View/January-2014/In-Photos-Eero-Saarinens-Bell-Labs/</link>
    <dc:creator>Vaguery</dc:creator><dc:subject>architecture via:mymarkup abandoned-places the-march-of-something photography community</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:e568d9318687/</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:via:mymarkup"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:abandoned-places"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:the-march-of-something"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:photography"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:community"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://think-info.com/2013/06/27/author-experience/">
    <title>The principles of Author Experience (AX)</title>
    <dc:date>2013-06-28T10:55:10+00:00</dc:date>
    <link>http://think-info.com/2013/06/27/author-experience/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Let’s start with a quiz: what is the purpose of a CMS? This may sound like a rather absurd question. After all, everyone knows that a CMS is used to store information to present somewhere, be…]]></description>
<dc:subject>content user-experience design architecture usability via:adrianh</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:3d0cb4517a22/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:content"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:user-experience"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:usability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:adrianh"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1304.7118">
    <title>[1304.7118] Synthesis of neural networks for spatio-temporal spike pattern recognition and processing</title>
    <dc:date>2013-04-30T11:40:43+00:00</dc:date>
    <link>http://arxiv.org/abs/1304.7118</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[The advent of large scale neural computational platforms has highlighted the lack of algorithms for synthesis of neural structures to perform predefined cognitive tasks. The Neural Engineering Framework offers one such synthesis, but it is most effective for a spike rate representation of neural information, and it requires a large number of neurons to implement simple functions. We describe a neural network synthesis method that generates synaptic connectivity for neurons which process time-encoded neural signals, and which makes very sparse use of neurons. The method allows the user to specify, arbitrarily, neuronal characteristics such as axonal and dendritic delays, and synaptic transfer functions, and then solves for the optimal input-output relationship using computed dendritic weights. The method may be used for batch or online learning and has an extremely fast optimization process. We demonstrate its use in generating a network to recognize speech which is sparsely encoded as spike times.
]]></description>
<dc:subject>neural-networks algorithms engineering-design nudge-targets speech-recognition library architecture</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:cb3ad7383591/</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:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:speech-recognition"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1302.1554">
    <title>[1302.1554] Object-Oriented Bayesian Networks</title>
    <dc:date>2013-03-03T21:15:52+00:00</dc:date>
    <link>http://arxiv.org/abs/1302.1554</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Bayesian networks provide a modeling language and associated inference algorithm for stochastic domains. They have been successfully applied in a variety of medium-scale applications. However, when faced with a large complex domain, the task of modeling using Bayesian networks begins to resemble the task of programming using logical circuits. In this paper, we describe an object-oriented Bayesian network (OOBN) language, which allows complex domains to be described in terms of inter-related objects. We use a Bayesian network fragment to describe the probabilistic relations between the attributes of an object. These attributes can themselves be objects, providing a natural framework for encoding part-of hierarchies. Classes are used to provide a reusable probabilistic model which can be applied to multiple similar objects. Classes also support inheritance of model fragments from a class to a subclass, allowing the common aspects of related classes to be defined only once. Our language has clear declarative semantics: an OOBN can be interpreted as a stochastic functional program, so that it uniquely specifies a probabilistic model. We provide an inference algorithm for OOBNs, and show that much of the structural information encoded by an OOBN--particularly the encapsulation of variables within an object and the reuse of model fragments in different contexts--can also be used to speed up the inference process.]]></description>
<dc:subject>models statistics machine-learning ontology algorithms architecture nudge-targets</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:1c848f2de2f3/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:models"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:statistics"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:machine-learning"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ontology"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:algorithms"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1211.5842">
    <title>[1211.5842] A Novel Algorithm for Real-time Procedural Generation of Building Floor Plans</title>
    <dc:date>2013-02-25T23:38:32+00:00</dc:date>
    <link>http://arxiv.org/abs/1211.5842</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Real-time generation of natural-looking floor plans is vital in games with dynamic environments. This paper presents an algorithm to generate suburban house floor plans in real-time. The algorithm is based on the work presented in [1]. However, the corridor placement is redesigned to produce floor plans similar to real houses. Moreover, an optimization stage is added to find a corridor placement with the minimum used space, an approach that is designed to mimic the real-life practices to minimize the wasted spaces in the design. The results show very similar floor plans to the ones designed by an architect.]]></description>
<dc:subject>algorithms generative-art gaming rendering architecture nudge-targets</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:99f3f2c643e0/</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:generative-art"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:gaming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rendering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://arxiv.org/abs/1105.0322">
    <title>[1105.0322] A Computational Model for the Direct Execution of General Specifications with Multi-way Constraints</title>
    <dc:date>2013-02-25T12:16:04+00:00</dc:date>
    <link>http://arxiv.org/abs/1105.0322</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[In this paper, we propose a computational model for the direct execution of general specifications with multi-way constraints. Although this computational model has a similar structure to existing constraint programming models, it is not meant for solving constraint satisfaction problems but rather for the simulation of social systems and to continue to execute assigned processes. Because of this similar structure, it is applicable to the spectrum of the constraint solver, which is purple in this model. Essentially, it is a technology that can speed up the construction of large-scale network systems. This model can be efficiently executed to directly describe design content in a simple way.]]></description>
<dc:subject>constraint-programming programming-language specification design architecture nudge-targets</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:6436dfd66bbe/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:constraint-programming"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:programming-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:specification"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge-targets"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://github.com/celluloid/celluloid">
    <title>celluloid/celluloid · GitHub</title>
    <dc:date>2012-12-17T22:07:11+00:00</dc:date>
    <link>https://github.com/celluloid/celluloid</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Automatic "deadlock-free" synchronization: Celluloid uses a concurrent object model which combines method dispatch and thread synchronization. Each actor is a concurrent object running in its own thread, and every method invocation is wrapped in a fiber that can be suspended whenever it calls out to other actors, and resumed when the response is available. This means methods which are waiting for responses from other actors, external messages, or other system events (including I/O with Celluloid::IO) can be suspended and will never block other methods that are ready to run. This won't prevent bugs in Celluloid, bugs in other thread-safe libraries you use, and even certain "dangerous" features of Celluloid from causing your program to deadlock, but in general, programs built with Celluloid will be naturally immune to deadlocks.

Fault-tolerance: Celluloid has taken to heart many of Erlang's ideas about fault-tolerance in order to enable self-healing applications. The central idea: have you tried turning it off and on again? Celluloid takes care of rebooting subcomponents of your application when they crash, whether it's a single actor, or large (potentially multi-tiered) groups of actors that are all interdependent. This means rather that worrying about rescuing every last exception, you can just sit back, relax, and let parts of your program crash, knowing Celluloid will automatically reboot them in a clean state. Celluloid provides its own implementation of the core fault-tolerance concepts in Erlang including linking, supervisors, and supervision groups.

Futures: Ever wanted to call a method "in the background" and retrieve the value it returns later? Celluloid futures do just that. It's like calling ahead to a restaurant to place an order, so they can work on preparing your food while you're on your way to pick it up. When you ask for a method's return value, it's returned immediately if the method has already completed, or otherwise the current method is suspended until the value becomes available.

]]></description>
<dc:subject>concurrency ruby framework answer-factory architecture</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:8c9d5859fabb/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:concurrency"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:ruby"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:framework"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:answer-factory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.archiparlour.org/worklifework-balance/">
    <title>Work/life/work balance | Parlour</title>
    <dc:date>2012-05-28T12:14:34+00:00</dc:date>
    <link>http://www.archiparlour.org/worklifework-balance/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA['Arguably the most pervasive element enabling exploitative office culture is the postmodern trickery of the contemporary working environment. Slavoj Žižek argues that modern employment tactics create the illusion that our employer is our friend. This fabrication empowers the employer while denying the employed the right to vocalise and protest dissatisfaction of their working conditions. “You’re not going to stick around and help out? I thought we were a team? I thought we were friends?”']]></description>
<dc:subject>worklife communities-of-practice architecture hierarchies values exploitation academic-culture</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:84f38a9d55ad/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:worklife"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:communities-of-practice"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:hierarchies"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:values"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:exploitation"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:academic-culture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://caines.ca/blog/programming/the-sun-is-setting-on-rails-style-mvc-frameworks/">
    <title>The Sun is Setting on Rails-style MVC Frameworks « caines.ca/blog</title>
    <dc:date>2012-03-06T12:15:59+00:00</dc:date>
    <link>http://caines.ca/blog/programming/the-sun-is-setting-on-rails-style-mvc-frameworks/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Lately I've been thinking a lot about the impact of the move to a thick client architecture for web applications, and I'm becoming more and more certain that this means that Rails-style MVC frameworks on the server-side are going to end up being phased out in favour of leaner and meaner frameworks that better address the new needs of thick-client architecture."]]></description>
<dc:subject>software-development architecture project-structure design-patterns client-side-processing</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b1b610342538/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:project-structure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design-patterns"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:client-side-processing"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://faye.jcoglan.com/">
    <title>Faye: Simple pub/sub messaging for the web</title>
    <dc:date>2011-05-15T13:09:52+00:00</dc:date>
    <link>http://faye.jcoglan.com/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA[Faye is an easy-to-use publish-subscribe messaging system based on the Bayeux protocol. It provides message servers for Node.js and Rack, and clients for use in Node and Ruby programs and in the browser.]]></description>
<dc:subject>distributed-processing publish-and-subscribe architecture software-development Ruby javascript</dc:subject>
<dc:source>https://pinboard.in/</dc:source>
<dc:identifier>https://pinboard.in/u:Vaguery/b:48f79c215e07/</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:publish-and-subscribe"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Ruby"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:javascript"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://www.worldchanging.com/archives/011242.html?utm_source=feedburner&amp;utm_medium=feed&amp;utm_campaign=Feed%3A+worldchanging_fulltext+(WorldChanging.com+Full+Text)">
    <title>Worldchanging: Bright Green: David Benqué's &quot;Fabulous Fabbers&quot; Project: Imagining New Industry in Future Cities</title>
    <dc:date>2010-06-08T12:09:52+00:00</dc:date>
    <link>http://www.worldchanging.com/archives/011242.html?utm_source=feedburner&amp;utm_medium=feed&amp;utm_campaign=Feed%3A+worldchanging_fulltext+(WorldChanging.com+Full+Text)</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["For instance, there is the Rogue Factory unit producing "custom high-tech goods"—but "what would the black market of 'special orders' look like?" Benque asks. This "black market of 'special orders'" for things like 3D-printed human organs would also be something quite extraordinary to see, given another two decades' time and cheap-enough bio-ink."
]]></description>
<dc:subject>fabrication fab architecture modeling future makers maker-culture</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:b415ec525ca5/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:fabrication"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:fab"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:modeling"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:future"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:makers"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:maker-culture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://malvasiabianca.org/archives/2010/04/christopher-alexanders-fort-mason-bench/">
    <title>christopher alexander’s fort mason bench | malvasia bianca</title>
    <dc:date>2010-04-25T12:45:43+00:00</dc:date>
    <link>http://malvasiabianca.org/archives/2010/04/christopher-alexanders-fort-mason-bench/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["As Alexander repeatedly points out, you can’t consider a construction in isolation, you have to consider the construction in context. And the context for this bench is rather remarkable: you have rather steep hills covered with trees behind you and to your right, you have the Fort Mason buildings to your left, and in front of you you have a gorgeous view of the San Francisco Bay, with Alcatraz and Angel Island in the distance."
]]></description>
<dc:subject>Alexandrianism design-patterns pattern-language architecture public-space design social-dynamics</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:d3f9e7ea109b/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Alexandrianism"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design-patterns"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:pattern-language"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:public-space"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:social-dynamics"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://robots.thoughtbot.com/post/443934722/redis-data-cheeseburgers#disqus_thread">
    <title>Redis: Data Cheeseburgers - GIANT ROBOTS SMASHING INTO OTHER GIANT ROBOTS</title>
    <dc:date>2010-03-18T12:51:33+00:00</dc:date>
    <link>http://robots.thoughtbot.com/post/443934722/redis-data-cheeseburgers#disqus_thread</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Explaining Redis is tough, it’s easy to say “a data structures server” or “memcached on steroids” or something more jargon filled. It’s not exactly a key value store, it’s definitely not a relational or document-oriented database. The biggest selling point of Redis is that usually as programmers we have to bend our data into a table or document to save it, but with Redis we can persist data as we conceptually visualize it. Tasty!"
]]></description>
<dc:subject>data database NoSQL distributed-processing virtual-memory library Ruby architecture</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:d76fd32b2a39/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:data"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:database"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:NoSQL"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:virtual-memory"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:library"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Ruby"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://code.google.com/apis/sketchup/">
    <title>Google SketchUp Ruby API - Google Code</title>
    <dc:date>2010-03-12T17:09:10+00:00</dc:date>
    <link>http://code.google.com/apis/sketchup/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Google SketchUp is software that you can use to create 3D models of anything you like. With its embedded Ruby application programming interface (API), you can extend and customize the program to suit your needs. If you love SketchUp but ever thought "I just wish it did XYZ," then there's a good chance the Ruby API can make it happen. "
]]></description>
<dc:subject>SketchUp Google Ruby API Google-apps software-development extensibility CAD engineering-design architecture rendering via:thetrek nudge</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:7be9ea685d51/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:SketchUp"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Google"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Ruby"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:API"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:Google-apps"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:extensibility"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:CAD"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:engineering-design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:rendering"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:via:thetrek"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:nudge"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="http://wonderfullyflawed.com/2009/07/02/get-your-api-right/">
    <title>Get Your API Right « Trek</title>
    <dc:date>2010-03-10T15:31:56+00:00</dc:date>
    <link>http://wonderfullyflawed.com/2009/07/02/get-your-api-right/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Every project I’ve worked on in the last two years has heavily involved the use of web APIs. Libersy at the time (no idea about now) had an architecture that was extensively API based, even for communication between internal applications (an architecture I strongly argued against, bee tea dubs). Since then I’ve futzed with web APIs almost exclusively. From very narrow focused uses like University of Michigan’s Bluestream Service, to more broad but still fairly local APIs like the Ann Arbor District Library’s soon-to-be-updated API, all the way to APIs of major web applications like Twitter and Flickr.

Constant exposure has turned me into a bit of a snob: I can’t stand working with a poorly designed API! If you’re about to design or release an API for the web and want to avoid the ire of your developers, I’ve summed up the best (and worst) of what I’ve seen into 8 rules:"
]]></description>
<dc:subject>API software-development interoperability architecture design best-practices</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:60a94cdb4ef7/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:API"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:software-development"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:interoperability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:design"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:best-practices"/>
</rdf:Bag></taxo:topics>
</item>
<item rdf:about="https://www.cloudkick.com/blog/2010/mar/02/4_months_with_cassandra/">
    <title>cloudkick | blog: 4 Months with Cassandra, a love story</title>
    <dc:date>2010-03-04T13:47:30+00:00</dc:date>
    <link>https://www.cloudkick.com/blog/2010/mar/02/4_months_with_cassandra/</link>
    <dc:creator>Vaguery</dc:creator><description><![CDATA["Write performance in Cassandra is excellent. The internals are specifically geared towards a heavy-write system. It writes to a memory table and a serial commit log, and every so often the memory table is flushed to disk in what the Big Table paper describes as a sorted strings table, often called an SSTable — an immutable data structure. There is a lot more happening behind the scenes, but the performance characteristics are clear: there is nothing slow in the write path. The Cassandra wiki page on Architecture Internals provides more details."
]]></description>
<dc:subject>infrastructure distributed-processing cloud-computing databases architecture administration opensource scalability storage</dc:subject>
<dc:identifier>https://pinboard.in/u:Vaguery/b:33fe3033d42e/</dc:identifier>
<taxo:topics><rdf:Bag>	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:infrastructure"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:distributed-processing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:cloud-computing"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:databases"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:architecture"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:administration"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:opensource"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:scalability"/>
	<rdf:li rdf:resource="https://pinboard.in/u:Vaguery/t:storage"/>
</rdf:Bag></taxo:topics>
</item>
</rdf:RDF>