ML Affairs

Kafka Streams vs Flink Is The Wrong Question

2026-04-01T00:00:00+00:00

I am not neutral about Flink.

I have spent years advocating for it, using it anywhere I could, organizing London meetups around it before COVID, and talking to anyone who would listen about why the dataflow model is such a good way to think. I still love that model. I love how naturally event-driven systems can align to a domain: a ship enters a port, this state changes, that downstream action happens next. Both Flink and Kafka Streams let you express stateful processes in a way that can stay close to business reality.

And that is exactly why this lesson was useful for me.

When I joined a later role, I found myself surrounded by repositories built with Kafka Streams. My first instinct was simple: replace them with Flink. Some of those repos were chaotic, under-loved, and far away from the kind of streaming architecture I like to build. I felt outside my waters. I wanted to modernize, refactor, migrate, clean the slate.

But over time, after giving those systems the attention they deserved, I learned something more valuable than another framework argument:

The useful question is not whether Flink is "better" than Kafka Streams.

The useful question is when your streaming problem stops being an application concern and becomes a platform concern.

That is still the line I care about most. But now I care about it with much more respect for both sides.

This is the real fork in the road: not which mascot wins, but whether the system is still application-shaped or is becoming a platform concern.

The Bias I Had To Correct

There is a recurring engineering mistake hiding in this topic: you inherit a system that feels old, untidy, or unfashionable, and you start reaching for the framework you know better.

I have had to relearn this lesson more than once in my career. It is almost embarrassing how often it comes back, which is probably proof of how important it is.

I originally wanted to replace those Kafka Streams solutions largely because I was more fluent in Flink. That fluency gave me clarity in one framework and discomfort in the other, and I briefly mistook that feeling for architecture.

That is a dangerous mistake.

Once I slowed down, cleaned up the code, made the domain model clearer, and brought more disciplined engineering practices to those codebases, I ended up with a much less dramatic conclusion:

if you give an existing streaming system enough love, enough structure, and enough respect for the underlying model, you can get very far without rewriting it.

That does not make Flink less good. It just makes engineering judgment less theatrical.

The urge to rewrite is strong. The better question is whether the system is structurally wrong or simply under-engineered.

The Lesson

Framework preference is not architecture. My first instinct was to rewrite messy Kafka Streams systems into Flink. The better answer was to clean the model first, then decide whether the runtime was actually the problem.

What I Still Love About Flink

Let me be clear: I am still a very strong Flink advocate.

I still think the Flink dataflow model is one of the cleanest ways to reason about stateful stream processing. Operator boundaries are explicit. State feels local to the operator that owns it. Checkpointing, recovery, repartitioning, and event-time semantics feel like first-class runtime concepts instead of side effects of a library attached to a broker.

That is a big deal to me, because I care a lot about how easily a streaming system can be explained.

When a framework makes the flow of state and events easy to communicate, it usually also makes the system easier to maintain.

But none of that comes for free.

Flink asks you to pay an upfront complexity tax in operations, onboarding, debugging, and platform maturity. Misconfigured jobs are not charming. They are expensive. The model feels cleaner once you have paid that tax, not before.

This is the part many framework comparisons skip: the platform is powerful, but you do pay for the privilege of operating it well.

This is why I still reach for Flink eagerly when the runtime itself needs to be a serious part of the design.

Where Kafka Streams Grew On Me

What changed for me was not that I stopped liking Flink. What changed is that I learned to appreciate where Kafka Streams is more enabling than I first allowed.

1. The State Model Is Different, Not Just Worse

One of the things that threw me off at first was the ergonomics of state in Kafka Streams.

Kafka Streams gives you state stores, changelog-backed recovery, and table-oriented patterns that can feel more globally available than Flink’s cleaner operator-local state style. The processor API is very explicit that processors interact with attached state stores, and those stores are fault-tolerant by default. In practice, the default persistent path is a local RocksDB store backed by a compacted changelog topic. On top of that, table abstractions and GlobalKTable-style patterns can make shared reference data or queryable state feel very convenient in the application model.

That convenience comes with real trade-offs:

local RocksDB state is fast and useful, but fault tolerance still depends on changelogs
restore times can still become painful at scale, especially when local state is lost and the store must rebuild from the changelog
the relationship between topology code and materialized state can become messy in under-disciplined repos
the convenience of reachable state can encourage poor habits if the model is not kept clear

But convenience is still convenience. There are use cases where having easier access to shared or queryable state is genuinely useful, and it would be dishonest to pretend otherwise.

My instinct, because of my Flink background, was to push Kafka Streams code toward a more operator-local way of thinking anyway: make state ownership clearer, keep logic close to the transform that really owns it, and avoid turning the topology into a stateful soup. That discipline improved those codebases a lot.

But that is exactly the point: bringing some Flink-style discipline into Kafka Streams made the code better. It did not prove that the whole system needed to become Flink.

2. Kafka-Native Integration Is A Real Strength

I am not even talking here about the obvious ecosystem point in a lazy way. Yes, Kafka Streams lives naturally inside the Kafka ecosystem. Yes, it works comfortably with keyed messages, schemas, topics, and the usual surrounding tooling. Yes, schema-registry-oriented flows often feel more straightforward there.

That matters. Not because Flink cannot do these things. It can. But because being native to the ecosystem reduces friction when the whole world around the application is already shaped like Kafka.

You should not dismiss that as a minor detail. It is part of the operating model.

Where Flink Still Pulls Away

This is where my original instincts still hold up.

1. Scaling Stops At The Broker Boundary Much Earlier In Kafka Streams

The scaling constraint in Kafka Streams is tightly tied to partitions, tasks, and instances. That is not a bug. It is the design. It is also why the system stays so close to Kafka itself.

But it has consequences.

There comes a point where adding more application instances does not really solve the problem because the partitioning boundary is already telling you how far you can go cleanly. You can absolutely scale Kafka Streams, but the broker topology keeps exerting a much stronger influence on the application topology.

At that point, scaling stops being primarily demand-driven and starts becoming topology-constrained.

Flink, by contrast, is still constrained at the source when consuming from Kafka, but once records are inside the runtime it has far more freedom to repartition, redistribute work, and run operators at a different parallelism from the source. I would not call that infinite scaling. I would call it a materially more flexible runtime.

That difference becomes major once traffic spikes, repartition pressure, or uneven workloads start shaping your architecture.

2. Checkpointing And Recovery Are In A Different League

This is still one of the clearest differentiators for me.

Flink’s checkpointing model is part of the platform. Recovery is an explicit runtime capability, not just the consequence of rebuilding local state from changelogs. The barrier-based snapshotting model, savepoints, and state redistribution semantics are exactly the kind of thing that make Flink feel like an engine rather than a library.

In Kafka Streams, the picture is a little more nuanced than “it always has to read the whole changelog again.” If the local state store still exists, the runtime can replay from the previously checkpointed offset and catch up from there. If local state is gone, it has to rebuild from the changelog from the beginning of the retained data. That is meaningfully better than a naive full replay every time, and it is one of the reasons the RocksDB path works as well as it does in practice.

But the deeper point still holds: fault tolerance and task migration are still anchored in changelog restoration, and on large stateful applications that can become one of the dominant operational pain points. Retention choices matter. Restore time matters. Recovery becomes less predictable under failure. Operational patience starts turning into architecture.

Running Streams applications and state restoration

At smaller scale this looks like an implementation detail. At larger scale it starts deciding how painful failure and recovery really feel in production.

That is the point where Flink stops being a nice architectural preference and starts becoming a serious operational advantage.

The Real Trade-Off

So, here is the trade in one sentence:

Kafka Streams is a very good way to build Kafka-native streaming applications.

Flink is a very good way to operate stateful dataflows as a platform concern.

Those are not the same problem, even if the diagrams sometimes look similar.

And this is why I do not buy generic advice like “use Flink if you need scale” or “use Kafka Streams if you want simplicity.”

Both statements are misleading. They sound practical, but they hide the real failure modes, encourage cargo-cult architecture, and make comfort-driven rewrites sound more principled than they are.

The better rule is this:

If your system is still primarily an application that processes Kafka topics, Kafka Streams is often the right engineering choice.

If your system is becoming a stateful processing layer that needs explicit control over time, state, replay, recovery, and heterogeneous I/O, Flink starts to justify its existence very quickly.

The Harder Lesson

This is the part I most wanted to say personally.

I am still a huge Flink proponent. That has not changed.

What has changed is that I now trust myself less when my first reaction is “we should rewrite this in the framework I prefer.”

That reaction is often just comfort seeking.

Sometimes you really should migrate. Sometimes the runtime boundary is wrong, recovery is too painful, scaling is too constrained, and Flink is the more honest architecture.

But sometimes the better engineering decision is to love the existing system properly: clarify the model, clean the state boundaries, improve the abstractions, respect the domain flow, and stop assuming that old means wrong.

That was the lesson here for me.

If I had followed my first instinct blindly, I would have replaced some systems for the wrong reason.

What I Would Actually Do

If I were starting with a Kafka-centric JVM team, modest operational requirements, and clean Kafka-in/Kafka-out topologies, I would still be very happy with Kafka Streams.

I would move toward Flink once one or more of these became persistently true:

stateful jobs became expensive to recover or rescale
I needed a broader processing platform rather than a library
event-time and replay behaviour started driving design choices
the system stopped being comfortably Kafka-shaped
operability and runtime visibility became a daily concern rather than an occasional debugging aid

That is the moment Flink stops being overkill and starts being the more honest architecture.

And that brings me back to where I started.

I still love Flink. I still think its model is easier to reason about once runtime concerns become serious. I still think it is the stronger platform when state, recovery, and rescaling dominate the design.

Many rewrites begin as comfort and only later get dressed up as architecture.

That is the part I understand better now, and it is probably the most useful thing this comparison taught me.

PyFlink In 2026: Better Than Its Reputation, Still Not Frictionless

2026-03-27T00:00:00+00:00

I do not think teams reach for PyFlink because Python feels nicer to type.

They reach for it when they have already paid the cost of splitting one ML system across two ecosystems.

I have seen that pain in the most annoying way possible: training and experimentation lived in Python, but the prediction path had to live in Java. On paper that sounds manageable. In practice it meant subtle differences in floating-point behavior, parsing choices, and even heading-angle calculations were enough to create inconsistent predictions. We lost months chasing what looked like model problems and turned out to be feature mismatches.

That is the part many architecture discussions understate. Once training is in Python and prediction is in Java, the real problem is no longer just inference. It becomes feature parity, interface parity, and the feedback loop between two runtimes that each have their own libraries, their own defaults, and their own ways of being almost the same.

