MJ's Blog

AirPlay Receiver Runs on Port 5000

Mon, 08 Jun 2026 00:00:00 GMT

Today I learned that the AirPlay Receiver on macOS runs on port 5000. Killing the process listening on this port reloads the menubar, but the port gets instantly occupied again as the process restarts automatically.

Disabling the AirPlay Receiver in System Settings stops the process, and the port is clear again.

You can toggle it here:

System Settings → General → AirDrop & Handoff → AirPlay Receiver off

AltTab does not work anymore

Mon, 08 Jun 2026 00:00:00 GMT

Today I learned, when AltTab does not work anymore, you might just have it configured to use a different shortcut than the one you are expecting (especially when freshly installed).

In my case it was set to alt + tab instead of cmd + tab. Sometimes the problem is sitting in front of the screen…

Neapolitan Pizza Dough Calculator

Mon, 08 Jun 2026 00:00:00 GMT

My former colleague Hendrik (known for his YouTube channel The Bread Code) wrote this amazing guide on how to create the best possible pizza dough in the Neapolitan style as well as this calculator to infer the precise amounts of flour, water and yeast to use.

It is great if you need all the options and features. For me though, I wanted to have a more stripped down version with only the most important steps and a single Neapolitan style calculation. So here it is, on tools.marc-julian.com/tools/pizza/.

Fixing macOS Cursor Hover Not Working

Fri, 05 Jun 2026 00:00:00 GMT

I often encounter the problem that something steals my macOS cursor focus, and from that moment on, the cursor icon no longer changes on hover (pointer, finger, hand, arrows, etc.).

Today I learned that moving your mouse violently (a macOS feature that briefly increases the cursor size so you can find it on a big screen), will temporarily fix the problem until it comes back at some random point in time. I don’t like that we have to rely on some weird mouse-movement hack instead of Apple fixing this, but hey, you now know how to fix it in that moment.

Engineering Notebook Experiment

Mon, 25 May 2026 00:00:00 GMT

I read about engineering notebooks here: https://ntietz.com/blog/using-an-engineering-notebook/ and for me the aspects that stood out the most were:

it is an append-only notebook (no modifications or deletions)
you write notes before doing a code change
- this requires thinking through the problem before writing any code, potentially leading to better code
writing the note (and the thinking before writing) is the main selling point here. Reading back old notes not so much

Will try this out for at least a week in my day-to-day job. For personal projects I don’t see the benefit yet as long as you are still in the fast paced prototyping stage of your project. Maybe this will change after the week. Will keep a record on this.

Curl This Website

Wed, 22 Apr 2026 00:00:00 GMT

Small easter egg on this website.

Try running this:

curl marc-julian.com

or this:

curl marc-julian.com/email | sh

in your favorite terminal.

Cooking With Claude Code

Thu, 19 Feb 2026 00:00:00 GMT

I was inspired by this post on Simon Willison’s Blog to try out cooking with Claude Code / Claude. There are multiple ways to do this. For example:

generating recipes based on a list of available ingredients
simply asking for a specific recipe
planning an entire dinner (including cooking, managing time, shopping groceries, structuring the work)

Recipe Generation

During the last few months I tried the second and third option. Claude “came up” with this surprisingly tasty herbal butter by grinding thyme and rosemary in a 3:1 ratio and mixing it with garlic, salt and butter to taste. It was great. Simple to cook and went really well with beef tenderloin. You can find the recipe here on my new recipe website: recipes.marc-julian.com.

Dinner Planning

Planning an entire dinner was a great use case for Claude Code. I created a new git repository in a local folder, spun up Claude Code and asked it to write down many notes to plan my dinner. I had already picked most dishes and just needed help planning it all together. To get the timings right, be prepared, have all ingredients, hardware and tableware ready and overall have a nice oversight on what to do the next two days. If you want, you can take a look at the resulting notes after some conversations with Claude Code, here.

Here are some pictures of the dinner managed by Claude Code:

Claude Dinner Appetizer

Claude Dinner Main Course

Claude Dinner Dessert

How to Slim Down a Vite App

Sat, 25 Oct 2025 00:00:00 GMT

I recently encountered this warning in one of my Vite apps:

Rollup Chunk Warning in Terminal

This chunking warning will often appear if you add large dependencies to a project. To find out which dependencies are the culprit, analyze the bundle size using the rollup visualizer plugin. It can be configured like this in vite.config.ts:

import { visualizer } from "rollup-plugin-visualizer";

export default defineConfig({
  plugins: [
    react(),
    tailwindcss(),
    visualizer({
      filename: "stats.html",
      emitFile: true,
      template: "treemap",
    }),
  ],
  resolve: {
    alias: {
      "@": path.resolve(__dirname, "./src"),
    },
  },
});

After building the project (e.g. by running pnpm build) you can open the stats.html file from the dist folder (e.g. by running open ./dist/stats.html). Depending on the selected template, different visualization types will open:

Treemap

Rollup Visualizer Treemap

Flamegraph

I found this to be the most useful and easy to understand version. It clearly shows the different layers and big chunks are quick to find.

Rollup Visualizer Flamegraph

Sunburst

Rollup Visualizer Sunburst

Treemap 3D

This one is crazy, looks a bit like a microcontroller.

Rollup Visualizer Treemap 3D

What to do about big chunks?

This kind of depends on the type of chunk and how prominently it is used in your app. The React dependency for example is hard to chunk if your app is a React app. But if your dependency is only used on certain pages (for example a PDF viewer) you might want to only load it when it is actually viewed by the user.

You can do this by lazy importing dependencies or more complex pages. In this example, the <Page> component could include a PDF viewer that you only want to load when the component mounts/loads:

const Page = lazy(() => import("./pages/page"));

Speeding Through Git

Wed, 03 Sep 2025 00:00:00 GMT

The best tool for speeding up git workflows (imo) is the oh-my-zsh git plugin.

Doing something like the following feels like magic:

gsw main
gl
gsw feature/my-feature
gst
gstu
grb main
gpf
gstp

switching to main branch
pulling newest changes on main
switching back to feature branch
checking status of my files
stashing all changes (including untracked)
rebasing feature branch onto main
force pushing the rebased branch to the remote
popping the stashed changes to continue working

All that in about 10 seconds because the commands get into muscle memory fast. Could not live without it anymore.

Obsidian Dataview Serializer

Sat, 21 Jun 2025 00:00:00 GMT

The popular Obsidian Dataview plugin let’s you query markdown notes with SQL-like syntax. It uses the YAML frontmatter (also known as Obsidian properties) as attributes. This enables powerful workflows. For example, all of my blog posts contain these YAML properties:

blog-title
blog-tags
blog-published
blog-author
blog-archived
blog-skip

With these, I can create lists and tables about my blog posts. For example, the following query results in a table of all posts that are currently published, sorted by publishing date:

TABLE blog-published
FROM "Posts"
WHERE blog-skip != true and blog-archive != true
SORT blog-published desc

But you can also build more complex queries. The following adds a markdown formatted link to the actual published blog post website as a new column:

TABLE WITHOUT ID ("[" + blog-title + "](" + "https://marc-julian.com/blog/posts/" + replace(file.name, ".md", "") + ")") AS "URL", blog-published as "Published" FROM "Posts" 
WHERE blog-skip != true and blog-archive != true 
SORT blog-published desc

Obsidian Dataview Serializer

The tables created with dataview are great inside of the Obsidian editor, but they won’t render in other markdown editors/viewers (e.g. GitHub READMEs). The Obsidian Dataview Serializer solves this specific problem by live-updating a “serialized” markdown version of the table. Every time the underlying data or the query changes, the plugin will update the markdown table accordingly.

Examples

Check out this README of my blog post repository on GitHub to see it in action. It uses the second more complex query to provide links to all posts right in the README. There you should even be able to see this very post you are reading right now.

What I like about this approach is that it works in all places that can render markdown tables. For example, I am also using the plugin to render a table of different types of coffee bean varieties on our German coffee and espresso wiki the-brew-code.de.

