Lingyun's website

【Display Troubleshooting】

Tue, 23 Sep 2025 00:00:00 GMT

https://askubuntu.com/questions/432255/what-is-the-display-environment-variable

【Computer Network Troubleshooting II: Tailscale】

Tue, 23 Sep 2025 00:00:00 GMT

https://unix.stackexchange.com/questions/523152/xrdp-disconnects-immediately-after-connection-from-windows10-centos-to-centos7#

https://www.cnblogs.com/dwj192/p/15685314.html

~/.xsession
/etc/xrdp/startwm.sh
/etc/xrdp/xrdp.ini

sudo systemctl restart xrdp
journalctl -u xrdp -e
journalctl -u xrdp-sesman -e

报错

`xrdp`

9月 25 22:00:37 ubuntu xrdp[507325]: **[ERROR] xrdp_sec_recv: xrdp_mcs_recv failed**

9月 25 22:00:37 ubuntu xrdp[507325]: **[ERROR] xrdp_rdp_recv: xrdp_sec_recv failed**

9月 25 22:00:37 ubuntu xrdp[507325]: **[ERROR] libxrdp_process_data: xrdp_rdp_recv failed**

9月 25 22:00:37 ubuntu xrdp[507325]: **[ERROR] xrdp_process_data_in: xrdp_process_loop failed**

9月 25 22:00:37 ubuntu xrdp[507325]: **[ERROR] SSL_shutdown: Failure in SSL library (protocol error?)**

9月 25 22:00:37 ubuntu xrdp[507325]: **[ERROR] SSL: error:0A000126:SSL routines::unexpected eof while reading**

`xrdp-sesman`

9月 25 15:55:19 ubuntu xrdp-sesman[491872]: **[ERROR] sesman_data_in: scp_process_msg failed**

9月 25 15:55:19 ubuntu xrdp-sesman[491872]: **[ERROR] sesman_main_loop: trans_check_wait_objs failed, removing trans**

display

 1063  **ps** -ef | grep Xorg

【Network Troubleshooting I: VPN & Internet Access】

Tue, 23 Sep 2025 00:00:00 GMT

Debugging VPN and Network Connectivity on Campus WiFi

Intro

It is common to encounter stubborn network issues when setting up a new computer or switching to a new Internet environment. For me, the case is returning from CMU to PKU: my VPN that previously worked flawlessly suddenly refused to connect when I joined PKU Secure, the campus WiFi.

This blog documents my debugging journey, where the culprit turned out to be a gateway problem, and along the way introduces a set of standard tools for network debugging on macOS and Linux systems.

Mistakes are bound to happen, so if you spot anything inaccurate, please feel free to reach out via email or comments.

Problem: VPN Fails on Campus WIFI

My VPN connects perfectly over a mobile hotspot, but fails on PKU Secure.

The key difference:

Hotspot uses public IPv4 addresses.

PKU Secure assigns addresses in a special subnet (10.x.x.x) with stricter campus-side firewall rules.

Analysis
Two potential causes stand out:

Local restrictions — my computer’s firewall could be blocking routes to these private subnets.

Campus network policies — PKU Secure itself may prohibit certain types of forwarding or tunneling.

To untangle these, I turned to a set of well-known command-line tools.

Tools and Commands

1. Routing and Gateway Inspection — `netstat`

netstat -rn
netstat -rn | grep -i default

Shows the routing table.
Look for the default gateway: if you don’t see one pointing to the campus network, your packets won’t make it past the first hop.

2. Firewall Rules — `pfctl`

sudo pfctl -sr    # Show current firewall rules
sudo pfctl -d     # Temporarily disable packet filter

macOS uses pf as its built-in firewall.
Checking rules helps confirm whether connections to 10.x subnets are being silently dropped.

3. DNS Resolution — `dig`

dig +short jt6t2204.epicgames.ink

Resolves domain names to IPs.
This step ensures the problem isn’t with name resolution, but rather with routing.

4. Path Testing — `traceroute`

traceroute -n <target-server>

