Регуляризация отсева с использованием PyTorch в Python

Как реализовать регуляризацию отсева с помощью PyTorch в Python

Узнайте о важности регуляризации отсева и о том, как ее применять в среде глубокого обучения PyTorch на Python.

Вступление

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

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

Мы также увидим график потерь на тестовом наборе во времени в нейронной сети с отсевом и без него.

Содержание:

• Вступление
• Настройка всего
• Обучение нейронной сети без отсева
• Общие проблемы в нейронных сетях
  • Переоснащение
  • Бэгинг
• Представляем отсев
  • Случайное удаление узлов
  • Уровень отсева
  • Практические советы по регуляризации отсева
  • Отсев при выводе
  • Примеры использования Dropout
• Обучение нейронной сети с помощью Dropout
• Вывод

---

Настройка всего

Для демонстрации мы будем использовать набор данных MNIST, доступный в библиотеке torchvision. Давайте установим все зависимости этого руководства:

$ pip install matplotlib==3.4.3 numpy==1.21.5 torch==1.10.1 torchvision

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

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

Давайте удостоверимся, что мы тренируемся с использованием GPU, если CUDA доступна:

# defining our device, 'cuda:0' if CUDA is available, 'cpu' otherwise
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
device

device(type='cuda', index=0)

Давайте создадим конвейер преобразования для нашего набора данных MNIST:

# make the transform pipeline, converting to tensor and normalizing
transform = transforms.Compose([
  transforms.ToTensor(),
  transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# the batch size during training
batch_size = 64

Затем загружаем обучающий набор данных:

train_dataset = torchvision.datasets.CIFAR10(root="./data", train=True, 
                                             download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)

Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
170499072/? [00:06<00:00, 29640614.08it/s]
Extracting ./data/cifar-10-python.tar.gz to ./data

Мы переходим Trueк, trainчтобы указать обучающий набор данных, и мы также устанавливаем download, чтобы Trueзагрузить набор данных в указанную dataпапку. После этого мы делаем наш DataLoader, передаем batch_sizeи shuffleустанавливаем True.

Аналогично для тестового набора:

test_dataset = torchvision.datasets.CIFAR10(root="./data", train=False, 
                                             download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)

Files already downloaded and verified

На этот раз мы собираемся trainполучить Falseтестовый набор.

Ниже приведены доступные классы в наборе данных MNIST:

# the MNIST classes
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

Обучение нейронной сети без отсева

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

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = torch.flatten(x, 1) # flatten all dimensions except batch
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()
# switch to GPU if available
net.to(device)

Инициализация кросс-энтропийной потери и оптимизатора SGD :

import torch.optim as optim

# defining the loss and the optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

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

def get_test_loss(net, criterion, data_loader):
  """A simple function that iterates over `data_loader` to calculate the overall loss"""
  testing_loss = []
  with torch.no_grad():
    for data in data_loader:
      inputs, labels = data
      # get the data to GPU (if available)
      inputs, labels = inputs.to(device), labels.to(device)
      outputs = net(inputs)
      # calculate the loss for this batch
      loss = criterion(outputs, labels)
      # add the loss of this batch to the list
      testing_loss.append(loss.item())
  # calculate the average loss
  return sum(testing_loss) / len(testing_loss)

Эта функция нам понадобится во время обучения. Приступаем к обучению прямо сейчас:

training_loss, testing_loss = [], []
running_loss = []
i = 0
for epoch in range(150): # 150 epochs
  for data in train_loader:
    inputs, labels = data
    # get the data to GPU (if available)
    inputs, labels = inputs.to(device), labels.to(device)
    optimizer.zero_grad()
    # forward pass
    outputs = net(inputs)
    # backward pass
    loss = criterion(outputs, labels)
    loss.backward()
    # update gradients
    optimizer.step()
    running_loss.append(loss.item())
    i += 1
    if i % 1000 == 0:
      avg_train_loss = sum(running_loss) / len(running_loss)
      avg_test_loss = get_test_loss(net, criterion, test_loader)
      # clear the list
      running_loss.clear()
      # for logging & plotting later
      training_loss.append(avg_train_loss)
      testing_loss.append(avg_test_loss)
      print(f"[{epoch:2d}] [it={i:5d}] Train Loss: {avg_train_loss:.3f}, Test Loss: {avg_test_loss:.3f}")

print("Done training.")

Выход:

[ 1] [it= 1000] Train Loss: 2.273, Test Loss: 2.118
[10] [it= 8000] Train Loss: 1.312, Test Loss: 1.326
[20] [it=16000] Train Loss: 1.031, Test Loss: 1.120
[30] [it=24000] Train Loss: 0.854, Test Loss: 1.043
[40] [it=32000] Train Loss: 0.718, Test Loss: 1.051
[51] [it=40000] Train Loss: 0.604, Test Loss: 1.085
[60] [it=47000] Train Loss: 0.521, Test Loss: 1.178
[70] [it=55000] Train Loss: 0.425, Test Loss: 1.370
[80] [it=63000] Train Loss: 0.348, Test Loss: 1.518
[93] [it=73000] Train Loss: 0.268, Test Loss: 1.859
[99] [it=78000] Train Loss: 0.248, Test Loss: 2.036
[109] [it=86000] Train Loss: 0.200, Test Loss: 2.351
[120] [it=94000] Train Loss: 0.161, Test Loss: 2.610
[130] [it=102000] Train Loss: 0.142, Test Loss: 2.976
[140] [it=110000] Train Loss: 0.117, Test Loss: 3.319
[149] [it=117000] Train Loss: 0.095, Test Loss: 3.593
Done training.

Общие проблемы в нейронных сетях

Переоснащение

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

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

Бэгинг

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

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

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

Представляем отсев

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

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

На обучающих данных нейроны учатся исправлять ошибки, допущенные их сверстниками, — процесс, известный как коадаптация. Следовательно, способность сети соответствовать обучающим данным резко улучшается. Поскольку коадаптации адаптированы к особенностям обучающих данных, они не будут обобщаться на тестовые данные; следовательно, он становится более изменчивым.

Нитиш Сривастава, Илья Суцкевер, Джеффри Хинтон, Алекс Крижевский и Руслан Салахутдинов были первыми, кто предложил отсев, чтобы минимизировать эффекты нейронной коадаптации.
 

 

Источник:  газета .

Случайное удаление узлов

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

Выпадение относится к удалению единиц (как скрытых, так и явных) из нейронной сети. Удаление устройства означает временное удаление его из сети, включая все его входящие и исходящие соединения. Dropout имитирует разреженную активацию с заданного уровня, что подталкивает сеть к изучению разреженного представления в качестве побочного эффекта. Его можно использовать вместо регуляризации активности для поощрения разреженных представлений в моделях автокодировщика.

Уровень отсева

Dropout добавляет новый гиперпараметр: вероятность сохранения единицы p. Этот гиперпараметр управляет степенью отсева.

Отсева нет, когда p = 1, а низкие значения p указывают на то, что отсева много. Для скрытых блоков типичные значения p находятся в диапазоне от 0,5 до 0,8.

Тип ввода влияет на выбор входных слоев. Типичное значение для входных данных с действительным знаком (изображения или звуковые кадры) равно 0,8.

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

Когда p велико, Dropout может быть недостаточно, чтобы избежать переобучения. На определенном уровне единицы будут иметь 70%-й шанс оставаться активным и 30%-й риск быть удаленным, если вероятность удержания на этом уровне составляет 0,7%.

Обратите внимание, что PyTorch и другие фреймворки для глубокого обучения используют коэффициент отсева вместо коэффициента сохранения p, коэффициент сохранения 70% означает коэффициент отсева 30% и т. д.

Практические советы по регуляризации отсева

• Частота отсева : значение гиперпараметра отсева по умолчанию — это вероятность обучения определенного узла в слое, где 1,0 означает отсутствие отсева, а 0,0 — отсутствие выходных данных слоя.
• Использование более широкой сети : более крупные сети (с большим количеством слоев или узлов) более склонны к переоснащению обучающих данных. При использовании регуляризации отсева можно использовать более крупные сети с меньшей опасностью переобучения.
• Grided Search Parameters : методически тестируйте различные показатели, а не предполагайте разумный процент отсева для вашей сети. Методично тестируйте различные скорости. Вы можете тестировать значения в диапазоне от 1,0 до 0,1 с шагом 0,1.
• Используйте ограничение по весу : веса сети будут расти из-за вероятностного устранения активаций слоев. Значительный размер веса может указывать на нестабильную сеть. Чтобы противодействовать этому эффекту, может применяться ограничение по весу, чтобы заставить норму (величину) всех весов в слое быть меньше определенного значения.

Отсев при выводе

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

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

Таким образом, нейроны в последующем слое будут перевозбуждены, если вы используете 50-процентный коэффициент отсева во время обучения и удаляете два из каждых четырех нейронов в слое. Таким образом, значения, выдаваемые этими нейронами, будут на 50% больше, чем необходимо. Вероятность удержания (1 — показатель отсева) используется для уменьшения веса сверхактивированных нейронов во время тестирования и вывода. На рисунке ниже, созданном участником  Datascience Stackexchange Дмитрием Прилипко , прекрасно показано, как это работает:

Примеры использования Dropout

Впервые представленный Джеффри Хинтоном и его коллегами в их статье 2012 года под названием « Улучшение нейронных сетей путем предотвращения совместной адаптации детекторов признаков », отсев был применен к широкому кругу типов задач, включая классификацию фотографий (CIFAR-10), распознавание рукописных цифр (MNIST). ) и распознавание речи (TIMIT).

В этой статье можно вывести некоторые интересные факты о приложениях отсева в наборе данных MNIST.
 

• MNIST, широко используемый тест для систем машинного обучения, был использован для изучения эффективности отсева. В базу данных включены 60 000 обучающих фотографий рукописных цифр размером 28x28 и 10 000 тестовых изображений.
• Улучшение обучающих данных с помощью преобразованных изображений или подключение знаний о пространственном преобразовании к сверточной нейронной сети или использование генеративного предварительного обучения для извлечения полезных функций из обучающих изображений без использования меток может значительно повысить производительность на тестовом наборе.
• Наилучшая оценка для обычной нейронной сети с прямой связью составляет 160 ошибок на тестовом наборе без применения какой-либо из этих стратегий.
  При удалении случайных 20 процентов пикселей количество ошибок может быть снижено примерно до 130 и даже до 110 за счет применения отдельных ограничений L2 к входящим весам каждой скрытой единицы.
• Отсев сочетался с генеративным предварительным обучением, но использовалась лишь небольшая скорость обучения. Никаких ограничений по весу не применялось, чтобы предотвратить потерю детекторов признаков, определенных в ходе предварительной подготовки. После точной настройки с использованием обычного обратного распространения общедоступная предварительно обученная сеть глубокого убеждения допустила 118 ошибок и в общей сложности 92 ошибки после точной настройки с использованием 50-процентного отсева скрытых единиц.
• На приведенном ниже рисунке представлены нейронные сети, обученные с использованием обратного распространения с использованием 50% отсева для всех скрытых слоев в тестовом наборе MNIST, а отсев составляет 20% для самого низкого набора строк. На горизонтальной линии отображается лучший ранее зарегистрированный результат с использованием обратного распространения без предварительной тренировки, распределения веса или обновлений тренировочной сессии. 
   

 

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

Используя глубокие сверточные нейронные сети с регуляризацией отсева, Алекс Крижевский и др. В своей публикации 2012 года « Классификация ImageNet с глубокими свёрточными нейронными сетями » получили самые современные результаты для классификации изображений в наборе данных ImageNet.

Обучение нейронной сети с помощью Dropout

Подход Dropout — отличная иллюстрация того, как PyTorch сделал программирование простым и понятным.

С помощью двух строк кода мы можем достичь нашей цели, которая поначалу кажется сложной. Нам просто нужно добавить дополнительный слой исключения при разработке нашей модели. torch.nn.Dropout()Для этого будет использоваться класс .

Некоторые элементы входного тензора деактивируются этим классом случайным образом во время обучения. Параметр p дает вероятность деактивации нейрона. Эта опция имеет значение по умолчанию 0,5, что означает, что половина нейронов выпадет. Выходные данные масштабируются с коэффициентом 1/1-p, что указывает на то, что модуль просто вычисляет функцию идентичности во время оценки.

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

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

class NetDropout(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.do1 = nn.Dropout(0.2)  # 20% Probability
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.do2 = nn.Dropout(0.2)  # 20% Probability
        self.fc2 = nn.Linear(120, 84)
        self.do3 = nn.Dropout(0.1)  # 10% Probability
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.do1(x)
        x = torch.flatten(x, 1) # flatten all dimensions except batch
        x = F.relu(self.fc1(x))
        x = self.do2(x)
        x = F.relu(self.fc2(x))
        x = self.do3(x)
        x = self.fc3(x)
        return x


net_dropout = NetDropout()
net_dropout.to(device)

Проведем тренировку как раньше:

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net_dropout.parameters(), lr=0.001, momentum=0.9)

training_loss_d, testing_loss_d = [], []
running_loss = []
i = 0
for epoch in range(150): # 10 epochs
  for data in train_loader:
    inputs, labels = data
    # get the data to GPU (if available)
    inputs, labels = inputs.to(device), labels.to(device)

    optimizer.zero_grad()
    # forward pass
    outputs = net_dropout(inputs)
    # backward pass
    loss = criterion(outputs, labels)
    loss.backward()
    # update gradients
    optimizer.step()
    running_loss.append(loss.item())
    i += 1
    if i % 1000 == 0:
      avg_train_loss = sum(running_loss) / len(running_loss)
      avg_test_loss = get_test_loss(net_dropout, criterion, test_loader)
      # clear the list
      running_loss.clear()
      # for logging & plotting later
      training_loss_d.append(avg_train_loss)
      testing_loss_d.append(avg_test_loss)
      print(f"[{epoch:2d}] [it={i:5d}] Train Loss: {avg_train_loss:.3f}, Test Loss: {avg_test_loss:.3f}")

print("Done training.")

[ 1] [it= 1000] Train Loss: 2.302, Test Loss: 2.298
[10] [it= 8000] Train Loss: 1.510, Test Loss: 1.489
[20] [it=16000] Train Loss: 1.290, Test Loss: 1.318
[30] [it=24000] Train Loss: 1.167, Test Loss: 1.214
[40] [it=32000] Train Loss: 1.085, Test Loss: 1.154
[49] [it=39000] Train Loss: 1.025, Test Loss: 1.141
[60] [it=47000] Train Loss: 0.979, Test Loss: 1.113
[70] [it=55000] Train Loss: 0.936, Test Loss: 1.082
[80] [it=63000] Train Loss: 0.902, Test Loss: 1.088
[90] [it=71000] Train Loss: 0.880, Test Loss: 1.087
[99] [it=78000] Train Loss: 0.856, Test Loss: 1.090
[109] [it=86000] Train Loss: 0.843, Test Loss: 1.094
[120] [it=94000] Train Loss: 0.818, Test Loss: 1.102
[130] [it=102000] Train Loss: 0.805, Test Loss: 1.090
[140] [it=110000] Train Loss: 0.796, Test Loss: 1.094
[149] [it=117000] Train Loss: 0.785, Test Loss: 1.115
Done training.

Теперь давайте построим тестовую потерю обеих сетей (с отсевом и без):

import matplotlib.pyplot as plt

# plot both benchmarks
plt.plot(testing_loss, label="no dropout")
plt.plot(testing_loss_d, label="with dropout")
# make the legend on the plot
plt.legend()
plt.title("The Cross-entropy loss of the MNIST test data with and w/o Dropout")
plt.show()

Выход:

Вывод

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

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

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

Оригинальный источник статьи на https://www.thepythoncode.com

#pytorch #python #глубокоеобучение 

What is GEEK

Buddha Community

Why use Python for Software Development

No programming language is pretty much as diverse as Python. It enables building cutting edge applications effortlessly. Developers are as yet investigating the full capability of end-to-end Python development services in various areas. 

By areas, we mean FinTech, HealthTech, InsureTech, Cybersecurity, and that's just the beginning. These are New Economy areas, and Python has the ability to serve every one of them. The vast majority of them require massive computational abilities. Python's code is dynamic and powerful - equipped for taking care of the heavy traffic and substantial algorithmic capacities. 

Programming advancement is multidimensional today. Endeavor programming requires an intelligent application with AI and ML capacities. Shopper based applications require information examination to convey a superior client experience. Netflix, Trello, and Amazon are genuine instances of such applications. Python assists with building them effortlessly. 

5 Reasons to Utilize Python for Programming Web Apps 

Python can do such numerous things that developers can't discover enough reasons to admire it. Python application development isn't restricted to web and enterprise applications. It is exceptionally adaptable and superb for a wide range of uses.

Robust frameworks 

Python is known for its tools and frameworks. There's a structure for everything. Django is helpful for building web applications, venture applications, logical applications, and mathematical processing. Flask is another web improvement framework with no conditions. 

Web2Py, CherryPy, and Falcon offer incredible capabilities to customize Python development services. A large portion of them are open-source frameworks that allow quick turn of events. 

Simple to read and compose 

Python has an improved sentence structure - one that is like the English language. New engineers for Python can undoubtedly understand where they stand in the development process. The simplicity of composing allows quick application building. 

The motivation behind building Python, as said by its maker Guido Van Rossum, was to empower even beginner engineers to comprehend the programming language. The simple coding likewise permits developers to roll out speedy improvements without getting confused by pointless subtleties. 

Utilized by the best 

Alright - Python isn't simply one more programming language. It should have something, which is the reason the business giants use it. Furthermore, that too for different purposes. Developers at Google use Python to assemble framework organization systems, parallel information pusher, code audit, testing and QA, and substantially more. Netflix utilizes Python web development services for its recommendation algorithm and media player. 

Massive community support 

Python has a steadily developing community that offers enormous help. From amateurs to specialists, there's everybody. There are a lot of instructional exercises, documentation, and guides accessible for Python web development solutions. 

Today, numerous universities start with Python, adding to the quantity of individuals in the community. Frequently, Python designers team up on various tasks and help each other with algorithmic, utilitarian, and application critical thinking. 

Progressive applications 

Python is the greatest supporter of data science, Machine Learning, and Artificial Intelligence at any enterprise software development company. Its utilization cases in cutting edge applications are the most compelling motivation for its prosperity. Python is the second most well known tool after R for data analytics.

The simplicity of getting sorted out, overseeing, and visualizing information through unique libraries makes it ideal for data based applications. TensorFlow for neural networks and OpenCV for computer vision are two of Python's most well known use cases for Machine learning applications.

Summary

Thinking about the advances in programming and innovation, Python is a YES for an assorted scope of utilizations. Game development, web application development services, GUI advancement, ML and AI improvement, Enterprise and customer applications - every one of them uses Python to its full potential. 

The disadvantages of Python web improvement arrangements are regularly disregarded by developers and organizations because of the advantages it gives. They focus on quality over speed and performance over blunders. That is the reason it's a good idea to utilize Python for building the applications of the future.

#python development services #python development company #python app development #python development #python in web development #python software development

Регуляризация отсева с использованием PyTorch в Python

Как реализовать регуляризацию отсева с помощью PyTorch в Python

Узнайте о важности регуляризации отсева и о том, как ее применять в среде глубокого обучения PyTorch на Python.

Вступление

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

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

Мы также увидим график потерь на тестовом наборе во времени в нейронной сети с отсевом и без него.

Содержание:

• Вступление
• Настройка всего
• Обучение нейронной сети без отсева
• Общие проблемы в нейронных сетях
  • Переоснащение
  • Бэгинг
• Представляем отсев
  • Случайное удаление узлов
  • Уровень отсева
  • Практические советы по регуляризации отсева
  • Отсев при выводе
  • Примеры использования Dropout
• Обучение нейронной сети с помощью Dropout
• Вывод

---

Настройка всего

Для демонстрации мы будем использовать набор данных MNIST, доступный в библиотеке torchvision. Давайте установим все зависимости этого руководства:

$ pip install matplotlib==3.4.3 numpy==1.21.5 torch==1.10.1 torchvision

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

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

Давайте удостоверимся, что мы тренируемся с использованием GPU, если CUDA доступна:

# defining our device, 'cuda:0' if CUDA is available, 'cpu' otherwise
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
device

device(type='cuda', index=0)

Давайте создадим конвейер преобразования для нашего набора данных MNIST:

# make the transform pipeline, converting to tensor and normalizing
transform = transforms.Compose([
  transforms.ToTensor(),
  transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# the batch size during training
batch_size = 64

Затем загружаем обучающий набор данных:

train_dataset = torchvision.datasets.CIFAR10(root="./data", train=True, 
                                             download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)

Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
170499072/? [00:06<00:00, 29640614.08it/s]
Extracting ./data/cifar-10-python.tar.gz to ./data

Мы переходим Trueк, trainчтобы указать обучающий набор данных, и мы также устанавливаем download, чтобы Trueзагрузить набор данных в указанную dataпапку. После этого мы делаем наш DataLoader, передаем batch_sizeи shuffleустанавливаем True.

Аналогично для тестового набора:

test_dataset = torchvision.datasets.CIFAR10(root="./data", train=False, 
                                             download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)

Files already downloaded and verified

На этот раз мы собираемся trainполучить Falseтестовый набор.

Ниже приведены доступные классы в наборе данных MNIST:

# the MNIST classes
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

Обучение нейронной сети без отсева

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

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = torch.flatten(x, 1) # flatten all dimensions except batch
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()
# switch to GPU if available
net.to(device)

Инициализация кросс-энтропийной потери и оптимизатора SGD :

import torch.optim as optim

# defining the loss and the optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

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

def get_test_loss(net, criterion, data_loader):
  """A simple function that iterates over `data_loader` to calculate the overall loss"""
  testing_loss = []
  with torch.no_grad():
    for data in data_loader:
      inputs, labels = data
      # get the data to GPU (if available)
      inputs, labels = inputs.to(device), labels.to(device)
      outputs = net(inputs)
      # calculate the loss for this batch
      loss = criterion(outputs, labels)
      # add the loss of this batch to the list
      testing_loss.append(loss.item())
  # calculate the average loss
  return sum(testing_loss) / len(testing_loss)

Эта функция нам понадобится во время обучения. Приступаем к обучению прямо сейчас:

training_loss, testing_loss = [], []
running_loss = []
i = 0
for epoch in range(150): # 150 epochs
  for data in train_loader:
    inputs, labels = data
    # get the data to GPU (if available)
    inputs, labels = inputs.to(device), labels.to(device)
    optimizer.zero_grad()
    # forward pass
    outputs = net(inputs)
    # backward pass
    loss = criterion(outputs, labels)
    loss.backward()
    # update gradients
    optimizer.step()
    running_loss.append(loss.item())
    i += 1
    if i % 1000 == 0:
      avg_train_loss = sum(running_loss) / len(running_loss)
      avg_test_loss = get_test_loss(net, criterion, test_loader)
      # clear the list
      running_loss.clear()
      # for logging & plotting later
      training_loss.append(avg_train_loss)
      testing_loss.append(avg_test_loss)
      print(f"[{epoch:2d}] [it={i:5d}] Train Loss: {avg_train_loss:.3f}, Test Loss: {avg_test_loss:.3f}")

print("Done training.")

Выход:

[ 1] [it= 1000] Train Loss: 2.273, Test Loss: 2.118
[10] [it= 8000] Train Loss: 1.312, Test Loss: 1.326
[20] [it=16000] Train Loss: 1.031, Test Loss: 1.120
[30] [it=24000] Train Loss: 0.854, Test Loss: 1.043
[40] [it=32000] Train Loss: 0.718, Test Loss: 1.051
[51] [it=40000] Train Loss: 0.604, Test Loss: 1.085
[60] [it=47000] Train Loss: 0.521, Test Loss: 1.178
[70] [it=55000] Train Loss: 0.425, Test Loss: 1.370
[80] [it=63000] Train Loss: 0.348, Test Loss: 1.518
[93] [it=73000] Train Loss: 0.268, Test Loss: 1.859
[99] [it=78000] Train Loss: 0.248, Test Loss: 2.036
[109] [it=86000] Train Loss: 0.200, Test Loss: 2.351
[120] [it=94000] Train Loss: 0.161, Test Loss: 2.610
[130] [it=102000] Train Loss: 0.142, Test Loss: 2.976
[140] [it=110000] Train Loss: 0.117, Test Loss: 3.319
[149] [it=117000] Train Loss: 0.095, Test Loss: 3.593
Done training.

Общие проблемы в нейронных сетях

Переоснащение

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

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

Бэгинг

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

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

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

Представляем отсев

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

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

На обучающих данных нейроны учатся исправлять ошибки, допущенные их сверстниками, — процесс, известный как коадаптация. Следовательно, способность сети соответствовать обучающим данным резко улучшается. Поскольку коадаптации адаптированы к особенностям обучающих данных, они не будут обобщаться на тестовые данные; следовательно, он становится более изменчивым.

Нитиш Сривастава, Илья Суцкевер, Джеффри Хинтон, Алекс Крижевский и Руслан Салахутдинов были первыми, кто предложил отсев, чтобы минимизировать эффекты нейронной коадаптации.
 

 

Источник:  газета .

Случайное удаление узлов

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

Выпадение относится к удалению единиц (как скрытых, так и явных) из нейронной сети. Удаление устройства означает временное удаление его из сети, включая все его входящие и исходящие соединения. Dropout имитирует разреженную активацию с заданного уровня, что подталкивает сеть к изучению разреженного представления в качестве побочного эффекта. Его можно использовать вместо регуляризации активности для поощрения разреженных представлений в моделях автокодировщика.

Уровень отсева

Dropout добавляет новый гиперпараметр: вероятность сохранения единицы p. Этот гиперпараметр управляет степенью отсева.

Отсева нет, когда p = 1, а низкие значения p указывают на то, что отсева много. Для скрытых блоков типичные значения p находятся в диапазоне от 0,5 до 0,8.

Тип ввода влияет на выбор входных слоев. Типичное значение для входных данных с действительным знаком (изображения или звуковые кадры) равно 0,8.

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

Когда p велико, Dropout может быть недостаточно, чтобы избежать переобучения. На определенном уровне единицы будут иметь 70%-й шанс оставаться активным и 30%-й риск быть удаленным, если вероятность удержания на этом уровне составляет 0,7%.

Обратите внимание, что PyTorch и другие фреймворки для глубокого обучения используют коэффициент отсева вместо коэффициента сохранения p, коэффициент сохранения 70% означает коэффициент отсева 30% и т. д.

Практические советы по регуляризации отсева

• Частота отсева : значение гиперпараметра отсева по умолчанию — это вероятность обучения определенного узла в слое, где 1,0 означает отсутствие отсева, а 0,0 — отсутствие выходных данных слоя.
• Использование более широкой сети : более крупные сети (с большим количеством слоев или узлов) более склонны к переоснащению обучающих данных. При использовании регуляризации отсева можно использовать более крупные сети с меньшей опасностью переобучения.
• Grided Search Parameters : методически тестируйте различные показатели, а не предполагайте разумный процент отсева для вашей сети. Методично тестируйте различные скорости. Вы можете тестировать значения в диапазоне от 1,0 до 0,1 с шагом 0,1.
• Используйте ограничение по весу : веса сети будут расти из-за вероятностного устранения активаций слоев. Значительный размер веса может указывать на нестабильную сеть. Чтобы противодействовать этому эффекту, может применяться ограничение по весу, чтобы заставить норму (величину) всех весов в слое быть меньше определенного значения.

Отсев при выводе

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

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

Таким образом, нейроны в последующем слое будут перевозбуждены, если вы используете 50-процентный коэффициент отсева во время обучения и удаляете два из каждых четырех нейронов в слое. Таким образом, значения, выдаваемые этими нейронами, будут на 50% больше, чем необходимо. Вероятность удержания (1 — показатель отсева) используется для уменьшения веса сверхактивированных нейронов во время тестирования и вывода. На рисунке ниже, созданном участником  Datascience Stackexchange Дмитрием Прилипко , прекрасно показано, как это работает:

Примеры использования Dropout

Впервые представленный Джеффри Хинтоном и его коллегами в их статье 2012 года под названием « Улучшение нейронных сетей путем предотвращения совместной адаптации детекторов признаков », отсев был применен к широкому кругу типов задач, включая классификацию фотографий (CIFAR-10), распознавание рукописных цифр (MNIST). ) и распознавание речи (TIMIT).

В этой статье можно вывести некоторые интересные факты о приложениях отсева в наборе данных MNIST.
 

• MNIST, широко используемый тест для систем машинного обучения, был использован для изучения эффективности отсева. В базу данных включены 60 000 обучающих фотографий рукописных цифр размером 28x28 и 10 000 тестовых изображений.
• Улучшение обучающих данных с помощью преобразованных изображений или подключение знаний о пространственном преобразовании к сверточной нейронной сети или использование генеративного предварительного обучения для извлечения полезных функций из обучающих изображений без использования меток может значительно повысить производительность на тестовом наборе.
• Наилучшая оценка для обычной нейронной сети с прямой связью составляет 160 ошибок на тестовом наборе без применения какой-либо из этих стратегий.
  При удалении случайных 20 процентов пикселей количество ошибок может быть снижено примерно до 130 и даже до 110 за счет применения отдельных ограничений L2 к входящим весам каждой скрытой единицы.
• Отсев сочетался с генеративным предварительным обучением, но использовалась лишь небольшая скорость обучения. Никаких ограничений по весу не применялось, чтобы предотвратить потерю детекторов признаков, определенных в ходе предварительной подготовки. После точной настройки с использованием обычного обратного распространения общедоступная предварительно обученная сеть глубокого убеждения допустила 118 ошибок и в общей сложности 92 ошибки после точной настройки с использованием 50-процентного отсева скрытых единиц.
• На приведенном ниже рисунке представлены нейронные сети, обученные с использованием обратного распространения с использованием 50% отсева для всех скрытых слоев в тестовом наборе MNIST, а отсев составляет 20% для самого низкого набора строк. На горизонтальной линии отображается лучший ранее зарегистрированный результат с использованием обратного распространения без предварительной тренировки, распределения веса или обновлений тренировочной сессии. 
   

 

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

Используя глубокие сверточные нейронные сети с регуляризацией отсева, Алекс Крижевский и др. В своей публикации 2012 года « Классификация ImageNet с глубокими свёрточными нейронными сетями » получили самые современные результаты для классификации изображений в наборе данных ImageNet.

Обучение нейронной сети с помощью Dropout

Подход Dropout — отличная иллюстрация того, как PyTorch сделал программирование простым и понятным.

С помощью двух строк кода мы можем достичь нашей цели, которая поначалу кажется сложной. Нам просто нужно добавить дополнительный слой исключения при разработке нашей модели. torch.nn.Dropout()Для этого будет использоваться класс .

Некоторые элементы входного тензора деактивируются этим классом случайным образом во время обучения. Параметр p дает вероятность деактивации нейрона. Эта опция имеет значение по умолчанию 0,5, что означает, что половина нейронов выпадет. Выходные данные масштабируются с коэффициентом 1/1-p, что указывает на то, что модуль просто вычисляет функцию идентичности во время оценки.

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

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

class NetDropout(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.do1 = nn.Dropout(0.2)  # 20% Probability
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.do2 = nn.Dropout(0.2)  # 20% Probability
        self.fc2 = nn.Linear(120, 84)
        self.do3 = nn.Dropout(0.1)  # 10% Probability
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.do1(x)
        x = torch.flatten(x, 1) # flatten all dimensions except batch
        x = F.relu(self.fc1(x))
        x = self.do2(x)
        x = F.relu(self.fc2(x))
        x = self.do3(x)
        x = self.fc3(x)
        return x


net_dropout = NetDropout()
net_dropout.to(device)

Проведем тренировку как раньше:

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net_dropout.parameters(), lr=0.001, momentum=0.9)

training_loss_d, testing_loss_d = [], []
running_loss = []
i = 0
for epoch in range(150): # 10 epochs
  for data in train_loader:
    inputs, labels = data
    # get the data to GPU (if available)
    inputs, labels = inputs.to(device), labels.to(device)

    optimizer.zero_grad()
    # forward pass
    outputs = net_dropout(inputs)
    # backward pass
    loss = criterion(outputs, labels)
    loss.backward()
    # update gradients
    optimizer.step()
    running_loss.append(loss.item())
    i += 1
    if i % 1000 == 0:
      avg_train_loss = sum(running_loss) / len(running_loss)
      avg_test_loss = get_test_loss(net_dropout, criterion, test_loader)
      # clear the list
      running_loss.clear()
      # for logging & plotting later
      training_loss_d.append(avg_train_loss)
      testing_loss_d.append(avg_test_loss)
      print(f"[{epoch:2d}] [it={i:5d}] Train Loss: {avg_train_loss:.3f}, Test Loss: {avg_test_loss:.3f}")

print("Done training.")

[ 1] [it= 1000] Train Loss: 2.302, Test Loss: 2.298
[10] [it= 8000] Train Loss: 1.510, Test Loss: 1.489
[20] [it=16000] Train Loss: 1.290, Test Loss: 1.318
[30] [it=24000] Train Loss: 1.167, Test Loss: 1.214
[40] [it=32000] Train Loss: 1.085, Test Loss: 1.154
[49] [it=39000] Train Loss: 1.025, Test Loss: 1.141
[60] [it=47000] Train Loss: 0.979, Test Loss: 1.113
[70] [it=55000] Train Loss: 0.936, Test Loss: 1.082
[80] [it=63000] Train Loss: 0.902, Test Loss: 1.088
[90] [it=71000] Train Loss: 0.880, Test Loss: 1.087
[99] [it=78000] Train Loss: 0.856, Test Loss: 1.090
[109] [it=86000] Train Loss: 0.843, Test Loss: 1.094
[120] [it=94000] Train Loss: 0.818, Test Loss: 1.102
[130] [it=102000] Train Loss: 0.805, Test Loss: 1.090
[140] [it=110000] Train Loss: 0.796, Test Loss: 1.094
[149] [it=117000] Train Loss: 0.785, Test Loss: 1.115
Done training.

Теперь давайте построим тестовую потерю обеих сетей (с отсевом и без):

import matplotlib.pyplot as plt

# plot both benchmarks
plt.plot(testing_loss, label="no dropout")
plt.plot(testing_loss_d, label="with dropout")
# make the legend on the plot
plt.legend()
plt.title("The Cross-entropy loss of the MNIST test data with and w/o Dropout")
plt.show()

Выход:

Вывод

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

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

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

Оригинальный источник статьи на https://www.thepythoncode.com

#pytorch #python #глубокоеобучение 

Python Tricks Every Developer Should Know

Python is awesome, it’s one of the easiest languages with simple and intuitive syntax but wait, have you ever thought that there might ways to write your python code simpler?

In this tutorial, you’re going to learn a variety of Python tricks that you can use to write your Python code in a more readable and efficient way like a pro.

Let’s get started

Swapping value in Python

Instead of creating a temporary variable to hold the value of the one while swapping, you can do this instead

>>> FirstName = "kalebu"
>>> LastName = "Jordan"
>>> FirstName, LastName = LastName, FirstName 
>>> print(FirstName, LastName)
('Jordan', 'kalebu')

#python #python-programming #python3 #python-tutorials #learn-python #python-tips #python-skills #python-development

How to Remove all Duplicate Files on your Drive via Python

Today you’re going to learn how to use Python programming in a way that can ultimately save a lot of space on your drive by removing all the duplicates.

Intro

In many situations you may find yourself having duplicates files on your disk and but when it comes to tracking and checking them manually it can tedious.

Heres a solution

Instead of tracking throughout your disk to see if there is a duplicate, you can automate the process using coding, by writing a program to recursively track through the disk and remove all the found duplicates and that’s what this article is about.

But How do we do it?

If we were to read the whole file and then compare it to the rest of the files recursively through the given directory it will take a very long time, then how do we do it?

The answer is hashing, with hashing can generate a given string of letters and numbers which act as the identity of a given file and if we find any other file with the same identity we gonna delete it.

There’s a variety of hashing algorithms out there such as

• md5
• sha1
• sha224, sha256, sha384 and sha512

#python-programming #python-tutorials #learn-python #python-project #python3 #python #python-skills #python-tips

How To Compare Tesla and Ford Company By Using Magic Methods in Python

Magic Methods are the special methods which gives us the ability to access built in syntactical features such as ‘<’, ‘>’, ‘==’, ‘+’ etc…

You must have worked with such methods without knowing them to be as magic methods. Magic methods can be identified with their names which start with __ and ends with __ like init, call, str etc. These methods are also called Dunder Methods, because of their name starting and ending with Double Underscore (Dunder).

Now there are a number of such special methods, which you might have come across too, in Python. We will just be taking an example of a few of them to understand how they work and how we can use them.

1. init

class AnyClass:
    def __init__():
        print("Init called on its own")
obj = AnyClass()

The first example is _init, _and as the name suggests, it is used for initializing objects. Init method is called on its own, ie. whenever an object is created for the class, the init method is called on its own.

The output of the above code will be given below. Note how we did not call the init method and it got invoked as we created an object for class AnyClass.

Init called on its own

2. add

Let’s move to some other example, add gives us the ability to access the built in syntax feature of the character +. Let’s see how,

class AnyClass:
    def __init__(self, var):
        self.some_var = var
    def __add__(self, other_obj):
        print("Calling the add method")
        return self.some_var + other_obj.some_var
obj1 = AnyClass(5)
obj2 = AnyClass(6)
obj1 + obj2

#python3 #python #python-programming #python-web-development #python-tutorials #python-top-story #python-tips #learn-python