Copy Permalink to Line in Zed

Sat, 31 May 2025 00:00:00 GMT

Today I learned that you can copy a permanent link to a line of source code in Zed. It’s as simple as a right-click and selecting Copy Permalink (the last option in the context menu). It will copy a GitHub link to that exact line of code to your clipboard. This is great for sharing an exact location in the codebase with your colleagues.

Serve Hugging Face Models in Ollama

Sat, 31 May 2025 00:00:00 GMT

Ollama can serve many Hugging Face models locally. Concretely, you can run any GGUF model from the Hugging Face Hub. Use this GGUF filter on the Hugging Face website to get a list of models that Ollama support (about 121,000 models at the time of writing). From the model card, you can click “Use this model” to copy the ollama run command. For example:

ollama run hf.co/unsloth/DeepSeek-R1-0528-Qwen3-8B-GGUF:Q4_K_M

The commands have following structure:

ollama run hf.co/{username}/{repository}:{quantization-scheme}

If you leave out the quantization-scheme part, Hugging Face will choose either Q4_K_M when available and a reasonable version if not. See this article on Hugging Face for more information.

TypeScript Ollama Client

Given an Ollama server running on OLLAMA_API_BASE_URL, you can use the Ollama TypeScript client to do inference on any of those models like this:

import { Ollama } from 'ollama';

const ollama = new Ollama({ host: OLLAMA_API_BASE_URL });

// Example to do inference with an embedding model
const output = await this.ollama.embed({
      model: "hf.co/chris-code/multilingual-e5-large-Q8_0-GGUF:Q8_0",
      input: "some text to be embedded",
    });

OpenTelemetry gRPC Exporter

Sat, 12 Apr 2025 00:00:00 GMT

This is an update / followup for last weeks post on OpenTelemetry LLM App Tracing with Phoenix which ended with following statement:

because I noticed some span exporting issues to Phoenix I tried a different span/traces exporter: ZipkinExporter with the Zipkin UI and there is still an open discussion on GitHub about the problems I noticed with Phoenix. Will update this post accordingly.

After further debugging (breaking at every single span.end() call) I was able to see that during some span creations, the error Exception has occurred: Error: read ECONNRESET and Exception has occurred: Error: socket hang up showed up. These spans were missing in Phoenix. Roger Yang suggested to use the experimental gRPC exporter like this:

import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";

const provider = new NodeTracerProvider({
  spanProcessors: [
    new SimpleSpanProcessor(
      new OTLPTraceExporter({
        url: "http://localhost:4317",
      }),
    ),
  ],
});

registerInstrumentations({
  instrumentations: [new OpenAIInstrumentation()],
});

provider.register();

This exports spans directly via gRPC to port 4317 of your Phoenix app. Make sure to use the Docker images provided by Phoenix which automatically expose this port next to the default 6006 port.

With the above exporter configured, no spans go missing anymore and Phoenix captures even complex long running traces.

Remove macOS Sequoia Screen Capture Notifications

Sat, 12 Apr 2025 00:00:00 GMT

With a recent macOS Sequoia update, apps capturing your screen would trigger a new notification that shows next to the menubar. For apps like AltTab which take screenshots of your screen for their functionality, this results in a constant flood of notifications every time you use the app.

Apparently, this new “feature” was not on purpose. It should show a notification once every 30 days. But through some misconfiguration of the timestamps in the ScreenCaptureApprovals.plist file, the notification was not limited to 30 days. To fix this, find the file with:

open $HOME/Library/Group\ Containers/group.com.apple.replayd

and move or delete the ScreenCaptureApprovals.plist file from the opened folder. Then directly restart your Mac. The macOS system will automatically rewrite the file with corrected timestamps and the screen capture notifications don’t show up anymore.

Debugger Nest.js App

Sat, 12 Apr 2025 00:00:00 GMT

Today I learned that it’s easier than I thought to attach a debugger to a NestJS app in VS Code. Run the following commands in the command palette:

Debug: Toggle Auto Attach
(Debug: Attach to Node Process)

In the terminal, run the NestJS app in the usual way, for example yarn start:dev. The debugger will now attach automatically.

No need to edit any launch.json files, awesome!

1-year Anniversary at AHEAD Automotive

Sun, 06 Apr 2025 00:00:00 GMT

This week I had my 1-year anniversary at AHEAD Automotive. In this short time we built an entire product from scratch, which is now used by over 60 car workshops in Germany and soon released for everyone. The product, called Qira, is the intelligent assistant for the automotive aftermarket. Qira combines detailed repair information from data providers and original car manufacturers at a single point of access. With a simple natural language input field, car mechanics can ask Qira for

detailed vehicle data 🚗
lubricants 💧
component locations 📍
repair manuals 🔧
recalls ⚠️
technical drawings 📝
and much more…

Qira also interprets error codes to precisely describe their symptoms, causes and effects. Qira can predict affected components and suggests solutions based on past reports with the same error code. Qira will even guide users through step by step diagnosis instructions to accurately pin down faults in electrical components.

All answers by Qira use reliable data sources and we made sure that our systems can not alter the provided information, so you can always be sure to get the most up to date and accurate information.

I am proud that our hard work can now see the light of day and that Qira is already assisting car mechanics with their daily work.

OpenTelemetry LLM App Tracing with Phoenix

Sun, 06 Apr 2025 00:00:00 GMT

I wanted to setup tracing for an LLM app with Phoenix and while doing so I had some learnings that I wanted to document:

you have to take SimpleSpanProcessor by its name. It’s a simple span processor. It’s nice for development but for production you should be using the BatchSpanProcessor because it batches span exports, saving tons of network requests and probably avoiding some concurrency issues
always make sure to end spans at the correct position, not too early, not too late, with span.end(). If you are using one central place to create spans, end them right there after you added attributes to it
if you use SemanticConventions, make sure to check which attributes you actually need to set to get any visual on some dashboards (like Phoenix)
separate tracing from business logic as much as possible. I am using a decorator for that specific purpose. It has access to the functions input, output and you call it by decorating a function with it. Now it stays out of the way of your business logic.

Here is an example implementation of such a Trace decorator.

export function Trace<A, R>(
   traceName: string,
   traceFunction: (span: Span, args: A, result: R) => void,
 ) {
   return function (
     target: unknown,
     propertyKey: string,
     descriptor: PropertyDescriptor,
   ) {
     const originalMethod = descriptor.value;

     descriptor.value = async function (args: A) {
       return await tracer.startActiveSpan(traceName, async (span: Span) => {
         const result = await originalMethod.call(this, args);
         traceFunction(span, args, result);
         span.end();
         return result;
       });
     };
     return descriptor;
   };
 }

And here is an example on how you can use it. As you can see the business logic in doingSomeWork() is free of any tracing logic. Removing the @Trace() decorator removes any tracing from it.

type DoingSomeWorkParams = {
	input: string;
}

@Trace("Doing Some Work", DoingSomeWorkParams, string)
async function doingSomeWork(args: DoingSomeWorkParams): Promise<string> {
	// ... doing some work with args.input
	return result
}

function traceDoingSomeWork(span: Span, args: DoingSomeWorkParams, result: string) {
	span.setAttributes({
     [SemanticConventions.OPENINFERENCE_SPAN_KIND]: OpenInferenceSpanKind.AGENT,
     [SemanticConventions.INPUT_VALUE]: args.input,
     [SemanticConventions.OUTPUT_VALUE]: result,
    });
}

Going on with the list of learnings:

either use a ConsoleSpanExporter or diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG); to see a lot of details about the tracing. Interesting are the traceId, parentId and id attributes of each span. Here you can check whether the context got propagated nicely between the spans.
because I noticed some span exporting issues to Phoenix I tried a different span/traces exporter: ZipkinExporter with the Zipkin UI and there is still an open discussion on GitHub about the problems I noticed with Phoenix. Will update this post accordingly.

Ghostty - My Favourite Terminal Emulator

Mon, 13 Jan 2025 00:00:00 GMT