This is the real tax of cross-language serving paths: not dramatic failure, but endless small mismatches that make the system harder to trust.

You can try to escape that with ONNX. You can rebuild parts of the feature logic in Java. You can expose the model behind a service boundary and call it remotely. All of these are reasonable patterns. None of them are free.

Four years ago, ONNX was not mature enough for the kinds of models and custom ops we cared about. The easy story broke precisely where real systems stop being toy examples. The fallback was the pattern most teams know well: deploy the model as a service and call it over REST. That works, but now your prediction pipeline owns an extra network hop, another SLA, another scaling surface, and one more place where raw features must remain perfectly aligned.

Model-as-a-service is often the sensible compromise. It is also where clean separation starts charging rent in latency, SLAs, and feature-parity work.

This is why I think the case for PyFlink should be stated more bluntly than it usually is:

If the real source of friction in your system is that your training, feature logic, and model-adjacent code live naturally in Python, then "just use Java Flink" is not a neutral suggestion.

It is an architectural trade, and often an expensive one.

That is the real driver for PyFlink adoption.

I went back to an older PyFlink review recently because I did not want to turn one painful period into a permanent opinion. Some of those frustrations had aged well. Some had not. And PyFlink is exactly the kind of technology people form a durable opinion about after one painful quarter and then never revisit.

That would have been lazy here, because the story has moved. PyFlink is in a better place now than many engineers assume. The official docs cover installation, packaging Python environments, debugging, a Python DataStream API, and connector examples. That is already a more serious platform story than the older dismissive take that it is simply immature.

But the core trade-off has not disappeared.

PyFlink is now real enough to take seriously, but it still does not let you forget that Flink is fundamentally a JVM-first distributed runtime. That is the part people need to hold in their head at the same time as the improvements.

What Has Improved Since The Older Evaluation

The first thing worth saying is that some of the older criticisms are now too blunt.

PyFlink is no longer just a thin curiosity around the Table API. The current docs cover installation, a Python DataStream API, debugging, dependency management, packaging Python environments for cluster execution, and connector examples:

That is already a materially better story than the one many engineers still carry around in their heads.

A few concrete improvements stand out:

1. The Python Story Is Better Documented

The installation docs now state clear Python version requirements. At the time of writing, PyFlink requires Python 3.9, 3.10, 3.11 or 3.12:

PyFlink installation

That sounds minor, but it is not. One of the easiest ways to waste time with cross-language frameworks is by discovering environment assumptions too late. The current docs at least acknowledge that this is a real part of the user experience.

2. The DataStream Story Is No Longer Hand-Wavy

One of the old reasons people dismissed PyFlink was that serious low-level streaming work still felt like Java territory.

That is less true now. The Python DataStream API is documented, examples exist, and the API surface is real enough that you can reason about it as a deliberate part of the platform rather than a side alley:

Intro to the Python DataStream API

I would still be careful not to confuse “documented” with “equally frictionless as the JVM path,” but the old complaint that PyFlink is barely there is no longer a fair description.

3. Debugging And Packaging Are Better Acknowledged

The older review spent a lot of energy on setup, environment pain, and debugging awkwardness.

Those pains have not disappeared, but the current docs are more honest about them. They cover packaging Python environments, adding JARs, client-side versus TaskManager-side logging, local debugging, remote debugging, and profiling:

This matters because it tells you something important about the maturity of the ecosystem: it now documents the pain instead of pretending it is not there.

That is progress, even if it is not magic.

Why PyFlink Is Genuinely Attractive

Despite the caveats, I do think PyFlink has a very real value proposition.

1. It Keeps The Streaming Layer Closer To The Actual ML Ecosystem

This is the point I think most comparisons understate, and it is the one that matters most to me.

The strongest argument for PyFlink is not merely “our team prefers Python.” The stronger argument is that the surrounding model ecosystem, experimentation culture, libraries, and iteration loops are still centered on Python.

This is why PyFlink remains attractive: not because the runtime becomes light, but because the surrounding Python ecosystem can stay closer to the streaming layer.

That matters when the alternative is forcing teams into one of these patterns:

re-implementing logic in Java
exporting models through formats like ONNX and accepting the translation burden
splitting the system so aggressively that the serving boundary becomes the architecture

None of these are invalid. But all of them are real costs, and in many teams they are the actual costs driving interest in PyFlink.

If the same raw features are calculated in one language for training and another for live prediction, you do not just inherit maintenance overhead. You inherit doubt. When a prediction looks wrong, is the model wrong, is the data wrong, or did one side normalise, round, parse, or order something differently? That uncertainty is corrosive, and it slows every feedback loop around the system.

2. It Meets Python-Heavy Teams Where They Already Work

If your data and ML teams already live in Python, PyFlink reduces one major source of organisational friction.

That does not mean everyone suddenly gets to ignore distributed systems. But it does mean:

feature logic can stay closer to the surrounding Python estate
model-adjacent transformations feel more natural
experimentation paths from notebook thinking to streaming execution become less culturally awkward

For some organisations, that is a very big deal.

The wrong reaction here is to sneer and say “just learn Java.” Sometimes that is the right answer. Often it is just a lazy one.

3. It Makes Flink More Reachable Without Hiding Flink

Good language bindings should not pretend the platform underneath does not exist.

PyFlink is useful when it gives Python teams access to Flink’s real strengths: state, checkpoints, event-time semantics, long-running streaming jobs, and broader dataflow capabilities. If that is what you are buying, then the Python layer can be a practical bridge.

That is especially true for teams whose work already mixes ETL, feature pipelines, and model-centric logic.

4. There Is A Real Connector Surface

This is another place where the older blanket criticism needs updating.

The current PyFlink docs and examples do show Kafka, Pulsar, and Elasticsearch examples in Python:

PyFlink connector examples

So it would be wrong to say that the connector story is absent.

But it would also be wrong to say that it feels like a pure Python ecosystem.

That brings me to the real downside.

Why PyFlink Is Still Not “Flink, But Easy”

The strongest criticism from the old evaluation still holds:

PyFlink reduces language friction, but it does not remove runtime friction.

1. You Still Have To Think In Two Worlds

The installation and FAQ pages make this clear if you read them carefully.

You have to think about:

Python interpreter version
Python packaging and archives
where Python executes
how dependencies are shipped
JAR dependencies for connectors or Java-side integration

That earlier review made this painfully concrete. Getting local execution into a sane state meant lining up:

the right Java version
the right Python version
the right connector JARs
the right Python dependencies

That list is not just setup trivia. It is the operating model announcing itself early.

That is not a small footnote. It is the day-to-day ergonomics of the platform:

This is why I would resist overselling PyFlink to a Python team as “just write Python and the rest disappears.”

It does not disappear.

It relocates.

2. The Connector Story Still Leaks JVM Reality

The connector examples are useful, but they also reveal the real shape of things: adding JARs, managing connector dependencies, and living with the fact that some integration points are still fundamentally JVM-shaped.

Even the current Kafka connector docs explicitly talk about bringing connector dependencies yourself for PyFlink jobs:

Flink Kafka connector docs

That is not a deal-breaker. It is just not the same experience as working inside a native Python framework whose extension model is Python all the way down.

It also shows up in deployment. In that earlier review, the easiest workable path for local standalone deployment was not “package a Python app and run it.” It was closer to:

start from a vanilla Flink image
add the Python dependencies
mount the repo or bundle the code carefully
run the Python entrypoint from inside the live container

That is a perfectly workable path. It is also a strong reminder that the deployment experience is still shaped by Flink’s runtime model, not by Python’s usual ergonomics.

3. Debugging Still Tells You What The System Really Is

The current debugging docs are better than before, but they are also revealing.

They distinguish between client-side logging and TaskManager-side logging. They discuss local debug, remote debug, and profiling Python UDFs. That is helpful, but it also tells you that when things go wrong, you are not debugging a simple Python program. You are debugging Python inside a distributed Flink runtime:

PyFlink debugging

In practice, that means some classes of issue still feel cross-boundary by nature:

packaging bugs
dependency mismatches
behavioural differences between local and cluster execution
performance bottlenecks around Python execution paths

This is not PyFlink being uniquely bad. It is just the cost of the abstraction being honest.

4. Native Python Models Are Not An Automatic Architectural Win

This was one of the more useful parts of the earlier review, because it is exactly the kind of point people skip when they are trying to justify a new stack.

Yes, being able to interact with model code directly inside a PyFlink job is a real plus. It can simplify some flows and avoid a network hop.

But that is not the same as saying it is always the better architecture.

Once the model is served behind a proper boundary, you often gain things that matter a lot in production:

safer zero-downtime upgrades
cleaner readiness and health semantics
independent model scaling behind a load balancer
a clearer separation between streaming orchestration and serving concerns

So, yes, native execution can save some overhead. But it can also collapse boundaries that were doing useful work for you.

The reason I still take the native path seriously is not hand-wavy elegance. It is that model-as-a-service also comes with a bill:

every prediction path now pays a network round trip
the serving tier becomes another system you need to scale for throughput and protect with its own SLA
raw feature generation has to stay perfectly aligned across the caller and the served model boundary

If demand is modest, teams can live with that for a long time. Once prediction volume rises, that architecture stops being an abstract diagram and starts showing up as latency, capacity planning, and operational drag.

5. The Performance Question Never Fully Goes Away

I would be very careful here not to pretend a benchmark I have not run.

But I am comfortable saying something narrower and more useful: if your workload is highly latency-sensitive, connector-heavy, or operationally unforgiving, the JVM path still deserves to be the default starting point.

PyFlink can absolutely be the right choice. I just would not choose it because I wanted to avoid understanding the Java side of Flink.

That is not how this platform works.

So When Would I Use It?

I would take PyFlink seriously when these conditions hold:

the team is materially more fluent in Python than in Java
the reason for adopting Flink is the runtime model, not fashion
the jobs are important, but not balanced on the sharpest latency edge
I am willing to own environment packaging and connector dependency management as part of the operating model

I would lean back toward Java Flink when:

connector maturity dominates the problem
the hot path is extremely performance-sensitive
the team already has strong JVM strength
I expect deep platform integration and want the least surprising execution path

If You Want To Try It

If this post pushed you toward experimenting rather than debating in the abstract, I put together a small starter page here:

PyFlink starter archetype and agent prompt

It is intentionally minimal. The goal is not to hand you a grand framework. The goal is to give you a sensible first project shape and an agent prompt that can get a small Python-first streaming scaffold off the ground without immediate chaos.

The Practical Takeaway

What matters here is not whether PyFlink is “good” or “bad.”

That is far too vague to help anyone.

The better question is this:

Do I want Python as the working language for a Flink system badly enough to own the extra operational boundary that comes with it?

