Hekovnik 3 Mesece Kasnenje

•Descargar como PPT, PDF•

0 recomendaciones•285 vistas

Simon Belak

Tecnología

Hekovnik 3 mesece kasneje [email_address]

Namensko okolje ,[object Object],[object Object],[object Object],[object Object],[object Object]

Skupnost zvečuje produktivnost ,[object Object],[object Object],[object Object],[object Object],[object Object]

Članstvo ,[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],* za dovolj majhne vrednosti

AI urice ,[object Object],[object Object],[object Object],[object Object]

Zgradba delavnice ,[object Object],[object Object],[object Object],[object Object]

Más contenido relacionado

Más de Simon Belak

Exploratory analysis

Simon Belak

Levelling up your data infrastructure

Simon Belak

Recommendation algorithms and their variations such as ranking are the most common way for machine learning to find its way into a product where it is not the main focus. In this talk we’ll dig into the subtleties of making recommendation algorithms a seamless and integral part of your UX (goal: it should completely fade into the background. The user should not be aware she’s interacting with any kind of machine learning, it should just feel right, perhaps smart or even a tad like cheating); how to solve the cold start problem (and having little training data in general); and how to effectively collect feedback data. I’ll be drawing from my experiences building Metabase, an open source analytics/BI tool, where we extensively use recommendations and ranking to keep users in a state of flow when exploring data; to help with discoverability; and as a way to gently teach analysis and visualization best practices; all on the way towards building an AI data scientist.

The subtle art of recommendation

Simon Belak

Metabase Ljubljana Meetup #2

Simon Belak

Metabase lj meetup

Simon Belak

In this talk we will look at how to efficiently (in both space and time) summarize large, potentially unbounded, streams of data by approximating the underlying distribution using so-called sketch algorithms. The main approach we are going to be looking at is summarization via histograms. Histograms have a number of desirable properties: they work well in an on-line setting, are embarrassingly parallel, and are space-bound. Not to mention they capture the entire (empirical) distribution which is something that otherwise often gets lost when doing descriptive statistics. Building from that we will delve into related problems of sampling in a stream setting, and updating in a batch setting; and highlight some cool tricks such as capturing time-dynamics via data snapshotting. To finish off we will touch upon algorithms to summarize categorical data, most notably count-min sketch.

Sketch algorithms

Simon Belak

Transducers -- composable algorithmic transformation decoupled from input or output sources -- are Clojure’s take on data transformation. In this talk we will look at what makes a transducer; push their composability to the limit chasing the panacea of building complex single-pass transformations out of reusable components (eg. calculating a bunch of descriptive statistics like sum, sum of squares, mean, variance, ... in a single pass without resorting to a spaghetti ball fold); explore how the fact they are decoupled from input and output traversal opens up some interesting possibilities as they can be made to work in both online and batch settings; all drawing from practical examples of using Clojure to analize “awkward-size” data.

Transducing for fun and profit

Simon Belak

You have defined your metrics, setup dashboards, and started to incorporate data into your everyday. Great, but I have some bad news for you. Almost certainly some of you metrics are wrong. At best these mistakes mean that you are not getting all the insights you could have, at worse some of the conclusions you have drawn from them are wrong. In this talk we will go through the most common but pernicious mistakes and unravel the mechanisms behind them so by the end of the talk you will be equipped with an analytical toolset to spot them on your own. The main classes of errors we will cover are: viewing data as a static process; not considering error margins and variance; picking the wrong reference point; assuming your population is homogeneous; and improperly accounting for costs.

Your metrics are wrong

Simon Belak

Writing correct smart contract is hard (a recent study estimated that 3% of Ethereum contracts in the wild have some sort of security vulnerability; we all know of the DAO and Parity exploits, …). There are two main reasons for this. First and foremost developing for the blockchain is quite different than what most programmers are used to. The level of concurrency is far beyond our (von Neumann) intuition and mental models. And you can’t stop and inspect running code like you can in other systems. Taken together blockchain is closer to a physical/living system than conventional software — a fact not reflected in the tools available. Compared to other domains our tooling and programming languages are somewhere between rudimentary and bad; and a far cry from where they would need to be to augment developers and help make programming for the blockchain less alien and less error prone. In this talk we will first unpack what makes programming for the blockchain hard, and what are the most common types of vulnerabilities and their causes. Then we will look at the state of art programming language research in correctness proving and programming massively concurrent systems; and how these can be applied to programming smart contracts; revisit some technologies from the past that didn’t get traction at the time, but are nevertheless worth studying; and finishing off by trying to imagine how programming for the blockchain should, and perhaps one day will, look like.

Writing smart contracts the sane way

Simon Belak

Online statistical analysis using transducers and sketch algorithms

Simon Belak

OpenAI recently published a fun paper where they showed using evolution algorithms to train policy networks to perform on par with state of the art reinforcement deep learning. In this talk we’ll try to reimplement the main ideas in that paper using Neanderthal (blazing fast matrix and linear algebra computations) and Cortex (neural networks); make it massively distributed using Onyx; build a simulation environment using re-frame; and of course save our princess from no particular harm in our toy game example