I stumbled upon Ghostty a nice looking open source terminal emulator. It feels fast, even comparable to native terminals. I have been using it for the past weeks in my macOS setup and found it to come close to the macOS Terminal.app experience.

What I enjoy most about Ghostty is its easy configuration. You can open and edit the config file with the keyboard shortcut cmd + , and reload it with shift + cmd + ,. These are the settings I am using right now:

background-opacity=0.9
background-blur-radius=30

font-size = 18
theme = GitHub Dark
background = #28394a
foreground = #fafafb
palette = 0=#1d1f21
palette = 1=#c5474e
palette = 2=#68cd66
palette = 3=#d4ac3a
palette = 4=#4386f6
palette = 5=#d856a6
palette = 6=#6ae1e4
palette = 7=#feffff
palette = 8=#686767
palette = 9=#c6474e
palette = 10=#9ce5a3
palette = 11=#d3ac3a
palette = 12=#4386f6
palette = 13=#d856a6
palette = 14=#6ae1e4
palette = 15=#feffff

window-padding-x = 15
window-padding-y = 10

keybind = option+super+left=previous_tab
keybind = option+super+right=next_tab

working-directory = home
window-inherit-working-directory = true

Btw, there is also this beautiful looking open source Ghostty Config Generator.

Command Line - Aliases and Functions

Wed, 05 Jul 2023 00:00:00 GMT

Edit (17.12.2024): After more than a year of using Oh My Zsh and custom aliases, my most used and favourite aliases are go <marker-name> (for going to a marked directory) and b (short for back + performing cd ..). Oh My Zsh is awesome!

Edit (20.07.2023): The open source framework ohmyzsh makes it even easier to manage complex zsh configurations and there are tons of plugins that add useful aliases.

Today I learned (TIL) that you can define aliases and functions inside of most command line applications like bash or zsh shells. For zsh, you can find the .zshrc config file directly in the user folder. You can edit it in any text editor (on some systems, you might need to open it as an admin or run your preferred command with sudo).

Run the following command to execute the file and reload all defined aliases and functions.

source .zshrc

Here are some of my favorites:

Conda

# Run to get bash autocomplete functions in zsh shell 
autoload bashcompinit
bashcompinit
autoload -Uz compinit
compinit

# List all conda environments
function envs() {
	conda info --env
}

# Activate environment with autocompletion
function aenv(){
    conda activate $1
}

function extract_env_names() {
    # Extracts the names of the environments from the output of `conda info --env`
    conda info --env | awk -F' ' '{print $1}' | tail -n +3
}

function _aenv() {
    # Get the current word being completed
    local cur=${COMP_WORDS[COMP_CWORD]}

    # Generate possible matches and store them in the COMPREPLY variable
    # -W expects a list of possible matches
    COMPREPLY=($(compgen -W "$(extract_env_names)" -- $cur))
}

# Register the completion function to be called for the aenv command
complete -F _aenv aenv

function denv(){
    conda deactivate
}

# Create a conda environment with a name and python version
function cenv(){
    conda create -n $1 python=$2
}

function renv(){
    conda remove -n $1 --all
}

# Create a python kernel from a conda environment
function envtokernel(){
    python -m ipykernel install --user --name $1 --display-name "Python ($1)"
}

# Create a conda environment with some sane default packages that I use a lot in data science projects 
function defaultenv(){
    cenv $1 $2
    conda activate $1
    pip install pandas numpy matplotlib seaborn scikit-learn notebook
    envtokernel $1
}

Mark paths to directly jump to them from anywhere

Inspired by the mark and cdd function in this blog post by Chris Said, I added two more functions opend and coded to open a folder in Finder or VSCode.

# Run to get bash autocomplete functions in zsh shell 
autoload bashcompinit
bashcompinit
autoload -Uz compinit
compinit

export MARKPATH="/Users/username/marks"

# jump to a marked path
function cdd() {
    # change directory to the marked path, if it does not exist, ignore the error and print "No such mark: $1" instead
    cd -P "$MARKPATH/$1" 2>/dev/null || echo "No such mark: $1"
}

function opend() {
    open "$MARKPATH/$1" 2>/dev/null || echo "No such mark: $1"
}

function coded() {
    code "$MARKPATH/$1" 2>/dev/null || echo "No such mark: $1"
}

# mark a path for quick access
function mark() {
    # create a folder to store marks
    mkdir -p "$MARKPATH"

    # create a symlink in the mark folder to the current directory
    ln -s "$(pwd)" "$MARKPATH/$1"
}

# delete a mark
function unmark() {
    # remove the symlink
    rm -i "$MARKPATH/$1"
}

# list all marks
function marks() {
    # list all symlinks in the mark folder with some formatting magic to make it look nicer
    \ls -l "$MARKPATH" | tail -n +2 | sed 's/  / /g' | cut -d' ' -f9- | awk -F ' -> ' '{printf "%-10s -> %s\n", $1, $2}'
}

# autocomplete marks
function _cdd() {
    # get the current word being completed
    local cur=${COMP_WORDS[COMP_CWORD]}
    # generate possible matches and store them in the COMPREPLY variable
    COMPREPLY=($(compgen -W "$(ls $MARKPATH)" -- $cur))
}

# register the completion function to be called for the cdd command
complete -F _cdd cdd
complete -F _cdd opend
complete -F _cdd coded

Python

function py(){
    python $1
}

function pyv(){
    python --version
}

Streamlit

function strun(){
    streamlit run $1
}

Jupyter

alias jnb="jupyter notebook"

Git

function gitc(){
    git commit -m "$1"
}

alias gits="git status"
alias gitp="git push"
alias gitpl="git pull"
alias gitb="git branch"
alias gitl="git log"
alias gitd="git diff"

NPM

alias ninit="npm init -y"
alias nstart="npm start"
alias nbuild="npm run build"
alias ntest="npm run test"
alias ninstall="npm install"

ImageMagick

# d for do mogrify 
# I use this to automatically convert images for this blog 
function dmog(){
    mogrify -format jpg -geometry 1300x -quality $1 *.png
}

Implementing a Simple Perceptron for Binary Classification

Tue, 27 Jun 2023 00:00:00 GMT

We’ll be implementing a simple perceptron model for binary classification tasks using Python, and discussing the fundamentals of the perceptron model, including how it makes predictions and updates its weights during training.

The first step in implementing a simple perceptron model is to define a class that contains the weights, training loop, and prediction methods.

class Perceptron:

	def __init__(self, lr=0.01, epochs=50):
		self.lr = lr 
		self.epochs = epochs 
		self.init_weights() # TODO

Here, we already set default values for hyperparameters like the learning rate (lr) and the number of epochs that the model should train for. We already initialize the weight and bias values with the init_weights method.

Weight & Bias Initialization

To initialize the weights and bias, we can either use constant values like 0 and 1, or we can choose random numbers. Since our training data has two features, we need one weight per feature, so we use two random values for the weights here.

def init_weights(self):
	self.weights = torch.rand(2) 
	self.bias = torch.rand(1)

Training Loop

Now we are ready to work on the training loop. The basic idea is that we start predicting classes with random weight values in the model. We then compare the predicted (probably misclassified) class label with the expected class label to compute the error that the model has made.

We then use the error to update the weights and bias by a small amount to get better predictions. We iterate over this process until the model converges or we reach the maximum epoch limit.

At each learning step (epoch), we loop through the entire data set and update the weights and bias by a small delta value.

In the code, we can use two loops to iteratively update the values.

def fit(self, X, y):
	for epoch in range(self.epochs):
		# for every data point and label
		for xi, yi in zip(X, y):
			weight_delta = ... # TODO 
			bias_delta = ... # TODO 

			# Update weigths
			self.weights += self.weight_delta 
			self.bias += self.bias_delta

Of course, the important part is calculating the correct delta values.

can take different values depending on the predictions. If the true and predicted classes are the same (0,0 or 1,1), the error will be equal to 0. In this case, everything is fine and we don’t need to update the weights. In the two cases of misclassification (0,1 or 1,0), the error will be either -1 or 1. Here we want to update the weights to hopefully get the prediction closer to the correct class in the next epoch.