If the answer is yes, PyFlink is now mature enough to be a serious option.

If the answer is no, then Java Flink is still the cleaner way to get the full benefits of Flink without pretending the JVM underneath is someone else’s problem.

That, at least, is the view I would hold today.

Harmonizing Avro and Python: A Dance of Data Classes

2023-11-07T00:00:00+00:00

Reposting from the Vortexa medium blog

In the realm of data engineering, managing data types and schemas efficiently is of paramount importance. The crux of the matter? When data schemas are poorly managed, a myriad of issues arise, ranging from data incompatibility to runtime errors. What I am aiming for in this article is to introduce Apache Avro, a binary serialization format born from the Apache Hadoop project, through which I hope to highlight the significance of Avro schemas in data engineering. Finally, I will provide you with a hands-on guide on converting Avro files into Python data classes. By the end of this read, you’ll grasp the fundamentals of Avro schemas, understand the advantages of using them, and be equipped with a practical example of generating Python data classes from these schemas.

The Issue at Hand

Imagine the following scenario:

Your application’s new update starts crashing for a specific set of users.
Upon investigation, you discover the root cause: a mismatch between the expected data format and the actual data sent from the backend.
Such mismatches can occur due to several reasons — maybe a field was renamed, or its data type got changed without proper communication to all stakeholders.
These are real-world problems arising from the lack of efficient schema management.
So, how can Apache Avro and particularly Avro schemas help deal with these predicaments?

Avro… what now?

In the grand scheme of data engineering and big data, one might compare the efficient storage and transmission of data to the very lifeblood of the show. Now, if this show needed a backstage hero, it would be Apache Avro. This binary serialization format, conceived in the heart of the Apache Hadoop project, is swift, concise, and unparalleled in dealing with huge data loads. When the curtain rises for powerhouses like Data Lakes, Apache Kafka, and Apache Hadoop, it’s Avro that steals the limelight.

The Evolution of Data Serialization

Before diving into the tapestry of data’s history, let’s demystify a foundational concept here: serialization. At its core, serialization is the process of converting complex data structures or objects into a format that can be easily stored or transmitted and later reconstructed. Imagine packing for a trip; you organize and fold your clothes (data) into a suitcase (a serialized format) so that they fit neatly and can be effortlessly unpacked at your destination.

With that in mind, the story of data storage and transmission is a dynamic saga filled with innovation, challenges, and breakthroughs. Cast your mind back to the times of simple flat files–text files abiding to a specific structure. They were the humble beginning, like parchment scrolls in a digital era. But as data grew in complexity, our digital scrolls evolved into intricate relational databases, swift NoSQL solutions, and vast data lakes.

Now, imagine various systems, microservices, or extract-transform-load (ETL) pipelines, trying to communicate with one another by attempting to read unfamiliar data formats. It’s like trying to read a book when you don’t know the language it’s written in. To solve this, data had to be serialized–essentially translating complex data structures into a universally understood format. The early translators in this world were XML and JSON. Effective? Yes. Efficient? Not quite. They often felt like scribes painstakingly inking each letter, especially when handling vast amounts of data. The world needed a faster scribe; one that was both concise and precise.

Enter Avro. Inspired by the bustling highways of big data scenarios–from the lightning speed of Kafka to the vastness of Hadoop–Avro was born to ensure that data packets glided smoothly without unexpected stops. It became the guardian of data integrity and compatibility.

What’s in a POJO?

So, integrity is the keyword here, and in the context of this blog, we care about integrity breaches concerned with schema changes in a service that are not properly propagated to its consumers, rendering them unable to accommodate the new schema of the data they consume–like reading a book in a foreign language 😉.

The Dawn of the POJO Era

In the realm of programming, particularly within Java, a hero emerged named the Plain Old Java Object (POJO). This simple, unadorned object didn’t extend or implement any specific Java framework or class, allowing it to represent data without any preset behaviors or constraints. Imagine a Person POJO, detailing fields like name, age, and address without binding rules on how you should engage with these fields. Simple and elegant.

public class Person {

    private String name;
    private int age;
    private String address;

    // Default constructor
    public Person() {
    }

    // Constructor with parameters
    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    // Getters and setters for each field

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", address='" + address + '\'' +
               '}';
    }
}

However, as data complexity increased and systems multiplied, ensuring that these straightforward representations, our POJOs, maintained their integrity when transmitted or stored across varying systems became a challenge. Manual serialization, translating each POJO for different systems, wasn’t just laborious — it was a minefield of potential errors.

Enter the need for an efficient and consistent serialization mechanism. One that could not only describe these POJOs but also seamlessly encode and decode them, ensuring data looked and felt the same everywhere.

Apache Avro & the Magic of Schemas

Amidst this backdrop, Apache Avro took centre stage. While the POJO painted the picture, Avro became the artist’s brush, allowing the artwork to be replicated without losing its original essence. Integral to Avro’s magic were its schemas. These files, with their unique .avsc extension, were a form of a blueprint, dictating the structure of an entity, data types, and nullable fields or default values. (see the Person.avsc as an example here).

{
  "type": "record",
  "name": "Person",
  "namespace": "com.example",
  "fields": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "int"
    },
    {
      "name": "address",
      "type": "string"
    }
  ]
}

Pairing the intuitive design of POJOs with the precision of Avro schemas, developers had a formidable toolkit. Now, data could be managed, shuttled, and transformed without ever losing its core essence or structure. But what if these changes weren’t properly communicated amongst interacting systems?

Challenges in Schema Communication

Imagine two services: Service A (the Producer) that creates and sends data, and Service B (the Consumer) that receives and processes it. Service A updates its schema — perhaps it added a new field or modified an existing one. But if Service B is unaware of this change, it might end up expecting apples and receiving oranges.

The Domino Effect: Let’s say Service A, our producer, changes a field from being a number to a string. Service B, expecting a number, might crash or perform incorrect operations when it encounters a string. In a real-world scenario, this could mean misinterpretation of important metrics, corrupted databases, or application failures.
Versioning Nightmares: If every schema change requires updating the application logic in both the producer and consumer, this can quickly spiral into a versioning nightmare. How does one ensure that Service B is always compatible with Service A’s data, especially when they are updated at different intervals?
Enter the Schema Registry: A centralized Schema Registry can be the saviour in this scenario. Instead of letting every service decide how to send or interpret data, the Schema Registry sets the standard.
Registration & Validation: When Service A wishes to update its schema, it first registers the new schema with the registry. The registry validates this schema, ensuring backward compatibility with its previous versions.
Schema Sharing: Service B, before processing any data, checks with the registry to get the most recent schema. This ensures it knows exactly how to interpret the data it receives.
Library Generation: On successful registration, the producer can then trigger a script to create or update the corresponding POJO or Python data class. This automatically generated class can be used directly, ensuring that the code aligns with the latest schema.

Artifact Repository & Versioning

The generated data classes need a home. An Artifact Repository acts as this home. Whenever there’s a change, the updated class is given a new version and stored in this repository. Service B can then reference the specific version of the class it needs, ensuring data compatibility.

Producers, Consumers, and their Interaction: Once the schema changes are validated and registered, and the respective classes are updated, both the producer and consumer know exactly how to interact. They can reliably share data, knowing that both sides understand the data’s structure and meaning.

In essence, a centralised schema management system, paired with a robust registry and an efficient artifact repository, ensures that such data incompatibility issues are rendered not possible!

Generating Python Data Classes from `*.avsc` files

Avro, by its design and origin, has a strong affinity for the Java ecosystem. Apache Avro’s project comes with built-in tools and libraries tailored for Java, which makes generating POJOs straightforward. But when working with Python, things aren’t as easy.

Historically, it is worth noting that the introduction of data classes, which brought a feature similar to Java’s POJOs, came with Python 3.7. It, however, necessitated reliance on external libraries, such as dataclasses_avroschema, for schema-based generation. While these libraries are effective, their unofficial status can raise concerns about long-term reliability. Moreover, their utilization often depends on well-documented and clear examples, which might sometimes be ambiguous or lacking altogether. Furthermore, Python’s dynamic type system, though offering flexibility, poses challenges in maintaining data representation consistency when interfacing with Avro’s static schemas.

In this blog post, I hope to provide a clear example for data class-autogeneration, using an easy-to-understand script. So, let’s dive into an example.

Suppose, as we have already iterated, that we have the Person.avsc:

{
  "type": "record",
  "name": "Person",
  "namespace": "com.example",
  "fields": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "int"
    },
    {
      "name": "address",
      "type": "string"
    }
  ]
}

Before providing the script, let’s discuss the sample project structure, which can help clarify why, later on, I state that the generated files must be read-only.

Sample Project Structure

Your project structure might look like this:

project/
│
├── resources/
│   └── schemas/
│       └── Person.avsc
├── src/
│   └── types/
│       └── Person.py
├── scripts/
│   └── generate_dataclasses.py
└── Makefile

resources/schemas/: This directory contains the Avro schema files (.avsc)
src/types/: This directory will contain the generated Python data classes (.py).
scripts/generate_dataclasses.py: This script generates the Python data classes from the Avro schemas
Makefile: This file contains the make command to run the script.
Now, you can use the following Python script to generate a Python data class from this Avro schema:

import json
import os
import subprocess

from dataclasses_avroschema.model_generator.generator import ModelGenerator

def main():
    print("Starting script...")
    model_generator = ModelGenerator()

    # Ensure the output directory exists
    output_dir = "../src/types"
    os.makedirs(output_dir, exist_ok=True)

    # Scan the directory for .avsc files
    for root, _, files in os.walk("../resources/schemas"):
        for _file in files:
            print(f"Generating DataClass for: {_file}")
            if _file.endswith(".avsc"):
                schema_file = os.path.join(root, _file)
                output_file = os.path.join(output_dir, _file.replace(".avsc", ".py"))

                # Load the schema
                with open(schema_file) as sf:
                    schema = json.load(sf)

                # Generate the python code for the schema
                result = model_generator.render(schema=schema)

                # Open the output file
                with open(output_file, mode="w") as f:
                    # Write a comment at the top of the file
                    f.write("# This is an autogenerated python class\n\n")
                    # Write the imports to the output file
                    f.write("from dataclasses_avroschema import AvroModel\n")
                    f.write("import dataclasses\n\n")

                    # Remove the imports from the result because we have already written them to the output file
                    result = result.replace("from dataclasses_avroschema import AvroModel\n", "")
                    result = result.replace("import dataclasses\n", "")

                    # Write the generated python code to the output file
                    f.write(result)

                # Format the output file using isort and black
                subprocess.run(["isort", output_file])
                subprocess.run(["black", output_file])

                # Make the file read-only
                os.chmod(output_file, 0o444)

                print(f"Generated {output_file} from {schema_file}")


