{{l10n_strings.DRAG_TEXT_HELP}}

{{article.content_lang.display}}

{{l10n_strings.AUTHOR_TOOLTIP_TEXT}}

Как начать работу с Keras, Deep Learning и Python

Специально для тех, кто только начинает осваивать Deep Learning и нейронные сети, мы подготовили перевод очень полезной статьи. Из неё вы узнаете, как использовать библиотеку Keras для обучения своей первой нейронной сети с собственным набором изображений, а также сможете создать свёрточную нейронную сеть (CNN).

Большинство учебных пособий по Keras основаны на работе со стандартными датасетами, такими как MNIST (распознавание рукописного ввода цифр) или CIFAR-10 (распознавание базовых объектов). Они помогут вам начать использовать Keras, но не смогут научить работать с собственными наборами изображений — вы просто будете вызывать вспомогательные функции для загрузки предварительно скомпилированных датасетов.

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

Статья предполагает пошаговое выполнение фрагментов кода, для чего понадобится компилятор Python или среда Jupyter Notebook.

Здесь мы не будем подробно рассматривать теорию Deep Learning. Этой теме посвящено большое количество литературы, например, книга Deep Learning for Computer Vision with Python.

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

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

Для начала отметим, что MNIST и CIFAR-10 представляют собой не самые интересные примеры. Вы не научитесь работать со своими данными, а будете пользоваться встроенными утилитами Keras, которые волшебным образом превращают датасеты MNIST и CIFAR-10 в массивы NumPy. Даже обучающую и тестовую выборку уже сделали за вас!

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

— откуда эти вспомогательные функции загружают данные?

— в каком формате должны быть изображения на диске?

— как загрузить мой датасет в память?

— какую предварительную обработку необходимо выполнить?

Без паники. Сейчас мы во всём разберёмся.

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

Цель — правильно классифицировать изображение как содержащее кота, собаку или панду.

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

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

— упорядочить свой набор изображений на диске;

— загрузить изображения и метки класса с диска;

— разделить данные на обучающую и тестовую выборки;

— обучить вашу первую нейросеть Keras;

— оценить вашу модель на тестовой выборке;

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

Если вы хотите создать набор данных из доступных в Интернете изображений, то сделать это можно простым способом с помощью поиска картинок Bing или чуть более сложным способом с помощью поисковика Google.

Распаковав zip-архив к статье, вы получите следующую структуру файлов и папок:

$ tree --dirsfirst --filelimit 10
 .
 ├── animals<br> 
   ├── cats [1000 entries exceeds filelimit, not opening dir]
   ├── dogs [1000 entries exceeds filelimit, not opening dir]
   └── panda [1000 entries exceeds filelimit, not opening dir]
 ├── images
   ├── cat.jpg
   ├── dog.jpg
   └── panda.jpg
 ├── output
   ├── simple_nn.model
   ├── simple_nn_lb.pickle
   ├── simple_nn_plot.png
   ├── smallvggnet.model
   ├── smallvggnet_lb.pickle
   └── smallvggnet_plot.png
 ├── pyimagesearch
   ├── init.py
   └── smallvggnet.py
 ├── predict.py
 ├── train_simple_nn.py
 └── train_vgg.py

 7 directories, 14 files

Как упоминалось ранее, мы работаем с датасетом Animals. Обратите внимание, как он расположен в дереве проекта. Внутри animals/ находятся каталоги трёх классов: cats/, dogs/, panda/. В каждом из них содержится 1000 изображений, относящихся к соответствующему классу.

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

Далее идёт каталог images/. Он содержит три изображения для тестирования модели, которые мы будем использовать, чтобы продемонстрировать, как:

1. Загрузить обученную модель с диска.
2. Классифицировать входное изображение, которое не является частью исходного набора данных.

Папка output/ содержит три типа файлов, которые создаются путём обучения:

— .model: сериализованный файл модели Keras, создаётся после обучения и может использоваться в дальнейших сценариях вывода.

— .pickle: сериализованный файл бинаризатора меток. Включает в себя объект, содержащий имена классов и сопряжён с файлом модели.

— .png: лучше всегда помещать свои графики обучения/проверки в эту папку, поскольку они отражают результат процесса.

Каталог pyimagesearch/ — модуль, который находится в папке проекта. Содержащиеся в нём классы могут быть импортированы в ваши сценарии.

В статье мы рассмотрим 4 .py файла. Начнём с обучения простой модели с помощью скрипта train_simple_nn.py. Далее перейдём к обучению SmallVGGNet, используя скрипт train_vgg.py. SmallVGGNet.py содержит класс SmallVGGNet (свёрточную нейронную сеть). Но что хорошего в сериализованной модели, если мы не можем её применить? В predict.py находится образец кода для загрузки модели и файла метки для распознавания изображений. Этот скрипт понадобится только после того, как мы успешно обучим модель с достаточной точностью. Всегда полезно запускать его для проверки модели на изображениях, которые не содержатся в исходных данных.

Для работы над проектом нам понадобится установить Keras, TensorFlow и OpenCV.

Если у вас ещё нет этого ПО, можете воспользоваться простыми руководствами по установке:

— руководство по установке OpenCV (для Ubuntu, MacOS или Raspberry Pi).

— установка Keras с TensorFlow. С помощью pip вы можете установить Keras и TensorFlow меньше, чем за две минуты. Ваш компьютер или устройство должно быть достаточно производительным. Поэтому  не рекомендуются устанавливать эти пакеты на Raspberry Pi, хотя на таком миникомпьютере могут хорошо работать уже обученные и не слишком объёмные модели.

— установка imutil, scikit-learn и matplotlib:

$ pip install --upgrade imutils 
$ pip install --upgrade scikit-learn 
$ pip install --upgrade matplotlib

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

Откройте файл train_simple_nn.py и вставьте в него следующий код:

# импортируем бэкенд Agg из matplotlib для сохранения графиков на диск
import matplotlib
matplotlib.use("Agg")
 
# подключаем необходимые пакеты
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from keras.models import Sequential
from keras.layers.core import Dense
from keras.optimizers import SGD
from imutils import paths
import matplotlib.pyplot as plt
import numpy as np
import argparse
import random
import pickle
import cv2
import os 

Рассмотрим инструменты, используемые в скрипте:

— matplotlib: готовый пакет для Python. В строке 3 мы подключаем бэкенд “Agg”, который позволяет сохранять графики на диск.

— sklearn: библиотека scikit-learn поможет бинаризовать наши метки, разделить данные на обучающую и тестовую выборки и сгенерировать отчёт об обучении в терминале.

— keras: высокоуровневый фронтенд для TensorFlow и других бэкендов глубокого обучения.

— imutils: пакет с удобными функциями, модуль path будет использоваться для генерации списка путей к файлам изображений.

— numpy: пакет для работы с числами в Python. Если у вас установлен OpenCV и scikit-learn, то у вас уже есть NumPy как зависимый от них пакет.

— cv2: это OpenCV. На данный момент необходимо будет использовать версию 2, даже если обычно вы используете OpenCV 3 или выше.

Всё остальное уже встроено в ваш Python.

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

Давайте разберём аргументы командной строки с помощью argparse:

# создаём парсер аргументов и передаём их
ap = argparse.ArgumentParser()
ap.add_argument("-d", "--dataset", required=True,
    help="path to input dataset of images")
ap.add_argument("-m", "--model", required=True,
    help="path to output trained model")
ap.add_argument("-l", "--label-bin", required=True,
    help="path to output label binarizer")
ap.add_argument("-p", "--plot", required=True,
    help="path to output accuracy/loss plot")
args = vars(ap.parse_args()) 

Наш скрипт будет динамически обрабатывать поступающую из командной строки информацию во время выполнения с помощью встроенного в Python модуля argparse.

У нас есть 4 аргумента командной строки:

—dataset: путь к набору изображений на диске.

—model: наша модель будет сериализована и записана на диск. Этот аргумент содержит путь к выходному файлу модели.

—label-bin: метки набора данных сериализуются на диск для возможности их вызова в других скриптах. Это путь к выходному бинаризованному файлу метки.

—plot: путь к выходному файлу графика обучения. Мы рассмотрим этот график, чтобы проверить недообучение или переобучение наших данных.

Имея информацию о наборе данных, давайте загрузим изображения и метки классов:

# инициализируем данные и метки
print("[INFO] loading images...")
data = []
labels = []
 
# берём пути к изображениям и рандомно перемешиваем
imagePaths = sorted(list(paths.list_images(args["dataset"])))
random.seed(42)
random.shuffle(imagePaths)
 
# цикл по изображениям
for imagePath in imagePaths:
    # загружаем изображение, меняем размер на 32x32 пикселей (без учёта
    # соотношения сторон), сглаживаем его в 32x32x3=3072 пикселей и
    # добавляем в список
    image = cv2.imread(imagePath)
    image = cv2.resize(image, (32, 32)).flatten()
    data.append(image)
 
    # извлекаем метку класса из пути к изображению и обновляем
    # список меток
    label = imagePath.split(os.path.sep)[-2]
    labels.append(label) 

Здесь мы:

1. Инициализируем списки для наших данных (data) и меток (labels) (строки 35 и 36). Позже это будут массивы NumPy.
2. Случайным образом перемешиваем imagePaths (строки 39-41). Функция paths.list_images найдёт пути ко всем входным изображениям в каталоге нашего датасета перед тем, как мы отсортируем и перемешаем (shuffle) их. Установим константное значение seed так, чтобы случайное переупорядочивание было воспроизводимым.
3. Начинаем цикл по всем imagePaths в наборе данных (строка 44).

Для каждого imagePath:

а) Загружаем изображение image в память (строка 48).

б) Изменяем его размер на 32×32 пикселя (без учёта соотношения сторон) и сглаживаем (flatten) (строка 49). Очень важно правильно изменить размер изображений (resize), поскольку это необходимо для данной нейронной сети. Каждая нейросеть требует различного разрешения изображений, поэтому просто помните об этом. Сглаживание данных позволяет легко передавать необработанные интенсивности пикселей в нейроны входного слоя. Позже вы увидите, что для VGGNet мы будем передавать в сеть сразу все данные, поскольку она является свёрточной. Но в этом примере пока рассматривается простая несвёрточная сеть.

в) Добавляем изменённое изображение к массиву данных (строка 50).

г) Извлекаем метку класса изображения из его пути (строка 54) и добавляем к остальным меткам (строка 55). Список меток содержит классы, соответствующие каждому изображению в массиве данных.

Теперь мы легко можем применить операции с массивами к нашим данным и меткам:

# масштабируем интенсивности пикселей в диапазон [0, 1]
data = np.array(data, dtype="float") / 255.0
labels = np.array(labels)

В строке 58 мы отображаем интенсивность пикселя из диапазона целых чисел [0, 255] в непрерывный вещественный диапазон [0, 1] (обычный этап предварительной обработки).

Также конвертируем метки в массив NumPy (строка 59).

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

# разбиваем данные на обучающую и тестовую выборки, используя 75% 
# данных для обучения и оставшиеся 25% для тестирования
(trainX, testX, trainY, testY) = train_test_split(data,
    labels, test_size=0.25, random_state=42)

Обычно большая часть данных выделяется для обучения, и около 20-30% для тестирования. Scikit-learn предоставляет удобную функцию train_test_split, которая разделит для нас данные.

trainX и testX — это изображения, а trainY и testY — соответствующие метки.

Наши метки классов сейчас представлены в виде строк, однако Keras будет считать, что:

1. Метки кодируются целыми числами.
2. Для этих меток выполняется One-Hot Encoding, в результате чего каждая метка представляется в виде вектора, а не целого числа.

Для того чтобы выполнить эту кодировку, можно использовать класс LabelBinarizer из scikit-learn:

# конвертируем метки из целых чисел в векторы (для 2х классов при 
# бинарной классификации вам следует использовать функцию Keras 
# “to_categorical” вместо “LabelBinarizer” из scikit-learn, которая
# не возвращает вектор)
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)

В строке 70 мы инициализируем объект LabelBinarizer.

Вызов fit_transform находит все уникальные метки класса в testY, а затем преобразует их в метки One-Hot Encoding.

Вызов .transform выполняет всего один шаг One-Hot Encoding — уникальный набор возможных меток классов уже был определён вызовом fit_transform.

Пример:

[1, 0, 0] # относится к кошкам 
[0, 1, 0] # относится к собакам 
[0, 0, 1] # относится к панде

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

# определим архитектуру 3072-1024-512-3 с помощью Keras
model = Sequential()
model.add(Dense(1024, input_shape=(3072,), activation="sigmoid"))
model.add(Dense(512, activation="sigmoid"))
model.add(Dense(len(lb.classes_), activation="softmax"))

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

Входной слой и первый скрытый слой определены в строке 76. input_shape будет равен 3072, так как мы имеем 32x32x3=3072 пикселей в сглаженном входном изображении. Первый скрытый слой будет иметь 1024 узла.

Второй скрытый слой имеет 512 узлов (строка 77).

И, наконец, количество узлов выходного слоя (строка 78) будет равно числу возможных меток классов — в нашем случае, выходной слой будет иметь три узла, один для каждой метки класса (“cats”, “dogs”, и “panda” соответственно).

После того как мы определили архитектуру нашей нейронной сети, нам необходимо скомпилировать её:

# инициализируем скорость обучения и общее число эпох
INIT_LR = 0.01
EPOCHS = 75
 
# компилируем модель, используя SGD как оптимизатор и категориальную
# кросс-энтропию в качестве функции потерь (для бинарной классификации 
# следует использовать binary_crossentropy)
print("[INFO] training network...")
opt = SGD(lr=INIT_LR)
model.compile(loss="categorical_crossentropy", optimizer=opt,
   metrics=["accuracy"]) 

Сначала мы инициализируем скорость обучения и общее число эпох (полных проходов по выборке) (строки 81 и 82).

Затем мы скомпилируем модель, используя метод стохастического градиентного спуска (SGD) и  «categorical_crossentropy» (категориальную кросс-энтропию) в качестве функции потерь.

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

Теперь, когда наша модель Keras скомпилирована, мы можем “подогнать” (fit) (т.е. обучить) её:

# обучаем нейросеть
H = model.fit(trainX, trainY, validation_data=(testX, testY),
    epochs=EPOCHS, batch_size=32) 

Здесь нам известно обо всём, кроме batch_size (размер пакета). Параметр batch_size контролирует размер каждой группы данных для передачи по сети. Мощные GPU могут обрабатывать большие пакеты, но рекомендуется отталкиваться от размеров 32 и 64.

Мы обучили модель, теперь нужно оценить её с помощью тестовой выборки.

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

Для оценки модели Keras можно использовать комбинацию методов .predict и classification_report из scikit-learn:

# оцениваем нейросеть
print("[INFO] evaluating network...")
predictions = model.predict(testX, batch_size=32)
print(classification_report(testY.argmax(axis=1),
    predictions.argmax(axis=1), target_names=lb.classes_))
 
# строим графики потерь и точности
N = np.arange(0, EPOCHS)
plt.style.use("ggplot")
plt.figure()
plt.plot(N, H.history["loss"], label="train_loss")
plt.plot(N, H.history["val_loss"], label="val_loss")
plt.plot(N, H.history["acc"], label="train_acc")
plt.plot(N, H.history["val_acc"], label="val_acc")
plt.title("Training Loss and Accuracy (Simple NN)")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
plt.savefig(args["plot"])

Запустив этот скрипт, вы увидите, что нейронная сеть начала обучаться, и теперь мы можем оценить модель на тестовых данных:

$ python train_simple_nn.py --dataset animals --model output/simple_nn.model \
	--label-bin output/simple_nn_lb.pickle --plot output/simple_nn_plot.png
Using TensorFlow backend.
[INFO] loading images...
[INFO] training network...
Train on 2250 samples, validate on 750 samples
Epoch 1/75
2250/2250 [==============================] - 1s - loss: 1.1033 - acc: 0.3636 - val_loss: 1.0811 - val_acc: 0.3707
Epoch 2/75
2250/2250 [==============================] - 0s - loss: 1.0882 - acc: 0.3862 - val_loss: 1.1292 - val_acc: 0.3227
Epoch 3/75
2250/2250 [==============================] - 0s - loss: 1.0713 - acc: 0.4067 - val_loss: 1.0525 - val_acc: 0.3907
...
Epoch 73/75
2250/2250 [==============================] - 0s - loss: 0.7780 - acc: 0.6067 - val_loss: 0.8438 - val_acc: 0.5813
Epoch 74/75
2250/2250 [==============================] - 0s - loss: 0.7805 - acc: 0.5978 - val_loss: 0.8463 - val_acc: 0.5893
Epoch 75/75
2250/2250 [==============================] - 0s - loss: 0.7765 - acc: 0.6262 - val_loss: 0.8144 - val_acc: 0.6133
[INFO] evaluating network...
         	precision    recall  f1-score   support
 
   	cats   	0.58      0.50      0.54   	236
   	dogs   	0.49      0.50      0.49   	236
      panda   	0.73      0.81      0.77   	278
 
avg / total   	0.61      0.61      0.61   	750
 
[INFO] serializing network and label binarizer...

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

Можно увидеть, что наша нейросеть точна на 61%.

Так как шанс случайного выбора правильной метки для изображения равен 1/3, мы можем утверждать, что сеть фактически выучила шаблоны, которые могут использоваться для различения трёх классов.

Также мы сохранили следующие графики:

— потери при обучении

— потери при оценке

— точность обучения

— точность оценивания

С их помощью мы можем определить переобучение или недообучение модели.

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

Наконец, мы можем сохранить нашу модель на диск, чтобы позже использовать её, не занимаясь обучением снова:

# сохраняем модель и бинаризатор меток на диск
print("[INFO] serializing network and label binarizer...")
model.save(args["model"])
f = open(args["label_bin"], "wb")
f.write(pickle.dumps(lb))
f.close() 

Сейчас наша модель обучена — но что, если нам снова понадобится классифицировать новые изображения? Как загрузить модель с диска? Как обработать изображение для классификации?Для начала откроем скрипт predict.py и вставим туда следующий код:

# импортируем необходимые пакеты
from keras.models import load_model
import argparse
import pickle
import cv2
 
# создаём парсер аргументов и передаём их
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True,
    help="path to input image we are going to classify")
ap.add_argument("-m", "--model", required=True,
    help="path to trained Keras model")
ap.add_argument("-l", "--label-bin", required=True,
    help="path to label binarizer")
ap.add_argument("-w", "--width", type=int, default=28,
    help="target spatial dimension width")
ap.add_argument("-e", "--height", type=int, default=28,
    help="target spatial dimension height")
ap.add_argument("-f", "--flatten", type=int, default=-1,
    help="whether or not we should flatten the image")
args = vars(ap.parse_args())

Сначала мы импортируем необходимые пакеты и модули.

load_model позволяет загрузить модель Keras с диска. OpenCV будет использоваться для вывода изображений. Модуль pickle загружает бинаризатор меток.

Далее снова разберём аргументы командной строки:

—image: путь к входному изображению.

—model: путь к нашей обученной и сериализованной модели.

—label-bin: путь к бинаризатору меток.

—width: ширина изображения для CNN. Помните, что вы не можете просто указать тут что-нибудь. Вам необходимо указать ширину, для которой предназначена модель.

—height: высота входного изображения. Также должна соответствовать конкретной модели.

—flatten: надо ли сглаживать изображение (по умолчанию мы не будем этого делать).

Загрузим изображение и изменим его размер, исходя из аргументов командной строки:

# загружаем входное изображение и меняем его размер на необходимый
image = cv2.imread(args["image"])
output = image.copy()
image = cv2.resize(image, (args["width"], args["height"]))
 
# масштабируем значения пикселей к диапазону [0, 1]
image = image.astype("float") / 255.0

Если необходимо, изображение можно сгладить:

# проверяем, необходимо ли сгладить изображение и добавить размер
# пакета
if args["flatten"] > 0:
    image = image.flatten()
    image = image.reshape((1, image.shape[0]))
 
# в противном случае мы работаем с CNN -- не сглаживаем изображение
# и просто добавляем размер пакета
else:
    image = image.reshape((1, image.shape[0], image.shape[1],
        image.shape[2]))

В случае с CNN мы указываем размер пакета, но не выполняем сглаживание (строки 39-41). Пример с CNN рассматривается в следующем разделе.

Теперь загрузим нашу модель и бинаризатор меток в память и попробуем распознать изображение:

# загружаем модель и бинаризатор меток
print("[INFO] loading network and label binarizer...")
model = load_model(args["model"])
lb = pickle.loads(open(args["label_bin"], "rb").read())
 
# распознаём изображение
preds = model.predict(image)
 
# находим индекс метки класса с наибольшей вероятностью
# соответствия
i = preds.argmax(axis=1)[0]
label = lb.classes_[i]

Модель и бинаризатор загружаются в строках 45 и 46.

Распознавание изображений (прогнозирование принадлежности объекта к одному из классов) осуществляется с помощью метода model.predict  (строка 49).

Как же выглядит массив preds?

(Pdb) preds
array([[5.4622066e-01, 4.5377851e-01, 7.7963534e-07]], dtype=float32)

