Войти или зарегистрироваться

Друзья, в это тяжёлое и непонятное для всех нас время мы просим вас воздержаться от любых упоминаний политики на форуме, - этим ситуации не поможешь, а только возникнут ненужные ссоры и обиды. Это касается также шуток и юмора на тему конфликта. Пусть войны будут только виртуальными, а политики решают разногласия дипломатическим путём. С уважением, администрация Old-Games.RU.
Скрыть объявление
Пожалуйста, внимательно прочитайте правила раздела.
Если Вы видите это сообщение, значит, вы ещё не зарегистрировались на нашем форуме.

Зарегистрируйтесь, если вы хотите принять участие в обсуждениях. Перед регистрацией примите к сведению:
1. Не регистрируйтесь с никами типа asdfdadhgd, 354621 и тому подобными, не несущими смысловой нагрузки (ник должен быть читаемым!): такие пользователи будут сразу заблокированы!
2. Не регистрируйте больше одной учётной записи. Если у вас возникли проблемы при регистрации, то вы можете воспользоваться формой обратной связи внизу страницы.
3. Регистрируйтесь с реально существующими E-mail адресами, иначе вы не сможете завершить регистрацию.
4. Обязательно ознакомьтесь с правилами поведения на нашем форуме, чтобы избежать дальнейших конфликтов и непонимания.
С уважением, администрация форума Old-Games.RU
Скрыть объявление

Нейросети и прочие ИИ

Тема в разделе "Флейм", создана пользователем GreenEyesMan, 23 дек 2022.

Метки:

?

А вы бы хотели, чтобы вашу работу отдали роботу?

Да.

4 голосов

3,5%
Да, конечно!

12 голосов

10,6%
Разумеется!

4 голосов

3,5%
А у меня есть выбор?

32 голосов

28,3%
Пусть он еще и гуся (кота, жену, мужа, ребенка, - нужное подчеркнуть) моего заберет?

4 голосов

3,5%
Я бы хотел сказать "Нет", но если подумать...

5 голосов

4,4%
Ну попробуйте, отдайте мою работу роботу, а я посмотрю.

52 голосов

46,0%

Страница 95 из 126

DJKrolik

Регистрация:

22 сен 2005

Сообщения:

6.708

Gaznak сказал(а): ↑

ВПС
Нажмите, чтобы раскрыть...

VPS/VDS?
Электронная музыка полностью или частично НЕ исполняется, и никакой разницы нет, дома кто-то ее пишет или на сцене стоит и лупы переключает.
Докопаться можно и до электрогитар с усилками, давайте чтобы честно, без электричества? А то, понимаешь, зажал струну и у него 10 минут музыка играет сама.

Если ваш концерт не похож на это, даже не пытайтесь меня приглашать

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

DJKrolik, 24 мар 2025

#1881

Kristobal Hozevich Hunta нравится это.
DJKrolik

Регистрация:

22 сен 2005

Сообщения:

6.708

Мде, DeepSeek разочаровывает в плане конкретики и фактов. Он не узнает даже игры 2020-2022 годов, нишевые и не сильно распиаренные. Начинает писать отсебятину.
Я попросил накидать краткий обзор игры Mothered, он сочинил шизо статью про выдуманную игру, причем приписал ее авторство Raising Hell Games почему-то, сам текст просто описание выдуманной игры, кстати нельзя сказать что шиза неинтересная, но ведь запрос был совершенно конкретный.

Grok продолжает писать "CMS мечты", в отличие от других чат не прерывается на самом интересном месте, хотя конечно начинает тормозить, когда уже несколько дней идет доработка. Впечатляет очень сильно. CMS такая обычная, создание постов, пользователи, комментарии. Например, создание поста: уже добавил все стандартные поля, создал и прикрутил WYSIWYG редактор, галерею сделал, скоро буду ее допиливать чтобы было идеально, но уже есть простая загрузка до 10 картинок, с возможностью удалить сразу некоторые и поменять порядок. Хочу сделать чтобы фотки грузились в определенные папки и подпапки - пожалуйста.
Лайки дизлайки, избранное, простейшая но наглядная система уведомлений (похожая на ту которая на OG).
И так далее. В общем, дико доставляет процесс. Например, чтобы сделать все именно так, как оно есть сейчас, на Вордпрессе - мне как минимум пришлось бы уже пересмотреть и установить кучу плагинов, настроить их и еще гуглить инфу про мелкие допиливания под себя. Те же комменты на ВП реализовать - это будет проблематично. А тут всё крайне персонализированно, все хотелки исполняются.
Конечно есть вопросы с оптимизацией, архитектурой (разделением кода) и т.д. Но мне нравится как решаются проблемы, например, с БД, когда возникли трудности с удалением таблицы: нашел кучу похожих тем на stackoverflow, но надо было еще адаптировать к своей ситуации, опять же есть устаревшие топики, а Grok прямо пошагово дает инструкцию, запросы пишет к БД, если не получается решить проблему дает код для вывода ошибок, короче вообще помогает как может.

DJKrolik, 26 мар 2025

#1882
Kristobal Hozevich Hunta Реликтовый гоминид

Регистрация:

24 апр 2006

Сообщения:

1.350

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

Kristobal Hozevich Hunta, 26 мар 2025

#1883

MrFlibble и DJKrolik нравится это.
DJKrolik

Регистрация:

22 сен 2005

Сообщения:

6.708

@Kristobal Hozevich Hunta, о, в сериале Миссис Дэвис похожий сюжетец:
Offtop
Программистка написала приложение для сети куриных крылышек, но его не приняли, он выложила в открытый доступ, и в итоге приложуха развилась до уровня практически полного управления людьми.

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

DJKrolik, 26 мар 2025

#1884

Kristobal Hozevich Hunta нравится это.
Kristobal Hozevich Hunta Реликтовый гоминид

Регистрация:

24 апр 2006

Сообщения:

1.350

@DJKrolik, для начала пусть попробуют на Огайо ))

Kristobal Hozevich Hunta, 26 мар 2025

#1885
Дмитрий Токмашов

Регистрация:

21 июн 2021

Сообщения:

550

Попробовал установить локальную LLM на бесплатный движок Godot. Результат интересный, я бы даже сказал впечатляющий для файла на 6 гигабайт, который не требует никакой связи с внешним миром. Попробую создать что-то типа демоверсии первого Fallout: небольшая локация с историей, несколько NPC и возможность для них и игрока взаимодействовать друг с другом и окружающим миром. Посмотрим, насколько живее будет играться такой тип RPG в сравнении со старыми, много ли даст игровому процессу возможность живого общения с обитателями мира.

Дмитрий Токмашов, 27 мар 2025

#1886
Ogr 2 лол

Хелпер Переводчик

Регистрация:

25 мар 2008

Сообщения:

6.784

Дмитрий Токмашов сказал(а): ↑

установить локальную LLM на бесплатный движок Godot.
Нажмите, чтобы раскрыть...

Есть аналогичный мод на скайрим:

Ogr 2, 27 мар 2025

#1887
Дмитрий Токмашов

Регистрация:

21 июн 2021

Сообщения:

550

Ogr 2 сказал(а): ↑

аналогичный мод
Нажмите, чтобы раскрыть...

То, что я пока видел, делает упор на поверхностную симуляцию живости, но в сути своей по большей части остаётся тем же чатом (максимум интерактивности, мной замеченный — когда NPC вынул меч из ножен в ответ на ругательства в его адрес) нанизанным на практически стандартных NPC. А я хотел бы запрячь ИИ именно в полноценное управление NPC, чтобы каждый житель небольшого поселения вёл свою жизнедеятельность в соответствии с прописанной ролью. Ну и для реального времени пока слабоваты мощности одновременно для LLM и T2S генераций, так что вариант текстового общения из классических RPG, мне кажется, будет выглядеть более органичным.

Дмитрий Токмашов, 27 мар 2025

#1888

DJKrolik нравится это.
DJKrolik

Регистрация:

22 сен 2005

Сообщения:

6.708

@Дмитрий Токмашов,
Я про нечто подобное писал.
Хорошо прописать роли потребует больших усилий.

--- добавлено 28 мар 2025, предыдущее сообщение размещено: 28 мар 2025 ---

Регулярные выражения - всё. Проще самый зубодробительный запрос написать в чатгпт и с высокой вероятностью с первого раза сделает.
Подозреваю что и формулы в экселе тоже всё.

DJKrolik, 28 мар 2025

#1889
Gamerun

Хелпер

Регистрация:

13 июн 2010

Сообщения:

9.224
Попробовал во второй раз написать простенькую программу-скрипт для работы с psd файлами и слоями. Некоторое время назад мне попалось несколько, у которых портятся цвета при открытии где-либо (Photoshop, онлайн-редакторы с поддержкой формата). Единственные программы, которые открывают их правильно - IrfanView и XnView MP, но у них нет средств для просмотра и активации/деактивации слоев как у Photoshop (у XnView MP вместо этого просмотр каждого слоя отдельно как у TIFF, что не то). Однако и со скриптом от ИИ, после всех правок, вышел провал - не то psd-tools, не то PIL используют, как мне кажется, повсеместный код работы с данным форматом, отчего цвета портятся как и везде.
Попытка проанализировать разницу между двумя psd (у одного цвета портятся, у другого нет) также не увенчалась успехом.
Оба скрипта во вложении.

Также попробовал спросить у ИИ про возможности создания плагина для IrfanView (мне лично он кажется более удобным).
Их ответы:
Qwen

Yes, it is technically possible to write a plugin for IrfanView that adds the ability to view layers in PSD files and allows users to activate or deactivate each layer separately. However, creating such a plugin requires a solid understanding of both the IrfanView plugin architecture and the PSD file format. Below, I will outline the steps and considerations for developing such a plugin.

---

### **1. Understand IrfanView Plugin Architecture**
IrfanView supports plugins written in C or C++ that conform to its plugin API. The plugin must:
- Be compiled as a DLL (Dynamic Link Library) on Windows.
- Export specific functions that IrfanView expects, such as `Info` and `Show`.
- Handle file loading, rendering, and user interface interactions.