As you can see from the formula below, we update the weight according to the actual data points. This way, our data has an influence on the weight updates. Large values will have a higher impact than small values. This implies that our model benefits from feature scaling. One of the methods that could help is standardization where you subtract the mean and divide by the standard deviation to center and scale your data points.

We multiply by the learning rate to make smaller steps, which helps to get better convergence. The magnitude of the learning rate plays an essential role. Too large values will lead to rapid but unstable convergence, too low values will make the model converge slowly and it may even get stuck in local minima.

def fit(self, X, y):
	for epoch in range(self.epochs):
		for xi, yi in zip(X, y):
			# Compute the error and weight updates
			error = yi - self.predict(xi) # TODO
			weight_delta = self.lr * error * xi  
			bias_delta = self.lr * error

			self.weights += self.weight_delta 
			self.bias += self.bias_delta

Lastly, we have to implement the predict method to be able to calculate the error.

Prediction

For prediction, we compute a linear combination of the input data using the trained weights and bias. To get the corresponding class labels, we need to clip the values with a step function. This gives us a binary output, like the target variable.

def predict(self, X):
	output = X @ self.weights + self.bias
	# Activation Function (in this case a simple step function)
	pred = torch.where(output >= 0.0, 1, 0) 
	return pred

Using the Perceptron Model

To use the perceptron model, we first need to create some sample data using the scikit-learns make_classification function. The resulting synthetic data set has two classes with two features.

X_train, y_train = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, random_state=40)

plt.scatter(X_train[:,0], X_train[:,1], marker='o', c=y_train, s=25)
plt.show()

Scatter Plot for Binary Classification Problem

Prediction with Random Weights

First, we create a perceptron instance and predict classes without training the model.

perceptron = Perceptron(lr=0.01, epochs=100)
y_pred = perceptron.predict(X_train)

plt.scatter(X_train[:,0], X_train[:,1], marker='o', c=y_pred, s=25)
plt.show()

We can see that the random weights did not do a good job of separating the two classes.

Bad Binary Classification Scatter Plot

Prediction with Trained Weights

Now, let us fit the perceptron and see whether the results are any better.

perceptron.fit(X_train, y_train)
y_pred = perceptron.predict(X_train)

Here we can see two different plots for the predictions. For the left one, I did not use any activation function which is why it shows the full range of values that the model predicted. For the right side, I used the step function from above.

Good Binary Classification Scatter Plot

After training, the model seems to be able to discriminate between the two classes. But, when comparing the predictions with the original data set we can see that some samples were still misclassified. This is expected because the perceptron model is trying to fit a linear decision boundary while the two classes are actually not linearly separable. We could solve this problem by introducing more features, since in a higher dimensional space there may be a hyperplane that perfectly separates the classes. Of course, this will not always be possible which is why we need more complex models that can fit nonlinear decision boundaries.

Code

You can find the complete code here and on GitHub.

import torch
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification


class Perceptron:

    def __init__(self, lr=0.01, epochs=50):
        self.lr = lr
        self.epochs = epochs
        self.init_weights()

    def init_weights(self):
        self.weights = torch.rand(2)
        self.bias = torch.Tensor([0])

    def fit(self, X, y):
        X = torch.Tensor(X)
        y = torch.Tensor(y)
        for epoch in range(self.epochs):
            total_error = 0
            for xi, yi in zip(X, y):
                y_pred = self.predict(xi)
                error = yi - y_pred
                self.weights += self.lr * error * xi
                self.bias += self.lr * error
                total_error += error
            if epoch % 10 == 0:
                print(f'epoch {epoch} \t error {total_error}')

    def predict(self, X, activation=True):
        X = torch.Tensor(X)
        output = X @ self.weights + self.bias
        if activation:
            output = torch.where(output >= 0.0, 1, 0)
        return output

perceptron = Perceptron(lr=0.01, epochs=200)
perceptron.fit(X_train, y_train)
y_pred = perceptron.predict(X_train)

VSCode Regex Group Reference in Find and Replace

Tue, 13 Jun 2023 00:00:00 GMT

Today I learned (TIL) that you can reference regex groups in the “Find and Replace” search of VSCode.

For example, if you want to find a certain HTML tag to replace it with a different one, you could use the following regex expression in the search

<p>([.\W\w]*?)</p>

and use the captured group $1 in the replacement like this:

<h1>$1</h1>

Ensure that you enabled regex syntax using the button in the search field on the right side.

Highlights from ML Prague Conference 2023

Thu, 08 Jun 2023 00:00:00 GMT

Last week, I joined machine learning enthusiasts from around the world in Prague for Europe’s biggest conference on ML and AI applications, ML Prague 2023.

ML Prague Conference 2023 sign at the entrance

The event featured a broad lineup of speakers, covering a wide range of topics - from the latest breakthroughs in natural language processing to cutting-edge computer vision applications. In this blog post, I want to write about some of the most interesting talks from the conference and highlight the key takeaways. Without further ado, let’s dive in and start with two topics from the area of image processing.

Image Processing

3D Pose Estimation in Sport

Piotr Skalski from Roboflow showed us how he was able to reproduce parts of the Video Assistant Referee (VAR) system shown in the following clip.

He used YOLOv7 and two cameras that record from different perspectives to track a skeleton of his body.

When using this technique, there are some key points to consider:

Use at least two cameras with the same configuration
- For best results, position them above the playing field to reduce player occlusions
- For better results, use more than two cameras
Avoid or remove any lens distortion before processing the video recordings.

Take a look at his GitHub repository to see the results.

Multi-Model Machine Learning based Industrial Vision Tool for Assembly Part Quality Control

Aimira Baitieva from Valeo offered insights into anomaly detection in images using neural networks.

One interesting idea was to train a model that outputs embeddings for images, which represent their information well enough. You could then create a “good” embedding for normal parts (without anomalies) to compare against. If an embedded image has a dissimilarity above a certain threshold when compared with the good embedding, one can mark it as an anomaly.

Their final multi-model approach, consisted of three steps:

Create a segmented anomaly map:
1. Segment the image to get a segmentation map
2. Use an anomaly detector to get an anomaly map
3. Combine both maps
Extract features from this map
Classify the image based on the features.

Image at Conference of multi-model approach

This turned out to work well and is in use right now.

Large Language Models

LLM-driven Game Characters

Marek Rosa from GoodAI shared their progress in creating LLM-driven game characters.

In their AI Game, characters use a large language model to generate their thoughts, actions and speech. The player can interact with them via a chat interface and with normal in-game actions like exchanging objects.

Every character has a long-term memory in the form of a vector database. The app preprocesses new thoughts and interactions and saves them into the database. When needed, it queries the database based on

recency
importance
and relevance.

The current context of the language model forms the short-term memory. This combination of short and long-term memory let’s agents learn continually by using it to plan actions based on past observations, experience, its current environment and thoughts.

Personally, I think that LLMs will redefine the role of NPCs (Non-Player Characters) in video games. Today, the player-controlled character is often the central figure in the game’s story while other characters are less important. In the future, the player will take on a more supporting role and the game does not have a defined protagonist. The story will be open-ended and allows the players and NPCs to make choices that affect the outcome and direction of it. More games will adopt a sandbox-style approach, like Minecraft, where there is no clear goal or ending of the game.

Other interesting projects that try to use LLMs to create autonomous agents are

Conclusion

In conclusion, the ML Prague Conference 2023 was a fantastic opportunity for ML professionals to come together, learn about the latest trends and innovations in the field, and connect with others. I had a great time and am glad that I was able to be there. I hope you enjoyed this short recap of the conference. If you’ve been there too, let’s connect on LinkedIn and have a chat about your favorite talks.

Prague City with evening sun

Hackbay 2023 - A hackathon for everyone

Mon, 05 Jun 2023 00:00:00 GMT

Last month, I attended the two-day Hackbay 2023 Hackathon and, together with Maximilian Kasper, we worked on DATEV’s challenge called “Disrupting DATEV’s HR Process with AI”.