if __name__ == "__main__":
    main()

This script will generate a Python file Person.py in the ../src/types directory with the following content:

# This is an autogenerated python class
from dataclasses_avroschema import AvroModel
import dataclasses

@dataclasses.dataclass
class Person(AvroModel):
name: str
age: int
address: str

    class Meta:
        namespace = "com.example"

Why Read-Only?

The generated Python files are made read-only to prevent accidental modifications. Since these files are autogenerated, any changes should be made in the Avro schema files, and then the Python files should be regenerated.

Conclusion

The integration of Avro files with Python data classes streamlines the complexities of data handling. It’s a union that empowers the data engineering toolkit, delivering precise type-checking, user-friendly code suggestions, rigorous validation, and crystal-clear readability. With the solid foundation provided by the schema registry, the integrity of your data remains uncompromised, no matter how intricate the data operations become. And while the magic lies in the technology and techniques discussed, the real art is in the consistent, reliable data flow it facilitates. As you delve deeper into the vast world of data, know that tools like these are pivotal in weaving the seamless narrative of your data story.

Stay tuned, as more insights await in follow-up discussions, where we’ll further dissect the intricacies of a comprehensive schema management ecosystem.

Remember to like my post and re-share it (if you really liked it)!

See you soon!

Agile In Action: Bridging Data Science and Engineering

2023-10-31T00:00:00+00:00

Picture taken from National Gallery, London

A few weeks ago, Bill Raymond invited me onto his Agile in Action podcast after reading an older post of mine on doing data science the Agile way.

I said yes because this topic has followed me through most of my career.

I started as a data scientist. Then I spent years watching perfectly respectable prototypes fail to become products. By the time I reached Vortexa, I was leading a team of data scientists and engineers and living right in the middle of the tension I had been talking about for years.

That is the version of Agile I wanted to discuss in the episode. Not the clean whiteboard version. The one that appears when a model has to leave a Python notebook, survive production, and still make sense to the people who have to operate it.

The real gap in ML teams is rarely enthusiasm. It is the distance between a model that works once and a system that can be trusted repeatedly.

Why This Topic Stayed With Me

Part of the reason this topic matters so much to me is that I learned it the frustrating way.

At Data Reply, I worked on one prototype after another. We would explore a problem, build something promising, show strong results, and then hit the same wall: the client liked the idea, but the system never really made it into production. Sometimes the missing piece was infrastructure. Sometimes it was culture. Sometimes it was simply that nobody owned the hard part after the demo.

That started to change for me at UBS.

For the first time, I heard the sentence I had wanted to hear for years: “Great. Now how do we put this into production?”

I was paired with an experienced engineer, and that changed the direction of my career. I stopped seeing engineering as the final packaging step after the interesting work was done. I started seeing it as part of the thinking itself.

That shift is still with me today.

The Real Gap Between Data Science And Engineering

When people talk about cross-functional ML teams, they often make the collaboration sound natural. In practice, it is not.

Data scientists are usually optimising for learning:

trying ideas quickly
testing hypotheses
moving fast through a messy search space

Engineers are usually optimising for control:

reproducibility
determinism
maintainability
safe change over time

Both instincts are valid.

The problem is that they are protecting the system from different failure modes.

The issue is not that data scientists are messy and engineers are rigid. The issue is that both are right about different kinds of breakage.

Take a simple pricing model. A data scientist can build a strong prototype in a notebook, engineer the features, train the model, and prove the concept. But once that model becomes part of a product, somebody has to make sure the production path transforms the raw input in exactly the same way. If the training pipeline and the prediction pipeline drift apart, the system lies even when the model itself is good.

That is why the gap matters so much.

It is not about user interfaces or wrapping code nicely. It is about making sure the system that predicts tomorrow behaves like the system that was validated yesterday.

What Agile Actually Helped With

When I say Agile helped here, I do not mean that Scrum ceremonies somehow solved the problem.

What helped was having a way to make uncertainty legible.

For me, that meant three things.

1. Making experiments explicit

In ML work, “we are exploring” is too vague.

An experiment becomes useful when the team can answer:

what assumption are we testing?
what would count as useful evidence?
what result would tell us to stop?

That sounds simple, but it changes the conversation completely. It stops research from turning into open-ended wandering and gives product and engineering a clearer way to understand what the team is actually learning.

2. Creating shared visibility

At Vortexa, one of the most useful habits we built was a regular data science catch-up where engineers and data scientists could present what they were doing, why they were doing it, and where the risks were.

This was not code review. It was not a status ritual either.

It was a way to keep everyone on the same mental map.

That mattered because a lot of problems in ML systems do not come from one catastrophic mistake. They come from small drifts in understanding. A feature is computed one way in training, another way in production. An assumption about data quality goes unchallenged. A result sounds promising, but nobody else can reproduce it.

Communication is not a soft add-on here.

It is part of the control surface of the system.

3. Putting discipline around handoffs

The teams I trust most are not the ones with the nicest process diagrams. They are the ones that make handoffs visible and expensive enough that people try to remove them.

If the data scientist can disappear after training a model and the engineer is left to guess the rest, the system will eventually reflect that fracture.

If the engineer is never exposed to how experimental the work really is, they will overestimate how stable the solution already is.

Agile helped when it forced us to confront those boundaries earlier.

What ML Teams Still Underestimate

One of the themes that came up in the podcast is that many teams still underestimate how much work starts after the model looks good.

You do not just need versioned code. You need versioned data and a credible way to tie the two together.

You do not just need a model in production. You need monitoring, drift detection, and a practical way to replace the model without breaking the product.

You do not just need experimentation. You need a path from experimentation to something deterministic enough to support.

This is why I often say that notebooks are wonderful research tools and terrible places to leave an idea if you want a system around it to survive.

The Lesson I Was Trying To Communicate

When Bill asked what Agile meant to me in this context, the answer I wanted to give was not especially fashionable.

It was this:

In ML, Agile is useful when it helps the team learn quickly without losing control of the system.

That is really the heart of it.

Not velocity in the abstract.

Not ceremony for its own sake.

Not pretending that uncertainty can be planned away.

Just a disciplined way to:

test assumptions early
expose the right risks
keep engineers and data scientists in sync
and make sure the thing you learned can actually survive contact with production

That was my view then, and I still think it was the right thing to say.

The Podcast

If you prefer the conversation version, the episode is below.

Dynamic(i/o) Why you should start your ML-Ops journey with wrapping your I/O

2022-05-31T00:00:00+00:00

If you call yourself an ML Engineer then you ‘ve been there–you ‘ve seen this before. To productionise your ML pipeline; well, that’s surely a challenge.

I have worked for many years as a Data Science consultant, and I can surely confirm the statement that “…more that 87% of Data Science projects never make it to production”. There is a reason why the first rule of doing Machine Learning is to really be sure you need to do ML! Surely, many reasons play into this challenge:

lack of the right leadership;
no or limited access to data in siloed organisations;
lack of the necessary tooling or infrastructure support, and even;
lack of a research-driven culture.

But there is one more beast to be tamed out there; the gap between Data Science and ML Engineering. And this is a gap you can perceive both in terms of the two practitioners in each field of work–data scientists and SWE–but also in terms of literally getting from a prototype to a production ready ML pipeline.

Simply put, to put a model into production is one thing; but to maintain that model, properly monitor it to identify possible drifts and streamline the process of re-training it or updating it in a robust and reproducible way, supported by a clean CI/CD process, is daunting task! If anything, I ‘d dare say that ML-Engineering, as a domain, fully encapsulates SWE in addition to many more challenges (highly recommend reading Hidden Technical Debt in Machine Learning Systems), for some of which we are still trying to standardise how we work in terms of best tooling or practices.

In many cases, organisations are forced to come up with their own ways of working to accommodate the unique challenges of their custom use-cases. Then again, it all comes down to the requirements of a project. Netflix has streamlined the process of putting python notebooks into production using papermil. Others, go as far as to standardise the whole ML Engineering process using tools like Airflow or Kubeflow, relying on AI pipelines (on GCP) or SageMaker (on AWS), etc.

So what do we do…?

At Vortexa, we are heavy users of Airflow and have recently embarked into a journey to include Kubeflow into our tech stack. As an ML-Engineer, my job usually concerns receiving a successful prototype of a model and implementing a complete end-to-end ML pipeline out of it; one that can be easily maintained and reused. In many ways, this process is very common to a traditional SWE project, only more complex, since ML projects come with more requirements and a strong dependency on data. Hence, it easily follows that everything one cares to implement for a SWE project needs to also be implemented for an ML-Engineering (MLE) project; and more.

But let’s start simple…

Here is my notebook! I am done; your turn now!

So you are handed a notebook, and you inspect it; you spend time with the Data Scientist and understand all crucial aspects in the procedural logic, and you start splitting the process into various tasks. You, usually, end up with something like this:

You think about the structure of your codebase, about how everything will be deployed, how you want to decouple orchestration from the logic of your ML-pipeline, and then you start thinking about domain driven development (DDD). You start thinking about abstractions and encapsulation, about testing and data validation. That’s when it hits you–testing; you can unit test most things and build a robust pipeline, but you also want fast feedback for when you introduce changes and improvements to your pipeline (shifting to the left)! What if you wanted to run a local regression test? With all data being read from external resources (databases, object storage service) you ‘ll have to mock all these calls (doable, but takes time) and replace actual data with sample input. And, finally, what about schema and data validations? How do you guarantee after data ingestion that all your expectations on the input are respected?

You have a look at the code again. Filled with various I/O operations. Sometimes it’s csv, others parquet, and others it’s json, sometimes you read from a database and others from an object storage service (s3 or gcp). Different libraries used to facilitate all these: gcsfs, s3fs and fsspec, boto3 sql-alchemy, tables; and pandas, of course, sits at the core of this process. As if that’s not enough, each file comes with a series of peculiar set of requirements supported through the use of kwargs; in your python code: orientation of json files, row-group-sizes for parquet files, coercions on certain timestamp columns–the list keeps going… This won’t be the last time you need to do this either!

It’s just too many details–way too many details–for you to worry about. A clear violation of the dependency inversion principle:

Business logic (high level code) should not be implemented in a way that “depends” on technical details (low level code, e.g., I/O in our case); instead both should be managed through abstractions!

You need abstractions to facilitate the flexibility to easily introduce changes. More often than not, business needs will require high-level modules to be modified. Low level code, on the other hand, is usually more cumbersome and difficult to change. The two should be independent; a database migration or a switch to an object storage service should have no impact on your work to generate a new valuable feature for your model, and vice-versa. Abstracting both of these using distinct layers can achieve this!

