link-to-remote.el When you’re sharing code and documentation with teammates, it can be slow to page over to your forge and navigate to the file you want and select a link. To solve this, I’m sharing link-to-remote.el, an Emacs package that creates shareable links to your current file in its remote repository. It offers branch selection via completing-read and provides multiple actions through a transient menu.
You can install link-to-remote.el using straight.el:
(use-package link-to-remote
:straight (:host github :repo "jsigman/link-to-remote.el")
:bind ("C-c l" . link-to-remote))
unison-sync-mode Working across multiple machines often means juggling file versions. To solve this, I’m sharing unison-sync-mode, an Emacs package that integrates Unison file synchronization directly into your workflow. It automatically syncs files on save, supports excluding specific patterns, and even offers one-way sync options.
You can install unison-sync-mode using straight.el:
(straight-use-package
'(unison-sync-mode :type git :host github :repo "jsigman/unison-sync-mode"))
Check out the GitHub repository for more details on configuration and usage. I’m excited to see how this tool evolves and welcome any feedback or contributions from the Emacs community.
]]>This is also a live test of some tweaking I’ve been doing to my tweaks to Org-Jekyll-Lite in order to run code and \(\LaTeX\) in Org documents and export it to web page.
Since elements of the group \( \text{SU}(2) \) are isomorphic to the unit quaternions, \(\mathbb{H}\), we will draw a unit quaternion and map it onto the matrix representation of SU(2).
import numpy as np
def random_quaternion() -> np.ndarray:
u1, u2, u3 = np.random.random(3)
q0 = np.sqrt(1 - u1) * np.sin(2 * np.pi * u2)
q1 = np.sqrt(1 - u1) * np.cos(2 * np.pi * u2)
q2 = np.sqrt(u1) * np.sin(2 * np.pi * u3)
q3 = np.sqrt(u1) * np.cos(2 * np.pi * u3)
return np.array([q0, q1, q2, q3])
The general form of the \( \text{SU}(2) \) matrix for a quaternion \( (q_0, q_1, q_2, q_3) \) is given by:
\( \begin{bmatrix} q_0 + iq_3 & q_2 + iq_1 \ -q_2 + iq_1 & q_0 - iq_3 \end{bmatrix} \)
def quaternion_to_su2(quaternion: np.ndarray) -> np.ndarray:
# Convert a quaternion into its SU(2) matrix representation.
q0, q1, q2, q3 = quaternion
return np.array([[q0 + 1j*q3, q2 + 1j*q1],
[-q2 + 1j*q1, q0 - 1j*q3]])
def draw_random_su2() -> np.ndarray:
return quaternion_to_su2(random_quaternion())
import pandas as pd
pd.DataFrame(quaternion_to_su2(random_quaternion()))
| 0 | 1 | |
|---|---|---|
| 0 | -0.706679+0.640604j | 0.141797+0.264810j |
| 1 | -0.141797+0.264810j | -0.706679-0.640604j |
pd.DataFrame(quaternion_to_su2(random_quaternion()))
| 0 | 1 | |
|---|---|---|
| 0 | 0.020562+0.599385j | -0.636772+0.484599j |
| 1 | 0.636772+0.484599j | 0.020562-0.599385j |
\( \text{SO}(3) \) matrices are 3x3 orthogonal matrices with determinant 1. They represent rotations in 3D space.
def quaternion_to_so3(quat: np.ndarray) -> np.ndarray:
w, x, y, z = quat
return np.array([
[1 - 2*y**2 - 2*z**2, 2*x*y - 2*z*w, 2*x*z + 2*y*w],
[2*x*y + 2*z*w, 1 - 2*x**2 - 2*z**2, 2*y*z - 2*x*w],
[2*x*z - 2*y*w, 2*y*z + 2*x*w, 1 - 2*x**2 - 2*y**2]
])
def draw_random_so3() -> np.ndarray:
quat = random_quaternion()
return quaternion_to_so3(quat)
pd.DataFrame(draw_random_so3())
| 0 | 1 | 2 | |
|---|---|---|---|
| 0 | -0.387516 | -0.605739 | -0.694918 |
| 1 | 0.468365 | 0.519912 | -0.714371 |
| 2 | 0.794019 | -0.602305 | 0.082233 |
pd.DataFrame(draw_random_so3())
| 0 | 1 | 2 | |
|---|---|---|---|
| 0 | -0.965783 | -0.034937 | -0.256986 |
| 1 | -0.036723 | 0.999323 | 0.002155 |
| 2 | 0.256737 | 0.011518 | -0.966413 |
from numpy.linalg import eigvals
su2_eigs =np.array([eigvals(draw_random_su2()) for _ in range(10)])
pd.DataFrame(su2_eigs)
| 0 | 1 | |
|---|---|---|
| 0 | -0.206546+0.978437j | -0.206546-0.978437j |
| 1 | -0.388936+0.921265j | -0.388936-0.921265j |
| 2 | 0.024305-0.999705j | 0.024305+0.999705j |
| 3 | 0.025415+0.999677j | 0.025415-0.999677j |
| 4 | -0.629142-0.777290j | -0.629142+0.777290j |
| 5 | 0.483896-0.875125j | 0.483896+0.875125j |
| 6 | -0.498570+0.866850j | -0.498570-0.866850j |
| 7 | -0.136583+0.990629j | -0.136583-0.990629j |
| 8 | -0.331002+0.943630j | -0.331002-0.943630j |
| 9 | -0.224566+0.974459j | -0.224566-0.974459j |
So the eigenvalues of \( \text{SU}(2) \) matrices are always complex conjugates of each other, and lie on the unit circle.
import pandas as pd
import numpy as np
pd.DataFrame(np.abs(su2_eigs[:5]))
| 0 | 1 | |
|---|---|---|
| 0 | 1.0 | 1.0 |
| 1 | 1.0 | 1.0 |
| 2 | 1.0 | 1.0 |
| 3 | 1.0 | 1.0 |
| 4 | 1.0 | 1.0 |
from numpy.linalg import eigvals
so3_eigs = np.array([eigvals(draw_random_so3()) for _ in range(10)])
pd.DataFrame(so3_eigs)
| 0 | 1 | 2 | |
|---|---|---|---|
| 0 | -0.368758+0.929525j | -0.368758-0.929525j | 1.000000+0.000000j |
| 1 | -0.197081+0.980387j | -0.197081-0.980387j | 1.000000+0.000000j |
| 2 | 0.436682+0.899616j | 0.436682-0.899616j | 1.000000+0.000000j |
| 3 | 1.000000+0.000000j | -0.935815+0.352491j | -0.935815-0.352491j |
| 4 | -0.318919+0.947782j | -0.318919-0.947782j | 1.000000+0.000000j |
| 5 | -0.739021+0.673682j | -0.739021-0.673682j | 1.000000+0.000000j |
| 6 | 1.000000+0.000000j | -0.997412+0.071897j | -0.997412-0.071897j |
| 7 | 1.000000+0.000000j | -0.019389+0.999812j | -0.019389-0.999812j |
| 8 | -0.816935+0.576729j | -0.816935-0.576729j | 1.000000+0.000000j |
| 9 | 1.000000+0.000000j | -0.692390+0.721524j | -0.692390-0.721524j |
Two of the eigenvalues of \( \text{SO}(3) \) matrices are also always complex conjugates of each other, with the other unity.
import numpy as np
np.abs(pd.DataFrame(so3_eigs[:5]))
| 0 | 1 | 2 | |
|---|---|---|---|
| 0 | 1.0 | 1.0 | 1.0 |
| 1 | 1.0 | 1.0 | 1.0 |
| 2 | 1.0 | 1.0 | 1.0 |
| 3 | 1.0 | 1.0 | 1.0 |
| 4 | 1.0 | 1.0 | 1.0 |
Also, the eigenvalues of \( \text{SO}(3) \) also lie on the unit circle. So far, though, I have not yet seen how \( \text{SU}(2) \) is a covers \( \text{SO}(3) \) doubly.
\( \text{SU}(2) \) matrices have determinant 1 by definition (“Special”). \( \text{SO}(3) \) matrices also have determinant 1 by definition (“Orthogonal”). So this is not a good way to distinguish between the two groups.
pd.DataFrame({"SU2":np.linalg.det([draw_random_su2() for _ in range(5)]), "SO3":np.linalg.det([draw_random_so3() for _ in range(5)])})
| SU2 | SO3 | |
|---|---|---|
| 0 | 1.0+0.0j | 1.0 |
| 1 | 1.0+0.0j | 1.0 |
| 2 | 1.0+0.0j | 1.0 |
| 3 | 1.0+0.0j | 1.0 |
| 4 | 1.0-0.0j | 1.0 |
I wrote this short essay when I was a postdoc. I started writing it to convince myself that I could interpret softmax scores as probabilities, and not just scores. I hope you find it as useful as I did thinking through it.
Suppose we possess data and labels, \(\{(x^{(1)},c^{(1)}),…,(x^{(m)},c^{(m)})\}\), collected from the joint distribution \((x,c) \sim p(x,c)\), with only two possible classes: \(c \in \{A,B\}\).
The loss function for a binary classifier \(f_{\theta}(x)=p(A \mid x)\) is given by the well-known1:
But where does these expressions come from? It is visible upon inspection that minimizing Equation 1 will yield an effective classifier. If the neural network \(f_\theta\) is terminated with a sigmoid function2, then examples of class \(A\) will push \(f_\theta(x)\) towards 1 for their values of \(x\), and examples of class \(B\) will be driven toward 0.
However, this observation is not enough to say with confidence that the output of the classifier is a good approximation of the conditional probability of the class label, \(P(c \mid x)\).
To build such a classifier, we will minimize the KL divergence between our target distribution for a binary classifier, \(P(c \mid x)\), and our model distribution parameterized by \(\theta\), \(f_\theta(c,x)\).
For the sake of clarity, while in Equation 1, we used \(f_\theta(x)\) to denote our classifier, here we indicate matching the distribution over all the classes \(\{A,B\}\), and so will use \(f_\theta(c,x)\) instead. There is no real need for the argument \(c\), since we are only interested in the single output \(f_\theta(A,x) = P(A \mid x) = 1 - P(B \mid x)\), and we will make this substitution later to simplify the derived loss.
The KL divergence of conditional distributions is the expectation of the distribution of KL divergences taken over each conditional variable:
And to motivate choice of parameters:
Taking an expectation over \(p(x)\) and then \(P(c \mid x)\) is the same as drawing samples from and calculating an expectation over samples from the joint distribution, so we can write:
And after dropping terms not involving \(\theta\):
Interestingly enough, at this point, minimizing the KL divergence statement of Equation 2 in order to produce \(P(c \mid x)\) looks as if we were trying to match the joint distribution \(p(c,x)\), because we’ve dropped any terms indicating conditional probability. It must be, therefore, that some feature in the architecture of \(f_{\theta}\) is the reason we say it mimics the conditional distribution, and not the joint.
By the law of large numbers, we can estimate the expectation in Equation 3 by summing over samples:
where \(\sum_A, \sum_B\) indicate taking the sum using examples of classes \(A\) and \(B\), and \(N_A\) and \(N_B\) are the number of samples of each class. If there are equal number of samples of each class \(N_A=N_B\), so the prior \(P( c) = P(A) = P(B) = .5\), as we do in GAN:
Choice of architecture allows us to say \(f_{\theta}\) approximates \(P(c \mid x)\), not objective function. Here, we choose \(f_{\theta}\) to be a legitimate probability distribution over class labels \(c\) by defining \(f_{\theta}(A,x) = 1 - f_{\theta}(B,x)\), and for simplicity, write \(f_{\theta}(A,x)\) as \(f_{\theta}(x)\). If we choose \(f_{\theta}\) so its output is between 0 and 1, by use of a sigmoid activation function, then we can learn a valid approximator for the conditional probability function \(P(c \mid x)\) by minimizing:
This is the same as the discriminator network of a GAN, whose loss function is given: \(\mathcal{L}(\psi)=-\mathbb{E}_{p(z)}\log\sigma(g_{\psi}(f_\theta(z))) - \mathbb{E}_{q(x)}\log[1 - \sigma(g_{\psi}(x))]\) ↩
Without loss of generality, we can consider binary classifiers of one channel terminated by sigmoid instead of softmax. ↩
My literate elisp webpage has a problem. It does not tell the reader what source code is loaded at startup, and what source code is vestigial, and only there to remind me that I configured a package but didn’t like it. I’d like the webpage to show this to the user.
I solved this by dynamically converting emacs-lisp blocks to plaintext blocks at org-export time. This way, the emacs lisp code will look like:
(print "This code will not be run!")
if it is skipped, and
(print "This code is run in my config!")
if it is loaded by the literate-elisp library.
Replacing header blocks that look like #+begin_src emacs-lisp :load no with header blocks that look like #+begin_src plaintext will achieve this in the rouge syntax highlighting system. I can do this (somewhat) hackily with some very simple regular expressions over the pure org source before export.
(defun my/org-export-filter-src-blocks (backend)
(when (eq backend 'jekyll)
(goto-char (point-min))
(while (re-search-forward "^#\\+begin_src\\s-+emacs-lisp\\(.*:load\\s-+no.*\\)$" nil t)
(replace-match "#+begin_src plaintext"))))
(add-hook 'org-export-before-processing-hook 'my/org-export-filter-src-blocks)
See where the code is run in the workflow code for automated export of the tangled config.
]]>I want to host the PDF of my CV on this site. I want it to link to the latest compiled version from where it’s tracked on github (private repo).
I linked to a public shared folder on my Dropbox. This meant that every time I update the CV locally, I have to upload the new version to github.
First, I created a new github action to build the PDF of the CV from .tex like this (only the jobs section necessary to show here):
jobs:
publish:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Compile
uses: xu-cheng/latex-action@v2
with:
working-directory: "CV"
root_file: |
John_Brevard_Sigman_CV.tex
pre_compile: |
make build-bib
- name: Create Release
uses: softprops/action-gh-release@v1
with:
tag_name: latest
files: John_Brevard_Sigman_CV.pdf
- name: Clear old releases
uses: dev-drprasad/delete-older-releases@v0.2.1
with:
keep_latest: 1
env:
GITHUB_TOKEN: $
- name: Close
run: exit 0
I use xu-cheng/latex-action@v2 to compile to PDF, preceded by running build-bib from the make target (see below):
build-bib:
latex John_Brevard_Sigman_CV.tex
latex John_Brevard_Sigman_CV.tex
bibtex John_Brevard_Sigman_CV1-blx
bibtex John_Brevard_Sigman_CV2-blx
bibtex John_Brevard_Sigman_CV3-blx
The three calls to bibtex are to compile separate bibliographies papers.bib, patents.bib, and government_reports.bib from the auxiliary files *CV[X]-blx. These files were generated by the two calls to latex.
I next modified the deployment action for this github pages website so that it would fetch the latest release of the CV repo.
First, make a personal access token with fine-grained read-only permission to the CV repo. Then, upload this as an encrypted secret (CV_ACCESS_TOKEN) of the website repo.
- name: Get latest CV release
uses: robinraju/release-downloader@v1.8
with:
repository: "jsigman/CV"
latest: true
fileName: "John_Brevard_Sigman_CV.pdf"
out-file-path: "assets/pdf/"
token: ${{ secrets.CV_ACCESS_TOKEN }}
I use robinraju/release-downloader@v1.8 fetch the latest release, and it’s ready to be shared on the website. This setup is clean and hands off!
]]>With unclear readership, I’m starting my tech blog about emacs, python, and machine learning. I hope that others enjoy my tips and perspective, but I’m mostly excited to gain some skills around web technologies and social media (not the instagram kind).
For a few years, I’ve been sharing my emacs configuration on github. I make this public, but its real use is that I can clone and track this across different machines. Less than a year ago, I migrated to literate elisp so that I could weave comments in with the lisp code. Who doesn’t love an excuse to learn org mode a little better?
Most recently, I played with github actions to release a tangled version of the entire configuration code, and I share it on this website as a project. Take a look, there are about 10 years of tinkering in that one document. Tinkering from grad school, through a postdoc, and continued as a professional.