Двумерный массив содержит (1) индекс изображения в пакете (здесь он только один, поскольку было передано одно изображение) и (2) проценты, соответствующие возможной принадлежности изображения к каждой метке класса:

— cats: 54.6%

— dogs: 45.4%

— panda: ~0%

То есть  наша нейросеть «думает», что, вероятнее всего, видит кошку, и определённо не видит панду.

В строке 53 мы находим индекс наибольшего значения (в данном случае нулевой).

И в строке 54 извлекаем строковую метку “cats” из бинаризатора меток.

Легко, правда?

Теперь отобразим результаты:

# рисуем метку класса + вероятность на выходном изображении
text = "{}: {:.2f}%".format(label, preds[0][i] * 100)
cv2.putText(output, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
    (0, 0, 255), 2)
 
# показываем выходное изображение
cv2.imshow("Image", output)
cv2.waitKey(0) 

Мы форматируем текстовый вывод в строке 57 (метку класса и прогнозируемое значение в процентах).

Затем помещаем текст на выходное изображение (строки 58 и 59).

Наконец, выводим картинку на экран и ждём, пока пользователь не нажмёт какую-либо клавишу (строки 62 и 63).

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

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

$ python predict.py --image images/cat.jpg --model output/simple_nn.model \
	--label-bin output/simple_nn_lb.pickle --width 32 --height 32 --flatten 1
Using TensorFlow backend.
[INFO] loading network and label binarizer...

Убедитесь, что вы скопировали/вставили команду целиком (включая аргументы командной строки) из папки со скриптом.

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

Примечание:

Обратите внимание, что полученные вами результаты могут отличаться от приведённых в этой статье. Скорее всего, это происходит из-за того, что процесс обучения каждый раз может проходить по-разному даже на одних и тех же исходных данных. Например, в нашем эксперименте точность нейросети снизилась до 60%, и изображение с котом классифицировалось как “dogs” с вероятностью 45.34%. Можете поделиться своими результатами и предположениями, с чем это может быть связано.

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

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

В этом разделе будет использоваться уменьшенный вариант VGGNet (назовём её “SmallVGGNet”).

VGGNet-подобные модели имеют две общие особенности:

1. Используются только свёрточные фильтры 3х3
2. Свёрточные слои (“convolution layers”) чередуются со слоями подвыборки (“pooling layers”).

Приступим к реализации SmallVGGNet.

Откройте файл smallvggnet.py и вставьте туда следующий код:

# импортируем необходимые пакеты
from keras.models import Sequential
from keras.layers.normalization import BatchNormalization
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.layers.core import Activation
from keras.layers.core import Flatten
from keras.layers.core import Dropout
from keras.layers.core import Dense
from keras import backend as K 

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

Теперь определим наш класс SmallVGGNet (строка 12) и метод сборки (build) (строка 14):

class SmallVGGNet:
    @staticmethod
    def build(width, height, depth, classes):
        # инициализируем модель и размер входного изображения
        # для порядка каналов “channel_last” и размер канала
        model = Sequential()
        inputShape = (height, width, depth)
        chanDim = -1
 
        # если мы используем порядок "channels first", обновляем
        # входное изображение и размер канала
        if K.image_data_format() == "channels_first":
            inputShape = (depth, height, width)
            chanDim = 1 

Для сборки требуется 4 параметра: ширина входных изображений (width), высота (height), глубина (depth) и число классов (classes).

Глубина также может интерпретироваться как число каналов. Поскольку мы используем RGB-изображения, то при вызове метода build будем передавать глубину = 3.

Сначала инициализируем последовательную (Sequential) модель (строка 17).

Затем определяем порядок каналов. Keras поддерживает «channels_last» (TensorFlow) и «channels_first» (Theano). Строки 18-25 позволяют использовать любой из них.

Теперь добавим несколько слоёв в сеть:

            # слои CONV => RELU => POOL
            model.add(Conv2D(32, (3, 3), padding="same",
            input_shape=inputShape))
            model.add(Activation("relu"))
            model.add(BatchNormalization(axis=chanDim))
            model.add(MaxPooling2D(pool_size=(2, 2)))
            model.add(Dropout(0.25)) 

В этом блоке добавляются слои CONV => RELU => POOL.

Первый слой CONV имеет 32 фильтра размером 3х3.

Важно, чтобы мы указали inputShape для первого слоя, так как все последующие размеры слоёв будут рассчитываться с использованием метода “просачивания” (trickle-down).

В этой архитектуре сети мы будем использовать функцию активации ReLU (Rectified Linear Unit). Также будут использованы: пакетная нормализация (Batch Normalization), функция максимума (MaxPooling) и метод исключения (Dropout).

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

К слоям POOL применяется функция постепенного уменьшения размера (т.е. ширины и высоты) входного слоя. Обычно в архитектуре CNN слои POOL вставляются между последовательно идущими слоями CONV.

Метод исключения деактивирует случайные нейроны между слоями. В результате процесс становится более устойчивым: уменьшается переобучение, повышается точность; и нейросеть лучше сможет распознавать незнакомые изображения. В нашем случае (строка 33) 25% нейронных соединений случайным образом деактивируются между слоями для каждой итерации обучения.

Переходим к следующим слоям:

            # слои (CONV => RELU) * 2 => POOL
            model.add(Conv2D(64, (3, 3), padding="same"))
            model.add(Activation("relu"))
            model.add(BatchNormalization(axis=chanDim))
            model.add(Conv2D(64, (3, 3), padding="same"))
            model.add(Activation("relu"))
            model.add(BatchNormalization(axis=chanDim))
            model.add(MaxPooling2D(pool_size=(2, 2)))
            model.add(Dropout(0.25))

Обратите внимание, что размеры фильтра остаются прежними (3х3), а общее число фильтров увеличивается с 32 до 64.

Затем идёт набор слоёв (CONV => RELU) * 3 => POOL:

            # слои (CONV => RELU) * 3 => POOL
            model.add(Conv2D(128, (3, 3), padding="same"))
            model.add(Activation("relu"))
            model.add(BatchNormalization(axis=chanDim))
            model.add(Conv2D(128, (3, 3), padding="same"))
            model.add(Activation("relu"))
            model.add(BatchNormalization(axis=chanDim))
            model.add(Conv2D(128, (3, 3), padding="same"))
            model.add(Activation("relu"))
            model.add(BatchNormalization(axis=chanDim))
            model.add(MaxPooling2D(pool_size=(2, 2)))
            model.add(Dropout(0.25))

Опять же, число фильтров удвоилось с 64 до 128, а размер остался прежним. Увеличение общего количества фильтров при уменьшении размера входных данных в CNN — обычная практика.

И, наконец, последний набор слоёв:

            # первый (и единственный) набор слоев FC => RELU
            model.add(Flatten())
            model.add(Dense(512))
            model.add(Activation("relu"))
            model.add(BatchNormalization())
            model.add(Dropout(0.5))
 
            # классификатор softmax
            model.add(Dense(classes))
            model.add(Activation("softmax"))
 
            # возвращаем собранную архитектуру нейронной сети
            return model