Shows the hops between your computer and the target server.
In my case, the traceroute couldn’t make a second hop because I wasn’t connected to the campus gateway at all.
Note that some intermediate hops, especially on .edu networks, may deliberately block ICMP or UDP trace packets. Seeing * * * for a hop therefore does not necessarily mean the forward path is broken; it may only mean that that router declined to respond to the trace probes.
How traceroute ends: it stops when the destination returns an ICMP Port Unreachable (i.e., the probe reached the host) or when the probe TTL reaches the configured maximum number of hops (the default is usually 30). It does not run forever — if intermediate hops never respond you will see repeated * * * lines up to the max-hops limit, and then traceroute exits.

5. Network Service State — `networksetup` & `scutil`

networksetup -listallnetworkservices
scutil --nwi
sudo scutil --nc list

networksetup: Lists all network interfaces (WiFi, Ethernet, VPN).
scutil: Reveals per-service connectivity and VPN states.

6. System Profiles and Extensions

sudo profiles -L
systemextensionsctl list

Useful for checking whether enterprise profiles or third-party system extensions are enforcing policies on your Mac.

7. Interface Inspection — `ifconfig`

ifconfig -a | grep utun
ifconfig utun0

VPN tunnels usually appear as utun interfaces on macOS.
Checking them confirms whether the VPN connection was established at all.

8. Connectivity Testing — `curl`

curl --interface en0 -4 www.baidu.com
curl -4 www.baidu.com
curl -6 www.baidu.com

Forces traffic over specific interfaces (en0 for WiFi).
Helps compare IPv4 vs IPv6 connectivity.

9. Open Sockets — `lsof`

sudo lsof | grep -i utun

Lists processes bound to VPN interfaces.
Useful for verifying whether your VPN client is holding a proper tunnel.

Takeaway

The real culprit was simple yet fundamental: my machine wasn’t connected to the gateway of PKU Secure at all, so packets couldn’t escape beyond the first hop.

In practice, network debugging often requires peeling away multiple layers:

Routing tables tell you where packets should go.
Traceroute shows whether they actually go there.
Firewalls and profiles reveal hidden restrictions.

And when in doubt, test with both IPv4 and IPv6, as campus networks sometimes block or misconfigure one of them.

【Generative Model】Look-into Video-Prediction-Policy codebase

Fri, 09 May 2025 00:00:00 GMT

Credits

link: VPO repo

@article{hu2024video,
  title={Video Prediction Policy: A Generalist Robot Policy with Predictive Visual Representations},
  author={Hu, Yucheng and Guo, Yanjiang and Wang, Pengchao and Chen, Xiaoyu and Wang, Yen-Jen and Zhang, Jianke and Sreenath, Koushil and Lu, Chaochao and Chen, Jianyu},
  journal={arXiv preprint arXiv:2412.14803},
  year={2024}
}

Training

text conditioning in SVP with CLIP

CLIP:
- tokenize
- call the encoder
- add positional encodings
concat with the image embeddings

details in def encode_text(...)

Feature Extractions in SVP

The UNet processes video frames through multiple layers

Overall

in policy_models.VPP_policy

class VPP_Policy(...):
	def __init__(...):
		# img encoder
		self.TVP_encoder = Diffusion_feature_extractor(pipeline=pipeline,
			tokenizer=tokenizer,	
			text_encoder=text_encoder,
			position_encoding = self.use_position_encoding)
		# goal encoder
		self.language_goal = LangClip(model_name='ViT-B/32').to(self.device)
		...

	def extract_predictive_featue(self, dataset_batch):
		...
		latent_goal = self.language_goal(dataset_batch["lang"])

		with torch.no_grad():
			input_rgb = torch.cat([rgb_static, rgb_gripper], dim=0)
			language = language + language
			perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep, self.extract_layer_idx, all_layer=self.use_all_layer, step_time=1, max_length=self.max_length)

			perceptual_features = self.Video_Former(perceptual_features)
	
			...
			return predictive_feature, latent_goal

	def training_step(self, dataset_batch):
		predictive_feature, latent_goal = self.extract_predictive_feature(dataset_batch)

		act_loss, _, _ = self.diffusion_loss(
			predictive_feature. 
			latent_goal,
			dataset_batch["actions"],
		)

