installing torch with cuda support is sometimes challenging, this probably helps.
YouTube

AI powered jupyter notebook.
Github

Rye: a Hassle-Free Python Experience

Rye is a comprehensive project and package management solution for Python. Born from its creator's desire to establish a one-stop-shop for all Python users, Rye provides a unified experience to install and manages Python installations, pyproject.toml based projects, dependencies and virtualenvs seamlessly. It's designed to accommodate complex projects, monorepos and to facilitate global tool installations.

Introduction video

This one looks good for a weekend

The 5 most important points explicitly mentioned in the document are:

1. Start doing research early: Begin research even if you don't know everything, as learning along the way is effective.

2. Engage with challenging areas: Pursue fields that may seem messy or unclear, as they offer opportunities for creative work.

3. Forgive yourself for wasting time: Recognize that in the real world, it's hard to identify which problems are important or solvable at a given time.

4. Dive into uncharted territories: Exploring unclear areas of science can lead to creativity and significant discoveries.

5. Learn the history of science: Understanding the history of science can provide context, make your work more meaningful, and help avoid oversimplified models of science.

CS229 Lecture Notes Andrew Ng and Tengyu Ma April 30, 2023

Still working on it, including Python scripts to reproduce some of the figures in the book.
GitHub

یه جلسه همخوانی برای مطالعه این کتاب برقراره و تا سه شنبه ۱۵ مرداد مهلت ثبت نام داره.
ویدیو جلسات هم ظبط میشه.
https://t.me/SystemBiologystudygroup

Kalimba note converter
Keep the punctuatuion unchanged.

https://datacamp.com/freeweek
DataCamp temporary free access.

GPU monitor

pip install nvitop

GitHub

Related posts:
https://t.me/scientific_programming/653

Panda methods
https://xmind.ai/share/ugVH30g4

# C++ Data Structures

(Landscape view shows better)
A detailed map of C++ data structures based on the latest updates, including both standard data structures from the Standard Template Library (STL) and newer features introduced in C++17, C++20, and C++23.

## 1. Primitive Data Types

- int
- char
- float
- double
- bool
- wchar_t (wide character type)
- char16_t, char32_t (introduced in C++11 for UTF-16 and UTF-32 encoding)

## 2. Compound Data Types

### Arrays

- Static: int arr[10];
- Dynamic: int* arr = new int[10];

### Pointers

- int* ptr;
- std::unique_ptr, std::shared_ptr, std::weak_ptr (introduced in C++11 for smart pointers)

### References

- int& ref = x;

## 3. Standard Containers (STL)

### Sequence Containers

- std::array (fixed-size array, introduced in C++11)
- std::vector (dynamic array)
- std::deque (double-ended queue)
- std::list (doubly linked list)
- std::forward_list (singly linked list, introduced in C++11)

### Container Adaptors

- std::stack (LIFO data structure, built on top of other containers)
- std::queue (FIFO data structure)
- std::priority_queue (heap data structure)

### Associative Containers

- std::set (ordered set)
- std::multiset (allows duplicate elements)
- std::map (key-value pairs, ordered by keys)
- std::multimap (allows duplicate keys)

### Unordered Containers (introduced in C++11)

- std::unordered_set (hash table-based set)
- std::unordered_multiset
- std::unordered_map (hash table-based key-value pairs)
- std::unordered_multimap

## 4. String Handling

### Basic Strings

- std::string (dynamic string of characters)
- std::wstring (wide string)
- std::u16string, std::u32string (for UTF-16 and UTF-32 encoding)

### String Views (introduced in C++17)

- std::string_view (lightweight, non-owning string reference)
- std::wstring_view, std::u16string_view, std::u32string_view

## 5. Iterators

### Types

- Input iterators
- Output iterators
- Forward iterators
- Bidirectional iterators
- Random-access iterators

### Iterator Adapters

- std::reverse_iterator
- std::move_iterator
- std::insert_iterator, std::back_insert_iterator, std::front_insert_iterator

### Range-based for loops (introduced in C++11)

- for (auto& item : container)

## 6. Utility Classes

