RUG RAG

Первой практической штукой, которую мы сделаем, будет RAG система

RAG (Retrieval-Augmented Generation) – это подход, при котором искусственный интеллект сначала находит нужную информацию в базе данных или документах (retrieval), а затем использует её для генерации ответа (generation).

Простыми словами, это способ “научить” модель отвечать с опорой на реальные данные, а не только на то, что она запомнила при обучении.

RAG-системы применяются в чат-ботах, справочных ассистентах и корпоративных поисках — чтобы AI давал точные, актуальные и обоснованные ответы, цитируя источник, а не "выдумывал" их.

Чтобы перейти к практике, нам в любом случае придётся разобраться с тем что такое: AI модель, в чем разница между AI моделью и нейросетью и понять понять какие вообще бывают модели. Всё это я расписал в конспекте, который прикрепляю снизу

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

Читать: AI модели для чайников


SemolinaCode | Chat | YouTube | HowToCode | Prop

📟 Прилетело из @semolina_code_python

Прототип дизайна страницы падения Cloudflare

📟 Прилетело из @danokhlopkov

Погружение в Core Solidity. Часть 2

Алгебраические типы данных и сопоставление с образцом

Алгебраические типы данных (ADT, Algebraic Data Types) предоставляют принципиальную основу для моделирования данных за счёт комбинирования суммарных (sum) и произведённых (product) типов. Суммарные типы являются расширением перечислений (enums) из классического Solidity. Они представляют исключающие друг друга варианты: значение принадлежит ровно одному из возможных вариантов. Произведённые типы объединяют несколько значений в структурированные кортежи. На основе этих двух примитивов можно конструировать точные типы, делающие недопустимые состояния полностью невозможными для представления, что позволяет системе типов обеспечивать соблюдение инвариантов полностью на этапе компиляции.

Начнём с очень простого типа:

data Bool = True | False

Левая часть приведённого выше выражения определяет имя нового типа (Bool), а правая часть задаёт множество значений, составляющих тип Bool (True или False).

С помощью ADT также можно реализовать те же самые паттерны, что и пользовательские типы-значения (User Defined Value Types) в классическом Solidity. Например, значение с фиксированной точкой и 18 знаками после запятой («wad») можно представить следующим образом:

data wad = wad(uint256)

Тип wad (слева) имеет единственный конструктор значений wad (справа), который хранит значение типа uint256 в качестве своего внутреннего представления. Имена типов и конструкторы значений находятся в отдельных пространствах имён, поэтому могут совпадать. Простые обёрточные типы подобного рода будут полностью удалены компилятором при трансляции в Yul, то есть тип wad будет иметь точно такое же представление во время выполнения, как и uint256.

Теперь можно определить процедуру умножения чисел с фиксированной точкой с проверкой типов. Для этого потребуется извлечь внутреннее значение uint256, произвести над ним необходимые операции и обернуть результат в новый конструктор wad. Для распаковки воспользуемся сопоставлением с образцом (pattern matching). Сопоставление с образцом — это механизм управления потоком выполнения, позволяющий деконструировать и анализировать данные по их структуре. Вместо громоздких цепочек if-else можно писать декларативные выражения, полностью перебирающие все возможные значения проверяемого типа.

let WAD = 10 ** 18;

function wmul(lhs : wad, rhs : wad) -> wad {
    match (lhs, rhs) {
    | (wad(l), wad(r)) => return wad((l * r) / WAD);
    }
}

Тип AuctionState, ниже, имеет четыре альтернативных конструктора значений:

- NotStarted указывает, что аукцион ещё не начался, и хранит резервную цену;
- Active означает, что аукцион идёт, и хранит текущую максимальную ставку и адрес того, кто её сделал;
- Ended представляет успешно завершившийся аукцион с максимальной ставкой и адресом победителя;
- Cancelled описывает отменённый аукцион и хранит максимальную ставку и адрес предполагаемого победителя на момент отмены.

Теперь можно определить функцию processAuction, которая изменяет состояние аукциона в зависимости от текущего состояния и значения msg.value. Выражение match позволяет выполнить исчерпывающий разбор всех возможных состояний. Случай _ в конце конструкции match является обработчиком по умолчанию для всех оставшихся состояний, которые явно не были перечислены. Компилятор гарантирует полноту такого разбора, требуя, чтобы каждое возможное состояние обрабатывалось ровно один раз.

function processAuction(state: AuctionState) -> AuctionState {
    match state {
    | NotStarted(reserve) =>
        require(msg.value >= reserve);
        return Active(msg.value, msg.sender);
    | Active(currentBid, bidder) =>
        require(msg.value > currentBid);
        transferFunds(bidder, currentBid);
        return Active(msg.value, msg.sender);
    | _ => return state;
    }
}

