Обзор Qwen3-Coder:30b — лучший локальный ИИ для кодинга

Введение

Подробнее о Qwen3 Coder

Тесты Qwen3-Coder

Точность текстовых ответов

Знание языков программирования

Assembler

.section .data
    # Массив для хранения чисел Фибоначчи
    fib_array: .quad 0, 1, 0, 0, 0, 0, 0, 0, 0, 0
    # Сообщение для вывода
    msg: .ascii "Fibonacci numbers: "
    msg_len = . - msg

.section .text
    .global _start

_start:
    # Инициализация переменных
    mov $0, %rax        # i = 0 (счетчик)
    mov $0, %rbx        # fib_prev = 0
    mov $1, %rcx        # fib_curr = 1
    mov $2, %rdx        # next_fib = 0

    # Вывод заголовка
    mov $1, %rax        # sys_write
    mov $1, %rdi        # stdout
    mov $msg, %rsi      # сообщение
    mov $msg_len, %rdx  # длина
    syscall

    # Генерация первых 10 чисел Фибоначчи
    mov $0, %r8         # счетчик цикла

fib_loop:
    cmp $10, %r8        # если i >= 10, то выйти
    jge fib_end

    # Вывод текущего числа (fib_prev)
    push %rbx           # сохраняем fib_prev
    call print_number   # выводим число
    pop %rbx            # восстанавливаем fib_prev

    # Вывод пробела
    mov $1, %rax        # sys_write
    mov $1, %rdi        # stdout
    mov $space, %rsi    # пробел
    mov $1, %rdx        # длина
    syscall

    # Вычисление следующего числа Фибоначчи
    add %rbx, %rcx      # fib_curr = fib_prev + fib_curr
    mov %rcx, %rbx      # fib_prev = fib_curr
    mov %rax, %rcx      # fib_curr = next_fib

    inc %r8             # i++
    jmp fib_loop

fib_end:
    # Вывод новой строки
    mov $1, %rax        # sys_write
    mov $1, %rdi        # stdout
    mov $newline, %rsi  # новая строка
    mov $1, %rdx        # длина
    syscall

    # Завершение программы
    mov $60, %rax       # sys_exit
    mov $0, %rdi        # код возврата
    syscall

# Функция для вывода числа
print_number:
    push %rbx
    push %rcx
    push %rdx
    push %rsi
    
    mov %rbx, %rax      # число для вывода
    mov $10, %rcx       # делитель
    mov $0, %rdx        # счетчик цифр
    mov $buffer + 15, %rsi  # указатель на конец буфера
    
    cmp $0, %rax
    jz print_zero
    
    # Деление на 10 для получения цифр
    mov $0, %rbx        # счетчик цифр
    mov $buffer + 15, %rdi  # указатель на конец буфера
    
print_digits:
    cmp $0, %rax
    jz digits_done
    
    xor %rdx, %rdx      # очистка RDX
    div %rcx            # делим на 10
    add $48, %rdx       # преобразуем в ASCII
    mov %dl, %byte [%rdi]
    dec %rdi
    inc %rbx
    jmp print_digits
    
digits_done:
    # Выводим цифры
    mov $1, %rax        # sys_write
    mov $1, %rdi        # stdout
    inc %rdi            # указатель на начало строки
    mov %rbx, %rdx      # длина
    syscall
    
    pop %rsi
    pop %rdx
    pop %rcx
    pop %rbx
    ret

print_zero:
    mov $48, %al        # ASCII '0'
    push %rax
    mov $1, %rax        # sys_write
    mov $1, %rdi        # stdout
    mov %rsp, %rsi      # указатель на символ
    mov $1, %rdx        # длина
    syscall
    pop %rax
    ret

# Вспомогательные символы
space: .ascii " "
newline: .ascii "\n"
buffer: .space 16

Python

pip install scikit-learn pandas matplotlib seaborn numpy

1. `smart_collector.py` — Сбор данных SMART

import subprocess
import json
from datetime import datetime

def get_smart_data(device_path):
    try:
        result = subprocess.run(['smartctl', '--json', '--all', device_path], capture_output=True, text=True)
        data = json.loads(result.stdout)
        return data
    except Exception as e:
        print(f"Ошибка при чтении SMART: {e}")
        return None