details in SVP

features are extracted at specific layers (controlled by extract_layer_idx)

class VPP_Policy(pl.LightningModule):
    def __init__(
        self,
        latent_dim: int = 512,
        use_Former: str = '3d',
        extract_layer_idx: int = 1,  # Controls which layer to extract features from
        use_all_layer: bool = False,  # Option to use all layers
        action_dim: int = 7,
        action_seq_len: int = 10,
    ):

in policy_models.module.diffusion_extract

class Diffusion_feature_extractor(nn.Module):
	def forward(
		self,...
		extract_layer_idx,...
	)
		...
		for i, t in enumerate(timesteps):
			...
			feature_pred = self.step_unet(
				...
				use_layer_idx=extract_layer_idx
			)[0]
			...
		return feature_pred

cross-attention and self-attention on features in VideoFormer

These features capture both spatial and temporal information

if use 3d, self.Video_Former = Video_Former_3D(...)

class Video_Former_3D(nn.Module):
    def __init__(
        self,
        dim: int,
        depth: int,
        condition_dim: int = 1280,
        dim_head: int = 64,
        heads: int = 8,
        num_latents: int = 64,
        num_frame: int = 16,
        num_time_embeds: int = 4,
        use_temporal: bool = False,
    ):
        # ...
        self.layers = nn.ModuleList([])
        if self.use_temporal:
            for _ in range(depth):
                self.layers.append(
                    nn.ModuleList([
                        PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
                        Attention(dim, num_heads=heads, qkv_bias=True, use_cross_attn=False,
                                y_dim=512, attn_mask=attn_mask),
                        feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
                    ])
                )

	def forward(x_f, mask): # x_f: input visual embedding
		# 1. Mask the position embeddings for the padded frames
		...
		# 2. Apply the position embeddings
		...
		x_f = x_f + time_pos_emb

		# 3. Apply attention and feed-forward layer
		for attn, temp_attn, ffw in self.layers:
			x = x + attn(x_f, x)
			x = rearrange(x, '(b T) q d -> (b q) T d', b = batch_size)
			x = x + Temp_attn(x)
			x = rearrange(x, '(b q) T d -> (b T) q d', b = batch_size)
			x = x + ffw(x)

		x = x.reshape(batch_size, -1 ,x.shape[1],x.shape[2])
		x = rearrange(x, 'b T q d -> b (T q) d')
		norm = self.norm(x)

		return norm

class PerceiverAttentionLayer(nn.Module):
	def forward(self, features, latents):
		# Layer normalization
		x = self.norm_media(features)
		latents = self.norm_latents(latents)

		# Cross-attention
		q = self.to_q(latents)
		kv_input = toch.cat((x, latents), dim=-2)
		k = self.to_k(kv_input)
		v = self.to_v(kv_input)

		# attention scores
		sim = eimsum('b h q d, b h f d -> b h q f', q, k)
		alphas = sim.softmax(dim=-1)

		out = einsum('b h q f, b h f v -> b h q v', alphas, v)
		out = rearrange(out, 'b h q v -> b q (h v)')

		return self.to_out(out)

class Attention(...):
	def forward(self, x):
		# Perform self-attention

diffusion loss in DiT

diffusion loss

class VPP_Policy(...):
	def diffusion_loss(
		self, 
		perceptual_emb,
		latent_goal,
		actions
	):
		sigmas = self.male_sample_density()(shape=(len(actions),))
		noise = torch.rand_like(actions)
		loss = self.model.loss(perceptual_emb, actions, latent_goal, noise, sigmas)
		return loss, sigmas, noise

self.model = GCDenoiser()

score matching loss

The loss effectively implements score matching, where the model learns to predict the score (gradient of log probability) of the data distribution.