### Pairs and Tuples

- std::pair
- std::tuple (introduced in C++11)
- Structured bindings (introduced in C++17): auto [x, y] = pair;

### Optional (introduced in C++17)

- std::optional<T>: stores an optional value.

### Variant (introduced in C++17)

- std::variant<Ts...>: type-safe union of multiple types.

### Any (introduced in C++17)

- std::any: holds any type of value.

## 7. Algorithms

### Sorting Algorithms

- std::sort, std::stable_sort
- std::partial_sort, std::nth_element
- std::is_sorted

### Searching Algorithms

- std::find, std::binary_search
- std::find_if, std::find_if_not

### Set Operations

- std::set_union, std::set_difference

### Other Algorithms

- std::transform, std::for_each, std::accumulate

## 8. Concurrency (C++11 and beyond)

### Thread Support

- std::thread (multi-threading support)
- std::mutex, std::shared_mutex (introduced in C++17)
- std::lock_guard, std::unique_lock

### Futures and Promises

- std::future, std::promise, std::async

### Coroutines (introduced in C++20)

- co_await, co_yield, co_return

## 9. Ranges (Introduced in C++20)

Provides a new way to handle ranges of data, offering a more modern alternative to traditional iterator-based algorithms.

- std::ranges::begin(), std::ranges::end()
- std::views::filter, std::views::transform

## 10. Concepts (Introduced in C++20)

Used to specify the requirements on template arguments, making template code easier to write and understand.

- template<typename T> requires std::integral<T>

## 11. Smart Pointers

### Ownership Models

- std::unique_ptr: Exclusive ownership of an object.
- std::shared_ptr: Shared ownership of an object.
- std::weak_ptr: Weak reference to a shared pointer, preventing circular dependencies.

## 12. Custom Data Structures

### Class/Struct

- class MyClass { /* ... */ };
- struct MyStruct { /* ... */ };

### Union

- union MyUnion { /* ... */ }

Search for CPP to find related posts, also practicing each section is a proper method to improve the programming skills in C++.

# Python Data Structures

## 1. Primitive Data Types
- int: Integer values.

  x = 10

float: Floating-point numbers.

y = 10.5

bool: Boolean values (True/False).

z = True

str: Strings (immutable sequences of Unicode characters).

s = "Hello, World!"

2. Sequence Types

a. List

A mutable, ordered collection of elements.

lst = [1, 2, 3, 4]
lst.append(5)

b. Tuple

An immutable, ordered collection of elements.

tpl = (1, 2, 3)

c. Range

A sequence of numbers, often used in loops.

r = range(1, 10)

d. String

A sequence of characters, treated as a list of characters.

s = "Hello"
first_char = s[0]

e. Byte/Bytearray

Immutable (bytes) or mutable (bytearray) sequences of bytes.

b = bytes([65, 66, 67])  # A, B, C
ba = bytearray([65, 66, 67])

3. Set Types

a. Set

An unordered, mutable collection of unique elements.

s = {1, 2, 3, 4}
s.add(5)

b. Frozen Set

An immutable version of a set.

fs = frozenset([1, 2, 3])

4. Mapping Type

Dictionary

An unordered, mutable collection of key-value pairs.

d = {'name': 'Alice', 'age': 25}
d['location'] = 'Wonderland'

5. Specialized Data Structures

a. Deque (Double-Ended Queue)

A thread-safe, general-purpose, double-ended queue.

from collections import deque
dq = deque([1, 2, 3])
dq.appendleft(0)

b. Defaultdict

A dictionary that provides a default value for non-existent keys.

from collections import defaultdict
dd = defaultdict(int)
dd['a'] += 1  # If 'a' doesn't exist, its value will default to 0

c. OrderedDict

A dictionary that remembers the order of key insertions (introduced in Python 3.1).

from collections import OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2

6. Stack and Queue

a. Stack (List-based)

A last-in, first-out (LIFO) structure.

stack = []
stack.append(10)
stack.pop()

b. Queue (List or deque-based)

A first-in, first-out (FIFO) structure.

queue = deque()
queue.append(10)
queue.popleft()