def extract_smart_metrics(data):
    if not data:
        return {}

    metrics = {
        'device': data.get('device', {}).get('name'),
        'model': data.get('model', {}).get('name'),
        'temperature': data.get('temperature', {}).get('current'),
        'reallocated_sectors_count': data.get('smartctl', {}).get('ata_smart_attributes', {}).get('table', [{}])[0].get('raw', {}).get('value'),
        'uncorrectable_errors': data.get('smartctl', {}).get('ata_smart_attributes', {}).get('table', [{}])[1].get('raw', {}).get('value'),
        'power_on_hours': data.get('power_on_time', {}).get('hours'),
        'time_to_full': data.get('rotation_rate'),
        'timestamp': datetime.now().isoformat()
    }
    return metrics

2. `ipmi_collector.py` — Сбор данных IPMI

import subprocess
import json

def get_ipmi_sensors():
    try:
        result = subprocess.run(['ipmitool', 'sdr', 'list'], capture_output=True, text=True)
        return result.stdout
    except Exception as e:
        print(f"Ошибка при чтении IPMI: {e}")
        return None

def parse_ipmi_data(log):
    # Пример обработки (можно расширить)
    lines = log.splitlines()
    sensors = []
    for line in lines:
        if 'Temperature' in line or 'Fan' in line or 'Voltage' in line:
            sensors.append(line.strip())
    return sensors

3. `ml_model.py` — Простая модель ML (пример)

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Предположим, у нас есть датасет с признаками и меткой отказа
def load_and_train_model():
    # Заглушка — замените на реальные данные из открытых датасетов
    data = pd.read_csv('smart_dataset.csv')  # Формат: ['temp', 'reallocated', 'uncorr_errors', 'health']
    X = data[['temp', 'reallocated', 'uncorr_errors']]
    y = data['health']  # 0 — не отказ, 1 — отказ
    model = RandomForestClassifier()
    model.fit(X, y)
    return model

def predict_failure(model, features):
    return model.predict_proba([features])[0][1]  # Вероятность отказа

4. `visualizer.py` — Визуализация трендов

import matplotlib.pyplot as plt
import seaborn as sns

def plot_smart_trends(data):
    df = pd.DataFrame(data)
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df.set_index('timestamp', inplace=True)

    fig, ax = plt.subplots(figsize=(10, 6))
    df[['temperature', 'reallocated_sectors_count']].plot(ax=ax)
    plt.title("Тренды SMART параметров")
    plt.xlabel("Время")
    plt.ylabel("Значение")
    plt.legend()
    plt.grid(True)
    plt.tight_layout()
    plt.savefig("smart_trends.png")

5. `notifier.py` — Уведомления

import smtplib
from email.mime.text import MIMEText

def send_alert(message):
    # Пример уведомления (можно заменить на Telegram, Slack и т.п.)
    print(f"[ALERT] {message}")

6. `main.py` — Основной скрипт

from smart_collector import get_smart_data, extract_smart_metrics
from ipmi_collector import get_ipmi_sensors, parse_ipmi_data
from ml_model import load_and_train_model, predict_failure
from visualizer import plot_smart_trends
from notifier import send_alert
import time

def main():
    devices = ['/dev/sda', '/dev/sdb']  # Укажите нужные диски
    model = load_and_train_model()
    smart_data_history = []

    for device in devices:
        data = get_smart_data(device)
        metrics = extract_smart_metrics(data)

        if metrics:
            features = [
                metrics.get('temperature', 0),
                metrics.get('reallocated_sectors_count', 0),
                metrics.get('uncorrectable_errors', 0)
            ]

            risk = predict_failure(model, features)
            print(f"Риск отказа для {device}: {risk:.2f}")

            if risk > 0.7:
                send_alert(f"Высокий риск отказа на диске {device} ({risk:.2f})")

            smart_data_history.append(metrics)

    plot_smart_trends(smart_data_history)

if __name__ == "__main__":
    main()

1С