class GCDenoiser(nn.Module):
	def loss(self, state, action, goal, noise, sigma, **kwargs):
		c_skip, c_out, c_in = [append_dims(x, action.ndim) for x in self.get_scalings(sigma)]
		noised_input = action + noise * append_dims(sigma, action.ndim)
		model_output = self.inner_model(state, noised_input * c_in, goal, sigma, **kwargs)
		target = (action - c_skip * noised_input) / c_out # NOTE: target score
		return (model_output - target).pow(2).flatten(1).mean(), model_output

`inner_model` architecture

Inputs:

States (visual observations)
Goals (language instructions)
Actions (current actions)
Sigma (noise level)

Process:

Encode context: States + Goals → Encoder → Context
Decode actions: Actions + Context + Sigma → Decoder → Predicted Actions

class GCDenoiser(nn.Module):
	def _init__(...):
		self.inner_model = DiffusionTransformer(
			action_dim = action_dim,
			obs_dim = obs_dim,
			goal_dim = goal_dim,
			proprio_dim= proprio_dim,
			goal_conditioned = True,
			...
		)

in policy_models.module.diffusion_decoder

class DiffusionTransformer(nn.Module):
	def __init__(...):
		self.encoder = TransformerEncoder(...)
		self.decoder = TransformerFiLMDecoder(...)
		self.proprio_emb = nn.Sequential(
			nn.Linear(...)
			nn.Mish(),
			nn.Linear(...)
		)
		self.sigma_emb = ...
		self.action_emb = nn.Linear(...)
	def forward(self, states, actions, goals, signa, uncond: Optional[bool]):
		# actions: actually noises (or noised_input for training)
		context = self.forward_enc_only(states, actions, goals, sigma, uncond)
		pred_actoins = self.forward_dec_only(context, actions, sigma)
		return pred_actions

Inference

class VPP_Policy: 
	def eval_forward(self, obs, goals)
	act_seq = self.denoise_actions(
		torch.zeros_like(latent_goal).to(latent_goal.device),
		perceptual_emb,
		latent_goal,
		inference=True,
	)

denoise_actions depend on the specific samplers
TODO: look into the different samplers

【Learning VLA】Understand π0 codebase framework【I】

Mon, 05 May 2025 00:00:00 GMT

Model architecture overview

Vision-Language Backbone: Based on PaliGemma, a pre-trained VLM that processes visual inputs and language instructions. This backbone leverages 400M images from SigLIP pre-training and 2.6B tokens from the Gemma language model.
Action Expert: A specialized module that translates the visual and language representations into robot actions. This component is trained on approximately 300M parameters and uses flow matching to generate continuous action distributions appropriate for robotic control.

VLM initialization

llm = nnx_bridge.ToNNX(
    _gemma.Module(
        configs=[paligemma_config, action_expert_config],
        embed_dtype=config.dtype,
    )
)
img = nnx_bridge.ToNNX(
    _siglip.Module(
        num_classes=paligemma_config.width,
        variant="So400m/14",
        pool_type="none",
        scan=True,
        dtype_mm=config.dtype,
    )
)
self.PaliGemma = nnx.Dict(llm=llm, img=img)

Token calculation

prefix embedding

visual & language inputs

def embed_prefix(self, obs: _model.Observation):
    # Embed images
    for name in obs.images:
        image_tokens, _ = self.PaliGemma.img(obs.images[name], train=False)
        tokens.append(image_tokens)
        # ... handle masks and attention
    
    # Add language inputs
    if obs.tokenized_prompt is not None:
        tokenized_inputs = self.PaliGemma.llm(obs.tokenized_prompt, method="embed")
        tokens.append(tokenized_inputs)
        # ... handle masks and attention

suffix embedding

action & state information

projection network initialization

self.state_proj = nnx.Linear(config.action_dim, action_expert_config.width, rngs=rngs)

self.action_in_proj = nnx.Linear(config.action_dim, action_expert_config.width, rngs=rngs)

self.action_time_mlp_in = nnx.Linear(2 * action_expert_config.width, action_expert_config.width, rngs=rngs)

self.action_time_mlp_out = nnx.Linear(action_expert_config.width, action_expert_config.width, rngs=rngs)