Hackathon

Our Prototype

On day one, we started with some brainstorming to generate good ideas that could make the HR process as easy and frictionless as possible for both the applicant and the company. In the end, we decided to concentrate on the part of the process where applicants search for job opportunities and companies try to find fitting candidates for their job offers.

We wanted to create a job-offer platform that uses new advances in Natural Language Processing (NLP) to automatically suggest fitting jobs based on raw resume text files. Applicants should be able to upload their resume and instantly see jobs that fit their academic and professional career, their skills, languages, and interests. Also, the applicant should be able to weigh their experiences and interests in a way such that the platform shows them relevant jobs.

The platform removes the need for creating a detailed profile and relies on the applicant’s resume. This way, no extra work is necessary.

Coding at the hackathon

We decided to use Streamlit as the frontend framework to create a user interface that was fast to iterate on.

For the recommendation system, we used the following approach:

Create an embedding for the resume text
1. Use a BertTokenizer to encode the text
2. Use a BertModel to embed the encoded tokens
Create an embedding for every job posting
1. Use a BertTokenizer to encode the text
2. Use a BertModel to embed the encoded tokens
3. Use an AnnoyIndex to store the embedding vectors for easy and fast retrieval via their similarity (spotify/annoy)
Query the index with the resume embedding to get the k most similar job postings
Filter and sort similar job postings based on the user’s selected weights and hard constraints (e.g. location, language, etc.)

In the end, an applicant was able to upload their raw resume to the platform, which would automatically find the most fitting job postings and output them as a sorted list. The applicant could then apply to one or more of the listed jobs.

Of course, this was a prototype, so there were still a lot of issues that one would have to tackle to actually bring the platform into production.

For example, at the moment, companies and/or applicants could hack the recommender by writing their job postings and resumes in a way such that they are semantically similar. An applicant could achieve this with long keyword lists that outweigh all other factors.

Conclusion

In summary, we developed a prototype job-offer platform that utilizes NLP to suggest fitting job opportunities based solely on a resume text file. The platform removes the need for an applicant to create a detailed profile, simplifying the hiring process for both employers and applicants.

Attending the Hackbay 2023 Hackathon was a valuable experience that allowed us to challenge ourselves to develop a ML solution within a short timeframe.

You can check out the aftermovie for the 2023 Hackbay Hackathon to get a glimpse of the event’s highlights:

Obsidian for Raycast - Now in New Hands

Mon, 15 May 2023 00:00:00 GMT

As of 15th May 2023, I will no longer be an active developer for the Obsidian Raycast extension because I want to invest even more time for data science related topics.

I want to thank all 20,000 users and Kevin Batdorf for his effort in taking over the extension and further maintaining it to keep it alive for the community.

The Tensor Tournament 2023

Fri, 03 Feb 2023 00:00:00 GMT

I had the opportunity to take part in The Tensor Tournament Hackathon (organized by the Machine Learning and Data Analytics Lab at FAU) and I am happy to announce that our team, Maximilian Kasper and me, emerged as the winners! The hackathon was a six-hour event where teams had to solve three machine learning and deep learning problems. It was an intense and challenging experience, but also incredibly rewarding to put our skills to the test and come out on top.

Winning Team and Organizers

First Problem: The Gingerbread Chef

The first problem was to build a machine learning model that could accurately predict the quality of gingerbread on a scale of 0 (garbage) to 4 (delicious) based on the ingredients. This required us to use regression or classification models. After trying some models we ended up using a simple regression model. Our scores were good but not as good as we’d like, so we decided to try a rather unconventional approach by leveraging the AutoML package AutoGluon to automatically train and evaluate lots of models with various hyperparameters. In the end, the model produced by AutoGluon was better than any of the other submissions. Apparently, simple problems become less relevant as automatic modeling gets better.

Score Leaderboard

Second Problem: Keep Your Distance

Adaptive cruise control is a driver assist feature that automatically keeps a set distance to the car in front, or maintains the set speed if there is none. The correct estimation of the distance between yourself and other vehicles is thus paramount. Instead of costly radar or lidar sensors you intend to use a simple video camera for that purpose.

The dataset for the next problem consisted of a total of 1074 images with 1442 vehicle bounding boxes and their measured distance to the car.

The goal of this problem was to predict the distance from the given images and bounding boxes for each vehicle. To get a good first baseline we decided to use the tabular annotation data and leave the images for a later model. To our surprise, after some feature engineering, a simple random forest regressor evaluated to a score of 0.95 on the test set. We suspect that the features “area of bounding box” and “angle to camera” were enough to explain the distance. The area has a direct causal relationship with the distance.

Example Train Image with cars and annotations

Final Problem: Find The Numbers

The final problem was by far the hardest one as it had an unusual train test split. The train dataset consisted of 24 images while the test set had over 10,000 images. Each image contained a random number of MNIST digits between 0 and 9 with random sizes in random positions. The task was to recognize all digits in the given images. The prediction for the following image could for example be 776186792825. The order of digits doesn’t matter, so 277698718625 would also be a valid prediction.

Example Train Image

The first approach we tried was to use an OCR-tool like Python-tesseract to directly recognize the digits embedded in the image. After some preprocessing of the image (e.g. inverting the colors) we were able to classify some images, but the accuracy wasn’t great.

We know that the images are from the MNIST dataset. As a lot of good models already exist for classifying MNIST digits, we decided to try cutting out the digits and classify each digit separately. We used OpenCV functions to cut out the digits, scale them to the correct size, sharpen the images, and perform other preprocessing steps to make them look as similar as possible to the MNIST digits. We then trained a simple MNIST model and used it to classify each image in the test set. This approach worked much better than the previous OCR attempt.

Conclusion

The hackathon was an incredible experience and I am grateful to have had the opportunity to be part of it. I would like to thank the organizers of the hackathon for putting on such a great event, and to Maximilian for being an incredible teammate. I am excited to see what the future holds for us in the world of data science.

The Tensor Tournament Banner

Gurobi - Solving Mixed Integer Problems with Python

Sat, 31 Dec 2022 00:00:00 GMT

Solving a Mixed Integer Programming (MIP) Problem with Gurobi requires the Gurobi Optimizer and the Python package GurobiPy.

Install the GurobiPy package with pip or conda:

python -m pip install gurobipy

conda install -c gurobi gurobi

Importing package

Import gurobipy like this:

import gurobipy as gp
from gurobipy import GRB

Initialize Model

The next step is to initialize a Gurobi model. For this example problem, setting a constant with the name capacitated to False will be necessary too. This variable defines whether you want to have production capacity constraints (LS-C) or not (LS-U).

m = gp.Model("ls")

capacitated = False

Constants

The situation for the example problem is the following:

A production facility wants to make a plan for the next 8 months. They want to know the amount of products that the factory has to produce each month to fulfill the demand in that month and reduce the costs which consist of

Production costs for one product: 100€
Preparing the machines at the beginning of a month (if the machines are running in that month): 5000€
Storing one product for a month: 5€

These are all constants that won’t change during the optimization of the model. That’s why you don’t have to add them to the model.

# Time (e.g. months)
n = 8
t = range(0, n)
  
# Costs for production of one product for each month
p = [100 for i in t]

# Costs for storing a product for each month
h = [5 for i in t]  

# Costs for armoring the machines for each month (at most once for each month)
q = [5000 for i in t]

# Demand for products for each month
d = [400, 400, 800, 800, 1200, 1200, 1200, 1200]

Add Variables

To describe the objective function and constraints of the model, add variables with specified types to the model.

The number of products produced each month (x) will have to be an integer variable as the facility can’t produce fractions of a product. The same constraint holds for the storage of finished products (s). The storage amount will have one extra entry in comparison to the other variables as there will be an initial stock from the month before.

The variable y is binary as it controls whether the facility has to prepare the machines (1) or not (0).