The IrfanView SDK provides documentation and examples for creating plugins. You can download the SDK from the official IrfanView website.

---

### **2. Parse PSD Files**
To work with PSD files, you need to parse their structure. The PSD file format is well-documented by Adobe:
- Layers are stored in the "Layer and Mask Information" section of the file.
- Each layer has visibility flags, blend modes, and pixel data.
- Embedded resources like ICC profiles and metadata may also need to be handled.

You can use existing libraries (e.g., `psd-tools` in Python) as a reference to understand how to parse PSD files. However, since IrfanView plugins are typically written in C/C++, you would need to implement the parsing logic in those languages.

---

### **3. Design the Plugin Functionality**
The plugin should provide the following features:
1. **Load PSD Files**:
- Detect PSD files when opened in IrfanView.
- Parse the file to extract layers and their properties.
2. **Display Layers**:
- Render the composite image with all visible layers.
- Allow toggling the visibility of individual layers.
3. **User Interface**:
- Add a custom dialog or panel within IrfanView to display the list of layers.
- Provide checkboxes or similar controls to toggle layer visibility.
4. **Export Options**:
- Optionally allow exporting the modified PSD or saving the composite image as a new file.

---

### **4. Implementation Steps**
Here’s a high-level breakdown of the implementation:

#### **Step 1: Set Up the Plugin Framework**
- Create a new C/C++ project and include the IrfanView SDK headers.
- Implement the required plugin functions:
- `Info`: Provides metadata about the plugin (e.g., supported file types).
- `Show`: Handles the main functionality of the plugin.

#### **Step 2: Parse the PSD File**
- Implement a PSD parser to extract:
- Layer names, visibility flags, and pixel data.
- Composite image dimensions.
- Use the parsed data to render the visible layers.

#### **Step 3: Render the Image**
- Use GDI+ or another graphics library to render the composite image in IrfanView.
- Recompute the composite image whenever the user toggles layer visibility.

#### **Step 4: Add a Layer Management UI**
- Create a dialog box or sidebar using WinAPI or a GUI library compatible with IrfanView.
- Display the list of layers with checkboxes for visibility control.
- Update the rendered image dynamically when the user interacts with the UI.

#### **Step 5: Handle Exporting**
- Allow the user to save the modified PSD file or export the composite image as PNG/JPG.

---

### **5. Challenges**
- **Complexity of PSD Parsing**: The PSD format is complex, and implementing a robust parser from scratch can be time-consuming. Consider reusing open-source libraries (if licensing permits) or writing bindings to existing libraries.
- **Performance**: Rendering large PSD files with many layers can be computationally expensive. Optimize the rendering process to ensure smooth performance.
- **Integration with IrfanView**: Ensure the plugin adheres to IrfanView's API requirements and does not conflict with other plugins.

---

### **6. Example Code Snippet**
Below is a simplified example of how the plugin might look in C++:

```cpp
#include "i_view.h" // IrfanView plugin header

// Plugin metadata
extern "C" __declspec(dllexport) int Info(int infono) {
switch (infono) {
case INFO_NAME: return (int)"PSD Layer Viewer";
case INFO_EXT: return (int)"PSD";
case INFO_TYPE: return TYPE_MULTI;
default: return 0;
}
}

// Main plugin function
extern "C" __declspec(dllexport) int Show(HWND hwndParent, char* filename) {
try {
// Load and parse the PSD file
PSDFile psd(filename);
if (!psd.isValid()) {
MessageBox(hwndParent, "Invalid PSD file!", "Error", MB_OK);
return 0;
}

// Create a dialog to manage layers
LayerDialog dialog(hwndParent, psd);
if (dialog.DoModal() == IDOK) {
// Render the composite image with selected layers
psd.renderVisibleLayers();
psd.displayInIrfanView();
}
} catch (const std::exception& e) {
MessageBox(hwndParent, e.what(), "Error", MB_OK);
return 0;
}
return 1;
}
```

---

### **7. Tools and Libraries**
- **IrfanView SDK**: For plugin development.
- **PSD Parsing Libraries**:
- Use an existing library like `libpsd` (C/C++) or write your own parser.
- **Graphics Libraries**:
- Use GDI+, Cairo, or OpenGL for rendering.

---

### **8. Licensing Considerations**
Ensure that your plugin complies with the licensing terms of any third-party libraries you use. For example:
- If you use `psd-tools` or similar libraries, check their licenses (e.g., MIT, GPL).
- Distribute the plugin under a compatible license.

---

### **9. Testing**
- Test the plugin with a variety of PSD files, including those with complex layer structures, masks, and blending modes.
- Verify compatibility with different versions of IrfanView.

---

### **Conclusion**
Creating an IrfanView plugin to view and manage PSD layers is feasible but requires careful planning and implementation. By leveraging existing PSD parsing libraries and adhering to IrfanView's plugin API, you can develop a functional and user-friendly tool. If you are not experienced with C/C++, consider collaborating with a developer familiar with these technologies.
Нажмите, чтобы раскрыть...

DeepSeek

Yes, it is possible to write a plugin for **IrfanView** that adds support for viewing **PSD (Photoshop) files with layers**, including the ability to toggle individual layers on/off. However, there are some technical considerations:

### **1. Current PSD Support in IrfanView**
- By default, IrfanView can open **flattened** PSD files (merged layers) using its built-in PSD plugin.
- It does **not** natively support layer visibility toggling.

### **2. Developing a Custom PSD Plugin**
To add layer support, you would need to:
- **Parse the PSD file structure** (Adobe’s PSD format is documented).
- **Extract layer data** (including layer masks, blend modes, etc.).
- **Render a composite preview** dynamically based on layer visibility.
- **Provide a UI** (dialog or sidebar) to toggle layers.

#### **Possible Approaches:**
- **Use an existing PSD library** (e.g., LibPSD, Photoshop File Format SDK, or FreeImage).
- **Write a C/C++ DLL plugin** (IrfanView plugins are typically written in C/C++).
- **Integrate with .NET via COM** (if IrfanView allows it, though native C is preferred).

### **3. Challenges**
- **PSD Format Complexity**: Photoshop files can have many features (adjustment layers, smart objects, etc.).
- **Performance**: Rendering layers dynamically may be slow for large PSDs.
- **UI Integration**: IrfanView’s plugin API may not easily support custom layer management UIs.

### **4. Alternatives**
If writing a plugin seems too complex, consider:
- **Using XnView MP** (supports PSD layers natively).
- **Converting PSD to TIFF/PNG with layers** before opening in IrfanView.
- **Requesting the feature** from Irfan Skiljan (IrfanView’s developer).

### **Conclusion**
Yes, it’s technically possible, but requires **significant effort** unless you leverage an existing PSD library. If you're comfortable with C/C++ and the PSD file format, you could develop such a plugin. Otherwise, using alternative viewers may be more practical.

Would you like guidance on specific parts (e.g., PSD parsing or IrfanView’s plugin API)?
Нажмите, чтобы раскрыть...

Grok

Yes, it is technically possible to write a plugin for IrfanView that adds the ability to view and manipulate layers in PSD (Photoshop Document) files, including the option to activate or deactivate each layer separately. However, there are several factors to consider regarding feasibility, implementation, and limitations.

IrfanView supports the development of custom plugins by third-party developers to extend its functionality, such as adding support for new file formats or introducing new features. The official IrfanView website states that developers interested in creating plugins can contact the author, Irfan Skiljan, for details on how to proceed. This indicates that the necessary framework and documentation exist to create such a plugin.

Currently, IrfanView can open PSD files and display a flattened version of the image, which is typically the composite of all layers as stored in the PSD file. However, it does not natively provide a way to view or toggle individual layers. A plugin could theoretically address this by:

1. **Parsing the PSD File Format**: PSD is a well-documented format (Adobe provides specifications), and a plugin could read the layer information, including layer visibility states, masks, and pixel data.
2. **Rendering Layers**: The plugin would need to render each layer independently and allow the user to toggle visibility, similar to how multi-page TIFF files are handled in IrfanView (where users can navigate between pages).
3. **User Interface**: A custom dialog or panel could be implemented within IrfanView to list layers and provide checkboxes or buttons to activate/deactivate them.
4. **Integration**: The plugin would integrate with IrfanView’s existing architecture, likely using its plugin API to hook into file loading and display processes.

Challenges to consider include:
- **Complexity**: PSD files can contain complex features (e.g., adjustment layers, layer effects, blending modes) that might be difficult to fully support in IrfanView’s lightweight framework.
- **Performance**: IrfanView is designed to be fast and lightweight, so rendering multiple layers dynamically could impact performance, especially for large files.
- **Development Effort**: Writing and maintaining such a plugin would require significant time and expertise in both PSD file handling and IrfanView’s plugin system.

While possible, no such plugin currently exists publicly for IrfanView, likely because advanced layer manipulation is typically handled by full-featured editors like Photoshop or GIMP. If you’re a developer interested in pursuing this, you could start by contacting Irfan Skiljan for the plugin development details and studying the PSD file format specification. Alternatively, for end-users seeking this functionality, software like GIMP (which supports PSD layers natively) might be a more immediate solution.
Нажмите, чтобы раскрыть...
Вложения:
- PSD_Tool_Grok_Qwen.rar
  
  Размер файла:
  
  4,6 КБ
  
  Просмотров:
  
  7
- PSD_Compare.rar
  
  Размер файла:
  
  2,3 КБ
  
  Просмотров:
  
  7
Gamerun, 28 мар 2025

#1890

DJKrolik и Forgettable нравится это.
Forgettable

Редактор Хелпер

Регистрация:

3 авг 2019

Сообщения:

9.910
Парсер rar-архивов. Открывает все rar в папке и дает подробную статистику по ним в csv. Требуется WinRAR по дефолтному пути.

Сводка анализа:
Всего архивов: 945
Общий размер архивов: 1.44 TB
Общий размер содержимого: 1.62 TB
Средний процент сжатия: 90.97%

