Как научиться рерайтингу с нуля


Как научиться рерайтингу: техники и приёмы

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

Содержание статьи

Что такое рерайтинг простыми словами

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

На западе копирайтерами называют специалистов по рекламе, сочиняющих слоганы и продающие тексты. Статьи для информационных и развлекательных ресурсов пишут website content writers. Что на русский переводится как веб-райтеры. А под рерайтингом понимают технику переработки, переписывания текста своими словами, но с сохранением смысла.

Если пользоваться зарубежной терминологией, рерайтинг — лишь частный случай веб-райтинга. Копировать тексты в интернете нельзя, чтобы не нарушать авторские права. Поэтому для создания оригинального контента SEO-оптимизаторы и владельцы сайтов заказывают рерайтинг статей с других ресурсов.

Копирайтером работал герой Мела Гибсона в фильме «Чего хотят женщины»

Когда заказчик просит веб-райтера использовать для статьи несколько источников, это не рерайтинг. Исполнитель не просто переделывает текст так, чтобы он отличался от оригинала. Он тратит время на сбор материала, погружается в тему, обдумывает структуру статьи. Такая работа сложнее, и расценки за неё выше.

Виды рерайтинга

Рерайтинг делят на поверхностный и глубокий.

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

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

Иногда в отдельное направление выделяют SEO-рерайтинг. Его главное отличие от других форматов — использование в статье ключевых слов. Они нужны для оптимизации сайта под поисковые запросы. Заказчик приводит в техническом задании список ключевых слов и фраз и указывает их количество. SEO-рерайтинг как самостоятельное направление мы рассматривать не будем. К нему применяют приёмы глубокого рерайтинга.

Как делать поверхностный рерайтинг

Инструментов поверхностного рерайтинга несколько.

 БылоСтало

Замена слов синонимами

Учёные обнаружили новые препятствия для переселения людей на другую планету.

Учёные нашли новые преграды для переселения людей на новую планету.

Преобразование прямой речи в косвенную
Министр экологии заявил: «В строительстве мусоросжигательных заводов нет коррупционной составляющей».Министр экологии отрицает коррупционную составляющую в строительстве мусоросжигательных заводов.

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

Изменение синтаксиса

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

Совет. Для подбора синонимов используйте онлайн-словари, например синонимонлайн.ру или синоним.орг. Существуют также сервисы для рерайтинга целых фрагментов текста: онлайн синомайзер текста или USyn.

Вот какой рерайт одного из абзацев этой статьи выдал usyn.ru.

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

Техника глубокого рерайтинга

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

  • Анализ информации

Рерайтинг начинайте с вдумчивого

Архитектура

- Когда переписывать кодовую базу с нуля

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. работы Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании
,

6 шагов для написания любого алгоритма машинного обучения с нуля: пример использования Perceptron | Джон Салливан

Написание алгоритма машинного обучения с нуля - чрезвычайно полезный опыт обучения.

Он дает вам это «ах-ха!» момент, когда он наконец щелкает, и вы понимаете, что на самом деле происходит под капотом.

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

Я проведу вас через следующий 6-шаговый процесс написания алгоритмов с нуля, используя Perceptron в качестве примера:

  1. Получите общее представление об алгоритме
  2. Найдите несколько различных источников обучения
  3. Разбейте алгоритм на фрагменты
  4. Начните с простого примера
  5. Подтвердите с помощью надежной реализации
  6. Напишите свой процесс

Это восходит к тому, что я изначально сказал. Если вы не понимаете основ, не беритесь за алгоритм с нуля.

По крайней мере, вы должны быть в состоянии ответить на следующие вопросы:

  • Что это?
  • Для чего он обычно используется?
  • Когда я НЕ МОГУ этим пользоваться?

Что касается персептрона, давайте продолжим и ответим на следующие вопросы:

  • Однослойный персептрон - это самая простая нейронная сеть. Обычно он используется для задач двоичной классификации (1 или 0, «да» или «нет»).
  • Некоторыми простыми применениями могут быть анализ настроений (положительный или отрицательный ответ) или прогнозирование дефолта по ссуде («дефолт», «не дефолт»).В обоих случаях граница принятия решения должна быть линейной.
  • Если граница принятия решения нелинейна, вы действительно не можете использовать персептрон. Для этих задач вам нужно будет использовать что-то другое.

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