Полностью связанные слои в Keras обозначаются как Dense. Последний слой соединён с тремя выходами (так как в нашем наборе данных три класса). Слой softmax возвращает вероятность принадлежности к определённому классу для каждой метки.

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

Большая часть кода такая же, как и в предыдущем примере. Откройте скрипт train_vgg.py:

# импортируем бэкенд Agg из matplotlib для сохранения графиков на диск
import matplotlib
matplotlib.use("Agg")
 
# подключаем необходимые пакеты
from pyimagesearch.smallvggnet import SmallVGGNet
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import SGD
from imutils import paths
import matplotlib.pyplot as plt
import numpy as np
import argparse
import random
import pickle
import cv2 
import os

Все import-ы те же, но с двумя отличиями:

1. Вместо from keras.models import Sequential мы загружаем модель SmallVGGNet: from pyimagesearch.smallvggnet import SmallVGGNet
2. Данные будут дополняться с помощью ImageDataGenerator.

Теперь аргументы командной строки:

# создаём парсер аргументов и передаём их
ap = argparse.ArgumentParser()
ap.add_argument("-d", "--dataset", required=True,
    help="path to input dataset of images")
ap.add_argument("-m", "--model", required=True,
    help="path to output trained model")
ap.add_argument("-l", "--label-bin", required=True,
    help="path to output label binarizer")
ap.add_argument("-p", "--plot", required=True,
    help="path to output accuracy/loss plot")
args = vars(ap.parse_args())

Видим, что аргументы такие же, как и в предыдущем примере.

Загружаем и предварительно обрабатываем данные:

# инициализируем данные и метки
print("[INFO] loading images...")
data = []
labels = []
 
# берём пути к изображениям и рандомно перемешиваем
imagePaths = sorted(list(paths.list_images(args["dataset"])))
random.seed(42)
random.shuffle(imagePaths)
 
# цикл по изображениям
for imagePath in imagePaths:
    # загружаем изображение, меняем размер на 64x64 пикселей
    # (требуемые размеры для SmallVGGNet), изменённое изображение
    # добавляем в список
    image = cv2.imread(imagePath)
    image = cv2.resize(image, (64, 64))
    data.append(image)
 
    # извлекаем метку класса из пути к изображению и обновляем
    # список меток
    label = imagePath.split(os.path.sep)[-2]
    labels.append(label)

# масштабируем интенсивности пикселей в диапазон [0, 1]
data = np.array(data, dtype="float") / 255.0
labels = np.array(labels)

Снова почти никаких отличий.

Разделяем данные на обучающую и тестовую выборки и бинаризуем метки:

# разбиваем данные на обучающую и тестовую выборки, используя 75% 
# данных для обучения и оставшиеся 25% для тестирования
(trainX, testX, trainY, testY) = train_test_split(data,
    labels, test_size=0.25, random_state=42)
 
# конвертируем метки из целых чисел в векторы (для 2х классов при 
# бинарной классификации вам следует использовать функцию Keras 
# “to_categorical” вместо “LabelBinarizer” из scikit-learn, которая
# не возвращает вектор)
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)

Теперь дополняем данные:

# создаём генератор для добавления изображений
aug = ImageDataGenerator(rotation_range=30, width_shift_range=0.1,
    height_shift_range=0.1, shear_range=0.2, zoom_range=0.2,
    horizontal_flip=True, fill_mode="nearest")
 
# инициализируем нашу VGG-подобную свёрточную нейросеть
model = SmallVGGNet.build(width=64, height=64, depth=3,
    classes=len(lb.classes_))

В строках 75-77 мы инициализируем генератор для добавления изображений.

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

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

Чтобы собрать нашу SmallVGGNet, просто вызовем метод SmallVGGNet.build в процессе передачи необходимых параметров (строки 80 и 81).

Скомпилируем и обучим модель:

# инициализируем скорость обучения, общее число шагов
# и размер пакета
INIT_LR = 0.01
EPOCHS = 75
BS = 32
 
# компилируем модель с помощью SGD (для бинарной классификации 
# следует использовать binary_crossentropy)
print("[INFO] training network...")
opt = SGD(lr=INIT_LR, decay=INIT_LR / EPOCHS)
model.compile(loss="categorical_crossentropy", optimizer=opt,
    metrics=["accuracy"])
 
# обучаем нейросеть
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
    validation_data=(testX, testY), steps_per_epoch=len(trainX) // BS,
    epochs=EPOCHS) 

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

Наконец, оценим модель, построив кривые потерь/точности и сохраним её:

# оцениваем нейросеть
print("[INFO] evaluating network...")
predictions = model.predict(testX, batch_size=32)
print(classification_report(testY.argmax(axis=1),
     predictions.argmax(axis=1), target_names=lb.classes_))
 
# строим графики потерь и точности
N = np.arange(0, EPOCHS)
plt.style.use("ggplot")
plt.figure()
plt.plot(N, H.history["loss"], label="train_loss")
plt.plot(N, H.history["val_loss"], label="val_loss")
plt.plot(N, H.history["acc"], label="train_acc")
plt.plot(N, H.history["val_acc"], label="val_acc")
plt.title("Training Loss and Accuracy (SmallVGGNet)")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
plt.savefig(args["plot"])
 
# сохраняем модель и бинаризатор меток на диск
print("[INFO] serializing network and label binarizer...")
model.save(args["model"])
f = open(args["label_bin"], "wb")
f.write(pickle.dumps(lb))
f.close()

Мы делаем прогнозы на тестовой выборке, а затем оцениваем точность классификации (строки 103-105).

Построение и сохранение на диск графиков, модели и меток аналогично предыдущему примеру.

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

$ python train_vgg.py --dataset animals --model output/smallvggnet.model \
	--label-bin output/smallvggnet_lb.pickle \
	--plot output/smallvggnet_plot.png
Using TensorFlow backend.
[INFO] loading images...
[INFO] training network...
Epoch 1/75
70/70 [==============================] - 3s - loss: 1.3783 - acc: 0.5165 - val_loss: 2.3654 - val_acc: 0.3133
Epoch 2/75
70/70 [==============================] - 2s - loss: 1.0382 - acc: 0.5998 - val_loss: 2.7962 - val_acc: 0.3173
Epoch 3/75
70/70 [==============================] - 2s - loss: 0.9366 - acc: 0.6018 - val_loss: 2.2790 - val_acc: 0.3173
...
Epoch 73/75
70/70 [==============================] - 2s - loss: 0.4402 - acc: 0.8044 - val_loss: 0.4975 - val_acc: 0.7880
Epoch 74/75
70/70 [==============================] - 2s - loss: 0.4306 - acc: 0.8055 - val_loss: 0.6150 - val_acc: 0.7520
Epoch 75/75
70/70 [==============================] - 2s - loss: 0.4179 - acc: 0.8110 - val_loss: 0.5624 - val_acc: 0.7653
[INFO] evaluating network...
         	precision    recall  f1-score   support
 
   	cats   	0.62      0.84      0.71   	236
   	dogs   	0.75      0.50      0.60   	236
      panda   	0.95      0.92      0.93   	278
 
avg / total   	0.78      0.77      0.76   	750
 
[INFO] serializing network and label binarizer...

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

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

GPU завершит процесс гораздо быстрее — каждый шаг выполняется всего за 2 секунды, как и продемонстрировано.