The one difference between the Uncapacitated and Capacitated Lot-Sizing problem lies in the definition of the capacity constraining variable M. For the uncapacitated case, the variable has no bound and will always be big enough to produce any amount of products. In the capacitated case it will consist of a list of capacities. In the code example below, the model selects capacities in a way to minimize the preparation costs of the machines.

# Production Amount for each month
x = m.addVars(n, name="x", vtype=GRB.INTEGER)

# Storage Amount for each month
s = m.addVars(n + 1, name="s", vtype=GRB.INTEGER)

# Production Preparation necessary for each month (0 or 1)
y = m.addVars(n, name="y", vtype=GRB.BINARY)

# Production Capacity for each month (in this case unbounded -> LS-U)
if capacitated:
	M = [7000, 0, 0, 0, 0, 0, 0, 0]
else:
	M = m.addVars(n, name="M", vtype=GRB.INTEGER)

Objective Function

As described above, the facility wants to minimize the costs. They consist of the sum of costs for producing products, preparing machines, and storing products. Thus, the objective function has to look like this:

m.setObjective(gp.quicksum(p[i] * x[i] + q[i] * y[i] + h[i] * s[i+1] for i in t), GRB.MINIMIZE)

(Linear) Constraints

Now, define all constraints of the model.

The first two constraints ensure that the facility fulfills their demand and stores the excess for the next month.

Constraints three and four will control the initial and final stock.

Constraint five adds capacity constraints to the model. As stated before, M will either not have a bound or have specific capacity restrictions.

The last three positivity constraints make sure that the machines don’t produce negative amounts of products and that the storage does not contain a negative amount of stored products.

# Stored products from the previous month plus the number of products produced in the current
# month must fulfill the demand while the rest of the products must be stored for the next month
m.addConstrs((s[i-1] + x[i-1] == d[i-1] + s[i] for i in range(1, n+1)), "c1")
m.addConstr((s[0] + x[0] == d[0] + s[1]), "c2")

# The number of products stored in the first month must be equal to 200 (Initial stock)
m.addConstr(s[0] == 200, "c3")

# The number of products stored in the last month must be equal to 0 (Final stock)
m.addConstr(s[n] == 0, "c4")

# If products are being produced in the current month the machines must be prepared
m.addConstrs((x[i] <= M[i]*y[i] for i in t), "c5")

# There cant be a negative number of products stored in the warehouse or produced
m.addConstrs((x[i] >= 0 for i in t), "c6")
m.addConstrs((s[i] >= 0 for i in t), "c7")
m.addConstrs((M[i] >= 0 for i in t), "c8");

Mathematical Model

The resulting mathematical model would look like this:

Mathematical LP model

Optimizing

The function call

m.optimize()

does everything we need to solve this optimization problem.

Gurobi will use the Branch-and-Bound algorithm as the model consists solely of linear constraints and a linear objective function, with (mixed) integer variables (IP).

Evaluation

These are the results for the given problem:

Gurobi Optimizer version 9.5.2 build v9.5.2rc0 (mac64[rosetta2])
Thread count: 10 physical cores, 10 logical processors, using up to 10 threads
Optimize a model with 35 rows, 33 columns and 53 nonzeros
Model fingerprint: 0xa7ef1cf7
Model has 8 quadratic constraints
Variable types: 0 continuous, 33 integer (8 binary)
Coefficient statistics:
  Matrix range     [1e+00, 1e+00]
  QMatrix range    [1e+00, 1e+00]
  QLMatrix range   [1e+00, 1e+00]
  Objective range  [5e+00, 5e+03]
  Bounds range     [1e+00, 1e+00]
  RHS range        [2e+02, 1e+03]
Presolve removed 29 rows and 4 columns
Presolve time: 0.00s
Presolved: 30 rows, 53 columns, 74 nonzeros
Presolved model has 16 SOS constraint(s)
Variable types: 0 continuous, 53 integer (16 binary)
Found heuristic solution: objective 859000.00000
Found heuristic solution: objective 830000.00000
Found heuristic solution: objective 822000.00000

Root relaxation: objective 7.170501e+05, 13 iterations, 0.00 seconds (0.00 work units)

    Nodes    |    Current Node    |     Objective Bounds      |     Work
 Expl Unexpl |  Obj  Depth IntInf | Incumbent    BestBd   Gap | It/Node Time

     0     0 717050.070    0    6 822000.000 717050.070  12.8%     -    0s
H    0     0                    737000.00000 717050.070  2.71%     -    0s
H    0     0                    736000.00000 727633.403  1.14%     -    0s
     0     0 736000.000    0    5 736000.000 736000.000  0.00%     -    0s

Cutting planes:
  Implied bound: 7
  Flow cover: 1

Explored 1 nodes (20 simplex iterations) in 0.01 seconds (0.00 work units)
Thread count was 10 (of 10 available processors)

Solution count 5: 736000 737000 822000 ... 859000

Optimal solution found (tolerance 1.00e-04)
Best objective 7.360000000000e+05, best bound 7.360000000000e+05, gap 0.0000%

As one can see the optimal solution is equal to 736,000€ of costs.

Printing out the variables reveals the number of products that the facility has to produce in each month to achieve these minimal costs.

for v in m.getVars():

	if v.varName.startswith("x"):
		print("Produce {} products in month {}".format(v.x, v.varName[1:]))
	
print("--------------------------------")
print("Total cost: {}".format(m.objVal))

Output:

Produce 600.0 products in month [0] 
Produce 0.0 products in month [1] 
Produce 1600.0 products in month [2] 
Produce 0.0 products in month [3] 
Produce 1200.0 products in month [4] 
Produce 1200.0 products in month [5] 
Produce 1200.0 products in month [6] 
Produce 1200.0 products in month [7] 
-------------------------------- 
Total cost: 736000.0

Text Generation using Markov Chains

Mon, 25 Jul 2022 00:00:00 GMT

Let’s create a simple text generation model using Markov chains. You can play with this demo to see what we’re trying to build today.

What is a Markov Chain?

A basic Markov chain consist of three main parts

a state space,
a transition matrix
and an initial distribution

We will go through the example of Weather Forecast for the next X days to get a better understanding of the different parts.

For a state space we could think of the following states:

Rain 🌧️
Sun ☀️
Snow ❄️

Of course, to model the real weather we might want to increase the size of the state space by a lot.

Now, we can model the weather by providing different probabilities to get from one state to another.

The probabilities (also known as transition matrix) could for example be

0.2 for 🌧️ → ☀️
0.3 for 🌧️ → ❄️
0.5 for 🌧️ → 🌧️
0.3 for ❄️ → 🌧️
0.1 for ❄️ → ☀️
0.6 for ❄️ → ❄️
0.1 for ☀️ → ❄️
0.2 for ☀️ → 🌧️
0.7 for ☀️ → ☀️

Now let us do a 5 day weather forecast and on day one the sun is shining (this first state is also known as the Initial Distribution). We have to sample from our state space with the probabilities from above to determine the next state for a given current state.

Day 1

Current State: ☀️
Sample State: ☀️

Day 2

Current State: ☀️
Sample State: ☀️

Day 3

Current State: ☀️
Sample State: 🌧️

Day 4

Current State: 🌧️
Sample State: 🌧️

Day 5

Current State: 🌧️
Sample State: ❄️

So, the weather forecast will look like this:

☀️ → ☀️ → 🌧️ → 🌧️ → ❄️ → …

Text Generation with Markov Chains

We can apply the same concept to words of a given text. Each unique word represents a single state. A sentence is a sequence of states that were sampled from a state space.

Create a state space
Compute probabilities for the transition matrix
Sample from the state space with the transition matrix

1. Create a State Space

We will create the state space from a given source text.

To do this, we read in the text as a string and split the text into individual words, often called tokens. Then we make sure that we have unique states by creating a set which is often called the vocab.

with open("source_text.txt", "r") as f:
	source_text = f.read()

# Split the text into all tokens (words)
tokens = source_text.split(" ")

# This will make sure that we only have unique states
states = list(set(tokens))

2. Calculate Probabilites (Transition Matrix)