Кто-то лучше учится по учебникам, кто-то - по видео.

Лично я люблю прыгать и использовать различные типы источников.

Что касается математических деталей, то учебники отлично справляются с задачей, но для более практических примеров я предпочитаю сообщения в блогах и видео на YouTube.

Вот несколько замечательных источников для персептрона:

Учебники

Блоги

Видео

Теперь, когда мы собрали наши источники, пора приступить к обучению.

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

Запишите пункты списка и попытайтесь обрисовать алгоритм.

Пройдя по источникам, я разбил Персептрон на следующие 5 частей:

  1. Инициализирую веса
  2. Умножьте веса на входные и просуммируйте их
  3. Сравните результат с порогом для вычисления вывода (1 или 0)
  4. Обновить веса
  5. Повторить

Давайте подробно рассмотрим каждый.

1. Инициализируйте веса

Для начала мы инициализируем вектор весов.

Количество весов должно соответствовать количеству функций. Предполагая, что у нас есть три функции, вот как будет выглядеть вектор весов

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

Затем мы умножим веса на входные данные, а затем просуммируем их.

Чтобы упростить работу, я раскрасил веса и соответствующие им элементы в первой строке.

После того, как мы умножим веса на характеристики, мы суммируем их. Это также известно как скалярное произведение.

Окончательный результат - 0. Я буду обозначать этот временный результат как «f».

После вычисления скалярного произведения нам нужно сравнить его с пороговым значением.

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

Поскольку скалярное произведение «f», которое мы вычислили (0), не превышает нашего порогового значения (0), наша оценка равна нулю.

Я обозначил оценку как y со шляпой (также известной как «y hat»), с нижним индексом 0, чтобы соответствовать первой строке. Вместо этого вы могли бы использовать 1 для первой строки, это не имеет значения. Я просто решил начать с 0.

Если мы сравним этот результат с фактическим значением, мы увидим, что наши текущие веса неверно предсказывают фактический результат.

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

Теперь мы обновим веса.Вот уравнение, которое мы собираемся использовать:

Основная идея состоит в том, что мы корректируем текущий вес на итерации «n», чтобы получить новый вес для использования в следующей итерации, «n + 1».

Чтобы настроить вес, нам нужно установить «скорость обучения». Обозначается это греческой буквой «эта».

Я выбрал 0,1 для скорости обучения, но вы можете поэкспериментировать с другими числами, как и с порогом.

Вот краткое изложение того, что у нас есть на данный момент:

А теперь давайте посчитаем новые веса для итерации n = 2.

Мы успешно завершили первую итерацию алгоритма персептрона.

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

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

Один полный просмотр набора данных известен как «эпоха».

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

Мы можем установить общее количество итераций или эпох, чтобы продолжить выполнение алгоритма.Может быть, мы хотим указать 30 итераций (или 10 эпох).

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

На следующей итерации мы переходим ко второй строке функций.

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

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

Теперь, когда мы вручную разбили алгоритм на части, пора приступить к его реализации в коде.

Для простоты я всегда люблю начинать с очень небольшого «игрушечного набора данных».

Хорошим маленьким линейно разделяемым набором данных для этого типа проблем является вентиль NAND. Это обычный логический вентиль, используемый в цифровой электронике.

Поскольку это довольно небольшой набор данных, мы можем просто вручную ввести его в Python.

Я собираюсь добавить фиктивный объект «x0», который представляет собой столбец из единиц.Я сделал это для того, чтобы наша модель рассчитала член смещения.

Вы можете думать о смещении как о члене перехвата, который правильно позволяет нашей модели разделить два класса.

Вот код для ввода данных:

 # Импорт библиотек 
# NAND Gate
# Примечание: x0 - фиктивная переменная для члена смещения
# x0 x1 x2
x = [[1., 0., 0 .],
[1., 0., 1.],
[1., 1., 0.],
[1., 1., 1.]] y = [1.,
1.,
1.,
0.]

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

Первым шагом является инициализация весов.

 # Инициализировать веса 
