Если установку для Ubuntu/Kubuntu и некоторую настройку произвести на VirtualBox, а затем перетащить это на хард диск и обычную загрузку, это сильно повредит операционке?

Как в sqlite3, в частности при использовании в питоне, запретить неявное открытие транзакции на запись? Чтобы при попытке что-либо записать без явного BEGIN вываливалось в исключение?

Есть задача собрать супер-компьютер для ML. Практически без ограничения на бюджет. Деньги не мои, и я пока не знаю, на какой сумме скажут что слишком, пока не говорят.

Предположительно будут гоняться сетки на питоне, там кажется была библиотека для параллелизации этих сеток DataParallel, вроде не сложная в применении. Пока без графики, но в будущем может и этого коснется.

На текущий момент, что я предполагаю, это закупиться RTX 4090 пять штучек, или может больше если найду подходящуюю материнку.

Или может лучше NVIDIA A100? И чем лучше, кроме того, что там 40Гб? Согласно техническим характеристикам, у A100 «Memory bus width» в размере 4096, в то время как у Rtx4090 всего 384. Но процессоров меньше и частота меньше. Но стоит почему то в 3-4 раза больше. На что влияет эта МемориБасВидх?

Будет ли на такую конфигурацию хорошо параллелиться этот DataParallel?

Является ли это оптимальным вариантом, и не будет ли каких либо затыков с этим. Или может это вообще не так делается?

Пытаюсь скомпилировать QtCreator скачанный из github:

https://github.com/qt-creator/qt-creator

В системе установлен КюТе из репозиториев, вроде такая была последовательность (вероятно qt5 здесь лишний):

sudo apt -y update
sudo apt -y upgrade

sudo apt -y install gcc-12 g++-12 build-essential libgl1-mesa-dev qt6-base-dev qt6-tools-dev cmake

sudo apt -y install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools

sudo apt -y install qt5-doc qt5-doc-html qtbase5-doc-html qtbase5-examples

sudo apt -y install qtcreator

sudo apt -y install qbs

sudo apt install ninja-build
sudo apt install qtwebengine5-dev

QtCreator скачанный из репозиториев работает. И я хочу поставить из гитхаба, посмотреть что там нового, и может некоторые глюки подправлены.

При выполнении компиляции QtCreator:

cmake -DCMAKE_BUILD_TYPE=Debug -G Ninja /1th/qt-creator_from_git

выдает такую ошибку:

-- Could NOT find XKB (missing: XKB_LIBRARY XKB_INCLUDE_DIR) (Required is at least version "0.5.0")
-- Could NOT find Qt6Qml (missing: Qt6Qml_DIR)

CMake Error at cmake/FindQt5.cmake:57 (find_package):
  Found package configuration file:

    /usr/lib/x86_64-linux-gnu/cmake/Qt6/Qt6Config.cmake

  but it set Qt6_FOUND to FALSE so package "Qt6" is considered to be NOT
  FOUND.  Reason given by package:

  Failed to find Qt component "Qml".

  Expected Config file at
  "/usr/lib/x86_64-linux-gnu/cmake/Qt6Qml/Qt6QmlConfig.cmake" does NOT exist

  

Call Stack (most recent call first):
  CMakeLists.txt:68 (find_package)

Т.е. ругается что cmake не видит qt6qml. Что ему тут нужно доустановить?

Можно ли в Ubuntu настроить отдельные хоткеи на разные раскладки? Например на русский Ctrl+1 и для английского Ctrl+2.

И можно ли из типового переключения по хоткею исключить одну из раскладок - третью, что бы она не участвовала в последовательности переключения. Оставить ее переключаться мышью через GUI или по отдельному хоткею.

Кто-либо практиковал карточки для запоминания компьютерных знаний? Интересует, какие варианты оформления возможны таких карточек? Что записывать на них? Помогает ли?

Зачем у нейронных сеток делают последний слой с не линейной функцией активации (ФА)?

Если используется не линейная ФА на последнем слое, тогда нужно подстраивать данные под диапазон этой ФА. Эта не линейность на последнем слое не может улучшить результат за счет своей не линейности, разве только если распределение обучаемых выходных данных хорошо вписывасываются в диапазон этой ФА.

Если используется линейная ФА, тогда для пакетного градиентного спуска последний слой можно просто считать по уравенениям линейного МНК. И тогда многослойная сетка становится на один слой проще, что кажется существенно. Для стохастических можно что-нибудь комбинированное придумывать.

Читаем внимательно: речь про последний слой.

Вот есть расписанный 2х параметрический линейный МНК без матриц: https://math.stackexchange.com/questions/1657030/fit-plane-to-3d-data-using-least-squares

Но там нет выражения для расчета квадратичной ошибки. Я попытался это сам подумать, но это вышем моих способностей и доступного времени. И там добавить вопрос в комментарий не могу - не хватает репутаций.

Может кто знает, как это можно посчитать?

Я подобный вопрос про этот мнк здесь уже спрашивал как-то, в результате нашлась та ссылка. Но расчет ошибки сам так и не осилил.

