Pratik Ingle https://pratik-ingle.github.io/blog.html Research explanations, learning notes, and tutorials. quarto-1.0.37 Tue, 28 Jul 2026 22:00:00 GMT Simulating a Tactile Sensor in MuJoCo https://pratik-ingle.github.io/posts/learning/mujoco-tactile-sensor-simulation/index.html One part of my UCL visit is about replicating a 3-channel tactile sensor in MuJoCo for data collection and training. The goal is not to build a perfect copy of the real sensor. The goal is to create a simulation that produces useful tactile structure for learning.

What needs to be simulated

A useful tactile simulation needs at least:

  • Contact location across the sensor surface.
  • Normal force at contact points.
  • Shear forces in two lateral directions.
  • Temporal changes as objects move, slip, or press into the surface.

The difficult part is matching the signal statistics closely enough that models trained on simulation learn transferable structure.

The modeling tradeoff

A high-fidelity tactile simulation can become expensive quickly. But a very simple proxy may miss the contact cues needed for downstream tasks. The practical question is where the approximation should live.

For representation learning, it may be enough for the simulation to capture the relationships between contact, shape, and force dynamics, even if every taxel is not physically perfect.

Data collection loop

The imagined loop is:

  1. Sample objects, poses, and interactions in simulation.
  2. Record normal and shear force maps over time.
  3. Train MAE/JEPA-style models on the generated tactile streams.
  4. Test whether the learned representation transfers to real tactile data.

Open questions

  • Which contact model best matches the real sensor behavior?
  • How much domain randomization is useful?
  • Should the network see raw forces or preprocessed tactile maps?
  • What downstream task best measures whether the simulation is good enough?
]]> learning simulation tactile sensing MuJoCo https://pratik-ingle.github.io/posts/learning/mujoco-tactile-sensor-simulation/index.html Tue, 28 Jul 2026 22:00:00 GMT Normal and Shear Forces in Tactile Sensing https://pratik-ingle.github.io/posts/learning/tactile-sensing-normal-shear/index.html Touch is not just pressure. A tactile sensor can measure how hard an object presses into the surface, but also how contact moves sideways. That sideways information is often the clue that an object is slipping, rotating, or changing contact state.

Three channels

The tactile setup I am learning from uses three force channels:

  1. Normal force: how strongly the object presses into the sensor.
  2. Shear-x: lateral force along one sensor axis.
  3. Shear-y: lateral force along the other sensor axis.

Together, these channels describe richer contact mechanics than normal force alone.

Why shear matters

If the normal force stays similar but shear changes, the object may be sliding or rotating. For in-hand manipulation, that can reveal object pose changes before the object visually moves in an obvious way.

This is especially relevant for shape and quantity inference. A pile of objects, a single larger object, and an object contacting at a different angle can produce different shear patterns even when the normal force magnitude is comparable.

What I want from representations

The representation should make contact events legible. It should capture where contact occurs, how force flows across the sensor, and how those patterns evolve over time.

That is why tactile sensing is a good fit for self-supervised learning: the raw signal is rich, but the useful abstractions are not always obvious in advance.

]]> learning tactile sensing robotics https://pratik-ingle.github.io/posts/learning/tactile-sensing-normal-shear/index.html Tue, 21 Jul 2026 22:00:00 GMT MAE vs JEPA: Two Ways to Learn Representations Without Labels https://pratik-ingle.github.io/posts/learning/mae-vs-jepa/index.html I am using this post as a working note while learning self-supervised learning for tactile sensing. The two families I keep comparing are Masked Autoencoders (MAE) and Joint Embedding Predictive Architectures (JEPA).

The shared goal

Both methods try to learn useful representations without requiring manual labels. Instead of asking a model to predict a human-provided class, we create a prediction problem from the data itself.

For tactile sensing, this is appealing because labeled tactile data can be expensive. But the robot can collect lots of interaction data: normal forces, shear forces, contact patches, and temporal sequences.

MAE intuition

A Masked Autoencoder hides part of the input and trains the model to reconstruct what was removed. In vision, that means masking image patches. In tactile sensing, a similar idea could mask spatial taxels, temporal spans, or force channels.

The reconstruction target keeps the training signal concrete: the model must recover missing data.

JEPA intuition

JEPA also predicts missing information, but it predicts in representation space rather than directly reconstructing pixels or sensor values. The model learns an embedding of visible context and predicts the embedding of the target.