import numpy as np
w = np.zeros (len (x [0])) Out:
[0. 0. 0.]

Имейте в виду, что длина вектора весов должна чтобы соответствовать количеству функций. В этом примере логического элемента И-НЕ эта длина равна 3.

Далее мы умножим веса на входные данные, а затем просуммируем их.

Другое название для этого - «скалярное произведение».

Опять же, мы можем использовать Numpy, чтобы легко выполнить эту операцию.Мы будем использовать метод .dot () .

Давайте начнем с скалярного произведения весового вектора и первой строки функций.

 # Dot Product 
f = np.dot (w, x [0])
print fOut:
0,0

Как и ожидалось, результат равен 0.

Чтобы не противоречить нашим примечаниям в предыдущем разделе, я назначил скалярное произведение на переменную «f».

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

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

Я собираюсь сделать порог «z» равным 0. Если скалярное произведение «f» больше 0, наш прогноз будет 1. В противном случае он будет равен нулю.

Имейте в виду, что прогноз обычно обозначается с отметкой в ​​каратах сверху, также известной как «шляпа». Переменная, которой я назначу прогноз, - yhat .

 # Функция активации 
z = 0,0
, если f> z:
yhat = 1.
else:
yhat = 0.

print yhat

Out:
0.0

Как и ожидалось, прогноз равен 0.

Вы заметите, что в примечании над кодом я назвал это «функцией активации». Это более формальное описание того, что мы делаем.

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

Теперь, когда мы сделали прогноз, мы готовы обновить веса.

Нам нужно будет установить скорость обучения, прежде чем мы сможем это сделать. Чтобы соответствовать нашему предыдущему примеру, я присвою скорости обучения «eta» значение 0,1.

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

 # Обновить веса 
eta = 0,1
w [0] = w [0] + eta * (y [0] - yhat) * x [0] [0]
w [1] = w [1] + eta * (y [0] - yhat) * x [0] [1]
w [2] = w [2] + eta * (y [0] - yhat) * x [0] [2]

напечатать w

Out:
[0.1 0. 0.]

Мы видим, что наши веса обновлены, так что мы готовы продолжать работу.

Теперь, когда мы проработали каждый шаг, пришло время собрать все воедино.

Последняя часть, которую мы не обсуждали, - это наша функция потерь. Это функция, которую мы пытаемся минимизировать, в нашем случае это ошибка суммы квадратов (SSE).

Это то, что мы будем использовать, чтобы вычислить нашу ошибку и посмотреть, как работает модель.

Собирая все вместе, вот как выглядит полная функция:

 import numpy as np 

# Perceptron function
def perceptron (x, y, z, eta, t):
'' '
Input Parameters:
x : набор данных входных характеристик
y: фактические выходы
z: порог функции активации
eta: скорость обучения
t: количество итераций
'' '

# инициализация весов
w = np.zeros (len (x [0]))
n = 0

# инициализация дополнительных параметров для вычисления суммы квадратов ошибок
yhat_vec = np.ones (len (y)) # вектор для прогнозов
errors = np.ones (len (y)) # вектор ошибок (фактический - прогнозы)
J = [] # вектор для функции затрат SSE

while n = z:
yhat = 1.
else:
yhat = 0.
yhat_vec [i] = yhat

# обновление весов
для j в xrange (0, len (w)):
w [j] = w [j] + eta * (y [i] -yhat) * x [i] [j]

n + = 1
# вычисление суммы квадратов ошибок
для i в xrange (0, len (y)):
errors [i] = (y [i] -yhat_vec [i]) ** 2
J.append (0,5 * np.sum (errors))

return w, J

Теперь, когда мы закодировали полный Персептрон, давайте продолжим и запустите его:

 # x0 x1 x2 
x = [[1., 0., 0.],
[1., 0., 1.],
[1., 1., 0.],
[1., 1., 1.]]

y = [1. ,
1.,
1.,
0.]

z = 0,0
eta = 0,1
t = 50

print "Веса:"
print perceptron (x, y, z, eta, t) [ 0]

print "Ошибки:"
print perceptron (x, y, z, eta, t) [0]