self.action_out_proj = nnx.Linear(action_expert_config.width, config.action_dim, rngs=rngs)

calculate embedding

@at.typecheck
def embed_suffix(
    self, obs: _model.Observation, noisy_actions: _model.Actions, timestep: at.Float[at.Array, " b"]
) -> tuple[at.Float[at.Array, "b s emb"], at.Bool[at.Array, "b s"], at.Bool[at.Array, " s"]]:
    input_mask = []
    ar_mask = []
    tokens = []
    
    # 1. Project state to token space
    state_token = self.state_proj(obs.state)[:, None, :]
    tokens.append(state_token)
    input_mask.append(jnp.ones((obs.state.shape[0], 1), dtype=jnp.bool_))
    ar_mask += [True]  # State token can't attend to previous tokens

    # 2. Project actions to token space
    action_tokens = self.action_in_proj(noisy_actions)
    
    # 3. Create time embeddings using sine-cosine positional encoding
    time_emb = posemb_sincos(timestep, self.action_in_proj.out_features, min_period=4e-3, max_period=4.0)
    time_tokens = einops.repeat(time_emb, "b emb -> b s emb", s=self.action_horizon)
    
    # 4. Mix action and time information
    action_time_tokens = jnp.concatenate([action_tokens, time_tokens], axis=-1)
    action_time_tokens = self.action_time_mlp_in(action_time_tokens)
    action_time_tokens = nnx.swish(action_time_tokens)
    action_time_tokens = self.action_time_mlp_out(action_time_tokens)
    
    tokens.append(action_time_tokens)
    input_mask.append(jnp.ones(action_time_tokens.shape[:2], dtype=jnp.bool_))
    ar_mask += [True] + ([False] * (self.action_horizon - 1))

Flow Matching

Inference

sample actions

flow matching

given t=1, apply velocity to noise, until t=0

code reading

def step(carry): given the current ($x_t$, time), determine the next ($x_t$, time)

use KV caching to process the prefix only once

@override
def sample_actions(
	self, 
	rng, 
	observation,
	*,
	num_steps
) -> _model.Actions:
    observation = _model.preprocess_observation(None, observation, train=False)
    # note that we use the convention more common in diffusion literature, where t=1 is noise and t=0 is the target
    # distribution. yes, this is the opposite of the pi0 paper, and I'm sorry.
    dt = -1.0 / num_steps
    batch_size = observation.state.shape[0]
    noise = jax.random.normal(rng, (batch_size, self.action_horizon, self.action_dim))

    # first fill KV cache with a forward pass of the prefix
    prefix_tokens, prefix_mask, prefix_ar_mask = self.embed_prefix(observation)
    prefix_attn_mask = make_attn_mask(prefix_mask, prefix_ar_mask)
    positions = jnp.cumsum(prefix_mask, axis=1) - 1
    _, kv_cache = self.PaliGemma.llm([prefix_tokens, None], mask=prefix_attn_mask, positions=positions)

    def step(carry):
        x_t, time = carry
        suffix_tokens, suffix_mask, suffix_ar_mask = self.embed_suffix(
            observation, x_t, jnp.broadcast_to(time, batch_size)
        )
        # `suffix_attn_mask` is shape (b, suffix_len, suffix_len) indicating how the suffix tokens can attend to each other
        suffix_attn_mask = make_attn_mask(suffix_mask, suffix_ar_mask)
        # `prefix_attn_mask` is shape (b, suffix_len, prefix_len) indicating how the suffix tokens can attend to the prefix tokens
        prefix_attn_mask = einops.repeat(prefix_mask, "b p -> b s p", s=suffix_tokens.shape[1])
        # `combined_mask` is shape (b, suffix_len, prefix_len + suffix_len) indicating how the suffix tokens (which generate the queries) can attend to the full prefix + suffix sequence (which generates the keys and values)
        full_attn_mask = jnp.concatenate([prefix_attn_mask, suffix_attn_mask], axis=-1)
        assert full_attn_mask.shape == (
            batch_size,
            suffix_tokens.shape[1],
            prefix_tokens.shape[1] + suffix_tokens.shape[1],
        )
        # `positions` is shape (b, suffix_len) indicating the positions of the suffix tokens
        positions = jnp.sum(prefix_mask, axis=-1)[:, None] + jnp.cumsum(suffix_mask, axis=-1) - 1

        (prefix_out, suffix_out), _ = self.PaliGemma.llm(
            [None, suffix_tokens], mask=full_attn_mask, positions=positions, kv_cache=kv_cache
        )
        assert prefix_out is None
        v_t = self.action_out_proj(suffix_out[:, -self.action_horizon :])

        return x_t + dt * v_t, time + dt

    def cond(carry):
        x_t, time = carry
        # robust to floating-point error
        return time >= -dt / 2

    x_0, _ = jax.lax.while_loop(cond, step, (noise, 1.0))
    return x_0