Посмотрим на итоговый график обучения в каталоге output/:

Как можно увидеть, мы достигли точности в 78% на наборе изображений Animals с использованием свёрточной нейронной сети — значительно выше, чем предыдущее значение в 60%.

Теперь мы можем применить нашу обученную CNN к новым изображениям:

$ python predict.py --image images/panda.jpg --model output/smallvggnet.model \
	--label-bin output/smallvggnet_lb.pickle --width 64 --height 64
Using TensorFlow backend.
[INFO] loading network and label binarizer...

CNN полностью уверена, что это панда.

Алгоритмы CNN используются для поиска изображений, например, в Google Photo, но распознавание и классификация фотографий — не единственный пример использования свёрточных нейросетей: они также хорошо себя показали, например, в задачах обработки естественного языка (Natural Language Processing, NLP).

Код и датасет к статье можно загрузить отсюда (размер архива 246 МБ).

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

С оригинальной статьёй можно ознакомиться на сайте pyimagesearch.com.

Big Picture Learning — Education Reimagined — Education Reimagined

НАЗАД В 1995 ГОДУ ДВА РАДИКАЛЬНЫХ МЫСЛИТЕЛЯ И ПРЕПОДАВАТЕЛЯ СОБЫЛИ ВМЕСТЕ , потому что они знали, что пришло время для перемен — изменения взглядов мира на обучение, детей и образование. У них было видение перестроить образование таким образом, чтобы «поставить студентов прямо в центр их собственного обучения». К счастью, одно маленькое государство готовилось пойти на риск со своей собственной системой образования — Род-Айленд. Таким образом, родилась первая школа Big Picture Learning — Столичный региональный центр карьеры и техники («Метрополитен») в Провиденсе, Род-Айленд.

С тех пор «обучение в общих чертах» распространилось как по всей стране — теперь в 65 филиалах в 18 штатах — так и через несколько океанов — со школами в Нидерландах, Австралии, Италии и Канаде. Дизайн Big Picture Learning доказывал себя снова и снова. И не только для одного типа детей. Схема обучения «Общая картина» оказалась успешной среди широкого круга учащихся, которым она служит, будь то учащиеся из группы риска, пожилые, не получающие должного внимания или одаренные учащиеся. Он работает для детей со всеми почтовыми индексами, с разными жизненными историями, разными интересами, увлечениями и проблемами.Как оно работает?

Без классов, оценок или тестов, среда Big Picture Learning на основе компетенций предназначена для того, чтобы рассматривать каждого учащегося как личность. Нет двух одинаковых способов обучения: учащиеся при поддержке своих наставников, родителей и сверстников используют компоненты дизайна и отличительных черт Big Picture для создания индивидуальных планов обучения. Все это сводится к тому, что Big Picture — это место, где дети учатся учиться, а не где их учат темам, предметам или информации.Фактически, пять учебных целей определяют подход каждого учащегося к своей работе: 1) эмпирическое рассуждение, 2) количественное рассуждение, 3) общение, 4) социальное рассуждение, 5) личные качества.

И аутентичные оценки — «публичные демонстрации обучения, отслеживающие рост и прогресс в области интересов учащегося» — показывают, как они демонстрируют свое обучение. Будь то устная презентация, художественный проект, бизнес-план или рассказ, то, как учащиеся демонстрируют свое обучение, так же индивидуально, как и то, как они учатся.

На практике изучающие Big Picture проводят время в консультациях и стажировках. Консультанты, когорта из 15 учеников и одного взрослого консультанта, остаются вместе в течение четырех лет, выстраивая связи и отношения, которые будут длиться всю жизнь. Эта социально-внедренная практика является «сердцем и душой» дизайна Big Picture. Второй ключевой компонент — это обучение через интересы и стажировки (LTI). LTI делают обучение персонализированным, релевантным и контекстуализированным. Учащиеся делают шаг вперед и определяют свою область интересов, а затем находят возможность поработать с экспертом из своего сообщества.Через LTI они получают открытого опыта , «как их интересы пересекаются с реальным миром» — учащиеся выясняют, действительно ли то, что, по их мнению, их интересует, действительно им интересно.

Спустя двадцать лет после открытия Метрополитена, Big Picture все больше и больше тратит силы на «влияние на общенациональные дебаты о государственном образовании». И, начиная с их ежегодной конференции Big Bang до их расширенных программных инициатив, таких как College Unbound и Deeper Learning Equity Fellowship, они каждый день усиливают все больше голосов и меняют все больше мировоззрений.

Более полное представление об обучении учащихся

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

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

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

Быть гибким — нормально

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

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

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

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

Фотоальбом

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

Нам никогда не нужна только одна фотография большого жизненного события, и мы не должны желать, чтобы только одна оценка записывала наш учебный путь. Оценка должна быть больше похожа на фотоальбом, фиксирующий многие моменты обучения.Фотоальбом фиксирует фотографии людей, процессов, предметов, событий и т. Д., Как и должно быть при оценке. Если бы мы относились к оцениванию как к фотоальбому, мы бы использовали различные моменты, чтобы лучше понять, как учащийся учится.

Фотоальбом праздничный и мощный, и оценка должна быть такой же.

Свидетельство

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

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

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

Вот несколько вопросов, над которыми стоит задуматься при рассмотрении этого подхода к оцениванию:

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

Обучение в больших картинках

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

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

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

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

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

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

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

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

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

LITTLE EXPLORERS Picture Dictionary от EnchantedLearning.com

EnchantedLearning.com — это сайт, поддерживаемый пользователями.
В качестве бонуса участники сайта получают доступ к версии сайта без баннерной рекламы с удобными для печати страницами.
Щелкните здесь, чтобы узнать больше.

• Чтобы просмотреть словарь, щелкните букву алфавита в верхней части окна, и вы увидите страницу со словами, начинающимися с этой буквы.
• 2 511 иллюстрированных словарных статей! Каждое слово используется в содержательном примере предложения.Большинство записей имеют ссылки на соответствующий веб-сайт. Просто щелкните подчеркнутое слово (или сопровождающее его изображение), и вы перейдете на соответствующую страницу.
• Словарь изображений LITTLE EXPLORERS ^TM упрощает работу в Интернете. Формат словаря с картинками используется для ссылки на сотни тщательно отобранных сайтов для детей по всему миру. Поскольку изображения являются ссылками, даже предварительные читатели могут просматривать страницы с минимальной помощью и руководством своего любимого взрослого. Дети постарше могут использовать «Маленьких исследователей» в качестве школьного справочника.
• Это английская версия; просто нажмите, чтобы использовать разные версии:

• Пожалуйста, добавьте в закладки эту страницу и возвращайтесь почаще.
• Удачи в изучении и обучении!
• Мы были полуфиналистами конкурса GII 1998 г. (награда за глобальную информационную инфраструктуру) в детской категории.
• Включено в образовательный веб-индекс BBC
• Жананда Кол

Страны с наибольшим количеством носителей английского языка:

Enchanted Learning ^®
Более 35 000 веб-страниц
Примеры страниц для потенциальных подписчиков или щелкните ниже

Нажмите, чтобы прочитать нашу Политику конфиденциальности