#core

📟 Прилетело из @solidityset

Запуск AI-моделей локально

Просто для понимания: ChatGPT 5, Gemini 3, Grok 3 и т. д. – это самые популярные AI-модели от крупных компаний

Но на самом деле этих моделей огромное количество. Только в открытом доступе на Hugging Face находится более 2.2 млн моделей под разные задачи (каждую из которых можно скачать и запустить у себя локально – если, конечно, хватит железа)

Один из самых простых способов запустить модель локально – использовать DMR (Docker Model Runner)
Если вы впервые слышите слово "Docker", ничего страшного. Чтобы скачать и запустить модель, вам не придётся писать код или вводить команды, так как у DMR есть понятный пользовательский интерфейс (см. скрин).

Без лишних слов – всё описал в конспекте:

Читать: DMR: запуск AI-моделей локально

P.S. А вообще, на канале есть урок про основы Docker и docker-compose для кодеров

SemolinaCode | Chat | YouTube | HowToCode | Prop

📟 Прилетело из @semolina_code_python

В продаже появился софт по Outlook'y

- Вход на реальных запросах с браузера.
- Привязка резервной почты с подтверждением.
- Смена пароля.
- Генер рефреш токена
- Генер резервных кодов для входа

Софт фулл на запросах . Outlook удаляет почты в которые не заходили 2+года

За покупкой в лс .

📟 Прилетело из @steamner

Погружение в Core Solidity. Часть 3

Обобщения и классы типов

Core Solidity вводит два новых механизма для повторного использования кода и полиморфизма: обобщения (generics) и классы типов (иногда также называемые трейтами, traits).

Обобщения реализуют параметрический полиморфизм: они позволяют писать функции и структуры данных, работающие одинаково для всех типов. В качестве примера определим полиморфную функцию тождества:

forall T . function identity(x : T) -> T {
    return x;
}

Здесь forall вводит новую переменную-тип T, область видимости которой ограничена определением функции.

Можно также определять обобщённые типы. Например, следующий тип Result, параметризованный типом полезной нагрузки в случае ошибки:

data Result(T) = Ok | Err(T)

Обобщения весьма мощны, но сами по себе довольно ограничены. Большинство интересных операций не определены для всех типов вообще. Классы типов решают эту проблему: они позволяют задавать перегруженные, специфичные для каждого типа реализации одной и той же сигнатуры функции. В сочетании с ограничениями классов типов они предоставляют возможность писать обобщённые функции, полиморфные лишь над ограниченным подмножеством типов.

Класс типов — это просто спецификация интерфейса. Рассмотрим, например, определение класса типов, которые поддерживают операцию умножения:

forall T . class T:Mul {
    function mul(lhs : T, rhs : T) -> T;
}

Вместо конкретной функции wmul, которую мы определили выше для нашего типа wad с фиксированной точкой, более идиоматично создать экземпляр (в терминологии Rust — impl) класса типов Mul для wad. Это даёт единообразный синтаксис умножения для всех типов и позволяет использовать wad в функциях, обобщённых над любыми типами, реализующими Mul:

instance wad:Mul {
    function mul(lhs : wad, rhs : wad) -> wad {
        return wmul(lhs, rhs);
    }
}

Если мы хотим написать функцию, принимающую любой тип, для которого определён экземпляр Mul, необходимо добавить ограничение в сигнатуру:

forall T . T:Mul => function square(val : T) -> T {
    return Mul.mul(val, val);
}

Простые обёрточные типы вроде wad встречаются очень часто. Один из особенно полезных классов типов при работе с ними — Typedef:

forall T U . class T:Typedef(U) {
    function abs(x : U) -> T;
    function rep(x : T) -> U;
}

Функции abs (абстрагирование) и rep (представление) позволяют единообразно преобразовывать обёрточные типы во внутренние и наоборот, избегая синтаксического шума, связанного с необходимостью использовать сопоставление с образцом каждый раз при распаковке значения. Экземпляр для wad выглядел бы так:

instance wad:Typedef(uint256) {
    function abs(u : uint256) -> wad {
        return wad(u);
    }

    function rep(x : wad) -> uint256 {
        match x {
        | wad(u) => return u;
        }
    }
}

Обратите внимание: параметры, следующие после имени класса (например, U в определении Typedef выше), являются «слабыми» — их значение однозначно определяется значением параметра T. Если вы знакомы с Haskell или Rust, то это по сути ассоциированный тип (associated type) (хотя, для тех, кто разбирается в системах типов, реализовано это с помощью ограниченной формы функциональных зависимостей). Проще говоря, для wad можно определить только один экземпляр Typedef: компилятор не разрешит одновременно объявить и wad:Typedef(uint256), и wad:Typedef(uint128). Это ограничение делает вывод типов значительно более предсказуемым и надёжным, избегая многих неоднозначностей, присущих полноценным многопараметрическим классам типов.

