Uncategorized – AV/IT Blog

Installation of Tensorflow and PyTorch on Windows GPU machines

Tensorflow

GPU support on native-Windows is only available for 2.10 or earlier versions, starting in TF 2.11, CUDA build is not supported for Windows. For using TensorFlow GPU on Windows, you will need to build/install TensorFlow in WSL2 or use tensorflow-cpu with TensorFlow-DirectML-Plugin
from Tensorflow

According to the website, Tensorflow v2.10 is the last version available. This version requires the following installations:

Python 3.10
CUDA v11.2
cuDNN v8.1

The CUDA Toolkit installation package can be downloaded from this link. We only need to select the correct version and OS and follow the instructions.

For cuDNN, the library files can be found at this link. Registration is required to download the file. The file contains three subfolders, namely bin, include and lib. We can just copy these folders to the corresponding subfolder of the CUDA installation. Alternatively, we can create separate folders for these files and add the path to bin folder to the environment variable.

When the installation is done, we can install Python 3.10. We have to download the Python from Python website. The one in Microsoft Store may not work. Someone said that the Python in Microsoft Store is run in sandbox and does not have access to the GPU resources.

After Python installation, we can install tensorflow v2.10 using the following command.

pip install 'tensorflow&lt;2.11'

1	pip install 'tensorflow<2.11'

After installation, we can test if tensorflow has access to the GPUs

import tensorflow as tf

print(tf.config.list_physical_devices('GPU'))

import tensorflow as tf

print(tf.config.list_physical_devices('GPU'))

PyTorch

The installation instructions for PyTorch can be found here. Choose the corresponding OS and CUDA version. The installation of PyTorch for CUDA v11.8 on Windows is:

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

1	pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

If the above is to be specified in requriements.txt, the following lines shall be added.

--extra-index-url
torch
torchvision
torchaudio

--extra-index-url

torch

torchvision

torchaudio

After installation, it can be tested using the following commands:

import torch

torch.cuda.is_available()

import torch

torch.cuda.is_available()

Notes on NLP

Tokenization

Tokenization is the process of breaking down raw text data into smaller, meaningful units called tokens. These tokens are used as the basic building blocks for natural language processing (NLP) tasks such as language modeling, text classification, and machine translation. Tokenization can be performed using various techniques, such as whitespace tokenization, regular expression tokenization, and subword tokenization. The choice of tokenization technique depends on the specific use case and the language being processed. The resulting tokens are then used to create a vocabulary that maps each token to a unique integer index, which is used by machine learning algorithms to process text data.

Tokenization Methods

Word-based tokenization: This method splits text into words based on spaces and punctuations. It’s the most basic form of tokenization and is used in many NLP tasks. However, it can be problematic for languages where there are no clear word boundaries, such as Chinese or Japanese.
Subword-based tokenization: This method splits text into subwords based on their frequency of occurrence in the training data. Subwords are parts of words that frequently occur together, such as prefixes, suffixes, and common word fragments. This method can handle words that are not in the dictionary, and it’s commonly used in transformer-based models like BERT and GPT-2.
Character-based tokenization: This method splits text into individual characters. It’s useful for languages where there are no clear word boundaries, but it can produce longer sequences than word-based or subword-based tokenization.
Byte-pair encoding (BPE) tokenization: This method is similar to subword-based tokenization, but instead of using pre-defined subwords, it learns the subwords on the fly based on the input text. It starts by treating each character as a separate token and then iteratively merges the most frequent pairs of tokens until a maximum vocabulary size is reached.
Sentencepiece tokenization: This method is similar to BPE tokenization, but it uses a more sophisticated algorithm that takes into account the likelihood of a sequence of tokens occurring together. It can handle languages with complex writing systems like Chinese and Japanese.
Unigram tokenization: This method is similar to BPE tokenization, but it uses a different algorithm that learns the subwords based on the likelihood of a sequence of characters occurring together. It’s faster and produces smaller vocabularies than BPE, but it may not perform as well on languages with complex writing systems.

Building Dictionary Using Tokenizer Function of HuggingFace

from tokenizers import Tokenizer, trainers, pre_tokenizers, decoders, models

# Initialize a tokenizer with Byte-Pair Encoding
tokenizer = Tokenizer(models.BPE())

# Set special tokens
tokenizer.add_special_tokens(["<PAD>", "<UNK>", "<BOS>", "<EOS>"])

# Initialize a trainer with default settings and set max vocab size to 150
trainer = trainers.BpeTrainer(special_tokens=["<PAD>", "<UNK>", "<BOS>", "<EOS>"], vocab_size=150)