As David Wheeler said:

All problems in computer science can be solved by adding a layer of indirection.

What is `dynamicio` then?

Wouldn’t it be great if you could:

have an abstraction that encapsulates all I/O logic;
be able to seamlessly handle reading or writing from and to different resource types or data types;
have an interface that is easy to understand and use with minimum configuration;
respect your expectations on schema types and data quality;
automatically generate metrics that would be used to leverage further insights, and more importantly;
be able to seamlessly switch between local, dev, staging and prod environments, performing dynamic I/O against different datasets and effectively supporting development, testing and qa use cases?

Well, dynamic(i/o) is exactly that; a layer of indirection for pandas I/O operations.

If you want to find out more about it then register to attend this year’s ODSC and attend the presentation by myself and my colleague Tyler Ferguson on dynamic(i/o). Come and learn about how its implementation and adoption has helped us go beyond just achieving consistency across our ML repos, effectively dealing with glue code and keeping our code-bases DRY, but also acting as an interface between different teams.

Remember to like my post and re-share it (if you really liked it)!

See you soon!

Complete Guide to Python Envs (MacOS)

2021-02-14T00:00:00+00:00

Configuring Python on your machine for the first time is a definite headache for any software engineer that decides to delve into the world of Python. Doing it properly confuses a lot of people and can prove to be very challenging.

It is often the case that many developers have numerous interpreters configured on their machines, without knowing where they live.

Most common ways of setting up Python

Firstly, there is a Python version that ships with macOS, but it is usually v2.7, which is not just out of date but also deprecated.

So, commonly, most users will download the latest Python release and move it to their $PATH or use brew install python3 (which does this for them).

Both of these solutions can cause many problems that will not be evident straight away. The main challenge, is usually not knowing, at any given time, what is the “default Python” that your system is using. Ideally, this is something you shouldn’t care about, but if you don’t set up things properly, you end up installing packages for the wrong environment or the wrong active Python interpreter, un-intentionally created from the wrong Python distribution and… well, you get the point (…this is pretty much summed up in the xkcd image above).

To find out more details, read this excellent December 2020, post, by Matthew Broberg.

How to avoid all these?

The short answer is “use pyenv”. pyenv will enable you to not only setup python properly on your machine, but to also manage different versions and python environments in a simple and straightforward way. As explained on the package’s github page:

“It’s simple, unobtrusive, and follows the UNIX tradition of single-purpose tools that do one thing well.”

For me, its main benefits are:

It depends on Python itself, i.e. since it was made from pure shell scripts, there is no bootstrap problem of Python.
It manages the need to be loaded into your shell though pyenv’s shim approach, which adds a directory to your $PATH.
It manages virtual environments, though I recommend using pyenv-virtualenv to automate the process.

Let’s get to it

Before you do anything make sure you start with a clean sheet. To do so, uninstall or remove any python distributions you already have. I strongly advise you to follow this link.

Now, assuming you have brew installed on your machine, do:

$ brew update
$ brew install pyenv

We will now need pyenv-virtualenv. pyenv-virtualenv is a pyenv plugin that provides features to manage virtualenvs and conda environments for Python on UNIX-like systems.

$ brew install pyenv-virtualenv

Setting up your `global` interpreter

So, the first thing you want to do is set up your global interpreter. This is the python environment that will be used by default by your system, unless you dictate otherwise.

If you run:

$ pyenv install --list
Available versions:
  2.1.3
...
  3.10-dev
  activepython-2.7.14
...
  activepython-3.6.0
  anaconda-1.4.0
...
  anaconda3-2020.07
  graalpython-20.1.0
  graalpython-20.2.0
  ironpython-dev
...
  ironpython-2.7.7
  jython-dev
...
  jython-2.7.2
  micropython-dev
...
  miniconda-latest
...
  miniconda3-4.7.12
  pypy-c-jit-latest
...
  pypy3.6-7.3.1
  pyston-0.5.1
...
  pyston-0.6.1
  stackless-dev
...
  stackless-3.7.5

You will see the full list of Python distributions available for installation.

Choose the one you want and do, e.g. 3.9.0:

$ pyenv install 3.9.0
python-build: use openssl@1.1 from homebrew
python-build: use readline from homebrew
Downloading Python-3.9.0.tar.xz...
-> https://www.python.org/ftp/python/3.9.0/Python-3.9.0.tar.xz
Installing Python-3.9.0...
python-build: use readline from homebrew
python-build: use zlib from xcode sdk
Installed Python-3.9.0 to /Users/<username>/.pyenv/versions/3.9.0

Once installation is complete, you can set this version as your global:

$ pyenv global 3.9.0

At this point, one should be able to find the full executable path to each of these using pyenv version.

$ pyenv version
3.9.0 (set by /Users/<username>/.pyenv/version)

Creating and managing virtual environments automatically

This is a standard practice when working with Python. The idea is to keep different environments isolated. Each Python environment can be associated to multiple projects, but it is generally better to just go for a one to one mapping.

Why you say? Well, for starters, this helps you maintain your system clean by not installing system-wide libraries that you are only going to need in a small project. It also allows you to use a certain version of a library for one project and a different version for another. Finally, it helps make your project reproducible and ensures it is configured in an identical manner across local environments amongst collaborating developers.

Let’s go through an example.

Suppose you have a github root directory where you clone and maintain all your projects and it looks like this:

GitHub
├── project_a
└── project_b

What you want to do is setup a different python virtual environment per project. What’s more is that you would like to automatically activate that virtual environment by means of simply accessing (cd-ing) into that project. Let’s see how we can do that.

First, I ‘ll assume you are using .zshrc as your default shell and have configured oh-my-zsh. If not, then just set it up. Note that this is not a pre-requisite; it’s more of a personal preference, but using oh-my-zsh does come with many benefits, like showing the current active python environment on your console, which is why I am recommending it.

In order to enable the above automations, we will need two pre-requisites. The first, is to include 2 files in each project (you can version control these files). The first is .python-version and the second is .python-virtualenv, as per the below tree:

GitHub
├── project_a
│   ├── .python-version
│   └── .python-virtualenv
└── project_b
    ├── .python-version
    └── .python-virtualenv

In each of these files you just add a line at the very top of the file with:

the python version you want to use
the name of the virtual environment you want to create.

For example, the contents of

GitHub
├── project_a
│   ├── .python-version 

can be:

3.9.0

and:

GitHub
├── project_a
│   └── .python-virtualenv

can be:

project-a-venv

similarly, for project b you can have 3.8.2 and project-b-venv.

Now, on to your .zshrc. Do:

$ vi ~/.zshrc

and add the following script:

# Define your $PATH
export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"

# Automatic venv activation
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"
export PYENV_VIRTUALENV_DISABLE_PROMPT=1

# Undo any existing alias for `cd`
unalias cd 2>/dev/null

# Method that verifies all requirements and activates the virtualenv
hasAndSetVirtualenv() {
  # .python-version is mandatory for .python-virtualenv but not vice versa
  if [ -f .python-virtualenv ]; then
    if [ ! -f .python-version ]; then
      echo "To use .python-virtualenv you need a .python-version"
      return 1
    fi
  fi

  # Check if pyenv has the Python version needed.
  # If not (or pyenv not available) exit with code 1 and the respective instructions.
  if [ -f .python-version ]; then
    if [ -z "`which pyenv`" ]; then
      echo "Install pyenv see https://github.com/yyuu/pyenv"
      return 1
    elif [ -n "`pyenv versions 2>&1 | grep 'not installed'`" ]; then
      # Message "not installed" is automatically generated by `pyenv versions`
      echo 'run "pyenv install"'
      return 1
    fi
  fi

  # Create and activate the virtualenv if all conditions above are successful
  # Also, if virtualenv is already created, then just activate it.
  if [ -f .python-virtualenv ]; then
    VIRTUALENV_NAME="`cat .python-virtualenv`"
    PYTHON_VERSION="`cat .python-version`"
    MY_ENV=$PYENV_ROOT/versions/$PYTHON_VERSION/envs/$VIRTUALENV_NAME
    ([ -d $MY_ENV ] || virtualenv $MY_ENV -p `which python`) && \
    source $MY_ENV/bin/activate
  fi
}

pythonVirtualenvCd () {
  # move to a folder + run the pyenv + virtualenv script
  cd "$@" && hasAndSetVirtualenv
}

# Every time you move to a folder, run the pyenv + virtualenv script
alias cd="pythonVirtualenvCd"

Save your changes, return to your terminal and either restart your terminal or do:

$ source ~/.zshrc

Now, let’s assume that you are in GitHub directory:

$ pwd
/Users/<username>/Github

Then, if you do:

~/GitHub $ cd project_a
created virtual environment CPython3.9.0.final.0-64 in 448ms
  creator CPython3Posix(dest=/Users/<username>/.pyenv/versions/3.9.0/envs/project-a-venvo, clear=False, no_vcs_ignore=False, global=False)
  seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/Users/<username>/Library/Application Support/virtualenv)
    added seed packages: pip==20.3.1, setuptools==51.3.3, wheel==0.36.2
  activators BashActivator,CShellActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator
(project-a-venv) --------------------------------------------------------------------------------
~/GitHub/project_a $

and, if you come out of it and change to project b:

$ cd ../project_b
created virtual environment CPython3.8.2.final.0-64 in 932ms
  creator CPython3Posix(dest=/Users/<username>/.pyenv/versions/3.8.2/envs/project-b-venv, clear=False, no_vcs_ignore=False, global=False)
  seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/Users/<username>/Library/Application Support/virtualenv)
    added seed packages: pip==20.3.1, setuptools==51.3.3, wheel==0.36.2
  activators BashActivator,CShellActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator
(project-b-venv) --------------------------------------------------------------------------------
~/GitHub/project_b $  

Now, two new virtual environments have been created:

$ pyenv versions
system
* 3.8.2 (set by /Users/<username>/GitHub/project_b/.python-version)
  3.8.2/envs/project-b-venv
  3.9.0
  3.9.0/envs/project-a-venv

and every time you cd into these directories, your pyenv will switch automatically.

Note 1: You may face some issues with python 3.8.7.
Note 2: To uninstall a python env, do: pyenv uninstall 3.8.2/envs/project-b-venv

Using `jupyter notebook` or `jupyter lab` with a virtual environment of your choice

Finally, suppose you want to use a python environment with a jupyter notebook. This is not as straightforward as one would think. Here is how you would do it.

Let’s continue from where we left things in the previous section. You are in:

GitHub
├── project_a

and you have project-a-venv activated:

(project-a-venv) --------------------------------------------------------------------------------
~/Github/project_a $