📟 Прилетело из @solidityset

В качестве реального примера того, как обобщения и ограничения через классы типов помогают устранить шаблонный и повторяющийся код, сравним комбинаторный взрыв перегрузок, необходимых для реализации console.log в библиотеке forge-std, с одной обобщённой функцией в Core Solidity, которая покрывает функциональность всех перегрузок с одним аргументом из оригинальной библиотеки. Слово word в этой реализации обозначает низкоуровневый тип, представляющий переменную на языке Yul, и является единственным типом, который можно передавать в блоки assembly и получать из них.

forall T . T:ABIEncode => function log(val : T) {
    let CONSOLE_ADDRESS : word = 0x000000000000000000636F6e736F6c652e6c6f67;
    let payload = abi_encode(val);

    // извлекаем внутреннее представление payload как word
    let ptr = Typedef.rep(payload);

    assembly {
        pop(
            staticcall(
                gas(),
                CONSOLE_ADDRESS,
                add(ptr, 32),
                mload(ptr),
                0,
                0
            )
        )
    }
}

Подобно Rust и Lean, все вызовы классов типов и обобщённых функций полностью мономорфизируются (monomorphized) на этапе компиляции. Это означает, что полиморфные функции не несут накладных расходов во время выполнения по сравнению с полностью конкретизированными функциями. Хотя это действительно приводит к тому, что скомпилированный код для EVM может содержать несколько специализированных версий одной и той же обобщённой функции, это не увеличивает размер бинарного файла по сравнению с классическим Solidity, где для получения эквивалентной функциональности в любом случае потребовалось бы определять несколько отдельных функций. Мы считаем такой компромисс полностью оправданным для нашей предметной области.

#core

📟 Прилетело из @solidityset

Запуск AI-моделей локально (способ 2)

Запускать ai модели ещё можно через ollama

Функции почти те же, что и у Docker:
– есть GUI
– устанавливается одной командой
– есть hub моделей
– гибкие настройки
– поддержка openai api
– есть возможность запуска моделей с Hugging Face (в формате GGUF)
– большое комьюнити

Читать: Запуск моделей локально через Ollama

SemolinaCode | Chat | YouTube | HowToCode | Prop

📟 Прилетело из @semolina_code_python

Open Academy, самая крупная биржа Binance и их совместный курс по фьючерсам!

Как принять участие, заработать $15 в BNB, доход от рефералов и получить сертификат.

Что мне понравилось:

1. Можно указать свою рефку на Бинансе прямо в курсе и приглашать рефералов в Open Academy. А те, регистрируясь в Binance, станут вашими рефералами и там.
Это даст доп. доход в случае их торговли.

2. Также вы сможете получить 15 $ в $BNB, завершив изучение курса с квестами до 27 ноября 19:00 по МСК.
Важное условие: нужен торговый объём в размере "$1000" на Binance Futures.

Проходите всего 10 уроков длительностью от 2 до 4 минут, и вы сможете получить бонусы + сертификат!

Изучать

P. S. Если вы в РФ, KYC (проверку личности) можно пройти только на загран-паспорт и выписку из банка с подтверждением адреса.

😎 Незрячий web3 программист (подписаться)
Чат | бот

📟 Прилетело из @blind_dev

Open Academy, самая крупная биржа Binance и их совместный курс по фьючерсам!

Как принять участие, заработать $15 в BNB, доход от рефералов и получить сертификат.

Что мне понравилось:

1. Можно указать свою рефку на Бинансе прямо в курсе и приглашать рефералов в Open Academy. А те, регистрируясь в Binance, станут вашими рефералами и там.
Это даст доп. доход в случае их торговли.

2. Также вы сможете получить 15 $ в $BNB, завершив изучение курса с квестами до 27 ноября 19:00 по МСК.
Важное условие: нужен торговый объём в размере "$1000" на Binance Futures.

Проходите всего 10 уроков длительностью от 2 до 4 минут, и вы сможете получить бонусы + сертификат!

Изучать

P. S. Если вы в РФ, KYC (проверку личности) можно пройти только на загран-паспорт и выписку из банка с подтверждением адреса.

😎 Незрячий web3 программист (подписаться)
Чат | бот

📟 Прилетело из @blind_dev

🏛How stablecoins work