Зачарованный поиск обучения

Наша политика конфиденциальности

Авторские права © 1996-2018 Очарованное обучение.com —— Как цитировать веб-страницу

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

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

• Поддерживает формирующие учебные стратегии и способы активизировать учащихся, чтобы они были ресурсами для себя и сверстников
• Бесплатно или очень близко к нему (менее 10 долларов в год, где это возможно)
• Позволяет как ученикам, так и учителям брать на себя роль активатора, когда это возможно (иногда учителям нужно начать работу)

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

1. Animoto Дает студентам возможность снять 30-секундное видео того, что они узнали на уроке.
2. AudioNote Комбинация диктофона и блокнота, она записывает как аудио, так и заметки для совместной работы студентов.
3. Edpuzzle Помогает вам использовать видео (ваше собственное или видео из Khan Academy, YouTube и др.) Для отслеживания понимания учащимися.
4. Flipgrid Позволяет учащимся использовать видео продолжительностью от 15 до 5 минут, чтобы отвечать на запросы. Учителя и сверстники могут дать обратную связь.
5. QuickVoice Recorder Позволяет записывать занятия, обсуждения или аудио для проектов. Легко синхронизируйте свои записи с компьютером для использования в презентациях.
6. Vocaroo Создает аудиозаписи без использования программного обеспечения. Вставьте запись в слайд-шоу, презентации или веб-сайты.
7. WeVideo Позволяет творчески использовать видео для вовлечения студентов в обучение.Учителя и студенты могут снимать видеоролики.

8. Crowdsignal Позволяет создавать онлайн-опросы, викторины и вопросы. Учащиеся могут использовать смартфоны, планшеты и компьютеры, чтобы давать ответы, а информацию можно отбирать для отчетов.
9. Edulastic Позволяет проводить оценки в соответствии со стандартами и мгновенно получать обратную связь.
10. FreeOnlineSurveys Помогает создавать опросы, викторины, формы и опросы.
11. Gimkit Позволяет писать викторины в реальном времени. И это было разработано старшеклассником!
12. Kahoot! Игровая система ответов в классе, позволяющая создавать викторины с использованием интернет-контента.
13. MicroPoll Помогает создавать опросы, встраивать их в веб-сайты и анализировать ответы.
14. Naiku Позволяет писать викторины, на которые студенты могут отвечать с помощью своих мобильных устройств.
15. Obsurvey Предназначен для проведения опросов, опросов и анкет.
16. Опрос везде Позволяет создавать опросы обратной связи или задавать вопросы и видеть результаты в режиме реального времени.Позволяет студентам реагировать по-разному. С помощью открытых вопросов вы можете собирать данные и раскручивать облака тегов для агрегирования ответов.
17. Poll Maker Предлагает уникальные функции, такие как возможность нескольких ответов на один вопрос.
18. ProProfs Помогает проводить викторины, опросы и опросы.
19. Quia Позволяет создавать игры, викторины, опросы и многое другое. Получите доступ к базе данных существующих викторин от других преподавателей.
20. Quizalize Помогает создавать викторины и домашние задания.
21. Викторина Помогает вам разрабатывать викторины и позволяет вовлекать учащихся в процесс написания викторин.
22. Quizlet Позволяет создавать карточки, тесты, викторины и обучающие игры, удобные для мобильных устройств.
23. Survey Hero Предназначен для создания анкет и опросов.
24. SurveyMonkey Полезно для онлайн-опросов и опросов.
25. SurveyPlanet Также полезно для онлайн-опросов и опросов.
26. Triventy Позволяет создавать викторины, которые учащиеся проходят в режиме реального времени с помощью индивидуальных устройств.
27. Yacapaca Помогает писать и назначать тесты.
28. Zoho Survey Позволяет проводить опросы для мобильных устройств и просматривать результаты в режиме реального времени.

29. AnswerGarden Инструмент для онлайн-мозгового штурма и совместной работы.
30. Coggle Инструмент для построения карты разума, призванный помочь вам понять мышление учащихся.
Программное обеспечение
31. Conceptboard, которое упрощает командную совместную работу в визуальном формате, похожем на отображение разума, но с использованием визуального и текстового ввода.
32. Dotstorming Приложение для белой доски, которое позволяет размещать цифровые стикеры и голосовать за них.Этот инструмент лучше всего подходит для обсуждения в классе и мозгового штурма по различным темам и вопросам.
33. Education Whiteboard Приложение для белой доски, позволяющее учащимся делиться своими знаниями.
34. iBrainstorm Позволяет учащимся совместно работать над проектами с помощью стилуса или пальца.
35. Miro Обеспечивает совместную работу всего класса в режиме реального времени.
36. Padlet Предоставляет студентам чистый холст для создания и разработки совместных проектов.
37. Интерактивная доска ShowMe Еще один инструмент для проверки понимания.
38. XMind Mind-mapping программное обеспечение для использования на настольных компьютерах и ноутбуках.

39. BrainPOP Позволяет использовать предварительно записанные видео по бесчисленным темам, чтобы сформировать план урока, а затем использовать викторины, чтобы узнать, что вас не интересует.
40. Buncee Помогает ученикам и учителям визуализировать, общаться и взаимодействовать с концепциями класса.
41. Five Card Flickr Использует функцию тегов фотографий на Flickr для развития визуального мышления.
42. PlayPosit Позволяет добавлять функции формирующего оценивания к видео из библиотеки или популярных сайтов, таких как YouTube и Vimeo, чтобы узнать, что учащиеся знают по теме.
43. RabbleBrowser Позволяет руководителю облегчить совместный просмотр.
44. Выбор случайного имени / слова Облегчает случайный выбор имени. Вы также можете добавить список ключевых слов и использовать инструмент, чтобы побуждать учащихся угадывать слова, предоставляя определения.
45. Socrative Использует упражнения и игры, чтобы заинтересовать студентов темой.
46. Spark Позволяет добавлять графику и визуальные эффекты к выходным билетам.
47. Typeform Помогает добавлять графические элементы в опросы.

48. EdWordle Создает облака слов из любого введенного текста, чтобы помочь агрегировать ответы и облегчить обсуждение. Облака слов — это картинки, состоящие из облака небольших слов, которые служат ключом к теме.
49. Tagxedo Позволяет изучить консенсус студентов и облегчить диалог.
50. Wordables Помогает вам получить доказательства изучения или определить базовые знания по теме.
51. WordArt Включает функцию, которая позволяет пользователю сделать каждое слово активной ссылкой для подключения к веб-сайтам, включая YouTube.

52. Формирующий Позволяет назначать действия, получать результаты в режиме реального времени и предоставлять немедленную обратную связь.
53. GoSoapBox Работает с моделью «принеси свое собственное устройство» и включает в себя особенно интересную функцию: измеритель путаницы.
54. IXL Разбивает варианты по классам и областям содержания.
55. Kaizena Дает учащимся отзывы о загружаемых ими работах в режиме реального времени. Вы можете использовать маркер или дать устную обратную связь. Также можно прикрепить ресурсы.
56. Mentimeter Позволяет использовать мобильные телефоны или планшеты для голосования по любому вопросу, который задает учитель, повышая вовлеченность учащихся.
57. Pear Deck Позволяет планировать и создавать интерактивные презентации, в которых учащиеся могут участвовать с помощью своих интеллектуальных устройств. Он также предлагает уникальные типы вопросов.
58. Plickers Позволяет собирать данные формирующей оценки в реальном времени без использования устройств учащихся.
59. Quick Key Помогает вам с точной маркировкой, мгновенной оценкой и немедленной обратной связью.