tokenizer.train(["sentences.txt"], trainer=trainer)

tokenizer.save("tokenizer.json")

# Encode a sentence
encoded = tokenizer.encode("This is an example sentence.")
print(encoded.tokens)
# return ['T', 'hi', 's ', 'is ', 'an', ' ', 'e', 'x', 'a', 'mp', 'l', 'e s', 'en', 't', 'enc', 'e', '.']

print(len(tokenizer.get_vocab()))
# return 150

from tokenizers import Tokenizer, trainers, pre_tokenizers, decoders, models

# Initialize a tokenizer with Byte-Pair Encoding

tokenizer = Tokenizer(models.BPE())

# Set special tokens

tokenizer.add_special_tokens(["<PAD>", "<UNK>", "<BOS>", "<EOS>"])

# Initialize a trainer with default settings and set max vocab size to 150

trainer = trainers.BpeTrainer(special_tokens=["<PAD>", "<UNK>", "<BOS>", "<EOS>"], vocab_size=150)

tokenizer.train(["sentences.txt"], trainer=trainer)

tokenizer.save("tokenizer.json")

# Encode a sentence

encoded = tokenizer.encode("This is an example sentence.")

print(encoded.tokens)

# return ['T', 'hi', 's ', 'is ', 'an', ' ', 'e', 'x', 'a', 'mp', 'l', 'e s', 'en', 't', 'enc', 'e', '.']

print(len(tokenizer.get_vocab()))

# return 150

Sentencepiece tokenization: This method is similar to BPE tokenization, but it uses a more sophisticated algorithm that takes into account the likelihood of a sequence of tokens occurring together. It can handle languages with complex writing systems like Chinese and Japanese.
Unigram tokenization: This method is similar to BPE tokenization, but it uses a different algorithm that learns the subwords based on the likelihood of a sequence of characters occurring together. It's faster and produces smaller vocabularies than BPE, but it may not perform as well on languages with complex writing systems.

Sentencepiece tokenization: This method is similar to BPE tokenization, but it uses a more sophisticated algorithm that takes into account the likelihood of a sequence of tokens occurring together. It can handle languages with complex writing systems like Chinese and Japanese.

Unigram tokenization: This method is similar to BPE tokenization, but it uses a different algorithm that learns the subwords based on the likelihood of a sequence of characters occurring together. It's faster and produces smaller vocabularies than BPE, but it may not perform as well on languages with complex writing systems.

v4l2, gstreamer, v4l2loopback, ffmpeg

v4l2

# List v4l2 devices
$ v4l2-ctl --list-devices

$ ls -l /dev/v4l/by-id/    # alternative

# Show device information
$ v4l2-ctl --device=/dev/video3 --all

# use list-formats to determine if it contains video streams
$ v4l2-ctl --list-formats --device /dev/video0

# List supported formats
$ v4l2-ctl -d /dev/video0 --list-formats-ext

# Brightness, zoom, focus, etc, can be adjusted with v4l2-ctl. Display all controls and their menus:
$ v4l2-ctl -L
# Then adjust the value:
$ v4l2-ctl -c <option>=<value>

# List v4l2 devices

$ v4l2-ctl --list-devices

$ ls -l /dev/v4l/by-id/ # alternative

# Show device information

$ v4l2-ctl --device=/dev/video3 --all

# use list-formats to determine if it contains video streams

$ v4l2-ctl --list-formats --device /dev/video0

# List supported formats

$ v4l2-ctl -d /dev/video0 --list-formats-ext

# Brightness, zoom, focus, etc, can be adjusted with v4l2-ctl. Display all controls and their menus:

$ v4l2-ctl -L

# Then adjust the value:

$ v4l2-ctl -c <option>=<value>

gstreamer

Installation

sudo apt install python-gi python3-gi \
    gstreamer1.0-tools \
    gir1.2-gstreamer-1.0 \
    gir1.2-gst-plugins-base-1.0 \
    gstreamer1.0-plugins-good \
    gstreamer1.0-plugins-ugly \
    gstreamer1.0-plugins-bad \
    gstreamer1.0-libav

sudo apt install python-gi python3-gi \

gstreamer1.0-tools \

gir1.2-gstreamer-1.0 \

gir1.2-gst-plugins-base-1.0 \

gstreamer1.0-plugins-good \

gstreamer1.0-plugins-ugly \

gstreamer1.0-plugins-bad \

gstreamer1.0-libav