Save the princess

Simon Belak

Data driven going to market strategy

Simon Belak

You can do cool and unexpected things if your entire type system is a first class citizen and accessible at runtime. With the introduction of spec, Clojure got its own distinct spin on a type system. Just as macros add another -time (runtime and compile time) where the full power of the language can be used, spec does to describing data. The result is an entire additional type system that is a first class citizen and accessible at runtime that facilitates validation, generative testing (a la QuickCheck), destructuring (pattern matching into deeply nested data), data macros (recursive transformations of data) and a pluginable error system. And then you can start building on top of it. The talk will be half introduction to spec and the ideas packed within it, and half experience report instrumenting 15k loc production codebase (primarily ETL and analytics) with spec.

Spec: a lisp-flavoured type system

Simon Belak

Clojure has always been good at manipulating data. With the release of spec and Onyx (“a masterless, cloud scale, fault tolerant, high performance distributed computation system”) good became best. In this talk you will learn about a streaming data layer architecture build around Kafka and Onyx that is self-describing, declarative, scalable and convenient to work with for the end user. The focus will be on the power and elegance of describing data and computation with data; the inferences and automations that can be built on top of that; and how and why Clojure is a natural choice for tasks that involve a lot of data manipulation, touching both on functional programming and lisp-specifics such as code-is-data. We will look at how such an approach can be used to manage a data warehouse by automatically inferring materialized views from raw incoming data or other views based on a combination of heuristics, statistical analysis (seasonality, outlier removal, ...) and predefined ontologies. Doing so is a practical way to maintain a large number of views, increasing their availability and abstracting the complexity into declarative rules, rather than having an ETL pipeline with dozens or even hundreds of hand crafted tasks. The system described requires relatively little effort upfront but can easily grow with one's needs both in terms of scale as well as scope. With its good introspection capabilities and strong decoupling it is for instance an excellent substrate for putting machine learning algorithms in production, which is the final use-case we will dive into.

A data layer in clojure

Simon Belak

Segmentacija je ključna za učinkovito nagovarjanje in konvertiranje potancialnih strank. Simon Belak, vodja analitike pri GoOptiju in transmedijski urednik pri kritičnem časopisu Tribuna, je razkril, kako odkrivati segmente iz podatkov. Po njegovih besedah je povsem neupravičeno, da je segmentacija povečini statična in narejena na slepo, neupoštevajoč podatke. V predavanju je predstavil aletrnativo: analitično delno avtomatično odkrivanje segmentov iz podatkov. Na konkretnih primerih je pokazal, kako preslikati podatke o interakcijah s strankami (obisk strani kot pokazatelji interesov, odgovori na ankete, vzorci premikanja po straneh, odpiranje emailov…) v model strank in nadaljeval z razdelitvijo v segmente. Simon je za konec izpostavil najpogostejše pasti in drobne trike za primere, ko imamo malo podatkov, ali so le-ti nejasni.

Odkrivanje segmentov iz podatkov

Simon Belak

@sbelak Simon Belak Using Onyx in anger Clojure has always been good at manipulating data. With the release of spec and Onyx ("masterless, cloud scale, fault tolerant, high performance distributed computation system") good became best. In this talk I will walk you through a data layer architecture build around Kafka an Onyx that is self-describing, declarative, scalable and convenient to work with for the end user. The focus will be on the power and elegance of describing data and computation with data; and the inferences and automations that can be built on top of that.

Using Onyx in anger

Simon Belak

Spec + onyx

Simon Belak

Whenever a programming language comes out with a new feature, us smug lisp weenies shrug and point out how lisp had that in the early seventies; and if you look at the list of influences of a given language, there is bound to be a lisp in there. In this talk I will try to unpack what makes lisp special, why it is called programming programming language , how it changes one’s thinking, and how that thinking can be applied elsewhere.

Dao of lisp

Simon Belak

Successfully forecasting future demand is key in allowing GoOpti its low prices while isolating transport partners from risk. It this talk Simon Belak, Chief Data scientist at GoOpti, will take you through how he approaches forecasting and the lessons that he learned along the way. The focus is going to be on models that do not require excessive amounts of data, are legible and work well as part of a continuous process (rather than being a one-of problem).

Predicting the future with goopti

Simon Belak

Living with-spec

Simon Belak

Más de Simon Belak (20)

Exploratory analysis

Levelling up your data infrastructure

The subtle art of recommendation

Metabase Ljubljana Meetup #2

Metabase lj meetup

Sketch algorithms

Transducing for fun and profit

Your metrics are wrong

Writing smart contracts the sane way

Online statistical analysis using transducers and sketch algorithms

Save the princess

Data driven going to market strategy

Spec: a lisp-flavoured type system

A data layer in clojure

Odkrivanje segmentov iz podatkov

Using Onyx in anger

Spec + onyx

Dao of lisp

Predicting the future with goopti

Living with-spec