This can encourage more semantic or task-useful representations because the model is not forced to reproduce every low-level detail.

The question I care about

For tactile sensing, the right representation should preserve object-relevant properties: shape, contact distribution, slip, force direction, and possibly object count. I want to understand whether direct reconstruction or representation-space prediction gives better features for downstream inference.

Open notes

  • What should be masked: time, taxels, force channels, or spatial regions?
  • Should shear and normal channels be treated symmetrically?
  • How much of the tactile signal is useful low-level detail versus nuisance variation?
  • Which downstream probe best reveals representation quality?
]]> learning self-supervised learning representation learning https://pratik-ingle.github.io/posts/learning/mae-vs-jepa/index.html Tue, 14 Jul 2026 22:00:00 GMT Variational Quantum Eigensolver From Scratch https://pratik-ingle.github.io/posts/quantum/vqe-from-scratch/index.html VQE stands for Variational Quantum Eigensolver. It is a hybrid quantum-classical algorithm for estimating the lowest-energy eigenstate, or ground state, of a Hamiltonian.

This is a migrated and lightly cleaned version of my original Medium post.

Original post: https://medium.com/analytics-vidhya/variational-quantum-eigensolver-from-scratch-finding-ground-state-energy-of-hamiltonian-a5c13d5268f1

Variational Principle

If we have a Hamiltonian H with eigenstates and associated eigenvalues, then:

H |psi> = lambda |psi>

Here lambda is the energy for the state |psi>. For many possible states there are different energies, but one state has the smallest energy. That state is the ground state of the system. VQE gives us a practical way to search for that ground state.

The algorithm can be summarized in three parts:

  1. Decomposition.
  2. Circuit construction, including the ansatz and measurement basis.
  3. Measurement and classical optimization.

Part 1: Decomposition

The first step is decomposing a Hamiltonian into Pauli matrices. Pauli matrices form a basis for the real vector space of 2 x 2 Hermitian matrices. That means any 2 x 2 Hermitian matrix can be written as a unique linear combination of Pauli matrices with real coefficients.

For a two-qubit Hamiltonian, we work with 4 x 4 Hermitian matrices and tensor products of Pauli terms. These terms tell us which basis to measure in, and their coefficients tell us how much weight each expectation value should receive in the final energy estimate.

For example, a decomposed two-qubit Hamiltonian may include terms such as:

  • I tensor I
  • X tensor X
  • Y tensor Y
  • Z tensor Z

Each term receives a coefficient from the decomposition.

Part 2: Circuit

Once the Hamiltonian is decomposed, we create circuits for the terms in the decomposition. The circuit has two central pieces.

Ansatz

The ansatz is a parameterized circuit that prepares the trial quantum state. In a VQE loop, the classical optimizer changes the ansatz parameters and the quantum circuit estimates the corresponding energy.

In the original experiment, the ansatz was chosen by trial and error. Different ansatz choices can produce similar performance, but the ansatz controls the set of states the algorithm can search.

Measurement basis

Quantum computers measure in the computational, or Z, basis by default. If we need expectation values in another basis, we rotate the state before measurement.

For a Hamiltonian with terms like:

  • I tensor I
  • X tensor X
  • Y tensor Y
  • Z tensor Z

the identity term does not need a circuit. The X tensor X term can be measured by rotating both qubits into the X basis. The Y tensor Y term can be measured by rotating both qubits into the Y basis. The Z tensor Z term can be measured directly after preparing the ansatz.

Part 3: Measurement

For each circuit, we measure probabilities for outcomes such as |00>, |01>, |10>, and |11>.

For a single qubit, measuring |0> corresponds to eigenvalue +1, and measuring |1> corresponds to eigenvalue -1. For two qubits, the sign for a measurement is the product of the two eigenvalues. For example, |01> gives:

(+1) x (-1) = -1

The expectation value is computed as:

sum(sign * probability)

After computing the expectation value for each circuit, we multiply by the corresponding Hamiltonian coefficient and add the terms together. That gives the current energy estimate.

VQE Algorithm

The VQE loop is:

  1. Pick ansatz parameters.
  2. Prepare the ansatz state on the quantum circuit.
  3. Measure each Hamiltonian term in the correct basis.
  4. Estimate the energy from expectation values.
  5. Use a classical optimizer to update the ansatz parameters.
  6. Repeat until the energy stops improving.