&НаКлиенте
Процедура ФормированиеОтчетаПоПродажам(КонецПериода)
	
	// Создаем форму отчета
	Форма = Новый Форма("ФормаОтчетаПоПродажам");
	
	// Заполняем таблицу с данными
	Запрос = Новый Запрос;
	Запрос.Текст = "
		ВЫБРАТЬ
			|	Покупатель.Имя,
			|	Менеджер.Имя,
			|	СуммаПродажи = Сумма(Продажа.СуммаОплаты),
			|	КоличествоТоваров = Сумма(Продажа.Количество)
		|ИЗ
			|	Документ.РеализацияТоваров.Продажа КАК Продажа,
			|	Справочник.Менеджеры.Менеджер КАК Менеджер,
			|	Справочник.Покупатели.Покупатель КАК Покупатель
		|ГДЕ
			|	Продажа.Дата <= &КонецПериода
			|	И Продажа.Статус = ""Закрыто""
			|	И Продажа.Менеджер = Менеджер.Ссылка
			|	И Продажа.Покупатель = Покупатель.Ссылка
		|ГРУППИРОВАТЬ ПО
			|	Покупатель.Имя,
			|	Менеджер.Имя
		|ПОРЯДОК ПО
			|	СуммаПродажи УБЫВАЮЩИЙ";
	
	Запрос.УстановитьПараметр("КонецПериода", КонецПериода);
	
	Результат = Запрос.Выполнить();
	
	// Формируем таблицу данных для отчета
	ТаблицаДанных = Новый ТаблицаЗначений;
	ТаблицаДанных.Колонки.Добавить("Менеджер", Тип("Строка"));
	ТаблицаДанных.Колонки.Добавить("СуммаПродажи", Тип("Число"));
	ТаблицаДанных.Колонки.Добавить("КоличествоТоваров", Тип("Число"));
	
	// Заполняем таблицу данными
	Пока Результат.Следующий() Цикл
		
		Запись = ТаблицаДанных.Добавить();
		Запись.Установить("Менеджер", Результат.Поле("Менеджер"));
		Запись.Установить("СуммаПродажи", Результат.Поле("СуммаПродажи"));
		Запись.Установить("КоличествоТоваров", Результат.Поле("КоличествоТоваров"));
		
	КонецЦикла;
	
	// Отображаем отчет
	Форма.Элементы.ТаблицаДанных.Значение = ТаблицаДанных;
	Форма.Открыть();
	
КонецПроцедуры

&НаСервере
Процедура ОбработкаВыбораМенеджера(ВыбранныйМенеджер)
	
	// Получаем данные по выбранному менеджеру
	Если ВыбранныйМенеджер = Неопределено Тогда
		// Если не выбран конкретный менеджер - показываем все
		Возврат;
	КонецЕсли;
	
	// Формируем отчет для конкретного менеджера
	Запрос = Новый Запрос;
	Запрос.Текст = "
		ВЫБРАТЬ
			|	Менеджер.Имя,
			|	СуммаПродажи = Сумма(Продажа.СуммаОплаты),
			|	КоличествоТоваров = Сумма(Продажа.Количество)
		|ИЗ
			|	Документ.РеализацияТоваров.Продажа КАК Продажа,
			|	Справочник.Менеджеры.Менеджер КАК Менеджер
		|ГДЕ
			|	Продажа.Дата <= &КонецПериода
			|	И Продажа.Статус = ""Закрыто""
			|	И Продажа.Менеджер = &ВыбранныйМенеджер
		|ГРУППИРОВАТЬ ПО
			|	Менеджер.Имя";
	
	Запрос.УстановитьПараметр("КонецПериода", ТекущаяДата());
	Запрос.УстановитьПараметр("ВыбранныйМенеджер", ВыбранныйМенеджер);
	
	Результат = Запрос.Выполнить();
	
	// Обновляем отчет
	Если Результат.Следующий() Тогда
		// Обновление отчета в форме
		Форма = НайтиФорму("ФормаОтчетаПоПродажам");
		Если Форма <> Неопределено Тогда
			Форма.Элементы.ТаблицаДанных.Значение = ПолучитьТаблицуДанныхИзРезультата(Результат);
		КонецЕсли;
	КонецЕсли;
	
КонецПроцедуры