Out:
Веса:
[0,2 -0,2 -0,1]
Ошибки:
[0,5, 1,5, 1,5, 1,0, 0,5, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0.0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0]

Взглянув на ошибки, мы видим, что ошибка упала до 0 примерно на 6-й итерации. Для оставшейся части итераций оно оставалось равным 0.

Когда ошибка переходит в 0 и остается на этом уровне, мы знаем, что наша модель сходится. Это говорит нам о том, что наша модель правильно «выучила» соответствующие веса.

В следующем разделе мы будем использовать наши вычисленные веса на большом наборе данных
, чтобы делать прогнозы.

К этому моменту мы нашли различные учебные ресурсы, проработали алгоритм вручную и протестировали его в коде на простом примере.

Пришло время сравнить наши результаты с проверенной реализацией. Для сравнения воспользуемся перцептроном из scikit-learn.

Мы проведем это сравнение, выполнив следующие шаги:

  1. Импорт данных
  2. Разделение данных на наборы для обучения / тестирования
  3. Обучите наш Perceptron
  4. Протестируйте Perceptron
  5. Сравните с Perceptron
  6. scikit-learn

Начнем с импорта данных.Вы можете получить копию набора данных здесь.

Это линейно разделяемый набор данных, который я создал, чтобы убедиться, что Perceptron будет работать. Просто для подтверждения, давайте продолжим и построим данные.

 import pandas as pd 
import numpy as np
import matplotlib.pyplot as plt

df = pd.read_csv ("dataset.csv")
plt.scatter (df.values ​​[:, 1], df.values ​​[: , 2], c = df ['3'], alpha = 0.8)

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

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

Я использовал Pandas для импорта csv, который автоматически помещает данные в фрейм данных.

Для построения графика данных мне пришлось вытащить значения из фрейма данных, поэтому я использовал метод .values ​​.

Характеристики находятся в столбцах 1 и 2, поэтому я использовал их в функции диаграммы рассеяния. Столбец 0 - это фиктивная функция единиц, которую я включил, чтобы вычислить точку пересечения. Это должно быть знакомо тому, что мы делали с вентилем NAND в предыдущем разделе.

Наконец, я раскрасил два класса, используя c = df ['3'], alpha = 0.8 в функции диаграммы рассеяния. Результатом являются данные в столбце 3 (0 или 1), поэтому я сказал функции раскрасить два класса, используя столбец «3».

Дополнительную информацию о функции диаграммы рассеяния Matplotlib можно найти здесь.

Теперь, когда мы подтвердили, что данные можно разделить линейно, пора разделить данные.

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

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

Начну с перемешивания данных. Если вы посмотрите на исходный файл, вы увидите, что данные сгруппированы по строкам с 0 в выводе (третий столбец), а затем следуют все единицы. Я хочу встряхнуть и добавить немного случайности, поэтому я собираюсь перемешать это.

 df = df.values ​​

np.random.seed (5)
np.random.shuffle (df)

Я начал с изменения данных из фрейма данных в массив numpy. Это упростит работу с множеством функций numpy, которые я собираюсь использовать, например .shuffle .

Чтобы результаты были воспроизводимы для вас, я установил случайное начальное число (5). После того, как мы закончим, попробуйте изменить случайное начальное число и посмотрите, как изменятся результаты.

Далее я разделю 70% моих данных на обучающий набор и 30% на тестовый набор.

 поезд = df [0: int (0.7 * len (df))] 
test = df [int (0.7 * len (df)): int (len (df))]

Последний шаг - разделить функции и выходные данные для обучения и тестирования. наборы.

 x_train = train [:, 0: 3] 
y_train = train [:, 3]

x_test = test [:, 0: 3]
y_test = test [:, 3]

Я выбрал 70% / 30 % для моих наборов поездов / тестов только для этого примера, но я рекомендую вам изучить другие методы, такие как перекрестная проверка в k-кратном размере.

Далее мы обучим нашего персептрона.

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

 def perceptron_train (x, y, z, eta, t): 
''
Входные параметры:
x: набор данных входных функций
y: фактические выходы
z: порог функции активации
eta: скорость обучения
t : количество итераций
'' '

# инициализация весов
w = np.zeros (len (x [0]))
n = 0