In the example from the original post, the lowest eigenvalue found was -1, corresponding to the ground-state estimate for the chosen Hamiltonian.

End Note

The most important thing I learned from coding VQE from scratch is that the quantum and classical pieces are tightly coupled. The quantum circuit gives noisy energy estimates; the classical optimizer decides where to search next. The ansatz sits between them and determines which states are reachable.

Why VQE is interesting

VQE is designed for near-term quantum computers because it keeps the quantum circuit relatively shallow and uses a classical optimizer for the outer loop. That makes it a useful algorithm to study when learning hybrid quantum-classical machine learning.

Resources

]]> quantum tutorial VQE https://pratik-ingle.github.io/posts/quantum/vqe-from-scratch/index.html Wed, 01 Dec 2021 23:00:00 GMT Getting Started With Webots https://pratik-ingle.github.io/posts/tutorials/getting-started-with-webots/index.html Webots is a simulation software package for rapidly prototyping mobile robots and autonomous systems. It provides a 3D physics-based environment with support for sensors, controllers, data visualization, and robot models.

What can Webots be used for?

  • Mobile robot prototyping for academic research and industry.
  • Robot locomotion research, including legged robots.
  • Multi-agent and swarm robotics.
  • Adaptive behavior experiments such as genetic algorithms.
  • Teaching robotics and running robot contests.

What you should know first

You can use Webots with C, C++, Java, Python, or MATLAB. If you want to create custom robot models or environments, it also helps to know some 3D graphics concepts and the VRML97 descriptive language.

A Webots simulation typically includes:

  1. A world file (.wbt) that defines robots and the environment.
  2. Controller programs that run the robot logic.
  3. Optional physics plugins for custom physics behavior.

Create the first project

Open Webots and go to Wizards > New Project Directory. Name the project bug, name the world file bug.wbt, and select the options to add a rectangular arena.

Before adding a robot, change the arena size from 1 x 1 m to 2 x 2 m by editing RectangleArena > floorSize.

Add an e-puck robot

Click Add in the scene tree, then choose PROTO nodes > robots > gctronic > e-puck > E-puck. The robot should appear in the arena. Save the world before running the simulation.

The e-puck has a default obstacle avoidance controller, so you can run the simulation immediately to see the robot move.

Create a simple controller

Go to Wizards > New Robot Controller, choose Python, and name the controller move_forward.

"""move_forward controller."""
from controller import Robot

robot = Robot()
time_step = 32
max_speed = 6.24

left_motor = robot.getMotor("left wheel motor")
right_motor = robot.getMotor("right wheel motor")

left_motor.setPosition(float("inf"))
right_motor.setPosition(float("inf"))
left_motor.setVelocity(0.0)
right_motor.setVelocity(0.0)

while robot.step(time_step) != -1:
    left_speed = max_speed * 0.5
    right_speed = max_speed * 0.25

    left_motor.setVelocity(left_speed)
    right_motor.setVelocity(right_speed)

Set the e-puck controller to move_forward and run the simulation. Try changing the wheel speeds to make the robot move in a circular path.

Line following with IR sensors

Add infrared ground sensors to the e-puck by using the groundSensorsSlot. Name two sensors ir0 and ir1, then enable them in the controller.

from controller import Robot

robot = Robot()
time_step = 32
max_speed = 6.24

left_motor = robot.getMotor("left wheel motor")
right_motor = robot.getMotor("right wheel motor")
left_motor.setPosition(float("inf"))
right_motor.setPosition(float("inf"))
left_motor.setVelocity(0.0)
right_motor.setVelocity(0.0)

left_ir = robot.getDistanceSensor("ir1")
right_ir = robot.getDistanceSensor("ir0")
left_ir.enable(time_step)
right_ir.enable(time_step)

while robot.step(time_step) != -1:
    left_ir_value = left_ir.getValue()
    right_ir_value = right_ir.getValue()

    left_speed = max_speed * 0.25
    right_speed = max_speed * 0.25

    if left_ir_value > right_ir_value and 6 < left_ir_value < 15:
        left_speed = -max_speed * 0.25
    elif right_ir_value > left_ir_value and 6 < right_ir_value < 15:
        right_speed = -max_speed * 0.25

    left_motor.setVelocity(left_speed)
    right_motor.setVelocity(right_speed)