# Display the (Logitech) webcam (/dev/video0) on screen (autovideosink ==> display on screen)
gst-launch-1.0 v4l2src device=/dev/video0 ! videoconvert ! autovideosink
# Latency is high due to video conversion
# Using native MJPG stream of the Logitech Camera
gst-launch-1.0 -v v4l2src device=/dev/video0 ! image/jpeg,width=1920,height=1080,framerate=30/1 ! jpegparse ! jpegdec ! videoconvert ! autovideosink

# Record a video
gst-launch-1.0 v4l2src ! x264enc ! mp4mux ! filesink location=/home/xyz/Desktop/recorded.mp4 -e
# A basic pipeline to record video from webcam to a file on specified location. The -e tage instructs GStreamer to flush EoS(End of Stream) before closing the recorded stream. This allows proper closing of the saved file.

gst-launch-1.0 v4l2src ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegparse ! jpegdec !  x264enc ! mp4mux ! filesink location=test.mp4 -e


# Ref: https://github.com/umlaeute/v4l2loopback/wiki/GStreamer

# Desktop capture as producer
gst-launch-1.0 -v ximagesrc startx=1 starty=1 endx=320 endy=240 ! videoconvert ! "video/x-raw,format=YUY2" ! v4l2sink device=/dev/video11

# Video file as producer
gst-launch-1.0 -v filesrc location=test.avi ! avidemux ! decodebin ! videoconvert ! "video/x-raw,format=YUY2" ! v4l2sink device=/dev/video1

# Separate PNG frames as infinite producer
mkdir test
gst-launch-1.0 -v filesrc location=test.avi ! avidemux ! decodebin ! videoconvert ! pngenc snapshot=false ! multifilesink location=test/%05d.png
gst-launch-1.0 -v multifilesrc location=test/%05d.png loop=1 caps="image/png,framerate=30/1" ! pngdec ! videoconvert ! "video/x-raw,format=YUY2" ! v4l2sink device=/dev/video1

# Display the (Logitech) webcam (/dev/video0) on screen (autovideosink ==> display on screen)

gst-launch-1.0 v4l2src device=/dev/video0 ! videoconvert ! autovideosink

# Latency is high due to video conversion

# Using native MJPG stream of the Logitech Camera

gst-launch-1.0 -v v4l2src device=/dev/video0 ! image/jpeg,width=1920,height=1080,framerate=30/1 ! jpegparse ! jpegdec ! videoconvert ! autovideosink

# Record a video

gst-launch-1.0 v4l2src ! x264enc ! mp4mux ! filesink location=/home/xyz/Desktop/recorded.mp4 -e

# A basic pipeline to record video from webcam to a file on specified location. The -e tage instructs GStreamer to flush EoS(End of Stream) before closing the recorded stream. This allows proper closing of the saved file.

gst-launch-1.0 v4l2src ! image/jpeg,width=640,height=480,framerate=30/1 ! jpegparse ! jpegdec ! x264enc ! mp4mux ! filesink location=test.mp4 -e

# Ref: https://github.com/umlaeute/v4l2loopback/wiki/GStreamer

# Desktop capture as producer

gst-launch-1.0 -v ximagesrc startx=1 starty=1 endx=320 endy=240 ! videoconvert ! "video/x-raw,format=YUY2" ! v4l2sink device=/dev/video11

# Video file as producer

gst-launch-1.0 -v filesrc location=test.avi ! avidemux ! decodebin ! videoconvert ! "video/x-raw,format=YUY2" ! v4l2sink device=/dev/video1

# Separate PNG frames as infinite producer

mkdir test

gst-launch-1.0 -v filesrc location=test.avi ! avidemux ! decodebin ! videoconvert ! pngenc snapshot=false ! multifilesink location=test/%05d.png

gst-launch-1.0 -v multifilesrc location=test/%05d.png loop=1 caps="image/png,framerate=30/1" ! pngdec ! videoconvert ! "video/x-raw,format=YUY2" ! v4l2sink device=/dev/video1

v4l2loopback

Referece: https://github.com/umlaeute/v4l2loopback

# Create 3 virtual camera devices
sudo modprobe v4l2loopback devices=3

# Create 3 devices and manually assign IDs (/dev/videoX). The following will create /dev/video3, /dev/video4 and /dev/video7.
sudo modprobe v4l2loopback video_nr=3,4,7

# Create 3 devices with ID and names
sudo modprobe v4l2loopback video_nr=3,4,7 card_label="device number 3","the number four","the last one"

# Remove a virtual device
sudo v4l2loopback-ctl delete /dev/video7

# Unload the v4l2loopback module from kernel
sudo modprobe -r v4l2loopback

# Create 3 virtual camera devices