Поставил Haskell, набрал програмку:

integer 0 = 3
main = print (integer 1)

Откомпилировал, запустил получил ошибку во время выполнения. В чем ошибка оно понятно, это я специально сделал, что бы посмотреть что будет.

Можно задаться вопросом, а почему она не во время компиляции была. Но у меня вопрос, что получается что Haskell не так уж и надежен, в нем можно забыть определить значение, и компилятор даже не предупредит об этом. Стоит ли его изучать?

(А тут еще и про новую версию на главной сайта... Совпало)

Допустим есть такой код с ошибкой:

struct Cmd {
	Operation op = Operation::...;
	double subtractor = 0.;
	double multipler = 0.;
};

void randomModifSubtractor(Cmd& cmd) {
	double& v = cmd.multipler; // <- ЭТО ОШИБКА, д.б. subtractor
	v = static_cast<double>(rand()) / RAND_MAX; // для демо сойдет
}

void randomModifCmd(Cmd& cmd) {
	if (rand() % 2 == 0)
		randomModifSubtractor(cmd);
	else
		randomModifMultipler(cmd);
}

В данном коде ошибка в подмене названия. Значения полей уже инициализированно рандомно, и здесь оно меняется на новое. У каждого из полей свои правила модификации, и в реальности сложней. Эта ошибка отчасти ухудшает работу программы, но не ломает. А какова д.б. нормальная работа заранее не известно.

Как может тестироваться такая ошибка? Или может быть можно по другому написать этот код, что бы ошибка тестировалась или минимизировалась ее вероятность?

Использую С++, но очень не удобно, что нет оператора yield. Использую вместо них лямбды для callback, что несколько утяжеляет читаемость кода. У меня их сотни, почти в каждой важной процедуре. В С++ есть какой-то не натив yield, там то же все переусложнено, и еще асинхронность хочет, что уже совсем не то.

На Питоне я еще не пробовал, но вроде он интерпретируемый, а не компилируемый, что не годится. Будет медлено. Или может есть нормально компилируемый? Питон, так же как R, они вроде больше под использование существующих в них библиотек, и не годятся, если хочешь свои тяжелые алгоритмы делать.

Вроде можно попробовать совмещать Python и С++, но пока не решился. Да и те же самые yield из С++ все равно в питон не отправлю.

И вот вопрос, какие могут быть варианты из компилируемых, что бы удобно было делать статистические расчеты на нем?

Нужны yield, нужны лямбды. Д.б. под линукс.

Как объясняется в интернете, я настроил запрет обновлений. Потому что оно вечно пытается начать что-либо выполнять, когда этого не нужно.

В общем настроил вот так: https://pic4a.ru/iHQ-/ и вот так: https://pic4a.ru/i5Nw/

Но тем не менее, периодически почему показываются окна каких-либо процессов от обновления, например появлялись такое: https://pic4a.ru/iJpY/ и такое: https://pic4a.ru/iJGs/

Как бы так это все позапрещать, что бы любые обновления и даже проверки обновлений выполнялись только при ручных запусках?

Вздумалось мне тут освоить vim, и вроде все пока нормально. Только не хватаем мне глобального поиска. Или мозгов, но с этим вы помочь не сможете.

Как в QtQreator: нажимаю Ctrl+Shift+F - на слове, или просто потом впечатываю строку поиска. И он мне выдает все упоминания этого в проекте, где я могу каждое прощелкать и посмотреть детальней:

https://drive.google.com/file/d/1ehG3uvv9zODiaJD_9DMUoo2ApI4Ne7Kn/view?usp=sh...

https://drive.google.com/file/d/1DRJjhm3LfFdDKS09WRYkJVQy27hYidDw/view?usp=sh...

Вот что-нибудь, что бы, скажем от CWD или от предустановленного в переменную каталога выполнять поиск.

Я поискал в инете, инет мне сказал, нужно использовать grep. Я написал :grep struct. И оно мне ничего не выдало. Как я понимаю grep это от pipe работает из командной строки, скажем от cat. Так что даже если он и выдаст, то только от текущего буфера. А мне то нужно рекурсивно от каталога.

Как сделать, что бы отступы после энтера всегда был как на прежней строке, не зависимо от формата файла?

Мне не нравятся попытки вима делать умные отступы в cpp файле, лучше я их сам буду делать.

:filetype indent off
ничего не отключает.

Если сделать файл
/usr/share/vim/vim81/indent.vim
пустым, то это вообще отключает любые отступы.

А нужно, что бы он был ровно таким, как на предыдущей строке.

В файле indent/cpp.vim присутствует надпись:
C++ indenting is built-in

====================
UPD:

Как подсказали ниже, решение состоит из вписывания в .vimrc следующих строк:

let g:did_indent_on = 1
set autoindent

Смотрю тут видео по базовым знаниям vim и там показывают как искать текст. Слеш, набирают текст. Текст в процессе набора сразу ищется и подкрашивается найденное.