Original standalone tutorial: https://pratik-ingle.github.io/webots_tutorial/

]]> tutorials robotics Webots https://pratik-ingle.github.io/posts/tutorials/getting-started-with-webots/index.html Tue, 30 Nov 2021 23:00:00 GMT HMM-Based POS Tagger on the Brown Corpus https://pratik-ingle.github.io/posts/tutorials/hmm-pos-tagger/index.html

Objective

Write a program in Python to implement an HMM-based part-of-speech (POS) tagger for English.

Dataset: the Brown corpus (via NLTK), which contains words paired with their POS tags.

Code: https://github.com/pratik-ingle/HMM-tagger

Mathematical model

An HMM tagger is a special case of Bayesian inference. We model , the probability of a tag sequence given a word sequence, using two kinds of probabilities:

  • Emission probability: the likelihood of a word given a tag , .
  • Transition probability: the likelihood of a tag given the previous tags, .

The best tag sequence is

Training

Both probabilities are estimated from counts in the training set:

Viterbi algorithm

where is the previous Viterbi path probability, the transition probability, and the state observation (emission) likelihood.

The total number of possible tag sequences is for tags and words, which is why dynamic programming is needed.

Assumptions

  1. The probability of a word depends only on its POS tag, and is independent of other words and tags.
  2. The probability of a tag depends only on the previous tag (bigram assumption).

Procedure

Flow of the HMM tagger: split corpus, count frequencies, compute probabilities, run Viterbi, evaluate.

1. Split the corpus

Insert start <s> and end <\s> symbols in each sentence, then hold out the first 10 sentences for testing.

from nltk.corpus import brown

p = brown.tagged_sents()
brown_corpus = []
for i in p:
    i.insert(0, ('<s>', '<s>'))
    i.insert(len(i), ('<\\s>', '<\\s>'))
    brown_corpus.append(i)

brown_test = []
brown_train = []
sen = 0
for i in brown_corpus:
    sen += 1
    if sen <= 10:
        brown_test.append(i)
    else:
        brown_train.append(i)

2. Count patterns in the training set

We need three frequency tables:

  • fre_wordtag: frequency of each (word, tag) pair
  • fre_tag: frequency of each tag
  • fre_bi_tag: frequency of each tag given its previous tag
from collections import Counter

def fre(x):
    types = Counter(tuple(item) for item in x)
    freq = list(types.items())
    freq.sort(key=lambda f: f[1], reverse=True)
    return freq

# flatten training sentences into (word, tag) pairs
brown_words_tag = [j for i in brown_train for j in i]
fre_wordtag = fre(brown_words_tag)

# tag frequencies
brown_tag = [j[1] for i in brown_train for j in i]
fre_tag = list(Counter(brown_tag).items())
fre_tag.sort(key=lambda f: f[1], reverse=True)

3. Turn counts into probabilities

Emission probabilities :

probWiti = []
for i in fre_wordtag:
    for j in fre_tag:
        if i[0][1] == j[0]:
            probWiti.append([i[0], i[1] / j[1]])

Transition probabilities , built from tag bigrams (skipping the <\s> → <s> sentence boundary):

bi_tag = []
x = len(brown_words_tag)
for j in range(x - 1):
    temp = [brown_words_tag[j][1], brown_words_tag[j + 1][1]]
    if temp != ['<\\s>', '<s>']:
        bi_tag.append(temp)

fre_bi_tag = fre(bi_tag)

probbitag = []
for i in fre_bi_tag:
    for j in fre_tag:
        if i[0][0] == j[0]:
            probbitag.append([i[0], i[1] / j[1]])

The set of all tags seen in training is simply:

pos_tag = [i[0] for i in fre_tag]

Because a word’s probability depends on its tag and a tag’s probability depends on the previous tag, there is no UNK tag in the tagger itself; unknown words are handled separately below.

4. Viterbi decoding

With the probabilities in hand we build, for one test sentence, an emission lattice (only entries with non-zero emission probability, since a zero would zero out the whole path) and the set of transition probabilities among the tags that sentence can take.

sentance = brown_test[4]   # pick any of the first 10 test sentences
l = len(sentance)

lattic_emission = [[] for _ in range(l)]
sen_tag = []
for i in range(l):
    for j in probWiti:
        if sentance[i][0] == j[0][0]:
            lattic_emission[i].append(j)
            if j[0][1] not in sen_tag:
                sen_tag.append(j[0][1])
    if len(lattic_emission[i]) == 0:
        # unknown word: treat as 'NN' with probability 0.11
        lattic_emission[i].append([(sentance[i][0], 'NN'), 0.11])