# инициализация дополнительных параметров для вычисления суммы квадратов ошибок
yhat_vec = np ,ones (len (y)) # вектор для прогнозов
errors = np.ones (len (y)) # вектор для ошибок (фактические - прогнозы)
J = [] # вектор для функции стоимости SSE

while n = z:
yhat = 1.
else:
yhat = 0.
yhat_vec [i] = yhat

# обновление весов
для j в xrange (0, len (w)):
w [j] = w [j] + eta * (y [i] -yhat) * x [i] [j]

n + = 1
# вычисление суммы квадратов ошибок
для i в xrange (0, len (y)):
errors [i] = (y [i] -yhat_vec [ i]) ** 2
J.append (0,5 * np.sum (errors))

return w, J

z = 0,0
eta = 0,1
t = 50

perceptron_train (x_train, y_train, z, eta , t)

Давайте продолжим и посмотрим на веса и ошибку суммы квадратов.

 w = perceptron_train (x_train, y_train, z, eta, t) [0] 
J = perceptron_train (x_train, y_train, z, eta, t) [1]

print w
print J

Out:
[-0.5 -0,29850122 0,35054929]
[4,5, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0]

Веса сейчас не имеют для нас большого значения, но мы будем использовать эти числа в следующем разделе для тестирования нашего Персептрона.Мы также будем использовать веса, чтобы сравнить нашу модель с моделью scikit-learn.

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

Пришло время протестировать наш персептрон. Для этого мы создадим небольшую функцию perceptron_test .

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

Единственная деталь, которую мы не видели, - это precision_score . Это метрическая функция оценки от scikit-learn. Вы можете узнать об этом подробнее здесь.

Собирая все это вместе, вот как выглядит код:

 из sklearn.metrics import precision_score 

w = perceptron_train (x_train, y_train, z, eta, t) [0]

def perceptron_test (x, w, z, eta, t):
y_pred = []
для i в xrange (0, len (x-1)):
f = np.dot (x [i], w)

# функция активации
if f > z:
yhat = 1
else:
yhat = 0
y_pred.append (yhat)
return y_pred

y_pred = perceptron_test (x_test, w, z, eta, t)

print "Оценка точности:"
print precision_score (y_test, y_pred)

Out:
Оценка точности:
1,0

Оценка 1,0 означает, что наша модель правильно сделала прогнозы на всех тестовых данных. Этот набор данных четко разделяется, поэтому мы ожидаем такого результата.

Последний шаг - сравнить наши результаты с Perceptron из scikit-learn. Вот код этой модели:

 от sklearn.linear_model import Perceptron 

# обучение sklearn Perceptron
clf = Perceptron (random_state = None, eta0 = 0.1, shuffle = False, fit_intercept = False)
clf.fit (x_train, y_train)
y_predict = clf_test.predict (x

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

 Out: 
Вес склеарна:
[-0,5 -0,29850122 0,35054929]
Вес моих перцептронов:
[-0,5 -0,29850122 0,35054929]

Веса из модели scikit-learn идентичны нашим весам.Это означает, что наша модель работает правильно, и это отличная новость.

Прежде чем мы подведем итоги, нужно остановиться на нескольких незначительных моментах. В модели scikit-learn нам нужно было установить случайное состояние на «None» и выключить перемешивание. Мы уже установили случайное начальное число и перетасовали данные, поэтому нам не нужно было делать это снова.

Нам также пришлось установить скорость обучения «eta0» на 0,1, чтобы она была идентична нашей модели.

Последняя точка - перехват. Поскольку мы уже включили столбец фиктивных функций с единицами, мы автоматически настраивали перехват, поэтому нам не нужно было включать его в scikit-learn Perceptron.

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

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

Этот последний шаг в процессе, вероятно, самый важный.

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

Описание процесса важно по двум причинам:

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

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

Отличный способ продемонстрировать свою работу - портфолио GitHub Pages.

В этом посте мы узнали, как реализовать Perceptron с нуля.

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

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

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

.Рефакторинг

- Новичок спрашивает опытных программистов: Переписать с нуля - рекомендуется или нет?

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. работы Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании
,

Смотрите также