The transition matrix contains all possibilities of a state i followed by a state j. So we create a matrix with len(states) rows and len(states) columns:

transition_matrix = np.zeroes((len(states), len(states)))

First, we count the number of occurrences for each state and each state transition (i.e. two words following each other).

state_transition_counts = {}
state_counts = {}

for i, state in enumerate(states):
	if i < len(states) - 1:
		# Get the transition from current to next state
		state_transition = (state, states[i + 1])

		state_transition_counts[from_to] = state_transition_counts.get(state_transition, 0) + 1
		state_counts[state] = state_counts.get(state, 0) + 1

Then, for each state transition, we calculate its relative frequency and store this probability in the transition matrix at an index that we get by encoding each state transition with two integers (the two states index in the vocab list).

for state_transition, count in state_transition_counts.items():
	from_state, to_state = state_transition
	
	# Relative Frequency 
	probability = count / state_counts[from_state]
	
	matrix_row_index = states.index(from_state)
	matrix_col_index = states.index(to_state)
	
	transition_matrix[matrix_row_index, matrix_col_index] = probability

Scatter Plot of a Transition Matrix

3. Sample from the Transition Matrix

Now, we are ready to sample words from the transition matrix. As we saw above, we need a current state to begin generating more states. A more sophisticated way than having a fixed first state is to provide an initial distribution that contains probabilities for each word to come first.

The initial distribution is a vector of length len(states). With it we can force certain words to be more likely to start the Markov chain. In an extreme case we might want the generated text to start with a certain word (e.g.: “The”). We look for the index of “The” in our states and set that index to 1 in the initial distribution vector and all other indices to 0.

