View history CPU usage statistics

First install sysstat package, then run sar -u

winget usage and recommended windows tools

winget is slow due to missing mirror site in china. consider using proxy.

to activate windows 10, use KMS tool.

Windows10Debloater: Script to remove Windows 10 bloatware.

Debloat-Windows-10 (not for win11?)

optimizer able to:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Full multilingual support (20 languages available)
Speed up your system and network performance
Disable unnecessary Windows services
Disable Windows telemetry, Cortana and many more
Disable Office telemetry (works only with Office 2016)
Disable Windows 10 automatic updates
Download useful apps quickly at once
Uninstall UWP apps
Clean your system drive and major browsers' profile data
Fix common registry issues
Ping IPs and assess your latency
Search IPs on SHODAN.io
Rapidly change DNS server (from a pre-made list)
Flush DNS cache
Remove unwanted programs running at startup
Edit your HOSTS file
Find file lock handles and kill associated processes
Hardware inspection tool
Add items in desktop on right-click menu
Define custom commands for run dialog
Silent run support using a configuration file

SophiApp: The most powerful open source tweaker on GitHub for fine-tuning Windows 10 & Windows 11

dynamically wait and reload the python code from disk when runtime exception occurs

One way to achieve this is to use the importlib module to dynamically reload a module at runtime. Here’s an example of how you can do this:

1
2
3
4
5
6
7
8
9

import importlib
def reload_module(module_name: str) -> None:
importlib.reload(module_name)
# Example usage
try:
reload_module("my_module")
except Exception as e:
print(f"Exception occurred: {e}")

This will reload the module with the given name at runtime, and if an exception occurs during the reloading process, it will be caught and handled by the except block.

Note that this approach will only work if the module has been imported at least once before, as the importlib.reload() function can only reload modules that are already imported into the current Python environment. If the module has not been imported yet, you will need to use the importlib.import_module() function to import it first.

I hope this helps! Let me know if you have any questions.

optimize GPT2 output with human feedback

There are a few ways you can optimize the output of a GPT-2 model with human feedback. Here are a few options you might consider:

Fine-tuning: One way to optimize the output of a GPT-2 model is to fine-tune it on a specific task or domain using human-labeled data. This involves training the model on a dataset of human-generated text, such as a collection of articles or a corpus of conversational transcripts. Fine-tuning the model can help it learn to produce output that is more relevant and appropriate for the specific task or domain you are interested in.

Evaluating and adjusting model hyperparameters: Another way to optimize the output of a GPT-2 model is to experiment with different model hyperparameters, such as the learning rate, batch size, and number of layers. You can use human feedback to evaluate the quality of the model’s output and adjust these hyperparameters accordingly to improve performance.

Using human feedback to guide model training: In addition to using human feedback to evaluate the model’s output, you can also use it to guide the training process itself. For example, you can use human feedback to identify specific examples or categories of output that the model is struggling with, and then use these examples to create a targeted training dataset for the model. This can help the model learn to produce more accurate and appropriate output for these specific cases.

I hope these suggestions are helpful! Let me know if you have any questions.

train GPT2 model to operate with terminal

To train a GPT-2 model to operate with the terminal, you will need to do the following:

Collect a dataset of terminal commands and their associated outputs. This dataset will be used to train the GPT-2 model.

Preprocess the dataset by tokenizing the commands and outputs and creating input-output pairs for training the model.

Train the GPT-2 model using the preprocessed dataset. This can be done using the openai/gpt-2 repository on GitHub, which contains the necessary code and instructions for training the model.

Evaluate the performance of the trained model on a separate test dataset of terminal commands and outputs to ensure that it is able to accurately predict the outputs for a given set of commands.

If the model’s performance is not satisfactory, you may need to fine-tune it further by adjusting the training hyperparameters or collecting more data for training.

I hope this helps! Let me know if you have any questions.

what can pyro do

Pyro is a probabilistic programming language developed by Uber for use in Bayesian machine learning. It allows users to build complex models using simple, high-level abstractions, and provides a suite of tools for working with probability distributions and performing Bayesian inference.

Some of the key features of Pyro include:

Support for a wide range of probability distributions, including continuous and discrete distributions, as well as a variety of common compound distributions such as mixtures and convolutions.

A flexible model construction API that allows users to define complex models using simple, high-level abstractions.

Automatic differentiation and gradient-based optimization algorithms for efficient training of probabilistic models.

Algorithms for performing approximate Bayesian inference, including Markov chain Monte Carlo (MCMC) and variational inference (VI).

Support for parallelization and distributed computing, allowing users to scale their models and inference algorithms to large datasets.

Overall, Pyro is a powerful tool for building and training probabilistic models for machine learning tasks, and is well-suited for a wide range of applications in areas such as natural language processing, computer vision, and time series analysis.

segment audio and classify audio with pyro

To segment and classify audio using Pyro, you will need to first build a probabilistic model that can process the audio data and make predictions about the segments and class labels. Here are the general steps you can follow:

Preprocess the audio data by converting it to a suitable format for use in the model (e.g., a spectrogram or other feature representation).

Define a probabilistic model in Pyro that takes the audio data as input and makes predictions about the segment boundaries and class labels. This model will likely include a number of latent variables (i.e., variables that are not directly observed, but are inferred from the data) that represent the underlying structure of the audio data.

Use Pyro’s automatic differentiation and gradient-based optimization algorithms to train the model on a dataset of labeled audio segments. This will involve defining a loss function that measures the model’s performance on the training data and adjusting the model parameters to minimize the loss.

Use the trained model to make predictions on new audio data by performing inference using one of Pyro’s approximate inference algorithms, such as Markov chain Monte Carlo (MCMC) or variational inference (VI).

I hope this helps! Let me know if you have any questions.

demonstrate the process with code

Sure! Here is an example of how you might build a probabilistic model in Pyro to segment and classify audio data. This example assumes that you have already preprocessed the audio data and converted it to a suitable format (e.g., a spectrogram) for use in the model.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import pyro
import torch
# Define the number of classes and the size of the input data
num_classes = 10
input_size = (batch_size, num_features)
# Define the model using Pyro's primitive distributions
def audio_classifier(x):
# Define the latent variables for the segment boundaries and class labels
segment_boundaries = pyro.sample("segment_boundaries", pyro.distributions.Uniform(0, 1))
class_labels = pyro.sample("class_labels", pyro.distributions.Categorical(torch.ones(num_classes)/num_classes))
# Use the latent variables to define the likelihood of the data
likelihood = pyro.sample("likelihood", pyro.distributions.Normal(segment_boundaries, class_labels), obs=x)
return likelihood
# Define the optimizer and the loss function
optimizer = torch.optim.Adam(audio_classifier.parameters(), lr=0.01)
loss_fn = pyro.infer.Trace_ELBO().differentiable_loss
# Loop over the training data and update the model parameters
for x, y in training_data:
# Clear the gradients
optimizer.zero_grad()
# Compute the loss
loss = loss_fn(audio_classifier, x, y)
# Backpropagate the loss and update the model parameters
loss.backward()
optimizer.step()

This model defines two latent variables: segment_boundaries, which represents the boundaries between different audio segments, and class_labels, which represents the class labels for each segment. The model then uses these latent variables to define the likelihood of the data (i.e., the probability of observing the audio data given the latent variables).

To perform inference with this model, you can use one of Pyro’s approximate inference algorithms, such as Markov chain Monte Carlo (MCMC) or variational inference (VI). For example, to perform MCMC inference, you can use the pyro.infer.MCMC class as follows:

1
2
3
4
5
6
7
8
9
10

# Define the MCMC sampler
mcmc = pyro.infer.MCMC(kernel=pyro.infer.NUTS(audio_classifier), num_samples=1000, warmup_steps=100)
# Run the sampler
mcmc.run(x)
# Extract the samples
samples = mcmc.get_samples()
# Use the samples to estimate the posterior distribution of the latent variables
segment_boundaries_posterior = samples["segment_boundaries"]
class_labels_posterior = samples["class_labels"]

I hope this example helps to illustrate the process of building and using a probabilistic model for audio segmentation and classification with Pyro. Let me know if you have any questions!