60. Напомнить Позволяет отправлять текстовые сообщения учащимся и оставаться на связи с семьями.
61. Seesaw Помогает улучшить семейное общение и упрощает формативное оценивание, а учащиеся могут использовать платформу для документирования своего обучения.
62. Voxer Позволяет отправлять записи, чтобы семьи могли слышать, как идут дела у их учеников, студенты могли болтать о своей работе, а вы могли оставлять отзывы.

63. Biblionasium Позволяет просматривать книги, которые прочитали учащиеся, создавать задания для чтения и отслеживать прогресс. Студенты также могут просматривать и рекомендовать книги своим сверстникам.
64. Classkick Помогает публиковать задания для учащихся, а вы и их сверстники можете оставлять отзывы.Студенты также могут следить за своими успехами и работой.
65. ForAllRubrics Позволяет импортировать, создавать и оценивать рубрики на планшете или смартфоне. Собирайте данные в автономном режиме, автоматически вычисляйте баллы и распечатывайте или сохраняйте рубрики в формате PDF или электронной таблицы.
66. Lino Виртуальная пробковая доска для заметок, на которой студенты могут задавать вопросы или комментировать свои знания.
67. Онлайн-секундомер Предоставляет десятки тематических цифровых таймеров в классе для использования во время небольших и групповых обсуждений.
68. Peergrade Помогает создавать задания и загружать рубрики. Вы также можете анонимно назначить экспертную оценку. Студенты могут загружать и проверять работы, используя соответствующую рубрику.
69. Spiral (Спираль) Предоставляет доступ к формирующим отзывам об оценке.
70. Verso Позволяет настроить обучение с помощью URL-адреса. Предусмотрено место для направлений. Учащиеся могут добавлять свои задания, оставлять комментарии и отвечать на комментарии. Вы можете группировать ответы и проверять уровни вовлеченности.
71. VoiceThread Позволяет создавать и обмениваться беседами с документами, диаграммами, видео, изображениями и т. Д.

72. Backchannel Chat Версия Twitter, модерируемая учителем.
73. Chatzy Поддерживает живые онлайн-чаты в приватной обстановке.

74. Google Forms Приложение Google Drive, которое позволяет создавать документы, над которыми учащиеся могут совместно работать в режиме реального времени, используя смартфоны, планшеты и ноутбуки.
75. Piazza Позволяет загружать лекции, задания и домашние задания; ставить и отвечать на вопросы студентов; и опрашивайте учащихся о содержании занятий.Этот инструмент больше подходит для учащихся старшего возраста, так как он имитирует форматы обучения в классах послешкольного образования.

Есть несколько ресурсов, чтобы узнать больше о формирующем оценивании и стратегиях адаптивного обучения. Рассмотрим наши семинары по формирующим практикам, на которых школьные и районные команды могут лучше понять роль формирующих практик в обучении и четыре базовых практики, которые можно использовать в классе. Или для быстрого начала загрузите нашу электронную книгу «Как заставить работать: как формирующее оценивание может улучшить вашу практику.”

Прыгайте, пробуйте новые инструменты и методы и получайте удовольствие!

Как ИИ учится видеть картину в целом

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

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

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

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

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

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

Каков ваш стиль обучения? 20 вопросов

Для этого приложения требуется JavaScript.

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

1.Какую книгу вы хотели бы прочитать для развлечения?

Книга с множеством картинок

Книга, в которой много слов

Книга с поиском слов или кроссвордами

2. Что вы, скорее всего, сделаете, если не знаете, как правильно написать слово?

Запишите, чтобы проверить, правильно ли он выглядит

Произнесите это вслух, чтобы проверить правильность звучания

Обведите буквы в воздухе (написание пальцем)

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

Посмотрите на другую одежду на вешалках

Поговорите с человеком рядом с вами на линии

Перемещайтесь или двигайтесь вперед и назад

4. Что вы делаете в первую очередь, когда видите слово «кошка»?

Представьте себе кошку

Произнеси себе слово «кот»

Подумайте о том, чтобы быть с кошкой (погладить ее или услышать мурлыканье)

5.Как лучше всего подготовиться к экзамену?

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

Попросите кого-нибудь задать вам вопросы, на которые вы сможете ответить вслух

Составьте каталожные карточки, которые вы можете просмотреть

6. Как лучше всего узнать, как что-то работает (например, компьютер или видеоигра)?

Попросите кого-нибудь показать вам

Прочтите об этом или послушайте, чтобы кто-нибудь это объяснил

Разберись сам

7.Если бы вы пошли на школьные танцы, что бы вы, скорее всего, вспомнили на следующий день?

Лица людей, которые были там

Музыка, которая игралась

Танцевальные движения, которые вы сделали, и еда, которую вы съели

8. Что вас больше всего отвлекает, когда вы пытаетесь учиться?

Люди проходят мимо вас

Громкие шумы

Стул неудобный

9.Когда вы злитесь, что вы, скорее всего, сделаете?

Сделай «безумное» лицо

Кричать и кричать

Распашные двери

10. Что вы, скорее всего, будете делать, когда счастливы?

Улыбка от уха до уха

Говорите бурю

Действительно гипер

11. Как вы ориентируетесь в новом месте?

Найдите карту или каталог, на котором показано, где все находится.

Спросите у кого-нибудь, как проехать

Просто начните ходить, пока не найдете то, что ищете

12.Какой из этих трех классов вам больше всего нравится?

Арт-класс

Музыкальный класс

Тренажерный зал

13. Что вы, скорее всего, сделаете, когда услышите песню по радио?

Представьте прилагаемое к нему видео

Пойте или напевайте под музыку

Начните танцевать или постучите ногой

14.Что вас больше всего отвлекает в классе?

Слишком яркий или слишком тусклый свет

Шум из коридора или снаружи здания (например, движение транспорта или стрижка травы)

Слишком высокая или слишком низкая температура

15. Что вы любите делать, чтобы расслабиться?

Читать

Слушать музыку

Физические упражнения (ходьба, бег, занятия спортом и т. Д.)

16. Как лучше всего запомнить номер телефона друга?

Представьте себе номера на телефоне, как если бы вы их набирали

Повторяйте это вслух снова и снова и снова

Запишите или сохраните в списке контактов телефона

17. Если бы вы выиграли игру, какой из этих трех призов вы бы выбрали?

Плакат на стену

Загрузите музыкальный компакт-диск или mp3

Любая игра (или футбольный мяч, или футбольный мяч и т. Д.).)

18. Куда вы бы предпочли пойти с компанией друзей?

Фильм

Концерт

Парк развлечений

19. Что вы, скорее всего, запомните в новых встречах с людьми?

Их лицо, но не их имя

Их имя, но не лицо

О чем вы с ними говорили

20.

No related posts.