sudo modprobe v4l2loopback devices=3

# Create 3 devices and manually assign IDs (/dev/videoX). The following will create /dev/video3, /dev/video4 and /dev/video7.

sudo modprobe v4l2loopback video_nr=3,4,7

# Create 3 devices with ID and names

sudo modprobe v4l2loopback video_nr=3,4,7 card_label="device number 3","the number four","the last one"

# Remove a virtual device

sudo v4l2loopback-ctl delete /dev/video7

# Unload the v4l2loopback module from kernel

sudo modprobe -r v4l2loopback

Clone the physical camera to virtual camera for multiple access

# Clone webcam (/dev/video0) with MJPG format to virutal camera (/dev/video11)
gst-launch-1.0 -v v4l2src device=/dev/video0 ! image/jpeg,width=640,height=360,framerate=30/1 ! jpegparse ! jpegdec ! videoconvert ! tee ! v4l2sink device=/dev/video11

gst-launch-1.0 v4l2src device=/dev/video1 ! "image/jpeg,width=3840,height=2160,framerate=30/1" ! avdec_mjpeg ! "video/x-raw,format=YUY2,width=3840,height=2160,framerate=30/1" ! tee name=t ! queue ! v4l2sink device=/dev/video20 t. ! queue ! v4l2sink device=/dev/video21

# Clone webcam (/dev/video0) with MJPG format to virutal camera (/dev/video11)

gst-launch-1.0 -v v4l2src device=/dev/video0 ! image/jpeg,width=640,height=360,framerate=30/1 ! jpegparse ! jpegdec ! videoconvert ! tee ! v4l2sink device=/dev/video11

gst-launch-1.0 v4l2src device=/dev/video1 ! "image/jpeg,width=3840,height=2160,framerate=30/1" ! avdec_mjpeg ! "video/x-raw,format=YUY2,width=3840,height=2160,framerate=30/1" ! tee name=t ! queue ! v4l2sink device=/dev/video20 t. ! queue ! v4l2sink device=/dev/video21

ffmpeg

# installation
sudo snap install ffmpeg
sudo snap connect ffmpeg:camera

# Copy video stream of physical camera to virtual camera
ffmpeg -i /dev/video0 -s 1920x1080 -f v4l2 -vcodec rawvideo -pix_fmt yuyv422 /dev/video13

# Copy video stream of physical camera to 2 virtual cameras
ffmpeg -i /dev/video0 -s 1920x1080 -vcodec rawvideo -pix_fmt yuyv422 "[f=v4l2]/dev/video11|[f=v4l2]/dev/video12"

# installation

sudo snap install ffmpeg

sudo snap connect ffmpeg:camera

# Copy video stream of physical camera to virtual camera

ffmpeg -i /dev/video0 -s 1920x1080 -f v4l2 -vcodec rawvideo -pix_fmt yuyv422 /dev/video13

# Copy video stream of physical camera to 2 virtual cameras

ffmpeg -i /dev/video0 -s 1920x1080 -vcodec rawvideo -pix_fmt yuyv422 "[f=v4l2]/dev/video11|[f=v4l2]/dev/video12"

Git Commands

General

#check original remote origin url
git remote -v

# you can check what's currently:
git config user.name
git config user.email

#check original remote origin url

git remote -v

# you can check what's currently:

git config user.name

git config user.email

git checkout --orphan newBranch
git add -A  # Add all files and commit them
git commit
git branch -D master  # Deletes the master branch
git branch -m master  # Rename the current branch to master
git push -f origin master  # Force push master branch to github
git gc --aggressive --prune=all     # remove the old files

git checkout --orphan newBranch

git add -A # Add all files and commit them

git commit

git branch -D master # Deletes the master branch

git branch -m master # Rename the current branch to master

git push -f origin master # Force push master branch to github

git gc --aggressive --prune=all # remove the old files

Recreate the master/main

rm -rf .git

-- recreate the repos from the current content only
git init
git add .
git commit -m "Initial commit"

-- push to the github remote repos ensuring you overwrite history
git remote add origin git@github.com:<YOUR ACCOUNT>/<YOUR REPOS>.git
git push -u --force origin master

rm -rf .git

-- recreate the repos from the current content only

git init

git add .

git commit -m "Initial commit"

-- push to the github remote repos ensuring you overwrite history

git remote add origin git@github.com:<YOUR ACCOUNT>/<YOUR REPOS>.git

git push -u --force origin master

Docker Notes

Enter the container:

docker exec -it my-running-app-01 /bin/bash

1	docker exec -it my-running-app-01 /bin/bash