Привет подписчики! Сегодня я поделюсь с вами своими познаниями о стейблкоинах. Как работают известные вам проекты и как крутится ДеФи маховик. Если вам эти слова уже начинают быть непонятными - спросите их значение у чатгпт. Ну а для более осведомленных товарищей - прошу к прочтению

Также не забывайте ставить реакции, я так хотяб буду понимать что вам нравится, а что нет, ну и комментарии пишите, я на них иногда стараюсь отвечать👀

Ps. Все написанно в статье исключительно мое мнение. Если вы с ним не согласны - прошу в комментарии

А теперь читать статью
Статья, Статья, Статья!!!

📟 Прилетело из @ortomich_main

Токен $0G рухнул с $ 7.05 до около $ 1.3. Почему так произошло: попробуем найти причину.

Проект 0G - это L1 модульный блокчейн для ИИ с масштабированием уровнем доступности данных для производительности.

Источник данных: Tokenomist.

всего - 1 МЛРД $0G.
Разблокировано 24% (62.05% в локе, 14.29% TBD).

Распределение:

1. Ecosystem Growth - 28% (разблокировано 14.3% от всех токенов).
49% от выделенных на эту категорию токенов было разблокировано на TGE, но уже прошло некоторое время - стало чуть больше.
Разблокировка на 24 месяца.
Это, как понимаю, финансирование развития экосистемы: разных приложений.
С точки зрения поддержки развития существенная доля. Но стоит учитывать, что непонятно качество распределения.
Я читал у одного человека про проекты 0G экосистемы - не впечатлили.

+ остаётся ещё существенная часть в локе, которая может давить на курс.

2. AI Alignment Node - 15%.
33% выдаются на TGE (10% без штрафа, 23% - с возможностью уменьшить штраф при ожидании до 360 дней).
Оставшиеся 67% идут в линейный вестинг на 36 месяцев.
Это за запуск ноды и за наличие nft-нод.

В частности, я участвовал в этом. Но вывел всё доступное со штрафом, и рад этому.

Возможно также, что выше указанные условия идут от 12.9%, так как выше таблицы указана именно эта доля, а 2.1% как TBD (ещё не определено).

3. Community Rewards - 13%.
20% (2.6% от всех) токенов распределено на TGE, остальное распределяется сезонно в течение 48 месяцев.
Это по всей видимости награды сообществу. Возможно это за стейкинг, а возможно и за что-то ещё.

Что касается разлоков - это примерно 0.2-0.3% в месяц от всех токенов.

4. Team Contributors & Advisors - 22%.
Многовато (> 10%).
Заблокирован на 12 месяцев, разблокировка 36 месяцев
Но странно, что в Cryptorank видел уже наличие разлоченных токенов команды в размере 5.5%.
Хотя там источник странный был указан, поэтому не стал упоминать.

5. Backers - 22%.
Как понимаю это инвесторы. Многовато - максимум 10%.
Заблокирован на 12 месяцев, разблокируется в течение на 36 месяцев


Утилиты $0G:

Источник: статья.

1. Оплата вычислений и хранения
Токен используется как Газ сети 0G: оплата вычислений, хранения данных, операций смарт-контрактов и работы AI-движка Zero Gravity Executor.
2. Стейкинг нод
Валидаторы и AI Alignment Nodes стейкают $0G, чтобы участвовать в консенсусе, выполнять вычисления и обеспечивать безопасность сети.
3. Вознаграждение валидаторов и AI-нод
Награды выплачиваются в $0G за выполнение вычислений, проверку данных, хранение, генерацию результатов AI и обеспечение работы сети.
4. Governance (управление протоколом)
Холдеры участвуют в голосованиях: параметры сети, обновления протокола, распределение Ecosystem Growth Fund, правила AI-alignment.
5. Оплата AI-моделей, сервисов и агентов
$0G используется внутри экосистемы для оплаты выполнения AI-задач, инференса моделей, запросов к AI-агентам и сервисам поверх L1.
6. Стимулирование экосистемы
Все гранты, airdrop-вознаграждения, кампании роста, награды разработчикам и строителям экосистемы выплачиваются в $0G.


Итог:

Основное давление от экосистемы и аэрдропа за ноды.

Думаю проектов не так много, чтоб выделять им 14.3% от всех токенов - это приводит скорее к сливу по рыночной цене, что мы и видим в результате (падение на 81.56% 13 ноября).
Но утилиты хорошие: если проект станет популярным, если появятся известные продукты может появиться спрос на $0G = возможен в это случае рост.
Но вероятность этого к сожалению мала.

Как вам проект и токен? Держите ли его?
Я забил. Откупать не планирую.

Буду рад реакциям, комментариям и репостам.

😎 Незрячий web3 программист (подписаться)
Чат | бот

📟 Прилетело из @blind_dev