First thing you need to do is install ipykernel using pip:

$ pip install ipykernel

Next, you need to install a new kernel:

ipython kernel install --user --name=project-a-venv

Finally, assuming you have jupyter or jupyterlab installed, you can start jupyter, create a new notebook and select the kernel that lives inside your environment.

$ jupyter notebook

Final notes

I really hope that this was a helpful post and if you are new to python, I hope that I have helped you disambiguate some confusing aspects of configuring python at the start of your journey!

The bellow references were very helpful for putting together this post:

Remember to like my post and re-share it (if you really liked it)!

See you soon!

A BREXIT NLP Dataset!

2020-09-02T00:00:00+00:00

So here is the thing… I love discussing politics; I think that everyone should, at least occasionally, bother themselves with what is happening in their country’s political scenery.

Regardless of whether you are into politics or not, it would be practically impossible to escape debating BREXIT back in the summer of 2016. At the time, I had just been hired by Data Reply UK and the company’s annual XChange conference was around the corner.

My boss at the time, wanted to us to come up with something interesting and eye catching for our demo pod at the conference. So, being that BREXIT was a trending and highly debated topic, I thought that maybe I can come up with a way to predict peoples’ political stance by means of their social activity.

The idea

The idea was simple:

Provided one’s twitter @handle, try to infer their political views on BREXIT.

The original approach was to:

Collect people’s tweets through the twitter API;
Label tweets related to BREXIT as either PRO or CON;
Calculate a ratio between the 2 and produce a number that would represent their political stance.

After experimenting a bit, I figured out that using one’s own tweets would not be enough. Many twitter users don’t tweet that often and when they do, they are not really concerned with the EU or BREXIT. So I thought that maybe we can use the tweets of the people that one follows. This draws from social science and ideas behind tribalism:

“…you are likely to be ideologically aligned with the positions of your peers [or of those you follow on twitter ;)]!”

The dataset

In order to be able to label tweets, I had to develop an NLP ML model. To do so, I needed a relatively big corpus of labelled tweets.

I turned to an article by BBC at the time, which categorised MPs according to the public stance on BREXIT. Using a twitter list that had the twitter handles of 449 MPs at the time and using the twitter API, I accumulated a corpus of 60,941 tweets from 449 UK MPs (at the time). Tweets had one or more of the following keywords:

key_words = ['European union', 'European Union', 'european union', 'EUROPEAN UNION',
    'Brexit', 'brexit', 'BREXIT',
    'euref', 'EUREF', 'euRef', 'eu_ref', 'EUref',
    'leaveeu', 'leave_eu', 'leaveEU', 'leaveEu',
    'borisvsdave', 'BorisVsDave',
    'StrongerI', 'strongerI', 'strongeri', 'strongerI',
    'votestay', 'vote_stay', 'voteStay',
    'votein', 'voteout', 'voteIn', 'voteOut', 'vote_In', 'vote_Out',
    'referendum', 'Referendum', 'REFERENDUM']

and were automatically labelled based on the views of the MP who tweeted them.

You can find more details on how I worked to generate the ML model and how the demo solution worked if you follow this github repository.

Dataset now available on Kaggle

It took me some time to publish it, but the dataset is now available to everyone to use on Kaggle. You can find it if you follow this link.

I hope that the ML community will make good use of it. It’s 4 years after the referendum but BREXIT is yet to really happen and unfortunately it remains a concerning issue. So, who knows, maybe someone wants to use this dataset in some other equally interesting way.

Remember to like my post and re-share it (if you really liked it)!

See you soon!

Style Transfer in Heraklion

2020-08-15T00:00:00+00:00

I am currently in Crete for my annual get away. Crete is an amazing island with many beautiful places to visit and a vast history that goes all the way back to the Minoans in 3500 BC.

One of the things I love doing whenever I am here is strolling around the city of Heraklion and taking pictures of the many hidden alleys, which reveal an amazing graffiti culture! I really wanted to write about it in my blog and I thought that maybe I can do so by using some amazing images I gathered just last week in a style-transfer post. So this is it: Style Transfer in Heraklion.

A bit of history: A Neural Algorithm of Artistic Style

Neural Style Transfer (NST) is a class of algorithms that process images to adopt the visual style of another image. A seminal paper that introduced this concept was “A Neural Algorithm of Artistic Style” by Leon A. Gatys, Alexander S. Ecker and Matthias Bethge. In their work, the authors emphasize that:

“…representations of content and style in Neural Networks are seperable”.

This is the foundation of this work, since if these two notions are indeed separable then provided two images you can get the style of the first, the content of the second and merge them together. So, how is this done exactly?

Delving into the details

The first figure in the paper shows the original setup and how a pre-trained NN, referred to as VGG19, was modified to do NST. What is VGG19? Well, the basic building blocks of traditional convolutional networks are the following layers:

a convolutional layer (with padding to maintain the resolution);
a non-linear activation layer such as a ReLU, and;
a pooling layer such as a max pooling layer.

A VGG block consists of a sequence of convolutional layers, followed by a max pooling layer for spatial down-sampling. What we are interested in is how this network will respond to the inputs.

Retrieving the content

Notice that the authors prefer to use paintings for the style and a random image; it seems like these combinations work best. The main idea is abstracting the content and putting more emphasis on the style!

At the top left you see “The Starry Night” by Vincent van Gogh and below it is just a random content image; let’s start with the latter.

Provided both an input (style) image and a content image, each neuron and respectively each layer in the NN will either activate or it won’t. Each image is processed, or better yet filtered, in a different way (by nature of the activation or not of different neurons). Looking at how the content image is gradually filtered in the above image you will notice that the first layer leaves the image seemingly intact. But looking all the way to the last filtered output you see that this is not the case at all; shapes are there but the inside is not so much the same. This is because of how the resulting high-level features are generated on earlier abstractions of the same image produced by previous layers. This is the intended behaviour to retrieve the content.

Retrieving the style

So, for the style, the authors explain that they have built a new feature-space, which focuses on the style of an input image on top of the original CNN representations. The style representation computes correlations between the different features in different layers of the CNN. They reconstruct the style of the input image from style representations built on different subsets of CNN layers and this results in images that match the style of the input on an increasing scale while discarding information of the arrangement of the scene.

It’s all in the formulas (or formul$ae$)

The authors also discuss the impact of the number of layers used to infer the style or the content of images before they are merged (visually depicted in Figure 3 of the paper). In the first row (A) only one layer is used in contrast to 5 layers used at the bottom row where the result is much better.

To generate the images which are a mixture of the content of an image-A with the style of another (image-B) the authors explain that they jointly minimise the distance of a “white noise” image from the content representation of image-A in one layer of the network and the style representation of image-B in a number of layers of the CNN. This is gracefully captured by the below loss function:

where $\overrightarrow{p}$ is image-A (usually a photograph where we care about the content) and $\overrightarrow{a}$ is image-B (usually a painting where we care to retrieve the style). Then $\alpha$ and $\beta$ respectively concern weighting factors for content and style reconstruction.

Going back to Figure 3 of the paper, looking at it from left to right we see what happens when we tweak these weighting factors ($\alpha$ and $\beta$). The left-most column concerns cases where $\alpha$ is low compared to $\beta$ and the right-most layer is the other way around. These two factors are practically the optimisers of the content and style errors respectively. If $\alpha$ is high, it means that content error is more important and vice-versa for increasing $\beta$.

The objective of the formula is to minimize $\mathcal{L}_{total}$. $\overrightarrow{x}$ is the image that we are gradually building through multiple iterations and it initially comes either from the photograph ($\overrightarrow{p}$) or it is initialised as white noise. $\alpha$ and $\beta$ are the weights that we need to set, and they are basically our hyper-parameters in this problem.

What is now left is understanding $\mathcal{L}_{content}$ and $\mathcal{L}_{style}$.

$\mathcal{L}_{content}$

Here is where everything gets a bit complicated but at the same time, you get to piece everything together nicely.

$\mathcal{L}_{content}$ is described as the squared-error loss between two feature representations: one concerned with the random photograph $\overrightarrow{p}$ and the generated image $\overrightarrow{x}$ which is originally a white noise image. $P^l$ and $F^l$ are the respective feature representations for the two images in layer $l$. The authors used the feature space provided by the 16 convolutional and 5 pooling layers of the 19 layer VGG Network. Here, $F^l$ represents an activation function ($F$) at a given layer $l$ or, plainly, a bank of non-linear filters for that layer. The complexity of these filters increases with the position of the layer in the network. $F$ is practically a matrix of size $N\times M$ where $N$ is the number of filters within a given layer with $N_l$ feature maps of size $M_l$; the latter is the height $\times$ width if the feature map.

So, a given input image $\overrightarrow{x}$ is encoded in each layer of the CNN by the filter responses to that image. To visualise the image information that is encoded at different layers of the hierarchy the authors perform gradient descent on the white noise image to find another image that matches the feature responses of the original image. So, the approach is to gradually changes the initially random image $\overrightarrow{x}$ until it generates the same response in a certain layer of the CNN as the original image.

$\mathcal{L}_{style}$

The style loss function is described by the following equation:
which is basically a sum of the weighted distances between feature correlations across the different filter (layer) responses for two images:

the original image $\overrightarrow{a}$, and;
a white noise image $\overrightarrow{x}$, used to generate a style representation of the original image.

Let’s break this down a bit more; what are these feature correlations? Practically they are a way to express a relationship between a feature map $F$ and the filters ($i$ and $j$) of the different layers ($l$) applied on it. This is beautifully expressed as a matrix of all possible inner products between the generated set of feature vectors, called a “Gram matrix $G$”, as per the below equation:

One such matrix is generated for each of the two images (the original $\overrightarrow{a}$ and $\overrightarrow{x}$), namely $A_{ij}^l$ and $G_{ij}^l$, and a squared distance is calculated between these two. The objective is to minimise the distance. So, practically, as with every ML problem, what we have is an optimisation problem and a cost function! Minimising this distance can be achieved through the application of gradient descent using standard error back-propagation to adjust the weight values of equation $5$.

Putting it all together

Finally, in order to generate the final image with the style transfer, we return to equation 7, which practically jointly minimises the distance of a white noise image from the content representation of the photograph in one layer of the network and the style representation of the painting in a number of layers of the CNN. The authors also note that:

For image synthesis they found that replacing the max-pooling operation by average pooling improves the gradient flow and one obtains slightly more appealing results.

That’s it! So, what’s left now is getting our hands dirty!

Using `PyTorch` for Style transfer

If you following this link to the official PyTorch website you will find a very well written tutorial on how to apply style transfer with PyTorch. I provide my own take of it $\rightarrow$here$\leftarrow$. You can follow the link to the python notebook and copy-paste the code to give it a try.