Docker Installation on Ubuntu

sudo snap install docker

1	sudo snap install docker

Docker Offline Deployment

# use save command to export an image
sudo docker save image_name | gzip > app_image.tar.gz

# use load command to import an image
sudo docker load < app_image.tar.gz

# set tag name
sudo docker tag image_id resp_name:tag

# run
sudo docker run -d --name container_name -p 8001:80 image_name:version

# Restart after boot
sudo docker update --restart unless-stopped container_name

# use save command to export an image

sudo docker save image_name | gzip > app_image.tar.gz

# use load command to import an image

sudo docker load < app_image.tar.gz

# set tag name

sudo docker tag image_id resp_name:tag

# run

sudo docker run -d --name container_name -p 8001:80 image_name:version

# Restart after boot

sudo docker update --restart unless-stopped container_name

Multiple IP Addresses on Windows 10

Open command prompt with administrative rights

C:\>netsh interface ipv4 show interface

Idx     Met         MTU          State                Name
---  ----------  ----------  ------------  ---------------------------
  1          75  4294967295  connected     Loopback Pseudo-Interface 1
  4          25        1500  disconnected  Wi-Fi
  7          35        1500  connected     Ethernet
  3          25        1500  disconnected  Local Area Connection* 1
  5          25        1500  connected     Ethernet 2
  9          25        1500  disconnected  Local Area Connection* 2
  8          65        1500  disconnected  Bluetooth Network Connection
 16          35        1500  connected     VMware Network Adapter VMnet1
 11          35        1500  connected     VMware Network Adapter VMnet8
 47          25        1500  connected     Ethernet 3

C:\>netsh interface ipv4 set interface interface="Ethernet 2" dhcpstaticipcoexistence=enabled
C:\>netsh interface ipv4 add address "Ethernet 2" 192.168.0.22 255.255.255.0

C:\>netsh interface ipv4 show interface

Idx Met MTU State Name

--- ---------- ---------- ------------ ---------------------------

1 75 4294967295 connected Loopback Pseudo-Interface 1

4 25 1500 disconnected Wi-Fi

7 35 1500 connected Ethernet

3 25 1500 disconnected Local Area Connection* 1

5 25 1500 connected Ethernet 2

9 25 1500 disconnected Local Area Connection* 2

8 65 1500 disconnected Bluetooth Network Connection

16 35 1500 connected VMware Network Adapter VMnet1

11 35 1500 connected VMware Network Adapter VMnet8

47 25 1500 connected Ethernet 3

C:\>netsh interface ipv4 set interface interface="Ethernet 2" dhcpstaticipcoexistence=enabled

C:\>netsh interface ipv4 add address "Ethernet 2" 192.168.0.22 255.255.255.0

Setting Proxy in Ubuntu

apt

Acquire {
  HTTP::proxy "http://127.0.0.1:8080";
  HTTPS::proxy "http://127.0.0.1:8080";
}

Acquire {

HTTP::proxy "http://127.0.0.1:8080";

HTTPS::proxy "http://127.0.0.1:8080";

}

snap

# /etc/environment
http_proxy=http://127.0.0.1:8080/
https_proxy=http://127.0.0.1:8080/

systemctl restart snapd

# /etc/environment

http_proxy=http://127.0.0.1:8080/

https_proxy=http://127.0.0.1:8080/

systemctl restart snapd

Change Default Username of Raspberry Pi

The Raspbian OS comes with a default username ‘pi’. For security reason, it is suggested to change the username. This article shows how to change it.

Since pi is the only account after the installation and we cannot change the account while it is logged in, we have to login as root. By default, the sulogon of root account is disabled. We enable it by the following steps:

Set a password for root

sudo passwd root

1	sudo passwd root

Open ssh configuration file

sudo nano /etc/ssh/sshd_config

1	sudo nano /etc/ssh/sshd_config

Find the line for PermitRootLogin and set it to yes

#PermitRootLogin prohibit-password
PermitRootLogin yes

1 2	#PermitRootLogin prohibit-password PermitRootLogin yes

Restart the SSH service to apply changes:

sudo service ssh restart

1	sudo service ssh restart

Log out user pi and login with root

Change the default username:

usermod -l <new_user> pi

1	usermod -l <new_user> pi

Rename the home directory:

usermod -m -d /home/<new_user> <new_user>

1	usermod -m -d /home/<new_user> <new_user>

Change the group name:

groupmod -n <new_user> pi

1	groupmod -n <new_user> pi

Reboot and done.

To disable root login:

sudo passwd -l root

1	sudo passwd -l root

Category: Uncategorized