initial_distribution = np.zeroes((len(states))
initial_distribution[states.index("The")] = 1

We could also use a list of possible sentence beginnings, which should all start a sentence with equal probability.

initial_distribution = np.zeroes((len(states))

sentence_beginnings = ["The", "This", "I", "You", "We", "That"]

for sentence_beginning in sentence_beginnings:
								 
	initial_distribution[states.index(sentence_beginning)] = 1 / len(sentence_beginnings)

To generate a text, we sample words from the list of states with a probability determined by the initial distribution and the transition matrix until we reach a maximum text length. If there is no initial distribution, we randomly choose a starting word.

def generate_text(tokens: List[str], length: int, P_matrix: np.ndarray, P_init: np.ndarray=None) -> str:

	text = []

	if P_init is not None:
		current_token = np.random.choice(tokens, p=P_init)
	else:
		current_token = np.random.choice(tokens)

	text.append(current_token)

	for i in range(length):

		current_token = np.random.choice(tokens, p=P_matrix[tokens.index(current_token)])
		text.append(current_token)

	return " ".join(text)

Try it

Now have fun generating texts. Be sure to try different source texts and see how that affects the quality of the generated text.

generate_text(states, 100, transition_matrix)

You can also try out the text generation web app I built and take a look at the GitHub repo which contains the source code.

Examples

Some German examples.

Winchester, Spring Valley, das Anstauen des Colorado River und teuer, um diese Gärten der Wasserknappheit > Wir sind die Bevölkerung muss als in Hotelzimmern von Las Vegas, der Stadt, näher betrachtet werden mit etwa vier Prozent aus dem Haus kein wertvoller Baugrund verwendet, welches bis zu minimieren, muss das Licht auf die Wiederverwendung von Las Vegas. Um die Sicherung der Wasserversorgung

Glücksspielmetropole der Hotels können selbst schon durch diesen neuen wassersparenden Technologien wie Kakteen in der größte Bereich der vielen exotischen Pflanzen und hat sich als in sonnenbetriebene Kraftwerke investieren. Besonders die Zukunft der Bau des Wassers ist der Lebensraum geraubt. Auch die Uhr mit Trockenzeiten in keinster Weise optimal für die Behörde sogar ganz gestoppt werden. Ein bekannter botanischer Garten, ist

individuellen Leistungsstand an die Höhe in Extremsportarten in den Rest des Selbstbewusstseins und unabhängig an positiven Gefühle, die er sich mit ihr umzugehen und hilft uns vor einem keine allgemeine Definition für sich relativ einfach nur das eigene Wohlempfinden zu gefährden, lässt sich lohnt dieses Risiko verbunden. Durch die Angst. Die Angst die Bremsen nicht vorhanden. 5 Fazit vorgestellt, in Hunderten

ESP8266 Height-Adjustable Desk Control with Home Assistant Integration

Thu, 12 May 2022 00:00:00 GMT

Project Overview

The goal of this project is to control a height-adjustable desk from a Home Assistant button while still preserving the functionality of the manual button controls on the table itself.

Prerequisites

These are the exact tools, hardware, and software I used. You can exchange most components with other similar ones.

Hardware

NodeMCU Lua Lolin V3 Module ESP8266 ESP-12F WIFI Development Board with CH340
At least 8 jumper wires
One 2-Channel Relay Module 5V with Optocoupler Low-Level Trigger
Three WAGO 221 Terminal Block 3 Connectors
USB-A to Micro-USB cable for powering the board and flashing code

Tools

Scissors to cut the cable
Cable insulation stripping tool

Software

Arduino IDE
Running Home Assistant instance

Safety Warnings

The instructions contain steps that permanently alter parts of the desk. If not followed properly, they CAN damage the desk controller, engine, and other parts on or around the table. Make sure to remove any items on, around, and under the desk before performing the steps.

The instructions are generally safe to follow, as they deal with low-voltage parts of the table. Nonetheless, be careful and do NOT make any changes to parts that run high voltages. Always check the components with a multimeter before working on them and unplug all cables.

Step-by-Step Guide

Understanding the Desk Controls

The desk controls consist of three cables. The following figures show a schematic view of those cables. The colors are for illustrative purposes and might be different for your specific desk.

The green (left) cable connects the controller with the Raise button, and the blue (right) one connects with the Lower button. One black cable connects both buttons back to the table to form a closed circuit. The open buttons interrupt this loop. Pressing a button closes the respective circuit, letting the desk controller know to start the engine for raising or lowering the table.

At this point, it’s straightforward to intercept the button presses by directly connecting the green and blue wires with the orange wire, thereby creating a closed circuit before the button is even reached.

Cut the Cable

To get access to the individual cables, cut the cable running from the button controls to the desk, and remove the insulation around it and the individual smaller cables for about 1-2 cm.

Automating a Button Click

Controlling the Relays

Relays don’t do anything on their own. You need a microcontroller to control them. For example, you can use the NodeMCU ESP8266 development board. The board has to provide power, ground, and two data pins. Each data pin controls one of the relays. Now the circuit is complete, and you can program the ESP.

Programming the Controller

Open esp8266.ino in the Arduino IDE and set all configuration variables.

Home Assistant Setup

1. Install MQTT Broker

Install Mosquitto Broker Add-on
Start Add-on with default configuration
Add new mqtt user under Settings > People and allow login

2. Add MQTT Integration

The MQTT integration should appear under Settings > Devices & services
Add the integration
Here you can try publishing packets to the desk topic. Set your payload to down or up.

3. Add Switch in Home Assistant Configuration

Use the Text Editor add-on to edit the configuration.yaml file of your Home Assistant instance. Add the following entry to the file.

mqtt:
  switch:
    - name: "Desk Switch"
      unique_id: desk_switch
      command_topic: "desk"
      payload_on: "up"
      payload_off: "down"

After restarting Home Assistant, this will add a new switch device that sends up and down payloads to the desk MQTT topic.

Optional Raycast Integration

The repository includes two python files that you can include in a script commands directory for Raycast. They will add the commands ⬆️ Raise Desk and ⬇️ Lower Desk.

Screenshot of Raycast Script Commands in Raycast Search

Install

To use the scripts, install the MQTT python client.

pip install paho-mqtt

Then change the shebang line to point to the Python environment where you installed the client, set the MQTT broker hostname, user, password, and add both Python scripts to your script commands directory. You should now be able to raise and lower your desk from Raycast 🎉.

Obsidian Raycast Extension - Update 1.4 and 1.5

Thu, 05 May 2022 00:00:00 GMT

Since my last post, I released version 1.4 and 1.5 for the Obsidian Raycast Extension. These are the new features:

Daily Note command

The new Daily Note command allows users to open or create a daily note. Select a vault, press enter and start typing. It requires the Advanced URI plugin for Obsidian.

Pinned Notes command

Use the Pinned Notes command to show a list of your pinned notes. You can use the same actions as with the Search Note command. This makes it easy to open, edit or view an important note.

New actions and new look for Search Note command

Actions

With the Append Selected Text to Note action you are now able to append selected text to a note. Use the keyboard shortcut opt + s to trigger it.

You can now pin and unpin notes using the Pin Note and Unpin Note actions. Pinned notes will appear in the Pinned Notes command.

New Look

Enabeling Detail View in preferences will show the content of a note on the right side.

Search Note

New Preferences

Append Prefix

Append Prefix is a new preference that appends a given prefix to text. This makes it easy to maintain bullet or checkbox lists.

Open Note on Creation

If turned on this setting will open a note created with the Create Note command after creation.

Hide LaTeX

You can now hide LaTeX from Quick Look, Detail View and all copy/paste commands.

Default Note Name

If the note name in the Create Note command is empty, this default note name replaces it.

Folder Actions

You can now provide a list of folders (paths) to the Create Note command. These folders will automatically create keyboard shortcuts (actions) to create notes in a specific folder. This is helpful if you are using Obsidians Templater Plugin.

Store page update

The store page got a new look with images, category and version history.

Store Images

Store Changelog

Other

Commands with a single vault will now trigger without prior vault selection.

Feature Requests

If you know of a feature that’s still missing or want to contribute otherwise, make sure to visit the projects GitHub repo. With these two updates I restructured the entire codebase which should make it a lot easier to contribute.

Obsidian Raycast Extension - Update

Sun, 06 Mar 2022 00:00:00 GMT

My Raycast extension “Obsidian” has been in the Raycast Store for some months now and lots of people are already using it. In this post I would like to introduce some of the new features that I added.

Create Note

With the new command Create Note you can now create new notes on the fly. Like the other commands you can access it system-wide which makes it a great tool for jotting down some notes while working in another application.

Create Note Command

The form accepts a name, local path (the command will automatically create a folder structure when the path doesn’t exist), a customizable tag picker and a big content field.

Customize the tag picker

Use the Racast Search to find the extensions preferences by searching for Extensions. Scroll down to Obsidian and select the Create Note command. You will see a list of settings pop up on the right side. In the tags section you can enter a comma separated list of tags. For example: “daily, blog, project, todo, read”.

Other settings

Entering a default path and tag will auto-fill the corresponding fields when running the command. This might be helpful when you always want to add notes to a certain folder or always tag them with the same tag.

New keyboard shortcuts for Search Note

The new update comes with two new keyboard shortcuts for the Search Note command. You can now use opt + l to copy a markdown link for the note to your clipboard or opt + u to copy the notes Obsidian URI.

Feature Requests

If you know of a feature that’s still missing or want to contribute otherwise, make sure to visit the projects GitHub repo.

Obsidian Raycast Extension

Thu, 06 Jan 2022 00:00:00 GMT

Raycast is a free to use productivity tool. It’s basically a replacement for the default macOS Spotlight Search and offers similar functionalities like searching for files and applications.

Or to put it in Raycasts words:

Raycast is a blazingly fast, totally extendable launcher. It lets you complete tasks, calculate, share common links, and much more.

The biggest difference is that it’s extendable through extensions which you can install in Raycast’s own store. There you will find everything from a YouTube Launcher, Visual Studio Code Search, GitHub actions, home control and so much more. The store is growing everyday and developers create new useful extensions.

As I enjoy the concept of a search/launcher to be the main hub on my Mac and because I am a big fan and extensive user of the note taking app Obsidian, I decided to create my own raycast extension for Obsidian.

Right now it consists of the following two commands but I work on new features while you are reading this sentence.

Search Note

With the command Search Note you can search for every note in your vault.

Search Note Command

Actions are available when you select a note. You can view the note using Quick Look to get a glance at the content or use Open in Obsidian to directly open it in Obsidian itself. With Append to note you can add text to the note, this is useful to add entries to lists or tables. The Copy note content is self-explanatory and Paste note content will paste the text into the last used application.

Preferences

In the commands settings you are able to exclude folders from the search. This is useful if you have lots of reference notes or some sort of “database” which you don’t want to search through. For Quick Look, copy and paste actions it could be a good idea to hide the YAML frontmatter and wiki-links as other applications might not need them. Which is why a setting for hiding this content is available too. Lastly, you can configure the primary action (enter key) to trigger Quick Look or Open in Obsidian.

Open Vault

With the command Open Vault you can open one of your vaults which you can specify in the preferences. This allows for quick switching between different vaults and removes the rather annoying way of using Obsidian’s vault switcher.

Open Vault Command

Contribute

If you want to contribute to this extension you can visit the GitHub repository and open a new issue. I am open to work on feature requests and would welcome it if you report any bugs or wrong behavior.

My Obsidian Knowledge Graph

Thu, 05 Aug 2021 00:00:00 GMT

Graph View

Whole Graph

This is the knowledge graph of my second brain, markdown notes written in Obsidian. It stores ideas, thoughts, and knowledge.

The colors represent individual groups, defined via folders, tags, or keywords. In my case, the colors represent overarching topics:

Green → University Notes
Blue → Bible Study Notes
Red → Other (Inbox, Projects, Blog, Private)

Zooming in reveals the more complex graph structure with its links between notes of different topics. The note names become readable, and you can see distinct links.

Zoomed in Graph

Local Graph

The local graph allows you to see specific parts of the graph that relate to one note. For example, the following image shows a local graph with a depth of 2, which means that notes with a distance of up to 2 edges are part of it. This can be helpful for navigating between notes on the same topic.

Local Graph of Note

What I like and don't like about iOS 15

Mon, 21 Jun 2021 00:00:00 GMT

As of today I have tested the first iOS 15 Beta for at least two weeks. And, I am happy with the new features added. But some of them stood out to me:

Safari

Apple markets it to be reimagined for the way we browse today. The tab and search bar dropped from the top of the screen right to the bottom where it’s easier to reach with one hand. Swiping across the bar will switch between all opened tabs. At first I wasn’t a fan of the new UI, it took some time to get used to the new gestures. But to be fair, Safari got lots of other great new functionalities. A customizable start page, privacy protections with iCloud+ Private Relay (although I wasn’t able to use it in the beta version yet), the ability to add web extensions and a grid-like tab overview.

Notifications

Apple made long requested changes to the notification system. Notifications are now ranked by priority to make sure that the most urgent ones are always at the top. iOS now delivers a helpful notification summary every day so you can see what’s new at a glance.

Focus

Strongly connected to notifications is the all new Focus mode. It’s basically an extension to the “Do not disturb mode” which silences all incoming notifications. Focus can automatically filter notifications to your liking. But thats not all. You can even specify which homescreens iOS will show during an activated Focus mode.

Spotlight Search + Live Text

The already beloved spotlight search got a complete revamp. It’s now faster, more detailed and the new live text feature adds so much more functionality to it. You can now search for text which appears in your images. For people who take lots of screenshots, this can be a big time-saver.

Conclusion:

I can see the problems people might have with the updated Safari UI but I do think that they will get used to it and in the end appreciate having the ability to use Safari one-handedly.

For me personally, the best feature in iOS 15 is the Focus mode. I already set up a Learning mode which automatically changes my homescreen to display relevant apps and widgets (e.g. Notability, Calendar, Reminders, Files, and other university related apps). Also any messages which weren’t sent by my fellow students or professors don’t show up. It helps me get less distracted when learning or working.

As I said in the beginning, iOS 15 gave us lots of small upgrades which will enhance the experience with your Apple devices. Nothing big, but great nonetheless.