# transition probabilities restricted to tags that appear in this sentence
tran_tag = [(i, j) for i in sen_tag for j in sen_tag]
tran_pro = [j for i in tran_tag for j in probbitag if i == j[0]]

# keep the highest-emission tag for each word, then chain transitions
max_emission = []
sequence = []
for i in lattic_emission:
    i.sort(key=lambda e: e[1], reverse=True)
    max_emission.append(i)

vi = []
for i in range(len(max_emission) - 1):
    vi.append((max_emission[i][0][0][1], max_emission[i + 1][0][0][1]))
    sequence.append(max_emission[i][0][0])
sequence.append(('<\\s>', '<\\s>'))

Vj = []
for i in range(len(vi)):
    for j in tran_pro:
        if vi[i] == j[0]:
            Vj.append(max_emission[i][0][1] * j[1])

def viterbi(Vj):
    result = 1
    for x in Vj:
        result *= x
    return result

print(sequence, '\n', viterbi(Vj))

5. Accuracy

count = 0
for i in range(len(sentance)):
    if sentance[i] == sequence[i]:
        count += 1
accuracy = count / len(sentance) * 100
print("accuracy of HMM tagger for given sentence is", accuracy)

Results

For sentence 4 of the test set:

[('<s>', '<s>'), ('The', 'AT-TL'), ('jury', 'NN-HL'), ('said', 'VBD'), ('it', 'PPS-HL'),
 ('did', 'DOD-NC'), ('find', 'VB'), ('that', 'WPS-NC'), ('many', 'AP-NC'), ('of', 'IN-TL'),
 ("Georgia's", 'NP
  tutorials
  nlp
  HMM
  Viterbi
  https://pratik-ingle.github.io/posts/tutorials/hmm-pos-tagger/index.html
  Sat, 30 Nov 2019 23:00:00 GMT
  



), ('registration', 'NN'), ('and', 'CC-HL'), ('election', 'NN'),
 ('laws', 'NNS'), ('``', '``'), ('are', 'BER-HL'), ('outmoded', 'JJ'), ('or', 'CC-NC'),
 ('inadequate', 'JJ'), ('and', 'CC-HL'), ('often', 'RB'), ('ambiguous', 'JJ'), ("''", "''"),
 ('.', '.-HL'), ('<\s>', '<\s>')]
5.0121351597188597e-33
accuracy of HMM tagger for given sentence is
53.84615384615385

Viterbi returns the most probable tag sequence with a sentence probability of about . Compared against the gold tags, accuracy on this sentence is only 53.8%, lower than the unigram and bigram taggers from earlier assignments. Two reasons: the Brown tagset is very fine-grained (phrase-level suffixes such as -HL, -TL, -NC split what would otherwise be one tag), and the corpus is case sensitive, so the same word gets different tags depending on capitalisation. The HMM does, however, do a better job at identifying phrases.

Unknown words

Words not seen in training are tagged NN, since most training words are nouns. In earlier assignments tagging everything as NN gave about 11% accuracy, so unknown words are given an emission probability of 0.11 in the Viterbi product.

Comparison with other taggers

Exhaustive HMM decoding is expensive: with tags and words there are tag sequences, which is why the Viterbi dynamic-programming algorithm is used to find the optimal one.

Like other stochastic taggers, an HMM tagger finds the most likely tag for a word or sequence of words. Unlike greedy taggers that tag one word at a time, the HMM tags a whole sentence at once, choosing the sequence that maximises

P(word | tag) * P(tag | previous n tags)

The HMM outperforms the simpler taggers here, but it is not the most accurate option: an interpolated tagger can do better.

HMM and ambiguity

Because the HMM considers the whole sentence, it can surface ambiguity: an ambiguous sentence gets different probabilities for its different tag sequences, and the most plausible reading is the one with the highest probability.

Further work

  • Extend the transition model to depend on three or more previous tags (trigram or higher-order HMM).
  • Replace the count-based model with a neural sequence tagger.
]]> tutorials nlp HMM Viterbi https://pratik-ingle.github.io/posts/tutorials/hmm-pos-tagger/index.html Sat, 30 Nov 2019 23:00:00 GMT