I intend to work on creating a package for it and will provide an updated post on it once I do (it will be developed in the same repo as the link). The intention is to be able to style images through the packages through an intuitive api that would take the image to be styled as the input and a choice between famous images that will be available through the package (provided as a text parameter) to produce the desired output (along with some other flags and side parameters). Something like:

import pytorch_style_transfer as pst

pst.generate(
    input_image_path="path_to_input_image", 
    style="starry_night", 
    resolution=128, 
    output_dir="path/to/output")

Enjoy some of the outputs:

Here are some of the results of this work. I tried blending the fortress of Koules with 4 different grafittis I was able to photograph.

The original picture:

The result is not always great, but it was still very interesting to try:

That’s it!

Remember to like my post and re-share it (if you really liked it)!

See you soon!

Agile Data Science

2020-08-11T00:00:00+00:00

Re-posting from https://www.iunera.com/

Around two weeks ago I was approached by Dr. Tim Frey, General Manager at Iunera GmbH & Co. KG. I was quite surprised to read his message:

Hi Christos, We met at the mind mastering machines conference in London. We operate a company blog (https://iunera.com/kraken ) and one of our writers wrote about agile in Data Science. I liked your talk two years ago and I thought she can approach you to ask a few questions like kind of an in-article interview with an expert. Hope that is fine with you. Would be super glad to get your insights.

I must admit this was a first for me! Then again, that talk in 2018 was quite an interesting one for me too.

How it all happened…

You see, 3 years ago I was asked to join an exceptional team over at UBS to help with a graph analytics project. If you asked me then I would proudly tell you that “…I am a Data Scientist”; that is how I saw myself. However, that was bound to change forever.

The first three months were amazing. I worked with a vast amount of data and revealed some very interesting insights. So, inevitably, my project manager approached me and asked “…how about we take this work of yours into production”!

I didn’t have a clue about what that meant in reality, but I was about to find out. He said: “Well, don’t worry, we will pair you with an engineer and you both can get started on it”. So we did!

This is basically the story about how I was exposed to software engineering and the Agile way of working–about how I was converted into an ML Engineer. Two years later I decided to take my learnings from this experience and share it with my community, and so I did at mCubed London in 2018:

That’s where I also met Tim. Turns out that a year and half later a colleague of Tim’s (Dhanhyaashri Mahendran) was doing a bit iof research on “Doing Data Science the Agile way” and Tim suggested that she gets in touch with me to ask me some questions, which I welcomed.

Some very interesting questions were thrown my way…

I really liked the questions that Dhanhyaashri had prepared. She had obviously done her research. I did my best to respond and two weeks later the interview was published on the Iunera blog. You can read it here but I also felt like re-posting the interview on my personal blog too.

Besides the cutting of time-consuming planning and quicker turnaround of projects, what other benefits are there in applying the Agile approach in data science?

For the community, I would say that that would be the emergence of new Data-Science-oriented practices that will drive the application of Agile in the research domain.

The problem with applying Agile in Data Science is that, traditionally, Agile is practiced in software development projects where experimentation, testing and tuning are minimum (usually dealt as spikes). The focus there is about delivering business requirements, in the form of features and products, fast in a volatile, constantly evolving environment. To support this, a number of underpinning practices have been developed, covering areas like modelling and design, coding and testing, risk handling and quality assurance. But all these, focus primarily on feature delivery (backlogs, user-stories, CI/CD, TDD or BDD to name a few). Some of these underpinning practices can directly be transferred in the Data Science world (e.g. user stories and backlogs, timeboxing and retrospectives) but others, not so much; for instance, how can TDD be useful when experimenting with what is the optimal k with which to cluster customer datasets? So, a clear benefit of trying to apply Agile in Data Science is that gradually, similar Data Science-specific underpinning practices will eventually be developed and these will, of course, be based on the same Agile drives: adaptive planning, evolutionary development, early delivery and continual improvement, and more generally, flexible responses to change.

For the Data Scientists I would say it is mostly about adjusting to the requirement of working in a way to deliver business value from their experimentation.

The feature-oriented focus that Agile is characterised by in the software development world is not so familiar to data scientists and researchers. What’s more is that “value”—business value—is perceived in very different ways across these two worlds as well. Have you ever discussed the “value” of an experiment with a project manager? Not an easy task I assure you! My experience tells me that most of the time this comes down to project managers fearing that no tangible outputs will be produced through experimentation. This is completely wrong, but only as long as experiments are well-structured and well-thought. To me, Agile Data science is all about iterative hypothesis testing. Proving or disproving a hypothesis is always useful; it minimises the risk of failure and increases decision awareness when choosing what needs to be prioritised! But these outcomes can only be achieved when Data Scientists know exactly what they are trying to prove, discover or disprove and how that would be valuable to their team’s objective. Gradually, Data Scientists become better at it and this benefits both themselves as well as their teams.

What are the downsides of Agile in data science? What can we do about these downsides?

Agile is a set of values and principles; as such, I can’t really say that there is something wrong with it. What is surely wrong is to assume that Agile is the only way that a team can work and be productive—it’s not. Ever since Agile emerged—in the concrete form that we know it today through the Agile manifesto—many hurried to undermine the effectiveness of other development models, e.g. Waterfall.

There is nothing wrong with the Waterfall model either; the real question is whether these practices or models are fit for purpose! There are surely research projects as well as business requirements around the delivery of software that could potentially be delivered through the Waterfall approach or maybe through a combination of the two. What project managers and teams should strive for is increasing their effectiveness and efficiency. If that can be done by building on top of the Agile values then great; if not, then maybe they will need to try and come up with a different formula.

Project managers focusing too much on what Agile is and what is not—if it needs to be Scrum or Kanban or if too much documentation or too much time spent in design is not Agile—are bound to make mistakes.

Do you think that the imposition of Agile on teams (the Agile Industrial Complex) is defeating the purpose of Agile in finding what works best for teams in working adaptively?

In similar spirit to my previous response, I do! Once more, I can’t stress enough how there is no single perfect development model. Project managers need to always assess what is fit for purpose. Primarily though, they should focus on the underpinning values and principles that Agile or other development models are characterised by. When they do, a recurrent mistake that I have experienced through my consulting career is the oversimplification of Agile as an anti-methodology, anti-documentation and anti-planning development model. I appreciate that this makes understanding Agile much easier, but at the same time it is a very unfair representation of what Agile is! Imposing it on this basis is surely wrong. Equally, practicing Agile is definitely not something that comes through imposition.

I was exposed to the Agile methodology through a passionate software engineer who was an evangelist of Xtreme Programming. To him, the way he worked was a way of seeing the software engineering world and was supported by many more things than just sprints and Jira tickets and user-stories. Knowledge transferring and evolution through an unparallel team spirit and an overall culture to do things in a way that will help everyone grow (people and software) in a fast-paced and fast-evolving world. Empathy was found at the centre of everything he did and his ability to convey this passion was extreme! @tumbarumba, all the best wherever you are!

This is because Agile is, above all, a culture—a way of thinking; a way of caring about the impact and consequences of every individual’s contribution to a team goal. When it is collectively addressed as such, then only good things can come out of it.

Is there a possible reason for many data scientists to not be aware of the Agile manifesto?

I can’t be too sure about this but I if I was to point at anything, that would be how Data Science has, until recently (5 years ago), been so disjoint from the delivery of production-ready solutions. It was more focussed on research and discovery to aid decision making. Lately, the evolution and growth of ML as well as of cost-effective services to support it, necessitates the interaction of the two worlds.

Never before has it been so much the case that ML models are such an integral component of software. Before, Data Scientists did not need to worry about the operationalisation and maintenance of their model. Concepts like versioning, robustness, code-coverage and testing where not so much imposed or needed, let alone challenges related to things like dealing with technical debt and refactoring. The traditional work environment would be a Jupyter notebook with access to a database! So, Data Scientists did not need to be exposed to so many practices to govern how they would work to deliver new insights.

What kind of challenges stand in the way of operational production level DS solutions?

This mostly has to do with bridging the gap between software engineers and data scientists. Software engineers not exposed to data science can’t really do this because they fail to appreciate how exactly to maintain ML-pipelines. Note that in contrast to traditional software pipelines, there are many more issues that need to be addressed; I would refer your readers to the 2014, NIPS seminal paper on the “Hidden Technical Debt in Machine Learning Systems”. Equally, Data Scientists don’t appreciate the complexity of developing and maintaining code-bases and software solutions in a flexible and robust way to allow for things like CI/CD to be supported. This gap is now partially addressed through the emergence of a new paradigm: the ML engineer, a hybrid data scientist and software engineer, equipped with the knowledge to deal with challenges from both worlds. However, that is not enough to account for everything. What is also necessary is the emergence of appropriate tooling to support the development and maintenance of ML pipelines. A good example is Apache KubeFlow, AWS Sagemaker and the less mature but fast evolving Google AI platform.

What is surely not helpful is the bad practice of finding ways to schedule and run python notebooks in production, and I purposely changed paragraphs to highlight this! I can’t stress enough how many times I have dealt with this in my career! Python notebooks are not made to be run as part of production pipelines—yet so many companies just do so!

This is a plea to every project manager running an ML project out there: This is madness! Please stop it!

This. Is. Sparta! GIF from 300 GIFs

In your opinion, what is the most important factor in making ML-Ops agile?

I think that the answer to this question is “culture”. ML-Ops are here to help cultivate collaboration between data scientists and engineers to support the ML-lifecycle. They are a manifestation of Agile for Data Science in a way! What’s needed is for this mentality towards the development of production level ML solutions to be supported by practitioners, project managers and stakeholders the same. Everyone needs to take risks and own responsibility. Data Scientists need to develop the courage of supporting their experiments even if they may appear to delay production; they need to help stakeholders and project managers appreciate the actual value of experimentation. This will often prove to be very challenging; loss aversion will eventually kick in and when it does people will be more reluctant to change, and they will want to stick to what they know. But this is to be expected! It is natural human behaviour, and this is what we, as a community, are up against.

At the end of the day, we need to remember that it is almost impossible to find the right balance or get it perfectly right. There is no formula for it. Nevertheless, value will come simply from trying to get it right, and that is more than enough!

Many thanks again to both Tim and Dhanhyaashri for their time and effort!

Remember to like my post and re-share it (if you really liked it)!

See you soon!

AWS ML Certification

2020-07-29T00:00:00+00:00

I recently took the AWS Certified Machine Learning - Specialty, which remains one of the most demanding AWS certifications. I went through a lot of work in order to adequately prepare for this exam and I can tell you that it is indeed one of the hardest AWS certifications. Nevertheless, with proper preparation and a bit of dedication you should be fine.

How long do I need to study for this?

Well it depends; if you are an experienced Data Scientist and have been applying Data Science for about 3+ years then an hour per day for a month should be enough. This also holds if you are an engineer already exposed to the AWS infrastructure and services but are not familiar with Data Science topics.

You see, this certification is labelled as hard simply because it is not just about AWS services. 50% of it is concerned with purely Data Science topics; the other 50% is about AWS services that support Data Science and ML activities. If you are neither exposed to Data Science nor to the AWS services then at least 2 months of studying is recommended.

What does the exam cover?

Data Engineering covers 20% of the exam, then Exploratory Data Analysis concerns another 24%, modelling is 36% and Machine Learning Implementation and Operations is 20%.

I put together a list below, in an attempt to summarise the content:

Data Concepts:
- Deals with data preparation routines; things like:
  - Feature selection and;
  - Feature engineering
  - PCA,
  - dealing with missing data or unbalanced datasets,
  - labels and one-hot encoding as well as;
  - splitting and randomisation of data.
ML Concepts: Covers:
- Classical ML Categories of Algorithms
- Deep Learning
- The ML-Life-cycle
- Optimisation: Gradient Descent
- Regularisation
- Hyperparameter Tuning
- Cross-Validation
- Record I/O
ML Algorithms: A list of algorithms you should be familiar with:
- Logistic Regression
- Linear Regression
- Support Vector Machine
- Decision Trees
- Random Forests
- K-Means
- K-Nearest Neighbours
- Latent Dirichlet Allocation (LDA) Algorithm
Deep Learning:
- Cover Neural Networks in a general sense
- Convolutional Neural Networks: High-level understanding
- Recurrent Neural Networks: High-level understanding
Model Optimisation:
- Confusion Matrix
- Sensitivity and Specificity
- Accuracy & Precision
- ROC/AUC
- Gini Impurity
- F1-Score
ML Tools & Frameworks: Cover basic ML tools (know what they do and what they are used for)
- Jupyter Notebooks
- Pytorch
- MXNet
- TensorFlow
- Keras
- Scikit-learn
Amazon Serverless Services: Not everything; think about the things that a Data Scientist of ML engineer would need to do.
- Simple Storage Services - S3
- Glue
- Athena
- Amazon Quicksight
- Kinesis, Streams, Firehose, Video & Analytics (S.O.S. this one ;) )
- EMR with Spark
- EC2 for ML
- Lambda Functions
- Step Functions
Amazon Serverless ML Services: These are out-of-the-box ML solutions offered by AWS.
- Rekognition (image/video)
- Amazon Poly (Text-to-Speech)
- Amazon Transcribe (Speech-to-Text)
- Amazon Translate
- Amazon Comprehend (Text Analysis Service)
- Amazon Lex (Conversation Interface Service - Chatbots)
- Amazon Service Chaining with AWS Step Functions
SageMaker: A service that you really need to spend time with!
- What is it exactly?
- Benefits? Advantages?
- Supported Algorithms (huge list; learn most popular ones)
- Building and Pre-processing / Ground Truth
- Training and Data sourcing
- Hyper-parameter Tuning
- Model Servicing (Https endpoints)
- Elastic inference
- Batch Transform