// Функция для получения таблицы данных из результата запроса
Функция ПолучитьТаблицуДанныхИзРезультата(Результат)
	
	ТаблицаДанных = Новый ТаблицаЗначений;
	ТаблицаДанных.Колонки.Добавить("Менеджер", Тип("Строка"));
	ТаблицаДанных.Колонки.Добавить("СуммаПродажи", Тип("Число"));
	ТаблицаДанных.Колонки.Добавить("КоличествоТоваров", Тип("Число"));
	
	Пока Результат.Следующий() Цикл
		Запись = ТаблицаДанных.Добавить();
		Запись.Установить("Менеджер", Результат.Поле("Менеджер"));
		Запись.Установить("СуммаПродажи", Результат.Поле("СуммаПродажи"));
		Запись.Установить("КоличествоТоваров", Результат.Поле("КоличествоТоваров"));
	КонецЦикла;
	
	Возврат ТаблицаДанных;
	
КонецФункции

Скорость генерации текста

Сайт с конфигуратором сервера

Калькулятор RAID

import argparse
import time
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from collections import defaultdict
import psutil
import os
import sys

class DiskHeatmap:
    def __init__(self, device_path, block_size=512):
        self.device_path = device_path
        self.block_size = block_size
        self.access_counts = defaultdict(int)
        self.total_blocks = 0
        self.is_running = False
        
    def get_disk_info(self):
        """Получение информации о диске"""
        try:
            # Получаем размер диска
            statvfs = os.statvfs(self.device_path)
            block_size = statvfs.f_frsize
            total_blocks = statvfs.f_blocks
            
            self.total_blocks = total_blocks
            return {
                'total_blocks': total_blocks,
                'block_size': block_size,
                'total_size': total_blocks * block_size
            }
        except Exception as e:
            print(f"Ошибка получения информации о диске: {e}")
            return None
    
    def monitor_disk_activity(self, duration=10):
        """Мониторинг активности диска в течение заданного времени"""
        print(f"Начинаем мониторинг диска {self.device_path} на {duration} секунд...")
        
        # Получаем начальное состояние
        initial_io = psutil.disk_io_counters()
        if not initial_io:
            print("Не удалось получить информацию о диске")
            return
            
        start_time = time.time()
        
        # Собираем данные о доступах
        while time.time() - start_time < duration:
            try:
                # Получаем текущую активность
                io_counters = psutil.disk_io_counters(perdisk=True)
                
                if self.device_path in io_counters:
                    current_io = io_counters[self.device_path]
                    
                    # Просто считаем количество операций (для примера)
                    # В реальности здесь нужно анализировать конкретные LBA
                    print(f"Данные: read_bytes={current_io.read_bytes}, write_bytes={current_io.write_bytes}")
                
                time.sleep(1)
                
            except KeyboardInterrupt:
                print("Остановка мониторинга...")
                break
            except Exception as e:
                print(f"Ошибка при мониторинге: {e}")
                time.sleep(1)
    
    def generate_sample_data(self):
        """Генерация симулированных данных для демонстрации"""
        print("Генерируем симулированные данные для тепловой карты...")
        
        # Генерируем случайные данные
        num_blocks = min(10000, self.total_blocks)  # Ограничиваем количество блоков
        
        # Создаем "горячие" зоны
        hot_zones = [
            (int(num_blocks * 0.2), int(num_blocks * 0.3)),  # Первая горячая зона
            (int(num_blocks * 0.7), int(num_blocks * 0.8)),  # Вторая горячая зона
        ]
        
        for i in range(num_blocks):
            count = 0
            
            # Увеличиваем счетчики для горячих зон
            for start, end in hot_zones:
                if start <= i < end:
                    count += np.random.poisson(10) + 5  # Горячие зоны
            
            # Добавляем случайные операции
            count += np.random.poisson(2)
            
            self.access_counts[i] = count
    
    def create_heatmap(self):
        """Создание тепловой карты"""
        if not self.access_counts:
            print("Нет данных для визуализации")
            return
            
        # Подготавливаем данные для визуализации
        num_blocks = len(self.access_counts)
        
        # Преобразуем данные в матрицу
        max_count = max(self.access_counts.values())
        heatmap_data = np.zeros(num_blocks)
        
        for block, count in self.access_counts.items():
            heatmap_data[block] = count
        
        # Создаем тепловую карту
        plt.figure(figsize=(15, 8))
        
        # Используем seaborn для лучшего вида
        sns.set_style("whitegrid")
        
        # Визуализация как линия с цветовой кодировкой
        x = np.arange(len(heatmap_data))
        y = heatmap_data
        
        # Создаем цветовую шкалу
        norm = plt.Normalize(vmin=0, vmax=max_count)
        colors = plt.cm.plasma(norm(y))
        
        # Рисуем график
        plt.figure(figsize=(15, 6))
        scatter = plt.scatter(x, y, c=y, cmap='plasma', alpha=0.7, s=1)
        
        # Добавляем цветовую шкалу
        cbar = plt.colorbar(scatter)
        cbar.set_label('Частота доступа')
        
        # Оси и заголовок
        plt.xlabel('LBA (Logical Block Addressing)')
        plt.ylabel('Количество операций')
        plt.title(f'Тепловая карта диска {self.device_path}\n(Горячие зоны отмечены высокой частотой доступа)')
        
        # Добавляем сетку для лучшей читаемости
        plt.grid(True, alpha=0.3)
        
        # Уменьшаем количество меток на оси X для лучшей читаемости
        plt.xticks(np.arange(0, len(heatmap_data), max(1, len(heatmap_data)//10)))
        
        plt.tight_layout()
        plt.show()
    
    def create_matrix_heatmap(self):
        """Создание тепловой карты в виде матрицы (для больших объемов)"""
        if not self.access_counts:
            print("Нет данных для визуализации")
            return
            
        # Преобразуем данные в двумерную матрицу
        num_blocks = len(self.access_counts)
        
        # Выбираем размеры матрицы (для демонстрации)
        rows, cols = 100, min(1000, num_blocks)
        
        # Создаем матрицу данных
        matrix_data = np.zeros((rows, cols))
        
        for i in range(rows):
            for j in range(cols):
                block_index = int(i * (num_blocks / rows) + j * (num_blocks / cols))
                if block_index < num_blocks:
                    matrix_data[i, j] = self.access_counts.get(block_index, 0)
        
        # Визуализация матрицы
        plt.figure(figsize=(12, 8))
        
        # Используем тепловую карту seaborn
        sns.heatmap(matrix_data, cmap='plasma', cbar_kws={'label': 'Частота доступа'})
        
        plt.title(f'Тепловая карта диска {self.device_path}')
        plt.xlabel('LBA (Logical Block Addressing)')
        plt.ylabel('Блоки')
        
        plt.tight_layout()
        plt.show()
    
    def save_data(self, filename):
        """Сохранение данных в файл"""
        try:
            with open(filename, 'w') as f:
                for block, count in sorted(self.access_counts.items()):
                    f.write(f"{block},{count}\n")
            print(f"Данные сохранены в {filename}")
        except Exception as e:
            print(f"Ошибка при сохранении данных: {e}")

def main():
    parser = argparse.ArgumentParser(description='Утилита для мониторинга и визуализации тепловой карты диска')
    parser.add_argument('device', help='Путь к устройству (например, /dev/sda)')
    parser.add_argument('--duration', type=int, default=10, help='Длительность мониторинга в секундах')
    parser.add_argument('--output', help='Файл для сохранения данных')
    parser.add_argument('--matrix', action='store_true', help='Использовать матричную визуализацию')
    
    args = parser.parse_args()
    
    # Проверка существования устройства
    if not os.path.exists(args.device):
        print(f"Устройство {args.device} не существует")
        sys.exit(1)
    
    # Создание объекта тепловой карты
    heatmap = DiskHeatmap(args.device)
    
    # Получаем информацию о диске
    disk_info = heatmap.get_disk_info()
    if not disk_info:
        print("Не удалось получить информацию о диске")
        sys.exit(1)
    
    print(f"Информация о диске:")
    print(f"  Путь: {args.device}")
    print(f"  Всего блоков: {disk_info['total_blocks']}")
    print(f"  Размер блока: {disk_info['block_size']} байт")
    print(f"  Общий размер: {disk_info['total_size'] / (1024**3):.2f} ГБ")
    
    # Симулируем мониторинг и генерируем данные
    heatmap.generate_sample_data()
    
    # Визуализация
    if args.matrix:
        heatmap.create_matrix_heatmap()
    else:
        heatmap.create_heatmap()
    
    # Сохранение данных при необходимости
    if args.output:
        heatmap.save_data(args.output)

if __name__ == "__main__":
    main()

Калькулятор TCO

Аркада про системного администратора

Выводы

Автор: Serverflow

Поделиться