Пытаюсь у себя сделать то же самое. Слеш, набираю текст. И текст находится, но только после нажатия энтер. Никакого подкрашивания, никакого поиска в процессе набора.

Может у меня неправильная версия? У меня на Ubuntu 20.04 ставил через sudo apt install vim потом еще поставил кажется vim-kde3 для gvim. По --version пришет VI Improved 8.1

Какой правильный vim нужно ставить?

Видео смотрел вот это: https://www.youtube.com/watch?v=ggSyF1SVFr4

Первый раз сознательно открыл vim. Вопрос, есть ли в нем возможность, что бы курсор мог быть за пределами строки?

Что бы он не прыгал по колонкам при вертикальных перемещениях.

Можно ли в дефайне такого вида:

#define USE_CODE(CODE, NAME) CODE

Для примера:

USE_CODE( a.NAME = b.NAME, attr );

a.attr = b.attr;

Более подробно, это для макроса FOREACH:

#define CNT_ARGS_PLACES(_1,_2,_3,_4,_5,_6,_7,_8,_9, n, ...) n
#define CNT_ARGS(...) CNT_ARGS_PLACES(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1)

#define USE_CODE(CODE, NAME) CODE

#define FOREACH_1(CODE, NAME, ...) USE_CODE(CODE, NAME)
#define FOREACH_2(CODE, NAME, ...) USE_CODE(CODE, NAME) FOREACH_1(CODE, __VA_ARGS__)
#define FOREACH_3(CODE, NAME, ...) USE_CODE(CODE, NAME) FOREACH_2(CODE, __VA_ARGS__)
#define FOREACH_4(CODE, NAME, ...) USE_CODE(CODE, NAME) FOREACH_3(CODE, __VA_ARGS__)

#define FOREACH_WRAP_NUM(N, CODE, ...) FOREACH_##N(CODE, __VA_ARGS__)
#define FOREACH_NUM(N, CODE,...) FOREACH_WRAP_NUM(N, CODE, __VA_ARGS__)

#define FOREACH(CODE, ...) FOREACH_NUM(CNT_ARGS(__VA_ARGS__), CODE, __VA_ARGS__)

FOREACH( a.NAME = b.NAME;, attr1, attr2, attr3)

Или может готовые варианты уже есть?

Перемещено Shaman007 из desktop

Суть: есть два упорядоченных массива. Нужно один добавить во второй объединением. Те которые не имеются в первом те вставляются. Те которые имеются в обоих, те не должны задублироватся, но нужно вызвать доп.обработку на эту пару элементов.

Упорядочены по доп.ключу, а не непосредственно по значению, т.е. прилагается функция сравнения.

Массивы равнозначны, и можно объединять в любой, или можно даже создать новый, если время на выделение памяти незначительно по сравнению с приростом скорости алгоритма.

Конечно, про это пишут везде и много, но везде повторяется примитивный вариант параллельного обхода. Так же как и в классическом std::merge.

В таком случае, не эффективно например, когда один из массивов из одного элемента - тогда проще поиском по сортированному массиву найти позицию вставки, чем перебирать все.

От которого количества имеет смысл вставлять по штучно, а не прогонкой объединения? И т.д.

В общем нюансов много, есть ли готовое, желательно на C++?

-----------------
Если более предметно, то имеется два массива, упорядоченных по Key:

using Key = ...;
using Aggr = int; // может быть любой складывамый класс
std::vector<pair<Key,Aggr>> ar1 = ...;
std::vector<pair<Key,Aggr>> ar2 = ...;

И из этих двух нужно сделать один объединением, а для случаев когда Key совпадают, то Aggr сложить для результатного массива.

===============================================
UPD: добавил описание результата изысканий: пост

Можно ли что-либо сделать с итератором std::set что бы можно было итерировать значения без конст-признака по умолчанию?

class Compare {
   bool operator()(const MyClass& v1, const MyClass& v2) const {
       return v1.constKey() < v2.constKey();
   }
};

std::set<MyClass,Compare> mySet;

...
for (MyClass& item: mySet) // <- error here
   ...;

Если я унаследую класс, то все его методы принмающие себеподбный класс перестанут быть корректными для наследника. Для примера операторы становятся не используемыми.

Как лучше это решается, можно ли без переписывания и переобъявления методов? Может с учетом новых с++2z?

===
UPD: Не, не работает. Например:

struct A {
   int a = 0;
   A() {}
   A(int _a) : a(_a) {}
   bool operator<(const A& other) const { return a < other.a; }
   A operator+(const A& other) const { return A(a + other.a); }
};

namespace std {
template <> struct hash<A> {
   std::size_t operator()(const A& o) const { return hash<int>()(o.a); }
}; }

struct B: public A {
   void methodOfB() const {}
};

B b1(1);
B b2(2);
(b1 + b2).methodOfB(); // <== ERROR

std::unordered_map<A,int> mapA; // normal
std::unordered_map<B,int> mapB; // <== ERROR