This is by no means an exhaustive list, but you will at least get an idea about what is generally involved.

How should I prepare?

There are many ways to prepare. Myself, I covered the relative course on Linux academy, which I highly recommend.

Ideally I would recommend spending some time with SageMaker and try to interact with services like lambda functions and step-functions as well as Kinesis, Glue and Athena. However, that would take a while to do plus, using these resources does not come for free.

The Linux Academy Course has a number of labs that will help you develop an adequate understanding of these services. You can worry about honing your skills and knowledge at a later point.

How long does the exam last?

The exam consists of 65 multiple-choice, multi-selection questions. It is 3 hours long, which I think is more than enough to answer all questions and then review your responses (…or take a nap while waiting for your colleagues to finish; I do have a colleague who actually did this–myself I can never relax that much when it comes to exams).

In general, AWS exams are taken at authorised exam centers. Due to the COVID-19 lockdown, this was adjusted to satisfy the high demand in exam takers and people can take the test from home. However, the process is equally strict:

You need to provide information about the room you will be sitting in;
Room needs to be completely quiet during the exam session;
You need to be alone in the room;
You need to provide pictures of your surroundings to show you have no notes or anything suspicious close to you;
A proctor will login at the time of the exam and will ask to inspect the space around you (he asked me to show him the back of my computer prior beginning and doing so with my iMac was quite a challenge… so if you have an option go for laptop).
The exam session will be recorded.

Note that, as one would expect, looking away from the screen for more than a couple of seconds might prompt the proctor to give you a notice. To be honest, as soon as the exam began it was quite easy to just focus on the screen. It took me less than an hour to cover all questions and then used all the remaining time reviewing my responses. I received a positive notification that I passed on exam completion, but it was subject to a committee review. I guess that examiners inspect the video of yourself taking the exam to identify if you tried cheating or something. In no more than 3 days I got the official certification.

Any tips? Advice?

Well, tip number one is: “If you don’t know which is the right answer, then just go for the AWS solution in the list of options”. At large, this exam tests whether you are familiar with what is available to you through the AWS platform. If a client wants to use ML for image moderation and you recommend anything other than Rekognition then you clearly don’t know how Rekognition is used! This has generally worked for me as a way of filtering in and out options.

I would definitely recommend covering the SageMaker FAQs which I see as a wonderful source for exam material.

Do cover the official AWS practice exam; it is just 20 questions, but it is enough to give you an idea about what you are up against.

That’s it! I really wish that this article will help you get started with your learning journey and I hope that soon enough you will be joining the AWS Certified Global Community to share your badge with everyone.

Remember to like my post and re-share it (if you really liked it)!

See you soon!

Just do it!

2020-07-28T00:00:00+00:00

The thing about writing a blog-post is that you are exposing yourself to the world; it feels a lot like flying for the first time.

You will be criticised! Some will appreciate your work. Others will say it’s wrong, they ‘ll disagree–which is actually promoting healthy public debates and hence is a good thing–or they will just not care. Ultimately, blogging has nothing to do with being right neither it is about writing the perfect post. Put simply, it is just about doing it.

One of my favourite novels is “The Plague, by A. Camus”. At the moment of writing I can’t recommend this book enough given the global COVID-19 commotion. In this book, Camus’ characters are engaged in helping and saving people in the name of no ideology; people dying so unfairly (especially children) is enough to move anyone to act irrespective of whether this is suported by some moral justification.

There is one particular character, a side-character that came to mind when I sat down to write this post; Joseph Grand. Joseph is a fifty-year-old clerk operating for the city government. He lives an austere life, and in his spare time, he is writing a book. However, he is such a perfectionist that he ends up rewriting the first sentence over and over and never gets to proceed any further. No words are ever good enough! What if meaning can be elevated to a higher level if a different wording is used. He is self-blocking himself feeling helpless and devastated.

We ‘ve all been there–I am sure. If only he could let go of his perfectionism and move on to complete that first paragraph and write the first chapter. What would be the story that he would say? What morals and learnings would be revealed and shared?

I guess we will never find out about Joseph Grand, but my blogging journey begins here and now. Looking forward to hear your thoughts and I welcome all of your comments.

Remember to like my post and re-share it (if you really liked it)!

See you soon!

ML Affairs

Kafka Streams vs Flink Is The Wrong Question

The Bias I Had To Correct

What I Still Love About Flink

Where Kafka Streams Grew On Me

1. The State Model Is Different, Not Just Worse

2. Kafka-Native Integration Is A Real Strength

Where Flink Still Pulls Away

1. Scaling Stops At The Broker Boundary Much Earlier In Kafka Streams

2. Checkpointing And Recovery Are In A Different League

The Real Trade-Off

The Harder Lesson

What I Would Actually Do

PyFlink In 2026: Better Than Its Reputation, Still Not Frictionless

What Has Improved Since The Older Evaluation

1. The Python Story Is Better Documented

2. The DataStream Story Is No Longer Hand-Wavy

3. Debugging And Packaging Are Better Acknowledged

Why PyFlink Is Genuinely Attractive

1. It Keeps The Streaming Layer Closer To The Actual ML Ecosystem

2. It Meets Python-Heavy Teams Where They Already Work

3. It Makes Flink More Reachable Without Hiding Flink

4. There Is A Real Connector Surface

Why PyFlink Is Still Not “Flink, But Easy”

1. You Still Have To Think In Two Worlds

2. The Connector Story Still Leaks JVM Reality

3. Debugging Still Tells You What The System Really Is

4. Native Python Models Are Not An Automatic Architectural Win

5. The Performance Question Never Fully Goes Away

So When Would I Use It?

If You Want To Try It

The Practical Takeaway

Harmonizing Avro and Python: A Dance of Data Classes

The Issue at Hand

Avro… what now?

The Evolution of Data Serialization

What’s in a POJO?

The Dawn of the POJO Era

Apache Avro & the Magic of Schemas

Challenges in Schema Communication

Artifact Repository & Versioning

Generating Python Data Classes from *.avsc files

Sample Project Structure

Why Read-Only?

Conclusion

Agile In Action: Bridging Data Science and Engineering

Why This Topic Stayed With Me

The Real Gap Between Data Science And Engineering

What Agile Actually Helped With

1. Making experiments explicit

2. Creating shared visibility

3. Putting discipline around handoffs

What ML Teams Still Underestimate

The Lesson I Was Trying To Communicate

The Podcast

Dynamic(i/o) Why you should start your ML-Ops journey with wrapping your I/O

So what do we do…?

Here is my notebook! I am done; your turn now!

What is dynamicio then?

Complete Guide to Python Envs (MacOS)

Most common ways of setting up Python

How to avoid all these?

Let’s get to it

Setting up your global interpreter

Creating and managing virtual environments automatically

Using jupyter notebook or jupyter lab with a virtual environment of your choice

Final notes

A BREXIT NLP Dataset!

The idea

The dataset

Dataset now available on Kaggle

Style Transfer in Heraklion

A bit of history: A Neural Algorithm of Artistic Style

Delving into the details

Retrieving the content

Retrieving the style

It’s all in the formulas (or formul$ae$)

$\mathcal{L}_{content}$

$\mathcal{L}_{style}$

Putting it all together

Generating Python Data Classes from `*.avsc` files

What is `dynamicio` then?

Setting up your `global` interpreter

Using `jupyter notebook` or `jupyter lab` with a virtual environment of your choice

Using `PyTorch` for Style transfer