Полный отчет сохранен в: rar_analysis_20250329_022348.csv
Нажмите, чтобы раскрыть...

Выпрошено у Deepseek)
Вложения:
- rar.py.rar
  
  Размер файла:
  
  4,1 КБ
  
  Просмотров:
  
  14
Forgettable, 29 мар 2025

#1891

DJKrolik и Gamerun нравится это.
DJKrolik

Регистрация:

22 сен 2005

Сообщения:

6.708

Я вчера в дипсик данные из кучи pdf файлов собрал в один json, а потом в каждую запись массива добавил соответствующие данные из кучи других pdf.
Единственный минус - с большими объемами дипсик не стал работать, пришлось порционно скармливать.

DJKrolik, 29 мар 2025

#1892
Gamerun

Хелпер

Регистрация:

13 июн 2010

Сообщения:

9.224

Оставлю себе в качестве памятки информацию по настройке AUTOMATIC1111 и Forge.
Вопрос

Can I use stable-diffusion-webui ( https://github.com/AUTOMATIC1111/stable-diffusion-webui ) and stable-diffusion-webui-forge ( https://github.com/lllyasviel/stable-diffusion-webui-forge ) on system with next specs:

```OS - Windows 10 Pro, 22H2, x64, 19045.5131
CPU - Intel Core i5 13500H (13th Gen), Raptor Lake, Socket 1744 FCBGA, 2.60Ghz, Cores 4P + 8E, Threads 16
Motherboard - THUNDEROBOT NLXB, Type2Version, PCI-e 5.0 (32.0 GT/s)
Memory - DDR4, 64GB, 2 x 64-bit (Slot 1 - Kingston DDR4-3200, 1600 Mhz, 32GB; Slot 2 - Kingston DDR4-3200, 1600 Mhz, 32GB)
GPU 1 - Intel Iris Xe Graphics, Revision 4
GPU 2 - NVIDIA GeForce RTX 4050 Laptop GPU, AD107, A1, 5nm, 6GB GDDR6, Samsung, 96 bits bus width, GFX Core 210 Mhz, Memory 405 Mhz```

And would these commands help to optimise for launch?:
```CPU
set COMMANDLINE_ARGS=--precision full --no-half --use-cpu all --skip-torch-cuda-test
set CUDA_VISIBLE_DEVICES=-1

GFX
set COMMANDLINE_ARGS=--xformers

\\\\\\\\\\
set COMMANDLINE_ARGS=--precision full --no-half --use-cpu all --skip-torch-cuda-test
set CUDA_VISIBLE_DEVICES=-1
_set COMMANDLINE_ARGS=--xformers
set COMMANDLINE_ARGS= --deepdanbooru

--opt-sub-quad-attention --lowvram --xformers --opt-split-attention-v1

CPU
--precision autocast --no-half --use-cpu all```
Нажмите, чтобы раскрыть...

Ответы
Grok

Yes, you can use both **stable-diffusion-webui** (AUTOMATIC1111) and **stable-diffusion-webui-forge** on your system with the specified hardware. Your setup meets the minimum requirements and should be capable of running these tools effectively, especially given the NVIDIA RTX 4050 GPU with 6GB GDDR6 VRAM and the robust 64GB of DDR4 RAM. Below, I’ll break down compatibility and analyze the optimization commands you’ve provided to help you configure them for your system.

---

### System Compatibility

#### Hardware Specs
1. **OS**: Windows 10 Pro (22H2, x64) is fully supported by both AUTOMATIC1111 and Forge versions of Stable Diffusion WebUI.
2. **CPU**: Intel Core i5-13500H (12 cores: 4P + 8E, 16 threads) is more than sufficient for CPU-based tasks and can handle preprocessing or fallback operations if needed.
3. **Memory**: 64GB DDR4 RAM is excellent and exceeds the typical requirements (8GB minimum, 16GB+ recommended). This will help with larger batch sizes and multitasking.
4. **GPU**:
- **NVIDIA RTX 4050 (6GB GDDR6)**: This is a capable GPU for running Stable Diffusion. The 6GB VRAM is on the lower side for some high-resolution SDXL models, but it’s sufficient for SD 1.5 models and optimized setups (especially with Forge, which is designed to be more VRAM-efficient). The RTX 4050 supports CUDA, which is critical for GPU acceleration in PyTorch.
- **Intel Iris Xe Graphics**: This integrated GPU cannot effectively run Stable Diffusion due to its limited VRAM and lack of CUDA support. You’ll want to rely solely on the RTX 4050.

#### Software Requirements
- Both repositories require **Python** (3.10.6 recommended for AUTOMATIC1111; Forge may tolerate newer versions but sticking to 3.10.6 is safest) and **Git** installed.
- You’ll need to install **PyTorch** with CUDA support for the RTX 4050. Given the 40-series GPU, PyTorch 2.0+ with CUDA 11.8 or 12.x is recommended for optimal performance.
- AUTOMATIC1111 and Forge both support Windows and NVIDIA GPUs natively, so no major compatibility issues arise.

#### Key Considerations
- **AUTOMATIC1111**: Works well with your setup but may require optimization flags for the 6GB VRAM limit, especially for SDXL or high-resolution outputs.
- **Forge**: Specifically designed to be faster and more VRAM-efficient, making it an excellent choice for your RTX 4050. You might see noticeable speed improvements (up to 60-75% faster with 6GB VRAM, per Forge’s claims).

---

### Analyzing Your Optimization Commands

You’ve provided several `COMMANDLINE_ARGS` configurations, some tailored for CPU and others for GPU usage. Let’s evaluate and refine them based on your hardware:

#### Your Commands Breakdown
1. **CPU-Oriented Commands**:
```
set COMMANDLINE_ARGS=--precision full --no-half --use-cpu all --skip-torch-cuda-test
set CUDA_VISIBLE_DEVICES=-1
```
- **`--precision full`**: Forces full-precision (FP32) computation instead of mixed precision. This increases VRAM and RAM usage and slows performance but may improve stability on CPU-only setups.
- **`--no-half`**: Disables FP16 (half-precision), aligning with `--precision full`. Unnecessary with your RTX 4050 unless you encounter compatibility issues.
- **`--use-cpu all`**: Forces all computation onto the CPU, bypassing the GPU entirely. This defeats the purpose of having an RTX 4050 unless you’re troubleshooting GPU issues.
- **`--skip-torch-cuda-test`**: Skips CUDA availability checks, useful if you’re forcing CPU mode or troubleshooting.
- **`set CUDA_VISIBLE_DEVICES=-1`**: Disables CUDA entirely, ensuring CPU-only operation.

**Verdict**: This setup is for CPU-only operation and negates your GPU’s potential. Avoid this unless your GPU fails to work.

2. **GFX-Oriented Command**:
```
set COMMANDLINE_ARGS=--xformers
```
- **`--xformers`**: Enables the xFormers library for optimized attention mechanisms, reducing VRAM usage and speeding up generation. Highly recommended for your RTX 4050.

**Verdict**: Good choice for GPU acceleration, but incomplete on its own.

3. **Mixed/Conflicting Commands**:
```
set COMMANDLINE_ARGS=--precision full --no-half --use-cpu all --skip-torch-cuda-test
set CUDA_VISIBLE_DEVICES=-1
_set COMMANDLINE_ARGS=--xformers
set COMMANDLINE_ARGS= --deepdanbooru
```
- **`--deepdanbooru`**: Enables DeepDanbooru for anime-style image tagging. This is a feature flag, not an optimization, and works fine with GPU setups.
- **Conflict**: Combining CPU-forcing flags (`--use-cpu all`, `CUDA_VISIBLE_DEVICES=-1`) with GPU-specific flags (`--xformers`) is contradictory. The last `set` command overwrites previous ones in a batch file, so only `--deepdanbooru` would apply here unless you concatenate them properly.

**Verdict**: This mix is confusing and likely a typo. Clarify your intent (CPU or GPU).

4. **Additional Optimization Flags**:
```
--opt-sub-quad-attention --lowvram --xformers --opt-split-attention-v1
```
- **`--opt-sub-quad-attention`**: Optimizes attention computation, reducing VRAM usage. Experimental but potentially beneficial for 6GB VRAM.
- **`--lowvram`**: Optimizes for low-VRAM GPUs (<8GB), offloading more to system RAM. Ideal for your RTX 4050.
- **`--opt-split-attention-v1`**: An older optimization for attention splitting, less efficient than xFormers but still reduces VRAM usage.

**Verdict**: These are solid options for your 6GB GPU, especially `--lowvram` and `--xformers`.

5. **Another CPU Variant**:
```
--precision autocast --no-half --use-cpu all
```
- **`--precision autocast`**: Uses mixed precision selectively (unlike `--precision full`). Better for performance but still CPU-focused here.

**Verdict**: Again, CPU-only and not ideal for your GPU.

---

### Recommended Configuration

Since you have an RTX 4050, you should leverage GPU acceleration rather than forcing CPU usage. Here’s a tailored setup for both AUTOMATIC1111 and Forge:

#### For AUTOMATIC1111
```bat
set COMMANDLINE_ARGS=--xformers --lowvram --opt-sub-quad-attention
```
- **`--xformers`**: Speeds up attention and reduces VRAM usage.
- **`--lowvram`**: Optimizes for your 6GB VRAM, offloading to your ample 64GB RAM as needed.
- **`--opt-sub-quad-attention`**: Further VRAM savings, experimental but worth trying.

#### For Forge
```bat
set COMMANDLINE_ARGS=--xformers --lowvram
```
- Forge already includes backend optimizations (e.g., reworked U-Net), so fewer flags are needed. `--xformers` and `--lowvram` should suffice for your setup.
- Optionally add `--opt-sub-quad-attention` if you notice VRAM issues with SDXL models.

#### Additional Tips
- **Batch Size**: Start with a batch size of 1 or 2 for 512x512 images to avoid VRAM overflow. Your 64GB RAM helps with larger batches if `--lowvram` is enabled.
- **Resolution**: Stick to 512x512 or 768x768 for SD 1.5 models. SDXL at 1024x1024 may require further tweaking (e.g., `--medvram` instead of `--lowvram`).
- **PyTorch Setup**: Ensure PyTorch is installed with CUDA 11.8 or 12.x:
```bash
pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cu118
```
- **Troubleshooting**: If you encounter CUDA errors, add `--skip-torch-cuda-test` temporarily to diagnose.

---

### Expected Performance
- **AUTOMATIC1111**: With SD 1.5 models at 512x512, expect ~5-10 iterations/second (it/s) depending on sampler and settings. SDXL will be slower and may need `--medvram`.
- **Forge**: Likely 30-75% faster than AUTOMATIC1111 (per Forge claims for 6GB VRAM), so ~7-15 it/s for SD 1.5. SDXL should be more manageable thanks to Forge’s optimizations.

---

### Conclusion
Your system is well-suited for both tools, with the RTX 4050 being the key component. Use the GPU-optimized flags above, avoiding CPU-only setups unless absolutely necessary. Forge may give you a performance edge, especially with your 6GB VRAM, so I’d recommend testing it first. Let me know if you need help with installation or further tweaking!
Нажмите, чтобы раскрыть...

Qwen

### Analysis of Your System Specifications and Compatibility

#### 1. **System Overview**
Your system is equipped with:
- **CPU**: Intel Core i5-13500H (Hybrid architecture with 4 Performance cores and 8 Efficient cores, 16 threads total).
- **GPU**: NVIDIA GeForce RTX 4050 Laptop GPU (6GB GDDR6, 96-bit bus width).
- **RAM**: 64GB DDR4 (dual-channel configuration).
- **Integrated GPU**: Intel Iris Xe Graphics.

The RTX 4050 is a mid-range laptop GPU based on the Ada Lovelace architecture. While it has limited VRAM (6GB), it supports CUDA and modern deep learning frameworks like PyTorch, which are essential for running Stable Diffusion models.

#### 2. **Software Requirements**
Both `stable-diffusion-webui` and `stable-diffusion-webui-forge` rely on PyTorch and CUDA for GPU acceleration. The RTX 4050 supports CUDA, so GPU acceleration is feasible. However, the limited VRAM (6GB) may restrict the size of models you can run efficiently.

#### 3. **Compatibility**
- **Stable Diffusion WebUI**: This is compatible with your system as long as you have the correct dependencies installed (Python, CUDA toolkit, PyTorch, etc.).
- **Stable Diffusion WebUI Forge**: This is a fork of the original WebUI with additional optimizations. It should also work on your system, but the same VRAM limitations apply.

### Optimization Commands Analysis

#### **CPU-Only Mode**
The following commands force the application to use the CPU instead of the GPU:
```cmd
set COMMANDLINE_ARGS=--precision full --no-half --use-cpu all --skip-torch-cuda-test
set CUDA_VISIBLE_DEVICES=-1
```
- **Explanation**:
- `--precision full`: Uses full precision (FP32) instead of mixed precision (FP16). This is slower but avoids potential numerical instability.
- `--no-half`: Disables FP16 operations, ensuring full precision.
- `--use-cpu all`: Forces all computations to run on the CPU.
- `--skip-torch-cuda-test`: Skips CUDA compatibility checks.
- `CUDA_VISIBLE_DEVICES=-1`: Hides all CUDA devices, effectively disabling GPU usage.

- **Use Case**: These settings are useful if your GPU is unavailable or if you encounter issues with CUDA. However, CPU-only mode will be significantly slower than GPU acceleration, even with your powerful i5-13500H.

#### **GPU-Optimized Mode**
The following commands optimize performance for GPU usage:
```cmd
set COMMANDLINE_ARGS=--xformers
```
- **Explanation**:
- `--xformers`: Enables the xFormers library, which optimizes attention mechanisms in transformers. This reduces memory usage and improves speed.

Additional options:
```cmd
--opt-sub-quad-attention --lowvram --xformers --opt-split-attention-v1
```
- **Explanation**:
- `--opt-sub-quad-attention`: Optimizes attention computation by using sub-quadratic methods.
- `--lowvram`: Reduces VRAM usage, allowing larger models to fit within your GPU's 6GB limit.
- `--opt-split-attention-v1`: Splits attention computations to reduce memory overhead.

- **Use Case**: These settings are ideal for leveraging your RTX 4050 GPU while working around its limited VRAM. They are particularly useful for running larger models like SDXL or high-resolution generations.

#### **Mixed Precision Mode**
The following command enables mixed precision (FP16):
```cmd
--precision autocast --no-half --use-cpu all
```
- **Explanation**:
- `--precision autocast`: Uses automatic mixed precision (AMP) to balance performance and memory usage.
- `--no-half`: Disables FP16, which might be redundant here since `autocast` already handles mixed precision.
- `--use-cpu all`: Forces CPU usage, which contradicts the purpose of `autocast`.

- **Use Case**: Mixed precision is beneficial for GPU acceleration but should not be combined with `--use-cpu all`. If you want to use mixed precision, remove the `--use-cpu all` flag.

### Recommendations for Launching

#### **If Using GPU (Preferred Option)**
1. Install the latest CUDA toolkit and cuDNN compatible with your RTX 4050.
2. Use the following command for optimal GPU performance:
```cmd
set COMMANDLINE_ARGS=--xformers --lowvram --opt-split-attention-v1
```
3. Ensure you have sufficient VRAM for the model you intend to run:
- For smaller models (e.g., SD 1.5), 6GB should suffice.
- For larger models (e.g., SDXL), consider reducing resolution or using `--lowvram`.

#### **If Using CPU (Fallback Option)**
1. Use the following command for CPU-only mode:
```cmd
set COMMANDLINE_ARGS=--precision full --no-half --use-cpu all --skip-torch-cuda-test
set CUDA_VISIBLE_DEVICES=-1
```
2. Be prepared for slower generation times compared to GPU acceleration.

### Additional Tips
- **Memory Management**: With 64GB of RAM, you can afford to allocate more memory to the application, especially in CPU-only mode.
- **Model Selection**: Choose models that fit within your GPU's VRAM limits. For example, SD 1.5 is lightweight, while SDXL requires more resources.
- **Updates**: Ensure both the WebUI and Forge forks are updated regularly, as they receive frequent performance improvements.

By following these recommendations, you should be able to run Stable Diffusion WebUI or Forge effectively on your system.

Would be custom resolutions higher than 512x512 like 1536x1536 or 1536x2048 would be work on my specs?
Running custom resolutions higher than the default 512x512 (e.g., 1536x1536 or 1536x2048) on your system is feasible but depends heavily on the available GPU memory (VRAM) and how you configure the Stable Diffusion WebUI. Let’s analyze this in detail based on your hardware specifications.

---

### **Key Factors to Consider**

#### 1. **GPU VRAM Limitations**
Your NVIDIA GeForce RTX 4050 Laptop GPU has **6GB of GDDR6 VRAM**, which is relatively limited for high-resolution image generation. Here's a rough breakdown of VRAM usage for different resolutions:
- **512x512**: Typically requires ~2-3GB of VRAM.
- **1536x1536**: Requires ~8-12GB of VRAM, depending on the model and settings.
- **1536x2048**: Requires ~12-16GB of VRAM, which exceeds your GPU's capacity.

Since your GPU only has 6GB of VRAM, generating images at these resolutions directly will likely result in out-of-memory errors unless you use specific optimizations.

---

#### 2. **Tiling and Memory Optimization**
To work around VRAM limitations, you can use techniques like **tiling** or **memory-efficient attention mechanisms**. These methods divide the image into smaller tiles, process them independently, and then combine the results. This significantly reduces memory usage.

- **Tiling Options**:
- `--lowvram`: Reduces VRAM usage by offloading intermediate computations to system RAM.
- `--medvram`: A middle-ground option that balances VRAM and performance.
- `--attention-split`: Splits attention computations to reduce memory overhead.

- **xFormers**:
- The `--xformers` flag enables the xFormers library, which optimizes attention mechanisms and reduces memory usage. This is highly recommended for high-resolution generation.

---

#### 3. **Batch Size and Model Complexity**
Higher resolutions also increase the computational load. To mitigate this:
- Use a **batch size of 1** (generate one image at a time).
- Stick to smaller models like **Stable Diffusion 1.5** instead of larger ones like SDXL, as they require less memory and compute power.

---

#### 4. **CPU Fallback**
If GPU memory is insufficient even with optimizations, you can fall back to CPU rendering. However, this will be significantly slower, especially for high resolutions.

---

### **Recommended Configuration for High Resolutions**

#### **Using GPU with Optimizations**
To generate images at 1536x1536 or 1536x2048, use the following configuration:

```cmd
set COMMANDLINE_ARGS=--xformers --lowvram --opt-split-attention-v1 --precision autocast
```

- **Explanation**:
- `--xformers`: Enables memory-efficient attention mechanisms.
- `--lowvram`: Reduces VRAM usage by offloading intermediate computations to RAM.
- `--opt-split-attention-v1`: Further reduces memory usage by splitting attention computations.
- `--precision autocast`: Uses mixed precision (FP16) to balance performance and memory usage.

#### **Steps to Follow**:
1. **Start Small**: Begin with a lower resolution (e.g., 768x768) to test stability.
2. **Gradually Increase**: Incrementally increase the resolution while monitoring VRAM usage.
3. **Monitor VRAM**: Use tools like MSI Afterburner or NVIDIA Task Manager to track VRAM usage during generation.

---

#### **Using CPU (Fallback Option)**
If GPU optimizations are insufficient, you can switch to CPU rendering:

```cmd
set COMMANDLINE_ARGS=--precision full --no-half --use-cpu all --skip-torch-cuda-test
set CUDA_VISIBLE_DEVICES=-1
```

- **Performance Expectations**:
- CPU rendering will be much slower, especially for high resolutions.
- With your i5-13500H and 64GB of RAM, it is feasible but not ideal for real-time generation.

---

### **Feasibility Summary**

| Resolution | GPU VRAM Required | Feasibility on RTX 4050 (6GB) | Recommended Settings |
|--------------|-------------------|-------------------------------|------------------------------------------|
| 512x512 | ~2-3GB | Fully Supported | Default settings |
| 768x768 | ~4-6GB | Supported with Optimizations | `--xformers --lowvram` |
| 1536x1536 | ~8-12GB | Limited Support | `--xformers --lowvram --opt-split-attention-v1` |
| 1536x2048 | ~12-16GB | Not Supported | Fall back to CPU rendering |

---

### **Conclusion**

- **1536x1536**: Possible with GPU optimizations (`--xformers`, `--lowvram`, `--opt-split-attention-v1`), but may still fail if the model is too large or complex.
- **1536x2048**: Unlikely to work on your GPU due to exceeding its 6GB VRAM limit. You would need to fall back to CPU rendering, which will be slow.

For best results, stick to resolutions like 768x768 or lower when using GPU acceleration. If you frequently need higher resolutions, consider upgrading to a GPU with more VRAM (e.g., RTX 4060 or higher).

How much big models I could use? Some basic ones in civitai for example have 4-6-8GB size.
The size of a model (e.g., 4GB, 6GB, or 8GB) refers to the file size of the model weights, which is **not directly equivalent** to the amount of VRAM required to run the model. Instead, VRAM usage depends on factors like the model architecture, resolution, batch size, and optimizations applied during inference.

Let’s analyze how large models you can use on your system with an NVIDIA RTX 4050 Laptop GPU (6GB VRAM) and what optimizations are necessary to make them work.

---

### **Key Factors Affecting VRAM Usage**

1. **Model Size vs. VRAM Requirements**
- The file size of a model (e.g., 4GB, 6GB, or 8GB) represents the uncompressed weights stored on disk. During inference, these weights are loaded into VRAM along with intermediate tensors, activations, and other overhead.
- For example:
- A **4GB model** might require ~6-8GB of VRAM at 512x512 resolution.
- A **6GB model** might require ~8-12GB of VRAM at 512x512 resolution.
- An **8GB model** (e.g., SDXL) might require ~12-16GB of VRAM at 512x512 resolution.

2. **Resolution**
- Higher resolutions increase VRAM usage exponentially because they involve more pixels and larger intermediate tensors. For example:
- At 512x512: ~2-3GB VRAM for small models.
- At 768x768: ~4-6GB VRAM for small models.
- At 1024x1024: ~8-12GB VRAM for small models.

3. **Batch Size**
- Generating multiple images simultaneously (batch size > 1) increases VRAM usage linearly. Always use a batch size of 1 when working with limited VRAM.

4. **Optimizations**
- Techniques like `--lowvram`, `--xformers`, and `--attention-split` reduce VRAM usage by offloading computations or splitting attention mechanisms.

---

### **Feasibility of Large Models on Your System**

#### **1. Small Models (e.g., Stable Diffusion 1.5, DreamShaper, Realistic Vision)**
- **File Size**: Typically 2-4GB.
- **VRAM Requirements**:
- 512x512: ~2-3GB VRAM.
- 768x768: ~4-6GB VRAM.
- 1024x1024: ~8-12GB VRAM (requires optimizations).
- **Feasibility**:
- These models should work well on your RTX 4050 at resolutions up to 768x768 with minimal optimizations (`--xformers`).
- For higher resolutions (e.g., 1024x1024), use `--lowvram` and `--opt-split-attention-v1`.

#### **2. Medium Models (e.g., Anything V3, Waifu Diffusion, Counterfeit)**
- **File Size**: Typically 4-6GB.
- **VRAM Requirements**:
- 512x512: ~4-6GB VRAM.
- 768x768: ~6-8GB VRAM (requires optimizations).
- 1024x1024: ~10-12GB VRAM (requires heavy optimizations or CPU fallback).
- **Feasibility**:
- These models will work at 512x512 resolution without issues.
- At 768x768, you’ll need to use `--lowvram` and `--xformers`.
- At 1024x1024, you may need to fall back to CPU rendering or use extreme optimizations.

#### **3. Large Models (e.g., SDXL, Flux, Juggernaut XL)**
- **File Size**: Typically 6-8GB.
- **VRAM Requirements**:
- 512x512: ~6-8GB VRAM (requires optimizations).
- 768x768: ~8-12GB VRAM (requires heavy optimizations or CPU fallback).
- 1024x1024: ~12-16GB VRAM (not feasible on your GPU).
- **Feasibility**:
- These models are unlikely to work on your RTX 4050 at reasonable resolutions unless you use extreme optimizations (`--lowvram`, `--xformers`, `--attention-split`) and limit the resolution to 512x512.
- For higher resolutions, you’ll need to fall back to CPU rendering or upgrade your GPU.

---

### **Recommended Optimizations**

To maximize the usability of large models on your system:

1. **Use xFormers**:
```cmd
set COMMANDLINE_ARGS=--xformers
```
- Reduces VRAM usage by optimizing attention mechanisms.

2. **Enable Low VRAM Mode**:
```cmd
set COMMANDLINE_ARGS=--lowvram
```
- Offloads intermediate computations to system RAM.

3. **Split Attention Mechanisms**:
```cmd
set COMMANDLINE_ARGS=--opt-split-attention-v1
```
- Further reduces VRAM usage by splitting attention computations.

4. **Limit Resolution**:
- Stick to 512x512 for large models.
- Use 768x768 only for smaller models.

5. **Batch Size**:
- Always use a batch size of 1 (`--batch-size 1`).

---

### **Practical Examples from CivitAI**

Here’s how some popular models from CivitAI might perform on your system:

| Model Name | File Size | Recommended Resolution | Feasibility on RTX 4050 (6GB) | Required Optimizations |
|-----------------------|-----------|------------------------|-------------------------------|--------------------------------------|
| **DreamShaper** | ~4GB | 512x512 to 768x768 | Fully Supported | `--xformers` |
| **Realistic Vision** | ~4GB | 512x512 to 768x768 | Fully Supported | `--xformers --lowvram` |
| **Anything V3** | ~6GB | 512x512 | Supported with Optimizations | `--xformers --lowvram` |
| **SDXL Base** | ~8GB | 512x512 | Limited Support | `--xformers --lowvram --attention-split` |
| **Flux** | ~8GB+ | Not Supported | Fall Back to CPU | N/A |

---

### **Conclusion**

- **Small Models (2-4GB)**: Fully supported at 512x512 and 768x768 with minimal optimizations.
- **Medium Models (4-6GB)**: Supported at 512x512 and 768x768 with `--xformers` and `--lowvram`.
- **Large Models (6-8GB+)**: Only feasible at 512x512 with heavy optimizations (`--xformers`, `--lowvram`, `--attention-split`). Higher resolutions will require CPU rendering or a GPU upgrade.

For the best experience, stick to smaller models and resolutions like 512x512 or 768x768. If you frequently need to run large models or high resolutions, consider upgrading to a GPU with 8GB or more VRAM (e.g., RTX 4060 or higher).

How can I use tiling at stable-diffusion-webui ( https://github.com/AUTOMATIC1111/stable-diffusion-webui ) and stable-diffusion-webui-forge ( https://github.com/lllyasviel/stable-diffusion-webui-forge ) and merging LoRAs into checkpoints?
### **Using Tiling in Stable Diffusion WebUI**

Tiling is a technique that divides an image into smaller tiles, processes them independently, and then combines the results. This reduces memory usage and allows you to generate high-resolution images even with limited VRAM. Both `stable-diffusion-webui` (AUTOMATIC1111) and `stable-diffusion-webui-forge` support tiling through various optimizations.

---

#### **1. Enabling Tiling in AUTOMATIC1111's WebUI**
To enable tiling in AUTOMATIC1111's WebUI, you can use specific flags or settings:

##### **Command-Line Arguments**
You can add the following arguments when launching the WebUI:
```cmd
set COMMANDLINE_ARGS=--xformers --lowvram --medvram --tiling
```

- **Explanation**:
- `--xformers`: Enables the xFormers library for memory-efficient attention mechanisms.
- `--lowvram`: Reduces VRAM usage by offloading intermediate computations to system RAM.
- `--medvram`: A middle-ground option between performance and memory usage.
- `--tiling`: Explicitly enables tiling mode.

##### **Inference Settings**
You can also configure tiling directly in the WebUI interface:
1. Open the WebUI and navigate to the **Settings** tab.
2. Under the **Stable Diffusion** section, look for options like `Enable Tiling` or `Use Split Attention`.
3. Enable these options and save your settings.

##### **Advanced Options**
For more control over tiling:
- Use the `--attention-split` flag to split attention computations.
- Adjust the `tile_size` parameter (if available) to control the size of individual tiles.

---

#### **2. Enabling Tiling in Forge**
The `stable-diffusion-webui-forge` fork includes additional optimizations for tiling. You can enable it similarly:

##### **Command-Line Arguments**
Add the following arguments when launching Forge:
```cmd
set COMMANDLINE_ARGS=--xformers --lowvram --opt-split-attention-v1 --tiling
```

- **Explanation**:
- `--xformers`: Optimizes attention mechanisms.
- `--lowvram`: Reduces VRAM usage.
- `--opt-split-attention-v1`: Splits attention computations for better memory efficiency.
- `--tiling`: Enables tiling mode.

##### **Inference Settings**
Forge also provides user-friendly options in the WebUI interface:
1. Navigate to the **Settings** tab.
2. Look for tiling-related options such as `Enable Tiling` or `Optimize for High Resolutions`.
3. Enable these options and save your settings.

---

#### **3. Practical Tips for Tiling**
- **Start Small**: Begin with lower resolutions (e.g., 768x768) to test stability before moving to higher resolutions (e.g., 1536x1536).
- **Monitor VRAM**: Use tools like MSI Afterburner or NVIDIA Task Manager to track VRAM usage during generation.
- **Tile Size**: Smaller tile sizes reduce VRAM usage but increase computation time. Experiment with different sizes to find the optimal balance.

---

### **Merging LoRAs into Checkpoints**

LoRA (Low-Rank Adaptation) models are lightweight fine-tuning layers that can be merged into base models (checkpoints) to simplify inference and improve performance. Merging LoRAs into checkpoints is straightforward using scripts provided by both WebUI forks.

---

#### **1. Merging LoRAs in AUTOMATIC1111's WebUI**
AUTOMATIC1111's WebUI includes a built-in script for merging LoRAs.

##### **Steps**:
1. Place your base model checkpoint (e.g., `model.ckpt`) and LoRA file (e.g., `lora.safetensors`) in the appropriate directories:
- Base models: `models/Stable-diffusion/`
- LoRAs: `models/Lora/`

2. Launch the WebUI and navigate to the **Train** tab.

3. Select the **Merge LoRA into Model** option:
- Choose your base model checkpoint.
- Select the LoRA file to merge.
- Specify the output filename (e.g., `merged_model.ckpt`).

4. Adjust the **Alpha** value (optional):
- The alpha value controls the strength of the LoRA influence. A value of `1.0` applies full strength.

5. Click **Merge** to generate the combined checkpoint.

---

#### **2. Merging LoRAs in Forge**
Forge also supports LoRA merging, either through the WebUI interface or command-line scripts.

##### **Using the WebUI Interface**:
The process is similar to AUTOMATIC1111's WebUI:
1. Place your base model and LoRA files in the respective directories.
2. Navigate to the **LoRA Merge** section in the WebUI.
3. Select the base model, LoRA file, and output filename.
4. Adjust the alpha value and merge the files.

##### **Using Command-Line Scripts**:
Forge includes a Python script for merging LoRAs. You can run it as follows:
```bash
python merge_lora.py --base_model_path <path_to_base_model> --lora_path <path_to_lora> --output_path <output_file> --alpha <alpha_value>
```

- Replace `<path_to_base_model>`, `<path_to_lora>`, `<output_file>`, and `<alpha_value>` with your specific paths and values.

---

#### **3. Practical Tips for Merging LoRAs**
- **Backup Original Files**: Always keep a backup of your original base model and LoRA files before merging.
- **Test Different Alpha Values**: Experiment with alpha values (e.g., `0.5`, `0.8`, `1.0`) to find the desired balance between the base model and LoRA influence.
- **Verify Compatibility**: Ensure the LoRA file is compatible with the base model architecture (e.g., SD 1.5 vs. SDXL).

---

### **Summary**

| Feature | AUTOMATIC1111 WebUI | Forge WebUI |
|-----------------------------|----------------------------------------------|-------------------------------------------|
| **Tiling Support** | Enabled via `--tiling` and `--lowvram` flags | Similar flags (`--tiling`, `--lowvram`) |
| **LoRA Merging** | Built-in UI or manual scripts | Built-in UI or command-line script |
| **Ease of Use** | User-friendly interface | Additional optimizations in Forge |

Both WebUI forks provide robust support for tiling and LoRA merging. By enabling tiling and merging LoRAs into checkpoints, you can efficiently generate high-resolution images and streamline your workflow on systems with limited VRAM.

How much base models and LORAs I could combine into one model?
Qwen
The number of base models and LoRAs (Low-Rank Adaptations) you can combine into a single model depends on several factors, including the architecture of the base model, the size of the LoRAs, and the computational resources available. Let’s break this down step by step to understand the practical limits and considerations.

---

### **1. Understanding LoRA and Base Model Combination**

#### **Base Model**
- A base model (e.g., Stable Diffusion 1.5, SDXL) is the foundation of the system. It contains the full set of weights for generating images.
- Merging multiple base models is generally not feasible because they have conflicting architectures or weight structures.

#### **LoRAs**
- LoRAs are lightweight fine-tuning layers that modify specific parts of the base model. They are designed to be modular and additive, meaning you can combine multiple LoRAs with a single base model.
- Each LoRA typically focuses on a specific style, concept, or feature (e.g., anime-style eyes, realistic lighting).

---

### **2. Combining Multiple LoRAs with a Single Base Model**

#### **How It Works**
When merging multiple LoRAs:
- Each LoRA modifies a subset of the base model's weights.
- The merged model applies all the modifications simultaneously during inference.

#### **Practical Limits**
There is no strict technical limit to the number of LoRAs you can merge, but combining too many may lead to:
- **Conflicting Styles**: Different LoRAs may introduce conflicting changes, resulting in unpredictable or undesirable outputs.
- **Increased Complexity**: More LoRAs increase the complexity of the model, potentially leading to slower inference times.
- **Overfitting**: Too many modifications may over-specialize the model, reducing its versatility.

#### **Recommended Practices**
- **Start Small**: Begin with 1-3 LoRAs and test the results before adding more.
- **Use Compatible LoRAs**: Ensure the LoRAs are compatible with the same base model (e.g., SD 1.5 or SDXL).
- **Adjust Alpha Values**: Use lower alpha values (e.g., `0.5` or `0.7`) for each LoRA to balance their influence.

---

### **3. Computational Considerations**

#### **VRAM Usage**
Merging LoRAs does not significantly increase VRAM usage because the modifications are applied to the base model weights. However:
- Larger base models (e.g., SDXL) require more VRAM.
- High-resolution generation increases VRAM usage regardless of the number of LoRAs.

#### **Inference Speed**
- Adding more LoRAs slightly increases computation time because the model processes additional modifications.
- This effect is negligible for small numbers of LoRAs but becomes noticeable with many.

---

### **4. Practical Examples**

Here are some examples of how many LoRAs you might reasonably combine:

#### **Example 1: Anime Character Generator**
- **Base Model**: Stable Diffusion 1.5
- **LoRAs**:
- "Anime Eyes" (focuses on eye details)
- "Anime Hair" (adds realistic hair styles)
- "Color Palette" (adjusts color tones)
- **Result**: Combining these 3 LoRAs creates a versatile anime character generator.

#### **Example 2: Realistic Portrait Generator**
- **Base Model**: SDXL
- **LoRAs**:
- "Realistic Skin" (improves skin texture)
- "Photorealistic Lighting" (enhances lighting effects)
- "Facial Features" (refines facial details)
- "Background Enhancement" (adds detailed backgrounds)
- **Result**: Combining these 4 LoRAs produces high-quality realistic portraits.

---

### **5. Step-by-Step Guide to Merge Multiple LoRAs**

#### **Using AUTOMATIC1111's WebUI**
1. Place your base model checkpoint (e.g., `model.ckpt`) and LoRA files (e.g., `lora1.safetensors`, `lora2.safetensors`) in the appropriate directories:
- Base models: `models/Stable-diffusion/`
- LoRAs: `models/Lora/`

2. Launch the WebUI and navigate to the **Train** tab.

3. Select the **Merge LoRA into Model** option:
- Choose your base model checkpoint.
- Select the first LoRA file and specify its alpha value.
- Merge the first LoRA into the base model.

4. Repeat the process for additional LoRAs, using the merged model as the new base model.

#### **Using Forge**
The process is similar to AUTOMATIC1111's WebUI:
1. Place your files in the respective directories.
2. Navigate to the **LoRA Merge** section in the WebUI.
3. Merge each LoRA sequentially, adjusting alpha values as needed.

#### **Using Command-Line Scripts**
If you prefer scripting, you can use a Python script to merge multiple LoRAs:
```bash
python merge_lora.py --base_model_path <path_to_base_model> --lora_path <path_to_lora1> --output_path <temp_output> --alpha <alpha_value>
python merge_lora.py --base_model_path <temp_output> --lora_path <path_to_lora2> --output_path <final_output> --alpha <alpha_value>
```

---

### **6. Potential Issues and Solutions**

#### **Issue 1: Conflicting Styles**
- **Cause**: Two LoRAs modify the same part of the base model in conflicting ways.
- **Solution**: Test each LoRA individually and adjust alpha values to reduce conflicts.

#### **Issue 2: Over-Specialization**
- **Cause**: Too many LoRAs make the model overly specific, reducing versatility.
- **Solution**: Limit the number of LoRAs and prioritize those most relevant to your use case.

#### **Issue 3: Performance Degradation**
- **Cause**: Adding too many LoRAs slows down inference.
- **Solution**: Profile performance and remove unnecessary LoRAs.

---

### **Conclusion**

| Number of LoRAs | Feasibility | Recommended Use Case |
|------------------|---------------------|---------------------------------------|
| 1-3 | Fully Supported | Focused tasks (e.g., anime characters)|
| 4-6 | Moderately Supported | Versatile tasks (e.g., realistic portraits) |
| 7+ | Limited Support | Avoid unless absolutely necessary |

You can combine multiple LoRAs with a single base model, but the practical limit is typically **3-6 LoRAs**. Beyond this, conflicts and diminishing returns become more likely. Always test combinations incrementally and adjust alpha values to achieve the desired balance.
Нажмите, чтобы раскрыть...

DeepSeek

Yes, you can run both **stable-diffusion-webui** and **stable-diffusion-webui-forge** on your system, but performance will vary depending on whether you use the **Intel Iris Xe (iGPU)** or the **NVIDIA RTX 4050 Laptop GPU (dGPU)**.

### **Key Considerations:**
1. **GPU vs. CPU Mode**
- Your **RTX 4050 (6GB GDDR6)** is the best choice for running Stable Diffusion, but it's a laptop GPU with limited VRAM.
- Using `--xformers` and `--opt-split-attention` will help reduce VRAM usage.
- Avoid `--use-cpu all` unless you want to run purely on CPU (very slow).

2. **Intel Iris Xe (iGPU)**
- Not officially supported for Stable Diffusion (poor OpenCL/directml performance).
- If forced, use `--use-cpu all` or `--device-id 0` (but expect very slow speeds).

3. **VRAM Limitations (6GB on RTX 4050)**
- Default models (SD 1.5, SDXL) may work at 512×512 but could struggle at higher resolutions.
- Use `--medvram` or `--lowvram` if you get "CUDA Out of Memory" errors.

---

### **Recommended Launch Commands (RTX 4050)**
#### **For Best Performance (NVIDIA GPU)**
```cmd
set COMMANDLINE_ARGS=--xformers --opt-split-attention --medvram --no-half-vae
```
- `--xformers` → Speeds up attention layers (requires xformers installed).
- `--opt-split-attention` → Reduces VRAM usage.
- `--medvram` → Optimizes for GPUs with 4-8GB VRAM.
- `--no-half-vae` → Prevents black images in some cases.

#### **If You Still Get OOM Errors (Low VRAM Mode)**
```cmd
set COMMANDLINE_ARGS=--xformers --opt-split-attention --lowvram --always-batch-cond-uncond
```

#### **For CPU-Only Mode (Slow, Not Recommended)**
```cmd
set COMMANDLINE_ARGS=--use-cpu all --skip-torch-cuda-test --precision full --no-half
set CUDA_VISIBLE_DEVICES=-1
```

---

### **Additional Optimizations**
1. **Disable Hardware-Accelerated GPU Scheduling (Windows)**
- Improves stability for some users:
`Settings > System > Display > Graphics > Default Graphics Settings > Turn off "Hardware-Accelerated GPU Scheduling"`

2. **Use `--deepdanbooru` Only if Needed**
- Only required for automatic tagging (adds extra VRAM load).

3. **Avoid `--precision full --no-half` on GPU**
- Slows down generation without significant quality improvement.

---

### **Final Verdict**
- **Best Option:** Use the **RTX 4050** with `--xformers --medvram`.
- **Fallback:** If VRAM issues persist, try `--lowvram`.
- **Avoid CPU Mode** unless absolutely necessary (extremely slow on even high-end CPUs).

Would you like help setting up the environment (Python, PyTorch, etc.) as well?

Would be custom resolutions higher than 512x512 like 1536x1536 or 1536x2048 would be work on my specs?
Running **custom resolutions like 1536×1536 or 1536×2048** on your **RTX 4050 (6GB VRAM)** is **possible but challenging**—you’ll need optimizations to avoid "CUDA Out of Memory" errors. Here’s how to approach it:

---

### **1. Can Your RTX 4050 Handle It?**
- **512×512** → Easy (~3-4GB VRAM used).
- **768×768** → Possible with `--medvram` (~5-6GB VRAM).
- **1024×1024+** → Risky, requires **tiled/token merging** or **CPU offloading**.
- **1536×1536 / 1536×2048** → **Likely to crash** unless heavily optimized.

#### **VRAM Limits (Approximate)**
| Resolution | Estimated VRAM Usage (SD 1.5) | Feasibility (RTX 4050 6GB) |
|-------------|-----------------------------|---------------------------|
| 512×512 | 3-4GB | ✅ Easy |
| 768×768 | 5-6GB | ⚠️ Possible (--medvram) |
| 1024×1024 | 7-8GB | ❌ Likely OOM |
| 1536×1536 | 10-12GB+ | ❌ Needs extreme tricks |

---

### **2. How to Make It Work (If You Must)**
#### **Option A: Use Tiled Diffusion (Best Choice)**
- **Forge UI** has built-in **Tiled Diffusion** (under "Extensions" → "Tiled Diffusion & VAE").
- **Command:**
```cmd
set COMMANDLINE_ARGS=--xformers --medvram --no-half-vae
```
- **In WebUI:**
- Enable **Tiled Diffusion** (splits image into smaller chunks).
- Use **Tiled VAE** to reduce memory further.
- Recommended settings:
- Tile size: **512×512**
- Overlap: **64px**

#### **Option B: Use `--lowvram` + Token Merging**
- Forces aggressive VRAM savings (slower but more stable):
```cmd
set COMMANDLINE_ARGS=--lowvram --xformers --opt-split-attention --always-batch-cond-uncond
```
- **Enable Token Merging (ToMe):**
- Reduces memory by merging redundant tokens (~20-30% less VRAM).
- Add `--tome-ratio 0.5` to merge half the tokens.

#### **Option C: CPU Offloading (Very Slow)**
- Moves parts of the model to RAM (works but **extremely slow**):
```cmd
set COMMANDLINE_ARGS=--medvram --xformers --sub-quadratic-attention
```
- **Forge UI** has better CPU offloading than A1111.

---

### **3. Alternative: Upscaling**
Instead of generating at **1536×1536 directly**, try:
1. Generate at **512×512** (or **768×768**).
2. Upscale **2x-4x** using:
- **ESRGAN** (for realism).
- **SwinIR** (for details).
- **Tiled Diffusion Upscale** (avoids OOM).

---

### **4. Expected Performance**
| Method | Speed (RTX 4050) | Max Resolution (Est.) | Quality Impact |
|----------------------|------------------|-----------------------|----------------|
| Direct Generation | 1-2 it/s | 768×768 | Best |
| Tiled Diffusion | 0.5-1 it/s | 1536×1536+ | Slight seams |
| CPU Offloading | 0.1 it/s | Any (but slow) | Worst |

---

### **Final Verdict**
- **✅ Doable:** Yes, but **only with Tiled Diffusion** (expect slower speeds).
- **⚠️ Avoid Direct Generation:** 1536×1536 will likely crash without tiling.
- **Best Workflow:**
- Generate at **768×768** (or lower).
- Upscale with **Tiled Diffusion + SwinIR**.

Would you like a step-by-step guide for setting up **Tiled Diffusion** in Forge UI?

How much big models I could use? Some basic ones in civitai for example have 4-6-8GB size.
Your **RTX 4050 (6GB VRAM)** can handle **most standard SD 1.5/SDXL models**, but **larger models (7GB+)** will require optimizations. Here’s a breakdown of what works and how to optimize:

---

### **1. Model Types & VRAM Requirements**
| Model Type | Size (FP16) | VRAM Usage (512×512) | Feasibility (RTX 4050) |
|--------------------------|-------------|----------------------|------------------------|
| **SD 1.5 (Standard)** | ~2GB | 3-4GB | ✅ Easy |
| **SD 1.5 (LoRA merged)** | ~2-4GB | 4-5GB | ✅ Works (--medvram) |
| **SDXL Base** | ~6-7GB | 6-8GB | ⚠️ Needs optimizations |
| **SDXL Refiner** | ~6GB | +2-3GB extra | ❌ Avoid (OOM risk) |
| **Large Custom (8GB+)** | 8GB+ | 10GB+ | ❌ Unusable (Crash) |

---

### **2. What Can You Run?**
#### **✅ Safe Choices (No Tweaks Needed)**
- **SD 1.5 (2-4GB models)**
- Most **CivitAI checkpoint/LoRA combos** (e.g., *RealisticVision*, *DreamShaper*).
- **Command:**
```cmd
set COMMANDLINE_ARGS=--xformers --medvram
```

#### **⚠️ Possible with Optimizations (SDXL, 6-7GB models)**
- **SDXL Base (6GB)** – Requires `--lowvram` or **tiled diffusion**.
```cmd
set COMMANDLINE_ARGS=--xformers --lowvram --no-half-vae
```
- **SDXL + Refiner** → **Disable refiner** (or use **TensorRT optimizations** in Forge UI).

#### **❌ Avoid (Unless You Love Pain)**
- **8GB+ Frankenstein Models** (e.g., *MajicMix Realistic XL* + multiple LoRAs).
- **SDXL with Refiner + HiRes Fix** (VRAM will explode).

---

### **3. How to Run Bigger Models?**
#### **Option A: Use `--medvram` / `--lowvram`**
- Forces memory-saving splits:
```cmd
set COMMANDLINE_ARGS=--medvram --xformers --opt-split-attention
```
- `--medvram` → Balances speed/memory (best for SD 1.5).
- `--lowvram` → Slower but safer for SDXL.

#### **Option B: Disable Unnecessary Loads**
- **Skip VAE half-precision** (prevents black images):
```cmd
--no-half-vae
```
- **Disable upscalers in RAM**:
```cmd
--no-hashing
```

#### **Option C: Use Forge UI’s Optimizations**
- **Forge UI** has better memory management than A1111.
- **TensorRT acceleration** (Windows-only) → Can cut SDXL VRAM usage by ~20%.
- **CPU Offloading** → Moves parts of the model to RAM (slow but works).

---

### **4. Model Recommendations for RTX 4050**
| Model Type | Example Models (CivitAI) | Notes |
|------------------|-----------------------------------|--------------------------------|
| **SD 1.5** | *RealisticVision*, *DreamShaper* | Best balance of speed/quality. |
| **SD 1.5 LoRA** | *epiCPhotoGasm*, *FilmGirls* | Merge into checkpoint to save VRAM. |
| **SDXL Lite** | *Juggernaut XL*, *AlbedoBase XL* | Smaller FP16 variants (~5GB). |
| **Avoid** | *MajicMix XL*, *Pony Diffusion 6* | Too heavy for 6GB VRAM. |

---

### **5. Extreme Case: "Can I Load an 8GB Model?"**
- **No** (without offloading to CPU/RAM).
- **Workaround:**
- Use **model pruning** (e.g., *Stable Diffusion Lite* variants).
- Try **8-bit quantized models** (if available).
- **Forge UI’s "DirectML" mode** (slower but bypasses VRAM limits).

---

### **Final Verdict**
- **Stick to SD 1.5 (2-4GB models)** → Best performance.
- **SDXL (6GB) works with `--lowvram`** → Expect slower speeds.
- **Avoid 8GB+ monsters** → Your GPU will cry.

Want a step-by-step guide to **merging LoRAs into checkpoints** (to save VRAM)?

How can I use tiling at stable-diffusion-webui ( https://github.com/AUTOMATIC1111/stable-diffusion-webui ) and stable-diffusion-webui-forge ( https://github.com/lllyasviel/stable-diffusion-webui-forge ) and merging LoRAs into checkpoints?
Here’s a step-by-step guide for **tiling in SD WebUI/Forge** and **merging LoRAs into checkpoints** to optimize performance on your RTX 4050 (6GB VRAM):

---

### **Part 1: Using Tiling for High-Resolution Generations**
#### **In Stable-Diffusion-WebUI (A1111)**
1. **Install the Tiled Diffusion Extension**:
- Go to `Extensions` → `Available` → Search for **"Tiled Diffusion"** → Install.
- Restart WebUI.

2. **Configure Tiled Diffusion**:
- Go to the `Tiled Diffusion` tab in WebUI.
- Enable **"Enable Tiled Diffusion"** and **"Enable Tiled VAE"**.
- Recommended settings:
- **Tile Width/Height**: `512` (balances speed & memory)
- **Overlap**: `64` (reduces seams)
- **Upscaler**: `R-ESRGAN 4x+` (if upscaling)
- Generate as usual (now supports 1536x1536+ without OOM).

3. **Launch Command (Optional Optimization)**:
```cmd
set COMMANDLINE_ARGS=--xformers --medvram --no-half-vae
```

#### **In Stable-Diffusion-WebUI-Forge**
- Forge has **built-in tiling** (no extension needed):
- Under `Generate`, enable:
- **Tiled Diffusion** (for the UNet)
- **Tiled VAE** (for decoding).
- Use similar settings as above.

---

### **Part 2: Merging LoRAs into Checkpoints (Save VRAM)**
#### **Method 1: Merge via WebUI (Easy)**
1. **Install "Additional Networks" Extension**:
- Go to `Extensions` → `Available` → Search for **"Additional Networks"** → Install.
- Restart WebUI.

2. **Merge LoRA with Checkpoint**:
- Go to the `Checkpoint Merger` tab.
- Set:
- **Primary Model**: Your base checkpoint (e.g., `realisticVision.safetensors`).
- **Secondary Model**: Leave blank.
- **Tertiary Model**: Leave blank.
- **Multiplier (Weight)**: `1.0` (full strength).
- Under **"LoRA"**, select your LoRA (e.g., `epiCPhotoGasm.safetensors`).
- Click **"Merge"** → Save as a new `.safetensors` file.

#### **Method 2: Manual Merge (Advanced)**
1. Use **`kohya-ss`** scripts ([GitHub](https://github.com/kohya-ss/sd-scripts)):
```bash
python merge_lora.py --base_model "model.safetensors" --lora_model "lora.safetensors" --ratio 1.0 --output "merged_model.safetensors"
```
- `--ratio 1.0`: Full LoRA strength (adjust as needed).

#### **Why Merge LoRAs?**
- **Reduces VRAM overhead** (LoRAs load dynamically, merging bakes them into the checkpoint).
- **Faster loading** (no separate LoRA file needed).

---

### **Part 3: Optimizing for RTX 4050 (6GB VRAM)**
#### **For Tiled High-Res (1536x1536)**:
- Use **Tiled Diffusion + Tiled VAE** (prevents OOM).
- Avoid `--lowvram` unless necessary (slower).

#### **For Merged Models**:
- **SD 1.5 + LoRA**: Safe (3-4GB VRAM).
- **SDXL + LoRA**: Use `--lowvram` or **TensorRT** (Forge only).

---

### **Example Workflow**
1. **Merge LoRA** (e.g., `realisticVision + epiCPhotoGasm`).
2. **Generate at 512x512** (fast draft).
3. **Upscale to 1536x1536** with Tiled Diffusion.
4. **Refine** with a lightweight LoRA (if needed).

---

### **Troubleshooting**
- **Seams in Tiled Output?** → Increase overlap to `96` or use **"Tile Diffusion + Noise Inversion"**.
- **OOM Errors?** → Add `--medvram` or reduce tile size to `384x384`.
- **LoRA Not Applying?** → Check multiplier weight (try `0.6-0.8` for subtle effects).

---

### **Final Tips**
- **Forge UI** handles tiling/LoRAs better than A1111 (recommended for SDXL).
- **Delete unused LoRAs** after merging to save disk space.
- **Monitor VRAM** with `nvidia-smi` (Windows Task Manager → GPU tab).

Need help with a specific LoRA or tiling setup? Share the model names, and I’ll test the workflow!
Нажмите, чтобы раскрыть...

Gamerun, 29 мар 2025

#1893
Forgettable

Редактор Хелпер

Регистрация:

3 авг 2019

Сообщения:

9.910

--precision full --no-half --use-cpu all --skip-torch-cuda-test
Нажмите, чтобы раскрыть...

Это вредные команды. Если у тебя выходят NaN ошибки, добавь в параметры "--all-in-fp32" и юзай "diffusion in low bits"

--opt-sub-quad-attention --lowvram --xformers --opt-split-attention-v1
Нажмите, чтобы раскрыть...

Это бесполезные команды в форже. Он уже оптимизирован и из коробки работает лучше a1111 с параметрами.

Forgettable, 29 мар 2025

#1894

Ogr 2 нравится это.
Forgettable

Редактор Хелпер

Регистрация:

3 авг 2019

Сообщения:

9.910

Стало интересно, а можно ли заставить Deepseek выдать не простой скрипт, а что-то прям мощное и умное.
1. Попросил написать аналог Quickpar на Python (получил его, но без ECC)
2. Попросил написать реализацию кодов Рида-Соломона на Python
3. Попросил доработать и то, и другое по несколько раз
4. Попросил совместить их в одну программу
5. Попросил доработать ее еще кучу раз (пока не надоело)
В итоге, получился вроде как рабочий софт для создания .par2, но... функции verify/repair для него тоже нужно просить отдельно

Последнее редактирование: 2 апр 2025

Forgettable, 2 апр 2025

#1895
Forgettable

Редактор Хелпер

Регистрация:

3 авг 2019

Сообщения:

9.910

Еще с помощью Deepseek можно некоторые старые игры чинить
Например, Diggles: The Myth of Fenris, которая написана на tcl и ее код лежит в открытом доступе

Это на редкость глюкавая игра, с крашами, софтлоками, тормозами к концу, мож удастся ее починить...

Последнее редактирование: 6 апр 2025

Forgettable, 6 апр 2025

#1896

Aynane, Gamerun, MAZterXP и ещё 1-му нравится это.
Tigoro AI General

Регистрация:

4 фев 2010

Сообщения:

3.425

Есть ограничение на количество одновременных файлов и на общий размер. По размеру вроде до 100кб через браузер работает. Плюс реакция разная, может полный код написать, может фрагменты подсказать, а может просто общую стратегию действий вручную описать. Код на 10-15кб единым файлом можно выбить, но часто кроит и не всегда возможно полученные подсказки использовать практически. Если запросить на их базе патч, то скорее всего не получится совместить. Для упрощения стоит жать (пробелы, прочее) файл с текстом и проставлять номера строк в конце каждой строки. Тогда чуть проще понимать односложные ответы куда что советует сделать если по тексту не ясно что он правит.

Tigoro, 7 апр 2025

#1897

DJKrolik нравится это.
DJKrolik

Регистрация:

22 сен 2005

Сообщения:

6.708

@Tigoro, есть такое, DeepSeek и другие отказывались файлы читать, я правда не смог понять объем, но приблизительно разбил текст и скармливал порциями.
Если DeepSeek сказать что-то отформатировать по формуле (образцу, алгоритму) - то можно закинуть первый файл, а дальше уже не писать ничего, только файлы кидать - будет одинаково их редачить, но потом напишет что диалог уже жирный и надо новый начать - вот тогда может малость по-другому отформатировать, даже если в подробностях пишешь, как нужно.
Короче, пока всё с такими лимитами - конечно не стоит на 100% результат рассчитывать, работая с большими файлами. Может чего-то где-то потерять.
А в плане реакции - DeepSeek и пара других часто ленятся а вот Grok обычно начинает фигачить код. Но там надо найти подход. Например, я всё с CMS и разными сайтами экспериментирую, если сразу запросить большой объем, который предполагает в результате десяток файлов - Grok их не напишет полностью, а даст заготовки. Лучше с небольшой задачи начинать и потихоньку подкидывать дровишек куда надо. А например какие-то игры на html делает сразу, потому что там один файл, вот вчера мне Batty написал, с допиливанием почти готовый продукт получился.

Сейчас наверное востребованная позиция должна быть - промптовый нинзя. Потому что при всей мощи и возможностях один человек будет весь день копаться, получая результат, а у второго пак промтов заготовлен и всё делается за секунды

DJKrolik, 8 апр 2025

#1898

Mel Shlemming нравится это.
Forgettable

Редактор Хелпер

Регистрация:

3 авг 2019

Сообщения:

9.910

Попробовал модифицировать не особо старую игру на GameMaker через Deepseek и Grok (один boss fight усложнить)
Grok выдал результат очень быстро, но полез не туда (ускорил косметические анимации) и добавил вылет на одной из атак.
Deepseek пыхтел намного дольше, но поменял только то, что реально влияло на геймплей и код полностью работает с первого раза.

Tigoro сказал(а): ↑

Есть ограничение на количество одновременных файлов и на общий размер.
Нажмите, чтобы раскрыть...

Да, много килобайт туда не забьешь, это печально.

Tigoro сказал(а): ↑

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

Нужно уточнять запрос потому что. "Provide a complete, production-ready script..."

Tigoro сказал(а): ↑

Код на 10-15кб единым файлом можно выбить, но часто кроит
Нажмите, чтобы раскрыть...

Любой полученный код нужно его же просить проверить на ошибки.

Forgettable, 8 апр 2025

#1899
Tigoro AI General

Регистрация:

4 фев 2010

Сообщения:

3.425

Это с уточнением того что я хочу получить полный вариант кода, все равно может экономить на мне время )

Локальные модели ещё хуже, посколько видео памяти и обычной памяти не террабайт )

Tigoro, 8 апр 2025

#1900

(Вы должны войти или зарегистрироваться, чтобы ответить.)

Страница 95 из 126

Поиск

Искать только в заголовках

Сообщения пользователя:: Имена участников (разделяйте запятой).

Новее чем:

Искать только в этой теме
Искать только в этом разделе
- Отображать результаты в виде тем

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

Принять Узнать больше...

Скрыть объявление