Training

flow matching loss

generate random noise
sample time points from beta distribution
interpolate between noise and gt actions -> $x_t$

$x_t$: action of the current timestep; the model takes $x_t$ as input

calculate gt velocity
get model predictions
project model output to velocity space
compute MSE loss between predicted and gt velocity

def compute_loss(self, rng, observation, actions, *, train=False):
    # Generate noise and time samples
    noise = jax.random.normal(noise_rng, actions.shape)
    time = jax.random.beta(time_rng, 1.5, 1, batch_shape) * 0.999 + 0.001
    
    # Interpolate between noise and actions
    time_expanded = time[..., None, None]
    x_t = time_expanded * noise + (1 - time_expanded) * actions
    u_t = noise - actions
    
    # Process through model
    prefix_tokens, prefix_mask, prefix_ar_mask = self.embed_prefix(observation)
    suffix_tokens, suffix_mask, suffix_ar_mask = self.embed_suffix(observation, x_t, time)
    
    # Compute attention and get model output
    attn_mask = make_attn_mask(input_mask, ar_mask)
    positions = jnp.cumsum(input_mask, axis=1) - 1
    (prefix_out, suffix_out), _ = self.PaliGemma.llm(
        [prefix_tokens, suffix_tokens], mask=attn_mask, positions=positions
    )
    v_t = self.action_out_proj(suffix_out[:, -self.action_horizon:])
    
    # Compute MSE loss between predicted and target velocity
    return jnp.mean(jnp.square(v_t - u_t), axis=-1)

Lingyun's website

【Display Troubleshooting】

【Computer Network Troubleshooting II: Tailscale】

报错

xrdp

xrdp-sesman

display

【Network Troubleshooting I: VPN & Internet Access】

Debugging VPN and Network Connectivity on Campus WiFi

Intro

Problem: VPN Fails on Campus WIFI

Tools and Commands

1. Routing and Gateway Inspection — netstat

2. Firewall Rules — pfctl

3. DNS Resolution — dig

4. Path Testing — traceroute

5. Network Service State — networksetup & scutil

6. System Profiles and Extensions

7. Interface Inspection — ifconfig

8. Connectivity Testing — curl

9. Open Sockets — lsof

Takeaway

【Generative Model】Look-into Video-Prediction-Policy codebase

Credits

Training

text conditioning in SVP with CLIP

Feature Extractions in SVP

Overall

details in SVP

cross-attention and self-attention on features in VideoFormer

diffusion loss in DiT

diffusion loss

score matching loss

inner_model architecture

Inference

【Learning VLA】Understand π0 codebase framework【I】

Model architecture overview

VLM initialization

Token calculation

prefix embedding

suffix embedding

Flow Matching

Inference

sample actions

Training

`xrdp`

`xrdp-sesman`

1. Routing and Gateway Inspection — `netstat`

2. Firewall Rules — `pfctl`

3. DNS Resolution — `dig`

4. Path Testing — `traceroute`

5. Network Service State — `networksetup` & `scutil`

7. Interface Inspection — `ifconfig`

8. Connectivity Testing — `curl`

9. Open Sockets — `lsof`

`inner_model` architecture